@antora/content-aggregator 3.1.9 → 3.1.11

package/lib/aggregate-content.js

@@ -1,32 +1,32 @@
 'use strict'
 
 const computeOrigin = require('./compute-origin')
-const { createHash } = require('crypto')
+const { createHash } = require('node:crypto')
 const createGitHttpPlugin = require('./git-plugin-http')
 const decodeUint8Array = require('./decode-uint8-array')
 const deepClone = require('./deep-clone')
-const EventEmitter = require('events')
+const EventEmitter = require('node:events')
 const expandPath = require('@antora/expand-path-helper')
 const File = require('./file')
 const filterRefs = require('./filter-refs')
-const fs = require('fs')
+const fs = require('node:fs')
 const { promises: fsp } = fs
 const getCacheDir = require('cache-directory')
 const GitCredentialManagerStore = require('./git-credential-manager-store')
 const git = require('./git')
 const { NotFoundError, ObjectTypeError, UnknownTransportError, UrlParseError } = git.Errors
 const { globStream } = require('fast-glob')
-const { inspect } = require('util')
+const { inspect } = require('node:util')
 const invariably = require('./invariably')
 const logger = require('./logger')
 const { makeMatcherRx, versionMatcherOpts: VERSION_MATCHER_OPTS } = require('./matcher')
 const MultiProgress = require('multi-progress') // calls require('progress') as a peer dependencies
-const ospath = require('path')
+const ospath = require('node:path')
 const { posix: path } = ospath
 const posixify = require('./posixify')
 const removeGitSuffix = require('./remove-git-suffix')
 const { fs: resolvePathGlobsFs, git: resolvePathGlobsGit } = require('./resolve-path-globs')
-const { pipeline, Writable } = require('stream')
+const { pipeline, Writable } = require('node:stream')
 const forEach = (write) => new Writable({ objectMode: true, write })
 const userRequire = require('@antora/user-require-helper')
 const yaml = require('js-yaml')
@@ -100,21 +100,22 @@ function aggregateContent (playbook) {
     const sourcesByUrl = sources.reduce((accum, source) => {
       return accum.set(source.url, [...(accum.get(source.url) || []), Object.assign({}, sourceDefaults, source)])
     }, new Map())
-    const progress = !quiet && createProgress(sourcesByUrl.keys(), process.stdout)
+    const progress = quiet ? undefined : createProgress(sourcesByUrl.keys(), process.stdout)
     const refPatternCache = Object.assign(new Map(), { braces: new Map() })
-    const loadOpts = { cacheDir, fetch, gitPlugins, progress, startDir, refPatternCache }
+    const fetchConfig = { always: fetch, depth: Math.max(0, gitConfig.fetchDepth ?? 1) }
+    const loadOpts = { cacheDir, fetch: fetchConfig, gitPlugins, progress, startDir, refPatternCache }
     return collectFiles(sourcesByUrl, loadOpts, concurrency).then(buildAggregate, (err) => {
-      progress && progress.terminate()
+      progress?.terminate()
       throw err
     })
   })
 }
 
-async function collectFiles (sourcesByUrl, loadOpts, concurrency, fetchedUrls) {
+async function collectFiles (sourcesByUrl, loadOpts, concurrency, fetchedUrls = []) {
   const loadTasks = [...sourcesByUrl.entries()].map(([url, sources]) => {
     const loadOptsForUrl = Object.assign({}, loadOpts)
-    if (loadOpts.fetch && fetchedUrls && fetchedUrls.length && fetchedUrls.includes(url)) loadOptsForUrl.fetch = false
-    if (tagsSpecified(sources)) loadOptsForUrl.fetchTags = true
+    if (loadOpts.fetch.always && fetchedUrls.length && fetchedUrls.includes(url)) loadOptsForUrl.fetch.always = false
+    if (tagsSpecified(sources)) loadOptsForUrl.fetch.tags = true
     return loadRepository.bind(null, url, loadOptsForUrl, { url, sources })
   })
   return gracefulPromiseAllWithLimit(loadTasks, concurrency.fetch).then(([results, rejections]) => {
@@ -124,7 +125,7 @@ async function collectFiles (sourcesByUrl, loadOpts, concurrency, fetchedUrls) {
         const msg0 = 'An unexpected error occurred while fetching content sources concurrently.'
         const msg1 = 'Retrying with git.fetch_concurrency value of 1.'
         logger.warn(rejections[0], msg0 + ' ' + msg1)
-        const fulfilledUrls = results.map((it) => it && it.repo.url && it.url).filter((it) => it)
+        const fulfilledUrls = results.filter((it) => it?.repo.url).map((it) => it.url)
         return collectFiles(sourcesByUrl, loadOpts, Object.assign(concurrency, { fetch: 1 }), fulfilledUrls)
       }
       throw rejections[0]
@@ -163,7 +164,7 @@ async function loadRepository (url, opts, result = {}) {
   if (~url.indexOf(':') && GIT_URI_DETECTOR_RX.test(url)) {
     let credentials, displayUrl
     ;({ displayUrl, url, credentials } = extractCredentials(url))
-    const { cacheDir, fetch, fetchTags, gitPlugins, progress } = opts
+    const { cacheDir, fetch, gitPlugins, progress } = opts
     dir = ospath.join(cacheDir, generateCloneFolderName(displayUrl))
     // NOTE the presence of the url property on the repo object implies the repository is remote
     repo = { cache, dir, fs, gitdir: dir, noCheckout: true, url }
@@ -171,9 +172,9 @@ async function loadRepository (url, opts, result = {}) {
     const validStateFile = ospath.join(dir, VALID_STATE_FILENAME)
     try {
       await fsp.access(validStateFile)
-      if (fetch) {
+      if (fetch.always) {
         await fsp.unlink(validStateFile)
-        const fetchOpts = buildFetchOptions(repo, progress, displayUrl, credentials, gitPlugins, fetchTags, 'fetch')
+        const fetchOpts = buildFetchOptions(repo, progress, displayUrl, credentials, gitPlugins, fetch, 'fetch')
         await git
           .fetch(fetchOpts)
           .then(() => {
@@ -181,19 +182,19 @@ async function loadRepository (url, opts, result = {}) {
             return git.setConfig(Object.assign({ path: 'remote.origin.private', value: authStatus }, repo))
           })
           .catch((fetchErr) => {
-            if (fetchOpts.onProgress) fetchOpts.onProgress.finish(fetchErr)
+            fetchOpts.onProgress?.finish(fetchErr)
             if (HTTP_ERROR_CODE_RX.test(fetchErr.code) && fetchErr.data.statusCode === 401) fetchErr.rethrow = true
             throw fetchErr
           })
           .then(() => fsp.writeFile(validStateFile, '').catch(invariably.void))
-          .then(() => fetchOpts.onProgress && fetchOpts.onProgress.finish())
+          .then(() => fetchOpts.onProgress?.finish())
       } else {
         authStatus = await git.getConfig(Object.assign({ path: 'remote.origin.private' }, repo))
       }
     } catch (gitErr) {
       await fsp['rm' in fsp ? 'rm' : 'rmdir'](dir, { recursive: true, force: true })
       if (gitErr.rethrow) throw transformGitCloneError(gitErr, displayUrl)
-      const fetchOpts = buildFetchOptions(repo, progress, displayUrl, credentials, gitPlugins, fetchTags, 'clone')
+      const fetchOpts = buildFetchOptions(repo, progress, displayUrl, credentials, gitPlugins, fetch, 'clone')
       await git
         .clone(fetchOpts)
         .then(() => git.resolveRef(Object.assign({ ref: 'HEAD', depth: 1 }, repo)))
@@ -202,16 +203,23 @@ async function loadRepository (url, opts, result = {}) {
           return git.setConfig(Object.assign({ path: 'remote.origin.private', value: authStatus }, repo))
         })
         .catch((cloneErr) => {
-          if (fetchOpts.onProgress) fetchOpts.onProgress.finish(cloneErr)
+          fetchOpts.onProgress?.finish(cloneErr)
           const authRequested = credentialManager.status({ url }) === 'requested'
           throw transformGitCloneError(cloneErr, displayUrl, authRequested)
         })
         .then(() => fsp.writeFile(validStateFile, '').catch(invariably.void))
-        .then(() => fetchOpts.onProgress && fetchOpts.onProgress.finish())
+        .then(() => fetchOpts.onProgress?.finish())
     }
   } else if (await isDirectory((dir = expandPath(url, { dot: opts.startDir })))) {
-    const gitdir = ospath.join(dir, '.git')
-    repo = (await isDirectory(gitdir)) ? { cache, dir, fs, gitdir } : { cache, dir, fs, gitdir: dir, noCheckout: true }
+    const dotgit = ospath.join(dir, '.git')
+    const dotgitStat = await fsp.stat(dotgit).catch(() => ({ isFile: invariably.false, isDirectory: invariably.false }))
+    if (dotgitStat.isDirectory()) {
+      repo = { cache, dir, fs, gitdir: dotgit }
+    } else if (dotgitStat.isFile()) {
+      repo = await resolveRepositoryFromWorktree({ cache, dir, fs, gitdir: dotgit })
+    } else {
+      repo = { cache, dir, fs, gitdir: dir, noCheckout: true }
+    }
     try {
       await git.resolveRef(Object.assign({ ref: 'HEAD', depth: 1 }, repo))
     } catch {
@@ -236,11 +244,9 @@ function extractCredentials (url) {
     // NOTE if only username is present, assume it's an oauth token and set password to empty string
     const credentials = username ? { username, password: password || '' } : {}
     return { displayUrl, url, credentials }
-  } else if (url.startsWith('git@')) {
-    return { displayUrl: url, url: 'https://' + url.substr(4).replace(':', '/') }
-  } else {
-    return { displayUrl: url, url }
   }
+  if (url.startsWith('git@')) return { displayUrl: url, url: 'https://' + url.substr(4).replace(':', '/') }
+  return { displayUrl: url, url }
 }
 
 async function selectStartPathsForRepository (repo, authStatus, sources) {
@@ -248,14 +254,27 @@ async function selectStartPathsForRepository (repo, authStatus, sources) {
   const originUrls = {}
   for (const source of sources) {
     const { version, editUrl } = source
-    // NOTE if repository is managed (has a url property), we can assume the remote name is origin
-    // TODO if the repo has no remotes, then remoteName should be undefined
-    const remoteName = repo.url ? 'origin' : source.remote || 'origin'
-    const originUrl = repo.url || (originUrls[remoteName] ||= await resolveRemoteUrl(repo, remoteName))
+    let remoteName, originUrl
+    if (repo.url) {
+      remoteName = 'origin' // NOTE if repository is managed (has url property), we can assume remote name is origin
+      originUrl = repo.url
+    } else {
+      remoteName = source.remote || 'origin'
+      originUrl =
+        remoteName in originUrls
+          ? originUrls[remoteName]
+          : (originUrls[remoteName] = await resolveRemoteUrl(repo, remoteName))
+      if (!originUrl) {
+        remoteName = undefined
+        if ((originUrl = posixify ? 'file:///' + posixify(repo.dir) : 'file://' + repo.dir).indexOf(' ')) {
+          originUrl = originUrl.replace(SPACE_RX, '%20')
+        }
+      }
+    }
     const refs = await selectReferences(source, repo, remoteName)
     if (refs.length) {
       for (const ref of refs) {
-        for (const startPath of await selectStartPaths(source, repo, remoteName, ref)) {
+        for (const startPath of await selectStartPaths(source, repo, ref)) {
           startPaths.push({ startPath, ref, originUrl, editUrl, version })
         }
       }
@@ -274,7 +293,7 @@ async function selectStartPathsForRepository (repo, authStatus, sources) {
 
 // QUESTION should we resolve HEAD to a ref eagerly to avoid having to do a match on it?
 async function selectReferences (source, repo, remote) {
-  let { branches: branchPatterns, tags: tagPatterns, worktrees: worktreePatterns = '.' } = source
+  let { branches: branchPatterns, tags: tagPatterns, worktrees: worktreePatterns } = source
   const managed = 'url' in repo
   const isBare = managed || repo.noCheckout
   const patternCache = repo.cache[REF_PATTERN_CACHE_KEY]
@@ -294,7 +313,16 @@ async function selectReferences (source, repo, remote) {
       }
     }
   }
-  if (!branchPatterns) return [...refs.values()]
+  if (
+    !branchPatterns ||
+    !(branchPatterns = Array.isArray(branchPatterns)
+      ? branchPatterns.map((pattern) => String(pattern))
+      : splitRefPatterns(String(branchPatterns))).length
+  ) {
+    return [...refs.values()]
+  }
+  const worktreeName = repo.worktreeName // possibly switch to worktree property ({ name, dir}) in future
+  if (worktreeName) branchPatterns = branchPatterns.map((it) => (it === 'HEAD' ? 'HEAD@' + worktreeName : it))
   if (worktreePatterns) {
     if (worktreePatterns === '.') {
       worktreePatterns = ['.']
@@ -304,14 +332,14 @@ async function selectReferences (source, repo, remote) {
       worktreePatterns = Array.isArray(worktreePatterns)
         ? worktreePatterns.map((pattern) => String(pattern))
         : splitRefPatterns(String(worktreePatterns))
+      if (worktreeName) worktreePatterns = worktreePatterns.map((it) => (it === '@' ? worktreeName : it))
     }
   } else {
-    worktreePatterns = []
+    worktreePatterns = worktreePatterns === undefined ? [worktreeName || '.'] : []
   }
-  const branchPatternsString = String(branchPatterns)
-  if (branchPatternsString === 'HEAD' || branchPatternsString === '.') {
-    const currentBranch = await getCurrentBranchName(repo, remote)
-    if (currentBranch) {
+  let currentBranch
+  if (branchPatterns.length === 1 && (branchPatterns[0] === 'HEAD' || branchPatterns[0] === '.')) {
+    if ((currentBranch = await getCurrentBranchName(repo, remote).then((branch) => branch ?? false))) {
       branchPatterns = [currentBranch]
     } else if (isBare) {
       return [...refs.values()]
@@ -321,17 +349,11 @@ async function selectReferences (source, repo, remote) {
       refs.set('HEAD', { shortname: 'HEAD', fullname: 'HEAD', type: 'branch', detached: true, head })
       return [...refs.values()]
     }
-  } else if (
-    (branchPatterns = Array.isArray(branchPatterns)
-      ? branchPatterns.map((pattern) => String(pattern))
-      : splitRefPatterns(branchPatternsString)).length
-  ) {
+  } else {
     let headBranchIdx
     // NOTE we can assume at least two entries if HEAD or . are present
     if (~(headBranchIdx = branchPatterns.indexOf('HEAD')) || ~(headBranchIdx = branchPatterns.indexOf('.'))) {
-      const currentBranch = await getCurrentBranchName(repo, remote)
-      if (currentBranch) {
-        // NOTE ignore if current branch is already in list
+      if ((currentBranch = await getCurrentBranchName(repo, remote).then((branch) => branch ?? false))) {
         if (~branchPatterns.indexOf(currentBranch)) {
           branchPatterns.splice(headBranchIdx, 1)
         } else {
@@ -350,11 +372,11 @@ async function selectReferences (source, repo, remote) {
         branchPatterns.splice(headBranchIdx, 1)
       }
     }
-  } else {
-    return [...refs.values()]
   }
   // NOTE isomorphic-git includes HEAD in list of remote branches (see https://isomorphic-git.org/docs/listBranches)
-  const remoteBranches = (await git.listBranches(Object.assign({ remote }, repo))).filter((it) => it !== 'HEAD')
+  const remoteBranches = remote
+    ? (await git.listBranches(Object.assign({ remote }, repo))).filter((it) => it !== 'HEAD')
+    : []
   if (remoteBranches.length) {
     for (const shortname of filterRefs(remoteBranches, branchPatterns, patternCache)) {
       const fullname = 'remotes/' + remote + '/' + shortname
@@ -363,11 +385,27 @@ async function selectReferences (source, repo, remote) {
   }
   // NOTE only consider local branches if repo has a worktree or there are no remote tracking branches
   if (!isBare) {
-    const localBranches = await git.listBranches(repo)
+    const localBranches = await git.listBranches(repo).then((branches) => {
+      if (branches.length) return branches
+      if (currentBranch == null) return getCurrentBranchName(repo).then((branch) => (branch ? [branch] : []))
+      return currentBranch ? [currentBranch] : []
+    })
     if (localBranches.length) {
       const worktrees = await findWorktrees(repo, worktreePatterns)
-      for (const shortname of filterRefs(localBranches, branchPatterns, patternCache)) {
-        const head = worktrees.get(shortname) || noWorktree
+      let onMatch
+      if ((worktreePatterns.join('') || '.') !== '.') {
+        const symbolicNames = new Map()
+        worktrees.forEach(({ name, symbolicName = 'HEAD@' + name }, shortname) => {
+          localBranches.push(symbolicName)
+          symbolicNames.set(symbolicName, shortname)
+        })
+        onMatch = (candidate, { pattern }) => {
+          const shortname = symbolicNames.get(candidate)
+          return shortname ? (pattern.startsWith('HEAD@') ? shortname : undefined) : candidate
+        }
+      }
+      for (const shortname of filterRefs(localBranches, branchPatterns, patternCache, onMatch)) {
+        const head = (worktrees.get(shortname) || { head: noWorktree }).head
         refs.set(shortname, { shortname, fullname: 'heads/' + shortname, type: 'branch', head })
       }
     }
@@ -387,18 +425,16 @@ async function selectReferences (source, repo, remote) {
  * Returns the current branch name or undefined if the HEAD is detached.
  */
 function getCurrentBranchName (repo, remote) {
-  let refPromise
-  if (repo.noCheckout) {
-    refPromise = git
-      .resolveRef(Object.assign({ ref: 'refs/remotes/' + remote + '/HEAD', depth: 2 }, repo))
-      .catch(() => git.resolveRef(Object.assign({ ref: 'HEAD', depth: 2 }, repo)))
-  } else {
-    refPromise = git.resolveRef(Object.assign({ ref: 'HEAD', depth: 2 }, repo))
-  }
-  return refPromise.then((ref) => (ref.startsWith('refs/') ? ref.replace(SHORTEN_REF_RX, '') : undefined))
+  return (
+    remote && repo.noCheckout
+      ? git
+          .resolveRef(Object.assign({ ref: 'refs/remotes/' + remote + '/HEAD', depth: 2 }, repo))
+          .catch(() => git.resolveRef(Object.assign({ ref: 'HEAD', depth: 2 }, repo)))
+      : git.resolveRef(Object.assign({ ref: 'HEAD', depth: 2 }, repo))
+  ).then((ref) => (ref.startsWith('refs/') ? ref.replace(SHORTEN_REF_RX, '') : undefined))
 }
 
-async function selectStartPaths (source, repo, remoteName, ref) {
+async function selectStartPaths (source, repo, ref) {
   const url = repo.url
   const displayUrl = url || repo.dir
   const worktreePath = ref.head
@@ -440,7 +476,7 @@ function collectFilesFromStartPath (startPath, repo, authStatus, ref, originUrl,
   return (worktreePath ? readFilesFromWorktree(origin) : readFilesFromGitTree(repo, ref.oid, startPath))
     .then((files) => {
       const batch = deepClone((origin.descriptor = loadComponentDescriptor(files, ref, version)))
-      if ('nav' in batch) batch.nav.origin = origin
+      if ('nav' in batch && Array.isArray(batch.nav)) batch.nav.origin = origin
       batch.files = files.map((file) => assignFileProperties(file, origin))
       batch.origins = [origin]
       return batch
@@ -525,9 +561,9 @@ function readFilesFromGitTree (repo, oid, startPath) {
     Object.assign(root, { dirname: '' })
     return startPath
       ? getGitTreeAtStartPath(repo, oid, startPath).then((start) => {
-        Object.assign(start, { dirname: startPath })
-        return srcGitTree(repo, root, start)
-      })
+          Object.assign(start, { dirname: startPath })
+          return srcGitTree(repo, root, start)
+        })
       : srcGitTree(repo, root)
   })
 }
@@ -582,7 +618,8 @@ function visitGitTree (emitter, repo, root, filter, convert, parent, dirname = '
               (target) => {
                 if (target.type === 'tree') {
                   return visitGitTree(emitter, repo, root, filter, convert, target, vfilePath, target.following)
-                } else if (target.type === 'blob' && filterVerdict === true && (mode = FILE_MODES[target.mode])) {
+                }
+                if (target.type === 'blob' && filterVerdict === true && (mode = FILE_MODES[target.mode])) {
                   return convert(Object.assign({ mode, oid: target.oid, path: vfilePath }, repo)).then((result) =>
                     emitter.emit('entry', result)
                   )
@@ -654,11 +691,11 @@ function readGitObjectAtPath (repo, root, parent, pathSegments, following) {
     if (entry.path === firstPathSegment) {
       return entry.type === 'tree'
         ? git.readTree(Object.assign({ oid: entry.oid }, repo)).then((subtree) => {
-          Object.assign(subtree, { dirname: path.join(parent.dirname, entry.path) })
-          return (pathSegments = pathSegments.slice(1)).length
-            ? readGitObjectAtPath(repo, root, subtree, pathSegments, following)
-            : Object.assign(subtree, { type: 'tree', following }) // Q: should this create copy?
-        })
+            Object.assign(subtree, { dirname: path.join(parent.dirname, entry.path) })
+            return (pathSegments = pathSegments.slice(1)).length
+              ? readGitObjectAtPath(repo, root, subtree, pathSegments, following)
+              : Object.assign(subtree, { type: 'tree', following }) // Q: should this create copy?
+          })
         : entry.mode === SYMLINK_FILE_MODE
           ? readGitSymlink(repo, root, parent, entry, following)
           : Promise.resolve(entry)
@@ -712,18 +749,18 @@ function loadComponentDescriptor (files, ref, version) {
   if (!version) {
     if (version === undefined) throw new Error(`${COMPONENT_DESC_FILENAME} is missing a version`)
     if (version === false) throw new Error(`${COMPONENT_DESC_FILENAME} has an invalid version`)
-    version = '' + (typeof version === 'number' ? version : '')
+    version = typeof version === 'number' ? '' + version : ''
   } else if (version === true) {
     version = ref.shortname.replace(PATH_SEPARATOR_RX, '-')
   } else if (version.constructor === Object) {
     const refname = ref.shortname
     let matched
     if (refname in version) {
-      matched = version[refname]
+      matched = '' + (version[refname] ?? '')
     } else if (
       !Object.entries(version).some(([pattern, replacement]) => {
-        const result = refname.replace(makeMatcherRx(pattern, VERSION_MATCHER_OPTS), '\0' + replacement)
-        if (result === refname) return false
+        const result = refname.replace(makeMatcherRx(pattern, VERSION_MATCHER_OPTS), '\0' + (replacement ?? ''))
+        if (result === refname) return false // no match
         matched = result.substr(1)
         return true
       })
@@ -738,7 +775,7 @@ function loadComponentDescriptor (files, ref, version) {
     throw new Error(`version in ${COMPONENT_DESC_FILENAME} cannot have path segments: ${version}`)
   }
   data.version = version
-  return camelCaseKeys(data, ['asciidoc'])
+  return camelCaseKeys(data, ['asciidoc', 'ext'])
 }
 
 function assignFileProperties (file, origin) {
@@ -755,18 +792,20 @@ function assignFileProperties (file, origin) {
   return file
 }
 
-function buildFetchOptions (repo, progress, displayUrl, credentialsFromUrl, gitPlugins, fetchTags, operation) {
+function buildFetchOptions (repo, progress, displayUrl, credentialsFromUrl, gitPlugins, fetch, operation) {
   const { credentialManager, http, urlRouter } = gitPlugins
+  const corsProxy = false
+  const depth = fetch.depth || undefined
   const onAuth = resolveCredentials.bind(credentialManager, new Map().set(undefined, credentialsFromUrl))
   const onAuthFailure = onAuth
   const onAuthSuccess = (url) => credentialManager.approved({ url })
-  const opts = Object.assign({ corsProxy: false, depth: 1, http, onAuth, onAuthFailure, onAuthSuccess }, repo)
+  const opts = Object.assign({ corsProxy, depth, http, onAuth, onAuthFailure, onAuthSuccess }, repo)
   if (urlRouter) opts.url = urlRouter.ensureGitSuffix(opts.url)
   if (progress) opts.onProgress = createProgressListener(progress, displayUrl, operation)
   if (operation === 'fetch') {
     opts.prune = true
-    if (fetchTags) opts.tags = opts.pruneTags = true
-  } else if (!fetchTags) {
+    if (fetch.tags) opts.tags = opts.pruneTags = true
+  } else if (!fetch.tags) {
     opts.noTags = true
   }
   return opts
@@ -861,7 +900,11 @@ function resolveCredentials (credentialsFromUrlHolder, url, auth) {
 }
 
 function identifyAuthStatus (credentialManager, credentials, url) {
-  return credentials ? 'auth-embedded' : credentialManager.status({ url }) ? 'auth-required' : undefined
+  const status = credentialManager.status({ url })
+  if (credentials) {
+    return typeof status === 'string' && status.startsWith('requested,') ? 'auth-required' : 'auth-embedded'
+  }
+  if (status != null) return 'auth-required'
 }
 
 /**
@@ -870,7 +913,7 @@ function identifyAuthStatus (credentialManager, credentials, url) {
  * The purpose of this function is generate a safe, unique folder name for the cloned
  * repository that gets stored in the cache directory.
  *
- * The generated folder name follows the pattern: <basename>-<sha1>-<version>.git
+ * The generated folder name follows the pattern: <basename>-<sha1-of-normalized-url>.git
  *
  * @param {String} url - The repository URL to convert.
  * @returns {String} The generated folder name.
@@ -886,21 +929,18 @@ function generateCloneFolderName (url) {
  *
  * @param {Repository} repo - The repository on which to operate.
  * @param {String} remoteName - The name of the remote to resolve.
- * @returns {String} The URL of the specified remote, if defined, or the file URI to the local repository.
+ * @returns {String} The URL of the specified remote, if defined
  */
 function resolveRemoteUrl (repo, remoteName) {
   return git.getConfig(Object.assign({ path: 'remote.' + remoteName + '.url' }, repo)).then((url) => {
-    if (url) {
-      if (url.startsWith('https://') || url.startsWith('http://')) {
-        return ~url.indexOf('@') ? url.replace(URL_AUTH_CLEANER_RX, '$1') : url
-      } else if (url.startsWith('git@')) {
-        return 'https://' + url.substr(4).replace(':', '/')
-      } else if (url.startsWith('ssh://')) {
-        return 'https://' + url.substr(url.indexOf('@') + 1 || 6).replace(URL_PORT_CLEANER_RX, '$1')
-      }
+    if (!url) return
+    if (url.startsWith('https://') || url.startsWith('http://')) {
+      return ~url.indexOf('@') ? url.replace(URL_AUTH_CLEANER_RX, '$1') : url
+    }
+    if (url.startsWith('git@')) return 'https://' + url.substr(4).replace(':', '/')
+    if (url.startsWith('ssh://')) {
+      return 'https://' + url.substr(url.indexOf('@') + 1 || 6).replace(URL_PORT_CLEANER_RX, '$1')
     }
-    url = posixify ? 'file:///' + posixify(repo.dir) : 'file://' + repo.dir
-    return ~url.indexOf(' ') ? url.replace(SPACE_RX, '%20') : url
   })
 }
 
@@ -928,7 +968,7 @@ function loadGitPlugins (gitConfig, networkConfig, startDir) {
     if (typeof credentialManager.configure === 'function') {
       credentialManager.configure({ config: gitConfig.credentials, startDir })
     }
-    if (typeof credentialManager.status !== 'function') Object.assign(credentialManager, { status () {} })
+    if (typeof credentialManager.status !== 'function') Object.assign(credentialManager, { status: invariably.void })
   } else {
     credentialManager = new GitCredentialManagerStore().configure({ config: gitConfig.credentials, startDir })
   }
@@ -1018,39 +1058,50 @@ function coerceToString (value) {
   return value == null ? '' : String(value)
 }
 
+function resolveRepositoryFromWorktree (repo) {
+  return fsp
+    .readFile(repo.gitdir, 'utf8')
+    .then((contents) => contents.substr(8).trimEnd())
+    .then((worktreeGitdir) =>
+      fsp.readFile(ospath.join(worktreeGitdir, 'commondir'), 'utf8').then(
+        (contents) => {
+          const gitdir = ospath.join(worktreeGitdir, contents.trimEnd())
+          const dir = ospath.basename(gitdir) === '.git' ? ospath.dirname(gitdir) : gitdir
+          return Object.assign(repo, { dir, gitdir, worktreeName: ospath.basename(worktreeGitdir) })
+        },
+        () => repo
+      )
+    )
+}
+
 function findWorktrees (repo, patterns) {
   if (!patterns.length) return new Map()
-  const linkedOnly = patterns[0] === '.' ? !(patterns = patterns.slice(1)) : true
-  let worktreesDir
+  const mainWorktree =
+    patterns[0] === '.' && (patterns = patterns.slice(1))
+      ? getCurrentBranchName(repo).then((branch) => branch && [branch, { head: repo.dir, name: '.' }])
+      : Promise.resolve()
+  const worktreesDir = patterns.length ? ospath.join(repo.dir, '.git', 'worktrees') : undefined
   const patternCache = repo.cache[REF_PATTERN_CACHE_KEY]
   return (
-    patterns.length
+    worktreesDir
       ? fsp
-        .readdir((worktreesDir = ospath.join(repo.dir, '.git', 'worktrees')))
-        .then((worktreeNames) => filterRefs(worktreeNames, patterns, patternCache), invariably.emptyArray)
-        .then((worktreeNames) =>
-          worktreeNames.length
-            ? Promise.all(
+          .readdir(worktreesDir)
+          .then((worktreeNames) => filterRefs(worktreeNames, patterns, patternCache), invariably.emptyArray)
+          .then((worktreeNames) =>
+            Promise.all(
               worktreeNames.map((worktreeName) => {
                 const gitdir = ospath.resolve(worktreesDir, worktreeName)
-                // NOTE uses name of worktree as branch name if HEAD is detached
-                return git
-                  .currentBranch(Object.assign({}, repo, { gitdir }))
-                  .then((branch = worktreeName) =>
-                    fsp
-                      .readFile(ospath.join(gitdir, 'gitdir'), 'utf8')
-                      .then((contents) => ({ branch, dir: ospath.dirname(contents.trimEnd()) }))
-                  )
+                // NOTE branch name defaults to worktree name if HEAD is detached
+                return getCurrentBranchName(Object.assign({}, repo, { gitdir })).then((branch = worktreeName) =>
+                  fsp
+                    .readFile(ospath.join(gitdir, 'gitdir'), 'utf8')
+                    .then((contents) => [branch, { head: ospath.dirname(contents.trimEnd()), name: worktreeName }])
+                )
               })
-            ).then((entries) => entries.reduce((accum, it) => accum.set(it.branch, it.dir), new Map()))
-            : new Map()
-        )
-      : Promise.resolve(new Map())
-  ).then((worktrees) =>
-    linkedOnly
-      ? worktrees
-      : git.currentBranch(repo).then((branch) => (branch ? worktrees.set(branch, repo.dir) : worktrees))
-  )
+            )
+          )
+      : Promise.resolve()
+  ).then((entries = []) => mainWorktree.then((entry) => new Map(entry ? entries.push(entry) && entries : entries)))
 }
 
 async function gracefulPromiseAllWithLimit (tasks, limit = Infinity) {

package/lib/compute-origin.js

@@ -1,10 +1,10 @@
 'use strict'
 
-const { posix: path } = require('path')
+const { posix: path } = require('node:path')
 const posixify = require('./posixify')
 const removeGitSuffix = require('./remove-git-suffix')
 
-const EDIT_URL_TEMPLATE_VAR_RX = /\{(web_url|ref(?:hash|name|type)|path)\}/g
+const EDIT_URL_TEMPLATE_VAR_RX = /\{(web_url|ref(?:hash|name|type)?|path)\}/g
 const HOSTED_GIT_REPO_RX = /^(?:https?:\/\/|.+@)(git(?:hub|lab)\.com|bitbucket\.org|pagure\.io)[/:](.+?)(?:\.git)?$/
 
 function computeOrigin (url, authStatus, gitdir, ref, startPath, worktreePath = undefined, editUrl = true) {
@@ -24,7 +24,7 @@ function computeOrigin (url, authStatus, gitdir, ref, startPath, worktreePath =
   if (authStatus) origin.private = authStatus
   if (url) origin.webUrl = removeGitSuffix(url)
   if (editUrl === true) {
-    const match = url && url.match(HOSTED_GIT_REPO_RX)
+    const match = url?.match(HOSTED_GIT_REPO_RX)
     if (match) {
       const host = match[1]
       let action = 'blob'
@@ -33,14 +33,16 @@ function computeOrigin (url, authStatus, gitdir, ref, startPath, worktreePath =
         category = 'f'
       } else if (host === 'bitbucket.org') {
         action = 'src'
-      } else if (reftype === 'branch') {
-        action = 'edit'
+      } else {
+        if (reftype === 'branch') action = 'edit'
+        if (host.startsWith('gitlab.')) action = '-/' + action
       }
       origin.editUrlPattern = 'https://' + path.join(match[1], match[2], action, refname, category, startPath, '%s')
     }
   } else if (editUrl) {
     const vars = {
       path: () => (startPath ? path.join(startPath, '%s') : '%s'),
+      ref: () => 'refs/' + (reftype === 'branch' ? 'heads' : reftype) + '/' + refname,
       refhash: () => refhash,
       reftype: () => reftype,
       refname: () => refname,

package/lib/decode-uint8-array.js

@@ -3,4 +3,4 @@
 module.exports = (({ StringDecoder }) => {
   const decoder = new StringDecoder()
   return decoder.write.bind(decoder)
-})(require('string_decoder'))
+})(require('node:string_decoder'))

package/lib/filter-refs.js

@@ -4,19 +4,20 @@ const { makeMatcherRx, refMatcherOpts: getMatcherOpts, MATCH_ALL_RX } = require(
 
 function compileRx (pattern, opts) {
   if (pattern === '*' || pattern === '**') return MATCH_ALL_RX
-  return pattern.charAt() === '!' // do our own negate
-    ? Object.defineProperty(makeMatcherRx(pattern.substr(1), opts), 'negated', { value: true })
-    : makeMatcherRx(pattern, opts)
+  const rx =
+    pattern.charAt() === '!' // we handle negate ourselves
+      ? Object.defineProperty(makeMatcherRx((pattern = pattern.substr(1)), opts), 'negated', { value: true })
+      : makeMatcherRx(pattern, opts)
+  return Object.defineProperty(rx, 'pattern', { value: pattern })
 }
 
-function createMatcher (patterns, cache, opts) {
+function createMatcher (patterns, cache = Object.assign(new Map(), { braces: new Map() })) {
   const rxs = patterns.map(
-    (pattern) =>
-      cache.get(pattern) || cache.set(pattern, compileRx(pattern, opts || (opts = getMatcherOpts(cache)))).get(pattern)
+    (pattern) => cache.get(pattern) || cache.set(pattern, compileRx(pattern, getMatcherOpts(cache))).get(pattern)
   )
   if (rxs[0].negated) rxs.unshift(MATCH_ALL_RX)
-  return (candidate) => {
-    let matched
+  return (candidate, onMatch) => {
+    let matched, symbolic
     for (const rx of rxs) {
       let voteIfMatched = true
       if (matched) {
@@ -25,16 +26,22 @@ function createMatcher (patterns, cache, opts) {
       } else if (rx.negated) {
         continue
       }
-      if (rx.test(candidate)) matched = voteIfMatched
+      if (rx.test(candidate) || (symbolic && rx.test(symbolic) && (candidate = symbolic))) {
+        if (onMatch) {
+          if (!(matched = onMatch(candidate, rx))) continue
+          ;[symbolic, candidate] = [candidate, matched]
+        }
+        matched = voteIfMatched && candidate
+      }
     }
     return matched
   }
 }
 
-function filterRefs (candidates, patterns, cache = Object.assign(new Map(), { braces: new Map() })) {
-  const isMatch = createMatcher(patterns, cache)
+function filterRefs (candidates, patterns, cache, onMatch) {
+  const match = createMatcher(patterns, cache)
   return candidates.reduce((accum, candidate) => {
-    if (isMatch(candidate)) accum.push(candidate)
+    if ((candidate = match(candidate, onMatch))) accum.push(candidate)
     return accum
   }, [])
 }

package/lib/git-credential-manager-store.js

@@ -1,10 +1,10 @@
 'use strict'
 
-const { homedir } = require('os')
+const { homedir } = require('node:os')
 const expandPath = require('@antora/expand-path-helper')
-const { promises: fsp } = require('fs')
+const { promises: fsp } = require('node:fs')
 const invariably = require('./invariably')
-const ospath = require('path')
+const ospath = require('node:path')
 
 class GitCredentialManagerStore {
   configure ({ config, startDir }) {
@@ -86,11 +86,11 @@ class GitCredentialManagerStore {
   }
 
   async approved ({ url }) {
-    this.urls[url] = 'approved'
+    this.urls[url] = (url in this.urls ? this.urls[url] + ',' : '') + 'approved'
   }
 
   async rejected ({ url, auth }) {
-    this.urls[url] = 'rejected'
+    this.urls[url] = (url in this.urls ? this.urls[url] + ',' : '') + 'rejected'
     const statusCode = 401
     const statusMessage = 'HTTP Basic: Access Denied'
     const err = new Error(`HTTP Error: ${statusCode} ${statusMessage}`)

package/lib/git.js

@@ -1,3 +1,10 @@
 'use strict'
 
-module.exports = require('isomorphic-git')
+const zlib = require('node:zlib')
+const { promisify } = require('node:util')
+
+module.exports = ((pakoModuleId) => {
+  const git = require('isomorphic-git')
+  require(pakoModuleId).inflate = promisify(zlib.inflate)
+  return git
+})('pako')

package/lib/matcher.js

@@ -17,7 +17,7 @@ const BASE_OPTS = {
 }
 
 module.exports = {
-  MATCH_ALL_RX: { test: () => true },
+  MATCH_ALL_RX: Object.defineProperty({ test: () => true }, 'pattern', { value: '*' }),
   expandBraces,
   makeMatcherRx: makeRe,
   pathMatcherOpts: Object.assign({}, BASE_OPTS, { dot: false }),

package/lib/posixify.js

@@ -1,3 +1,3 @@
 'use strict'
 
-module.exports = require('path').sep === '\\' ? (p) => p.replace(/\\/g, '/') : undefined
+module.exports = require('node:path').sep === '\\' ? (p) => p.replace(/\\/g, '/') : undefined

package/lib/resolve-path-globs.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const deepFlatten = require('./deep-flatten')
-const { promises: fsp } = require('fs')
+const { promises: fsp } = require('node:fs')
 const git = require('./git')
 const invariably = require('./invariably')
 const { expandBraces, makeMatcherRx, pathMatcherOpts: MATCHER_OPTS } = require('./matcher')
@@ -16,11 +16,11 @@ function resolvePathGlobs (base, patterns, listDirents, retrievePath, tree = { p
         if (resolvedPaths.length) {
           const rx = makeMatcherRx(pattern.substr(1), MATCHER_OPTS)
           return resolvedPaths.filter((it) => !rx.test(it))
-        } else {
-          return resolvedPaths
         }
+        return resolvedPaths
       })
-    } else if (RX_MAGIC_DETECTOR.test(pattern)) {
+    }
+    if (RX_MAGIC_DETECTOR.test(pattern)) {
       return glob(base, pattern.split('/'), listDirents, retrievePath, tree).then((nestedPaths) =>
         paths.then((resolvedPaths) => [...resolvedPaths, ...nestedPaths])
       )
@@ -62,35 +62,36 @@ async function glob (base, patternSegments, listDirents, retrievePath, { oid, pa
           dirent.isDirectory() && isMatch(dirent.name)
             ? patternSegments.length
               ? glob(base, patternSegments, listDirents, retrievePath, {
-                oid: dirent.oid,
-                path: joinPath(path, dirent.name),
-                globbed: true,
-              })
+                  oid: dirent.oid,
+                  path: joinPath(path, dirent.name),
+                  globbed: true,
+                })
               : joinPath(path, dirent.name)
             : []
         )
       )
     )
     return explicit ? [...[...explicit].map((it) => joinPath(path, it)), ...discovered] : discovered
-  } else {
-    const [magicBase, nextSegment] = extractMagicBase(patternSegments, patternSegment)
-    patternSegment = magicBase
-    if (nextSegment) {
-      const obj = await retrievePath(base, { oid, path }, patternSegment)
-      if (obj) {
-        return glob(base, patternSegments, listDirents, retrievePath, {
-          oid: obj.oid,
-          path: joinPath(path, patternSegment),
-        })
-      } else if ((patternSegment += '/' + patternSegments.join('/')).indexOf('{')) {
-        return expandBraces(patternSegment).map((it) => joinPath(path, it))
-      }
-      return [joinPath(path, patternSegment)]
-    } else if (globbed) {
-      return (await retrievePath(base, { oid, path }, patternSegment)) ? [joinPath(path, patternSegment)] : []
+  }
+  const [magicBase, nextSegment] = extractMagicBase(patternSegments, patternSegment)
+  patternSegment = magicBase
+  if (nextSegment) {
+    const obj = await retrievePath(base, { oid, path }, patternSegment)
+    if (obj) {
+      return glob(base, patternSegments, listDirents, retrievePath, {
+        oid: obj.oid,
+        path: joinPath(path, patternSegment),
+      })
+    }
+    if ((patternSegment += '/' + patternSegments.join('/')).indexOf('{')) {
+      return expandBraces(patternSegment).map((it) => joinPath(path, it))
     }
     return [joinPath(path, patternSegment)]
   }
+  if (globbed) {
+    return (await retrievePath(base, { oid, path }, patternSegment)) ? [joinPath(path, patternSegment)] : []
+  }
+  return [joinPath(path, patternSegment)]
 }
 
 function extractMagicBase (patternSegments, base) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antora/content-aggregator",
-  "version": "3.1.9",
+  "version": "3.1.11",
   "description": "Fetches and aggregates content from distributed sources for use in an Antora documentation pipeline.",
   "license": "MPL-2.0",
   "author": "OpenDevise Inc. (https://opendevise.com)",
@@ -11,7 +11,11 @@
     "Balachandran Sivakumar <balachandran@balachandran.org>"
   ],
   "homepage": "https://antora.org",
-  "repository": "gitlab:antora/antora",
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitlab.com/antora/antora.git",
+    "directory": "packages/content-aggregator"
+  },
   "bugs": {
     "url": "https://gitlab.com/antora/antora/issues"
   },
@@ -28,9 +32,9 @@
     "#constants": "./lib/constants.js"
   },
   "dependencies": {
-    "@antora/expand-path-helper": "~2.0",
-    "@antora/logger": "3.1.9",
-    "@antora/user-require-helper": "~2.0",
+    "@antora/expand-path-helper": "~3.0",
+    "@antora/logger": "3.1.11",
+    "@antora/user-require-helper": "~3.0",
     "braces": "~3.0",
     "cache-directory": "~2.0",
     "fast-glob": "~3.3",
@@ -45,7 +49,7 @@
     "vinyl": "~3.0"
   },
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=18.0.0"
   },
   "files": [
     "lib/"
@@ -62,7 +66,7 @@
   ],
   "scripts": {
     "test": "_mocha",
-    "prepublishOnly": "npx -y downdoc --prepublish",
-    "postpublish": "npx -y downdoc --postpublish"
+    "prepublishOnly": "npx -y downdoc@latest --prepublish",
+    "postpublish": "npx -y downdoc@latest --postpublish"
   }
 }