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

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/53/utils_53dfb762f99e59335c970a62a9e510a2

@@ -0,0 +1,58 @@
+a5b7106ce25ba7feed190fd1a2474b0e
+'use strict';
+
+exports.repeat = function (str, num) {
+  var result = '';
+  for (var i = 0; i < num; i++) { result += str; }
+  return result;
+};
+
+exports.arrayEqual = function (a, b) {
+  if (a.length !== b.length) { return false; }
+  for (var i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) { return false; }
+  }
+  return true;
+};
+
+exports.trimChars = function (str, chars) {
+  var start = 0;
+  var end = str.length - 1;
+  while (chars.indexOf(str.charAt(start)) >= 0) { start++; }
+  while (chars.indexOf(str.charAt(end)) >= 0) { end--; }
+  return str.slice(start, end + 1);
+};
+
+exports.capitalize = function (str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+};
+
+exports.arrayUnion = function () {
+  var result = [];
+  for (var i = 0, values = {}; i < arguments.length; i++) {
+    var arr = arguments[i];
+    for (var j = 0; j < arr.length; j++) {
+      if (!values[arr[j]]) {
+        values[arr[j]] = true;
+        result.push(arr[j]);
+      }
+    }
+  }
+  return result;
+};
+
+function has(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+exports.has = has;
+
+exports.extend = function (dest, src) {
+  for (var i in src) {
+    if (has(src, i)) { dest[i] = src[i]; }
+  }
+};
+
+exports.trimEnd = function (str) {
+  return str.replace(/\s+$/g, '');
+};

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/56/identifiers_5666c8fdebf8bea43ee0cb13c2c4fb99

@@ -0,0 +1,24 @@
+510c174c5bfc993023542e3b4f699cd1
+const numeric = /^[0-9]+$/
+const compareIdentifiers = (a, b) => {
+  const anum = numeric.test(a)
+  const bnum = numeric.test(b)
+
+  if (anum && bnum) {
+    a = +a
+    b = +b
+  }
+
+  return a === b ? 0
+    : (anum && !bnum) ? -1
+    : (bnum && !anum) ? 1
+    : a < b ? -1
+    : 1
+}
+
+const rcompareIdentifiers = (a, b) => compareIdentifiers(b, a)
+
+module.exports = {
+  compareIdentifiers,
+  rcompareIdentifiers,
+}

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/57/Terminal_578f895bcff5950330288b7fbb82e347

@@ -0,0 +1,298 @@
+356dd43912d9e71c67143ca04728da3c
+"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.Terminal = void 0;
+const ITerminalProvider_1 = require("./ITerminalProvider");
+const Colors_1 = require("./Colors");
+/**
+ * This class facilitates writing to a console.
+ *
+ * @beta
+ */
+class Terminal {
+    constructor(provider) {
+        this._providers = new Set();
+        this._providers.add(provider);
+    }
+    /**
+     * {@inheritdoc ITerminal.registerProvider}
+     */
+    registerProvider(provider) {
+        this._providers.add(provider);
+    }
+    /**
+     * {@inheritdoc ITerminal.unregisterProvider}
+     */
+    unregisterProvider(provider) {
+        if (this._providers.has(provider)) {
+            this._providers.delete(provider);
+        }
+    }
+    /**
+     * {@inheritdoc ITerminal.write}
+     */
+    write(...messageParts) {
+        this._writeSegmentsToProviders(messageParts, ITerminalProvider_1.TerminalProviderSeverity.log);
+    }
+    /**
+     * {@inheritdoc ITerminal.writeLine}
+     */
+    writeLine(...messageParts) {
+        this.write(...messageParts, Colors_1.eolSequence);
+    }
+    /**
+     * {@inheritdoc ITerminal.writeWarning}
+     */
+    writeWarning(...messageParts) {
+        this._writeSegmentsToProviders(messageParts.map((part) => (Object.assign(Object.assign({}, Colors_1.Colors._normalizeStringOrColorableSequence(part)), { foregroundColor: Colors_1.ColorValue.Yellow }))), ITerminalProvider_1.TerminalProviderSeverity.warning);
+    }
+    /**
+     * {@inheritdoc ITerminal.writeWarningLine}
+     */
+    writeWarningLine(...messageParts) {
+        this._writeSegmentsToProviders([
+            ...messageParts.map((part) => (Object.assign(Object.assign({}, Colors_1.Colors._normalizeStringOrColorableSequence(part)), { foregroundColor: Colors_1.ColorValue.Yellow }))),
+            Colors_1.eolSequence
+        ], ITerminalProvider_1.TerminalProviderSeverity.warning);
+    }
+    /**
+     * {@inheritdoc ITerminal.writeError}
+     */
+    writeError(...messageParts) {
+        this._writeSegmentsToProviders(messageParts.map((part) => (Object.assign(Object.assign({}, Colors_1.Colors._normalizeStringOrColorableSequence(part)), { foregroundColor: Colors_1.ColorValue.Red }))), ITerminalProvider_1.TerminalProviderSeverity.error);
+    }
+    /**
+     * {@inheritdoc ITerminal.writeErrorLine}
+     */
+    writeErrorLine(...messageParts) {
+        this._writeSegmentsToProviders([
+            ...messageParts.map((part) => (Object.assign(Object.assign({}, Colors_1.Colors._normalizeStringOrColorableSequence(part)), { foregroundColor: Colors_1.ColorValue.Red }))),
+            Colors_1.eolSequence
+        ], ITerminalProvider_1.TerminalProviderSeverity.error);
+    }
+    /**
+     * {@inheritdoc ITerminal.writeVerbose}
+     */
+    writeVerbose(...messageParts) {
+        this._writeSegmentsToProviders(messageParts, ITerminalProvider_1.TerminalProviderSeverity.verbose);
+    }
+    /**
+     * {@inheritdoc ITerminal.writeVerboseLine}
+     */
+    writeVerboseLine(...messageParts) {
+        this.writeVerbose(...messageParts, Colors_1.eolSequence);
+    }
+    /**
+     * {@inheritdoc ITerminal.writeDebug}
+     */
+    writeDebug(...messageParts) {
+        this._writeSegmentsToProviders(messageParts, ITerminalProvider_1.TerminalProviderSeverity.debug);
+    }
+    /**
+     * {@inheritdoc ITerminal.writeDebugLine}
+     */
+    writeDebugLine(...messageParts) {
+        this.writeDebug(...messageParts, Colors_1.eolSequence);
+    }
+    _writeSegmentsToProviders(segments, severity) {
+        const withColorText = {};
+        const withoutColorText = {};
+        let withColorLines;
+        let withoutColorLines;
+        this._providers.forEach((provider) => {
+            const eol = provider.eolCharacter;
+            let textToWrite;
+            if (provider.supportsColor) {
+                if (!withColorLines) {
+                    withColorLines = this._serializeFormattableTextSegments(segments, true);
+                }
+                if (!withColorText[eol]) {
+                    withColorText[eol] = withColorLines.join(eol);
+                }
+                textToWrite = withColorText[eol];
+            }
+            else {
+                if (!withoutColorLines) {
+                    withoutColorLines = this._serializeFormattableTextSegments(segments, false);
+                }
+                if (!withoutColorText[eol]) {
+                    withoutColorText[eol] = withoutColorLines.join(eol);
+                }
+                textToWrite = withoutColorText[eol];
+            }
+            provider.write(textToWrite, severity);
+        });
+    }
+    _serializeFormattableTextSegments(segments, withColor) {
+        const lines = [];
+        let segmentsToJoin = [];
+        let lastSegmentWasEol = false;
+        for (let i = 0; i < segments.length; i++) {
+            const segment = Colors_1.Colors._normalizeStringOrColorableSequence(segments[i]);
+            lastSegmentWasEol = !!segment.isEol;
+            if (lastSegmentWasEol) {
+                lines.push(segmentsToJoin.join(''));
+                segmentsToJoin = [];
+            }
+            else {
+                if (withColor) {
+                    const startColorCodes = [];
+                    const endColorCodes = [];
+                    switch (segment.foregroundColor) {
+                        case Colors_1.ColorValue.Black: {
+                            startColorCodes.push(Colors_1.ConsoleColorCodes.BlackForeground);
+                            endColorCodes.push(Colors_1.ConsoleColorCodes.DefaultForeground);
+                            break;
+                        }
+                        case Colors_1.ColorValue.Red: {
+                            startColorCodes.push(Colors_1.ConsoleColorCodes.RedForeground);
+                            endColorCodes.push(Colors_1.ConsoleColorCodes.DefaultForeground);
+                            break;
+                        }
+                        case Colors_1.ColorValue.Green: {
+                            startColorCodes.push(Colors_1.ConsoleColorCodes.GreenForeground);
+                            endColorCodes.push(Colors_1.ConsoleColorCodes.DefaultForeground);
+                            break;
+                        }
+                        case Colors_1.ColorValue.Yellow: {
+                            startColorCodes.push(Colors_1.ConsoleColorCodes.YellowForeground);
+                            endColorCodes.push(Colors_1.ConsoleColorCodes.DefaultForeground);
+                            break;
+                        }
+                        case Colors_1.ColorValue.Blue: {
+                            startColorCodes.push(Colors_1.ConsoleColorCodes.BlueForeground);
+                            endColorCodes.push(Colors_1.ConsoleColorCodes.DefaultForeground);
+                            break;
+                        }
+                        case Colors_1.ColorValue.Magenta: {
+                            startColorCodes.push(Colors_1.ConsoleColorCodes.MagentaForeground);
+                            endColorCodes.push(Colors_1.ConsoleColorCodes.DefaultForeground);
+                            break;
+                        }
+                        case Colors_1.ColorValue.Cyan: {
+                            startColorCodes.push(Colors_1.ConsoleColorCodes.CyanForeground);
+                            endColorCodes.push(Colors_1.ConsoleColorCodes.DefaultForeground);
+                            break;
+                        }
+                        case Colors_1.ColorValue.White: {
+                            startColorCodes.push(Colors_1.ConsoleColorCodes.WhiteForeground);
+                            endColorCodes.push(Colors_1.ConsoleColorCodes.DefaultForeground);
+                            break;
+                        }
+                        case Colors_1.ColorValue.Gray: {
+                            startColorCodes.push(Colors_1.ConsoleColorCodes.GrayForeground);
+                            endColorCodes.push(Colors_1.ConsoleColorCodes.DefaultForeground);
+                            break;
+                        }
+                    }
+                    switch (segment.backgroundColor) {
+                        case Colors_1.ColorValue.Black: {
+                            startColorCodes.push(Colors_1.ConsoleColorCodes.BlackBackground);
+                            endColorCodes.push(Colors_1.ConsoleColorCodes.DefaultBackground);
+                            break;
+                        }
+                        case Colors_1.ColorValue.Red: {
+                            startColorCodes.push(Colors_1.ConsoleColorCodes.RedBackground);
+                            endColorCodes.push(Colors_1.ConsoleColorCodes.DefaultBackground);
+                            break;
+                        }
+                        case Colors_1.ColorValue.Green: {
+                            startColorCodes.push(Colors_1.ConsoleColorCodes.GreenBackground);
+                            endColorCodes.push(Colors_1.ConsoleColorCodes.DefaultBackground);
+                            break;
+                        }
+                        case Colors_1.ColorValue.Yellow: {
+                            startColorCodes.push(Colors_1.ConsoleColorCodes.YellowBackground);
+                            endColorCodes.push(Colors_1.ConsoleColorCodes.DefaultBackground);
+                            break;
+                        }
+                        case Colors_1.ColorValue.Blue: {
+                            startColorCodes.push(Colors_1.ConsoleColorCodes.BlueBackground);
+                            endColorCodes.push(Colors_1.ConsoleColorCodes.DefaultBackground);
+                            break;
+                        }
+                        case Colors_1.ColorValue.Magenta: {
+                            startColorCodes.push(Colors_1.ConsoleColorCodes.MagentaBackground);
+                            endColorCodes.push(Colors_1.ConsoleColorCodes.DefaultBackground);
+                            break;
+                        }
+                        case Colors_1.ColorValue.Cyan: {
+                            startColorCodes.push(Colors_1.ConsoleColorCodes.CyanBackground);
+                            endColorCodes.push(Colors_1.ConsoleColorCodes.DefaultBackground);
+                            break;
+                        }
+                        case Colors_1.ColorValue.White: {
+                            startColorCodes.push(Colors_1.ConsoleColorCodes.WhiteBackground);
+                            endColorCodes.push(Colors_1.ConsoleColorCodes.DefaultBackground);
+                            break;
+                        }
+                        case Colors_1.ColorValue.Gray: {
+                            startColorCodes.push(Colors_1.ConsoleColorCodes.GrayBackground);
+                            endColorCodes.push(49);
+                            break;
+                        }
+                    }
+                    if (segment.textAttributes) {
+                        for (const textAttribute of segment.textAttributes) {
+                            switch (textAttribute) {
+                                case Colors_1.TextAttribute.Bold: {
+                                    startColorCodes.push(Colors_1.ConsoleColorCodes.Bold);
+                                    endColorCodes.push(Colors_1.ConsoleColorCodes.NormalColorOrIntensity);
+                                    break;
+                                }
+                                case Colors_1.TextAttribute.Dim: {
+                                    startColorCodes.push(Colors_1.ConsoleColorCodes.Dim);
+                                    endColorCodes.push(Colors_1.ConsoleColorCodes.NormalColorOrIntensity);
+                                    break;
+                                }
+                                case Colors_1.TextAttribute.Underline: {
+                                    startColorCodes.push(Colors_1.ConsoleColorCodes.Underline);
+                                    endColorCodes.push(Colors_1.ConsoleColorCodes.UnderlineOff);
+                                    break;
+                                }
+                                case Colors_1.TextAttribute.Blink: {
+                                    startColorCodes.push(Colors_1.ConsoleColorCodes.Blink);
+                                    endColorCodes.push(Colors_1.ConsoleColorCodes.BlinkOff);
+                                    break;
+                                }
+                                case Colors_1.TextAttribute.InvertColor: {
+                                    startColorCodes.push(Colors_1.ConsoleColorCodes.InvertColor);
+                                    endColorCodes.push(Colors_1.ConsoleColorCodes.InvertColorOff);
+                                    break;
+                                }
+                                case Colors_1.TextAttribute.Hidden: {
+                                    startColorCodes.push(Colors_1.ConsoleColorCodes.Hidden);
+                                    endColorCodes.push(Colors_1.ConsoleColorCodes.HiddenOff);
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    for (let j = 0; j < startColorCodes.length; j++) {
+                        const code = startColorCodes[j];
+                        segmentsToJoin.push(...['\u001b[', code.toString(), 'm']);
+                    }
+                    segmentsToJoin.push(segment.text);
+                    for (let j = endColorCodes.length - 1; j >= 0; j--) {
+                        const code = endColorCodes[j];
+                        segmentsToJoin.push(...['\u001b[', code.toString(), 'm']);
+                    }
+                }
+                else {
+                    segmentsToJoin.push(segment.text);
+                }
+            }
+        }
+        if (segmentsToJoin.length > 0) {
+            lines.push(segmentsToJoin.join(''));
+        }
+        if (lastSegmentWasEol) {
+            lines.push('');
+        }
+        return lines;
+    }
+}
+exports.Terminal = Terminal;
+//# sourceMappingURL=Terminal.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/57/mkdirssync_57a474552ec95c9b8e2261bbaaf33e4c

@@ -0,0 +1,55 @@
+e7fa2b447ce94afbabff8325bd297fce
+'use strict'
+
+const fs = require('graceful-fs')
+const path = require('path')
+const invalidWin32Path = require('./win32').invalidWin32Path
+
+const o777 = parseInt('0777', 8)
+
+function mkdirsSync (p, opts, made) {
+  if (!opts || typeof opts !== 'object') {
+    opts = { mode: opts }
+  }
+
+  let mode = opts.mode
+  const xfs = opts.fs || fs
+
+  if (process.platform === 'win32' && invalidWin32Path(p)) {
+    const errInval = new Error(p + ' contains invalid WIN32 path characters.')
+    errInval.code = 'EINVAL'
+    throw errInval
+  }
+
+  if (mode === undefined) {
+    mode = o777 & (~process.umask())
+  }
+  if (!made) made = null
+
+  p = path.resolve(p)
+
+  try {
+    xfs.mkdirSync(p, mode)
+    made = made || p
+  } catch (err0) {
+    if (err0.code === 'ENOENT') {
+      if (path.dirname(p) === p) throw err0
+      made = mkdirsSync(path.dirname(p), opts, made)
+      mkdirsSync(p, opts, made)
+    } else {
+      // 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.
+      let stat
+      try {
+        stat = xfs.statSync(p)
+      } catch (err1) {
+        throw err0
+      }
+      if (!stat.isDirectory()) throw err0
+    }
+  }
+
+  return made
+}
+
+module.exports = mkdirsSync

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/58/index_58c57a8f2a96bf6fdf5db35a2e44baa7

@@ -0,0 +1,84 @@
+3fc85697379a38faf34a7605e1fb101f
+"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.TypeUuid = exports.StringBufferTerminalProvider = exports.ConsoleTerminalProvider = exports.TerminalProviderSeverity = exports.TextAttribute = exports.ColorValue = exports.Colors = exports.Terminal = exports.SubprocessTerminator = exports.StringBuilder = exports.LegacyAdapters = exports.FileWriter = exports.FileSystem = exports.AlreadyExistsBehavior = exports.Sort = exports.NewlineKind = exports.Text = exports.Encoding = exports.Path = exports.PackageNameParser = exports.PackageName = exports.PackageJsonLookup = exports.ProtectableMap = exports.PosixModeBits = exports.MapExtensions = exports.LockFile = exports.JsonSchema = exports.JsonFile = exports.JsonSyntax = exports.InternalError = exports.Import = exports.FileError = exports.Executable = exports.EnvironmentMap = exports.Enum = exports.FolderConstants = exports.FileConstants = exports.Async = exports.AnsiEscape = exports.AlreadyReportedError = void 0;
+/**
+ * Core libraries that every NodeJS toolchain project should use.
+ *
+ * @packageDocumentation
+ */
+var AlreadyReportedError_1 = require("./AlreadyReportedError");
+Object.defineProperty(exports, "AlreadyReportedError", { enumerable: true, get: function () { return AlreadyReportedError_1.AlreadyReportedError; } });
+var AnsiEscape_1 = require("./Terminal/AnsiEscape");
+Object.defineProperty(exports, "AnsiEscape", { enumerable: true, get: function () { return AnsiEscape_1.AnsiEscape; } });
+var Async_1 = require("./Async");
+Object.defineProperty(exports, "Async", { enumerable: true, get: function () { return Async_1.Async; } });
+var Constants_1 = require("./Constants");
+Object.defineProperty(exports, "FileConstants", { enumerable: true, get: function () { return Constants_1.FileConstants; } });
+Object.defineProperty(exports, "FolderConstants", { enumerable: true, get: function () { return Constants_1.FolderConstants; } });
+var Enum_1 = require("./Enum");
+Object.defineProperty(exports, "Enum", { enumerable: true, get: function () { return Enum_1.Enum; } });
+var EnvironmentMap_1 = require("./EnvironmentMap");
+Object.defineProperty(exports, "EnvironmentMap", { enumerable: true, get: function () { return EnvironmentMap_1.EnvironmentMap; } });
+var Executable_1 = require("./Executable");
+Object.defineProperty(exports, "Executable", { enumerable: true, get: function () { return Executable_1.Executable; } });
+var FileError_1 = require("./FileError");
+Object.defineProperty(exports, "FileError", { enumerable: true, get: function () { return FileError_1.FileError; } });
+var Import_1 = require("./Import");
+Object.defineProperty(exports, "Import", { enumerable: true, get: function () { return Import_1.Import; } });
+var InternalError_1 = require("./InternalError");
+Object.defineProperty(exports, "InternalError", { enumerable: true, get: function () { return InternalError_1.InternalError; } });
+var JsonFile_1 = require("./JsonFile");
+Object.defineProperty(exports, "JsonSyntax", { enumerable: true, get: function () { return JsonFile_1.JsonSyntax; } });
+Object.defineProperty(exports, "JsonFile", { enumerable: true, get: function () { return JsonFile_1.JsonFile; } });
+var JsonSchema_1 = require("./JsonSchema");
+Object.defineProperty(exports, "JsonSchema", { enumerable: true, get: function () { return JsonSchema_1.JsonSchema; } });
+var LockFile_1 = require("./LockFile");
+Object.defineProperty(exports, "LockFile", { enumerable: true, get: function () { return LockFile_1.LockFile; } });
+var MapExtensions_1 = require("./MapExtensions");
+Object.defineProperty(exports, "MapExtensions", { enumerable: true, get: function () { return MapExtensions_1.MapExtensions; } });
+var PosixModeBits_1 = require("./PosixModeBits");
+Object.defineProperty(exports, "PosixModeBits", { enumerable: true, get: function () { return PosixModeBits_1.PosixModeBits; } });
+var ProtectableMap_1 = require("./ProtectableMap");
+Object.defineProperty(exports, "ProtectableMap", { enumerable: true, get: function () { return ProtectableMap_1.ProtectableMap; } });
+var PackageJsonLookup_1 = require("./PackageJsonLookup");
+Object.defineProperty(exports, "PackageJsonLookup", { enumerable: true, get: function () { return PackageJsonLookup_1.PackageJsonLookup; } });
+var PackageName_1 = require("./PackageName");
+Object.defineProperty(exports, "PackageName", { enumerable: true, get: function () { return PackageName_1.PackageName; } });
+Object.defineProperty(exports, "PackageNameParser", { enumerable: true, get: function () { return PackageName_1.PackageNameParser; } });
+var Path_1 = require("./Path");
+Object.defineProperty(exports, "Path", { enumerable: true, get: function () { return Path_1.Path; } });
+var Text_1 = require("./Text");
+Object.defineProperty(exports, "Encoding", { enumerable: true, get: function () { return Text_1.Encoding; } });
+Object.defineProperty(exports, "Text", { enumerable: true, get: function () { return Text_1.Text; } });
+Object.defineProperty(exports, "NewlineKind", { enumerable: true, get: function () { return Text_1.NewlineKind; } });
+var Sort_1 = require("./Sort");
+Object.defineProperty(exports, "Sort", { enumerable: true, get: function () { return Sort_1.Sort; } });
+var FileSystem_1 = require("./FileSystem");
+Object.defineProperty(exports, "AlreadyExistsBehavior", { enumerable: true, get: function () { return FileSystem_1.AlreadyExistsBehavior; } });
+Object.defineProperty(exports, "FileSystem", { enumerable: true, get: function () { return FileSystem_1.FileSystem; } });
+var FileWriter_1 = require("./FileWriter");
+Object.defineProperty(exports, "FileWriter", { enumerable: true, get: function () { return FileWriter_1.FileWriter; } });
+var LegacyAdapters_1 = require("./LegacyAdapters");
+Object.defineProperty(exports, "LegacyAdapters", { enumerable: true, get: function () { return LegacyAdapters_1.LegacyAdapters; } });
+var StringBuilder_1 = require("./StringBuilder");
+Object.defineProperty(exports, "StringBuilder", { enumerable: true, get: function () { return StringBuilder_1.StringBuilder; } });
+var SubprocessTerminator_1 = require("./SubprocessTerminator");
+Object.defineProperty(exports, "SubprocessTerminator", { enumerable: true, get: function () { return SubprocessTerminator_1.SubprocessTerminator; } });
+var Terminal_1 = require("./Terminal/Terminal");
+Object.defineProperty(exports, "Terminal", { enumerable: true, get: function () { return Terminal_1.Terminal; } });
+var Colors_1 = require("./Terminal/Colors");
+Object.defineProperty(exports, "Colors", { enumerable: true, get: function () { return Colors_1.Colors; } });
+Object.defineProperty(exports, "ColorValue", { enumerable: true, get: function () { return Colors_1.ColorValue; } });
+Object.defineProperty(exports, "TextAttribute", { enumerable: true, get: function () { return Colors_1.TextAttribute; } });
+var ITerminalProvider_1 = require("./Terminal/ITerminalProvider");
+Object.defineProperty(exports, "TerminalProviderSeverity", { enumerable: true, get: function () { return ITerminalProvider_1.TerminalProviderSeverity; } });
+var ConsoleTerminalProvider_1 = require("./Terminal/ConsoleTerminalProvider");
+Object.defineProperty(exports, "ConsoleTerminalProvider", { enumerable: true, get: function () { return ConsoleTerminalProvider_1.ConsoleTerminalProvider; } });
+var StringBufferTerminalProvider_1 = require("./Terminal/StringBufferTerminalProvider");
+Object.defineProperty(exports, "StringBufferTerminalProvider", { enumerable: true, get: function () { return StringBufferTerminalProvider_1.StringBufferTerminalProvider; } });
+var TypeUuid_1 = require("./TypeUuid");
+Object.defineProperty(exports, "TypeUuid", { enumerable: true, get: function () { return TypeUuid_1.TypeUuid; } });
+//# sourceMappingURL=index.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/58/link_588215e47725c14ad798d475bb0fea94

@@ -0,0 +1,62 @@
+87a056a34d6f9e0afcc150c235c6b972
+'use strict'
+
+const u = require('universalify').fromCallback
+const path = require('path')
+const fs = require('graceful-fs')
+const mkdir = require('../mkdirs')
+const pathExists = require('../path-exists').pathExists
+
+function createLink (srcpath, dstpath, callback) {
+  function makeLink (srcpath, dstpath) {
+    fs.link(srcpath, dstpath, err => {
+      if (err) return callback(err)
+      callback(null)
+    })
+  }
+
+  pathExists(dstpath, (err, destinationExists) => {
+    if (err) return callback(err)
+    if (destinationExists) return callback(null)
+    fs.lstat(srcpath, (err) => {
+      if (err) {
+        err.message = err.message.replace('lstat', 'ensureLink')
+        return callback(err)
+      }
+
+      const dir = path.dirname(dstpath)
+      pathExists(dir, (err, dirExists) => {
+        if (err) return callback(err)
+        if (dirExists) return makeLink(srcpath, dstpath)
+        mkdir.mkdirs(dir, err => {
+          if (err) return callback(err)
+          makeLink(srcpath, dstpath)
+        })
+      })
+    })
+  })
+}
+
+function createLinkSync (srcpath, dstpath) {
+  const destinationExists = fs.existsSync(dstpath)
+  if (destinationExists) return undefined
+
+  try {
+    fs.lstatSync(srcpath)
+  } catch (err) {
+    err.message = err.message.replace('lstat', 'ensureLink')
+    throw err
+  }
+
+  const dir = path.dirname(dstpath)
+  const dirExists = fs.existsSync(dir)
+  if (dirExists) return fs.linkSync(srcpath, dstpath)
+  mkdir.mkdirsSync(dir)
+
+  return fs.linkSync(srcpath, dstpath)
+}
+
+module.exports = {
+  createLink: u(createLink),
+  createLinkSync
+}