@antora/assembler 1.0.0-alpha.1

package/README.md

@@ -0,0 +1,16 @@
+# Antora Assembler
+
+A library for writing Antora extensions that combine multiple pages into one.
+
+Assembler works by constructing aggregate AsciiDoc documents from the pages based on the navigation tree per component version.
+It then invokes the specified callback to convert those documents to an output format.
+If a catalog is specified, Assembler pushes the converted files back into the catalog to be published as attachments alongside the other files in the site.
+
+[Antora](https://antora.org) is a modular static site generator designed for creating documentation sites from AsciiDoc documents.
+The Assembler extends the feature set of Antora by providing the foundation for page aggregation.
+
+## Copyright and License
+
+Copyright (C) 2022-present by OpenDevise Inc. and the individual contributors of this project.
+
+Use of this software is granted under the terms of the [Mozilla Public License Version 2.0](https://www.mozilla.org/en-US/MPL/2.0/) (MPL-2.0).

package/lib/asciidoctor/reducer-extension.js

@@ -0,0 +1,230 @@
+'use strict'
+
+const Opal = global.Opal
+const Asciidoctor = Opal.Asciidoctor
+const $Reducer = function $Reducer () {}
+
+const DocumentExt = (() => {
+  const parentScope = Opal.module(Asciidoctor, 'Reducer', $Reducer)
+  const scope = Opal.module(parentScope, 'DocumentExt', function $DocumentExt () {})
+
+  Opal.defn(scope, '$save_attributes', function saveAttributes () {
+    this.attributes_defined_in_header = this.attributes_modified.$to_a().reduce((accum, name) => {
+      accum[name] = this.getAttribute(name)
+      return accum
+    }, {})
+    return Opal.send(this, Opal.find_super_dispatcher(this, 'save_attributes', saveAttributes), [])
+  })
+
+  return scope
+})()
+
+const ConditionalDirectiveTracker = (() => {
+  const parentScope = Opal.module(Asciidoctor, 'Reducer', $Reducer)
+  const scope = Opal.module(parentScope, 'ConditionalDirectiveTracker', function $ConditionalDirectiveTracker () {})
+
+  Opal.defn(
+    scope,
+    '$preprocess_conditional_directive',
+    function preprocessConditionalDirective (keyword, target, delimiter, text) {
+      const skipActive = this.skipping
+      const depth = this.conditional_stack.length
+      let directiveLineno = this.lineno
+      const result = Opal.send(
+        this,
+        Opal.find_super_dispatcher(this, 'preprocess_conditional_directive', preprocessConditionalDirective),
+        [keyword, target, delimiter, text]
+      )
+      if (this.skipping && skipActive) return result
+      const currIncReplacement = this.includeReplacements.$current()
+      const drop = currIncReplacement.drop || (currIncReplacement.drop = [])
+      directiveLineno -= currIncReplacement.offset || 0
+      const depthChange = this.conditional_stack.length - depth
+      if (depthChange < 0) {
+        if (skipActive) {
+          for (let n = drop.pop(); n <= directiveLineno; n++) drop.push(n)
+        } else {
+          drop.push(directiveLineno)
+        }
+      } else if (depthChange > 0 || directiveLineno === this.lineno) {
+        drop.push(directiveLineno)
+      } else {
+        drop.push([directiveLineno, text])
+      }
+      return result
+    }
+  )
+
+  return scope
+})()
+
+const CurrentPosition = (() => {
+  const parentScope = Opal.module(Opal.Asciidoctor, 'Reducer', $Reducer)
+  const scope = Opal.module(parentScope, 'CurrentPosition', function $CurrentPosition () {})
+
+  Opal.defn(Opal.get_singleton_class(scope), '$extended', function $extended (instance) {
+    instance.$to_end()
+  })
+
+  Opal.defn(scope, '$current', function $current () {
+    return this[this.pointer]
+  })
+
+  Opal.defn(scope, '$to_end', function $toEnd () {
+    this.pointer = this.length - 1
+  })
+
+  Opal.defn(scope, '$up', function $up () {
+    this.pointer = this.$current().into
+  })
+
+  return scope
+})()
+
+const IncludeDirectiveTracker = (() => {
+  const parentScope = Opal.module(Opal.Asciidoctor, 'Reducer', $Reducer)
+  const scope = Opal.module(parentScope, 'IncludeDirectiveTracker', function $IncludeDirectiveTracker () {})
+
+  Opal.defn(Opal.get_singleton_class(scope), '$extended', function $extended (instance) {
+    instance.includeReplacements = [{}].$extend(CurrentPosition)
+    instance.$$reducer = {}
+  })
+
+  Opal.defn(scope, '$preprocess_include_directive', function preprocessIncludeDirective (target, attrlist) {
+    this.$$reducer.includeDirectiveLine = `include::${target}[${attrlist}]`
+    this.$$reducer.includePushed = false
+    const directiveLineno = this.lineno // we're currently on the include line, which is 1-based
+    const result = Opal.send(
+      this,
+      Opal.find_super_dispatcher(this, 'preprocess_include_directive', preprocessIncludeDirective),
+      [target, attrlist]
+    )
+    if (!this.$$reducer.includePushed) {
+      let ln = this.peekLine(true)
+      let unresolved
+      if (
+        ln &&
+        ln.charAt(ln.length - 1) === ']' &&
+        !(unresolved = ln.startsWith('Unresolved directive in ')) &&
+        directiveLineno === this.lineno &&
+        (unresolved = ln.startsWith('link:'))
+      ) {
+        ln = `${ln.slice(0, ln.length - 1)}role=include]`
+      }
+      pushIncludeReplacement.call(this, directiveLineno, unresolved ? [ln] : [], 0, unresolved)
+    }
+    this.$$reducer = {}
+    return result
+  })
+
+  Opal.defn(scope, '$push_include', function pushInclude (data, file, path, lineno, attrs) {
+    this.$$reducer.includePushed = true
+    const directiveLineno = this.lineno - 1 // we're below the include line, which is 1-based
+    const prevIncDepth = this.include_stack.length
+    const result = Opal.send(this, Opal.find_super_dispatcher(this, 'push_include', pushInclude), [
+      data,
+      file,
+      path,
+      lineno,
+      attrs,
+    ])
+    pushIncludeReplacement.call(
+      this,
+      directiveLineno,
+      this.include_stack.length > prevIncDepth ? this.$lines() : [],
+      lineno > 1 ? lineno - 1 : 0
+    )
+    return result
+  })
+
+  Opal.defn(scope, '$pop_include', function popInclude () {
+    if (!this.$$reducer.includePushed) this.includeReplacements.$up()
+    return Opal.send(this, Opal.find_super_dispatcher(this, 'pop_include', popInclude), [])
+  })
+
+  function pushIncludeReplacement (lineno, lines, offset, unresolved) {
+    const incReplacements = this.includeReplacements
+    const into = incReplacements.pointer
+    const line = this.$$reducer.includeDirectiveLine
+    incReplacements.push({ into, lineno: lineno - (incReplacements.$current().offset || 0), line, lines, offset })
+    if (!unresolved && lines.length) incReplacements.$to_end()
+  }
+
+  return scope
+})()
+
+function preprocessor () {
+  this.process((doc, reader) =>
+    doc.getOptions().preserve_conditionals
+      ? reader.$extend(IncludeDirectiveTracker)
+      : reader.$extend(ConditionalDirectiveTracker, IncludeDirectiveTracker)
+  )
+}
+
+function treeProcessor () {
+  this.process((doc) => {
+    const incReplacements = doc.reader.includeReplacements
+    if (incReplacements.length > 1 || (incReplacements[0].drop || []).length) {
+      const sourceLines = doc.getSourceLines()
+      incReplacements[0].lines = sourceLines.slice()
+      incReplacements
+        .slice()
+        .reverse()
+        .forEach(({ into, lineno, lines, line, drop }) => {
+          let targetLines, idx
+          if (into != null) {
+            targetLines = incReplacements[into].lines
+            // adds assurance that we're replacing the correct line
+            if (targetLines[(idx = lineno - 1)] !== line) return
+          }
+          if ((drop || []).length) {
+            drop
+              .slice()
+              .reverse()
+              .forEach((dropIt) => {
+                Array.isArray(dropIt) ? (lines[dropIt[0] - 1] = dropIt[1]) : lines.splice(dropIt - 1, 1)
+              })
+          }
+          if (targetLines) targetLines[idx] = lines
+        })
+      const reducedSourceLines = flattenDeep(incReplacements[0].lines)
+      if (doc.getSourcemap()) {
+        const logger = Asciidoctor.LoggerManager.getLogger()
+        const opts = Object.assign(doc.getOptions(), { logger: undefined, parse: false, reduced: true })
+        if (opts.extension_registry) {
+          opts.extension_registry = Asciidoctor.Extensions.Registry.$new(opts.extension_registry.groups)
+        }
+        const includes = doc.getCatalog().includes
+        doc = Asciidoctor.load(reducedSourceLines, opts)
+        doc.catalog.$send('[]=', 'includes', includes)
+        doc.parse()
+        Asciidoctor.LoggerManager.setLogger(logger)
+      } else {
+        while (reducedSourceLines[reducedSourceLines.length - 1] === '') reducedSourceLines.pop()
+        sourceLines.splice(0, sourceLines.length, ...reducedSourceLines)
+      }
+    }
+    return doc
+  })
+}
+
+function flattenDeep (array, accum = []) {
+  const len = array.length
+  for (let i = 0, it; i < len; i++) Array.isArray((it = array[i])) ? flattenDeep(it, accum) : accum.push(it)
+  return accum
+}
+
+function toProc (fn) {
+  return Object.defineProperty(fn, '$$arity', { value: fn.length })
+}
+
+module.exports.register = (registry) => {
+  const extGroup = toProc(function () {
+    const doc = this.document
+    doc.$extend(DocumentExt)
+    if (doc.getOptions().reduced) return
+    this.preprocessor(preprocessor)
+    this.treeProcessor(treeProcessor)
+  })
+  registry.groups.$send('[]=', 'reducer', extGroup)
+}

package/lib/assemble-content.js

@@ -0,0 +1,45 @@
+'use strict'
+
+const loadConfig = require('./load-config')
+const produceAggregateDocuments = require('./produce-aggregate-documents')
+const PromiseQueue = require('./util/promise-queue')
+
+async function assembleContent (playbook, contentCatalog, converter, { siteCatalog, configSource }) {
+  // Q: could we get ContentCatalog#getComponentVersionStartPage() in Antora core?
+  if (typeof contentCatalog.getComponentVersionStartPage !== 'function') {
+    contentCatalog.getComponentVersionStartPage = function (component, version) {
+      return this.resolvePage('index.adoc', { component, version })
+    }
+  }
+  const assemblerConfig = await loadConfig(playbook, configSource)
+  if (!assemblerConfig) return [] // TODO consider removing and doing this another way
+  const generatorFunctions = this ? this.getFunctions() : {}
+  const { loadAsciiDoc = require('@antora/asciidoc-loader') } = generatorFunctions
+  const aggregateDocuments = produceAggregateDocuments(loadAsciiDoc, contentCatalog, assemblerConfig)
+  if (!converter) return aggregateDocuments
+  const { publishSite: publishFiles = require('@antora/site-publisher') } = generatorFunctions
+  const buildConfig = assemblerConfig.build
+  await prepareWorkspace(publishFiles, aggregateDocuments, contentCatalog, buildConfig)
+  // TODO: pass more information to converter so it doesn't have to compute internal stuff
+  // Q: don't we need to pass in the combined/resolved AsciiDoc attributes per file or component version?
+  return new PromiseQueue({ concurrency: buildConfig.processLimit })
+    .add(aggregateDocuments.map((doc) => () => converter.call(this, doc, buildConfig)))
+    .toPromise()
+    .then((files) => {
+      if (buildConfig.publish && siteCatalog) siteCatalog.addFiles(files)
+      return files
+    })
+}
+
+// TODO: if no workspace dir is defined; we shouldn't continue
+function prepareWorkspace (publishFiles, aggregateDocuments, contentCatalog, buildConfig) {
+  const { dir, clean, keepAggregateSource } = buildConfig
+  const files = contentCatalog.findBy({ family: 'image' }).filter(({ out }) => out?.assembled)
+  if (keepAggregateSource) {
+    files.push(...aggregateDocuments.map((file) => Object.assign(file, { out: { path: file.path } })))
+  }
+  // TODO: site publisher should accept a single catalog
+  return publishFiles({ output: { clean, dir } }, [{ getFiles: () => files }])
+}
+
+module.exports = assembleContent

package/lib/filter-component-versions.js

@@ -0,0 +1,71 @@
+'use strict'
+
+const { compile: bracesToGroup } = require('braces')
+const { makeRe: makePicomatchRx } = require('picomatch')
+
+const PICOMATCH_OPTS = {
+  bash: true,
+  expandRange: (begin, end, step, opts) => bracesToGroup(opts ? `{${begin}..${end}..${step}}` : `{${begin}..${end}}`),
+  fastpaths: false,
+  nobracket: true,
+  noglobstar: true,
+  nonegate: true,
+  noquantifiers: true,
+  regex: false,
+  strictSlashes: true,
+}
+
+const VERSION_SEPARATOR_RX = /@(?!\()/
+
+function compilePatterns (patterns) {
+  if (patterns[0].charAt() === '!') patterns = ['**', ...patterns]
+  return patterns.map((pattern) => {
+    const negated = pattern.charAt() === '!'
+    if (negated) pattern = pattern.substr(1)
+    let version
+    const separatorIdx = pattern.search(VERSION_SEPARATOR_RX)
+    if (~separatorIdx) {
+      pattern = (version = true) && `${pattern.substr(0, separatorIdx)}%${pattern.substr(separatorIdx + 1) || '*'}`
+    }
+    return Object.assign(makePicomatchRx(pattern, PICOMATCH_OPTS), {
+      globstar: pattern === '**',
+      negated,
+      star: pattern === '*',
+      version,
+    })
+  })
+}
+
+function filterComponentVersions (components, patterns) {
+  if (!patterns.length) return []
+  const rxs = compilePatterns(patterns)
+  return components.reduce((accum, { latest, versions }) => {
+    accum.push(
+      ...versions.filter((version) => {
+        let matched
+        for (const rx of rxs) {
+          let voteIfMatched
+          if (matched) {
+            if (rx.negated) voteIfMatched = false
+          } else if (!rx.negated) {
+            voteIfMatched = true
+          }
+          if (voteIfMatched == null) continue
+          if (rx.globstar) {
+            matched = voteIfMatched
+          } else if (rx.star) {
+            if (version === latest) matched = voteIfMatched
+          } else if (rx.version) {
+            if (rx.test(`${version.version}%${version.name}`)) matched = voteIfMatched
+          } else if (version === latest && rx.test(version.name)) {
+            matched = voteIfMatched
+          }
+        }
+        return matched
+      })
+    )
+    return accum
+  }, [])
+}
+
+module.exports = filterComponentVersions

package/lib/index.js

@@ -0,0 +1,6 @@
+'use strict'
+
+const assembleContent = require('./assemble-content')
+const runCommand = require('./util/run-command')
+
+module.exports = { assembleContent, runCommand }

package/lib/load-config.js

@@ -0,0 +1,62 @@
+'use strict'
+
+const camelCaseKeys = require('camelcase-keys')
+const expandPath = require('@antora/expand-path-helper')
+const { promises: fsp } = require('fs')
+const os = require('os')
+const yaml = require('js-yaml')
+
+const CAMEL_CASE_KEYS_OPTS = { deep: true, stopPaths: ['asciidoc'] }
+
+function loadConfig (playbook, configSource = './antora-assembler.yml') {
+  return (
+    configSource.constructor === Object
+      ? Promise.resolve(configSource)
+      : fsp
+        .access((configSource = expandPath(configSource, { dot: playbook.dir })))
+        .then(
+          () => true,
+          () => false
+        )
+        .then((exists) =>
+          exists
+            ? fsp.readFile(configSource).then((data) => camelCaseKeys(yaml.load(data), CAMEL_CASE_KEYS_OPTS))
+            : {}
+        )
+  ).then((config) => {
+    if (config.enabled === false) return undefined
+    let asciidocAttrs
+    if (!config.asciidoc) {
+      config.asciidoc = { attributes: (asciidocAttrs = { doctype: 'book' }) }
+    } else if (!(asciidocAttrs = config.asciidoc.attributes)) {
+      config.asciidoc.attributes = asciidocAttrs = { doctype: 'book' }
+    }
+    Object.assign(asciidocAttrs, { revdate: new Date().toISOString().split('T')[0], 'page-partial': null })
+    if (config.componentVersions == null) {
+      config.componentVersions = ['**']
+    } else if (typeof config.componentVersions === 'string') {
+      config.componentVersions = config.componentVersions.split(', ')
+    }
+    if (!('rootLevel' in config)) config.rootLevel = 0
+    if (!('insertStartPage' in config)) config.insertStartPage = true
+    if (['discrete', 'fuse', 'enclose'].indexOf(config.sectionMergeStrategy) < 0) {
+      config.sectionMergeStrategy = 'discrete'
+    }
+    const build = config.build || (config.build = {})
+    if (build.dir === '$' + '{playbook.output.dir}') {
+      //build.dir = playbook.output.dir
+      throw new Error('Not implemented')
+    } else {
+      build.dir = expandPath(build.dir || './build/assembler', { dot: playbook.dir })
+    }
+    build.cwd = playbook.dir // use playbook.dir the purpose of finding and loading require scripts
+    if (!('clean' in build) && 'output' in playbook) build.clean = playbook.output.clean
+    if (!('publish' in build)) build.publish = true
+    if (!build.processLimit) {
+      build.processLimit = 'processLimit' in build ? Infinity : Math.round(os.cpus().length * 0.5)
+    }
+    return config
+  })
+}
+
+module.exports = loadConfig

package/lib/produce-aggregate-document.js

@@ -0,0 +1,520 @@
+'use strict'
+
+const File = require('vinyl')
+const { posix: path } = require('path')
+
+function produceAggregateDocument (
+  loadAsciiDoc,
+  contentCatalog,
+  componentVersion,
+  outline,
+  pages,
+  asciidocConfig,
+  mutableAttributes,
+  sectionMergeStrategy = 'discrete'
+) {
+  const pagesInOutline = selectPagesInOutline(outline, pages)
+  const navtitle = outline.content
+  const stem = generateStem(componentVersion, navtitle)
+  const header = buildAsciiDocHeader(componentVersion, navtitle)
+  const body = aggregateAsciiDoc(
+    loadAsciiDoc,
+    contentCatalog,
+    header,
+    componentVersion,
+    outline,
+    pagesInOutline,
+    asciidocConfig,
+    mutableAttributes,
+    sectionMergeStrategy
+  )
+  const relativeSrcPath = `${stem}.adoc`
+  return new File({
+    asciidoc: asciidocConfig,
+    contents: Buffer.from([...header, ...body].join('\n') + '\n'),
+    mediaType: 'text/asciidoc',
+    path: relativeSrcPath,
+    src: {
+      component: componentVersion.name,
+      version: componentVersion.version,
+      basename: path.basename(relativeSrcPath),
+      stem,
+      extname: '.adoc',
+    },
+  })
+}
+
+function buildAsciiDocHeader (componentVersion, navtitle) {
+  const doctitle = navtitle === componentVersion.title ? navtitle : `${componentVersion.title}: ${navtitle}`
+  const version = componentVersion.version && componentVersion.version !== 'master' ? componentVersion.version : ''
+  return [
+    `= ${doctitle}`,
+    ...(version ? [`v${version}`] : []),
+    ':doctype: book', // for debugging only; set via CLI
+    // Q: should we pass these via the CLI so they cannot be modified?
+    `:page-component-name: ${componentVersion.name}`,
+    `:page-component-version:${version ? ' ' + version : ''}`,
+    ':page-version: {page-component-version}',
+    `:page-component-display-version: ${componentVersion.displayVersion}`,
+    `:page-component-title: ${componentVersion.title}`,
+  ]
+}
+
+function selectPagesInOutline (outlineEntry, pages) {
+  const page = outlineEntry.urlType === 'internal' ? pages.find((it) => it.pub.url === outlineEntry.url) : undefined
+  return (outlineEntry.items || []).reduce(
+    (accum, item) => new Map([...accum, ...selectPagesInOutline(item, pages)]),
+    new Map(
+      page && [
+        [`${page.src.module === 'ROOT' ? '' : page.src.module + ':'}${page.src.relative}`, page],
+        [page.pub.url, page],
+      ]
+    )
+  )
+}
+
+function aggregateAsciiDoc (
+  loadAsciiDoc,
+  contentCatalog,
+  header,
+  componentVersion,
+  outlineEntry,
+  pagesInOutline,
+  asciidocConfig,
+  mutableAttributes,
+  sectionMergeStrategy,
+  level = 0
+) {
+  const buffer = []
+  // TODO: we could try to be smart about it and make sure the page with fragment is included at least once
+  if (outlineEntry.hash) return buffer
+  const { content: navtitle, items, unresolved, urlType, url } = outlineEntry
+  // FIXME: ideally, resource ID would be stored in navigation so we can look up the page more efficiently
+  let page = urlType === 'internal' && !unresolved ? pagesInOutline.get(url) : undefined
+  if (page) {
+    let contents = page.src.contents
+    // NOTE: blank lines at top and bottom of document create mismatch when using line numbers to navigate source lines
+    // IMPORTANT: this must not leave behind lines the parser will drop!
+    // IDEA: another option is to capture initial lineno of reader and use as offset (but preseves those blank lines)
+    contents = Buffer.from(
+      contents
+        .toString()
+        .replace(/^(?:[ \t]*\r\n?|[ \t]*\n)+/, '')
+        .trimRight()
+    )
+    page = new page.constructor(Object.assign({}, page, { contents, mediaType: 'text/asciidoc' }))
+    const { module: module_, relative, origin } = page.src
+    const doc = loadAsciiDoc(page, contentCatalog, asciidocConfig)
+    const ids = doc.getCatalog().ids
+    // NOTE: in Antora, docname is relative src path from module without file extension
+    const docname = doc.getAttribute('docname')
+    //const idprefix = `${module_ === 'ROOT' ? '' : module_ + ':'}${docname}//`
+    const idprefix = `${module_ === 'ROOT' ? '' : module_ + ':'}${docname.replace(/[/]/g, '::')}:::`
+    //const idprefix = `${module_ === 'ROOT' ? '' : module_ + ':'}${docname.replace(/[/]/g, ':-:')}:--:`
+    buffer.push('')
+    buffer.push(`:docname: ${docname}`)
+    buffer.push(`:page-module: ${module_}`)
+    buffer.push(`:page-relative-src-path: ${relative}`)
+    //buffer.push(`:page-origin-type: ${origin.type}`)
+    buffer.push(`:page-origin-url: ${origin.url}`)
+    buffer.push(`:page-origin-start-path:${origin.startPath && ' '}${origin.startPath}`)
+    buffer.push(`:page-origin-refname: ${origin.branch || origin.tag}`)
+    buffer.push(`:page-origin-reftype: ${origin.branch ? 'branch' : 'tag'}`)
+    buffer.push(`:page-origin-refhash: ${origin.worktree ? '(worktree)' : origin.refhash}`)
+    let enclosed
+    // NOTE: if level is 0, doctitle has already been added and we're in the document header
+    if (level) {
+      if (level === 1 && navtitle === componentVersion.title) {
+        level--
+      } else {
+        let hlevel = level + 1
+        if (hlevel > 6) {
+          hlevel = 6
+          buffer.push(`[discrete#${idprefix}]`)
+        } else {
+          buffer.push(`[#${idprefix}]`)
+        }
+        buffer.push(`${'='.repeat(hlevel)} ${navtitle}`)
+      }
+    } else {
+      header.unshift(`[#${idprefix}]`)
+    }
+    if (sectionMergeStrategy === 'enclose' && items && doc.hasSections()) {
+      enclosed = true
+      // TODO: make overview section title configurable
+      //let overviewTitle = doc.getDocumentTitle()
+      //if (overviewTitle === navtitle) overviewTitle = doc.getAttribute('overview-title', 'Overview')
+      const overviewTitle = doc.getAttribute('overview-title', 'Overview')
+      buffer.push('')
+      // NOTE: try to toggle sectids; otherwise, fallback to globally unique synthetic ID
+      let toggleSectids, syntheticId
+      if (doc.isAttribute('sectids')) {
+        if (doc.isAttributeLocked('sectids')) {
+          syntheticId = `__object-id-${getObjectId(outlineEntry)}`
+        } else {
+          buffer.push(':!sectids:')
+          toggleSectids = true
+        }
+      }
+      let hlevel = level + 2
+      if (hlevel > 6) {
+        hlevel = 6
+        buffer.push(syntheticId ? `[discrete#${syntheticId}]` : '[discrete]')
+      } else if (syntheticId) {
+        buffer.push(`[#${syntheticId}]`)
+      }
+      buffer.push(`${'='.repeat(hlevel)} ${overviewTitle}`)
+      if (toggleSectids) buffer.push(':sectids:')
+    }
+    const siteUrl = doc.getAttribute('site-url')
+    const lines = doc.getSourceLines()
+    const ignoreLines = []
+    // TODO: think more about when multipart is allowed; perhaps configurable
+    if (doc.hasSections()) fixSectionLevels(doc.getSections(), level === 0)
+    // TODO: update / simplify findBy calls when upgrading to Asciidoctor 2
+    const allBlocks = doc
+      .findBy((it) => it.getContext() !== 'document')
+      .reduce((accum, block) => {
+        accum.push(block)
+        if (block.getContext() === 'table') {
+          const rows = block.rows
+          ;[...rows.body, ...rows.foot].forEach((row) => {
+            row.forEach((cell) => {
+              if (cell.style !== 'asciidoc') return
+              accum.push(...cell.inner_document.findBy((it) => it.getContext() !== 'document'))
+            })
+          })
+        }
+        return accum
+      }, [])
+    allBlocks.forEach((block) => {
+      const contentModel = block.content_model
+      if (
+        ((contentModel === 'verbatim' && block.getContext() !== 'table_cell') ||
+          contentModel === 'simple' ||
+          contentModel === 'pass') &&
+        !block.hasSubstitution('macros')
+      ) {
+        const lineno = block.getLineNumber()
+        const idx = typeof lineno === 'number' ? lineno - 1 : undefined
+        const startLine = lines[idx]
+        // NOTE: one case this happens if when sourcemap isn't enabled when reducing
+        if (startLine == null) {
+          console.log(`null startLine for ${block.getContext()} at ${lineno} in ${relative}`)
+          return
+        }
+        const char0 = startLine.charAt()
+        // FIXME: needs to be more robust; move logic to helper
+        const delimited =
+          startLine.length > 3 &&
+          startLine === char0.repeat(startLine.length) &&
+          (char0 === '-' || char0 === '.' || char0 === '+')
+        // QUESTION: exclude block attribute lines too? what about attribute entries?
+        for (let i = idx; i < block.lines.length + (delimited ? idx + 2 : idx); i++) ignoreLines.push(i)
+      }
+    })
+    for (let idx = 0, len = lines.length; idx < len; idx++) {
+      if (~ignoreLines.indexOf(idx)) continue
+      let line = lines[idx]
+      if (~line.indexOf('<<')) {
+        line = line.replace(/(?<![\\+])<<#?([\p{Alpha}0-9_/.:{][^>,]*?)(?:|, *([^>]+?))?>>/gu, (m, refid, text) => {
+          // support natural xref; note this logic will change when upgrading to Asciidoctor 2
+          if (!ids['$key?'](refid) && (~refid.indexOf(' ') || refid.toLowerCase() !== refid)) {
+            if (!(refid = doc.getCatalog().ids.$key(refid).$to_s())) {
+              return m
+            }
+          }
+          return `<<${idprefix}${refid}${text ? ',' + text : ''}>>`
+        })
+      }
+      // NOTE: the next check takes care of inline and block anchors
+      if (~line.indexOf('[[')) {
+        line = line.replace(/\[\[([\p{Alpha}_:][\p{Alpha}0-9_\-:.]*)(|, *.+?)\]\]/gu, `[[${idprefix}$1$2]]`)
+      }
+      if (~line.indexOf('xref:')) {
+        // Q: should we allow : as first character of target?
+        line = line.replace(/xref:([\p{Alpha}#/.{].*?)\[(|.*?[^\\])\]/gu, (m, target, text) => {
+          let pagePart, fragment, targetPage
+          const hashIdx = target.indexOf('#')
+          if (~hashIdx) {
+            pagePart = target.substr(0, hashIdx)
+            fragment = target.substr(hashIdx + 1)
+            // TODO: for now, assume .adoc; in the future, consider other file extensions
+            if (!(pagePart && pagePart.endsWith('.adoc'))) pagePart += '.adoc'
+          } else if (target.endsWith('.adoc')) {
+            pagePart = target
+            fragment = ''
+          } else {
+            fragment = target
+          }
+          if (!pagePart) return `<<${idprefix}${fragment}${text ? ',' + text.replace(/\\]/g, ']') : ''}>>`
+          if (~pagePart.indexOf('@') || /:.*:/.test(pagePart)) {
+            // TODO: handle unresolved page better
+            return siteUrl && (targetPage = contentCatalog.resolvePage(pagePart, page.src))
+              ? `${siteUrl}${targetPage.pub.url}${fragment && '#' + fragment}[${text}]`
+              : m
+          } else if (pagePart.indexOf(':') < 0) {
+            if (module_ !== 'ROOT') pagePart = `${module_}:${pagePart}`
+          } else if (pagePart.startsWith('ROOT:')) {
+            pagePart = pagePart.substr(5)
+          }
+          if (!(targetPage = pagesInOutline.get(pagePart))) {
+            // TODO: handle unresolved page better
+            return siteUrl && (targetPage = contentCatalog.resolvePage(target, page.src))
+              ? `${siteUrl}${targetPage.pub.url}${fragment && '#' + fragment}[${text}]`
+              : m
+          }
+          pagePart = pagePart.replace(/[/]/g, '::').replace(/\.adoc$/, '')
+          const refid = `${pagePart}:::${fragment}`
+          return `<<${refid}${text && text !== targetPage.title ? ',' + text.replace(/\\]/g, ']') : ''}>>`
+        })
+      }
+      if (~line.indexOf('link:{attachmentsdir}/')) {
+        line = line.replace(/(?<![\\+])link:\{attachmentsdir\}\/([^\s[]+)\[(|.*?[^\\])\]/g, (m, relative, text) => {
+          const attachment =
+            siteUrl &&
+            contentCatalog.getById({
+              component: componentVersion.name,
+              version: componentVersion.version,
+              module: module_,
+              family: 'attachment',
+              relative,
+            })
+          return attachment ? `${siteUrl}${attachment.pub.url}[${text}]` : m
+        })
+      }
+      if (~line.indexOf('image:') && !line.startsWith('image::')) {
+        line = line.replace(/(?<![\\+])image:([^:\s[](?:[^[]*[^\s[])?)\[([^\]]*)\]/g, (m, target, attrlist) => {
+          if (isResourceSpec(target)) {
+            const image = contentCatalog.resolveResource(target, page.src, 'image', ['image'])
+            // TODO: handle (or report) unresolved image better
+            if (image) {
+              image.out.assembled = true
+              return `image:${image.pub.url.substr(1)}[${attrlist}]`
+            }
+          }
+          return m
+        })
+      }
+      lines[idx] = line
+    }
+    // NOTE: need to do this last since it modifies the line numbers
+    // we could remap the line numbers to make them resilient
+    // or we could mark which lines to remove and filter them after
+    ;[...allBlocks].reverse().forEach((block) => {
+      const lineno = block.getLineNumber()
+      // NOTE: lineno is not defined for preamble
+      if (typeof lineno !== 'number') return
+      const context = block.getContext()
+      const idx = lineno - 1
+      if (context === 'section') {
+        if (block.getSectionName() === 'header') {
+          lines.splice(idx, 1)
+          return
+        }
+        let blockStyle = sectionMergeStrategy === 'discrete' ? 'discrete' : undefined
+        // FIXME: quick fix; needs more thorough review
+        const leveloffset = Number(doc.getAttribute('leveloffset') || 0)
+        lines[idx] = lines[idx].replace(/^=+( .+)/, (_, rest) => {
+          let targetMarkerLength = block.level + (1 - leveloffset) + level + (enclosed ? 1 : 0)
+          if (targetMarkerLength > 6) {
+            targetMarkerLength = 6
+            blockStyle = 'discrete'
+          }
+          return '='.repeat(targetMarkerLength) + rest
+        })
+        // NOTE: ID will be undefined if sectids are turned off
+        if (block.getId()) rewriteStyleAttribute(block, lines, idx, idprefix, blockStyle)
+      } else {
+        if (context === 'image') {
+          const atImageMacro = (lines[idx] || '').startsWith('image::')
+          // NOTE: the following logic is needed only if parser is messing up line number of image block
+          //let atImageMacro
+          //// NOTE: account for line number tracking error in parser when image has block anchor
+          //if (block.getId()) {
+          //  const originalIdx = idx
+          //  let line
+          //  while ((line = lines[idx]) != null && !(atImageMacro = line.startsWith('image::'))) idx++
+          //  if (!atImageMacro) {
+          //    idx = originalIdx
+          //    if ((lines[idx - 1] || '').startsWith('image::')) {
+          //      atImageMacro = true
+          //      idx--
+          //    }
+          //  }
+          //} else if ((lines[idx] || '').startsWith('image::')) {
+          //  atImageMacro = true
+          //}
+          const target = block.getAttribute('target')
+          if (atImageMacro && isResourceSpec(target)) {
+            const image = contentCatalog.resolveResource(target, page.src, 'image', ['image'])
+            // FIXME: handle (or report) case when image is not resolved
+            if (image) {
+              image.out.assembled = true
+              const line = lines[idx]
+              lines[idx] = `image::${image.pub.url.substr(1)}${line.substr(line.indexOf('['))}`
+            }
+          }
+        }
+        if (block.getId()) rewriteStyleAttribute(block, lines, idx, idprefix)
+      }
+    })
+    buffer.push(...lines)
+    const attributeEntries = Object.entries(doc.attributes_defined_in_header || {})
+    if (attributeEntries.length) {
+      const resolvedAttributeEntries = attributeEntries.reduce(
+        (accum, [name, val]) => {
+          // Q: couldn't we just check if attribute is locked?
+          if (name in mutableAttributes) {
+            const initialVal = mutableAttributes[name]
+            if (initialVal == null) {
+              if (val != null) accum.push(`:!${name}:`)
+            } else if (val !== initialVal) {
+              accum.push(`:${name}:${initialVal ? ' ' + initialVal : ''}`)
+            }
+          } else if (val != null && !doc.isAttributeLocked(name)) {
+            accum.push(`:!${name}:`)
+          }
+          return accum
+        },
+        ['']
+      )
+      if (resolvedAttributeEntries.length > 1) buffer.push(...resolvedAttributeEntries)
+    }
+  } else {
+    if (level) {
+      if (level === 1 && navtitle === componentVersion.title) {
+        level--
+      } else {
+        buffer.push('')
+        // NOTE: try to toggle sectids; otherwise, fallback to globally unique synthetic ID
+        let toggleSectids, syntheticId
+        if (!('sectids' in asciidocConfig.attributes)) {
+          buffer.push(':!sectids:')
+          toggleSectids = true
+        } else if (typeof asciidocConfig.attributes.sectids === 'string') {
+          if ('sectids' in mutableAttributes) {
+            buffer.push(':!sectids:')
+            toggleSectids = true
+          } else {
+            syntheticId = `__object-id-${global.Opal.hash(outlineEntry).$object_id()}`
+          }
+        }
+        // Q: should we unset docname, page-module, etc?
+        const sectionTitle = urlType === 'external' ? `${url}[${navtitle.replace(/\]/, '\\]')}]` : navtitle
+        let hlevel = level + 1
+        if (hlevel > 6) {
+          hlevel = 6
+          buffer.push(syntheticId ? `[discrete#${syntheticId}]` : '[discrete]')
+        } else if (syntheticId) {
+          buffer.push(`[#${syntheticId}]`)
+        }
+        buffer.push(`${'='.repeat(hlevel)} ${sectionTitle}`)
+        if (toggleSectids) buffer.push(':sectids:')
+      }
+    }
+  }
+
+  const nextLevel = level + 1
+  if (items) {
+    items.forEach((item) => {
+      buffer.push(
+        ...aggregateAsciiDoc(
+          loadAsciiDoc,
+          contentCatalog,
+          header,
+          componentVersion,
+          item,
+          pagesInOutline,
+          asciidocConfig,
+          mutableAttributes,
+          sectionMergeStrategy,
+          nextLevel
+        )
+      )
+    })
+  }
+  return buffer
+}
+
+function generateStem (componentVersion, title) {
+  const { name, version } = componentVersion
+  const segments = [name]
+  if (version && version !== 'master') segments.push(version)
+  segments.push(
+    title
+      .toLowerCase()
+      .replace(/&.+?;|[^ \p{Alpha}0-9_\-.]/gu, '')
+      .replace(/[ _.]/g, '-')
+      .replace(/--+/g, '-')
+  )
+  return path.join(...segments)
+}
+
+function fixSectionLevels (sections, multipart) {
+  sections.forEach((sect) => {
+    const targetLevel = sect.getParent().getLevel() + 1
+    if (multipart ? sect.getLevel() > targetLevel : sect.getLevel() !== targetLevel) sect.level = targetLevel
+    if (sect.hasSections()) fixSectionLevels(sect.getSections(), multipart)
+  })
+}
+
+function rewriteStyleAttribute (block, lines, idx, idprefix, replacementStyle = '') {
+  let prevLine = lines[idx - 1]
+  const char0 = prevLine?.charAt()
+  if (char0) {
+    if (
+      (char0 === '.' && /^\.\.?[^ \t.]/.test(prevLine)) ||
+      (char0 === '[' &&
+        prevLine.charAt(1) === '[' &&
+        /^\[\[(?:|[\p{Alpha}_:][\p{Alpha}0-9_\-:.]*(?:, *.+)?)\]\]$/u.test(prevLine))
+    ) {
+      return rewriteStyleAttribute(block, lines, idx - 1, idprefix, replacementStyle)
+    }
+  }
+  let cellSpec
+  if (
+    char0 &&
+    (char0 === '[' || (block.getDocument().isNested() && (cellSpec = prevLine.match(/^([^[|]*)\| *(\[.+)/)))) &&
+    prevLine.charAt(prevLine.length - 1) === ']'
+  ) {
+    if (cellSpec) {
+      prevLine = cellSpec[2]
+      cellSpec = cellSpec[1]
+    }
+    let rawStyle
+    const commaIdx = prevLine.indexOf(',')
+    if (~commaIdx) {
+      rawStyle = prevLine.substr(1, commaIdx - 1)
+      if (~rawStyle.indexOf('=')) rawStyle = undefined
+    } else if (!~prevLine.indexOf('=')) {
+      rawStyle = prevLine.substr(1, prevLine.length - 2)
+    }
+    if (rawStyle) {
+      if (~rawStyle.indexOf('#')) {
+        prevLine = prevLine.replace(/#[^.%,\]]+/, `#${idprefix}${block.getId()}`)
+        if (replacementStyle) prevLine = prevLine.replace(/^[^#.%,\]]+/, `[${replacementStyle}`)
+      } else {
+        prevLine = `[${
+          replacementStyle ? rawStyle.replace(/^[^.%]*]/, replacementStyle) : rawStyle
+        }#${idprefix}${block.getId()}${prevLine.substr(rawStyle.length + 1)}`
+      }
+    } else {
+      prevLine = `[${replacementStyle}#${idprefix}${block.getId()}${rawStyle == null ? ',' : ''}${prevLine.substr(1)}`
+    }
+    if (cellSpec) prevLine = `${cellSpec}|${prevLine}`
+    lines[idx - 1] = prevLine
+  } else {
+    lines.splice(idx, 0, `[${replacementStyle}#${idprefix}${block.getId()}]`)
+  }
+}
+
+function isResourceSpec (str) {
+  return !(~str.indexOf(':') && (~str.indexOf('://') || (str.startsWith('data:') && ~str.indexOf(','))))
+}
+
+function getObjectId (obj) {
+  return global.Opal.uid()
+}
+
+module.exports = produceAggregateDocument

package/lib/produce-aggregate-documents.js

@@ -0,0 +1,83 @@
+'use strict'
+
+const filterComponentVersions = require('./filter-component-versions')
+const produceAggregateDocument = require('./produce-aggregate-document')
+const selectMutableAttributes = require('./select-mutable-attributes')
+
+function produceAggregateDocuments (loadAsciiDoc, contentCatalog, assemblerConfig) {
+  const { insertStartPage, rootLevel, sectionMergeStrategy, asciidoc: assemblerAsciiDocConfig } = assemblerConfig
+  return filterComponentVersions(contentCatalog.getComponents(), assemblerConfig.componentVersions).reduce(
+    (accum, componentVersion) => {
+      const { name: componentName, version, title, navigation } = componentVersion
+      if (!navigation) return accum
+      const componentVersionAsciiDocConfig = getAsciiDocConfigWithAsciidoctorReducerExtension(componentVersion)
+      const mergedAsciiDocConfig = Object.assign({}, componentVersionAsciiDocConfig, {
+        attributes: Object.assign({}, componentVersionAsciiDocConfig.attributes, assemblerAsciiDocConfig.attributes),
+      })
+      const rootEntry = { content: title }
+      const startPage = contentCatalog.getComponentVersionStartPage(componentName, version)
+      let startPageUrl
+      if (startPage && insertStartPage) {
+        if (includedInNav(navigation, (startPageUrl = startPage.pub.url))) {
+          startPageUrl = undefined
+        } else {
+          Object.assign(rootEntry, { url: startPageUrl, urlType: 'internal' })
+        }
+      }
+      // Q: should we use an artificial page instead or as fallback?
+      const mutableAttributes = startPage
+        ? selectMutableAttributes(loadAsciiDoc, contentCatalog, startPage, mergedAsciiDocConfig)
+        : {}
+      return accum.concat(
+        prepareOutlines(navigation, rootEntry, rootLevel).map((outline) =>
+          produceAggregateDocument(
+            loadAsciiDoc,
+            contentCatalog,
+            componentVersion,
+            outline,
+            contentCatalog.getPages((page) => page.out),
+            mergedAsciiDocConfig,
+            mutableAttributes,
+            sectionMergeStrategy
+          )
+        )
+      )
+    },
+    []
+  )
+}
+
+function getAsciiDocConfigWithAsciidoctorReducerExtension (componentVersion) {
+  const asciidoctorReducerExtension = require('./asciidoctor/reducer-extension') // NOTE: must be required lazily
+  const asciidocConfig = componentVersion.asciidoc
+  const extensions = asciidocConfig.extensions || []
+  if (extensions.length) {
+    return Object.assign({}, asciidocConfig, {
+      extensions: extensions.reduce(
+        (accum, candidate) => {
+          if (candidate !== asciidoctorReducerExtension) accum.push(candidate)
+          return accum
+        },
+        [asciidoctorReducerExtension]
+      ),
+    })
+  }
+  return Object.assign({}, asciidocConfig, { extensions: [asciidoctorReducerExtension], sourcemap: true })
+}
+
+function includedInNav (items, url) {
+  return items.find((it) => it.url === url || includedInNav(it.items || [], url))
+}
+
+function prepareOutlines (navigation, rootEntry, rootLevel) {
+  if (rootLevel === 0 || navigation.length === 1) {
+    const navBranch =
+      navigation.length === 1
+        ? navigation[0]
+        : { items: navigation.reduce((navTree, it) => navTree.concat(it.content ? it : it.items), []) }
+    return [Object.assign(rootEntry, navBranch)]
+  }
+  return navigation.reduce((navTree, it) => navTree.concat(it.content ? it : it.items), [rootEntry])
+}
+
+module.exports = produceAggregateDocuments

package/lib/select-mutable-attributes.js

@@ -0,0 +1,26 @@
+'use strict'
+
+function selectMutableAttributes (loadAsciiDoc, contentCatalog, referencePage, asciidocConfig) {
+  const doc = loadAsciiDoc(
+    new referencePage.constructor(
+      Object.assign({}, referencePage, { contents: Buffer.alloc(0), mediaType: 'text/asciidoc' })
+    ),
+    contentCatalog,
+    asciidocConfig
+  )
+  const additionalMutableNames = [
+    'page-component-name',
+    'page-component-version',
+    'page-version',
+    'page-component-display-version',
+    'page-component-title',
+  ]
+  // we could consider using an Asciidoctor extension here to grab attributes passed via the API instead
+  const immutableAttributeNames = doc.attribute_overrides.$keys()['$-'](additionalMutableNames)
+  return Object.entries(doc.getAttributes()).reduce((accum, [name, val]) => {
+    if (!immutableAttributeNames.includes(name)) accum[name] = val
+    return accum
+  }, {})
+}
+
+module.exports = selectMutableAttributes

package/lib/util/lazy-readable.js

@@ -0,0 +1,19 @@
+'use strict'
+
+const { PassThrough } = require('stream')
+
+// adapted from https://github.com/jpommerening/node-lazystream/blob/master/lib/lazystream.js | license: MIT
+class LazyReadable extends PassThrough {
+  constructor (fn, options) {
+    super(options)
+    const _read = this._read
+    this._read = function () {
+      this._read = _read.bind(this)
+      fn.call(this, options).on('error', this.emit.bind(this, 'error')).pipe(this)
+      return this._read.apply(this, arguments)
+    }
+    this.emit('readable')
+  }
+}
+
+module.exports = LazyReadable

package/lib/util/promise-queue.js

@@ -0,0 +1,57 @@
+'use strict'
+
+class PromiseQueue {
+  #scheduler
+  #started
+  #pending
+  #rejection
+  #startTask
+  #trapRejection
+
+  constructor ({ concurrency = Infinity } = {}) {
+    this.concurrency = concurrency
+    this.#scheduler = Promise.resolve()
+    this.#started = []
+    this.#pending = []
+    this.#startTask = (task) => {
+      if (this.#rejection) return
+      if (this.concurrency === Infinity) {
+        this.#started.push(task().catch(this.#trapRejection))
+      } else {
+        let current
+        this.#pending.push(
+          (current = task()
+            .catch(this.#trapRejection)
+            .finally(() => this.#pending.splice(this.#pending.indexOf(current), 1)))
+        )
+        this.#started.push(current)
+      }
+    }
+    this.#trapRejection = (err) => (this.#rejection = err || new Error()) && undefined
+  }
+
+  add (tasks) {
+    if (!Array.isArray(tasks)) tasks = [tasks]
+    for (const task of tasks) {
+      if (this.#pending.length < this.concurrency) {
+        this.#startTask(task)
+      } else {
+        this.#scheduler = this.#scheduler.then(
+          () => this.#pending.length && Promise.race(this.#pending).then(() => this.#startTask(task))
+        )
+      }
+    }
+    return this
+  }
+
+  async toPromise () {
+    // what about promiseAll(), all(), or promise()?
+    await this.#scheduler
+    return Promise.all(this.#started).then((returnValues) => {
+      if (this.#rejection) throw this.#rejection
+      return returnValues
+    })
+  }
+}
+
+module.exports = PromiseQueue

package/lib/util/run-command.js

@@ -0,0 +1,56 @@
+'use strict'
+
+const fs = require('fs')
+const LazyReadable = require('./lazy-readable')
+const { spawn } = require('child_process')
+
+const IS_WIN = process.platform === 'win32'
+const DBL_QUOTE_RX = /"/g
+
+const shellEscape = IS_WIN
+  ? (val) => {
+      if (val.charAt() === '-') {
+        return val
+      } else if (~val.indexOf('"')) {
+        return ~val.indexOf(' ') ? `"${val.replace(DBL_QUOTE_RX, '"""')}"` : val.replace(DBL_QUOTE_RX, '""')
+      } else if (~val.indexOf(' ')) {
+        return `"${val}"`
+      }
+      return val
+    }
+  : (val) => val
+
+async function runCommand (cmd, argv = [], opts = {}) {
+  if (!cmd) throw new TypeError('Command not specified')
+  const cmdv = cmd.split(' ').map(shellEscape)
+  const { input, output, implicitStdin, ...spawnOpts } = opts
+  if (input) input instanceof Buffer ? implicitStdin || argv.push('-') : argv.push(input)
+  if (IS_WIN) Object.assign(spawnOpts, { shell: true, windowsHide: true })
+  return new Promise((resolve, reject) => {
+    const stdout = []
+    const stderr = []
+    const ps = spawn(cmdv[0], [...cmdv.slice(1), ...argv.map(shellEscape)], spawnOpts)
+    ps.on('close', (code) => {
+      if (code === 0) {
+        if (stderr.length) process.stderr.write(stderr.join(''))
+        resolve(output ? new LazyReadable(() => fs.createReadStream(output)) : Buffer.from(stdout.join('')))
+      } else {
+        let msg = `Command failed: ${ps.spawnargs.join(' ')}`
+        if (stderr.length) msg += '\n' + stderr.join('')
+        reject(new Error(msg))
+      }
+    })
+    ps.on('error', (err) => reject(err.code === 'ENOENT' ? new Error(`Command not found: ${cmdv.join(' ')}`) : err))
+    ps.stdout.on('data', (data) => (output ? process.stdout.write(data) : stdout.push(data)))
+    ps.stderr.on('data', (data) => stderr.push(data))
+    try {
+      input instanceof Buffer ? ps.stdin.end(input) : ps.stdin.end()
+    } catch (err) {
+      reject(err)
+    } finally {
+      ps.stdin.end()
+    }
+  })
+}
+
+module.exports = runCommand

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@antora/assembler",
+  "version": "1.0.0-alpha.1",
+  "description": "An extension library for Antora that assembles content from multiple pages into a single AsciiDoc file to converted and publish.",
+  "license": "MPL-2.0",
+  "author": "OpenDevise Inc. (https://opendevise.com)",
+  "contributors": [
+    "Dan Allen <dan@opendevise.com>",
+    "Sarah White <sarah@opendevise.com>"
+  ],
+  "homepage": "https://antora.org",
+  "repository": "gitlab:antora/antora-assembler",
+  "bugs": {
+    "url": "https://gitlab.com/antora/antora-assembler/issues"
+  },
+  "scripts": {
+    "test": "_mocha test",
+    "prepublishOnly": "node $npm_config_local_prefix/npm/prepublishOnly.js",
+    "postpublish": "node $npm_config_local_prefix/npm/postpublish.js"
+  },
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./asciidoctor/reducer-extension": "./lib/asciidoctor/reducer-extension.js",
+    "./filter-component-versions": "./lib/filter-component-versions.js",
+    "./load-config": "./lib/load-config.js",
+    "./produce-aggregate-document": "./lib/produce-aggregate-document.js",
+    "./select-mutable-attributes": "./lib/select-mutable-attributes.js"
+  },
+  "dependencies": {
+    "@antora/expand-path-helper": "~2.0",
+    "braces": "~3.0",
+    "camelcase-keys": "~7.0",
+    "picomatch": "~2.3",
+    "vinyl": "~2.2",
+    "js-yaml": "~4.1"
+  },
+  "devDependencies": {
+    "@antora/asciidoc-loader": "3.0.1",
+    "@antora/site-publisher": "3.0.1"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "files": [
+    "lib/"
+  ],
+  "keywords": [
+    "antora",
+    "antora-extension",
+    "asciidoc",
+    "documentation"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}