@antora/assembler 1.0.0-alpha.1 → 1.0.0-alpha.10

package/lib/produce-aggregate-documents.js

@@ -4,37 +4,58 @@ const filterComponentVersions = require('./filter-component-versions')
 const produceAggregateDocument = require('./produce-aggregate-document')
 const selectMutableAttributes = require('./select-mutable-attributes')
 
+const IMAGE_MACRO_RX = /^image::?(.+?)\[(.*?)\]$/
+
 function produceAggregateDocuments (loadAsciiDoc, contentCatalog, assemblerConfig) {
   const { insertStartPage, rootLevel, sectionMergeStrategy, asciidoc: assemblerAsciiDocConfig } = assemblerConfig
+  const assemblerAsciiDocAttributes = Object.assign({}, assemblerAsciiDocConfig.attributes)
+  const { doctype, revdate, 'source-highlighter': sourceHighlighter } = assemblerAsciiDocAttributes
+  delete assemblerAsciiDocAttributes.doctype
+  delete assemblerAsciiDocAttributes.revdate
+  delete assemblerAsciiDocAttributes['source-highlighter']
   return filterComponentVersions(contentCatalog.getComponents(), assemblerConfig.componentVersions).reduce(
     (accum, componentVersion) => {
       const { name: componentName, version, title, navigation } = componentVersion
       if (!navigation) return accum
       const componentVersionAsciiDocConfig = getAsciiDocConfigWithAsciidoctorReducerExtension(componentVersion)
       const mergedAsciiDocConfig = Object.assign({}, componentVersionAsciiDocConfig, {
-        attributes: Object.assign({}, componentVersionAsciiDocConfig.attributes, assemblerAsciiDocConfig.attributes),
+        attributes: Object.assign({ revdate }, componentVersionAsciiDocConfig.attributes, assemblerAsciiDocAttributes),
+      })
+      const mergedAsciiDocAttributes = mergedAsciiDocConfig.attributes
+      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]}]`
+        image.out.assembled = true
       })
       const rootEntry = { content: title }
-      const startPage = contentCatalog.getComponentVersionStartPage(componentName, version)
-      let startPageUrl
-      if (startPage && insertStartPage) {
-        if (includedInNav(navigation, (startPageUrl = startPage.pub.url))) {
-          startPageUrl = undefined
-        } else {
-          Object.assign(rootEntry, { url: startPageUrl, urlType: 'internal' })
+      let startPage = contentCatalog.getComponentVersionStartPage(componentName, version)
+      if (startPage && startPage.src.component === componentName && startPage.src.version === version) {
+        if (insertStartPage && !includedInNav(navigation, startPage.pub.url)) {
+          Object.assign(rootEntry, { url: startPage.pub.url, urlType: 'internal' })
         }
+      } else {
+        // Q: should we always use a reference page as startPage for computing mutableAttributes?
+        startPage = createFile({
+          component: componentVersion.name,
+          version: componentVersion.version,
+          relative: '.reference-page.adoc',
+          origin: (componentVersion.origins || [])[0],
+        })
       }
-      // Q: should we use an artificial page instead or as fallback?
-      const mutableAttributes = startPage
-        ? selectMutableAttributes(loadAsciiDoc, contentCatalog, startPage, mergedAsciiDocConfig)
-        : {}
-      return accum.concat(
+      const mutableAttributes = selectMutableAttributes(loadAsciiDoc, contentCatalog, startPage, mergedAsciiDocConfig)
+      delete mutableAttributes.doctype
+      accum = accum.concat(
         prepareOutlines(navigation, rootEntry, rootLevel).map((outline) =>
           produceAggregateDocument(
             loadAsciiDoc,
             contentCatalog,
             componentVersion,
             outline,
+            doctype,
             contentCatalog.getPages((page) => page.out),
             mergedAsciiDocConfig,
             mutableAttributes,
@@ -42,40 +63,79 @@ function produceAggregateDocuments (loadAsciiDoc, contentCatalog, assemblerConfi
           )
         )
       )
+      mergedAsciiDocAttributes.doctype = doctype
+      sourceHighlighter
+        ? (mergedAsciiDocAttributes['source-highlighter'] = sourceHighlighter)
+        : delete mergedAsciiDocAttributes['source-highlighter']
+      return accum
     },
     []
   )
 }
 
+function createFile (src) {
+  const familySegment = (src.family ??= 'page') + 's'
+  const relativeSegments = src.relative.split('/')
+  const segments = ['modules', (src.module ??= 'ROOT'), familySegment, ...relativeSegments]
+  const path = segments.join('/')
+  const moduleRootPath = Array(relativeSegments.length - 1)
+    .fill('..')
+    .join('/')
+  const outPath = [
+    src.component === 'ROOT' ? '' : src.component,
+    src.version,
+    src.module === 'ROOT' ? '' : src.module,
+    src.family === 'page' ? '' : '_' + familySegment,
+    src.family === 'page' ? src.relative.replace(/\.adoc$/, '.html') : src.relative,
+  ]
+    .filter((it) => it)
+    .join('/')
+  return {
+    path,
+    dirname: path.slice(0, path.lastIndexOf('/')),
+    contents: src.contents ?? Buffer.alloc(0),
+    src,
+    out: { path: outPath },
+    pub: { url: '/' + outPath, moduleRootPath },
+  }
+}
+
 function getAsciiDocConfigWithAsciidoctorReducerExtension (componentVersion) {
-  const asciidoctorReducerExtension = require('./asciidoctor/reducer-extension') // NOTE: must be required lazily
+  const asciidoctorReducerExtension = require('@asciidoctor/reducer') // NOTE: must be required lazily
   const asciidocConfig = componentVersion.asciidoc
-  const extensions = asciidocConfig.extensions || []
-  if (extensions.length) {
-    return Object.assign({}, asciidocConfig, {
-      extensions: extensions.reduce(
-        (accum, candidate) => {
-          if (candidate !== asciidoctorReducerExtension) accum.push(candidate)
-          return accum
-        },
-        [asciidoctorReducerExtension]
-      ),
-    })
-  }
-  return Object.assign({}, asciidocConfig, { extensions: [asciidoctorReducerExtension], sourcemap: true })
+  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(',')))
+}
+
+// when root level is 0, merge the navigation into the rootEntry
+// when root level is 1, create navigation per navigation menu
+// in this case, if there's only a single navigation menu with no title, promote each top-level item to a menu
 function prepareOutlines (navigation, rootEntry, rootLevel) {
   if (rootLevel === 0 || navigation.length === 1) {
-    const navBranch =
-      navigation.length === 1
-        ? navigation[0]
-        : { items: navigation.reduce((navTree, it) => navTree.concat(it.content ? it : it.items), []) }
-    return [Object.assign(rootEntry, navBranch)]
+    let navBranch
+    if (navigation.length === 1) {
+      navBranch = navigation[0]
+    } else {
+      const items = navigation.reduce((accum, it) => accum.concat(it.content ? it : it.items), [])
+      navBranch = items.length ? { items } : {}
+    }
+    return rootLevel === 0 || navBranch.content ? [Object.assign(rootEntry, navBranch)] : navBranch.items
   }
   return navigation.reduce((navTree, it) => navTree.concat(it.content ? it : it.items), [rootEntry])
 }

package/lib/util/sanitize.js

@@ -0,0 +1,13 @@
+'use strict'
+
+const XML_TAG_RX = /<[^>]+>/g
+const XML_SPECIAL_CHARS = { '&lt;': '<', '&gt;': '>', '&amp;': '&' }
+const XML_SPECIAL_CHARS_RX = /&(?:[lg]t|amp);/g
+
+function sanitize (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,6 +1,6 @@
 {
   "name": "@antora/assembler",
-  "version": "1.0.0-alpha.1",
+  "version": "1.0.0-alpha.10",
   "description": "An extension library for Antora that assembles content from multiple pages into a single AsciiDoc file to converted and publish.",
   "license": "MPL-2.0",
   "author": "OpenDevise Inc. (https://opendevise.com)",
@@ -14,9 +14,9 @@
     "url": "https://gitlab.com/antora/antora-assembler/issues"
   },
   "scripts": {
-    "test": "_mocha test",
-    "prepublishOnly": "node $npm_config_local_prefix/npm/prepublishOnly.js",
-    "postpublish": "node $npm_config_local_prefix/npm/postpublish.js"
+    "test": "node --test test/*-test.js",
+    "prepublishOnly": "npx -y downdoc --prepublish",
+    "postpublish": "npx -y downdoc --postpublish"
   },
   "main": "lib/index.js",
   "exports": {
@@ -25,19 +25,23 @@
     "./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",
     "./select-mutable-attributes": "./lib/select-mutable-attributes.js"
   },
+  "imports": {
+    "#unconvert-inline-asciidoc": "./lib/util/unconvert-inline-asciidoc.js"
+  },
   "dependencies": {
+    "@asciidoctor/reducer": "~1.1",
     "@antora/expand-path-helper": "~2.0",
+    "@antora/run-command-helper": "~1.0",
     "braces": "~3.0",
-    "camelcase-keys": "~7.0",
-    "picomatch": "~2.3",
-    "vinyl": "~2.2",
+    "picomatch": "~3.0",
     "js-yaml": "~4.1"
   },
   "devDependencies": {
-    "@antora/asciidoc-loader": "3.0.1",
-    "@antora/site-publisher": "3.0.1"
+    "@antora/asciidoc-loader": "~3.1",
+    "@antora/site-publisher": "~3.1"
   },
   "engines": {
     "node": ">=16.0.0"

package/lib/asciidoctor/reducer-extension.js

@@ -1,230 +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
-    const result = Opal.send(this, Opal.find_super_dispatcher(this, 'push_include', pushInclude), [
-      data,
-      file,
-      path,
-      lineno,
-      attrs,
-    ])
-    pushIncludeReplacement.call(
-      this,
-      directiveLineno,
-      this.include_stack.length > prevIncDepth ? this.$lines() : [],
-      lineno > 1 ? lineno - 1 : 0
-    )
-    return result
-  })
-
-  Opal.defn(scope, '$pop_include', function popInclude () {
-    if (!this.$$reducer.includePushed) this.includeReplacements.$up()
-    return Opal.send(this, Opal.find_super_dispatcher(this, 'pop_include', popInclude), [])
-  })
-
-  function pushIncludeReplacement (lineno, lines, offset, unresolved) {
-    const incReplacements = this.includeReplacements
-    const into = incReplacements.pointer
-    const line = this.$$reducer.includeDirectiveLine
-    incReplacements.push({ into, lineno: lineno - (incReplacements.$current().offset || 0), line, lines, offset })
-    if (!unresolved && lines.length) incReplacements.$to_end()
-  }
-
-  return scope
-})()
-
-function preprocessor () {
-  this.process((doc, reader) =>
-    doc.getOptions().preserve_conditionals
-      ? reader.$extend(IncludeDirectiveTracker)
-      : reader.$extend(ConditionalDirectiveTracker, IncludeDirectiveTracker)
-  )
-}
-
-function treeProcessor () {
-  this.process((doc) => {
-    const incReplacements = doc.reader.includeReplacements
-    if (incReplacements.length > 1 || (incReplacements[0].drop || []).length) {
-      const sourceLines = doc.getSourceLines()
-      incReplacements[0].lines = sourceLines.slice()
-      incReplacements
-        .slice()
-        .reverse()
-        .forEach(({ into, lineno, lines, line, drop }) => {
-          let targetLines, idx
-          if (into != null) {
-            targetLines = incReplacements[into].lines
-            // adds assurance that we're replacing the correct line
-            if (targetLines[(idx = lineno - 1)] !== line) return
-          }
-          if ((drop || []).length) {
-            drop
-              .slice()
-              .reverse()
-              .forEach((dropIt) => {
-                Array.isArray(dropIt) ? (lines[dropIt[0] - 1] = dropIt[1]) : lines.splice(dropIt - 1, 1)
-              })
-          }
-          if (targetLines) targetLines[idx] = lines
-        })
-      const reducedSourceLines = flattenDeep(incReplacements[0].lines)
-      if (doc.getSourcemap()) {
-        const logger = Asciidoctor.LoggerManager.getLogger()
-        const opts = Object.assign(doc.getOptions(), { logger: undefined, parse: false, reduced: true })
-        if (opts.extension_registry) {
-          opts.extension_registry = Asciidoctor.Extensions.Registry.$new(opts.extension_registry.groups)
-        }
-        const includes = doc.getCatalog().includes
-        doc = Asciidoctor.load(reducedSourceLines, opts)
-        doc.catalog.$send('[]=', 'includes', includes)
-        doc.parse()
-        Asciidoctor.LoggerManager.setLogger(logger)
-      } else {
-        while (reducedSourceLines[reducedSourceLines.length - 1] === '') reducedSourceLines.pop()
-        sourceLines.splice(0, sourceLines.length, ...reducedSourceLines)
-      }
-    }
-    return doc
-  })
-}
-
-function flattenDeep (array, accum = []) {
-  const len = array.length
-  for (let i = 0, it; i < len; i++) Array.isArray((it = array[i])) ? flattenDeep(it, accum) : accum.push(it)
-  return accum
-}
-
-function toProc (fn) {
-  return Object.defineProperty(fn, '$$arity', { value: fn.length })
-}
-
-module.exports.register = (registry) => {
-  const extGroup = toProc(function () {
-    const doc = this.document
-    doc.$extend(DocumentExt)
-    if (doc.getOptions().reduced) return
-    this.preprocessor(preprocessor)
-    this.treeProcessor(treeProcessor)
-  })
-  registry.groups.$send('[]=', 'reducer', extGroup)
-}

package/lib/util/lazy-readable.js

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

package/lib/util/run-command.js

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