@baic/yolk-cli 2.1.0-alpha.9 → 2.1.0-github.0

package/compiled/minimatch/package.json

@@ -0,0 +1 @@
+{"name":"minimatch","author":"Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me)","license":"ISC"}

package/compiled/mkdirp/index.d.ts

@@ -0,0 +1,114 @@
+/// <reference types="node" />
+
+import fs = require('fs');
+
+export declare type FsImplementation = mkdirp.FsImplementation;
+
+export declare type FsImplementationSync = mkdirp.FsImplementationSync;
+
+export declare type manual = mkdirp.manual;
+
+export declare type manualSync = mkdirp.manualSync;
+
+/**
+ * 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.
+ */
+declare function mkdirp(dir: string, opts?: mkdirp.Mode | mkdirp.Options): Promise<string|undefined>;
+
+declare namespace mkdirp {
+    type Mode = number | string | undefined;
+
+    interface FsImplementation {
+        mkdir: typeof fs.mkdir;
+        stat: typeof fs.stat;
+    }
+
+    interface FsImplementationSync {
+        mkdirSync: typeof fs.mkdirSync;
+        statSync: typeof fs.statSync;
+    }
+
+    interface Options {
+        mode?: Mode | undefined;
+        fs?: FsImplementation | undefined;
+    }
+
+    interface OptionsSync {
+        mode?: Mode | undefined;
+        fs?: FsImplementationSync | undefined;
+    }
+
+    /**
+     * 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()`).
+     * 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.
+     * @returns Returns the first directory that had to be created, or undefined if everything already exists.
+     */
+    function sync(dir: string, opts?: Mode | OptionsSync): string|undefined;
+
+    /**
+     * 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.
+     */
+    function manual(dir: string, opts?: Mode | Options): Promise<string|undefined>;
+
+    /**
+     * 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.
+     */
+    function manualSync(dir: string, opts?: Mode | OptionsSync): string|undefined;
+
+    /**
+     * Use the native implementation (not the manual one). This is the default
+     * when the native implementation is available and stat/mkdir are not
+     * overridden.
+     */
+    function native(dir: string, opts?: Mode | Options): Promise<string|undefined>;
+
+    /**
+     * Use the native implementation (not the manual one). This is the default
+     * when the native implementation is available and stat/mkdir are not
+     * overridden.
+     */
+    function nativeSync(dir: string, opts?: Mode | OptionsSync): string|undefined;
+}
+export default mkdirp;
+
+export declare type Mode = mkdirp.Mode;
+
+export declare type native = mkdirp.native;
+
+export declare type nativeSync = mkdirp.nativeSync;
+
+export declare type Options = mkdirp.Options;
+
+export declare type OptionsSync = mkdirp.OptionsSync;
+
+export declare type sync = mkdirp.sync;
+
+export { }

package/compiled/mkdirp/index.js

@@ -0,0 +1,348 @@
+/******/ (function() { // webpackBootstrap
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 86:
+/***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
+
+const optsArg = __nccwpck_require__(642)
+const pathArg = __nccwpck_require__(926)
+
+const {mkdirpNative, mkdirpNativeSync} = __nccwpck_require__(161)
+const {mkdirpManual, mkdirpManualSync} = __nccwpck_require__(130)
+const {useNative, useNativeSync} = __nccwpck_require__(981)
+
+
+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
+
+
+/***/ }),
+
+/***/ 165:
+/***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
+
+const {dirname} = __nccwpck_require__(17)
+
+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}
+
+
+/***/ }),
+
+/***/ 130:
+/***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
+
+const {dirname} = __nccwpck_require__(17)
+
+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}
+
+
+/***/ }),
+
+/***/ 161:
+/***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
+
+const {dirname} = __nccwpck_require__(17)
+const {findMade, findMadeSync} = __nccwpck_require__(165)
+const {mkdirpManual, mkdirpManualSync} = __nccwpck_require__(130)
+
+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}
+
+
+/***/ }),
+
+/***/ 642:
+/***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
+
+const { promisify } = __nccwpck_require__(837)
+const fs = __nccwpck_require__(147)
+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
+
+
+/***/ }),
+
+/***/ 926:
+/***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
+
+const platform = process.env.__TESTING_MKDIRP_PLATFORM__ || process.platform
+const { resolve, parse } = __nccwpck_require__(17)
+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
+
+
+/***/ }),
+
+/***/ 981:
+/***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
+
+const fs = __nccwpck_require__(147)
+
+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}
+
+
+/***/ }),
+
+/***/ 147:
+/***/ (function(module) {
+
+"use strict";
+module.exports = require("fs");
+
+/***/ }),
+
+/***/ 17:
+/***/ (function(module) {
+
+"use strict";
+module.exports = require("path");
+
+/***/ }),
+
+/***/ 837:
+/***/ (function(module) {
+
+"use strict";
+module.exports = require("util");
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __nccwpck_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		var threw = true;
+/******/ 		try {
+/******/ 			__webpack_modules__[moduleId](module, module.exports, __nccwpck_require__);
+/******/ 			threw = false;
+/******/ 		} finally {
+/******/ 			if(threw) delete __webpack_module_cache__[moduleId];
+/******/ 		}
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/compat */
+/******/ 	
+/******/ 	if (typeof __nccwpck_require__ !== 'undefined') __nccwpck_require__.ab = __dirname + "/";
+/******/ 	
+/************************************************************************/
+/******/ 	
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	// This entry module is referenced by other modules so it can't be inlined
+/******/ 	var __webpack_exports__ = __nccwpck_require__(86);
+/******/ 	module.exports = __webpack_exports__;
+/******/ 	
+/******/ })()
+;

package/compiled/mkdirp/package.json

@@ -0,0 +1 @@
+{"name":"mkdirp","license":"MIT"}