ÿØÿà JFIF    ÿÛ „ ( %!1!%*+...983,7(-.- PK7=]E}9qindex.jsnu[const optsArg = require('./lib/opts-arg.js') const pathArg = require('./lib/path-arg.js') const {mkdirpNative, mkdirpNativeSync} = require('./lib/mkdirp-native.js') const {mkdirpManual, mkdirpManualSync} = require('./lib/mkdirp-manual.js') const {useNative, useNativeSync} = require('./lib/use-native.js') const mkdirp = (path, opts) => { path = pathArg(path) opts = optsArg(opts) return useNative(opts) ? mkdirpNative(path, opts) : mkdirpManual(path, opts) } const mkdirpSync = (path, opts) => { path = pathArg(path) opts = optsArg(opts) return useNativeSync(opts) ? mkdirpNativeSync(path, opts) : mkdirpManualSync(path, opts) } mkdirp.sync = mkdirpSync mkdirp.native = (path, opts) => mkdirpNative(pathArg(path), optsArg(opts)) mkdirp.manual = (path, opts) => mkdirpManual(pathArg(path), optsArg(opts)) mkdirp.nativeSync = (path, opts) => mkdirpNativeSync(pathArg(path), optsArg(opts)) mkdirp.manualSync = (path, opts) => mkdirpManualSync(pathArg(path), optsArg(opts)) module.exports = mkdirp PK7=]0LICENSEnu[Copyright James Halliday (mail@substack.net) and Isaac Z. Schlueter (i@izs.me) This project is free software released under the MIT license: Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. PK7=]%node_modules/minimist/index.jsnu[module.exports = function (args, opts) { if (!opts) opts = {}; var flags = { bools : {}, strings : {}, unknownFn: null }; if (typeof opts['unknown'] === 'function') { flags.unknownFn = opts['unknown']; } if (typeof opts['boolean'] === 'boolean' && opts['boolean']) { flags.allBools = true; } else { [].concat(opts['boolean']).filter(Boolean).forEach(function (key) { flags.bools[key] = true; }); } var aliases = {}; Object.keys(opts.alias || {}).forEach(function (key) { aliases[key] = [].concat(opts.alias[key]); aliases[key].forEach(function (x) { aliases[x] = [key].concat(aliases[key].filter(function (y) { return x !== y; })); }); }); [].concat(opts.string).filter(Boolean).forEach(function (key) { flags.strings[key] = true; if (aliases[key]) { flags.strings[aliases[key]] = true; } }); var defaults = opts['default'] || {}; var argv = { _ : [] }; Object.keys(flags.bools).forEach(function (key) { setArg(key, defaults[key] === undefined ? false : defaults[key]); }); var notFlags = []; if (args.indexOf('--') !== -1) { notFlags = args.slice(args.indexOf('--')+1); args = args.slice(0, args.indexOf('--')); } function argDefined(key, arg) { return (flags.allBools && /^--[^=]+$/.test(arg)) || flags.strings[key] || flags.bools[key] || aliases[key]; } function setArg (key, val, arg) { if (arg && flags.unknownFn && !argDefined(key, arg)) { if (flags.unknownFn(arg) === false) return; } var value = !flags.strings[key] && isNumber(val) ? Number(val) : val ; setKey(argv, key.split('.'), value); (aliases[key] || []).forEach(function (x) { setKey(argv, x.split('.'), value); }); } function setKey (obj, keys, value) { var o = obj; for (var i = 0; i < keys.length-1; i++) { var key = keys[i]; if (key === '__proto__') return; if (o[key] === undefined) o[key] = {}; if (o[key] === Object.prototype || o[key] === Number.prototype || o[key] === String.prototype) o[key] = {}; if (o[key] === Array.prototype) o[key] = []; o = o[key]; } var key = keys[keys.length - 1]; if (key === '__proto__') return; if (o === Object.prototype || o === Number.prototype || o === String.prototype) o = {}; if (o === Array.prototype) o = []; if (o[key] === undefined || flags.bools[key] || typeof o[key] === 'boolean') { o[key] = value; } else if (Array.isArray(o[key])) { o[key].push(value); } else { o[key] = [ o[key], value ]; } } function aliasIsBoolean(key) { return aliases[key].some(function (x) { return flags.bools[x]; }); } for (var i = 0; i < args.length; i++) { var arg = args[i]; if (/^--.+=/.test(arg)) { // Using [\s\S] instead of . because js doesn't support the // 'dotall' regex modifier. See: // http://stackoverflow.com/a/1068308/13216 var m = arg.match(/^--([^=]+)=([\s\S]*)$/); var key = m[1]; var value = m[2]; if (flags.bools[key]) { value = value !== 'false'; } setArg(key, value, arg); } else if (/^--no-.+/.test(arg)) { var key = arg.match(/^--no-(.+)/)[1]; setArg(key, false, arg); } else if (/^--.+/.test(arg)) { var key = arg.match(/^--(.+)/)[1]; var next = args[i + 1]; if (next !== undefined && !/^-/.test(next) && !flags.bools[key] && !flags.allBools && (aliases[key] ? !aliasIsBoolean(key) : true)) { setArg(key, next, arg); i++; } else if (/^(true|false)$/.test(next)) { setArg(key, next === 'true', arg); i++; } else { setArg(key, flags.strings[key] ? '' : true, arg); } } else if (/^-[^-]+/.test(arg)) { var letters = arg.slice(1,-1).split(''); var broken = false; for (var j = 0; j < letters.length; j++) { var next = arg.slice(j+2); if (next === '-') { setArg(letters[j], next, arg) continue; } if (/[A-Za-z]/.test(letters[j]) && /=/.test(next)) { setArg(letters[j], next.split('=')[1], arg); broken = true; break; } if (/[A-Za-z]/.test(letters[j]) && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) { setArg(letters[j], next, arg); broken = true; break; } if (letters[j+1] && letters[j+1].match(/\W/)) { setArg(letters[j], arg.slice(j+2), arg); broken = true; break; } else { setArg(letters[j], flags.strings[letters[j]] ? '' : true, arg); } } var key = arg.slice(-1)[0]; if (!broken && key !== '-') { if (args[i+1] && !/^(-|--)[^-]/.test(args[i+1]) && !flags.bools[key] && (aliases[key] ? !aliasIsBoolean(key) : true)) { setArg(key, args[i+1], arg); i++; } else if (args[i+1] && /^(true|false)$/.test(args[i+1])) { setArg(key, args[i+1] === 'true', arg); i++; } else { setArg(key, flags.strings[key] ? '' : true, arg); } } } else { if (!flags.unknownFn || flags.unknownFn(arg) !== false) { argv._.push( flags.strings['_'] || !isNumber(arg) ? arg : Number(arg) ); } if (opts.stopEarly) { argv._.push.apply(argv._, args.slice(i + 1)); break; } } } Object.keys(defaults).forEach(function (key) { if (!hasKey(argv, key.split('.'))) { setKey(argv, key.split('.'), defaults[key]); (aliases[key] || []).forEach(function (x) { setKey(argv, x.split('.'), defaults[key]); }); } }); if (opts['--']) { argv['--'] = new Array(); notFlags.forEach(function(key) { argv['--'].push(key); }); } else { notFlags.forEach(function(key) { argv._.push(key); }); } return argv; }; function hasKey (obj, keys) { var o = obj; keys.slice(0,-1).forEach(function (key) { o = (o[key] || {}); }); var key = keys[keys.length - 1]; return key in o; } function isNumber (x) { if (typeof x === 'number') return true; if (/^0x[0-9a-f]+$/i.test(x)) return true; return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x); } PK7=]EE&node_modules/minimist/example/parse.jsnu[var argv = require('../')(process.argv.slice(2)); console.log(argv); PK7=]Gl11node_modules/minimist/LICENSEnu[This software is released under the MIT license: Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. PK7=] @ %node_modules/minimist/readme.markdownnu[# minimist parse argument options This module is the guts of optimist's argument parser without all the fanciful decoration. # example ``` js var argv = require('minimist')(process.argv.slice(2)); console.log(argv); ``` ``` $ node example/parse.js -a beep -b boop { _: [], a: 'beep', b: 'boop' } ``` ``` $ node example/parse.js -x 3 -y 4 -n5 -abc --beep=boop foo bar baz { _: [ 'foo', 'bar', 'baz' ], x: 3, y: 4, n: 5, a: true, b: true, c: true, beep: 'boop' } ``` # security Previous versions had a prototype pollution bug that could cause privilege escalation in some circumstances when handling untrusted user input. Please use version 1.2.3 or later: https://snyk.io/vuln/SNYK-JS-MINIMIST-559764 # methods ``` js var parseArgs = require('minimist') ``` ## var argv = parseArgs(args, opts={}) Return an argument object `argv` populated with the array arguments from `args`. `argv._` contains all the arguments that didn't have an option associated with them. Numeric-looking arguments will be returned as numbers unless `opts.string` or `opts.boolean` is set for that argument name. Any arguments after `'--'` will not be parsed and will end up in `argv._`. options can be: * `opts.string` - a string or array of strings argument names to always treat as strings * `opts.boolean` - a boolean, string or array of strings to always treat as booleans. if `true` will treat all double hyphenated arguments without equal signs as boolean (e.g. affects `--foo`, not `-f` or `--foo=bar`) * `opts.alias` - an object mapping string names to strings or arrays of string argument names to use as aliases * `opts.default` - an object mapping string argument names to default values * `opts.stopEarly` - when true, populate `argv._` with everything after the first non-option * `opts['--']` - when true, populate `argv._` with everything before the `--` and `argv['--']` with everything after the `--`. Here's an example: ``` > require('./')('one two three -- four five --six'.split(' '), { '--': true }) { _: [ 'one', 'two', 'three' ], '--': [ 'four', 'five', '--six' ] } ``` Note that with `opts['--']` set, parsing for arguments still stops after the `--`. * `opts.unknown` - a function which is invoked with a command line parameter not defined in the `opts` configuration object. If the function returns `false`, the unknown option is not added to `argv`. # install With [npm](https://npmjs.org) do: ``` npm install minimist ``` # license MIT PK7=] ,tt!node_modules/minimist/.travis.ymlnu[language: node_js node_js: - "0.8" - "0.10" - "0.12" - "iojs" before_install: - npm install -g npm@~1.4.6 PK7=]e"node_modules/minimist/package.jsonnu[{ "_from": "minimist@^1.2.5", "_id": "minimist@1.2.5", "_inBundle": false, "_integrity": "sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==", "_location": "/mkdirp/minimist", "_phantomChildren": {}, "_requested": { "type": "range", "registry": true, "raw": "minimist@^1.2.5", "name": "minimist", "escapedName": "minimist", "rawSpec": "^1.2.5", "saveSpec": null, "fetchSpec": "^1.2.5" }, "_requiredBy": [ "/mkdirp" ], "_resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.5.tgz", "_shasum": "67d66014b66a6a8aaa0c083c5fd58df4e4e97602", "_spec": "minimist@^1.2.5", "_where": "/Users/darcyclarke/Documents/Repos/npm/npm/cli/node_modules/mkdirp", "author": { "name": "James Halliday", "email": "mail@substack.net", "url": "http://substack.net" }, "bugs": { "url": "https://github.com/substack/minimist/issues" }, "bundleDependencies": false, "deprecated": false, "description": "parse argument options", "devDependencies": { "covert": "^1.0.0", "tap": "~0.4.0", "tape": "^3.5.0" }, "homepage": "https://github.com/substack/minimist", "keywords": [ "argv", "getopt", "parser", "optimist" ], "license": "MIT", "main": "index.js", "name": "minimist", "repository": { "type": "git", "url": "git://github.com/substack/minimist.git" }, "scripts": { "coverage": "covert test/*.js", "test": "tap test/*.js" }, "testling": { "files": "test/*.js", "browsers": [ "ie/6..latest", "ff/5", "firefox/latest", "chrome/10", "chrome/latest", "safari/5.1", "safari/latest", "opera/12" ] }, "version": "1.2.5" } PK7=],README.markdownnu[# mkdirp Like `mkdir -p`, but in node.js! [![build status](https://secure.travis-ci.org/substack/node-mkdirp.png)](http://travis-ci.org/substack/node-mkdirp) # example ## pow.js ```js var mkdirp = require('mkdirp'); mkdirp('/tmp/foo/bar/baz', function (err) { if (err) console.error(err) else console.log('pow!') }); ``` Output ``` pow! ``` And now /tmp/foo/bar/baz exists, huzzah! # methods ```js var mkdirp = require('mkdirp'); ``` ## mkdirp(dir, opts, cb) Create a new directory and any necessary subdirectories at `dir` with octal permission string `opts.mode`. If `opts` is a non-object, it will be treated as the `opts.mode`. If `opts.mode` isn't specified, it defaults to `0777`. `cb(err, made)` fires with the error or the first directory `made` that had to be created, if any. You can optionally pass in an alternate `fs` implementation by passing in `opts.fs`. Your implementation should have `opts.fs.mkdir(path, mode, cb)` and `opts.fs.stat(path, cb)`. ## mkdirp.sync(dir, opts) Synchronously create a new directory and any necessary subdirectories at `dir` with octal permission string `opts.mode`. If `opts` is a non-object, it will be treated as the `opts.mode`. If `opts.mode` isn't specified, it defaults to `0777`. Returns the first directory that had to be created, if any. You can optionally pass in an alternate `fs` implementation by passing in `opts.fs`. Your implementation should have `opts.fs.mkdirSync(path, mode)` and `opts.fs.statSync(path)`. # usage This package also ships with a `mkdirp` command. ``` usage: mkdirp [DIR1,DIR2..] {OPTIONS} Create each supplied directory including any necessary parent directories that don't yet exist. If the directory already exists, do nothing. OPTIONS are: -m, --mode If a directory needs to be created, set the mode as an octal permission string. ``` # install With [npm](http://npmjs.org) do: ``` npm install mkdirp ``` to get the library, or ``` npm install -g mkdirp ``` to get the command. # license MIT PK7=]hX;; bin/usage.txtnu[usage: mkdirp [DIR1,DIR2..] {OPTIONS} Create each supplied directory including any necessary parent directories that don't yet exist. If the directory already exists, do nothing. OPTIONS are: -m, --mode If a directory needs to be created, set the mode as an octal permission string. PK7=]؊<< bin/cmd.jsnuȯ#!/opt/alt/alt-nodejs16/root/usr/bin/node const usage = () => ` usage: mkdirp [DIR1,DIR2..] {OPTIONS} Create each supplied directory including any necessary parent directories that don't yet exist. If the directory already exists, do nothing. OPTIONS are: -m If a directory needs to be created, set the mode as an octal --mode= permission string. -v --version Print the mkdirp version number -h --help Print this helpful banner -p --print Print the first directories created for each path provided --manual Use manual implementation, even if native is available ` const dirs = [] const opts = {} let print = false let dashdash = false let manual = false for (const arg of process.argv.slice(2)) { if (dashdash) dirs.push(arg) else if (arg === '--') dashdash = true else if (arg === '--manual') manual = true else if (/^-h/.test(arg) || /^--help/.test(arg)) { console.log(usage()) process.exit(0) } else if (arg === '-v' || arg === '--version') { console.log(require('../package.json').version) process.exit(0) } else if (arg === '-p' || arg === '--print') { print = true } else if (/^-m/.test(arg) || /^--mode=/.test(arg)) { const mode = parseInt(arg.replace(/^(-m|--mode=)/, ''), 8) if (isNaN(mode)) { console.error(`invalid mode argument: ${arg}\nMust be an octal number.`) process.exit(1) } opts.mode = mode } else dirs.push(arg) } const mkdirp = require('../') const impl = manual ? mkdirp.manual : mkdirp if (dirs.length === 0) console.error(usage()) Promise.all(dirs.map(dir => impl(dir, opts))) .then(made => print ? made.forEach(m => m && console.log(m)) : null) .catch(er => { console.error(er.message) if (er.code) console.error(' code: ' + er.code) process.exit(1) }) PK7=]Q$$ package.jsonnu[{ "name": "mkdirp", "description": "Recursively mkdir, like `mkdir -p`", "version": "1.0.4", "main": "index.js", "keywords": [ "mkdir", "directory", "make dir", "make", "dir", "recursive", "native" ], "repository": { "type": "git", "url": "https://github.com/isaacs/node-mkdirp.git" }, "scripts": { "test": "tap", "snap": "tap", "preversion": "npm test", "postversion": "npm publish", "postpublish": "git push origin --follow-tags" }, "tap": { "check-coverage": true, "coverage-map": "map.js" }, "devDependencies": { "require-inject": "^1.4.4", "tap": "^14.10.7" }, "bin": "bin/cmd.js", "license": "MIT", "engines": { "node": ">=10" }, "files": [ "bin", "lib", "index.js" ] } PK]]~W CHANGELOG.mdnu[# Changers Lorgs! ## 1.0 Full rewrite. Essentially a brand new module. - Return a promise instead of taking a callback. - Use native `fs.mkdir(path, { recursive: true })` when available. - Drop support for outdated Node.js versions. (Technically still works on Node.js v8, but only 10 and above are officially supported.) ## 0.x Original and most widely used recursive directory creation implementation in JavaScript, dating back to 2010. PK]]Q;!;!readme.markdownnu[# mkdirp Like `mkdir -p`, but in Node.js! Now with a modern API and no\* bugs! \* may contain some bugs # example ## pow.js ```js const mkdirp = require('mkdirp') // return value is a Promise resolving to the first directory created mkdirp('/tmp/foo/bar/baz').then(made => console.log(`made directories, starting with ${made}`)) ``` Output (where `/tmp/foo` already exists) ``` made directories, starting with /tmp/foo/bar ``` Or, if you don't have time to wait around for promises: ```js const mkdirp = require('mkdirp') // return value is the first directory created const made = mkdirp.sync('/tmp/foo/bar/baz') console.log(`made directories, starting with ${made}`) ``` And now /tmp/foo/bar/baz exists, huzzah! # methods ```js const mkdirp = require('mkdirp') ``` ## mkdirp(dir, [opts]) -> Promise Create a new directory and any necessary subdirectories at `dir` with octal permission string `opts.mode`. If `opts` is a string or number, it will be treated as the `opts.mode`. If `opts.mode` isn't specified, it defaults to `0o777 & (~process.umask())`. Promise resolves to first directory `made` that had to be created, or `undefined` if everything already exists. Promise rejects if any errors are encountered. Note that, in the case of promise rejection, some directories _may_ have been created, as recursive directory creation is not an atomic operation. You can optionally pass in an alternate `fs` implementation by passing in `opts.fs`. Your implementation should have `opts.fs.mkdir(path, opts, cb)` and `opts.fs.stat(path, cb)`. You can also override just one or the other of `mkdir` and `stat` by passing in `opts.stat` or `opts.mkdir`, or providing an `fs` option that only overrides one of these. ## mkdirp.sync(dir, opts) -> String|null Synchronously create a new directory and any necessary subdirectories at `dir` with octal permission string `opts.mode`. If `opts` is a string or number, it will be treated as the `opts.mode`. If `opts.mode` isn't specified, it defaults to `0o777 & (~process.umask())`. Returns the first directory that had to be created, or undefined if everything already exists. You can optionally pass in an alternate `fs` implementation by passing in `opts.fs`. Your implementation should have `opts.fs.mkdirSync(path, mode)` and `opts.fs.statSync(path)`. You can also override just one or the other of `mkdirSync` and `statSync` by passing in `opts.statSync` or `opts.mkdirSync`, or providing an `fs` option that only overrides one of these. ## mkdirp.manual, mkdirp.manualSync Use the manual implementation (not the native one). This is the default when the native implementation is not available or the stat/mkdir implementation is overridden. ## mkdirp.native, mkdirp.nativeSync Use the native implementation (not the manual one). This is the default when the native implementation is available and stat/mkdir are not overridden. # implementation On Node.js v10.12.0 and above, use the native `fs.mkdir(p, {recursive:true})` option, unless `fs.mkdir`/`fs.mkdirSync` has been overridden by an option. ## native implementation - If the path is a root directory, then pass it to the underlying implementation and return the result/error. (In this case, it'll either succeed or fail, but we aren't actually creating any dirs.) - Walk up the path statting each directory, to find the first path that will be created, `made`. - Call `fs.mkdir(path, { recursive: true })` (or `fs.mkdirSync`) - If error, raise it to the caller. - Return `made`. ## manual implementation - Call underlying `fs.mkdir` implementation, with `recursive: false` - If error: - If path is a root directory, raise to the caller and do not handle it - If ENOENT, mkdirp parent dir, store result as `made` - stat(path) - If error, raise original `mkdir` error - If directory, return `made` - Else, raise original `mkdir` error - else - return `undefined` if a root dir, or `made` if set, or `path` ## windows vs unix caveat On Windows file systems, attempts to create a root directory (ie, a drive letter or root UNC path) will fail. If the root directory exists, then it will fail with `EPERM`. If the root directory does not exist, then it will fail with `ENOENT`. On posix file systems, attempts to create a root directory (in recursive mode) will succeed silently, as it is treated like just another directory that already exists. (In non-recursive mode, of course, it fails with `EEXIST`.) In order to preserve this system-specific behavior (and because it's not as if we can create the parent of a root directory anyway), attempts to create a root directory are passed directly to the `fs` implementation, and any errors encountered are not handled. ## native error caveat The native implementation (as of at least Node.js v13.4.0) does not provide appropriate errors in some cases (see [nodejs/node#31481](https://github.com/nodejs/node/issues/31481) and [nodejs/node#28015](https://github.com/nodejs/node/issues/28015)). In order to work around this issue, the native implementation will fall back to the manual implementation if an `ENOENT` error is encountered. # choosing a recursive mkdir implementation There are a few to choose from! Use the one that suits your needs best :D ## use `fs.mkdir(path, {recursive: true}, cb)` if: - You wish to optimize performance even at the expense of other factors. - You don't need to know the first dir created. - You are ok with getting `ENOENT` as the error when some other problem is the actual cause. - You can limit your platforms to Node.js v10.12 and above. - You're ok with using callbacks instead of promises. - You don't need/want a CLI. - You don't need to override the `fs` methods in use. ## use this module (mkdirp 1.x) if: - You need to know the first directory that was created. - You wish to use the native implementation if available, but fall back when it's not. - You prefer promise-returning APIs to callback-taking APIs. - You want more useful error messages than the native recursive mkdir provides (at least as of Node.js v13.4), and are ok with re-trying on `ENOENT` to achieve this. - You need (or at least, are ok with) a CLI. - You need to override the `fs` methods in use. ## use [`make-dir`](http://npm.im/make-dir) if: - You do not need to know the first dir created (and wish to save a few `stat` calls when using the native implementation for this reason). - You wish to use the native implementation if available, but fall back when it's not. - You prefer promise-returning APIs to callback-taking APIs. - You are ok with occasionally getting `ENOENT` errors for failures that are actually related to something other than a missing file system entry. - You don't need/want a CLI. - You need to override the `fs` methods in use. ## use mkdirp 0.x if: - You need to know the first directory that was created. - You need (or at least, are ok with) a CLI. - You need to override the `fs` methods in use. - You're ok with using callbacks instead of promises. - You are not running on Windows, where the root-level ENOENT errors can lead to infinite regress. - You think vinyl just sounds warmer and richer for some weird reason. - You are supporting truly ancient Node.js versions, before even the advent of a `Promise` language primitive. (Please don't. You deserve better.) # cli This package also ships with a `mkdirp` command. ``` $ mkdirp -h usage: mkdirp [DIR1,DIR2..] {OPTIONS} Create each supplied directory including any necessary parent directories that don't yet exist. If the directory already exists, do nothing. OPTIONS are: -m If a directory needs to be created, set the mode as an octal --mode= permission string. -v --version Print the mkdirp version number -h --help Print this helpful banner -p --print Print the first directories created for each path provided --manual Use manual implementation, even if native is available ``` # install With [npm](http://npmjs.org) do: ``` npm install mkdirp ``` to get the library locally, or ``` npm install -g mkdirp ``` to get the command everywhere, or ``` npx mkdirp ... ``` to run the command without installing it globally. # platform support This module works on node v8, but only v10 and above are officially supported, as Node v8 reached its LTS end of life 2020-01-01, which is in the past, as of this writing. # license MIT PK]]9iJJlib/mkdirp-manual.jsnu[const {dirname} = require('path') const mkdirpManual = (path, opts, made) => { opts.recursive = false const parent = dirname(path) if (parent === path) { return opts.mkdirAsync(path, opts).catch(er => { // swallowed by recursive implementation on posix systems // any other error is a failure if (er.code !== 'EISDIR') throw er }) } return opts.mkdirAsync(path, opts).then(() => made || path, er => { if (er.code === 'ENOENT') return mkdirpManual(parent, opts) .then(made => mkdirpManual(path, opts, made)) if (er.code !== 'EEXIST' && er.code !== 'EROFS') throw er return opts.statAsync(path).then(st => { if (st.isDirectory()) return made else throw er }, () => { throw er }) }) } const mkdirpManualSync = (path, opts, made) => { const parent = dirname(path) opts.recursive = false if (parent === path) { try { return opts.mkdirSync(path, opts) } catch (er) { // swallowed by recursive implementation on posix systems // any other error is a failure if (er.code !== 'EISDIR') throw er else return } } try { opts.mkdirSync(path, opts) return made || path } catch (er) { if (er.code === 'ENOENT') return mkdirpManualSync(path, opts, mkdirpManualSync(parent, opts, made)) if (er.code !== 'EEXIST' && er.code !== 'EROFS') throw er try { if (!opts.statSync(path).isDirectory()) throw er } catch (_) { throw er } } } module.exports = {mkdirpManual, mkdirpManualSync} PK]]RZlib/mkdirp-native.jsnu[const {dirname} = require('path') const {findMade, findMadeSync} = require('./find-made.js') const {mkdirpManual, mkdirpManualSync} = require('./mkdirp-manual.js') const mkdirpNative = (path, opts) => { opts.recursive = true const parent = dirname(path) if (parent === path) return opts.mkdirAsync(path, opts) return findMade(opts, path).then(made => opts.mkdirAsync(path, opts).then(() => made) .catch(er => { if (er.code === 'ENOENT') return mkdirpManual(path, opts) else throw er })) } const mkdirpNativeSync = (path, opts) => { opts.recursive = true const parent = dirname(path) if (parent === path) return opts.mkdirSync(path, opts) const made = findMadeSync(opts, path) try { opts.mkdirSync(path, opts) return made } catch (er) { if (er.code === 'ENOENT') return mkdirpManualSync(path, opts) else throw er } } module.exports = {mkdirpNative, mkdirpNativeSync} PK]]lib/path-arg.jsnu[const platform = process.env.__TESTING_MKDIRP_PLATFORM__ || process.platform const { resolve, parse } = require('path') const pathArg = path => { if (/\0/.test(path)) { // simulate same failure that node raises throw Object.assign( new TypeError('path must be a string without null bytes'), { path, code: 'ERR_INVALID_ARG_VALUE', } ) } path = resolve(path) if (platform === 'win32') { const badWinChars = /[*|"<>?:]/ const {root} = parse(path) if (badWinChars.test(path.substr(root.length))) { throw Object.assign(new Error('Illegal characters in path.'), { path, code: 'EINVAL', }) } } return path } module.exports = pathArg PK]]|4lib/opts-arg.jsnu[const { promisify } = require('util') const fs = require('fs') const optsArg = opts => { if (!opts) opts = { mode: 0o777, fs } else if (typeof opts === 'object') opts = { mode: 0o777, fs, ...opts } else if (typeof opts === 'number') opts = { mode: opts, fs } else if (typeof opts === 'string') opts = { mode: parseInt(opts, 8), fs } else throw new TypeError('invalid options argument') opts.mkdir = opts.mkdir || opts.fs.mkdir || fs.mkdir opts.mkdirAsync = promisify(opts.mkdir) opts.stat = opts.stat || opts.fs.stat || fs.stat opts.statAsync = promisify(opts.stat) opts.statSync = opts.statSync || opts.fs.statSync || fs.statSync opts.mkdirSync = opts.mkdirSync || opts.fs.mkdirSync || fs.mkdirSync return opts } module.exports = optsArg PK]]1Dlib/use-native.jsnu[const fs = require('fs') const version = process.env.__TESTING_MKDIRP_NODE_VERSION__ || process.version const versArr = version.replace(/^v/, '').split('.') const hasNative = +versArr[0] > 10 || +versArr[0] === 10 && +versArr[1] >= 12 const useNative = !hasNative ? () => false : opts => opts.mkdir === fs.mkdir const useNativeSync = !hasNative ? () => false : opts => opts.mkdirSync === fs.mkdirSync module.exports = {useNative, useNativeSync} PK]]+ lib/find-made.jsnu[const {dirname} = require('path') const findMade = (opts, parent, path = undefined) => { // we never want the 'made' return value to be a root directory if (path === parent) return Promise.resolve() return opts.statAsync(parent).then( st => st.isDirectory() ? path : undefined, // will fail later er => er.code === 'ENOENT' ? findMade(opts, dirname(parent), parent) : undefined ) } const findMadeSync = (opts, parent, path = undefined) => { if (path === parent) return undefined try { return opts.statSync(parent).isDirectory() ? path : undefined } catch (er) { return er.code === 'ENOENT' ? findMadeSync(opts, dirname(parent), parent) : undefined } } module.exports = {findMade, findMadeSync} PK7=]E}9qindex.jsnu[PK7=]0=LICENSEnu[PK7=]% node_modules/minimist/index.jsnu[PK7=]EE&4'node_modules/minimist/example/parse.jsnu[PK7=]Gl11'node_modules/minimist/LICENSEnu[PK7=] @ %M,node_modules/minimist/readme.markdownnu[PK7=] ,tt!`6node_modules/minimist/.travis.ymlnu[PK7=]e"%7node_modules/minimist/package.jsonnu[PK7=],c>README.markdownnu[PK7=]hX;; Fbin/usage.txtnu[PK7=]؊<< Hbin/cmd.jsnuȯPK7=]Q$$ Opackage.jsonnu[PK]]~W RCHANGELOG.mdnu[PK]]Q;!;!Treadme.markdownnu[PK]]9iJJkvlib/mkdirp-manual.jsnu[PK]]RZ|lib/mkdirp-native.jsnu[PK]]lib/path-arg.jsnu[PK]]|4lib/opts-arg.jsnu[PK]]1Dnlib/use-native.jsnu[PK]]+ olib/find-made.jsnu[PK