rapid_stack 1.0.0 → 1.0.1

data/lib/rapid_stack/generators/generator-rapid/node_modules/@npmcli/arborist/node_modules/pacote/lib/git.js

@@ -1,304 +0,0 @@
-const Fetcher = require('./fetcher.js')
-const FileFetcher = require('./file.js')
-const RemoteFetcher = require('./remote.js')
-const DirFetcher = require('./dir.js')
-const hashre = /^[a-f0-9]{40}$/
-const git = require('@npmcli/git')
-const pickManifest = require('npm-pick-manifest')
-const npa = require('npm-package-arg')
-const url = require('url')
-const Minipass = require('minipass')
-const cacache = require('cacache')
-const { promisify } = require('util')
-const readPackageJson = require('read-package-json-fast')
-const npm = require('./util/npm.js')
-
-const _resolvedFromRepo = Symbol('_resolvedFromRepo')
-const _resolvedFromHosted = Symbol('_resolvedFromHosted')
-const _resolvedFromClone = Symbol('_resolvedFromClone')
-const _tarballFromResolved = Symbol.for('pacote.Fetcher._tarballFromResolved')
-const _addGitSha = Symbol('_addGitSha')
-const addGitSha = require('./util/add-git-sha.js')
-const _clone = Symbol('_clone')
-const _cloneHosted = Symbol('_cloneHosted')
-const _cloneRepo = Symbol('_cloneRepo')
-const _setResolvedWithSha = Symbol('_setResolvedWithSha')
-const _prepareDir = Symbol('_prepareDir')
-
-// get the repository url.
-// prefer https if there's auth, since ssh will drop that.
-// otherwise, prefer ssh if available (more secure).
-// We have to add the git+ back because npa suppresses it.
-const repoUrl = (h, opts) =>
-  h.sshurl && !(h.https && h.auth) && addGitPlus(h.sshurl(opts)) ||
-  h.https && addGitPlus(h.https(opts))
-
-// add git+ to the url, but only one time.
-const addGitPlus = url => url && `git+${url}`.replace(/^(git\+)+/, 'git+')
-
-class GitFetcher extends Fetcher {
-  constructor (spec, opts) {
-    super(spec, opts)
-    this.resolvedRef = null
-    if (this.spec.hosted)
-      this.from = this.spec.hosted.shortcut({ noCommittish: false })
-
-    // shortcut: avoid full clone when we can go straight to the tgz
-    // if we have the full sha and it's a hosted git platform
-    if (this.spec.gitCommittish && hashre.test(this.spec.gitCommittish)) {
-      this.resolvedSha = this.spec.gitCommittish
-      // use hosted.tarball() when we shell to RemoteFetcher later
-      this.resolved = this.spec.hosted
-        ? repoUrl(this.spec.hosted, { noCommittish: false })
-        : this.spec.rawSpec
-    } else
-      this.resolvedSha = ''
-  }
-
-  // just exposed to make it easier to test all the combinations
-  static repoUrl (hosted, opts) {
-    return repoUrl(hosted, opts)
-  }
-
-  get types () {
-    return ['git']
-  }
-
-  resolve () {
-    // likely a hosted git repo with a sha, so get the tarball url
-    // but in general, no reason to resolve() more than necessary!
-    if (this.resolved)
-      return super.resolve()
-
-    // fetch the git repo and then look at the current hash
-    const h = this.spec.hosted
-    // try to use ssh, fall back to git.
-    return h ? this[_resolvedFromHosted](h)
-      : this[_resolvedFromRepo](this.spec.fetchSpec)
-  }
-
-  // first try https, since that's faster and passphrase-less for
-  // public repos, and supports private repos when auth is provided.
-  // Fall back to SSH to support private repos
-  // NB: we always store the https url in resolved field if auth
-  // is present, otherwise ssh if the hosted type provides it
-  [_resolvedFromHosted] (hosted) {
-    return this[_resolvedFromRepo](hosted.https && hosted.https())
-      .catch(er => {
-        // Throw early since we know pathspec errors will fail again if retried
-        if (er instanceof git.errors.GitPathspecError)
-          throw er
-        const ssh = hosted.sshurl && hosted.sshurl()
-        // no fallthrough if we can't fall through or have https auth
-        if (!ssh || hosted.auth)
-          throw er
-        return this[_resolvedFromRepo](ssh)
-      })
-  }
-
-  [_resolvedFromRepo] (gitRemote) {
-    // XXX make this a custom error class
-    if (!gitRemote)
-      return Promise.reject(new Error(`No git url for ${this.spec}`))
-    const gitRange = this.spec.gitRange
-    const name = this.spec.name
-    return git.revs(gitRemote, this.opts).then(remoteRefs => {
-      return gitRange ? pickManifest({
-          versions: remoteRefs.versions,
-          'dist-tags': remoteRefs['dist-tags'],
-          name,
-        }, gitRange, this.opts)
-        : this.spec.gitCommittish ?
-          remoteRefs.refs[this.spec.gitCommittish] ||
-          remoteRefs.refs[remoteRefs.shas[this.spec.gitCommittish]]
-        : remoteRefs.refs.HEAD // no git committish, get default head
-    }).then(revDoc => {
-      // the committish provided isn't in the rev list
-      // things like HEAD~3 or @yesterday can land here.
-      if (!revDoc || !revDoc.sha)
-        return this[_resolvedFromClone]()
-
-      this.resolvedRef = revDoc
-      this.resolvedSha = revDoc.sha
-      this[_addGitSha](revDoc.sha)
-      return this.resolved
-    })
-  }
-
-  [_setResolvedWithSha] (withSha) {
-    // we haven't cloned, so a tgz download is still faster
-    // of course, if it's not a known host, we can't do that.
-    this.resolved = !this.spec.hosted ? withSha
-      : repoUrl(npa(withSha).hosted, { noCommittish: false })
-  }
-
-  // when we get the git sha, we affix it to our spec to build up
-  // either a git url with a hash, or a tarball download URL
-  [_addGitSha] (sha) {
-    this[_setResolvedWithSha](addGitSha(this.spec, sha))
-  }
-
-  [_resolvedFromClone] () {
-    // do a full or shallow clone, then look at the HEAD
-    // kind of wasteful, but no other option, really
-    return this[_clone](dir => this.resolved)
-  }
-
-  [_prepareDir] (dir) {
-    return readPackageJson(dir + '/package.json').then(mani => {
-      // no need if we aren't going to do any preparation.
-      const scripts = mani.scripts
-      if (!scripts || !(
-          scripts.postinstall ||
-          scripts.build ||
-          scripts.preinstall ||
-          scripts.install ||
-          scripts.prepare))
-        return
-
-      // to avoid cases where we have an cycle of git deps that depend
-      // on one another, we only ever do preparation for one instance
-      // of a given git dep along the chain of installations.
-      // Note that this does mean that a dependency MAY in theory end up
-      // trying to run its prepare script using a dependency that has not
-      // been properly prepared itself, but that edge case is smaller
-      // and less hazardous than a fork bomb of npm and git commands.
-      const noPrepare = !process.env._PACOTE_NO_PREPARE_ ? []
-        : process.env._PACOTE_NO_PREPARE_.split('\n')
-      if (noPrepare.includes(this.resolved)) {
-        this.log.info('prepare', 'skip prepare, already seen', this.resolved)
-        return
-      }
-      noPrepare.push(this.resolved)
-
-      // the DirFetcher will do its own preparation to run the prepare scripts
-      // All we have to do is put the deps in place so that it can succeed.
-      return npm(
-        this.npmBin,
-        [].concat(this.npmInstallCmd).concat(this.npmCliConfig),
-        dir,
-        { ...process.env, _PACOTE_NO_PREPARE_: noPrepare.join('\n') },
-        { message: 'git dep preparation failed' }
-      )
-    })
-  }
-
-  [_tarballFromResolved] () {
-    const stream = new Minipass()
-    stream.resolved = this.resolved
-    stream.integrity = this.integrity
-    stream.from = this.from
-
-    // check it out and then shell out to the DirFetcher tarball packer
-    this[_clone](dir => this[_prepareDir](dir)
-      .then(() => new Promise((res, rej) => {
-        const df = new DirFetcher(`file:${dir}`, {
-          ...this.opts,
-          resolved: null,
-          integrity: null,
-        })
-        const dirStream = df[_tarballFromResolved]()
-        dirStream.on('error', rej)
-        dirStream.on('end', res)
-        dirStream.pipe(stream)
-      }))).catch(
-        /* istanbul ignore next: very unlikely and hard to test */
-        er => stream.emit('error', er)
-      )
-    return stream
-  }
-
-  // clone a git repo into a temp folder (or fetch and unpack if possible)
-  // handler accepts a directory, and returns a promise that resolves
-  // when we're done with it, at which point, cacache deletes it
-  //
-  // TODO: after cloning, create a tarball of the folder, and add to the cache
-  // with cacache.put.stream(), using a key that's deterministic based on the
-  // spec and repo, so that we don't ever clone the same thing multiple times.
-  [_clone] (handler, tarballOk = true) {
-    const o = { tmpPrefix: 'git-clone' }
-    const ref = this.resolvedSha || this.spec.gitCommittish
-    const h = this.spec.hosted
-    const resolved = this.resolved
-
-    // can be set manually to false to fall back to actual git clone
-    tarballOk = tarballOk &&
-      h && resolved === repoUrl(h, { noCommittish: false }) && h.tarball
-
-    return cacache.tmp.withTmp(this.cache, o, tmp => {
-      // if we're resolved, and have a tarball url, shell out to RemoteFetcher
-      if (tarballOk) {
-        const nameat = this.spec.name ? `${this.spec.name}@` : ''
-        return new RemoteFetcher(h.tarball({ noCommittish: false }), {
-          ...this.opts,
-          allowGitIgnore: true,
-          pkgid: `git:${nameat}${this.resolved}`,
-          resolved: this.resolved,
-          integrity: null, // it'll always be different, if we have one
-        }).extract(tmp).then(() => handler(tmp), er => {
-          // fall back to ssh download if tarball fails
-          if (er.constructor.name.match(/^Http/))
-            return this[_clone](handler, false)
-          else
-            throw er
-        })
-      }
-
-      return (
-        h ? this[_cloneHosted](ref, tmp)
-        : this[_cloneRepo](this.spec.fetchSpec, ref, tmp)
-      ).then(sha => {
-        this.resolvedSha = sha
-        if (!this.resolved)
-          this[_addGitSha](sha)
-      })
-      .then(() => handler(tmp))
-    })
-  }
-
-  // first try https, since that's faster and passphrase-less for
-  // public repos, and supports private repos when auth is provided.
-  // Fall back to SSH to support private repos
-  // NB: we always store the https url in resolved field if auth
-  // is present, otherwise ssh if the hosted type provides it
-  [_cloneHosted] (ref, tmp) {
-    const hosted = this.spec.hosted
-    return this[_cloneRepo](hosted.https({ noCommittish: true }), ref, tmp)
-      .catch(er => {
-        // Throw early since we know pathspec errors will fail again if retried
-        if (er instanceof git.errors.GitPathspecError)
-          throw er
-        const ssh = hosted.sshurl && hosted.sshurl({ noCommittish: true })
-        // no fallthrough if we can't fall through or have https auth
-        if (!ssh || hosted.auth)
-          throw er
-        return this[_cloneRepo](ssh, ref, tmp)
-      })
-  }
-
-  [_cloneRepo] (repo, ref, tmp) {
-    const { opts, spec } = this
-    return git.clone(repo, ref, tmp, { ...opts, spec })
-  }
-
-  manifest () {
-    if (this.package)
-      return Promise.resolve(this.package)
-
-    return this.spec.hosted && this.resolved
-      ? FileFetcher.prototype.manifest.apply(this)
-      : this[_clone](dir =>
-          readPackageJson(dir + '/package.json')
-            .then(mani => this.package = {
-              ...mani,
-              _integrity: this.integrity && String(this.integrity),
-              _resolved: this.resolved,
-              _from: this.from,
-            }))
-  }
-
-  packument () {
-    return FileFetcher.prototype.packument.apply(this)
-  }
-}
-module.exports = GitFetcher

data/lib/rapid_stack/generators/generator-rapid/node_modules/@npmcli/arborist/node_modules/pacote/lib/registry.js

@@ -1,182 +0,0 @@
-const Fetcher = require('./fetcher.js')
-const RemoteFetcher = require('./remote.js')
-const _tarballFromResolved = Symbol.for('pacote.Fetcher._tarballFromResolved')
-const pacoteVersion = require('../package.json').version
-const npa = require('npm-package-arg')
-const rpj = require('read-package-json-fast')
-const pickManifest = require('npm-pick-manifest')
-const ssri = require('ssri')
-const Minipass = require('minipass')
-
-// Corgis are cute. 🐕🐶
-const corgiDoc = 'application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*'
-const fullDoc = 'application/json'
-
-const fetch = require('npm-registry-fetch')
-
-// TODO: memoize reg requests, so we don't even have to check cache
-
-const _headers = Symbol('_headers')
-class RegistryFetcher extends Fetcher {
-  constructor (spec, opts) {
-    super(spec, opts)
-
-    // you usually don't want to fetch the same packument multiple times in
-    // the span of a given script or command, no matter how many pacote calls
-    // are made, so this lets us avoid doing that.  It's only relevant for
-    // registry fetchers, because other types simulate their packument from
-    // the manifest, which they memoize on this.package, so it's very cheap
-    // already.
-    this.packumentCache = this.opts.packumentCache || null
-
-    // handle case when npm-package-arg guesses wrong.
-    if (this.spec.type === 'tag' &&
-        this.spec.rawSpec === '' &&
-        this.defaultTag !== 'latest')
-      this.spec = npa(`${this.spec.name}@${this.defaultTag}`)
-    this.registry = fetch.pickRegistry(spec, opts)
-    this.packumentUrl = this.registry.replace(/\/*$/, '/') +
-      this.spec.escapedName
-
-    // XXX pacote <=9 has some logic to ignore opts.resolved if
-    // the resolved URL doesn't go to the same registry.
-    // Consider reproducing that here, to throw away this.resolved
-    // in that case.
-  }
-
-  resolve () {
-    if (this.resolved)
-      return Promise.resolve(this.resolved)
-
-    // fetching the manifest sets resolved and (usually) integrity
-    return this.manifest().then(() => {
-      if (this.resolved)
-        return this.resolved
-
-      throw Object.assign(
-        new Error('Invalid package manifest: no `dist.tarball` field'),
-        { package: this.spec.toString() }
-      )
-    })
-  }
-
-  [_headers] () {
-    return {
-      // npm will override UA, but ensure that we always send *something*
-      'user-agent': this.opts.userAgent ||
-        `pacote/${pacoteVersion} node/${process.version}`,
-      ...(this.opts.headers || {}),
-      'pacote-version': pacoteVersion,
-      'pacote-req-type': 'packument',
-      'pacote-pkg-id': `registry:${this.spec.name}`,
-      accept: this.fullMetadata ? fullDoc : corgiDoc,
-    }
-  }
-
-  async packument () {
-    // note this might be either an in-flight promise for a request,
-    // or the actual packument, but we never want to make more than
-    // one request at a time for the same thing regardless.
-    if (this.packumentCache && this.packumentCache.has(this.packumentUrl))
-      return this.packumentCache.get(this.packumentUrl)
-
-    // npm-registry-fetch the packument
-    // set the appropriate header for corgis if fullMetadata isn't set
-    // return the res.json() promise
-    const p = fetch(this.packumentUrl, {
-      ...this.opts,
-      headers: this[_headers](),
-      spec: this.spec,
-      // never check integrity for packuments themselves
-      integrity: null,
-    }).then(res => res.json().then(packument => {
-      packument._cached = res.headers.has('x-local-cache')
-      packument._contentLength = +res.headers.get('content-length')
-      if (this.packumentCache)
-        this.packumentCache.set(this.packumentUrl, packument)
-      return packument
-    })).catch(er => {
-      if (this.packumentCache)
-        this.packumentCache.delete(this.packumentUrl)
-      if (er.code === 'E404' && !this.fullMetadata) {
-        // possible that corgis are not supported by this registry
-        this.fullMetadata = true
-        return this.packument()
-      }
-      throw er
-    })
-    if (this.packumentCache)
-      this.packumentCache.set(this.packumentUrl, p)
-    return p
-  }
-
-  manifest () {
-    if (this.package)
-      return Promise.resolve(this.package)
-
-    return this.packument()
-      .then(packument => pickManifest(packument, this.spec.fetchSpec, {
-        ...this.opts,
-        defaultTag: this.defaultTag,
-        before: this.before,
-      }) /* XXX add ETARGET and E403 revalidation of cached packuments here */)
-      .then(mani => {
-        // add _resolved and _integrity from dist object
-        const { dist } = mani
-        if (dist) {
-          this.resolved = mani._resolved = dist.tarball
-          mani._from = this.from
-          const distIntegrity = dist.integrity ? ssri.parse(dist.integrity)
-            : dist.shasum ? ssri.fromHex(dist.shasum, 'sha1', {...this.opts})
-            : null
-          if (distIntegrity) {
-            if (!this.integrity)
-              this.integrity = distIntegrity
-            else if (!this.integrity.match(distIntegrity)) {
-              // only bork if they have algos in common.
-              // otherwise we end up breaking if we have saved a sha512
-              // previously for the tarball, but the manifest only
-              // provides a sha1, which is possible for older publishes.
-              // Otherwise, this is almost certainly a case of holding it
-              // wrong, and will result in weird or insecure behavior
-              // later on when building package tree.
-              for (const algo of Object.keys(this.integrity)) {
-                if (distIntegrity[algo]) {
-                  throw Object.assign(new Error(
-                    `Integrity checksum failed when using ${algo}: `+
-                    `wanted ${this.integrity} but got ${distIntegrity}.`
-                  ), { code: 'EINTEGRITY' })
-                }
-              }
-              // made it this far, the integrity is worthwhile.  accept it.
-              // the setter here will take care of merging it into what we
-              // already had.
-              this.integrity = distIntegrity
-            }
-          }
-        }
-        if (this.integrity)
-          mani._integrity = String(this.integrity)
-        this.package = rpj.normalize(mani)
-        return this.package
-      })
-  }
-
-  [_tarballFromResolved] () {
-    // we use a RemoteFetcher to get the actual tarball stream
-    return new RemoteFetcher(this.resolved, {
-      ...this.opts,
-      resolved: this.resolved,
-      pkgid: `registry:${this.spec.name}@${this.resolved}`,
-    })[_tarballFromResolved]()
-  }
-
-  get types () {
-    return [
-      'tag',
-      'version',
-      'range',
-    ]
-  }
-}
-module.exports = RegistryFetcher

data/lib/rapid_stack/generators/generator-rapid/node_modules/@npmcli/arborist/node_modules/pacote/lib/remote.js

@@ -1,84 +0,0 @@
-const Fetcher = require('./fetcher.js')
-const FileFetcher = require('./file.js')
-const _tarballFromResolved = Symbol.for('pacote.Fetcher._tarballFromResolved')
-const pacoteVersion = require('../package.json').version
-const fetch = require('npm-registry-fetch')
-const ssri = require('ssri')
-const Minipass = require('minipass')
-// The default registry URL is a string of great magic.
-const magic = /^https?:\/\/registry\.npmjs\.org\//
-
-const _cacheFetches = Symbol.for('pacote.Fetcher._cacheFetches')
-const _headers = Symbol('_headers')
-class RemoteFetcher extends Fetcher {
-  constructor (spec, opts) {
-    super(spec, opts)
-    this.resolved = this.spec.fetchSpec
-    if (magic.test(this.resolved) && !magic.test(this.registry + '/'))
-      this.resolved = this.resolved.replace(magic, this.registry + '/')
-
-    // nam is a fermented pork sausage that is good to eat
-    const nameat = this.spec.name ? `${this.spec.name}@` : ''
-    this.pkgid = opts.pkgid ? opts.pkgid : `remote:${nameat}${this.resolved}`
-  }
-
-  // Don't need to cache tarball fetches in pacote, because make-fetch-happen
-  // will write into cacache anyway.
-  get [_cacheFetches] () {
-    return false
-  }
-
-  [_tarballFromResolved] () {
-    const stream = new Minipass()
-    const fetchOpts = {
-      ...this.opts,
-      headers: this[_headers](),
-      spec: this.spec,
-      integrity: this.integrity,
-      algorithms: [ this.pickIntegrityAlgorithm() ],
-    }
-    fetch(this.resolved, fetchOpts).then(res => {
-      const hash = res.headers.get('x-local-cache-hash')
-      if (hash) {
-        this.integrity = decodeURIComponent(hash)
-      }
-
-      res.body.on('error',
-        /* istanbul ignore next - exceedingly rare and hard to simulate */
-        er => stream.emit('error', er)
-      ).pipe(stream)
-    }).catch(er => stream.emit('error', er))
-
-    return stream
-  }
-
-  [_headers] () {
-    return {
-      // npm will override this, but ensure that we always send *something*
-      'user-agent': this.opts.userAgent ||
-        `pacote/${pacoteVersion} node/${process.version}`,
-      ...(this.opts.headers || {}),
-      'pacote-version': pacoteVersion,
-      'pacote-req-type': 'tarball',
-      'pacote-pkg-id': this.pkgid,
-      ...(this.integrity ? { 'pacote-integrity': String(this.integrity) }
-        : {}),
-      ...(this.opts.headers || {}),
-    }
-  }
-
-  get types () {
-    return ['remote']
-  }
-
-  // getting a packument and/or manifest is the same as with a file: spec.
-  // unpack the tarball stream, and then read from the package.json file.
-  packument () {
-    return FileFetcher.prototype.packument.apply(this)
-  }
-
-  manifest () {
-    return FileFetcher.prototype.manifest.apply(this)
-  }
-}
-module.exports = RemoteFetcher

data/lib/rapid_stack/generators/generator-rapid/node_modules/@npmcli/arborist/node_modules/pacote/lib/util/cache-dir.js

@@ -1,12 +0,0 @@
-const os = require('os')
-const {resolve} = require('path')
-
-module.exports = (fakePlatform = false) => {
-  const temp = os.tmpdir()
-  const uidOrPid = process.getuid ? process.getuid() : process.pid
-  const home = os.homedir() || resolve(temp, 'npm-' + uidOrPid)
-  const platform = fakePlatform || process.platform
-  const cacheExtra = platform === 'win32' ? 'npm-cache' : '.npm'
-  const cacheRoot = (platform === 'win32' && process.env.LOCALAPPDATA) || home
-  return resolve(cacheRoot, cacheExtra, '_cacache')
-}

data/lib/rapid_stack/generators/generator-rapid/node_modules/@npmcli/arborist/node_modules/pacote/lib/util/is-package-bin.js

@@ -1,24 +0,0 @@
-// Function to determine whether a path is in the package.bin set.
-// Used to prevent issues when people publish a package from a
-// windows machine, and then install with --no-bin-links.
-//
-// Note: this is not possible in remote or file fetchers, since
-// we don't have the manifest until AFTER we've unpacked.  But the
-// main use case is registry fetching with git a distant second,
-// so that's an acceptable edge case to not handle.
-
-const binObj = (name, bin) =>
-  typeof bin === 'string' ? { [name]: bin } : bin
-
-const hasBin = (pkg, path) => {
-  const bin = binObj(pkg.name, pkg.bin)
-  const p = path.replace(/^[^\\\/]*\//, '')
-  for (const [k, v] of Object.entries(bin)) {
-    if (v === p)
-      return true
-  }
-  return false
-}
-
-module.exports = (pkg, path) =>
-  pkg && pkg.bin ? hasBin(pkg, path) : false

data/lib/rapid_stack/generators/generator-rapid/node_modules/@npmcli/arborist/node_modules/pacote/lib/util/npm.js

@@ -1,15 +0,0 @@
-// run an npm command
-const spawn = require('@npmcli/promise-spawn')
-const {dirname} = require('path')
-
-module.exports = (npmBin, npmCommand, cwd, env, extra) => {
-  const isJS = npmBin.endsWith('.js')
-  const cmd = isJS ? process.execPath : npmBin
-  const args = (isJS ? [npmBin] : []).concat(npmCommand)
-  // when installing to run the `prepare` script for a git dep, we need
-  // to ensure that we don't run into a cycle of checking out packages
-  // in temp directories.  this lets us link previously-seen repos that
-  // are also being prepared.
-
-  return spawn(cmd, args, { cwd, stdioString: true, env }, extra)
-}

data/lib/rapid_stack/generators/generator-rapid/node_modules/@npmcli/arborist/node_modules/pacote/lib/util/tar-create-options.js

@@ -1,30 +0,0 @@
-const isPackageBin = require('./is-package-bin.js')
-
-const tarCreateOptions = manifest => ({
-  cwd: manifest._resolved,
-  prefix: 'package/',
-  portable: true,
-  gzip: {
-    // forcing the level to 9 seems to avoid some
-    // platform specific optimizations that cause
-    // integrity mismatch errors due to differing
-    // end results after compression
-    level: 9
-  },
-
-  // ensure that package bins are always executable
-  // Note that npm-packlist is already filtering out
-  // anything that is not a regular file, ignored by
-  // .npmignore or package.json "files", etc.
-  filter: (path, stat) => {
-    if (isPackageBin(manifest, path))
-      stat.mode |= 0o111
-    return true
-  },
-
-  // Provide a specific date in the 1980s for the benefit of zip,
-  // which is confounded by files dated at the Unix epoch 0.
-  mtime: new Date('1985-10-26T08:15:00.000Z'),
-})
-
-module.exports = tarCreateOptions