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

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/e7/parse_e7d763c8be3f06ca68dae801f67f74f0

@@ -0,0 +1,34 @@
+ff5236f7a01fb67ae5e0f441b30a7114
+const { MAX_LENGTH } = require('../internal/constants')
+const { re, t } = require('../internal/re')
+const SemVer = require('../classes/semver')
+
+const parseOptions = require('../internal/parse-options')
+const parse = (version, options) => {
+  options = parseOptions(options)
+
+  if (version instanceof SemVer) {
+    return version
+  }
+
+  if (typeof version !== 'string') {
+    return null
+  }
+
+  if (version.length > MAX_LENGTH) {
+    return null
+  }
+
+  const r = options.loose ? re[t.LOOSE] : re[t.FULL]
+  if (!r.test(version)) {
+    return null
+  }
+
+  try {
+    return new SemVer(version, options)
+  } catch (er) {
+    return null
+  }
+}
+
+module.exports = parse

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/e9/prerelease_e9273d37a4257d1ec90c3290bff01e38

@@ -0,0 +1,7 @@
+40a72fe55e64efcc0a5c6b859a0378ab
+const parse = require('./parse')
+const prerelease = (version, options) => {
+  const parsed = parse(version, options)
+  return (parsed && parsed.prerelease.length) ? parsed.prerelease : null
+}
+module.exports = prerelease

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/ea/index_eac4fe91a50305745e819cc74aa7ecef

@@ -0,0 +1,135 @@
+5b763a20ca1c55c88a59dd7a72037c9c
+var _fs
+try {
+  _fs = require('graceful-fs')
+} catch (_) {
+  _fs = require('fs')
+}
+
+function readFile (file, options, callback) {
+  if (callback == null) {
+    callback = options
+    options = {}
+  }
+
+  if (typeof options === 'string') {
+    options = {encoding: options}
+  }
+
+  options = options || {}
+  var fs = options.fs || _fs
+
+  var shouldThrow = true
+  if ('throws' in options) {
+    shouldThrow = options.throws
+  }
+
+  fs.readFile(file, options, function (err, data) {
+    if (err) return callback(err)
+
+    data = stripBom(data)
+
+    var obj
+    try {
+      obj = JSON.parse(data, options ? options.reviver : null)
+    } catch (err2) {
+      if (shouldThrow) {
+        err2.message = file + ': ' + err2.message
+        return callback(err2)
+      } else {
+        return callback(null, null)
+      }
+    }
+
+    callback(null, obj)
+  })
+}
+
+function readFileSync (file, options) {
+  options = options || {}
+  if (typeof options === 'string') {
+    options = {encoding: options}
+  }
+
+  var fs = options.fs || _fs
+
+  var shouldThrow = true
+  if ('throws' in options) {
+    shouldThrow = options.throws
+  }
+
+  try {
+    var content = fs.readFileSync(file, options)
+    content = stripBom(content)
+    return JSON.parse(content, options.reviver)
+  } catch (err) {
+    if (shouldThrow) {
+      err.message = file + ': ' + err.message
+      throw err
+    } else {
+      return null
+    }
+  }
+}
+
+function stringify (obj, options) {
+  var spaces
+  var EOL = '\n'
+  if (typeof options === 'object' && options !== null) {
+    if (options.spaces) {
+      spaces = options.spaces
+    }
+    if (options.EOL) {
+      EOL = options.EOL
+    }
+  }
+
+  var str = JSON.stringify(obj, options ? options.replacer : null, spaces)
+
+  return str.replace(/\n/g, EOL) + EOL
+}
+
+function writeFile (file, obj, options, callback) {
+  if (callback == null) {
+    callback = options
+    options = {}
+  }
+  options = options || {}
+  var fs = options.fs || _fs
+
+  var str = ''
+  try {
+    str = stringify(obj, options)
+  } catch (err) {
+    // Need to return whether a callback was passed or not
+    if (callback) callback(err, null)
+    return
+  }
+
+  fs.writeFile(file, str, options, callback)
+}
+
+function writeFileSync (file, obj, options) {
+  options = options || {}
+  var fs = options.fs || _fs
+
+  var str = stringify(obj, options)
+  // not sure if fs.writeFileSync returns anything, but just in case
+  return fs.writeFileSync(file, str, options)
+}
+
+function stripBom (content) {
+  // we do this because JSON.parse would convert it to a utf8 string if encoding wasn't specified
+  if (Buffer.isBuffer(content)) content = content.toString('utf8')
+  content = content.replace(/^\uFEFF/, '')
+  return content
+}
+
+var jsonfile = {
+  readFile: readFile,
+  readFileSync: readFileSync,
+  writeFile: writeFile,
+  writeFileSync: writeFileSync
+}
+
+module.exports = jsonfile

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/eb/SubprocessTerminator_ebf12d3f7deaa7ae1d03a93896142f71

@@ -0,0 +1,183 @@
+1ec09c442d3a2a91025d696fbb24cf1b
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubprocessTerminator = void 0;
+const process_1 = __importDefault(require("process"));
+const Executable_1 = require("./Executable");
+/**
+ * When a child process is created, registering it with the SubprocessTerminator will ensure
+ * that the child gets terminated when the current process terminates.
+ *
+ * @remarks
+ * This works by hooking the current process's events for SIGTERM/SIGINT/exit, and ensuring the
+ * child process gets terminated in those cases.
+ *
+ * SubprocessTerminator doesn't do anything on Windows, since by default Windows automatically
+ * terminates child processes when their parent is terminated.
+ *
+ * @beta
+ */
+class SubprocessTerminator {
+    /**
+     * Registers a child process so that it will be terminated automatically if the current process
+     * is terminated.
+     */
+    static killProcessTreeOnExit(subprocess, subprocessOptions) {
+        if (typeof subprocess.exitCode === 'number') {
+            // Process has already been killed
+            return;
+        }
+        SubprocessTerminator._validateSubprocessOptions(subprocessOptions);
+        SubprocessTerminator._ensureInitialized();
+        // Closure variable
+        const pid = subprocess.pid;
+        subprocess.on('close', (code, signal) => {
+            if (SubprocessTerminator._subprocessesByPid.has(pid)) {
+                SubprocessTerminator._logDebug(`untracking #${pid}`);
+                SubprocessTerminator._subprocessesByPid.delete(pid);
+            }
+        });
+        SubprocessTerminator._subprocessesByPid.set(pid, {
+            subprocess,
+            subprocessOptions
+        });
+        SubprocessTerminator._logDebug(`tracking #${pid}`);
+    }
+    /**
+     * Terminate the child process and all of its children.
+     */
+    static killProcessTree(subprocess, subprocessOptions) {
+        const pid = subprocess.pid;
+        // Don't attempt to kill the same process twice
+        if (SubprocessTerminator._subprocessesByPid.has(pid)) {
+            SubprocessTerminator._logDebug(`untracking #${pid} via killProcessTree()`);
+            this._subprocessesByPid.delete(subprocess.pid);
+        }
+        SubprocessTerminator._validateSubprocessOptions(subprocessOptions);
+        if (typeof subprocess.exitCode === 'number') {
+            // Process has already been killed
+            return;
+        }
+        SubprocessTerminator._logDebug(`terminating #${subprocess.pid}`);
+        if (SubprocessTerminator._isWindows) {
+            // On Windows we have a problem that CMD.exe launches child processes, but when CMD.exe is killed
+            // the child processes may continue running.  Also if we send signals to CMD.exe the child processes
+            // will not receive them.  The safest solution is not to attempt a graceful shutdown, but simply
+            // kill the entire process tree.
+            const result = Executable_1.Executable.spawnSync('TaskKill.exe', [
+                '/T',
+                '/F',
+                '/PID',
+                subprocess.pid.toString()
+            ]);
+            if (result.status) {
+                const output = result.output.join('\n');
+                // Nonzero exit code
+                if (output.indexOf('not found') >= 0) {
+                    // The PID does not exist
+                }
+                else {
+                    // Another error occurred, for example TaskKill.exe does not support
+                    // the expected CLI syntax
+                    throw new Error(`TaskKill.exe returned exit code ${result.status}:\n` + output + '\n');
+                }
+            }
+        }
+        else {
+            // Passing a negative PID terminates the entire group instead of just the one process
+            process_1.default.kill(-subprocess.pid, 'SIGKILL');
+        }
+    }
+    // Install the hooks
+    static _ensureInitialized() {
+        if (!SubprocessTerminator._initialized) {
+            SubprocessTerminator._initialized = true;
+            SubprocessTerminator._logDebug('initialize');
+            process_1.default.prependListener('SIGTERM', SubprocessTerminator._onTerminateSignal);
+            process_1.default.prependListener('SIGINT', SubprocessTerminator._onTerminateSignal);
+            process_1.default.prependListener('exit', SubprocessTerminator._onExit);
+        }
+    }
+    // Uninstall the hooks and perform cleanup
+    static _cleanupChildProcesses() {
+        if (SubprocessTerminator._initialized) {
+            SubprocessTerminator._initialized = false;
+            process_1.default.removeListener('SIGTERM', SubprocessTerminator._onTerminateSignal);
+            process_1.default.removeListener('SIGINT', SubprocessTerminator._onTerminateSignal);
+            const trackedSubprocesses = Array.from(SubprocessTerminator._subprocessesByPid.values());
+            let firstError = undefined;
+            for (const trackedSubprocess of trackedSubprocesses) {
+                try {
+                    SubprocessTerminator.killProcessTree(trackedSubprocess.subprocess, { detached: true });
+                }
+                catch (error) {
+                    if (firstError === undefined) {
+                        firstError = error;
+                    }
+                }
+            }
+            if (firstError !== undefined) {
+                // This is generally an unexpected error such as the TaskKill.exe command not being found,
+                // not a trivial issue such as a nonexistent PID.   Since this occurs during process shutdown,
+                // we should not interfere with control flow by throwing an exception  or calling process.exit().
+                // So simply write to STDERR and ensure our exit code indicates the problem.
+                console.error('\nAn unexpected error was encountered while attempting to clean up child processes:');
+                console.error(firstError.toString());
+                if (!process_1.default.exitCode) {
+                    process_1.default.exitCode = 1;
+                }
+            }
+        }
+    }
+    static _validateSubprocessOptions(subprocessOptions) {
+        if (!SubprocessTerminator._isWindows) {
+            if (!subprocessOptions.detached) {
+                // Setting detached=true is what creates the process group that we use to kill the children
+                throw new Error('killProcessTree() requires detached=true on this operating system');
+            }
+        }
+    }
+    static _onExit(exitCode) {
+        SubprocessTerminator._logDebug(`received exit(${exitCode})`);
+        SubprocessTerminator._cleanupChildProcesses();
+        SubprocessTerminator._logDebug(`finished exit()`);
+    }
+    static _onTerminateSignal(signal) {
+        SubprocessTerminator._logDebug(`received signal ${signal}`);
+        SubprocessTerminator._cleanupChildProcesses();
+        // When a listener is added to SIGTERM, Node.js strangely provides no way to reference
+        // the original handler.  But we can invoke it by removing our listener and then resending
+        // the signal to our own process.
+        SubprocessTerminator._logDebug(`relaying ${signal}`);
+        process_1.default.kill(process_1.default.pid, signal);
+    }
+    // For debugging
+    static _logDebug(message) {
+        //const logLine: string = `SubprocessTerminator: [${process.pid}] ${message}`;
+        // fs.writeFileSync('trace.log', logLine + '\n', { flag: 'a' });
+        //console.log(logLine);
+    }
+}
+exports.SubprocessTerminator = SubprocessTerminator;
+/**
+ * Whether the hooks are installed
+ */
+SubprocessTerminator._initialized = false;
+/**
+ * The list of registered child processes.  Processes are removed from this set if they
+ * terminate on their own.
+ */
+SubprocessTerminator._subprocessesByPid = new Map();
+SubprocessTerminator._isWindows = process_1.default.platform === 'win32';
+/**
+ * The recommended options when creating a child process.
+ */
+SubprocessTerminator.RECOMMENDED_OPTIONS = {
+    detached: process_1.default.platform !== 'win32'
+};
+//# sourceMappingURL=SubprocessTerminator.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/ed/Constants_edd5c8fac126611f0aac2c21306624ce

@@ -0,0 +1,8 @@
+e7979f52b10198f38b07af192494e7e7
+"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.SCOPING_PARAMETER_GROUP = void 0;
+exports.SCOPING_PARAMETER_GROUP = Symbol('scoping');
+//# sourceMappingURL=Constants.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/ee/CommandLineIntegerListParameter_ee2f3b50b51fed153ef44b020f23a401

@@ -0,0 +1,83 @@
+78d206a241504727ca1c0004885ff20d
+"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.CommandLineIntegerListParameter = void 0;
+const BaseClasses_1 = require("./BaseClasses");
+const EnvironmentVariableParser_1 = require("./EnvironmentVariableParser");
+/**
+ * The data type returned by {@link CommandLineParameterProvider.defineIntegerListParameter}.
+ * @public
+ */
+class CommandLineIntegerListParameter extends BaseClasses_1.CommandLineParameterWithArgument {
+    /** @internal */
+    constructor(definition) {
+        super(definition);
+        this._values = [];
+    }
+    /** {@inheritDoc CommandLineParameter.kind} */
+    get kind() {
+        return BaseClasses_1.CommandLineParameterKind.IntegerList;
+    }
+    /**
+     * {@inheritDoc CommandLineParameter._setValue}
+     * @internal
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _setValue(data) {
+        // If argparse passed us a value, confirm it is valid
+        if (data !== null && data !== undefined) {
+            if (!Array.isArray(data)) {
+                this.reportInvalidData(data);
+            }
+            for (const arrayItem of data) {
+                if (typeof arrayItem !== 'number') {
+                    this.reportInvalidData(data);
+                }
+            }
+            this._values = data;
+            return;
+        }
+        // If an environment variable exists, attempt to parse it as a list
+        if (this.environmentVariable !== undefined) {
+            const values = EnvironmentVariableParser_1.EnvironmentVariableParser.parseAsList(this.environmentVariable);
+            if (values) {
+                const parsedValues = [];
+                for (const value of values) {
+                    const parsed = parseInt(value, 10);
+                    if (isNaN(parsed) || value.indexOf('.') >= 0) {
+                        throw new Error(`Invalid value "${value}" for the environment variable` +
+                            ` ${this.environmentVariable}.  It must be an integer value.`);
+                    }
+                    parsedValues.push(parsed);
+                }
+                this._values = parsedValues;
+                return;
+            }
+        }
+        // (No default value for integer lists)
+        this._values = [];
+    }
+    /**
+     * Returns the integer arguments for an integer list parameter that was parsed from the command line.
+     *
+     * @remarks
+     * The array will be empty if the command-line has not been parsed yet,
+     * or if the parameter was omitted and has no default value.
+     */
+    get values() {
+        return this._values;
+    }
+    /** {@inheritDoc CommandLineParameter.appendToArgList} @override */
+    appendToArgList(argList) {
+        if (this.values.length > 0) {
+            for (const value of this.values) {
+                argList.push(this.longName);
+                argList.push(value.toString());
+            }
+        }
+    }
+}
+exports.CommandLineIntegerListParameter = CommandLineIntegerListParameter;
+//# sourceMappingURL=CommandLineIntegerListParameter.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/ee/TextRewriterTransform_eea93c8f7ebdbdc06d142929eabdbf1a

@@ -0,0 +1,94 @@
+8fb208556fb16f866aaa8e0ce4418b7c
+"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.TextRewriterTransform = void 0;
+const TerminalTransform_1 = require("./TerminalTransform");
+const RemoveColorsTextRewriter_1 = require("./RemoveColorsTextRewriter");
+const NormalizeNewlinesTextRewriter_1 = require("./NormalizeNewlinesTextRewriter");
+/**
+ * A {@link TerminalTransform} subclass that performs one or more {@link TextRewriter} operations.
+ * The most common operations are {@link NormalizeNewlinesTextRewriter} and {@link RemoveColorsTextRewriter}.
+ *
+ * @remarks
+ * The `TextRewriter` operations are applied separately to the `stderr` and `stdout` streams.
+ * If multiple {@link ITextRewriterTransformOptions.textRewriters} are configured, they are applied
+ * in the order that they appear in the array.
+ *
+ * @public
+ */
+class TextRewriterTransform extends TerminalTransform_1.TerminalTransform {
+    constructor(options) {
+        super(options);
+        const textRewriters = options.textRewriters || [];
+        if (options.removeColors) {
+            textRewriters.push(new RemoveColorsTextRewriter_1.RemoveColorsTextRewriter());
+        }
+        if (options.normalizeNewlines) {
+            textRewriters.push(new NormalizeNewlinesTextRewriter_1.NormalizeNewlinesTextRewriter({
+                newlineKind: options.normalizeNewlines,
+                ensureNewlineAtEnd: options.ensureNewlineAtEnd
+            }));
+        }
+        if (textRewriters.length === 0) {
+            throw new Error('TextRewriterTransform requires at least one matcher');
+        }
+        this.textRewriters = textRewriters;
+        this._stderrStates = this.textRewriters.map((x) => x.initialize());
+        this._stdoutStates = this.textRewriters.map((x) => x.initialize());
+    }
+    onWriteChunk(chunk) {
+        if (chunk.kind === "E" /* TerminalChunkKind.Stderr */) {
+            this._processText(chunk, this._stderrStates);
+        }
+        else if (chunk.kind === "O" /* TerminalChunkKind.Stdout */) {
+            this._processText(chunk, this._stdoutStates);
+        }
+        else {
+            this.destination.writeChunk(chunk);
+        }
+    }
+    _processText(chunk, states) {
+        let text = chunk.text;
+        for (let i = 0; i < states.length; ++i) {
+            if (text.length > 0) {
+                text = this.textRewriters[i].process(states[i], text);
+            }
+        }
+        if (text.length > 0) {
+            // If possible, avoid allocating a new chunk
+            if (text === chunk.text) {
+                this.destination.writeChunk(chunk);
+            }
+            else {
+                this.destination.writeChunk({
+                    text: text,
+                    kind: chunk.kind
+                });
+            }
+        }
+    }
+    _closeRewriters(states, chunkKind) {
+        let text = '';
+        for (let i = 0; i < states.length; ++i) {
+            if (text.length > 0) {
+                text = this.textRewriters[i].process(states[i], text);
+            }
+            text += this.textRewriters[i].close(states[i]);
+        }
+        if (text.length > 0) {
+            this.destination.writeChunk({
+                text: text,
+                kind: chunkKind
+            });
+        }
+    }
+    onClose() {
+        this._closeRewriters(this._stderrStates, "E" /* TerminalChunkKind.Stderr */);
+        this._closeRewriters(this._stderrStates, "O" /* TerminalChunkKind.Stdout */);
+        this.autocloseDestination();
+    }
+}
+exports.TextRewriterTransform = TextRewriterTransform;
+//# sourceMappingURL=TextRewriterTransform.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/f0/sort_f08e51bfef63ae58474299f9e7546731

@@ -0,0 +1,4 @@
+b7fc2bc365d5f6f9e2ad842441755e7b
+const compareBuild = require('./compare-build')
+const sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose))
+module.exports = sort

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/f1/false_f1144cdddaa535b00035b0fbe77ead5f

@@ -0,0 +1,28 @@
+69eba4ce33b3a5b01def86bb7f8bc6e8
+/*:nodoc:*
+ * class ActionStoreFalse
+ *
+ * This action store the values False respectively.
+ * This is special cases of 'storeConst'
+ *
+ * This class inherited from [[Action]]
+ **/
+
+'use strict';
+
+var util = require('util');
+
+var ActionStoreConstant = require('./constant');
+
+/*:nodoc:*
+ * new ActionStoreFalse(options)
+ * - options (object): hash of options see [[Action.new]]
+ *
+ **/
+var ActionStoreFalse = module.exports = function ActionStoreFalse(options) {
+  options = options || {};
+  options.constant = false;
+  options.defaultValue = options.defaultValue !== null ? options.defaultValue : true;
+  ActionStoreConstant.call(this, options);
+};
+util.inherits(ActionStoreFalse, ActionStoreConstant);

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/f2/utimes_f2a55040651c41f48b71717467a0818a

@@ -0,0 +1,80 @@
+519c3dcfbd5d695328b4b0cf039dec4c
+'use strict'
+
+const fs = require('graceful-fs')
+const os = require('os')
+const path = require('path')
+
+// HFS, ext{2,3}, FAT do not, Node.js v0.10 does not
+function hasMillisResSync () {
+  let tmpfile = path.join('millis-test-sync' + Date.now().toString() + Math.random().toString().slice(2))
+  tmpfile = path.join(os.tmpdir(), tmpfile)
+
+  // 550 millis past UNIX epoch
+  const d = new Date(1435410243862)
+  fs.writeFileSync(tmpfile, 'https://github.com/jprichardson/node-fs-extra/pull/141')
+  const fd = fs.openSync(tmpfile, 'r+')
+  fs.futimesSync(fd, d, d)
+  fs.closeSync(fd)
+  return fs.statSync(tmpfile).mtime > 1435410243000
+}
+
+function hasMillisRes (callback) {
+  let tmpfile = path.join('millis-test' + Date.now().toString() + Math.random().toString().slice(2))
+  tmpfile = path.join(os.tmpdir(), tmpfile)
+
+  // 550 millis past UNIX epoch
+  const d = new Date(1435410243862)
+  fs.writeFile(tmpfile, 'https://github.com/jprichardson/node-fs-extra/pull/141', err => {
+    if (err) return callback(err)
+    fs.open(tmpfile, 'r+', (err, fd) => {
+      if (err) return callback(err)
+      fs.futimes(fd, d, d, err => {
+        if (err) return callback(err)
+        fs.close(fd, err => {
+          if (err) return callback(err)
+          fs.stat(tmpfile, (err, stats) => {
+            if (err) return callback(err)
+            callback(null, stats.mtime > 1435410243000)
+          })
+        })
+      })
+    })
+  })
+}
+
+function timeRemoveMillis (timestamp) {
+  if (typeof timestamp === 'number') {
+    return Math.floor(timestamp / 1000) * 1000
+  } else if (timestamp instanceof Date) {
+    return new Date(Math.floor(timestamp.getTime() / 1000) * 1000)
+  } else {
+    throw new Error('fs-extra: timeRemoveMillis() unknown parameter type')
+  }
+}
+
+function utimesMillis (path, atime, mtime, callback) {
+  // if (!HAS_MILLIS_RES) return fs.utimes(path, atime, mtime, callback)
+  fs.open(path, 'r+', (err, fd) => {
+    if (err) return callback(err)
+    fs.futimes(fd, atime, mtime, futimesErr => {
+      fs.close(fd, closeErr => {
+        if (callback) callback(futimesErr || closeErr)
+      })
+    })
+  })
+}
+
+function utimesMillisSync (path, atime, mtime) {
+  const fd = fs.openSync(path, 'r+')
+  fs.futimesSync(fd, atime, mtime)
+  return fs.closeSync(fd)
+}
+
+module.exports = {
+  hasMillisRes,
+  hasMillisResSync,
+  timeRemoveMillis,
+  utimesMillis,
+  utimesMillisSync
+}