@asciidoctor/core 3.0.4 → 4.0.0-alpha.2

package/src/attribute_entry.js

@@ -0,0 +1,12 @@
+export class AttributeEntry {
+  constructor(name, value, negate = null) {
+    this.name = name
+    this.value = value
+    this.negate = negate == null ? value == null : negate
+  }
+
+  saveTo(blockAttributes) {
+    ;(blockAttributes.attribute_entries ??= []).push(this)
+    return this
+  }
+}

package/src/attribute_list.js

@@ -0,0 +1,380 @@
+// ESM conversion of attribute_list.rb
+//
+// Ruby-to-JavaScript notes:
+//   - Ruby's StringScanner is reimplemented as the module-private StringScanner
+//     class using JS sticky regexes (flag 'y'). The scanner caches a sticky
+//     version of each RegExp on first use to avoid repeated RegExp construction.
+//   - scan() returns null (not nil) on no-match; getByte() returns undefined at EOS.
+//   - Ruby's boolean `false` return from parse_attribute (bare `return`) is
+//     represented as `return false`.
+//   - The `continue` local variable is renamed `shouldContinue` because `continue`
+//     is a reserved word in JS.
+//   - snake_case method names are converted to camelCase.
+//   - Private methods/fields use the JS # prefix.
+//   - block.apply_subs → block.applySubs (matches Substitutors mixin naming).
+
+import { CG_WORD, CC_WORD } from './rx.js'
+
+// ── Constants ─────────────────────────────────────────────────────────────────
+const APOS = "'"
+const BACKSLASH = '\\'
+const QUOT = '"'
+
+// Regular expressions for detecting the boundary of a value.
+// These are passed to StringScanner which converts them to sticky variants.
+const BoundaryRx = {
+  [QUOT]: /.*?[^\\](?=")/,
+  [APOS]: /.*?[^\\](?=')/,
+  ',': /.*?(?=[ \t]*(,|$))/,
+}
+
+// Regular expressions for unescaping quoted characters.
+const EscapedQuotes = {
+  [QUOT]: '\\"',
+  [APOS]: "\\'",
+}
+
+// Regular expressions for skipping delimiters.
+const SkipRx = {
+  ',': /[ \t]*(,|$)/,
+}
+
+// Attribute name: starts with a word character, followed by word chars or hyphens.
+// Constructed with the 'u' flag so \p{…} Unicode properties work.
+const NameRx = new RegExp(`${CG_WORD}[${CC_WORD}\\-]*`, 'u')
+
+// Matches one or more horizontal whitespace characters.
+const BlankRx = /[ \t]+/
+
+// ── StringScanner ─────────────────────────────────────────────────────────────
+/**
+ * A minimal port of Ruby's StringScanner, sufficient for AttributeList parsing.
+ *
+ * Differences from Ruby's StringScanner:
+ * - getByte() returns undefined (not nil) at end of string.
+ * - scan/skip return null/0 (not nil) on no match.
+ * - Regexes are anchored at the current position via the sticky ('y') flag.
+ *   A sticky copy is created once per regex and cached for reuse.
+ * - unscan() reverts only the most recent getByte / scan / skip advance.
+ */
+class StringScanner {
+  #source
+  #pos = 0
+  #lastMatchLen = 0
+  #stickyCache = new Map()
+
+  constructor(source) {
+    this.#source = source
+  }
+
+  /** @returns {string} The original source string (equivalent to Ruby scanner.string). */
+  get source() {
+    return this.#source
+  }
+
+  /** @returns {boolean} true when the scan pointer is at or past the end of the string. */
+  eos() {
+    return this.#pos >= this.#source.length
+  }
+
+  /**
+   * @param {number} n
+   * @returns {string} The next n characters without advancing the scan pointer.
+   */
+  peek(n) {
+    return this.#source.slice(this.#pos, this.#pos + n)
+  }
+
+  /** @returns {string|undefined} The next character, or undefined at EOS. */
+  getByte() {
+    if (this.#pos >= this.#source.length) {
+      this.#lastMatchLen = 0
+      return undefined
+    }
+    this.#lastMatchLen = 1
+    return this.#source[this.#pos++]
+  }
+
+  /** Reverts the most recent getByte / scan / skip advance. */
+  unscan() {
+    this.#pos -= this.#lastMatchLen
+    this.#lastMatchLen = 0
+  }
+
+  /**
+   * Advances past rx at the current position.
+   * @param {RegExp} rx
+   * @returns {number} The number of characters skipped, or 0 on no match.
+   */
+  skip(rx) {
+    const m = this.#exec(rx)
+    return m ? m[0].length : 0
+  }
+
+  /**
+   * @param {RegExp} rx
+   * @returns {string|null} The matched string at the current position, or null on no match.
+   */
+  scan(rx) {
+    const m = this.#exec(rx)
+    return m ? m[0] : null
+  }
+
+  /**
+   * @param {RegExp} rx
+   * @returns {RegExpExecArray|null}
+   */
+  #exec(rx) {
+    let sticky = this.#stickyCache.get(rx)
+    if (!sticky) {
+      const flags = rx.flags.includes('y') ? rx.flags : `${rx.flags}y`
+      sticky = new RegExp(rx.source, flags)
+      this.#stickyCache.set(rx, sticky)
+    }
+    sticky.lastIndex = this.#pos
+    const m = sticky.exec(this.#source)
+    if (!m) {
+      this.#lastMatchLen = 0
+      return null
+    }
+    this.#lastMatchLen = m[0].length
+    this.#pos += m[0].length
+    return m
+  }
+}
+
+// ── AttributeList ─────────────────────────────────────────────────────────────
+
+/**
+ * Handles parsing AsciiDoc attribute lists into a plain object of key/value pairs.
+ * By default, attributes must each be separated by a comma and quotes may be used
+ * around the value. If a key is not detected, the value is assigned to a 1-based
+ * positional key. Positional attributes can be "rekeyed" when given a positionalAttrs
+ * array either during parsing or after.
+ *
+ * @example
+ * const attrlist = new AttributeList('astyle')
+ * await attrlist.parse()
+ * // => { 1: 'astyle' }
+ *
+ * attrlist.rekey(['style'])
+ * // => { 1: 'astyle', style: 'astyle' }
+ *
+ * @example
+ * const attrlist2 = new AttributeList('quote, Famous Person, Famous Book (2001)')
+ * await attrlist2.parse(['style', 'attribution', 'citetitle'])
+ * // => { 1: 'quote', style: 'quote', 2: 'Famous Person', attribution: 'Famous Person',
+ * //      3: 'Famous Book (2001)', citetitle: 'Famous Book (2001)' }
+ */
+export class AttributeList {
+  #scanner
+  #block
+  #delimiter
+  #delimiterSkipPattern
+  #delimiterBoundaryPattern
+  #attributes = null
+
+  constructor(source, block = null, delimiter = ',') {
+    this.#scanner = new StringScanner(source)
+    this.#block = block
+    this.#delimiter = delimiter
+    this.#delimiterSkipPattern = SkipRx[delimiter]
+    this.#delimiterBoundaryPattern = BoundaryRx[delimiter]
+  }
+
+  /**
+   * Parse the attribute list and merge the result into the given object.
+   * @param {Object} attributes - The target plain object to update.
+   * @param {string[]} [positionalAttrs=[]] - An array of keys to assign to positional values.
+   * @returns {Promise<Object>} The updated attributes object.
+   */
+  async parseInto(attributes, positionalAttrs = []) {
+    return Object.assign(attributes, await this.parse(positionalAttrs))
+  }
+
+  /**
+   * Parse the attribute list and return a plain object of key/value pairs.
+   * Subsequent calls return the already-parsed result without re-parsing.
+   * @param {string[]} [positionalAttrs=[]] - An array of keys to assign to positional values.
+   * @returns {Promise<Object>} A plain object of parsed attributes.
+   */
+  async parse(positionalAttrs = []) {
+    if (this.#attributes) return this.#attributes
+    this.#attributes = {}
+    let index = 0
+    while (await this.#parseAttribute(index, positionalAttrs)) {
+      if (this.#scanner.eos()) break
+      this.#skipDelimiter()
+      index++
+    }
+    return this.#attributes
+  }
+
+  /**
+   * Rekey the parsed positional attributes using the given key names.
+   * @param {string[]} positionalAttrs - An array of keys to assign to positional values.
+   * @returns {Object} The updated attributes object.
+   */
+  rekey(positionalAttrs) {
+    return AttributeList.rekey(this.#attributes, positionalAttrs)
+  }
+
+  /**
+   * Assign string keys to the positional (numeric-keyed) values of the given attributes object.
+   * @param {Object} attributes - A plain object produced by parse().
+   * @param {Array<string|null>} positionalAttrs - Keys to assign (null entries are skipped).
+   * @returns {Object} The updated attributes object.
+   */
+  static rekey(attributes, positionalAttrs) {
+    for (let i = 0; i < positionalAttrs.length; i++) {
+      const key = positionalAttrs[i]
+      if (key) {
+        const val = attributes[i + 1]
+        if (val != null) attributes[key] = val
+      }
+    }
+    return attributes
+  }
+
+  /**
+   * @param {number} index
+   * @param {string[]} positionalAttrs
+   * @returns {Promise<boolean>} true to continue parsing, false to stop.
+   */
+  async #parseAttribute(index, positionalAttrs) {
+    let shouldContinue = true
+    this.#skipBlank()
+    const peeked = this.#scanner.peek(1)
+    let name, value, singleQuoted
+
+    if (peeked === QUOT) {
+      // example: "quote" || "foo
+      name = this.#parseAttributeValue(this.#scanner.getByte())
+    } else if (peeked === APOS) {
+      // example: 'quote' || 'foo
+      name = this.#parseAttributeValue(this.#scanner.getByte())
+      if (!name.startsWith(APOS)) singleQuoted = true
+    } else {
+      name = this.#scanName()
+      const skipped = (name !== null && this.#skipBlank()) || 0
+
+      if (this.#scanner.eos()) {
+        // Stop unless we have a name or the source ends with the delimiter
+        if (!name && !this.#scanner.source.trimEnd().endsWith(this.#delimiter))
+          return false
+        // example: quote (at eos)
+        shouldContinue = false
+      } else {
+        const c = this.#scanner.getByte()
+        if (c === this.#delimiter) {
+          // example: quote,
+          this.#scanner.unscan()
+        } else if (name) {
+          if (c === '=') {
+            // example: foo=...
+            this.#skipBlank()
+            const c2 = this.#scanner.getByte()
+            if (c2 === QUOT) {
+              // example: foo="bar" || foo="ba\"zaar" || foo="bar
+              value = this.#parseAttributeValue(c2)
+            } else if (c2 === APOS) {
+              // example: foo='bar' || foo='ba\'zaar' || foo='ba"zaar' || foo='bar
+              value = this.#parseAttributeValue(c2)
+              if (!value.startsWith(APOS)) singleQuoted = true
+            } else if (c2 === this.#delimiter) {
+              // example: foo=,
+              value = ''
+              this.#scanner.unscan()
+            } else if (c2 === undefined) {
+              // example: foo= (at eos)
+              value = ''
+            } else {
+              // example: foo=bar || foo=None
+              value = `${c2}${this.#scanToDelimiter() ?? ''}`
+              if (value === 'None') return true
+            }
+          } else {
+            // example: foo bar
+            name = `${name}${' '.repeat(skipped)}${c}${this.#scanToDelimiter() ?? ''}`
+          }
+        } else {
+          // example: =foo= || !foo
+          name = `${c}${this.#scanToDelimiter() ?? ''}`
+        }
+      }
+    }
+
+    if (value !== undefined) {
+      // Named attribute
+      if (name === 'options' || name === 'opts') {
+        // example: options="opt1,opt2,opt3" || opts="opt1,opt2,opt3"
+        if (value.includes(',')) {
+          if (value.includes(' ')) value = value.replace(/ /g, '')
+          for (const opt of value.split(',')) {
+            if (opt) this.#attributes[`${opt}-option`] = ''
+          }
+        } else if (value) {
+          this.#attributes[`${value}-option`] = ''
+        }
+      } else if (singleQuoted && this.#block) {
+        if (name === 'title' || name === 'reftext') {
+          this.#attributes[name] = value
+        } else {
+          this.#attributes[name] = await this.#block.applySubs(value)
+        }
+      } else {
+        this.#attributes[name] = value
+      }
+    } else {
+      // Positional attribute
+      if (singleQuoted && this.#block) {
+        name = await this.#block.applySubs(name)
+      }
+      const positionalAttrName = positionalAttrs[index]
+      if (positionalAttrName && name != null) {
+        this.#attributes[positionalAttrName] = name
+      }
+      // QUESTION should we assign the positional key even when claimed by a positional attribute?
+      this.#attributes[index + 1] = name
+    }
+
+    return shouldContinue
+  }
+
+  /**
+   * @param {string} quote - The quote character that opened this value (QUOT or APOS).
+   * @returns {string} The parsed value (unescaped, without surrounding quotes).
+   */
+  #parseAttributeValue(quote) {
+    // empty quoted value: "" or ''
+    if (this.#scanner.peek(1) === quote) {
+      this.#scanner.getByte()
+      return ''
+    }
+    const value = this.#scanToQuote(quote)
+    if (value !== null) {
+      this.#scanner.getByte() // consume closing quote
+      return value.includes(BACKSLASH)
+        ? value.replaceAll(EscapedQuotes[quote], quote)
+        : value
+    }
+    // no closing quote found – treat opening quote as part of the value
+    return `${quote}${this.#scanToDelimiter() ?? ''}`
+  }
+
+  #skipBlank() {
+    return this.#scanner.skip(BlankRx)
+  }
+  #skipDelimiter() {
+    return this.#scanner.skip(this.#delimiterSkipPattern)
+  }
+  #scanName() {
+    return this.#scanner.scan(NameRx)
+  }
+  #scanToDelimiter() {
+    return this.#scanner.scan(this.#delimiterBoundaryPattern)
+  }
+  #scanToQuote(quote) {
+    return this.#scanner.scan(BoundaryRx[quote])
+  }
+}

package/src/block.js

@@ -0,0 +1,168 @@
+// ESM conversion of block.rb
+
+import { AbstractBlock } from './abstract_block.js'
+import { prepareSourceString } from './helpers.js'
+import { LF } from './constants.js'
+
+/**
+ * Maps block context strings to their default content model.
+ * Any context not listed defaults to 'simple'.
+ * @type {Object<string, string>}
+ */
+export const DEFAULT_CONTENT_MODEL = new Proxy(
+  {
+    audio: 'empty',
+    image: 'empty',
+    listing: 'verbatim',
+    literal: 'verbatim',
+    stem: 'raw',
+    open: 'compound',
+    page_break: 'empty',
+    pass: 'raw',
+    thematic_break: 'empty',
+    video: 'empty',
+  },
+  {
+    get: (target, key) => (Object.hasOwn(target, key) ? target[key] : 'simple'),
+  }
+)
+
+/**
+ * Methods for managing AsciiDoc content blocks.
+ */
+export class Block extends AbstractBlock {
+  /** @type {string[]} */
+  lines
+  /** @type {string[]|null} */
+  defaultSubs
+
+  /**
+   * Factory method — mirrors the core Block.create(parent, context, opts) API.
+   * @param {AbstractBlock} parent
+   * @param {string} context
+   * @param {Object} [opts={}]
+   * @returns {Block}
+   */
+  static create(parent, context, opts = {}) {
+    return new Block(parent, context, opts)
+  }
+
+  /**
+   * Initialize an Asciidoctor::Block object.
+   * @param {AbstractBlock} parent - The parent AbstractBlock.
+   * @param {string} context - The context name (e.g. 'paragraph', 'listing').
+   * @param {Object} [opts={}]
+   * @param {'compound'|'simple'|'verbatim'|'raw'|'empty'} [opts.content_model] - Defaults to lookup from DEFAULT_CONTENT_MODEL.
+   * @param {Object} [opts.attributes] - Attributes to merge in.
+   * @param {string|string[]} [opts.source] - Raw source string or lines.
+   * @param {'default'|string[]|string|null} [opts.subs]
+   * @param {string[]} [opts.default_subs] - Override for default subs (used with subs: 'default').
+   */
+  constructor(parent, context, opts = {}) {
+    super(parent, context, opts)
+    this.contentModel = opts.content_model ?? DEFAULT_CONTENT_MODEL[context]
+
+    if ('subs' in opts) {
+      const subs = opts.subs
+      if (subs) {
+        if (subs === 'default') {
+          // subs attribute is honored; falls back to opts.default_subs then built-in defaults
+          this.defaultSubs = opts.default_subs ?? null
+        } else if (Array.isArray(subs)) {
+          // subs attribute is not honored; use provided array directly
+          this.defaultSubs = [...subs]
+          delete this.attributes.subs
+        } else {
+          // e.g. subs: 'normal' — subs attribute is not honored
+          this.defaultSubs = null
+          this.attributes.subs = String(subs)
+        }
+        // Resolve subs eagerly when subs option is specified
+        this.commitSubs()
+      } else {
+        // subs: null/[] — lock subs as empty; subsequent commitSubs() calls are no-ops
+        this.defaultSubs = []
+        delete this.attributes.subs
+      }
+    } else {
+      // Defer subs resolution; subs attribute will be honored later
+      this.defaultSubs = null
+    }
+
+    const rawSource = opts.source
+    if (!rawSource && rawSource !== 0) {
+      this.lines = []
+    } else if (typeof rawSource === 'string') {
+      this.lines = prepareSourceString(rawSource)
+    } else {
+      this.lines = [...rawSource]
+    }
+  }
+
+  /** @returns {string} Alias for context — consistent with AsciiDoc terminology. */
+  get blockname() {
+    return this.context
+  }
+
+  /**
+   * Get the converted result appropriate to this block's content model.
+   * @returns {Promise<string|null>}
+   */
+  async content() {
+    switch (this.contentModel) {
+      case 'compound':
+        return super.content()
+      case 'simple':
+        return this.applySubs(this.lines.join(LF), this.subs)
+      case 'verbatim':
+      case 'raw': {
+        const result = await this.applySubs(this.lines, this.subs)
+        if (result.length < 2) return result[0] ?? ''
+        while (result.length > 0 && result[0].trimEnd() === '') result.shift()
+        while (result.length > 0 && result[result.length - 1].trimEnd() === '')
+          result.pop()
+        return result.join(LF)
+      }
+      default:
+        if (this.contentModel !== 'empty') {
+          this.logger.warn(
+            `unknown content model '${this.contentModel}' for block: ${this}`
+          )
+        }
+        return null
+    }
+  }
+
+  /** @returns {string[]} The source lines for this block (matches the core API). */
+  getSourceLines() {
+    return this.lines
+  }
+
+  /** @returns {string} The preprocessed source of this block as a single String. */
+  get source() {
+    return this.lines.join(LF)
+  }
+
+  /** @returns {string} The source as a single String (alias for the source getter). */
+  getSource() {
+    return this.source
+  }
+
+  // ── JavaScript-style accessors ────────────────────────────────────────────────
+
+  /**
+   * Get the block name (alias for context).
+   * @returns {string}
+   */
+  getBlockName() {
+    return this.blockname
+  }
+
+  toString() {
+    const contentSummary =
+      this.contentModel === 'compound'
+        ? `blocks: ${this.blocks.length}`
+        : `lines: ${this.lines.length}`
+    return `#<Block {context: '${this.context}', content_model: '${this.contentModel}', style: ${JSON.stringify(this.style ?? null)}, ${contentSummary}}>`
+  }
+}

package/src/browser/asset.js

@@ -0,0 +1,22 @@
+// Browser-specific asset reading via Fetch API.
+//
+// In a browser environment the document base directory is resolved as an HTTP URL,
+// so "local" assets are served over HTTP rather than from the filesystem.
+// This module provides a fetch-based fallback used by readContents when the
+// resolved path is an HTTP/HTTPS URI (i.e. docdir was set to a browser URL).
+
+/**
+ * Fetch the text content of a URI.
+ *
+ * @param {string} uri - The URI to fetch.
+ * @returns {Promise<string|null>} the response text, or null on failure.
+ */
+export async function readBrowserAsset(uri) {
+  try {
+    const response = await fetch(uri)
+    if (!response.ok) return null
+    return response.text()
+  } catch {
+    return null
+  }
+}