@antora/assembler 1.0.0-alpha.8 → 1.0.0-beta.1

package/lib/produce-assembly-files.js

@@ -0,0 +1,146 @@
+'use strict'
+
+const createAsciiDocFile = require('./util/create-asciidoc-file')
+const filterComponentVersions = require('./filter-component-versions')
+const produceAssemblyFile = require('./produce-assembly-file')
+const selectMutableAttributes = require('./select-mutable-attributes')
+
+const IMAGE_MACRO_RX = /^image::?(.+?)\[(.*?)\]$/
+
+function produceAssemblyFiles (loadAsciiDoc, contentCatalog, assemblerConfig, resolveAssemblyModel) {
+  const { asciidoc: assemblerAsciiDocConfig, assembly: assemblyConfig } = assemblerConfig
+  resolveAssemblyModel ??= (componentVersion) => ({
+    doctype: assemblyConfig.doctype,
+    insertStartPage: assemblyConfig.insertStartPage,
+    rootLevel: assemblyConfig.rootLevel,
+    sectionMergeStrategy: assemblyConfig.sectionMergeStrategy,
+    navigation: componentVersion.navigation,
+    xmlIds: assemblyConfig.xmlIds,
+  })
+  const assemblerAsciiDocAttributes = Object.assign({}, assemblerAsciiDocConfig.attributes)
+  const { revdate, 'source-highlighter': sourceHighlighter } = assemblerAsciiDocAttributes
+  delete assemblerAsciiDocAttributes.revdate
+  delete assemblerAsciiDocAttributes['source-highlighter']
+  const publishableFiles = contentCatalog.getFiles().filter((file) => file.out)
+  return filterComponentVersions(contentCatalog.getComponents(), assemblerConfig.componentVersionFilter.names).reduce(
+    (accum, componentVersion) => {
+      const assemblyModel = resolveAssemblyModel(componentVersion)
+      if (!assemblyModel.navigation) return accum
+      const { name: componentName, version, title } = componentVersion
+      const componentVersionAsciiDocConfig = getAsciiDocConfigWithAsciidoctorReducerExtension(componentVersion)
+      const mergedAsciiDocConfig = Object.assign({}, componentVersionAsciiDocConfig, {
+        attributes: Object.assign({ revdate }, componentVersionAsciiDocConfig.attributes, assemblerAsciiDocAttributes),
+      })
+      const mergedAsciiDocAttributes = mergedAsciiDocConfig.attributes
+      const auxiliaryImages = new Set()
+      Object.entries(mergedAsciiDocAttributes).forEach(([name, val]) => {
+        const match = name.endsWith('-image') && val.startsWith('image:') && IMAGE_MACRO_RX.exec(val)
+        if (!(match && isResourceRef(match[1]))) return
+        // Q should we allow image to be resolved relative to component version?
+        const image = contentCatalog.resolveResource(match[1], undefined, 'image', ['image'])
+        if (!image?.out) return
+        mergedAsciiDocAttributes[name] = `image:${image.out.path}[${match[2]}]`
+        auxiliaryImages.add(image)
+      })
+      const rootEntry = { content: title }
+      const { navigation, rootLevel } = assemblyModel
+      let startPage =
+        'startPage' in componentVersion
+          ? componentVersion.startPage
+          : contentCatalog.resolvePage('index.adoc', { component: componentName, version })
+      if (startPage && startPage.src.component === componentName && startPage.src.version === version) {
+        if (assemblyModel.insertStartPage) {
+          const navtitle = startPage.asciidoc?.navtitle || rootEntry.content
+          Object.assign(rootEntry, { navtitle, url: startPage.pub.url, urlType: 'internal' })
+        }
+      } else {
+        // Q: should we always use a reference page as startPage for computing mutableAttributes?
+        startPage = createAsciiDocFile(contentCatalog, {
+          src: {
+            component: componentVersion.name,
+            version: componentVersion.version,
+            module: 'ROOT',
+            family: 'page',
+            relative: '.start-page.adoc',
+            origin: (componentVersion.origins || [])[0],
+          },
+        })
+      }
+      const mutableAttributes = selectMutableAttributes(loadAsciiDoc, contentCatalog, startPage, mergedAsciiDocConfig)
+      delete mutableAttributes.doctype // Q: should this be in selectMutableAttributes?
+      prepareOutlines(navigation, rootEntry, rootLevel).reduce((any, outline) => {
+        const assemblyFile = produceAssemblyFile(
+          loadAsciiDoc,
+          contentCatalog,
+          componentVersion,
+          outline,
+          publishableFiles,
+          mergedAsciiDocConfig,
+          mutableAttributes,
+          assemblyModel
+        )
+        if (!assemblyFile) return any
+        if (!any && auxiliaryImages.size) {
+          const assembledAssets = assemblyFile.assembler.assembled.assets
+          auxiliaryImages.forEach((asset) => assembledAssets.add(asset))
+        }
+        accum.push(assemblyFile)
+        return true
+      }, false)
+      mergedAsciiDocAttributes.doctype = assemblyModel.doctype
+      sourceHighlighter
+        ? (mergedAsciiDocAttributes['source-highlighter'] = sourceHighlighter)
+        : delete mergedAsciiDocAttributes['source-highlighter']
+      return accum
+    },
+    []
+  )
+}
+
+function getAsciiDocConfigWithAsciidoctorReducerExtension (componentVersion) {
+  const asciidoctorReducerExtension = require('@asciidoctor/reducer') // NOTE: must be required lazily
+  const asciidocConfig = componentVersion.asciidoc
+  const extensions = [asciidoctorReducerExtension]
+  const configuredExtensions = asciidocConfig.extensions || []
+  if (!configuredExtensions.length) return Object.assign({}, asciidocConfig, { extensions, sourcemap: true })
+  return Object.assign({}, asciidocConfig, {
+    extensions: configuredExtensions.reduce((accum, candidate) => {
+      if (candidate !== asciidoctorReducerExtension) accum.push(candidate)
+      return accum
+    }, extensions),
+    sourcemap: true,
+  })
+}
+
+function includedInNav (items, url) {
+  return items.find((it) => it.url === url || includedInNav(it.items || [], url))
+}
+
+function isResourceRef (target) {
+  return ~target.indexOf(':') && !(~target.indexOf('://') || (target.startsWith('data:') && ~target.indexOf(',')))
+}
+
+function prepareOutlines (navigation, rootEntry, rootLevel) {
+  const singleEntry = navigation.length === 1
+  const items = navigation.reduce((accum, it) => {
+    if (!it.content || (singleEntry && it.url ? it.url === rootEntry.url : it.content === rootEntry.content)) {
+      accum.push(...it.items)
+    } else {
+      accum.push(it)
+    }
+    return accum
+  }, [])
+  if (rootLevel === 0) {
+    if (rootEntry.url && includedInNav(items, rootEntry.url)) {
+      for (const p of ['url', 'urlType']) delete rootEntry[p]
+    }
+    return [Object.assign(rootEntry, { index: true, items })]
+  }
+  if (rootEntry.url && !includedInNav(items, rootEntry.url)) {
+    rootEntry.content = singleEntry && rootEntry.url === navigation[0].url ? navigation[0].content : rootEntry.navtitle
+    items.unshift(rootEntry)
+  }
+  return items
+}
+
+module.exports = produceAssemblyFiles

package/lib/util/compute-out.js

@@ -0,0 +1,57 @@
+'use strict'
+
+const { posix: path } = require('node:path')
+
+function computeOut (src) {
+  const { component, version, module: module_, family, relative } = src
+  const outRelative = family === 'page' ? relative.replace(/\.adoc$/, '.html') : relative
+  const { dir: dirname, base: basename, ext: extname, name: stem } = path.parse(outRelative)
+  const componentVersion = this.getComponentVersion(component, version)
+  const versionSegment =
+    'activeVersionSegment' in componentVersion
+      ? componentVersion.activeVersionSegment
+      : resolveActiveVersionSegment.call(this, component, version)
+  const outDirSegments = []
+  const moduleRootPathSegments = []
+  if (component !== 'ROOT') outDirSegments.push(component)
+  if (versionSegment) outDirSegments.push(versionSegment)
+  if (module_ !== 'ROOT') outDirSegments.push(module_)
+  const outModuleDirSegments = outDirSegments.slice()
+  if (family !== 'page') {
+    outDirSegments.push(`_${family}s`)
+    moduleRootPathSegments.push('..')
+  }
+  if (dirname) {
+    outDirSegments.push(dirname)
+    for (const _ of dirname.split('/')) moduleRootPathSegments.push('..')
+  }
+  const rootPathSegments = moduleRootPathSegments.slice()
+  for (const _ of outModuleDirSegments) rootPathSegments.push('..')
+  const outDirname = outDirSegments.join('/')
+  const result = {
+    dirname: outDirname,
+    basename,
+    path: outDirname + '/' + basename,
+    moduleRootPath: moduleRootPathSegments.length ? moduleRootPathSegments.join('/') : '.',
+    rootPath: rootPathSegments.length ? rootPathSegments.join('/') : '.',
+  }
+  return result
+}
+
+function resolveActiveVersionSegment (component, version) {
+  let startPage = this.resolvePage('index.adoc', { component, version })
+  let startPageSrc
+  if (startPage) {
+    startPageSrc = startPage.src
+  } else {
+    startPageSrc = { component, version, module: 'ROOT', family: 'page', relative: 'index.adoc' }
+    this.removeFile((startPage = this.addFile({ src: startPageSrc })))
+  }
+  const outPathSegments = startPage.out.path.split('/')
+  for (const depth of startPage.out.moduleRootPath.split('/')) outPathSegments.pop()
+  if (startPageSrc.module !== 'ROOT') outPathSegments.pop()
+  if (startPageSrc.component !== 'ROOT') outPathSegments.shift()
+  return outPathSegments.length ? outPathSegments[0] : ''
+}
+
+module.exports = computeOut

package/lib/util/create-asciidoc-file.js

@@ -0,0 +1,18 @@
+'use strict'
+
+const computeOut = require('./compute-out')
+const { posix: path } = require('node:path')
+
+function createAsciiDocFile (contentCatalog, file) {
+  file.mediaType = 'text/asciidoc'
+  const src = file.src
+  const out = computeOut.call(contentCatalog, src)
+  if (src.family === 'export') {
+    contentCatalog.removeFile((file = contentCatalog.addFile(Object.assign(file, { path: out.path, out: null }))))
+    return file
+  }
+  const pub = { url: '/' + out.path, moduleRootPath: out.moduleRootPath, rootPath: out.rootPath }
+  return { contents: src.contents ?? Buffer.alloc(0), src, out, pub }
+}
+
+module.exports = createAsciiDocFile

package/lib/util/sanitize.js

@@ -5,11 +5,9 @@ const XML_SPECIAL_CHARS = { '&lt;': '<', '&gt;': '>', '&amp;': '&' }
 const XML_SPECIAL_CHARS_RX = /&(?:[lg]t|amp);/g
 
 function sanitize (str) {
-  return ~str.indexOf('<')
-    ? [str.replace(XML_TAG_RX, '').replace(XML_SPECIAL_CHARS_RX, (m) => XML_SPECIAL_CHARS[m]), `+++${str}+++`, true]
-    : ~str.indexOf('&')
-        ? Array(2).fill(str.replace(XML_SPECIAL_CHARS_RX, (m) => XML_SPECIAL_CHARS[m]))
-        : [str, str]
+  if (~str.indexOf('<')) str = str.replace(XML_TAG_RX, '')
+  if (~str.indexOf('&')) str = str.replace(XML_SPECIAL_CHARS_RX, (m) => XML_SPECIAL_CHARS[m])
+  return str
 }
 
 module.exports = sanitize

package/lib/util/unconvert-inline-asciidoc.js

@@ -0,0 +1,95 @@
+'use strict'
+
+const ATTRIBUTE_REFERENCE_RX = /\{[a-z0-9_][a-z0-9_-]*\}/g
+const STRICT_WORD_CHAR_RX = /[\p{L}\d_]/u
+const WORD_CHAR_RX = /[\p{L}\d_;}:<>]/u
+
+const MARK_FOR_TAG = { code: '`', em: '_', mark: '#', span: '#', strong: '*' }
+const SKIP_SPAN = { icon: '<i ', image: '<img ' }
+
+module.exports = (str) => {
+  if (!str) return str
+  let matchIndex = str.indexOf('<')
+  if (!~matchIndex) return ~str.indexOf('{') ? str.replace(ATTRIBUTE_REFERENCE_RX, '\\$&') : str
+  let current = { contents: '' }
+  const stack = [current]
+  let lastIndex = 0
+  do {
+    if (matchIndex > lastIndex) {
+      const matched = str.slice(lastIndex, matchIndex)
+      current.contents += ~matched.indexOf('{') ? matched.replace(ATTRIBUTE_REFERENCE_RX, '\\$&') : matched
+    }
+    const isCloseTag = str[++matchIndex] === '/' ? ++matchIndex : false
+    let tagName = str.slice(matchIndex, (lastIndex = str.indexOf('>', matchIndex) + 1) - 1)
+    if (isCloseTag) {
+      const parent = current // TODO expect tagName to equal current.tagName
+      stack.pop()
+      current = stack[stack.length - 1]
+      if (parent.mark) {
+        let { contents, mark, id, role } = parent
+        const attrlist = (id ? '#' + id : '') + (role ? '.' + role.replace(/ /g, '.') : '')
+        if (
+          current.mark === mark ||
+          current.mark === '_' ||
+          isWordChar(str.charAt(lastIndex), true) ||
+          isWordChar(current.contents[current.contents.length - 1] || current.mark)
+        ) {
+          mark = mark.repeat(2)
+        }
+        current.contents += (attrlist ? '[' + attrlist + ']' : '') + mark + contents + mark
+      } else {
+        current.contents += parent.contents
+      }
+    } else {
+      let attrs, attrlistIndex, role
+      if (~(attrlistIndex = tagName.indexOf(' '))) {
+        role = (attrs = parseAttrlist(tagName.slice(attrlistIndex))).class
+        tagName = tagName.slice(0, attrlistIndex)
+      }
+      if (tagName === 'img') {
+        current.contents += 'image:' + attrs.src + '[' + attrs.alt + ']'
+      } else if (tagName === 'i' && current.tagName === 'span' && current.role === 'icon') {
+        current.contents += 'icon:' + role.slice(6) + '[]'
+        lastIndex += 4
+      } else {
+        let check, mark
+        const id = attrs?.id
+        if (tagName !== 'span' || id || (role && !((check = SKIP_SPAN[role]) && str.startsWith(check, lastIndex)))) {
+          mark = MARK_FOR_TAG[tagName]
+        }
+        stack.push((current = { tagName, role, id, mark, contents: '' }))
+      }
+    }
+  } while (~(matchIndex = str.indexOf('<', lastIndex)))
+  const rest = str.slice(lastIndex)
+  if (rest) current.contents += ~rest.indexOf('{') ? rest.replace(ATTRIBUTE_REFERENCE_RX, '\\$&') : rest
+  return current.contents
+}
+
+function parseAttrlist (str) {
+  let lastIndex = 0
+  const attrs = {}
+  while (str.charAt(lastIndex++) === ' ') {
+    const spaceIndex = str.indexOf(' ', lastIndex)
+    const equalsIndex = str.indexOf('=', lastIndex)
+    if (~spaceIndex && spaceIndex < equalsIndex) {
+      attrs[str.slice(lastIndex, (lastIndex = spaceIndex))] = true
+    } else if (~equalsIndex) {
+      const name = str.slice(lastIndex, equalsIndex)
+      const valueIndex = equalsIndex + 1
+      attrs[name] =
+        str.charAt(valueIndex) === '"'
+          ? str.slice(valueIndex + 1, (lastIndex = str.indexOf('"', valueIndex + 1) + 1) - 1)
+          : str.slice(valueIndex, (lastIndex = ~spaceIndex ? spaceIndex : str.length))
+    } else {
+      attrs[str.slice(lastIndex)] = true
+      break
+    }
+  }
+  return attrs
+}
+
+function isWordChar (str, strict) {
+  if (!str) return false
+  return (strict ? STRICT_WORD_CHAR_RX : WORD_CHAR_RX).test(str)
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@antora/assembler",
-  "version": "1.0.0-alpha.8",
-  "description": "An extension library for Antora that assembles content from multiple pages into a single AsciiDoc file to converted and publish.",
+  "version": "1.0.0-beta.1",
+  "description": "A JavaScript library that merges AsciiDoc content from multiple pages in an Antora site into assembly files and delegates to an exporter to convert those files to another format, such as PDF.",
   "license": "MPL-2.0",
   "author": "OpenDevise Inc. (https://opendevise.com)",
   "contributors": [
@@ -9,34 +9,42 @@
     "Sarah White <sarah@opendevise.com>"
   ],
   "homepage": "https://antora.org",
-  "repository": "gitlab:antora/antora-assembler",
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitlab.com/antora/antora-assembler.git",
+    "directory": "packages/assembler"
+  },
   "bugs": {
     "url": "https://gitlab.com/antora/antora-assembler/issues"
   },
   "scripts": {
-    "test": "_mocha test",
+    "test": "node --test test/*-test.js",
     "prepublishOnly": "npx -y downdoc --prepublish",
     "postpublish": "npx -y downdoc --postpublish"
   },
   "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",
-    "./produce-aggregate-documents": "./lib/produce-aggregate-documents.js",
+    "./produce-assembly-file": "./lib/produce-assembly-file.js",
+    "./produce-assembly-files": "./lib/produce-assembly-files.js",
     "./select-mutable-attributes": "./lib/select-mutable-attributes.js"
   },
+  "imports": {
+    "#run-command": "@antora/run-command-helper",
+    "#unconvert-inline-asciidoc": "./lib/util/unconvert-inline-asciidoc.js"
+  },
   "dependencies": {
-    "@antora/expand-path-helper": "~2.0",
+    "@asciidoctor/reducer": "~1.1",
+    "@antora/expand-path-helper": "~3.0",
     "braces": "~3.0",
     "picomatch": "~3.0",
-    "vinyl": "~2.2",
     "js-yaml": "~4.1"
   },
   "devDependencies": {
     "@antora/asciidoc-loader": "~3.1",
+    "@antora/navigation-builder": "~3.1",
     "@antora/site-publisher": "~3.1"
   },
   "engines": {
@@ -50,8 +58,5 @@
     "antora-extension",
     "asciidoc",
     "documentation"
-  ],
-  "publishConfig": {
-    "access": "public"
-  }
+  ]
 }

package/lib/asciidoctor/reducer-extension.js

@@ -1,235 +0,0 @@
-'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
-    let offset = lineno > 1 ? lineno - 1 : 0
-    const result = Opal.send(this, Opal.find_super_dispatcher(this, 'push_include', pushInclude), [
-      data,
-      file,
-      path,
-      lineno,
-      attrs,
-    ])
-    let incLines = []
-    if (this.include_stack.length > prevIncDepth) {
-      incLines = this.$lines()
-      if (attrs['$key?']('leveloffset') && incLines[0].startsWith(':leveloffset: ') && incLines[1] === '') offset -= 2
-    }
-    pushIncludeReplacement.call(this, directiveLineno, incLines, offset)
-    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 extra assurance that the program is replacing the correct line
-            if (targetLines[(idx = lineno - 1)] !== line) {
-              const msg = `include directive to reduce not found; expected: "${line}"; got: "${targetLines[idx]}"`
-              doc.getLogger().error(msg)
-              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)
-}