@gradientedge/cdk-utils 8.16.0 → 8.18.0

package/app/api-destined-function/node_modules/mkdirp/package.json

@@ -1,8 +1,7 @@
 {
   "name": "mkdirp",
   "description": "Recursively mkdir, like `mkdir -p`",
-  "version": "1.0.4",
-  "main": "index.js",
+  "version": "2.1.3",
   "keywords": [
     "mkdir",
     "directory",
@@ -12,33 +11,80 @@
     "recursive",
     "native"
   ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/isaacs/node-mkdirp.git"
+  "main": "./dist/cjs/src/index-cjs.js",
+  "module": "./dist/mjs/index.js",
+  "bin": "./dist/cjs/src/bin.js",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/mjs/index.d.ts",
+        "default": "./dist/mjs/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/src/index-cjs.d.ts",
+        "default": "./dist/cjs/src/index-cjs.js"
+      }
+    }
   },
+  "files": [
+    "dist"
+  ],
   "scripts": {
-    "test": "tap",
-    "snap": "tap",
     "preversion": "npm test",
     "postversion": "npm publish",
-    "postpublish": "git push origin --follow-tags"
+    "prepublishOnly": "git push origin --follow-tags",
+    "preprepare": "rm -rf dist",
+    "prepare": "tsc -p tsconfig.json && tsc -p tsconfig-esm.json",
+    "postprepare": "bash fixup.sh",
+    "pretest": "npm run prepare",
+    "presnap": "npm run prepare",
+    "test": "c8 tap",
+    "snap": "c8 tap",
+    "format": "prettier --write . --loglevel warn",
+    "benchmark": "node benchmark/index.js",
+    "typedoc": "typedoc --tsconfig tsconfig-esm.json ./src/*.ts"
   },
-  "tap": {
-    "check-coverage": true,
-    "coverage-map": "map.js"
+  "prettier": {
+    "semi": false,
+    "printWidth": 80,
+    "tabWidth": 2,
+    "useTabs": false,
+    "singleQuote": true,
+    "jsxSingleQuote": false,
+    "bracketSameLine": true,
+    "arrowParens": "avoid",
+    "endOfLine": "lf"
   },
   "devDependencies": {
-    "require-inject": "^1.4.4",
-    "tap": "^14.10.7"
+    "@types/brace-expansion": "^1.1.0",
+    "@types/node": "^18.11.9",
+    "@types/tap": "^15.0.7",
+    "c8": "^7.12.0",
+    "eslint-config-prettier": "^8.6.0",
+    "prettier": "^2.8.2",
+    "tap": "^16.3.3",
+    "ts-node": "^10.9.1",
+    "typedoc": "^0.23.21",
+    "typescript": "^4.9.3"
+  },
+  "tap": {
+    "coverage": false,
+    "node-arg": [
+      "--no-warnings",
+      "--loader",
+      "ts-node/esm"
+    ],
+    "ts": false
+  },
+  "funding": {
+    "url": "https://github.com/sponsors/isaacs"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/isaacs/node-mkdirp.git"
   },
-  "bin": "bin/cmd.js",
   "license": "MIT",
   "engines": {
     "node": ">=10"
-  },
-  "files": [
-    "bin",
-    "lib",
-    "index.js"
-  ]
+  }
 }

package/app/api-destined-function/node_modules/mkdirp/readme.markdown

@@ -11,11 +11,15 @@ Now with a modern API and no\* bugs!
 ## pow.js
 
 ```js
-const mkdirp = require('mkdirp')
+// hybrid module, import or require() both work
+import { mkdirp } from 'mkdirp'
+// or:
+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}`))
+  console.log(`made directories, starting with ${made}`)
+)
 ```
 
 Output (where `/tmp/foo` already exists)
@@ -27,7 +31,7 @@ made directories, starting with /tmp/foo/bar
 Or, if you don't have time to wait around for promises:
 
 ```js
-const mkdirp = require('mkdirp')
+import { mkdirp } from 'mkdirp'
 
 // return value is the first directory created
 const made = mkdirp.sync('/tmp/foo/bar/baz')
@@ -39,86 +43,88 @@ And now /tmp/foo/bar/baz exists, huzzah!
 # methods
 
 ```js
-const mkdirp = require('mkdirp')
+import { mkdirp } from 'mkdirp'
 ```
 
-## mkdirp(dir, [opts]) -> Promise<String | undefined>
+## `mkdirp(dir: string, opts?: MkdirpOptions) => Promise<string | undefined>`
 
-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`.
+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())`.
+If `opts.mode` isn't specified, it defaults to `0o777`.
 
-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.
+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 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.
+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
+## `mkdirp.sync(dir: string, opts: MkdirpOptions) => string|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`.
+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())`.
+If `opts.mode` isn't specified, it defaults to `0o777`.
 
-Returns the first directory that had to be created, or undefined if
-everything already exists.
+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 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.
+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
+## `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.
+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
+## `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.
+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.
+{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`.
+  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`
+- 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 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
@@ -129,67 +135,74 @@ overridden by an option.
 
 ## 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 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`.)
+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.
+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
+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.
+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
+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 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 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:
+## use this module (mkdirp 1.x or 2.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 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 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 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 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.
 
@@ -199,11 +212,13 @@ There are a few to choose from!  Use the one that suits your needs best :D
 - 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.)
+- 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
 

package/app/api-destined-function/package.json

@@ -23,7 +23,7 @@
     "uuid": "^9.0.0"
   },
   "devDependencies": {
-    "mkdirp": "^1.0.4",
+    "mkdirp": "^2.1.3",
     "rimraf": "^3.0.2"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gradientedge/cdk-utils",
-  "version": "8.16.0",
+  "version": "8.18.0",
   "description": "Utilities for AWS CDK provisioning",
   "main": "dist/index.js",
   "engines": {
@@ -38,7 +38,7 @@
     "prettier": "npx prettier --check \"**/*.{ts,json,md}\"",
     "prettify": "npx prettier --write \"**/*.{ts,json,md}\"",
     "test": "rimraf coverage && npx jest --ci --maxWorkers=100%",
-    "update:deps": "ncu -u -x lerna -x semantic-release",
+    "update:deps": "ncu -u -x lerna,semantic-release",
     "validate": "yarn prettier && yarn test"
   },
   "husky": {
@@ -48,11 +48,11 @@
   },
   "dependencies": {
     "@types/lodash": "^4.14.191",
-    "@types/node": "^18.11.18",
+    "@types/node": "^18.13.0",
     "app-root-path": "^3.1.0",
-    "aws-cdk-lib": "^2.63.1",
-    "aws-sdk": "^2.1309.0",
-    "constructs": "^10.1.240",
+    "aws-cdk-lib": "^2.64.0",
+    "aws-sdk": "^2.1316.0",
+    "constructs": "^10.1.251",
     "lodash": "^4.17.21",
     "moment": "^2.29.4",
     "nconf": "^0.12.0",
@@ -62,26 +62,26 @@
   "devDependencies": {
     "@babel/plugin-proposal-class-properties": "^7.18.6",
     "@types/jest": "^29.4.0",
-    "@typescript-eslint/eslint-plugin": "^5.50.0",
-    "@typescript-eslint/parser": "^5.50.0",
+    "@typescript-eslint/eslint-plugin": "^5.52.0",
+    "@typescript-eslint/parser": "^5.52.0",
     "aws-cdk": "*",
     "babel-eslint": "^10.1.0",
     "better-docs": "^2.7.2",
     "codecov": "^3.8.3",
     "commitizen": "^4.3.0",
     "dotenv": "^16.0.3",
-    "eslint": "^8.33.0",
+    "eslint": "^8.34.0",
     "eslint-config-prettier": "^8.6.0",
     "eslint-plugin-import": "^2.27.5",
     "husky": "^8.0.3",
-    "jest": "^29.4.1",
+    "jest": "^29.4.3",
     "jest-extended": "^3.2.3",
     "jest-junit": "^15.0.0",
     "jsdoc": "^4.0.0",
     "jsdoc-babel": "^0.5.0",
     "jsdoc-mermaid": "^1.0.0",
     "lerna": "^5.6.2",
-    "prettier": "^2.8.3",
+    "prettier": "^2.8.4",
     "prettier-plugin-organize-imports": "^3.2.2",
     "rimraf": "^4.1.2",
     "semantic-release": "^19.0.5",

package/app/api-destined-function/node_modules/mkdirp/bin/cmd.js

@@ -1,68 +0,0 @@
-#!/usr/bin/env 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<mode>       If a directory needs to be created, set the mode as an octal
-  --mode=<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)
-  })

package/app/api-destined-function/node_modules/mkdirp/index.js

@@ -1,31 +0,0 @@
-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

package/app/api-destined-function/node_modules/mkdirp/lib/find-made.js

@@ -1,29 +0,0 @@
-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}

package/app/api-destined-function/node_modules/mkdirp/lib/mkdirp-manual.js

@@ -1,64 +0,0 @@
-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}