@antora/assembler 1.0.0-beta.9 → 1.0.0-rc.10

package/lib/util/parse-resource-ref.js

@@ -0,0 +1,36 @@
+'use strict'
+
+function parseResourceRef (ref, ctx = {}, family = undefined, contentCatalog = undefined) {
+  const atIdx = ref.indexOf('@')
+  let firstColonIdx = ref.indexOf(':')
+  let component, version, module_
+  if (~atIdx && (~firstColonIdx ? atIdx < firstColonIdx : true)) {
+    if ((version = ref.substring(0, atIdx)) === '_') version = ''
+    ref = ref.substring(atIdx + 1)
+    if (~firstColonIdx) firstColonIdx -= atIdx + 1
+  }
+  const addColons = ~firstColonIdx ? (~ref.indexOf(':', firstColonIdx + 1) ? '' : ':') : '::'
+  const segments = (addColons + ref).split(':')
+  if ((component = segments[0])) {
+    module_ = segments[1] || 'ROOT'
+    version ??= contentCatalog?.getComponent(component)?.latest.version
+  } else {
+    component = ctx.component
+    version ??= ctx.version
+    module_ = segments[1] || ctx.module || 'ROOT'
+  }
+  let relative = segments.length > 3 ? segments.slice(2).join(':') : segments[2]
+  const dollarIdx = relative.indexOf('$')
+  if (~dollarIdx) {
+    family = relative.substring(0, dollarIdx) || family
+    relative = relative.substring(dollarIdx + 1)
+  }
+  if (relative.charAt() === '.' && relative.charAt(1) === '/') {
+    const ctxRelative = ctx.relative
+    const topic = ctxRelative ? ctxRelative.substring(0, (ctxRelative.lastIndexOf('/') + 1 || 1) - 1) : undefined
+    relative = (topic ? topic + '/' : '') + relative.substring(2)
+  }
+  return { component, version, module: module_, family, relative }
+}
+
+module.exports = parseResourceRef

package/lib/util/resolver.js

@@ -0,0 +1,36 @@
+'use strict'
+
+const path = require('node:path/posix')
+
+function resolveEmbedTarget (resource, outDirname, referenceStyle, escapeForInline) {
+  const target =
+    referenceStyle === 'output-relative' ? resource.out.path : path.relative(outDirname + '/', resource.out.path)
+  return escapeForInline ? target.replace(/_/g, '{underscore}') : target
+}
+
+function resolveLinkTarget (resource, siteRoot, pubRoot, referenceStyle, escapeForInline, ensurePrefix = true) {
+  let target
+  if (resource.site?.url) {
+    target = ['', resource.pub.url]
+  } else {
+    switch (referenceStyle) {
+      case 'absolute':
+        target = ['', siteRoot.url + resource.pub.url]
+        break
+      case 'root-relative':
+        target = [ensurePrefix ? 'link:' : '', siteRoot.path + resource.pub.url]
+        break
+      default:
+        target = [ensurePrefix ? 'link:' : '', computeRelativeUrl(pubRoot + '/', resource.pub.url)]
+    }
+  }
+  if (escapeForInline) target[1] = target[1].replace(/_/g, '{underscore}')
+  return target.join('')
+}
+
+function computeRelativeUrl (from, to) {
+  const rel = path.relative(from, to)
+  return to.charAt(to.length - 1) === '/' ? rel + '/' : rel
+}
+
+module.exports = { resolveEmbedTarget, resolveLinkTarget }

package/lib/util/rewriter.js

@@ -0,0 +1,231 @@
+'use strict'
+
+const createResourceKey = require('./create-resource-key')
+const generateScopedId = require('./generate-scoped-id')
+const parseResourceRef = require('./parse-resource-ref')
+const { resolveEmbedTarget, resolveLinkTarget } = require('./resolver')
+const toHash = require('./to-hash')
+
+const { NAMED_ID_ATTR_RX } = require('./rx')
+
+function rewriteXrefs (
+  line,
+  contentCatalog,
+  assemblyModel,
+  ctx,
+  escapeForInline,
+  pagesInOutline,
+  idSeparators,
+  idLeader,
+  doc,
+  sourceLocation
+) {
+  return line.replace(/(?<![\\+])xref:((?:\.\/|:)?[\p{Alpha}0-9_/.{#].*?)\[(|[\s\S]*?[^\\])\]/gu, (_, target, text) =>
+    rewriteXref(
+      target,
+      text,
+      contentCatalog,
+      assemblyModel,
+      ctx,
+      escapeForInline,
+      pagesInOutline,
+      idSeparators,
+      idLeader,
+      doc,
+      sourceLocation
+    )
+  )
+}
+
+function rewriteXref (
+  target,
+  text,
+  contentCatalog,
+  assemblyModel,
+  ctx,
+  escapeForInline,
+  pagesInOutline,
+  idSeparators,
+  idLeader,
+  doc,
+  sourceLocation
+) {
+  const rawTarget = target
+  if (sourceLocation && ~target.indexOf('{')) {
+    target = doc.$sub_attributes(target, toHash({ attribute_missing: 'skip' }))
+  }
+  let fragment, resourceRef
+  const hashIdx = target.indexOf('#')
+  if (~hashIdx) {
+    resourceRef = target.substring(0, hashIdx)
+    fragment = target.substring(hashIdx + 1)
+  } else if (target.endsWith('.adoc') || ~target.indexOf('$')) {
+    resourceRef = target
+    fragment = ''
+  } else {
+    fragment = target
+  }
+  if (!resourceRef) return `xref:${idLeader == null ? rawTarget : idLeader + fragment}[${text}]`
+  let resourceId = parseResourceRef(resourceRef, ctx, 'page', contentCatalog)
+  const family = resourceId.family
+  let resource
+  if (family === 'page' && !contentCatalog.getById(resourceId)) {
+    if ((resource = contentCatalog.getById(Object.assign({}, resourceId, { family: 'alias' })))) {
+      resourceId = resource.rel.src
+    }
+  }
+  if (family !== 'page' || !(resource = pagesInOutline?.get(createResourceKey(resourceId)))) {
+    let defaultText
+    if ((resource = contentCatalog.getById(resourceId))?.pub) {
+      const { linkReferenceStyle, pubRoot, siteRoot } = assemblyModel
+      defaultText = resource.asciidoc?.xreftext || rawTarget
+      if (siteRoot || linkReferenceStyle === 'relative') {
+        const hash = fragment && !(family === 'page' && fragment === resource.asciidoc.id) ? '#' + fragment : ''
+        const linkTarget = resolveLinkTarget(resource, siteRoot, pubRoot, linkReferenceStyle, escapeForInline)
+        return `${linkTarget}${hash}[${updateAttrlist(doc, text, defaultText)}]`
+      }
+      if (sourceLocation) {
+        const msg = `Cannot create external ${family} reference in assembly because site URL is unknown: ${rawTarget}`
+        doc.getLogger().warn(doc.createLogMessage(msg, { source_location: sourceLocation }))
+      }
+    } else if (~target.indexOf(':')) {
+      defaultText = rawTarget // use explicit text so AsciiDoc processor displays it correctly
+    }
+    const linkAttrlist = updateAttrlist(doc, text, defaultText, 'unresolved')
+    return `link:${rawTarget.charAt() === ':' ? resourceId.module + rawTarget : rawTarget}[${linkAttrlist}]`
+  }
+  if (fragment === resource.asciidoc.id) fragment = ''
+  if (
+    text &&
+    (assemblyModel.dropExplicitXrefText === 'always' ||
+      (assemblyModel.dropExplicitXrefText === 'if-redundant' && text === resource.title))
+  ) {
+    text = ''
+  }
+  const componentVersionCtx = { name: ctx.component, version: ctx.version }
+  const refid = generateScopedId(
+    resource.src,
+    componentVersionCtx,
+    idSeparators,
+    assemblyModel.filetype,
+    text.length > 0
+  )
+  return `xref:${fragment ? refid + idSeparators.scope + fragment : refid}[${text}]`
+}
+
+function rewriteImageAttr (val, contentCatalog, assemblyModel, ctx, assets) {
+  const match = val.startsWith('image:') && /^image::?(.+?)\[(.*?)\](@|)$/.exec(val)
+  if (!match) return
+  const newTarget = rewriteImageRef(match[1], contentCatalog, assemblyModel, ctx, assets)
+  return newTarget ? `image:${newTarget}[${match[2]}]${match[3]}` : val
+}
+
+function rewriteInlineImages (line, contentCatalog, assemblyModel, ctx, assets, escapeForInline, doc) {
+  return line.replace(/(?<![\\+])image:([^:\s[](?:[^[]*[^\s[])?)\[(|[\s\S]*?[^\\])\]/g, (m, target, attrlist) => {
+    const newTarget = rewriteImageRef(target, contentCatalog, assemblyModel, ctx, assets, escapeForInline, doc)
+    return newTarget ? `image:${newTarget}[${attrlist}]` : m
+  })
+}
+
+function rewriteImageRef (target, contentCatalog, assemblyModel, ctx, assets, escapeForInline, doc) {
+  if (doc && ~target.indexOf('{')) target = doc.$sub_attributes(target, toHash({ attribute_missing: 'skip' }))
+  const image = isResourceRef(target) && contentCatalog.resolveResource(target, ctx, 'image', ['image'])
+  if (!image?.out) return
+  let newTarget
+  const { filetype, embedReferenceStyle, linkReferenceStyle, outDirname, pubRoot, siteRoot } = assemblyModel
+  if (filetype !== 'html') {
+    newTarget = resolveEmbedTarget(image, outDirname, embedReferenceStyle, escapeForInline ?? false)
+    assets.add(image)
+  } else if (siteRoot || linkReferenceStyle === 'relative') {
+    newTarget = resolveLinkTarget(image, siteRoot, pubRoot, linkReferenceStyle, escapeForInline ?? false, false)
+    if (linkReferenceStyle === 'relative') assets.add(image)
+  }
+  return newTarget
+}
+
+function rewriteStyleAttribute (block, lines, idx, idLeader, 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, idLeader, replacementStyle)
+    }
+  }
+  let cellSpec
+  const blockId = block.getId()
+  if (
+    char0 &&
+    (char0 === '[' || (block.getDocument().isNested() && (cellSpec = prevLine.match(/^([^[|]*)\| *(\[.+)/)))) &&
+    prevLine.charAt(prevLine.length - 1) === ']'
+  ) {
+    if (cellSpec) {
+      prevLine = cellSpec[2]
+      cellSpec = cellSpec[1]
+    } else if (~prevLine.indexOf('id=')) {
+      prevLine = `[${prevLine.substring(1, prevLine.length - 1).replace(NAMED_ID_ATTR_RX, '')}]`
+    }
+    let rawStyle
+    const commaIdx = prevLine.indexOf(',')
+    if (~commaIdx) {
+      rawStyle = prevLine.substring(1, commaIdx)
+      if (~rawStyle.indexOf('=')) rawStyle = undefined
+    } else if (!~prevLine.indexOf('=')) {
+      rawStyle = prevLine.substring(1, prevLine.length - 1)
+    }
+    if (rawStyle) {
+      if (~rawStyle.indexOf('#')) {
+        prevLine = prevLine.replace(/#[^.%,\]]+/, `#${idLeader}${blockId}`)
+        if (replacementStyle) prevLine = prevLine.replace(/^[^#.%,\]]+/, `[${replacementStyle}`)
+      } else {
+        prevLine = `[${
+          replacementStyle ? rawStyle.replace(/^[^.%]*/, replacementStyle) : rawStyle
+        }#${idLeader}${blockId}${prevLine.substring(rawStyle.length + 1)}`
+      }
+    } else {
+      prevLine = `[${replacementStyle}#${idLeader}${blockId}${rawStyle == null ? ',' : ''}${prevLine.substring(1)}`
+    }
+    if (cellSpec) prevLine = `${cellSpec}|${prevLine}`
+    lines[idx - 1] = prevLine
+  } else {
+    lines.splice(idx, 0, `[${replacementStyle}#${idLeader}${blockId}]`)
+  }
+}
+
+function isResourceRef (str) {
+  return !(~str.indexOf(':') && (~str.indexOf('://') || (str.startsWith('data:') && ~str.indexOf(','))))
+}
+
+function updateAttrlist (doc, attrlist, defaultText, role) {
+  const attrs = { named: {}, pos: [] }
+  if (attrlist) {
+    const normalize = ~attrlist.indexOf('\n')
+    if (normalize) attrlist = attrlist.replace(/\n/g, '\x1e')
+    doc
+      .$parse_attributes(attrlist)
+      .$entries()
+      .forEach(([k, v]) => {
+        v = v['$nil?']() ? '' : normalize ? v.replace(/\x1e/g, '\n') : v
+        typeof k === 'number' ? attrs.pos.push(v) : (attrs.named[k] = v)
+      })
+  }
+  if (defaultText) attrs.pos[0] ||= defaultText
+  if (role) attrs.named.role = (attrs.named.role ? attrs.named.role + ' ' : '') + role
+  const entries = []
+  for (const v of attrs.pos) entries.push(~v.indexOf(',') || ~v.indexOf('=') ? `"${v}"` : v)
+  for (const [k, v] of Object.entries(attrs.named)) entries.push(`${k}=` + (~v.indexOf(',') ? `"${v}"` : v))
+  return entries.join(',')
+}
+
+module.exports = {
+  rewriteXref,
+  rewriteXrefs,
+  rewriteImageAttr,
+  rewriteImageRef,
+  rewriteInlineImages,
+  rewriteStyleAttribute,
+}

package/lib/util/rx.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const NAMED_ID_ATTR_RX = /(?:^|, *)id=(?:("[^"]*"|'[^']*'|[^,]*))/
+
+module.exports = { NAMED_ID_ATTR_RX }

package/lib/util/to-hash.js

@@ -0,0 +1,7 @@
+'use strict'
+
+function toHash (obj = {}) {
+  return global.Opal.hash(obj)
+}
+
+module.exports = toHash

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

@@ -3,6 +3,8 @@
 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 XML_SPECIAL_CHARS = { '&lt;': '<', '&gt;': '>', '&amp;': '&' }
+const XML_SPECIAL_CHARS_RX = /&(?:[lg]t|amp);/g
 
 const MARK_FOR_TAG = { code: '`', em: '_', mark: '#', span: '#', strong: '*' }
 const SKIP_SPAN = { icon: '<i ', image: '<img ' }
@@ -10,17 +12,17 @@ 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
+  if (!~matchIndex) return unconvertNonTag(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 matched = str.substring(lastIndex, matchIndex)
+      current.contents += unconvertNonTag(matched)
     }
     const isCloseTag = str[++matchIndex] === '/' ? ++matchIndex : false
-    let tagName = str.slice(matchIndex, (lastIndex = str.indexOf('>', matchIndex) + 1) - 1)
+    let tagName = str.substring(matchIndex, (lastIndex = str.indexOf('>', matchIndex) + 1) - 1)
     if (isCloseTag) {
       const parent = current // TODO expect tagName to equal current.tagName
       stack.pop()
@@ -43,13 +45,13 @@ module.exports = (str) => {
     } else {
       let attrs, attrlistIndex, role
       if (~(attrlistIndex = tagName.indexOf(' '))) {
-        role = (attrs = parseAttrlist(tagName.slice(attrlistIndex))).class
-        tagName = tagName.slice(0, attrlistIndex)
+        role = (attrs = parseAttrlist(tagName.substring(attrlistIndex))).class
+        tagName = tagName.substring(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) + '[]'
+        current.contents += 'icon:' + role.substring(6) + '[]'
         lastIndex += 4
       } else {
         let check, mark
@@ -61,8 +63,8 @@ module.exports = (str) => {
       }
     }
   } while (~(matchIndex = str.indexOf('<', lastIndex)))
-  const rest = str.slice(lastIndex)
-  if (rest) current.contents += ~rest.indexOf('{') ? rest.replace(ATTRIBUTE_REFERENCE_RX, '\\$&') : rest
+  const rest = str.substring(lastIndex)
+  if (rest) current.contents += unconvertNonTag(rest)
   return current.contents
 }
 
@@ -73,16 +75,16 @@ function parseAttrlist (str) {
     const spaceIndex = str.indexOf(' ', lastIndex)
     const equalsIndex = str.indexOf('=', lastIndex)
     if (~spaceIndex && spaceIndex < equalsIndex) {
-      attrs[str.slice(lastIndex, (lastIndex = spaceIndex))] = true
+      attrs[str.substring(lastIndex, (lastIndex = spaceIndex))] = true
     } else if (~equalsIndex) {
-      const name = str.slice(lastIndex, equalsIndex)
+      const name = str.substring(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))
+          ? str.substring(valueIndex + 1, (lastIndex = str.indexOf('"', valueIndex + 1) + 1) - 1)
+          : str.substring(valueIndex, (lastIndex = ~spaceIndex ? spaceIndex : str.length))
     } else {
-      attrs[str.slice(lastIndex)] = true
+      attrs[str.substring(lastIndex)] = true
       break
     }
   }
@@ -93,3 +95,9 @@ function isWordChar (str, strict) {
   if (!str) return false
   return (strict ? STRICT_WORD_CHAR_RX : WORD_CHAR_RX).test(str)
 }
+
+function unconvertNonTag (str) {
+  if (~str.indexOf('{')) str = str.replace(ATTRIBUTE_REFERENCE_RX, '\\$&')
+  if (~str.indexOf('&')) str = str.replace(XML_SPECIAL_CHARS_RX, (m) => XML_SPECIAL_CHARS[m])
+  return str
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antora/assembler",
-  "version": "1.0.0-beta.9",
+  "version": "1.0.0-rc.10",
   "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)",
@@ -19,38 +19,38 @@
   },
   "scripts": {
     "test": "node --test test/*-test.js",
-    "prepublishOnly": "npx -y downdoc --prepublish",
-    "postpublish": "npx -y downdoc --postpublish"
+    "prepublishOnly": "npx -y downdoc@latest --prepublish",
+    "postpublish": "npx -y downdoc@latest --postpublish"
   },
   "main": "lib/index.js",
   "exports": {
     ".": "./lib/index.js",
     "./filter-component-versions": "./lib/filter-component-versions.js",
     "./load-config": "./lib/load-config.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"
+    "./package.json": "./package.json"
   },
   "imports": {
-    "#run-command": "@antora/run-command-helper",
+    "#asciidoctor-log-adapter": "./adapters/asciidoctor/jsonl-logger.rb",
+    "#identify-mutable-attributes": "./lib/util/identify-mutable-attributes.js",
+    "#produce-assembly-files": "./lib/produce-assembly-files.js",
     "#unconvert-inline-asciidoc": "./lib/util/unconvert-inline-asciidoc.js"
   },
   "dependencies": {
-    "@asciidoctor/reducer": "~1.1",
     "@antora/expand-path-helper": "~3.0",
-    "braces": "~3.0",
-    "picomatch": "~3.0",
-    "js-yaml": "~4.1"
+    "@antora/run-command-helper": "~1.1",
+    "@asciidoctor/reducer": "~1.1",
+    "js-yaml": "~5.3"
   },
   "devDependencies": {
-    "@antora/asciidoc-loader": "~3.1",
-    "@antora/navigation-builder": "~3.1",
-    "@antora/site-publisher": "~3.1"
+    "@antora/asciidoc-loader": "3.2.0-rc.3",
+    "@antora/navigation-builder": "3.2.0-rc.3",
+    "@antora/site-publisher": "3.2.0-rc.3"
   },
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=20.0.0"
   },
   "files": [
+    "adapters/",
     "lib/"
   ],
   "keywords": [

package/lib/select-mutable-attributes.js

@@ -1,26 +0,0 @@
-'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/compute-out.js

@@ -1,57 +0,0 @@
-'use strict'
-
-const { posix: path } = require('node:path')
-
-function computeOut (src) {
-  const { component, version, module: module_ = 'ROOT', family, relative } = src
-  const outRelative = family === 'page' ? relative.replace(/\.adoc$/, '.html') : relative
-  const { dir: dirname, base: basename } = 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 _ 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

@@ -1,17 +0,0 @@
-'use strict'
-
-const computeOut = require('./compute-out')
-
-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