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

package/lib/produce-assembly-files.js

@@ -1,164 +1,165 @@
 'use strict'
 
-const computeOut = require('./util/compute-out')
-const createAsciiDocFile = require('./util/create-asciidoc-file')
+const collateAsciiDocAttributes = require('./util/collate-asciidoc-attributes')
 const filterComponentVersions = require('./filter-component-versions')
 const produceAssemblyFile = require('./produce-assembly-file')
-const selectMutableAttributes = require('./select-mutable-attributes')
+const identifyMutableAttributes = require('./util/identify-mutable-attributes')
 
-const ATTR_REF_RX = /\\?\{(\w[\w-]*)\}/g
-const IMAGE_MACRO_RX = /^image::?(.+?)\[(.*?)\]$/
-
-function produceAssemblyFiles (loadAsciiDoc, contentCatalog, assemblerConfig, resolveAssemblyModel) {
-  const { asciidoc: assemblerAsciiDocConfig, assembly: assemblyConfig } = assemblerConfig
-  resolveAssemblyModel ??= (componentVersion) => ({
+function produceAssemblyFiles (
+  loadAsciiDoc,
+  contentCatalog,
+  assemblerConfig,
+  selectAssemblerProfile,
+  selectComponentVersions
+) {
+  const { assembly: assemblyConfig } = assemblerConfig
+  selectAssemblerProfile ??= (componentVersion) => ({
+    attributes: assemblyConfig.attributes,
     doctype: assemblyConfig.doctype,
     insertStartPage: assemblyConfig.insertStartPage,
     rootLevel: assemblyConfig.rootLevel,
+    rootPageStyle: assemblyConfig.rootPageStyle,
     sectionMergeStrategy: assemblyConfig.sectionMergeStrategy,
     navigation: componentVersion.navigation,
     xmlIds: assemblyConfig.xmlIds,
     embedReferenceStyle: assemblyConfig.embedReferenceStyle,
     linkReferenceStyle: assemblyConfig.linkReferenceStyle,
     dropExplicitXrefText: assemblyConfig.dropExplicitXrefText,
+    revdate: assemblyConfig.revdate,
+    logger: assemblyConfig.logger, // for tests
   })
-  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)
+  const baseAssemblyAttributes = assemblyConfig.attributes
+  const publishableFiles = contentCatalog.getFiles().filter((file) => file.out && file.pub)
+  const reducerExtension = require('@asciidoctor/reducer') // require lazily to wait for Opal to be defined
   let siteRoot
   const configMdc = assemblerConfig.file ? { file: { path: assemblerConfig.file } } : {}
-  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 mergedAsciiDocAttributes = collateAsciiDocAttributes(
-        Object.assign({ revdate }, componentVersionAsciiDocConfig.attributes),
-        assemblerAsciiDocAttributes,
-        { logger: assemblyModel.logger, mdc: configMdc }
-      )
-      const mergedAsciiDocConfig = Object.assign({}, componentVersionAsciiDocConfig, {
-        attributes: mergedAsciiDocAttributes,
-      })
-      assemblyModel.outDirname = computeOut.call(contentCatalog, {
+  selectComponentVersions ??= filterComponentVersions.bind(null, assemblerConfig.componentVersionFilter)
+  return selectComponentVersions(contentCatalog.getComponents()).reduce((accum, componentVersion) => {
+    const assemblyModel = selectAssemblerProfile(componentVersion)
+    const { attributes: assemblyAttributes, logger, navigation, rootLevel } = assemblyModel
+    if (!navigation) return accum
+    const contextualLogger = logger ? { warn: logger.warn.bind(logger, configMdc) } : undefined
+    const { name: componentName, version, title } = componentVersion
+    const asciidocConfig = getAsciiDocConfigWithAsciidoctorReducerExtension(componentVersion, reducerExtension)
+    let sourceHighlighter
+    if ('source-highlighter' in assemblyAttributes) {
+      sourceHighlighter = assemblyAttributes['source-highlighter']
+      delete assemblyAttributes['source-highlighter']
+    }
+    const mergedAsciiDocAttributes = collateAsciiDocAttributes(
+      Object.assign({}, asciidocConfig.attributes),
+      assemblyAttributes,
+      contextualLogger
+    )
+    const mergedAsciiDocConfig = Object.assign({}, asciidocConfig, {
+      attributes: mergedAsciiDocAttributes,
+    })
+    assemblyModel.filetype = baseAssemblyAttributes['assembler-filetype']
+    const outDirname = (assemblyModel.outDirname = contentCatalog.createFile({
+      src: {
         component: componentName,
         version,
+        componentVersion,
+        module: 'ROOT',
         family: 'export',
-        relative: '.index.adoc',
-      }).dirname
-      assemblyModel.filetype = assemblerAsciiDocAttributes['assembler-filetype']
-      assemblyModel.siteRoot =
-        siteRoot === undefined
-          ? (siteRoot ??= ((val) => {
-              if (!val) return null
-              if (val.charAt(val.length - 1) === '/') val = val.slice(0, val.length - 1)
-              if (!val || val.charAt() === '/') return { path: val }
-              return { url: val, path: extractUrlPath(val) }
-            })(mergedAsciiDocAttributes['site-url'] || mergedAsciiDocAttributes['primary-site-url']))
-          : siteRoot
-      if (assemblyModel.filetype === 'html') {
-        let linkRefStyle = assemblyModel.linkReferenceStyle
-        if (linkRefStyle === 'absolute' && siteRoot?.url == null) linkRefStyle = 'root-relative'
-        if (linkRefStyle === 'root-relative' && siteRoot?.path == null) linkRefStyle = 'relative'
-        assemblyModel.linkReferenceStyle = linkRefStyle
-      } else {
-        assemblyModel.linkReferenceStyle = 'absolute'
-      }
-      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],
-          },
-        })
+        relative: 'index.adoc',
+      },
+    }).out.dirname)
+    assemblyModel.pubRoot = outDirname ? '/' + outDirname : ''
+    assemblyModel.siteRoot =
+      siteRoot === undefined
+        ? (siteRoot ??= ((val) => {
+            if (!val) return null
+            if (val.charAt(val.length - 1) === '/') val = val.substring(0, val.length - 1)
+            if (!val || val.charAt() === '/') return { path: val }
+            return { url: val, path: extractUrlPath(val) }
+          })(mergedAsciiDocAttributes['site-url'] || mergedAsciiDocAttributes['primary-site-url']))
+        : siteRoot
+    if (assemblyModel.filetype === 'html') {
+      let linkRefStyle = assemblyModel.linkReferenceStyle
+      if (linkRefStyle === 'absolute' && siteRoot?.url == null) linkRefStyle = 'root-relative'
+      if (linkRefStyle === 'root-relative' && siteRoot?.path == null) linkRefStyle = 'relative'
+      assemblyModel.linkReferenceStyle = linkRefStyle
+    } else if (!(assemblyModel.filetype === 'pdf' && assemblyModel.linkReferenceStyle === 'relative')) {
+      assemblyModel.linkReferenceStyle = 'absolute'
+    }
+    const outlineRoot = { content: title }
+    const startPage = resolveStartPage(contentCatalog, componentVersion, assemblyModel.insertStartPage, outlineRoot)
+    const mutableAttributes = identifyMutableAttributes(loadAsciiDoc, contentCatalog, startPage, mergedAsciiDocConfig)
+    prepareOutlines(navigation, outlineRoot, rootLevel).reduce((any, outline) => {
+      const assemblyFile = produceAssemblyFile(
+        loadAsciiDoc,
+        contentCatalog,
+        componentVersion,
+        outline,
+        publishableFiles,
+        mergedAsciiDocConfig,
+        mutableAttributes,
+        assemblyModel
+      )
+      if (!assemblyFile) return any
+      // NOTE restore source highlighter for conversion if defined in Assembler config
+      if (sourceHighlighter !== undefined) {
+        assemblyFile.asciidoc.attributes['source-highlighter'] = sourceHighlighter
+      } else if (assemblyModel.filetype !== 'html') {
+        delete assemblyFile.asciidoc.attributes['source-highlighter']
       }
-      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)
-      sourceHighlighter
-        ? (mergedAsciiDocAttributes['source-highlighter'] = sourceHighlighter)
-        : delete mergedAsciiDocAttributes['source-highlighter']
-      return accum
-    },
-    []
-  )
+      return !!accum.push(assemblyFile)
+    }, false)
+    return accum
+  }, [])
 }
 
-function getAsciiDocConfigWithAsciidoctorReducerExtension (componentVersion) {
-  const asciidoctorReducerExtension = require('@asciidoctor/reducer') // NOTE: must be required lazily
+function getAsciiDocConfigWithAsciidoctorReducerExtension (componentVersion, reducerExtension) {
   const asciidocConfig = componentVersion.asciidoc
-  const extensions = [asciidoctorReducerExtension]
+  const extensions = [reducerExtension]
   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,
-  })
+  return configuredExtensions.length
+    ? Object.assign({}, asciidocConfig, {
+        extensions: configuredExtensions.reduce((accum, candidate) => {
+          if (candidate !== reducerExtension) accum.push(candidate)
+          return accum
+        }, extensions),
+        sourcemap: true,
+      })
+    : Object.assign({}, asciidocConfig, { 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 resolveStartPage (contentCatalog, componentVersion, insertStartPage, outlineRoot) {
+  const { name: componentName, version } = componentVersion
+  const startPage =
+    'startPage' in componentVersion
+      ? componentVersion.startPage
+      : contentCatalog.resolvePage('index.adoc', { component: componentName, version })
+  if (startPage && startPage.src.component === componentName && startPage.src.version === version) {
+    if (insertStartPage) {
+      const navtitle = startPage.asciidoc?.navtitle || outlineRoot.content
+      Object.assign(outlineRoot, { navtitle, url: startPage.pub.url, urlType: 'internal', roles: ['page'] })
+    }
+    return startPage
+  }
+  return contentCatalog.createFile({
+    src: {
+      component: componentName,
+      version,
+      componentVersion,
+      module: 'ROOT',
+      family: 'page',
+      relative: 'index.adoc',
+      origin: componentVersion.origins?.values().next().value,
+    },
+  })
 }
 
 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)
+      it.items && accum.push(...it.items)
     } else {
       accum.push(it)
     }
@@ -166,7 +167,7 @@ function prepareOutlines (navigation, rootEntry, rootLevel) {
   }, [])
   if (rootLevel === 0) {
     if (rootEntry.url && includedInNav(items, rootEntry.url)) {
-      for (const p of ['url', 'urlType']) delete rootEntry[p]
+      for (const p of ['roles', 'url', 'urlType']) delete rootEntry[p]
     }
     return [Object.assign(rootEntry, { index: true, items })]
   }
@@ -177,39 +178,9 @@ function prepareOutlines (navigation, rootEntry, rootLevel) {
   return items
 }
 
-function collateAsciiDocAttributes (collated, additional, { logger, mdc }) {
-  Object.entries(additional).forEach(([name, val]) => {
-    if (val && val.constructor === String) {
-      let alias
-      val = val.replace(ATTR_REF_RX, (ref, refname) => {
-        if (ref.charAt() === '\\') return ref.substr(1)
-        const refval = collated[refname]
-        if (refval == null || refval === false) {
-          if (refname in collated && ref === val) {
-            alias = refval
-          } else if (collated['attribute-missing'] === 'warn') {
-            if (logger) {
-              logger.warn(mdc, "Skipping reference to missing attribute '%s' in value of '%s' attribute", refname, name)
-            }
-          }
-          return ref
-        }
-        if (refval.constructor === String) return refval
-        if (ref !== val) return refval.toString()
-        alias = refval
-        return ref
-      })
-      if (alias !== undefined) val = alias
-    }
-    collated[name] = val
-  })
-  return collated
-}
-
 function extractUrlPath (url) {
-  if (!url) return ''
-  const urlPath = new URL(url).pathname
-  return urlPath === '/' ? '' : urlPath
+  const parsedUrl = url ? URL.parse(url) : null
+  return parsedUrl == null || parsedUrl.pathname === '/' ? '' : parsedUrl.pathname
 }
 
 module.exports = produceAssemblyFiles

package/lib/util/collate-asciidoc-attributes.js

@@ -0,0 +1,32 @@
+'use strict'
+
+const ATTR_REF_RX = /\\?\{(\w[\w-]*)\}/g
+
+function collateAsciiDocAttributes (collated, additional = {}, logger = undefined) {
+  Object.entries(additional).forEach(([name, val]) => {
+    if (val && val.constructor === String) {
+      let alias
+      val = val.replace(ATTR_REF_RX, (ref, refname) => {
+        if (ref.charAt() === '\\') return ref.substring(1)
+        const refval = collated[refname]
+        if (refval == null || refval === false) {
+          if (refname in collated && ref === val) {
+            alias = refval
+          } else if (collated['attribute-missing'] === 'warn') {
+            logger?.warn("Skipping reference to missing attribute '%s' in value of '%s' attribute", refname, name)
+          }
+          return ref
+        }
+        if (refval.constructor === String) return refval
+        if (ref !== val) return refval.toString()
+        alias = refval
+        return ref
+      })
+      if (alias !== undefined) val = alias
+    }
+    collated[name] = val
+  })
+  return collated
+}
+
+module.exports = collateAsciiDocAttributes

package/lib/util/create-resource-key.js

@@ -0,0 +1,7 @@
+'use strict'
+
+function createResourceKey ({ component, version, module: mod, family, relative }) {
+  return `${version}@${component}:${mod === 'ROOT' ? '' : mod}:${family === 'page' ? '' : family + '$'}${relative}`
+}
+
+module.exports = createResourceKey

package/lib/util/deep-clone.js

@@ -0,0 +1,18 @@
+'use strict'
+
+function deepClone (o) {
+  switch (o.constructor) {
+    case Object:
+      return Object.keys(o).reduce((accum, k) => {
+        const v = o[k]
+        accum[k] = !v || typeof v !== 'object' ? v : deepClone(v)
+        return accum
+      }, {})
+    case Array:
+      return o.map((it) => (!it || typeof it !== 'object' ? it : deepClone(it)))
+    default:
+      return o
+  }
+}
+
+module.exports = deepClone

package/lib/util/generate-scoped-id.js

@@ -0,0 +1,26 @@
+'use strict'
+
+const HTML_RESERVED_ID_NAMES = 'content header footnotes footer footer-text premable toc toctitle'.split(' ')
+
+function generateScopedId (componentSrc, componentVersion, separators, filetype, asXrefTarget) {
+  let { component, module: mod, relative } = componentSrc
+  let id = relative.replace(/\.adoc$/, '').replace(/[/.]/g, '-')
+  let { coordinate: coordinateSeparator, prefix: prefixSeparator } = separators
+  if (mod !== 'ROOT' && ~mod.indexOf('.')) mod = mod.replace(/[.]/g, '-')
+  if (component !== componentVersion.name) {
+    id = [component, mod === 'ROOT' ? '' : mod, id].join(coordinateSeparator)
+  } else if (mod !== 'ROOT') {
+    if (asXrefTarget && coordinateSeparator === ':' && /(?:pass|stem)$/.test(mod) && /^[a-z]+(?:,[a-z-]+)*$/.test(id)) {
+      prefixSeparator = ''
+      mod = mod.replace(/(?:pass|stem)$/, '\\$&')
+    }
+    id = mod + coordinateSeparator + id
+  } else if (filetype === 'html' && HTML_RESERVED_ID_NAMES.includes(id)) {
+    id = prefixSeparator + id
+    prefixSeparator = ''
+  }
+  if (prefixSeparator && !/^[\p{Alpha}_:]/u.test(id)) id = prefixSeparator + id
+  return id
+}
+
+module.exports = generateScopedId

package/lib/util/identify-mutable-attributes.js

@@ -0,0 +1,25 @@
+'use strict'
+
+/**
+ * Identifies AsciiDoc attributes that can be modified in the body of the page.
+ *
+ * This determination is made by loading a reference page with empty contents, retrieving the list of document attribute
+ * names, then removing any attributes that were passed via the API with some exceptions. The reason for this function
+ * is to be more prudent with which attributes to manage at the boundaries of an assembled page.
+ */
+function identifyMutableAttributes (loadAsciiDoc, contentCatalog, referencePage, asciidocConfig) {
+  const doc = loadAsciiDoc(
+    new referencePage.constructor(
+      Object.assign({}, referencePage, { contents: Buffer.alloc(0), mediaType: 'text/asciidoc' })
+    ),
+    contentCatalog,
+    Object.assign({}, asciidocConfig, { extensions: [], headerOnly: true })
+  )
+  const immutableAttributeNames = doc.attribute_overrides.$keys()['$+'](['doctype'])
+  return Object.entries(doc.getAttributes()).reduce((accum, [name, val]) => {
+    if (!immutableAttributeNames.includes(name)) accum[name] = val
+    return accum
+  }, {})
+}
+
+module.exports = identifyMutableAttributes

package/lib/util/lazy-readable.js

@@ -1,14 +1,23 @@
 'use strict'
 
+const fs = require('node:fs')
 const { PassThrough } = require('node: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)
+  constructor (fnOrPath) {
+    super()
+    const fn = typeof fnOrPath === 'function' ? fnOrPath : fs.createReadStream.bind(null, fnOrPath)
     this._read = function () {
       delete this._read // restores original method
-      fn.call(this, options).on('error', this.emit.bind(this, 'error')).pipe(this)
+      const readable = fn().on('error', (err) => {
+        let msg = 'Failed to create stream'
+        if (err.syscall === 'open') msg += ` for path '${err.path}'`
+        this.emit('error', new Error(msg, { cause: err }))
+      })
+      readable.pipe(this)
+      this.fd = readable.fd
+      this.path = readable.path
       return this._read.apply(this, arguments)
     }
     this.emit('readable')

package/lib/util/matcher.js

@@ -0,0 +1,150 @@
+'use strict'
+
+const SPECIAL = { '.': true, '[': true, ']': true, '^': true, $: true, '}': true, ')': true, '|': true }
+const QUANTIFIER_ALTERNATE = { '*': '.*?', '+': '\\+', '?': '.' }
+const QUANTIFIERS = { '*': true, '+': true, '?': true, '@': true, '!': true }
+const RS = '\x1e'
+
+const BRACE_RANGE_RX = /^\{(?:([a-z])\.\.([a-z])|(0|[1-9][0-9]*)\.\.(0|[1-9][0-9]*))\}/
+
+function filterCollection (candidates, patterns, opts = {}) {
+  const rxs = patterns.map(opts.compilePattern ?? compilePattern)
+  const test = opts.test ?? ((rx, candidate) => rx.test(candidate))
+  return candidates.filter((candidate) => {
+    let matched = false
+    for (const rx of rxs) {
+      let voteIfMatched = true
+      if (matched) {
+        if (!rx.negated) continue
+        voteIfMatched = false
+      } else if (rx.negated) {
+        voteIfMatched = false
+      }
+      if (test(rx, candidate)) matched = voteIfMatched
+    }
+    return matched
+  })
+}
+
+function compilePattern (str) {
+  const negated = str.charAt() === '!' ? (str = str.substring(1)).constructor === String : false
+  if (str === '**') return Object.assign(new RegExp(), { globstar: true, negated })
+  if (str === '*') return Object.assign(new RegExp(), { star: true, negated })
+  const buffer = { result: '', brace: undefined, group: undefined }
+  let target = 'result'
+  let nestedTarget
+  for (let i = 0, len = str.length; i < len; i++) {
+    const c = str[i]
+    if (target === 'brace') {
+      if (c === '}') {
+        const braceBuffer = buffer.brace
+        let braceResult
+        if (~braceBuffer.indexOf(RS)) {
+          braceResult = braceBuffer === RS ? '' : '(?:' + braceBuffer.replace(/\x1e/g, '|') + ')'
+        } else {
+          const m = BRACE_RANGE_RX.exec('{' + braceBuffer.replace('\\.\\.', '..') + '}')
+          braceResult = m[1] != null ? `[${m[1]}-${m[2]}]` : rangeRe(+m[3], +m[4])
+        }
+        buffer[(target = nestedTarget === 'group' ? 'group' : 'result')] += braceResult
+        buffer.brace = nestedTarget = undefined
+        continue
+      } else if (c === ',') {
+        buffer.brace += RS
+        continue
+      }
+    } else if (target === 'group') {
+      if (c === ')') {
+        const { group: groupBuffer, groupQuantifier } = buffer
+        let groupResult = '(?:' + groupBuffer + ')'
+        if (groupQuantifier === '!') {
+          groupResult = '(?!' + groupResult + '.*?)'
+        } else if (groupQuantifier !== '@') {
+          groupResult += groupQuantifier
+        }
+        buffer[(target = nestedTarget === 'brace' ? 'brace' : 'result')] += groupResult
+        buffer.group = buffer.groupQuantifier = nestedTarget = undefined
+        continue
+      }
+    }
+    if (SPECIAL[c]) {
+      buffer[target] += '\\' + c
+    } else if (c === '(' || QUANTIFIERS[c]) {
+      const hasQuantifier = c !== '('
+      const atGroupStart = hasQuantifier ? str[i + 1] === '(' : true
+      if (target !== 'group' && atGroupStart && isGroup(str.substring(hasQuantifier ? i + 1 : i))) {
+        if (target === 'brace') nestedTarget = 'brace'
+        buffer[(target = 'group')] = ''
+        buffer.groupQuantifier = hasQuantifier ? ++i > 0 && c : ''
+      } else if (hasQuantifier) {
+        buffer[target] += (QUANTIFIER_ALTERNATE[c] ?? c) + (atGroupStart ? ++i > 0 && '\\(' : '')
+      } else {
+        buffer[target] += '\\('
+      }
+    } else if (c === '{') {
+      if (target !== 'brace' && isBrace(str.substring(i))) {
+        if (target === 'group') nestedTarget = 'group'
+        buffer[(target = 'brace')] = ''
+      } else {
+        buffer[target] += '\\' + c
+      }
+    } else {
+      buffer[target] += c
+    }
+  }
+  return Object.assign(new RegExp('^' + cleanup(buffer, target, nestedTarget) + '$'), { negated })
+}
+
+function cleanup (buffer, target, nestedTarget) {
+  if (target === 'result') return buffer.result
+  if (target === 'brace') {
+    buffer.result += '\\{' + buffer.brace.replace(/\x1e/g, ',')
+    buffer.brace = undefined
+  } else if (target === 'group') {
+    const groupQuantifier = buffer.groupQuantifier
+    buffer.result += (QUANTIFIER_ALTERNATE[groupQuantifier] ?? groupQuantifier) + '\\(' + buffer.group
+    buffer.group = buffer.groupQuantifier = undefined
+  }
+  return nestedTarget ? cleanup(buffer, nestedTarget) : buffer.result
+}
+
+function isBrace (str) {
+  const endBraceIdx = str.indexOf('}')
+  const candidate = ~endBraceIdx ? str.substring(0, endBraceIdx + 1) : ''
+  if (!candidate || ~candidate.indexOf('{', 1)) return false
+  return ~candidate.indexOf(',') || BRACE_RANGE_RX.test(candidate)
+}
+
+function isGroup (str) {
+  const endBraceIdx = str.indexOf(')')
+  const candidate = ~endBraceIdx ? str.substring(0, endBraceIdx + 1) : ''
+  return candidate ? !~candidate.indexOf('(', 1) : false
+}
+
+function rangeRe (min, max) {
+  if (min === max) return String(min)
+  min > max && ([min, max] = [max, min])
+  if (min < 10 && max < 10) return `[${min}${min + 1 === max ? '' : '-'}${max}]`
+  const result = []
+  let minStr, minStrLen, toStr
+  while (min <= max) {
+    let to = (minStrLen = (minStr = String(min)).length) < String(max).length ? 10 ** minStrLen - 1 : max
+    const limit = 10 ** minStrLen
+    for (let i = 10; i <= limit; i *= 10) {
+      const candidate = min + (i - (min % i) || i) - 1
+      if (candidate > max) break
+      to = candidate
+    }
+    toStr = String(to)
+    let rangesForChunk = ''
+    for (let i = 0, len = minStr.length; i < len; i++) {
+      const lhs = minStr[i]
+      const rhs = toStr[i]
+      rangesForChunk += lhs === rhs ? lhs : `[${lhs}${+lhs + 1 === +rhs ? '' : '-'}${rhs}]`
+    }
+    result.push(rangesForChunk)
+    min = to + 1
+  }
+  return result.length > 1 ? `(?:${result.join('|')})` : result[0]
+}
+
+module.exports = { filterCollection, compilePattern }