@rushstack/rush-http-build-cache-plugin 5.92.0

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/5c/npa_5c7f076d9565dfd59727d5116cf9ccd7

@@ -0,0 +1,302 @@
+2a05f1fd92e7f6811efa0541acd6a8be
+'use strict'
+module.exports = npa
+module.exports.resolve = resolve
+module.exports.Result = Result
+
+let url
+let HostedGit
+let semver
+let path_
+function path () {
+  if (!path_) path_ = require('path')
+  return path_
+}
+let validatePackageName
+let osenv
+
+const isWindows = process.platform === 'win32' || global.FAKE_WINDOWS
+const hasSlashes = isWindows ? /\\|[/]/ : /[/]/
+const isURL = /^(?:git[+])?[a-z]+:/i
+const isFilename = /[.](?:tgz|tar.gz|tar)$/i
+
+function npa (arg, where) {
+  let name
+  let spec
+  if (typeof arg === 'object') {
+    if (arg instanceof Result && (!where || where === arg.where)) {
+      return arg
+    } else if (arg.name && arg.rawSpec) {
+      return npa.resolve(arg.name, arg.rawSpec, where || arg.where)
+    } else {
+      return npa(arg.raw, where || arg.where)
+    }
+  }
+  const nameEndsAt = arg[0] === '@' ? arg.slice(1).indexOf('@') + 1 : arg.indexOf('@')
+  const namePart = nameEndsAt > 0 ? arg.slice(0, nameEndsAt) : arg
+  if (isURL.test(arg)) {
+    spec = arg
+  } else if (namePart[0] !== '@' && (hasSlashes.test(namePart) || isFilename.test(namePart))) {
+    spec = arg
+  } else if (nameEndsAt > 0) {
+    name = namePart
+    spec = arg.slice(nameEndsAt + 1)
+  } else {
+    if (!validatePackageName) validatePackageName = require('validate-npm-package-name')
+    const valid = validatePackageName(arg)
+    if (valid.validForOldPackages) {
+      name = arg
+    } else {
+      spec = arg
+    }
+  }
+  return resolve(name, spec, where, arg)
+}
+
+const isFilespec = isWindows ? /^(?:[.]|~[/]|[/\\]|[a-zA-Z]:)/ : /^(?:[.]|~[/]|[/]|[a-zA-Z]:)/
+
+function resolve (name, spec, where, arg) {
+  const res = new Result({
+    raw: arg,
+    name: name,
+    rawSpec: spec,
+    fromArgument: arg != null
+  })
+
+  if (name) res.setName(name)
+
+  if (spec && (isFilespec.test(spec) || /^file:/i.test(spec))) {
+    return fromFile(res, where)
+  } else if (spec && /^npm:/i.test(spec)) {
+    return fromAlias(res, where)
+  }
+  if (!HostedGit) HostedGit = require('hosted-git-info')
+  const hosted = HostedGit.fromUrl(spec, {noGitPlus: true, noCommittish: true})
+  if (hosted) {
+    return fromHostedGit(res, hosted)
+  } else if (spec && isURL.test(spec)) {
+    return fromURL(res)
+  } else if (spec && (hasSlashes.test(spec) || isFilename.test(spec))) {
+    return fromFile(res, where)
+  } else {
+    return fromRegistry(res)
+  }
+}
+
+function invalidPackageName (name, valid) {
+  const err = new Error(`Invalid package name "${name}": ${valid.errors.join('; ')}`)
+  err.code = 'EINVALIDPACKAGENAME'
+  return err
+}
+function invalidTagName (name) {
+  const err = new Error(`Invalid tag name "${name}": Tags may not have any characters that encodeURIComponent encodes.`)
+  err.code = 'EINVALIDTAGNAME'
+  return err
+}
+
+function Result (opts) {
+  this.type = opts.type
+  this.registry = opts.registry
+  this.where = opts.where
+  if (opts.raw == null) {
+    this.raw = opts.name ? opts.name + '@' + opts.rawSpec : opts.rawSpec
+  } else {
+    this.raw = opts.raw
+  }
+  this.name = undefined
+  this.escapedName = undefined
+  this.scope = undefined
+  this.rawSpec = opts.rawSpec == null ? '' : opts.rawSpec
+  this.saveSpec = opts.saveSpec
+  this.fetchSpec = opts.fetchSpec
+  if (opts.name) this.setName(opts.name)
+  this.gitRange = opts.gitRange
+  this.gitCommittish = opts.gitCommittish
+  this.hosted = opts.hosted
+}
+
+Result.prototype.setName = function (name) {
+  if (!validatePackageName) validatePackageName = require('validate-npm-package-name')
+  const valid = validatePackageName(name)
+  if (!valid.validForOldPackages) {
+    throw invalidPackageName(name, valid)
+  }
+  this.name = name
+  this.scope = name[0] === '@' ? name.slice(0, name.indexOf('/')) : undefined
+  // scoped packages in couch must have slash url-encoded, e.g. @foo%2Fbar
+  this.escapedName = name.replace('/', '%2f')
+  return this
+}
+
+Result.prototype.toString = function () {
+  const full = []
+  if (this.name != null && this.name !== '') full.push(this.name)
+  const spec = this.saveSpec || this.fetchSpec || this.rawSpec
+  if (spec != null && spec !== '') full.push(spec)
+  return full.length ? full.join('@') : this.raw
+}
+
+Result.prototype.toJSON = function () {
+  const result = Object.assign({}, this)
+  delete result.hosted
+  return result
+}
+
+function setGitCommittish (res, committish) {
+  if (committish != null && committish.length >= 7 && committish.slice(0, 7) === 'semver:') {
+    res.gitRange = decodeURIComponent(committish.slice(7))
+    res.gitCommittish = null
+  } else {
+    res.gitCommittish = committish === '' ? null : committish
+  }
+  return res
+}
+
+const isAbsolutePath = /^[/]|^[A-Za-z]:/
+
+function resolvePath (where, spec) {
+  if (isAbsolutePath.test(spec)) return spec
+  return path().resolve(where, spec)
+}
+
+function isAbsolute (dir) {
+  if (dir[0] === '/') return true
+  if (/^[A-Za-z]:/.test(dir)) return true
+  return false
+}
+
+function fromFile (res, where) {
+  if (!where) where = process.cwd()
+  res.type = isFilename.test(res.rawSpec) ? 'file' : 'directory'
+  res.where = where
+
+  const spec = res.rawSpec.replace(/\\/g, '/')
+    .replace(/^file:[/]*([A-Za-z]:)/, '$1') // drive name paths on windows
+    .replace(/^file:(?:[/]*([~./]))?/, '$1')
+  if (/^~[/]/.test(spec)) {
+    // this is needed for windows and for file:~/foo/bar
+    if (!osenv) osenv = require('osenv')
+    res.fetchSpec = resolvePath(osenv.home(), spec.slice(2))
+    res.saveSpec = 'file:' + spec
+  } else {
+    res.fetchSpec = resolvePath(where, spec)
+    if (isAbsolute(spec)) {
+      res.saveSpec = 'file:' + spec
+    } else {
+      res.saveSpec = 'file:' + path().relative(where, res.fetchSpec)
+    }
+  }
+  return res
+}
+
+function fromHostedGit (res, hosted) {
+  res.type = 'git'
+  res.hosted = hosted
+  res.saveSpec = hosted.toString({noGitPlus: false, noCommittish: false})
+  res.fetchSpec = hosted.getDefaultRepresentation() === 'shortcut' ? null : hosted.toString()
+  return setGitCommittish(res, hosted.committish)
+}
+
+function unsupportedURLType (protocol, spec) {
+  const err = new Error(`Unsupported URL Type "${protocol}": ${spec}`)
+  err.code = 'EUNSUPPORTEDPROTOCOL'
+  return err
+}
+
+function matchGitScp (spec) {
+  // git ssh specifiers are overloaded to also use scp-style git
+  // specifiers, so we have to parse those out and treat them special.
+  // They are NOT true URIs, so we can't hand them to `url.parse`.
+  //
+  // This regex looks for things that look like:
+  // git+ssh://git@my.custom.git.com:username/project.git#deadbeef
+  //
+  // ...and various combinations. The username in the beginning is *required*.
+  const matched = spec.match(/^git\+ssh:\/\/([^:#]+:[^#]+(?:\.git)?)(?:#(.*))?$/i)
+  return matched && !matched[1].match(/:[0-9]+\/?.*$/i) && {
+    fetchSpec: matched[1],
+    gitCommittish: matched[2] == null ? null : matched[2]
+  }
+}
+
+function fromURL (res) {
+  if (!url) url = require('url')
+  const urlparse = url.parse(res.rawSpec)
+  res.saveSpec = res.rawSpec
+  // check the protocol, and then see if it's git or not
+  switch (urlparse.protocol) {
+    case 'git:':
+    case 'git+http:':
+    case 'git+https:':
+    case 'git+rsync:':
+    case 'git+ftp:':
+    case 'git+file:':
+    case 'git+ssh:':
+      res.type = 'git'
+      const match = urlparse.protocol === 'git+ssh:' && matchGitScp(res.rawSpec)
+      if (match) {
+        setGitCommittish(res, match.gitCommittish)
+        res.fetchSpec = match.fetchSpec
+      } else {
+        setGitCommittish(res, urlparse.hash != null ? urlparse.hash.slice(1) : '')
+        urlparse.protocol = urlparse.protocol.replace(/^git[+]/, '')
+        if (urlparse.protocol === 'file:' && /^git\+file:\/\/[a-z]:/i.test(res.rawSpec)) {
+          // keep the drive letter : on windows file paths
+          urlparse.host += ':'
+          urlparse.hostname += ':'
+        }
+        delete urlparse.hash
+        res.fetchSpec = url.format(urlparse)
+      }
+      break
+    case 'http:':
+    case 'https:':
+      res.type = 'remote'
+      res.fetchSpec = res.saveSpec
+      break
+
+    default:
+      throw unsupportedURLType(urlparse.protocol, res.rawSpec)
+  }
+
+  return res
+}
+
+function fromAlias (res, where) {
+  const subSpec = npa(res.rawSpec.substr(4), where)
+  if (subSpec.type === 'alias') {
+    throw new Error('nested aliases not supported')
+  }
+  if (!subSpec.registry) {
+    throw new Error('aliases only work for registry deps')
+  }
+  res.subSpec = subSpec
+  res.registry = true
+  res.type = 'alias'
+  res.saveSpec = null
+  res.fetchSpec = null
+  return res
+}
+
+function fromRegistry (res) {
+  res.registry = true
+  const spec = res.rawSpec === '' ? 'latest' : res.rawSpec
+  // no save spec for registry components as we save based on the fetched
+  // version, not on the argument so this can't compute that.
+  res.saveSpec = null
+  res.fetchSpec = spec
+  if (!semver) semver = require('semver')
+  const version = semver.valid(spec, true)
+  const range = semver.validRange(spec, true)
+  if (version) {
+    res.type = 'version'
+  } else if (range) {
+    res.type = 'range'
+  } else {
+    if (encodeURIComponent(spec) !== spec) {
+      throw invalidTagName(spec)
+    }
+    res.type = 'tag'
+  }
+  return res
+}

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/5d/CommandLineIntegerParameter_5d2f433e98ce71e716006ab8ac983248

@@ -0,0 +1,87 @@
+fdcab3d74916e35caf5c446e6672d422
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandLineIntegerParameter = void 0;
+const BaseClasses_1 = require("./BaseClasses");
+/**
+ * The data type returned by {@link CommandLineParameterProvider.defineIntegerParameter}.
+ * @public
+ */
+class CommandLineIntegerParameter extends BaseClasses_1.CommandLineParameterWithArgument {
+    /** @internal */
+    constructor(definition) {
+        super(definition);
+        this._value = undefined;
+        this.defaultValue = definition.defaultValue;
+        this.validateDefaultValue(!!this.defaultValue);
+    }
+    /** {@inheritDoc CommandLineParameter.kind} */
+    get kind() {
+        return BaseClasses_1.CommandLineParameterKind.Integer;
+    }
+    /**
+     * {@inheritDoc CommandLineParameter._setValue}
+     * @internal
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _setValue(data) {
+        // abstract
+        if (data !== null && data !== undefined) {
+            if (typeof data !== 'number') {
+                this.reportInvalidData(data);
+            }
+            this._value = data;
+            return;
+        }
+        if (this.environmentVariable !== undefined) {
+            // Try reading the environment variable
+            const environmentValue = process.env[this.environmentVariable];
+            if (environmentValue !== undefined && environmentValue !== '') {
+                const parsed = parseInt(environmentValue, 10);
+                if (isNaN(parsed) || environmentValue.indexOf('.') >= 0) {
+                    throw new Error(`Invalid value "${environmentValue}" for the environment variable` +
+                        ` ${this.environmentVariable}.  It must be an integer value.`);
+                }
+                this._value = parsed;
+                return;
+            }
+        }
+        if (this.defaultValue !== undefined) {
+            this._value = this.defaultValue;
+            return;
+        }
+        this._value = undefined;
+    }
+    /**
+     * {@inheritDoc CommandLineParameter._getSupplementaryNotes}
+     * @internal
+     */
+    _getSupplementaryNotes(supplementaryNotes) {
+        // virtual
+        super._getSupplementaryNotes(supplementaryNotes);
+        if (this.defaultValue !== undefined) {
+            supplementaryNotes.push(`The default value is ${this.defaultValue}.`);
+        }
+    }
+    /**
+     * Returns the argument value for an integer parameter that was parsed from the command line.
+     *
+     * @remarks
+     * The return value will be undefined if the command-line has not been parsed yet,
+     * or if the parameter was omitted and has no default value.
+     */
+    get value() {
+        return this._value;
+    }
+    /** {@inheritDoc CommandLineParameter.appendToArgList} @override */
+    appendToArgList(argList) {
+        if (this.value !== undefined) {
+            argList.push(this.longName);
+            argList.push(this.value.toString());
+        }
+    }
+}
+exports.CommandLineIntegerParameter = CommandLineIntegerParameter;
+//# sourceMappingURL=CommandLineIntegerParameter.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/5d/InternalError_5dd9d2af36ccc351a963a526c009c8a5

@@ -0,0 +1,56 @@
+07845377ff5cec48555ce390554ffa09
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalError = void 0;
+/**
+ * An `Error` subclass that should be thrown to report an unexpected state that may indicate a software defect.
+ * An application may handle this error by instructing the end user to report an issue to the application maintainers.
+ *
+ * @remarks
+ * Do not use this class unless you intend to solicit bug reports from end users.
+ *
+ * @public
+ */
+class InternalError extends Error {
+    /**
+     * Constructs a new instance of the {@link InternalError} class.
+     *
+     * @param message - A message describing the error.  This will be assigned to
+     * {@link InternalError.unformattedMessage}.  The `Error.message` field will have additional boilerplate
+     * explaining that the user has encountered a software defect.
+     */
+    constructor(message) {
+        super(InternalError._formatMessage(message));
+        // Manually set the prototype, as we can no longer extend built-in classes like Error, Array, Map, etc.
+        // https://github.com/microsoft/TypeScript-wiki/blob/main/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work
+        //
+        // Note: the prototype must also be set on any classes which extend this one
+        this.__proto__ = InternalError.prototype; // eslint-disable-line @typescript-eslint/no-explicit-any
+        this.unformattedMessage = message;
+        if (InternalError.breakInDebugger) {
+            // eslint-disable-next-line no-debugger
+            debugger;
+        }
+    }
+    static _formatMessage(unformattedMessage) {
+        return (`Internal Error: ${unformattedMessage}\n\nYou have encountered a software defect. Please consider` +
+            ` reporting the issue to the maintainers of this application.`);
+    }
+    /** @override */
+    toString() {
+        return this.message; // Avoid adding the "Error:" prefix
+    }
+}
+exports.InternalError = InternalError;
+/**
+ * If true, a JavScript `debugger;` statement will be invoked whenever the `InternalError` constructor is called.
+ *
+ * @remarks
+ * Generally applications should not be catching and ignoring an `InternalError`.  Instead, the error should
+ * be reported and typically the application will terminate.  Thus, if `InternalError` is constructed, it's
+ * almost always something we want to examine in a debugger.
+ */
+InternalError.breakInDebugger = true;
+//# sourceMappingURL=InternalError.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/5d/Text_5da85b5db9a2f06bbe29cdcd91e6fbca

@@ -0,0 +1,187 @@
+8dae91cf649ea3fe0d93d91605c9165e
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Text = exports.NewlineKind = exports.Encoding = void 0;
+const os = __importStar(require("os"));
+/**
+ * The allowed types of encodings, as supported by Node.js
+ * @public
+ */
+var Encoding;
+(function (Encoding) {
+    Encoding["Utf8"] = "utf8";
+})(Encoding = exports.Encoding || (exports.Encoding = {}));
+/**
+ * Enumeration controlling conversion of newline characters.
+ * @public
+ */
+var NewlineKind;
+(function (NewlineKind) {
+    /**
+     * Windows-style newlines
+     */
+    NewlineKind["CrLf"] = "\r\n";
+    /**
+     * POSIX-style newlines
+     *
+     * @remarks
+     * POSIX is a registered trademark of the Institute of Electrical and Electronic Engineers, Inc.
+     */
+    NewlineKind["Lf"] = "\n";
+    /**
+     * Default newline type for this operating system (`os.EOL`).
+     */
+    NewlineKind["OsDefault"] = "os";
+})(NewlineKind = exports.NewlineKind || (exports.NewlineKind = {}));
+/**
+ * Operations for working with strings that contain text.
+ *
+ * @remarks
+ * The utilities provided by this class are intended to be simple, small, and very
+ * broadly applicable.
+ *
+ * @public
+ */
+class Text {
+    /**
+     * Returns the same thing as targetString.replace(searchValue, replaceValue), except that
+     * all matches are replaced, rather than just the first match.
+     * @param input         - The string to be modified
+     * @param searchValue   - The value to search for
+     * @param replaceValue  - The replacement text
+     */
+    static replaceAll(input, searchValue, replaceValue) {
+        return input.split(searchValue).join(replaceValue);
+    }
+    /**
+     * Converts all newlines in the provided string to use Windows-style CRLF end of line characters.
+     */
+    static convertToCrLf(input) {
+        return input.replace(Text._newLineRegEx, '\r\n');
+    }
+    /**
+     * Converts all newlines in the provided string to use POSIX-style LF end of line characters.
+     *
+     * POSIX is a registered trademark of the Institute of Electrical and Electronic Engineers, Inc.
+     */
+    static convertToLf(input) {
+        return input.replace(Text._newLineRegEx, '\n');
+    }
+    /**
+     * Converts all newlines in the provided string to use the specified newline type.
+     */
+    static convertTo(input, newlineKind) {
+        return input.replace(Text._newLineRegEx, Text.getNewline(newlineKind));
+    }
+    /**
+     * Returns the newline character sequence for the specified `NewlineKind`.
+     */
+    static getNewline(newlineKind) {
+        switch (newlineKind) {
+            case NewlineKind.CrLf:
+                return '\r\n';
+            case NewlineKind.Lf:
+                return '\n';
+            case NewlineKind.OsDefault:
+                return os.EOL;
+            default:
+                throw new Error('Unsupported newline kind');
+        }
+    }
+    /**
+     * Append characters to the end of a string to ensure the result has a minimum length.
+     * @remarks
+     * If the string length already exceeds the minimum length, then the string is unchanged.
+     * The string is not truncated.
+     */
+    static padEnd(s, minimumLength, paddingCharacter = ' ') {
+        if (paddingCharacter.length !== 1) {
+            throw new Error('The paddingCharacter parameter must be a single character.');
+        }
+        if (s.length < minimumLength) {
+            const paddingArray = new Array(minimumLength - s.length);
+            paddingArray.unshift(s);
+            return paddingArray.join(paddingCharacter);
+        }
+        else {
+            return s;
+        }
+    }
+    /**
+     * Append characters to the start of a string to ensure the result has a minimum length.
+     * @remarks
+     * If the string length already exceeds the minimum length, then the string is unchanged.
+     * The string is not truncated.
+     */
+    static padStart(s, minimumLength, paddingCharacter = ' ') {
+        if (paddingCharacter.length !== 1) {
+            throw new Error('The paddingCharacter parameter must be a single character.');
+        }
+        if (s.length < minimumLength) {
+            const paddingArray = new Array(minimumLength - s.length);
+            paddingArray.push(s);
+            return paddingArray.join(paddingCharacter);
+        }
+        else {
+            return s;
+        }
+    }
+    /**
+     * If the string is longer than maximumLength characters, truncate it to that length
+     * using "..." to indicate the truncation.
+     *
+     * @remarks
+     * For example truncateWithEllipsis('1234578', 5) would produce '12...'.
+     */
+    static truncateWithEllipsis(s, maximumLength) {
+        if (maximumLength < 0) {
+            throw new Error('The maximumLength cannot be a negative number');
+        }
+        if (s.length <= maximumLength) {
+            return s;
+        }
+        if (s.length <= 3) {
+            return s.substring(0, maximumLength);
+        }
+        return s.substring(0, maximumLength - 3) + '...';
+    }
+    /**
+     * Returns the input string with a trailing `\n` character appended, if not already present.
+     */
+    static ensureTrailingNewline(s, newlineKind = NewlineKind.Lf) {
+        // Is there already a newline?
+        if (Text._newLineAtEndRegEx.test(s)) {
+            return s; // yes, no change
+        }
+        return s + newlineKind; // no, add it
+    }
+}
+exports.Text = Text;
+Text._newLineRegEx = /\r\n|\n\r|\r|\n/g;
+Text._newLineAtEndRegEx = /(\r\n|\n\r|\r|\n)$/;
+//# sourceMappingURL=Text.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/5d/mkdirs_5d126b371fc3eb56a986e5354ede8f8f

@@ -0,0 +1,64 @@
+6d9d5a662a7d1defd64be18ec7b21cc2
+'use strict'
+
+const fs = require('graceful-fs')
+const path = require('path')
+const invalidWin32Path = require('./win32').invalidWin32Path
+
+const o777 = parseInt('0777', 8)
+
+function mkdirs (p, opts, callback, made) {
+  if (typeof opts === 'function') {
+    callback = opts
+    opts = {}
+  } else if (!opts || typeof opts !== 'object') {
+    opts = { mode: opts }
+  }
+
+  if (process.platform === 'win32' && invalidWin32Path(p)) {
+    const errInval = new Error(p + ' contains invalid WIN32 path characters.')
+    errInval.code = 'EINVAL'
+    return callback(errInval)
+  }
+
+  let mode = opts.mode
+  const xfs = opts.fs || fs
+
+  if (mode === undefined) {
+    mode = o777 & (~process.umask())
+  }
+  if (!made) made = null
+
+  callback = callback || function () {}
+  p = path.resolve(p)
+
+  xfs.mkdir(p, mode, er => {
+    if (!er) {
+      made = made || p
+      return callback(null, made)
+    }
+    switch (er.code) {
+      case 'ENOENT':
+        if (path.dirname(p) === p) return callback(er)
+        mkdirs(path.dirname(p), opts, (er, made) => {
+          if (er) callback(er, made)
+          else mkdirs(p, opts, callback, made)
+        })
+        break
+
+      // In the case of any other error, just see if there's a dir
+      // there already.  If so, then hooray!  If not, then something
+      // is borked.
+      default:
+        xfs.stat(p, (er2, stat) => {
+          // if the stat fails, then that's super weird.
+          // let the original error be the failure reason.
+          if (er2 || !stat.isDirectory()) callback(er, made)
+          else callback(null, made)
+        })
+        break
+    }
+  })
+}
+
+module.exports = mkdirs