Update build

Bumps [word-wrap](https://github.com/jonschlinkert/word-wrap) from 1.2.3 to 1.2.4.
- [Release notes](https://github.com/jonschlinkert/word-wrap/releases)
- [Commits](https://github.com/jonschlinkert/word-wrap/compare/1.2.3...1.2.4)

---
updated-dependencies:
- dependency-name: word-wrap
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

__tests__/cache-save.test.ts

@@ -92,6 +92,9 @@ describe('run', () => {
 
     it('Package manager is not valid, skip caching', async () => {
       inputs['cache'] = 'yarn3';
+      getStateSpy.mockImplementation(key =>
+        key === State.CachePackageManager ? inputs['cache'] : ''
+      );
 
       await run();
 
@@ -108,7 +111,9 @@ describe('run', () => {
     it('should not save cache for yarn1', async () => {
       inputs['cache'] = 'yarn';
       getStateSpy.mockImplementation(key =>
-        key === State.CachePrimaryKey || key === State.CacheMatchedKey
+        key === State.CachePackageManager
+          ? inputs['cache']
+          : key === State.CachePrimaryKey || key === State.CacheMatchedKey
           ? yarnFileHash
           : key === State.CachePaths
           ? '["/foo/bar"]'
@@ -117,8 +122,8 @@ describe('run', () => {
 
       await run();
 
-      expect(getInputSpy).toHaveBeenCalled();
+      expect(getInputSpy).not.toHaveBeenCalled();
-      expect(getStateSpy).toHaveBeenCalledTimes(3);
+      expect(getStateSpy).toHaveBeenCalledTimes(4);
       expect(getCommandOutputSpy).toHaveBeenCalledTimes(0);
       expect(debugSpy).toHaveBeenCalledTimes(0);
       expect(infoSpy).toHaveBeenCalledWith(
@@ -130,7 +135,9 @@ describe('run', () => {
     it('should not save cache for yarn2', async () => {
       inputs['cache'] = 'yarn';
       getStateSpy.mockImplementation(key =>
-        key === State.CachePrimaryKey || key === State.CacheMatchedKey
+        key === State.CachePackageManager
+          ? inputs['cache']
+          : key === State.CachePrimaryKey || key === State.CacheMatchedKey
           ? yarnFileHash
           : key === State.CachePaths
           ? '["/foo/bar"]'
@@ -139,8 +146,8 @@ describe('run', () => {
 
       await run();
 
-      expect(getInputSpy).toHaveBeenCalled();
+      expect(getInputSpy).not.toHaveBeenCalled();
-      expect(getStateSpy).toHaveBeenCalledTimes(3);
+      expect(getStateSpy).toHaveBeenCalledTimes(4);
       expect(getCommandOutputSpy).toHaveBeenCalledTimes(0);
       expect(debugSpy).toHaveBeenCalledTimes(0);
       expect(infoSpy).toHaveBeenCalledWith(
@@ -152,7 +159,9 @@ describe('run', () => {
     it('should not save cache for npm', async () => {
       inputs['cache'] = 'npm';
       getStateSpy.mockImplementation(key =>
-        key === State.CachePrimaryKey || key === State.CacheMatchedKey
+        key === State.CachePackageManager
+          ? inputs['cache']
+          : key === State.CachePrimaryKey || key === State.CacheMatchedKey
           ? yarnFileHash
           : key === State.CachePaths
           ? '["/foo/bar"]'
@@ -162,8 +171,8 @@ describe('run', () => {
 
       await run();
 
-      expect(getInputSpy).toHaveBeenCalled();
+      expect(getInputSpy).not.toHaveBeenCalled();
-      expect(getStateSpy).toHaveBeenCalledTimes(3);
+      expect(getStateSpy).toHaveBeenCalledTimes(4);
       expect(getCommandOutputSpy).toHaveBeenCalledTimes(0);
       expect(debugSpy).toHaveBeenCalledTimes(0);
       expect(setFailedSpy).not.toHaveBeenCalled();
@@ -172,7 +181,9 @@ describe('run', () => {
     it('should not save cache for pnpm', async () => {
       inputs['cache'] = 'pnpm';
       getStateSpy.mockImplementation(key =>
-        key === State.CachePrimaryKey || key === State.CacheMatchedKey
+        key === State.CachePackageManager
+          ? inputs['cache']
+          : key === State.CachePrimaryKey || key === State.CacheMatchedKey
           ? yarnFileHash
           : key === State.CachePaths
           ? '["/foo/bar"]'
@@ -181,8 +192,8 @@ describe('run', () => {
 
       await run();
 
-      expect(getInputSpy).toHaveBeenCalled();
+      expect(getInputSpy).not.toHaveBeenCalled();
-      expect(getStateSpy).toHaveBeenCalledTimes(3);
+      expect(getStateSpy).toHaveBeenCalledTimes(4);
       expect(getCommandOutputSpy).toHaveBeenCalledTimes(0);
       expect(debugSpy).toHaveBeenCalledTimes(0);
       expect(setFailedSpy).not.toHaveBeenCalled();
@@ -193,7 +204,9 @@ describe('run', () => {
     it('saves cache from yarn 1', async () => {
       inputs['cache'] = 'yarn';
       getStateSpy.mockImplementation((key: string) =>
-        key === State.CacheMatchedKey
+        key === State.CachePackageManager
+          ? inputs['cache']
+          : key === State.CacheMatchedKey
           ? yarnFileHash
           : key === State.CachePrimaryKey
           ? npmFileHash
@@ -204,8 +217,8 @@ describe('run', () => {
 
       await run();
 
-      expect(getInputSpy).toHaveBeenCalled();
+      expect(getInputSpy).not.toHaveBeenCalled();
-      expect(getStateSpy).toHaveBeenCalledTimes(3);
+      expect(getStateSpy).toHaveBeenCalledTimes(4);
       expect(getCommandOutputSpy).toHaveBeenCalledTimes(0);
       expect(debugSpy).toHaveBeenCalledTimes(0);
       expect(infoSpy).not.toHaveBeenCalledWith(
@@ -221,7 +234,9 @@ describe('run', () => {
     it('saves cache from yarn 2', async () => {
       inputs['cache'] = 'yarn';
       getStateSpy.mockImplementation((key: string) =>
-        key === State.CacheMatchedKey
+        key === State.CachePackageManager
+          ? inputs['cache']
+          : key === State.CacheMatchedKey
           ? yarnFileHash
           : key === State.CachePrimaryKey
           ? npmFileHash
@@ -232,8 +247,8 @@ describe('run', () => {
 
       await run();
 
-      expect(getInputSpy).toHaveBeenCalled();
+      expect(getInputSpy).not.toHaveBeenCalled();
-      expect(getStateSpy).toHaveBeenCalledTimes(3);
+      expect(getStateSpy).toHaveBeenCalledTimes(4);
       expect(getCommandOutputSpy).toHaveBeenCalledTimes(0);
       expect(debugSpy).toHaveBeenCalledTimes(0);
       expect(infoSpy).not.toHaveBeenCalledWith(
@@ -249,7 +264,9 @@ describe('run', () => {
     it('saves cache from npm', async () => {
       inputs['cache'] = 'npm';
       getStateSpy.mockImplementation((key: string) =>
-        key === State.CacheMatchedKey
+        key === State.CachePackageManager
+          ? inputs['cache']
+          : key === State.CacheMatchedKey
           ? npmFileHash
           : key === State.CachePrimaryKey
           ? yarnFileHash
@@ -260,8 +277,8 @@ describe('run', () => {
 
       await run();
 
-      expect(getInputSpy).toHaveBeenCalled();
+      expect(getInputSpy).not.toHaveBeenCalled();
-      expect(getStateSpy).toHaveBeenCalledTimes(3);
+      expect(getStateSpy).toHaveBeenCalledTimes(4);
       expect(getCommandOutputSpy).toHaveBeenCalledTimes(0);
       expect(debugSpy).toHaveBeenCalledTimes(0);
       expect(infoSpy).not.toHaveBeenCalledWith(
@@ -277,7 +294,9 @@ describe('run', () => {
     it('saves cache from pnpm', async () => {
       inputs['cache'] = 'pnpm';
       getStateSpy.mockImplementation((key: string) =>
-        key === State.CacheMatchedKey
+        key === State.CachePackageManager
+          ? inputs['cache']
+          : key === State.CacheMatchedKey
           ? pnpmFileHash
           : key === State.CachePrimaryKey
           ? npmFileHash
@@ -288,8 +307,8 @@ describe('run', () => {
 
       await run();
 
-      expect(getInputSpy).toHaveBeenCalled();
+      expect(getInputSpy).not.toHaveBeenCalled();
-      expect(getStateSpy).toHaveBeenCalledTimes(3);
+      expect(getStateSpy).toHaveBeenCalledTimes(4);
       expect(getCommandOutputSpy).toHaveBeenCalledTimes(0);
       expect(debugSpy).toHaveBeenCalledTimes(0);
       expect(infoSpy).not.toHaveBeenCalledWith(
@@ -305,7 +324,9 @@ describe('run', () => {
     it('save with -1 cacheId , should not fail workflow', async () => {
       inputs['cache'] = 'npm';
       getStateSpy.mockImplementation((key: string) =>
-        key === State.CacheMatchedKey
+        key === State.CachePackageManager
+          ? inputs['cache']
+          : key === State.CacheMatchedKey
           ? npmFileHash
           : key === State.CachePrimaryKey
           ? yarnFileHash
@@ -319,8 +340,8 @@ describe('run', () => {
 
       await run();
 
-      expect(getInputSpy).toHaveBeenCalled();
+      expect(getInputSpy).not.toHaveBeenCalled();
-      expect(getStateSpy).toHaveBeenCalledTimes(3);
+      expect(getStateSpy).toHaveBeenCalledTimes(4);
       expect(getCommandOutputSpy).toHaveBeenCalledTimes(0);
       expect(debugSpy).toHaveBeenCalledTimes(0);
       expect(infoSpy).not.toHaveBeenCalledWith(
@@ -336,7 +357,9 @@ describe('run', () => {
     it('saves with error from toolkit, should fail workflow', async () => {
       inputs['cache'] = 'npm';
       getStateSpy.mockImplementation((key: string) =>
-        key === State.CacheMatchedKey
+        key === State.CachePackageManager
+          ? inputs['cache']
+          : key === State.CacheMatchedKey
           ? npmFileHash
           : key === State.CachePrimaryKey
           ? yarnFileHash
@@ -350,8 +373,8 @@ describe('run', () => {
 
       await run();
 
-      expect(getInputSpy).toHaveBeenCalled();
+      expect(getInputSpy).not.toHaveBeenCalled();
-      expect(getStateSpy).toHaveBeenCalledTimes(3);
+      expect(getStateSpy).toHaveBeenCalledTimes(4);
       expect(getCommandOutputSpy).toHaveBeenCalledTimes(0);
       expect(debugSpy).toHaveBeenCalledTimes(0);
       expect(infoSpy).not.toHaveBeenCalledWith(

__tests__/cache-utils.test.ts

@@ -6,8 +6,7 @@ import {
   PackageManagerInfo,
   isCacheFeatureAvailable,
   supportedPackageManagers,
-  getCommandOutput,
+  getProjectDirectoriesFromCacheDependencyPath
-  resetProjectDirectoriesMemoized
 } from '../src/cache-utils';
 import fs from 'fs';
 import * as cacheUtils from '../src/cache-utils';
@@ -123,7 +122,7 @@ describe('cache-utils', () => {
           MockGlobber.create(['/foo', '/bar'])
       );
 
-      resetProjectDirectoriesMemoized();
+      getProjectDirectoriesFromCacheDependencyPath.cache.clear?.();
     });
 
     afterEach(() => {

dist/cache-save/index.js

@@ -46782,6 +46782,689 @@ DelayedStream.prototype._checkIfMaxDataSizeExceeded = function() {
 };
 
 
+/***/ }),
+
+/***/ 4538:
+/***/ ((module) => {
+
+/**
+ * lodash (Custom Build) <https://lodash.com/>
+ * Build: `lodash modularize exports="npm" -o ./`
+ * Copyright jQuery Foundation and other contributors <https://jquery.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */
+
+/** Used as the `TypeError` message for "Functions" methods. */
+var FUNC_ERROR_TEXT = 'Expected a function';
+
+/** Used to stand-in for `undefined` hash values. */
+var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+/** `Object#toString` result references. */
+var funcTag = '[object Function]',
+    genTag = '[object GeneratorFunction]';
+
+/**
+ * Used to match `RegExp`
+ * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+ */
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+
+/** Used to detect host constructors (Safari). */
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+
+/** Detect free variable `global` from Node.js. */
+var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
+
+/** Detect free variable `self`. */
+var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+
+/** Used as a reference to the global object. */
+var root = freeGlobal || freeSelf || Function('return this')();
+
+/**
+ * Gets the value at `key` of `object`.
+ *
+ * @private
+ * @param {Object} [object] The object to query.
+ * @param {string} key The key of the property to get.
+ * @returns {*} Returns the property value.
+ */
+function getValue(object, key) {
+  return object == null ? undefined : object[key];
+}
+
+/**
+ * Checks if `value` is a host object in IE < 9.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a host object, else `false`.
+ */
+function isHostObject(value) {
+  // Many host objects are `Object` objects that can coerce to strings
+  // despite having improperly defined `toString` methods.
+  var result = false;
+  if (value != null && typeof value.toString != 'function') {
+    try {
+      result = !!(value + '');
+    } catch (e) {}
+  }
+  return result;
+}
+
+/** Used for built-in method references. */
+var arrayProto = Array.prototype,
+    funcProto = Function.prototype,
+    objectProto = Object.prototype;
+
+/** Used to detect overreaching core-js shims. */
+var coreJsData = root['__core-js_shared__'];
+
+/** Used to detect methods masquerading as native. */
+var maskSrcKey = (function() {
+  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
+  return uid ? ('Symbol(src)_1.' + uid) : '';
+}());
+
+/** Used to resolve the decompiled source of functions. */
+var funcToString = funcProto.toString;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var objectToString = objectProto.toString;
+
+/** Used to detect if a method is native. */
+var reIsNative = RegExp('^' +
+  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
+  .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
+);
+
+/** Built-in value references. */
+var splice = arrayProto.splice;
+
+/* Built-in method references that are verified to be native. */
+var Map = getNative(root, 'Map'),
+    nativeCreate = getNative(Object, 'create');
+
+/**
+ * Creates a hash object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function Hash(entries) {
+  var index = -1,
+      length = entries ? entries.length : 0;
+
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+
+/**
+ * Removes all key-value entries from the hash.
+ *
+ * @private
+ * @name clear
+ * @memberOf Hash
+ */
+function hashClear() {
+  this.__data__ = nativeCreate ? nativeCreate(null) : {};
+}
+
+/**
+ * Removes `key` and its value from the hash.
+ *
+ * @private
+ * @name delete
+ * @memberOf Hash
+ * @param {Object} hash The hash to modify.
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function hashDelete(key) {
+  return this.has(key) && delete this.__data__[key];
+}
+
+/**
+ * Gets the hash value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf Hash
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function hashGet(key) {
+  var data = this.__data__;
+  if (nativeCreate) {
+    var result = data[key];
+    return result === HASH_UNDEFINED ? undefined : result;
+  }
+  return hasOwnProperty.call(data, key) ? data[key] : undefined;
+}
+
+/**
+ * Checks if a hash value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf Hash
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function hashHas(key) {
+  var data = this.__data__;
+  return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);
+}
+
+/**
+ * Sets the hash `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf Hash
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the hash instance.
+ */
+function hashSet(key, value) {
+  var data = this.__data__;
+  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
+  return this;
+}
+
+// Add methods to `Hash`.
+Hash.prototype.clear = hashClear;
+Hash.prototype['delete'] = hashDelete;
+Hash.prototype.get = hashGet;
+Hash.prototype.has = hashHas;
+Hash.prototype.set = hashSet;
+
+/**
+ * Creates an list cache object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function ListCache(entries) {
+  var index = -1,
+      length = entries ? entries.length : 0;
+
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+
+/**
+ * Removes all key-value entries from the list cache.
+ *
+ * @private
+ * @name clear
+ * @memberOf ListCache
+ */
+function listCacheClear() {
+  this.__data__ = [];
+}
+
+/**
+ * Removes `key` and its value from the list cache.
+ *
+ * @private
+ * @name delete
+ * @memberOf ListCache
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function listCacheDelete(key) {
+  var data = this.__data__,
+      index = assocIndexOf(data, key);
+
+  if (index < 0) {
+    return false;
+  }
+  var lastIndex = data.length - 1;
+  if (index == lastIndex) {
+    data.pop();
+  } else {
+    splice.call(data, index, 1);
+  }
+  return true;
+}
+
+/**
+ * Gets the list cache value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf ListCache
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function listCacheGet(key) {
+  var data = this.__data__,
+      index = assocIndexOf(data, key);
+
+  return index < 0 ? undefined : data[index][1];
+}
+
+/**
+ * Checks if a list cache value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf ListCache
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function listCacheHas(key) {
+  return assocIndexOf(this.__data__, key) > -1;
+}
+
+/**
+ * Sets the list cache `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf ListCache
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the list cache instance.
+ */
+function listCacheSet(key, value) {
+  var data = this.__data__,
+      index = assocIndexOf(data, key);
+
+  if (index < 0) {
+    data.push([key, value]);
+  } else {
+    data[index][1] = value;
+  }
+  return this;
+}
+
+// Add methods to `ListCache`.
+ListCache.prototype.clear = listCacheClear;
+ListCache.prototype['delete'] = listCacheDelete;
+ListCache.prototype.get = listCacheGet;
+ListCache.prototype.has = listCacheHas;
+ListCache.prototype.set = listCacheSet;
+
+/**
+ * Creates a map cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function MapCache(entries) {
+  var index = -1,
+      length = entries ? entries.length : 0;
+
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+
+/**
+ * Removes all key-value entries from the map.
+ *
+ * @private
+ * @name clear
+ * @memberOf MapCache
+ */
+function mapCacheClear() {
+  this.__data__ = {
+    'hash': new Hash,
+    'map': new (Map || ListCache),
+    'string': new Hash
+  };
+}
+
+/**
+ * Removes `key` and its value from the map.
+ *
+ * @private
+ * @name delete
+ * @memberOf MapCache
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function mapCacheDelete(key) {
+  return getMapData(this, key)['delete'](key);
+}
+
+/**
+ * Gets the map value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf MapCache
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function mapCacheGet(key) {
+  return getMapData(this, key).get(key);
+}
+
+/**
+ * Checks if a map value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf MapCache
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function mapCacheHas(key) {
+  return getMapData(this, key).has(key);
+}
+
+/**
+ * Sets the map `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf MapCache
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the map cache instance.
+ */
+function mapCacheSet(key, value) {
+  getMapData(this, key).set(key, value);
+  return this;
+}
+
+// Add methods to `MapCache`.
+MapCache.prototype.clear = mapCacheClear;
+MapCache.prototype['delete'] = mapCacheDelete;
+MapCache.prototype.get = mapCacheGet;
+MapCache.prototype.has = mapCacheHas;
+MapCache.prototype.set = mapCacheSet;
+
+/**
+ * Gets the index at which the `key` is found in `array` of key-value pairs.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {*} key The key to search for.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+function assocIndexOf(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq(array[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+
+/**
+ * The base implementation of `_.isNative` without bad shim checks.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a native function,
+ *  else `false`.
+ */
+function baseIsNative(value) {
+  if (!isObject(value) || isMasked(value)) {
+    return false;
+  }
+  var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource(value));
+}
+
+/**
+ * Gets the data for `map`.
+ *
+ * @private
+ * @param {Object} map The map to query.
+ * @param {string} key The reference key.
+ * @returns {*} Returns the map data.
+ */
+function getMapData(map, key) {
+  var data = map.__data__;
+  return isKeyable(key)
+    ? data[typeof key == 'string' ? 'string' : 'hash']
+    : data.map;
+}
+
+/**
+ * Gets the native function at `key` of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {string} key The key of the method to get.
+ * @returns {*} Returns the function if it's native, else `undefined`.
+ */
+function getNative(object, key) {
+  var value = getValue(object, key);
+  return baseIsNative(value) ? value : undefined;
+}
+
+/**
+ * Checks if `value` is suitable for use as unique object key.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
+ */
+function isKeyable(value) {
+  var type = typeof value;
+  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
+    ? (value !== '__proto__')
+    : (value === null);
+}
+
+/**
+ * Checks if `func` has its source masked.
+ *
+ * @private
+ * @param {Function} func The function to check.
+ * @returns {boolean} Returns `true` if `func` is masked, else `false`.
+ */
+function isMasked(func) {
+  return !!maskSrcKey && (maskSrcKey in func);
+}
+
+/**
+ * Converts `func` to its source code.
+ *
+ * @private
+ * @param {Function} func The function to process.
+ * @returns {string} Returns the source code.
+ */
+function toSource(func) {
+  if (func != null) {
+    try {
+      return funcToString.call(func);
+    } catch (e) {}
+    try {
+      return (func + '');
+    } catch (e) {}
+  }
+  return '';
+}
+
+/**
+ * Creates a function that memoizes the result of `func`. If `resolver` is
+ * provided, it determines the cache key for storing the result based on the
+ * arguments provided to the memoized function. By default, the first argument
+ * provided to the memoized function is used as the map cache key. The `func`
+ * is invoked with the `this` binding of the memoized function.
+ *
+ * **Note:** The cache is exposed as the `cache` property on the memoized
+ * function. Its creation may be customized by replacing the `_.memoize.Cache`
+ * constructor with one whose instances implement the
+ * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
+ * method interface of `delete`, `get`, `has`, and `set`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Function
+ * @param {Function} func The function to have its output memoized.
+ * @param {Function} [resolver] The function to resolve the cache key.
+ * @returns {Function} Returns the new memoized function.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': 2 };
+ * var other = { 'c': 3, 'd': 4 };
+ *
+ * var values = _.memoize(_.values);
+ * values(object);
+ * // => [1, 2]
+ *
+ * values(other);
+ * // => [3, 4]
+ *
+ * object.a = 2;
+ * values(object);
+ * // => [1, 2]
+ *
+ * // Modify the result cache.
+ * values.cache.set(object, ['a', 'b']);
+ * values(object);
+ * // => ['a', 'b']
+ *
+ * // Replace `_.memoize.Cache`.
+ * _.memoize.Cache = WeakMap;
+ */
+function memoize(func, resolver) {
+  if (typeof func != 'function' || (resolver && typeof resolver != 'function')) {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  var memoized = function() {
+    var args = arguments,
+        key = resolver ? resolver.apply(this, args) : args[0],
+        cache = memoized.cache;
+
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    var result = func.apply(this, args);
+    memoized.cache = cache.set(key, result);
+    return result;
+  };
+  memoized.cache = new (memoize.Cache || MapCache);
+  return memoized;
+}
+
+// Assign cache to `_.memoize`.
+memoize.Cache = MapCache;
+
+/**
+ * Performs a
+ * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * comparison between two values to determine if they are equivalent.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ * @example
+ *
+ * var object = { 'a': 1 };
+ * var other = { 'a': 1 };
+ *
+ * _.eq(object, object);
+ * // => true
+ *
+ * _.eq(object, other);
+ * // => false
+ *
+ * _.eq('a', 'a');
+ * // => true
+ *
+ * _.eq('a', Object('a'));
+ * // => false
+ *
+ * _.eq(NaN, NaN);
+ * // => true
+ */
+function eq(value, other) {
+  return value === other || (value !== value && other !== other);
+}
+
+/**
+ * Checks if `value` is classified as a `Function` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+ * @example
+ *
+ * _.isFunction(_);
+ * // => true
+ *
+ * _.isFunction(/abc/);
+ * // => false
+ */
+function isFunction(value) {
+  // The use of `Object#toString` avoids issues with the `typeof` operator
+  // in Safari 8-9 which returns 'object' for typed array and other constructors.
+  var tag = isObject(value) ? objectToString.call(value) : '';
+  return tag == funcTag || tag == genTag;
+}
+
+/**
+ * Checks if `value` is the
+ * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+ * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+ * @example
+ *
+ * _.isObject({});
+ * // => true
+ *
+ * _.isObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isObject(_.noop);
+ * // => true
+ *
+ * _.isObject(null);
+ * // => false
+ */
+function isObject(value) {
+  var type = typeof value;
+  return !!value && (type == 'object' || type == 'function');
+}
+
+module.exports = memoize;
+
+
 /***/ }),
 
 /***/ 7426:
@@ -60332,91 +61015,86 @@ exports.debug = debug; // for test
 /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
-
+
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
+    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
+}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
+    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
+    o[k2] = m[k];
-}));
+}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
+}) : function(o, v) {
-    o["default"] = v;
+    o["default"] = v;
-});
+});
-var __importStar = (this && this.__importStar) || function (mod) {
+var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
+    if (mod && mod.__esModule) return mod;
-    var result = {};
+    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
+    __setModuleDefault(result, mod);
-    return result;
+    return result;
-};
+};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
+    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+    });
-};
+};
-var __importDefault = (this && this.__importDefault) || function (mod) {
+Object.defineProperty(exports, "__esModule", ({ value: true }));
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+exports.run = void 0;
-};
+const core = __importStar(__nccwpck_require__(2186));
-Object.defineProperty(exports, "__esModule", ({ value: true }));
+const cache = __importStar(__nccwpck_require__(7799));
-exports.run = void 0;
+const constants_1 = __nccwpck_require__(9042);
-const core = __importStar(__nccwpck_require__(2186));
+const cache_utils_1 = __nccwpck_require__(1678);
-const cache = __importStar(__nccwpck_require__(7799));
+// Catch and log any unhandled exceptions.  These exceptions can leak out of the uploadChunk method in
-const fs_1 = __importDefault(__nccwpck_require__(7147));
+// @actions/toolkit when a failed upload closes the file descriptor causing any in-process reads to
-const constants_1 = __nccwpck_require__(9042);
+// throw an uncaught exception.  Instead of failing this action, just warn.
-const cache_utils_1 = __nccwpck_require__(1678);
+process.on('uncaughtException', e => {
-// Catch and log any unhandled exceptions.  These exceptions can leak out of the uploadChunk method in
+    const warningPrefix = '[warning]';
-// @actions/toolkit when a failed upload closes the file descriptor causing any in-process reads to
+    core.info(`${warningPrefix}${e.message}`);
-// throw an uncaught exception.  Instead of failing this action, just warn.
+});
-process.on('uncaughtException', e => {
+function run() {
-    const warningPrefix = '[warning]';
+    return __awaiter(this, void 0, void 0, function* () {
-    core.info(`${warningPrefix}${e.message}`);
+        try {
-});
+            const cacheLock = core.getState(constants_1.State.CachePackageManager);
-function run() {
+            yield cachePackages(cacheLock);
-    return __awaiter(this, void 0, void 0, function* () {
+        }
-        try {
+        catch (error) {
-            const cacheLock = core.getInput('cache');
+            core.setFailed(error.message);
-            yield cachePackages(cacheLock);
+        }
-        }
+    });
-        catch (error) {
+}
-            core.setFailed(error.message);
+exports.run = run;
-        }
+const cachePackages = (packageManager) => __awaiter(void 0, void 0, void 0, function* () {
-    });
+    const state = core.getState(constants_1.State.CacheMatchedKey);
-}
+    const primaryKey = core.getState(constants_1.State.CachePrimaryKey);
-exports.run = run;
+    const cachePaths = JSON.parse(core.getState(constants_1.State.CachePaths) || '[]');
-const cachePackages = (packageManager) => __awaiter(void 0, void 0, void 0, function* () {
+    const packageManagerInfo = yield cache_utils_1.getPackageManagerInfo(packageManager);
-    const state = core.getState(constants_1.State.CacheMatchedKey);
+    if (!packageManagerInfo) {
-    const primaryKey = core.getState(constants_1.State.CachePrimaryKey);
+        core.debug(`Caching for '${packageManager}' is not supported`);
-    let cachePaths = JSON.parse(core.getState(constants_1.State.CachePaths) || '[]');
+        return;
-    cachePaths = cachePaths.filter(fs_1.default.existsSync);
+    }
-    const packageManagerInfo = yield cache_utils_1.getPackageManagerInfo(packageManager);
+    if (!cachePaths.length) {
-    if (!packageManagerInfo) {
+        // TODO: core.getInput has a bug - it can return undefined despite its definition (tests only?)
-        core.debug(`Caching for '${packageManager}' is not supported`);
+        //       export declare function getInput(name: string, options?: InputOptions): string;
-        return;
+        const cacheDependencyPath = core.getInput('cache-dependency-path') || '';
-    }
+        throw new Error(`Cache folder paths are not retrieved for ${packageManager} with cache-dependency-path = ${cacheDependencyPath}`);
-    if (!cachePaths.length) {
+    }
-        // TODO: core.getInput has a bug - it can return undefined despite its definition (tests only?)
+    if (primaryKey === state) {
-        //       export declare function getInput(name: string, options?: InputOptions): string;
+        core.info(`Cache hit occurred on the primary key ${primaryKey}, not saving cache.`);
-        const cacheDependencyPath = core.getInput('cache-dependency-path') || '';
+        return;
-        throw new Error(`Cache folder paths are not retrieved for ${packageManager} with cache-dependency-path = ${cacheDependencyPath}`);
+    }
-    }
+    const cacheId = yield cache.saveCache(cachePaths, primaryKey);
-    if (primaryKey === state) {
+    if (cacheId == -1) {
-        core.info(`Cache hit occurred on the primary key ${primaryKey}, not saving cache.`);
+        return;
-        return;
+    }
-    }
+    core.info(`Cache saved with the key: ${primaryKey}`);
-    const cacheId = yield cache.saveCache(cachePaths, primaryKey);
+});
-    if (cacheId == -1) {
+run();
-        return;
-    }
-    core.info(`Cache saved with the key: ${primaryKey}`);
-});
-run();
 
 
 /***/ }),
@@ -60425,254 +61103,245 @@ run();
 /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
-
+
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
+    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
+}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
+    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
+    o[k2] = m[k];
-}));
+}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
+}) : function(o, v) {
-    o["default"] = v;
+    o["default"] = v;
-});
+});
-var __importStar = (this && this.__importStar) || function (mod) {
+var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
+    if (mod && mod.__esModule) return mod;
-    var result = {};
+    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
+    __setModuleDefault(result, mod);
-    return result;
+    return result;
-};
+};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
+    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+    });
-};
+};
-var __importDefault = (this && this.__importDefault) || function (mod) {
+var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+};
-Object.defineProperty(exports, "__esModule", ({ value: true }));
+Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.isCacheFeatureAvailable = exports.isGhes = exports.repoHasYarnBerryManagedDependencies = exports.getCacheDirectories = exports.resetProjectDirectoriesMemoized = exports.getPackageManagerInfo = exports.getCommandOutputNotEmpty = exports.getCommandOutput = exports.supportedPackageManagers = void 0;
+exports.isCacheFeatureAvailable = exports.isGhes = exports.repoHasYarnBerryManagedDependencies = exports.getCacheDirectories = exports.getProjectDirectoriesFromCacheDependencyPath = exports.getPackageManagerInfo = exports.getCommandOutputNotEmpty = exports.getCommandOutput = exports.supportedPackageManagers = void 0;
-const core = __importStar(__nccwpck_require__(2186));
+const core = __importStar(__nccwpck_require__(2186));
-const exec = __importStar(__nccwpck_require__(1514));
+const exec = __importStar(__nccwpck_require__(1514));
-const cache = __importStar(__nccwpck_require__(7799));
+const cache = __importStar(__nccwpck_require__(7799));
-const glob = __importStar(__nccwpck_require__(8090));
+const glob = __importStar(__nccwpck_require__(8090));
-const path_1 = __importDefault(__nccwpck_require__(1017));
+const lodash_memoize_1 = __importDefault(__nccwpck_require__(4538));
-const fs_1 = __importDefault(__nccwpck_require__(7147));
+const path_1 = __importDefault(__nccwpck_require__(1017));
-const util_1 = __nccwpck_require__(2629);
+const fs_1 = __importDefault(__nccwpck_require__(7147));
-exports.supportedPackageManagers = {
+const util_1 = __nccwpck_require__(2629);
-    npm: {
+exports.supportedPackageManagers = {
-        name: 'npm',
+    npm: {
-        lockFilePatterns: ['package-lock.json', 'npm-shrinkwrap.json', 'yarn.lock'],
+        name: 'npm',
-        getCacheFolderPath: () => exports.getCommandOutputNotEmpty('npm config get cache', 'Could not get npm cache folder path')
+        lockFilePatterns: ['package-lock.json', 'npm-shrinkwrap.json', 'yarn.lock'],
-    },
+        getCacheFolderPath: () => exports.getCommandOutputNotEmpty('npm config get cache', 'Could not get npm cache folder path')
-    pnpm: {
+    },
-        name: 'pnpm',
+    pnpm: {
-        lockFilePatterns: ['pnpm-lock.yaml'],
+        name: 'pnpm',
-        getCacheFolderPath: () => exports.getCommandOutputNotEmpty('pnpm store path --silent', 'Could not get pnpm cache folder path')
+        lockFilePatterns: ['pnpm-lock.yaml'],
-    },
+        getCacheFolderPath: () => exports.getCommandOutputNotEmpty('pnpm store path --silent', 'Could not get pnpm cache folder path')
-    yarn: {
+    },
-        name: 'yarn',
+    yarn: {
-        lockFilePatterns: ['yarn.lock'],
+        name: 'yarn',
-        getCacheFolderPath: (projectDir) => __awaiter(void 0, void 0, void 0, function* () {
+        lockFilePatterns: ['yarn.lock'],
-            const yarnVersion = yield exports.getCommandOutputNotEmpty(`yarn --version`, 'Could not retrieve version of yarn', projectDir);
+        getCacheFolderPath: (projectDir) => __awaiter(void 0, void 0, void 0, function* () {
-            core.debug(`Consumed yarn version is ${yarnVersion} (working dir: "${projectDir || ''}")`);
+            const yarnVersion = yield exports.getCommandOutputNotEmpty(`yarn --version`, 'Could not retrieve version of yarn', projectDir);
-            const stdOut = yarnVersion.startsWith('1.')
+            core.debug(`Consumed yarn version is ${yarnVersion} (working dir: "${projectDir || ''}")`);
-                ? yield exports.getCommandOutput('yarn cache dir', projectDir)
+            const stdOut = yarnVersion.startsWith('1.')
-                : yield exports.getCommandOutput('yarn config get cacheFolder', projectDir);
+                ? yield exports.getCommandOutput('yarn cache dir', projectDir)
-            if (!stdOut) {
+                : yield exports.getCommandOutput('yarn config get cacheFolder', projectDir);
-                throw new Error(`Could not get yarn cache folder path for ${projectDir}`);
+            if (!stdOut) {
-            }
+                throw new Error(`Could not get yarn cache folder path for ${projectDir}`);
-            return stdOut;
+            }
-        })
+            return stdOut;
-    }
+        })
-};
+    }
-const getCommandOutput = (toolCommand, cwd) => __awaiter(void 0, void 0, void 0, function* () {
+};
-    let { stdout, stderr, exitCode } = yield exec.getExecOutput(toolCommand, undefined, Object.assign({ ignoreReturnCode: true }, (cwd && { cwd })));
+const getCommandOutput = (toolCommand, cwd) => __awaiter(void 0, void 0, void 0, function* () {
-    if (exitCode) {
+    let { stdout, stderr, exitCode } = yield exec.getExecOutput(toolCommand, undefined, Object.assign({ ignoreReturnCode: true }, (cwd && { cwd })));
-        stderr = !stderr.trim()
+    if (exitCode) {
-            ? `The '${toolCommand}' command failed with exit code: ${exitCode}`
+        stderr = !stderr.trim()
-            : stderr;
+            ? `The '${toolCommand}' command failed with exit code: ${exitCode}`
-        throw new Error(stderr);
+            : stderr;
-    }
+        throw new Error(stderr);
-    return stdout.trim();
+    }
-});
+    return stdout.trim();
-exports.getCommandOutput = getCommandOutput;
+});
-const getCommandOutputNotEmpty = (toolCommand, error, cwd) => __awaiter(void 0, void 0, void 0, function* () {
+exports.getCommandOutput = getCommandOutput;
-    const stdOut = exports.getCommandOutput(toolCommand, cwd);
+const getCommandOutputNotEmpty = (toolCommand, error, cwd) => __awaiter(void 0, void 0, void 0, function* () {
-    if (!stdOut) {
+    const stdOut = exports.getCommandOutput(toolCommand, cwd);
-        throw new Error(error);
+    if (!stdOut) {
-    }
+        throw new Error(error);
-    return stdOut;
+    }
-});
+    return stdOut;
-exports.getCommandOutputNotEmpty = getCommandOutputNotEmpty;
+});
-const getPackageManagerInfo = (packageManager) => __awaiter(void 0, void 0, void 0, function* () {
+exports.getCommandOutputNotEmpty = getCommandOutputNotEmpty;
-    if (packageManager === 'npm') {
+const getPackageManagerInfo = (packageManager) => __awaiter(void 0, void 0, void 0, function* () {
-        return exports.supportedPackageManagers.npm;
+    if (packageManager === 'npm') {
-    }
+        return exports.supportedPackageManagers.npm;
-    else if (packageManager === 'pnpm') {
+    }
-        return exports.supportedPackageManagers.pnpm;
+    else if (packageManager === 'pnpm') {
-    }
+        return exports.supportedPackageManagers.pnpm;
-    else if (packageManager === 'yarn') {
+    }
-        return exports.supportedPackageManagers.yarn;
+    else if (packageManager === 'yarn') {
-    }
+        return exports.supportedPackageManagers.yarn;
-    else {
+    }
-        return null;
+    else {
-    }
+        return null;
-});
+    }
-exports.getPackageManagerInfo = getPackageManagerInfo;
+});
-/**
+exports.getPackageManagerInfo = getPackageManagerInfo;
- * getProjectDirectoriesFromCacheDependencyPath is called twice during `restoreCache`
+/**
- *  - first through `getCacheDirectories`
+ * Expands (converts) the string input `cache-dependency-path` to list of directories that
- *  - second from `repoHasYarn3ManagedCache`
+ * may be project roots
- *
+ *
- *  it contains expensive IO operation and thus should be memoized
+ * getProjectDirectoriesFromCacheDependencyPath is called twice during `restoreCache`
- */
+ *  - first through `getCacheDirectories`
-let projectDirectoriesMemoized = null;
+ *  - second from `repoHasYarn3ManagedCache`
-/**
+ *
- * unit test must reset memoized variables
+ * it contains expensive IO operation and thus should be memoized
- */
+ *
-const resetProjectDirectoriesMemoized = () => (projectDirectoriesMemoized = null);
+ * @param cacheDependencyPath - either a single string or multiline string with possible glob patterns
-exports.resetProjectDirectoriesMemoized = resetProjectDirectoriesMemoized;
+ *                              expected to be the result of `core.getInput('cache-dependency-path')`
-/**
+ * @return list of directories
- * Expands (converts) the string input `cache-dependency-path` to list of directories that
+ */
- * may be project roots
+exports.getProjectDirectoriesFromCacheDependencyPath = lodash_memoize_1.default((cacheDependencyPath) => __awaiter(void 0, void 0, void 0, function* () {
- * @param cacheDependencyPath - either a single string or multiline string with possible glob patterns
+    const globber = yield glob.create(cacheDependencyPath);
- *                              expected to be the result of `core.getInput('cache-dependency-path')`
+    const cacheDependenciesPaths = yield globber.glob();
- * @return list of directories and possible
+    const existingDirectories = cacheDependenciesPaths
- */
+        .map(path_1.default.dirname)
-const getProjectDirectoriesFromCacheDependencyPath = (cacheDependencyPath) => __awaiter(void 0, void 0, void 0, function* () {
+        .filter(util_1.unique())
-    if (projectDirectoriesMemoized !== null) {
+        .map(dirName => fs_1.default.realpathSync(dirName))
-        return projectDirectoriesMemoized;
+        .filter(directory => fs_1.default.lstatSync(directory).isDirectory());
-    }
+    if (!existingDirectories.length)
-    const globber = yield glob.create(cacheDependencyPath);
+        core.warning(`No existing directories found containing cache-dependency-path="${cacheDependencyPath}"`);
-    const cacheDependenciesPaths = yield globber.glob();
+    return existingDirectories;
-    const existingDirectories = cacheDependenciesPaths
+}));
-        .map(path_1.default.dirname)
+/**
-        .filter(util_1.unique())
+ * Finds the cache directories configured for the repo if cache-dependency-path is not empty
-        .map(dirName => fs_1.default.realpathSync(dirName))
+ * @param packageManagerInfo - an object having getCacheFolderPath method specific to given PM
-        .filter(directory => fs_1.default.lstatSync(directory).isDirectory());
+ * @param cacheDependencyPath - either a single string or multiline string with possible glob patterns
-    if (!existingDirectories.length)
+ *                              expected to be the result of `core.getInput('cache-dependency-path')`
-        core.warning(`No existing directories found containing cache-dependency-path="${cacheDependencyPath}"`);
+ * @return list of files on which the cache depends
-    projectDirectoriesMemoized = existingDirectories;
+ */
-    return existingDirectories;
+const getCacheDirectoriesFromCacheDependencyPath = (packageManagerInfo, cacheDependencyPath) => __awaiter(void 0, void 0, void 0, function* () {
-});
+    const projectDirectories = yield exports.getProjectDirectoriesFromCacheDependencyPath(cacheDependencyPath);
-/**
+    const cacheFoldersPaths = yield Promise.all(projectDirectories.map((projectDirectory) => __awaiter(void 0, void 0, void 0, function* () {
- * Finds the cache directories configured for the repo if cache-dependency-path is not empty
+        const cacheFolderPath = yield packageManagerInfo.getCacheFolderPath(projectDirectory);
- * @param packageManagerInfo - an object having getCacheFolderPath method specific to given PM
+        core.debug(`${packageManagerInfo.name}'s cache folder "${cacheFolderPath}" configured for the directory "${projectDirectory}"`);
- * @param cacheDependencyPath - either a single string or multiline string with possible glob patterns
+        return cacheFolderPath;
- *                              expected to be the result of `core.getInput('cache-dependency-path')`
+    })));
- * @return list of files on which the cache depends
+    // uniq in order to do not cache the same directories twice
- */
+    return cacheFoldersPaths.filter(util_1.unique());
-const getCacheDirectoriesFromCacheDependencyPath = (packageManagerInfo, cacheDependencyPath) => __awaiter(void 0, void 0, void 0, function* () {
+});
-    const projectDirectories = yield getProjectDirectoriesFromCacheDependencyPath(cacheDependencyPath);
+/**
-    const cacheFoldersPaths = yield Promise.all(projectDirectories.map((projectDirectory) => __awaiter(void 0, void 0, void 0, function* () {
+ * Finds the cache directories configured for the repo ignoring cache-dependency-path
-        const cacheFolderPath = yield packageManagerInfo.getCacheFolderPath(projectDirectory);
+ * @param packageManagerInfo - an object having getCacheFolderPath method specific to given PM
-        core.debug(`${packageManagerInfo.name}'s cache folder "${cacheFolderPath}" configured for the directory "${projectDirectory}"`);
+ * @return list of files on which the cache depends
-        return cacheFolderPath;
+ */
-    })));
+const getCacheDirectoriesForRootProject = (packageManagerInfo) => __awaiter(void 0, void 0, void 0, function* () {
-    // uniq in order to do not cache the same directories twice
+    const cacheFolderPath = yield packageManagerInfo.getCacheFolderPath();
-    return cacheFoldersPaths.filter(util_1.unique());
+    core.debug(`${packageManagerInfo.name}'s cache folder "${cacheFolderPath}" configured for the root directory`);
-});
+    return [cacheFolderPath];
-/**
+});
- * Finds the cache directories configured for the repo ignoring cache-dependency-path
+/**
- * @param packageManagerInfo - an object having getCacheFolderPath method specific to given PM
+ * A function to find the cache directories configured for the repo
- * @return list of files on which the cache depends
+ * currently it handles only the case of PM=yarn && cacheDependencyPath is not empty
- */
+ * @param packageManagerInfo - an object having getCacheFolderPath method specific to given PM
-const getCacheDirectoriesForRootProject = (packageManagerInfo) => __awaiter(void 0, void 0, void 0, function* () {
+ * @param cacheDependencyPath - either a single string or multiline string with possible glob patterns
-    const cacheFolderPath = yield packageManagerInfo.getCacheFolderPath();
+ *                              expected to be the result of `core.getInput('cache-dependency-path')`
-    core.debug(`${packageManagerInfo.name}'s cache folder "${cacheFolderPath}" configured for the root directory`);
+ * @return list of files on which the cache depends
-    return [cacheFolderPath];
+ */
-});
+const getCacheDirectories = (packageManagerInfo, cacheDependencyPath) => __awaiter(void 0, void 0, void 0, function* () {
-/**
+    // For yarn, if cacheDependencyPath is set, ask information about cache folders in each project
- * A function to find the cache directories configured for the repo
+    // folder satisfied by cacheDependencyPath https://github.com/actions/setup-node/issues/488
- * currently it handles only the case of PM=yarn && cacheDependencyPath is not empty
+    if (packageManagerInfo.name === 'yarn' && cacheDependencyPath) {
- * @param packageManagerInfo - an object having getCacheFolderPath method specific to given PM
+        return getCacheDirectoriesFromCacheDependencyPath(packageManagerInfo, cacheDependencyPath);
- * @param cacheDependencyPath - either a single string or multiline string with possible glob patterns
+    }
- *                              expected to be the result of `core.getInput('cache-dependency-path')`
+    return getCacheDirectoriesForRootProject(packageManagerInfo);
- * @return list of files on which the cache depends
+});
- */
+exports.getCacheDirectories = getCacheDirectories;
-const getCacheDirectories = (packageManagerInfo, cacheDependencyPath) => __awaiter(void 0, void 0, void 0, function* () {
+/**
-    // For yarn, if cacheDependencyPath is set, ask information about cache folders in each project
+ * A function to check if the directory is a yarn project configured to manage
-    // folder satisfied by cacheDependencyPath https://github.com/actions/setup-node/issues/488
+ * obsolete dependencies in the local cache
-    if (packageManagerInfo.name === 'yarn' && cacheDependencyPath) {
+ * @param directory - a path to the folder
-        return getCacheDirectoriesFromCacheDependencyPath(packageManagerInfo, cacheDependencyPath);
+ * @return - true if the directory's project is yarn managed
-    }
+ *  - if there's .yarn/cache folder do not mess with the dependencies kept in the repo, return false
-    return getCacheDirectoriesForRootProject(packageManagerInfo);
+ *  - global cache is not managed by yarn @see https://yarnpkg.com/features/offline-cache, return false
-});
+ *  - if local cache is not explicitly enabled (not yarn3), return false
-exports.getCacheDirectories = getCacheDirectories;
+ *  - return true otherwise
-/**
+ */
- * A function to check if the directory is a yarn project configured to manage
+const projectHasYarnBerryManagedDependencies = (directory) => __awaiter(void 0, void 0, void 0, function* () {
- * obsolete dependencies in the local cache
+    const workDir = directory || process.env.GITHUB_WORKSPACE || '.';
- * @param directory - a path to the folder
+    core.debug(`check if "${workDir}" has locally managed yarn3 dependencies`);
- * @return - true if the directory's project is yarn managed
+    // if .yarn/cache directory exists the cache is managed by version control system
- *  - if there's .yarn/cache folder do not mess with the dependencies kept in the repo, return false
+    const yarnCacheFile = path_1.default.join(workDir, '.yarn', 'cache');
- *  - global cache is not managed by yarn @see https://yarnpkg.com/features/offline-cache, return false
+    if (fs_1.default.existsSync(yarnCacheFile) &&
- *  - if local cache is not explicitly enabled (not yarn3), return false
+        fs_1.default.lstatSync(yarnCacheFile).isDirectory()) {
- *  - return true otherwise
+        core.debug(`"${workDir}" has .yarn/cache - dependencies are kept in the repository`);
- */
+        return Promise.resolve(false);
-const projectHasYarnBerryManagedDependencies = (directory) => __awaiter(void 0, void 0, void 0, function* () {
+    }
-    const workDir = directory || process.env.GITHUB_WORKSPACE || '.';
+    // NOTE: yarn1 returns 'undefined' with return code = 0
-    core.debug(`check if "${workDir}" has locally managed yarn3 dependencies`);
+    const enableGlobalCache = yield exports.getCommandOutput('yarn config get enableGlobalCache', workDir);
-    // if .yarn/cache directory exists the cache is managed by version control system
+    // only local cache is not managed by yarn
-    const yarnCacheFile = path_1.default.join(workDir, '.yarn', 'cache');
+    const managed = enableGlobalCache.includes('false');
-    if (fs_1.default.existsSync(yarnCacheFile) &&
+    if (managed) {
-        fs_1.default.lstatSync(yarnCacheFile).isDirectory()) {
+        core.debug(`"${workDir}" dependencies are managed by yarn 3 locally`);
-        core.debug(`"${workDir}" has .yarn/cache - dependencies are kept in the repository`);
+        return true;
-        return Promise.resolve(false);
+    }
-    }
+    else {
-    // NOTE: yarn1 returns 'undefined' with return code = 0
+        core.debug(`"${workDir}" dependencies are not managed by yarn 3 locally`);
-    const enableGlobalCache = yield exports.getCommandOutput('yarn config get enableGlobalCache', workDir);
+        return false;
-    // only local cache is not managed by yarn
+    }
-    const managed = enableGlobalCache.includes('false');
+});
-    if (managed) {
+/**
-        core.debug(`"${workDir}" dependencies are managed by yarn 3 locally`);
+ * A function to report the repo contains Yarn managed projects
-        return true;
+ * @param packageManagerInfo - used to make sure current package manager is yarn
-    }
+ * @param cacheDependencyPath - either a single string or multiline string with possible glob patterns
-    else {
+ *                              expected to be the result of `core.getInput('cache-dependency-path')`
-        core.debug(`"${workDir}" dependencies are not managed by yarn 3 locally`);
+ * @return - true if all project directories configured to be Yarn managed
-        return false;
+ */
-    }
+const repoHasYarnBerryManagedDependencies = (packageManagerInfo, cacheDependencyPath) => __awaiter(void 0, void 0, void 0, function* () {
-});
+    if (packageManagerInfo.name !== 'yarn')
-/**
+        return false;
- * A function to report the repo contains Yarn managed projects
+    const yarnDirs = cacheDependencyPath
- * @param packageManagerInfo - used to make sure current package manager is yarn
+        ? yield exports.getProjectDirectoriesFromCacheDependencyPath(cacheDependencyPath)
- * @param cacheDependencyPath - either a single string or multiline string with possible glob patterns
+        : [''];
- *                              expected to be the result of `core.getInput('cache-dependency-path')`
+    const isManagedList = yield Promise.all(yarnDirs.map(projectHasYarnBerryManagedDependencies));
- * @return - true if all project directories configured to be Yarn managed
+    return isManagedList.every(Boolean);
- */
+});
-const repoHasYarnBerryManagedDependencies = (packageManagerInfo, cacheDependencyPath) => __awaiter(void 0, void 0, void 0, function* () {
+exports.repoHasYarnBerryManagedDependencies = repoHasYarnBerryManagedDependencies;
-    if (packageManagerInfo.name !== 'yarn')
+function isGhes() {
-        return false;
+    const ghUrl = new URL(process.env['GITHUB_SERVER_URL'] || 'https://github.com');
-    const yarnDirs = cacheDependencyPath
+    return ghUrl.hostname.toUpperCase() !== 'GITHUB.COM';
-        ? yield getProjectDirectoriesFromCacheDependencyPath(cacheDependencyPath)
+}
-        : [''];
+exports.isGhes = isGhes;
-    const isManagedList = yield Promise.all(yarnDirs.map(projectHasYarnBerryManagedDependencies));
+function isCacheFeatureAvailable() {
-    return isManagedList.every(Boolean);
+    if (cache.isFeatureAvailable())
-});
+        return true;
-exports.repoHasYarnBerryManagedDependencies = repoHasYarnBerryManagedDependencies;
+    if (isGhes()) {
-function isGhes() {
+        core.warning('Cache action is only supported on GHES version >= 3.5. If you are on version >=3.5 Please check with GHES admin if Actions cache service is enabled or not.');
-    const ghUrl = new URL(process.env['GITHUB_SERVER_URL'] || 'https://github.com');
+        return false;
-    return ghUrl.hostname.toUpperCase() !== 'GITHUB.COM';
+    }
-}
+    core.warning('The runner was not able to contact the cache service. Caching will be skipped');
-exports.isGhes = isGhes;
+    return false;
-function isCacheFeatureAvailable() {
+}
-    if (cache.isFeatureAvailable())
+exports.isCacheFeatureAvailable = isCacheFeatureAvailable;
-        return true;
-    if (isGhes()) {
-        core.warning('Cache action is only supported on GHES version >= 3.5. If you are on version >=3.5 Please check with GHES admin if Actions cache service is enabled or not.');
-        return false;
-    }
-    core.warning('The runner was not able to contact the cache service. Caching will be skipped');
-    return false;
-}
-exports.isCacheFeatureAvailable = isCacheFeatureAvailable;
 
 
 /***/ }),
@@ -60681,25 +61350,26 @@ exports.isCacheFeatureAvailable = isCacheFeatureAvailable;
 /***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
-
+
-Object.defineProperty(exports, "__esModule", ({ value: true }));
+Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.Outputs = exports.State = exports.LockType = void 0;
+exports.Outputs = exports.State = exports.LockType = void 0;
-var LockType;
+var LockType;
-(function (LockType) {
+(function (LockType) {
-    LockType["Npm"] = "npm";
+    LockType["Npm"] = "npm";
-    LockType["Pnpm"] = "pnpm";
+    LockType["Pnpm"] = "pnpm";
-    LockType["Yarn"] = "yarn";
+    LockType["Yarn"] = "yarn";
-})(LockType = exports.LockType || (exports.LockType = {}));
+})(LockType = exports.LockType || (exports.LockType = {}));
-var State;
+var State;
-(function (State) {
+(function (State) {
-    State["CachePrimaryKey"] = "CACHE_KEY";
+    State["CachePackageManager"] = "SETUP_NODE_CACHE_PACKAGE_MANAGER";
-    State["CacheMatchedKey"] = "CACHE_RESULT";
+    State["CachePrimaryKey"] = "CACHE_KEY";
-    State["CachePaths"] = "CACHE_PATHS";
+    State["CacheMatchedKey"] = "CACHE_RESULT";
-})(State = exports.State || (exports.State = {}));
+    State["CachePaths"] = "CACHE_PATHS";
-var Outputs;
+})(State = exports.State || (exports.State = {}));
-(function (Outputs) {
+var Outputs;
-    Outputs["CacheHit"] = "cache-hit";
+(function (Outputs) {
-})(Outputs = exports.Outputs || (exports.Outputs = {}));
+    Outputs["CacheHit"] = "cache-hit";
+})(Outputs = exports.Outputs || (exports.Outputs = {}));
 
 
 /***/ }),
@@ -60708,108 +61378,108 @@ var Outputs;
 /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
-
+
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
+    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
+}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
+    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
+    o[k2] = m[k];
-}));
+}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
+}) : function(o, v) {
-    o["default"] = v;
+    o["default"] = v;
-});
+});
-var __importStar = (this && this.__importStar) || function (mod) {
+var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
+    if (mod && mod.__esModule) return mod;
-    var result = {};
+    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
+    __setModuleDefault(result, mod);
-    return result;
+    return result;
-};
+};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
+    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+    });
-};
+};
-Object.defineProperty(exports, "__esModule", ({ value: true }));
+Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.unique = exports.printEnvDetailsAndSetOutput = exports.parseNodeVersionFile = void 0;
+exports.unique = exports.printEnvDetailsAndSetOutput = exports.parseNodeVersionFile = void 0;
-const core = __importStar(__nccwpck_require__(2186));
+const core = __importStar(__nccwpck_require__(2186));
-const exec = __importStar(__nccwpck_require__(1514));
+const exec = __importStar(__nccwpck_require__(1514));
-function parseNodeVersionFile(contents) {
+function parseNodeVersionFile(contents) {
-    var _a, _b, _c;
+    var _a, _b, _c;
-    let nodeVersion;
+    let nodeVersion;
-    // Try parsing the file as an NPM `package.json` file.
+    // Try parsing the file as an NPM `package.json` file.
-    try {
+    try {
-        nodeVersion = (_a = JSON.parse(contents).volta) === null || _a === void 0 ? void 0 : _a.node;
+        nodeVersion = (_a = JSON.parse(contents).volta) === null || _a === void 0 ? void 0 : _a.node;
-        if (!nodeVersion)
+        if (!nodeVersion)
-            nodeVersion = (_b = JSON.parse(contents).engines) === null || _b === void 0 ? void 0 : _b.node;
+            nodeVersion = (_b = JSON.parse(contents).engines) === null || _b === void 0 ? void 0 : _b.node;
-    }
+    }
-    catch (_d) {
+    catch (_d) {
-        core.info('Node version file is not JSON file');
+        core.info('Node version file is not JSON file');
-    }
+    }
-    if (!nodeVersion) {
+    if (!nodeVersion) {
-        const found = contents.match(/^(?:node(js)?\s+)?v?(?<version>[^\s]+)$/m);
+        const found = contents.match(/^(?:node(js)?\s+)?v?(?<version>[^\s]+)$/m);
-        nodeVersion = (_c = found === null || found === void 0 ? void 0 : found.groups) === null || _c === void 0 ? void 0 : _c.version;
+        nodeVersion = (_c = found === null || found === void 0 ? void 0 : found.groups) === null || _c === void 0 ? void 0 : _c.version;
-    }
+    }
-    // In the case of an unknown format,
+    // In the case of an unknown format,
-    // return as is and evaluate the version separately.
+    // return as is and evaluate the version separately.
-    if (!nodeVersion)
+    if (!nodeVersion)
-        nodeVersion = contents.trim();
+        nodeVersion = contents.trim();
-    return nodeVersion;
+    return nodeVersion;
-}
+}
-exports.parseNodeVersionFile = parseNodeVersionFile;
+exports.parseNodeVersionFile = parseNodeVersionFile;
-function printEnvDetailsAndSetOutput() {
+function printEnvDetailsAndSetOutput() {
-    return __awaiter(this, void 0, void 0, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
-        core.startGroup('Environment details');
+        core.startGroup('Environment details');
-        const promises = ['node', 'npm', 'yarn'].map((tool) => __awaiter(this, void 0, void 0, function* () {
+        const promises = ['node', 'npm', 'yarn'].map((tool) => __awaiter(this, void 0, void 0, function* () {
-            const output = yield getToolVersion(tool, ['--version']);
+            const output = yield getToolVersion(tool, ['--version']);
-            return { tool, output };
+            return { tool, output };
-        }));
+        }));
-        const tools = yield Promise.all(promises);
+        const tools = yield Promise.all(promises);
-        tools.forEach(({ tool, output }) => {
+        tools.forEach(({ tool, output }) => {
-            if (tool === 'node') {
+            if (tool === 'node') {
-                core.setOutput(`${tool}-version`, output);
+                core.setOutput(`${tool}-version`, output);
-            }
+            }
-            core.info(`${tool}: ${output}`);
+            core.info(`${tool}: ${output}`);
-        });
+        });
-        core.endGroup();
+        core.endGroup();
-    });
+    });
-}
+}
-exports.printEnvDetailsAndSetOutput = printEnvDetailsAndSetOutput;
+exports.printEnvDetailsAndSetOutput = printEnvDetailsAndSetOutput;
-function getToolVersion(tool, options) {
+function getToolVersion(tool, options) {
-    return __awaiter(this, void 0, void 0, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
-        try {
+        try {
-            const { stdout, stderr, exitCode } = yield exec.getExecOutput(tool, options, {
+            const { stdout, stderr, exitCode } = yield exec.getExecOutput(tool, options, {
-                ignoreReturnCode: true,
+                ignoreReturnCode: true,
-                silent: true
+                silent: true
-            });
+            });
-            if (exitCode > 0) {
+            if (exitCode > 0) {
-                core.info(`[warning]${stderr}`);
+                core.info(`[warning]${stderr}`);
-                return '';
+                return '';
-            }
+            }
-            return stdout.trim();
+            return stdout.trim();
-        }
+        }
-        catch (err) {
+        catch (err) {
-            return '';
+            return '';
-        }
+        }
-    });
+    });
-}
+}
-const unique = () => {
+const unique = () => {
-    const encountered = new Set();
+    const encountered = new Set();
-    return (value) => {
+    return (value) => {
-        if (encountered.has(value))
+        if (encountered.has(value))
-            return false;
+            return false;
-        encountered.add(value);
+        encountered.add(value);
-        return true;
+        return true;
-    };
+    };
-};
+};
-exports.unique = unique;
+exports.unique = unique;
 
 
 /***/ }),

package-lock.json

@@ -17,14 +17,14 @@
         "@actions/http-client": "^1.0.11",
         "@actions/io": "^1.0.2",
         "@actions/tool-cache": "^1.5.4",
-        "semver": "^6.3.1",
+        "lodash.memoize": "^4.1.2",
-        "uuid": "^9.0.0"
+        "semver": "^6.3.1"
       },
       "devDependencies": {
         "@types/jest": "^27.0.2",
+        "@types/lodash.memoize": "^4.1.7",
         "@types/node": "^16.11.25",
         "@types/semver": "^6.0.0",
-        "@types/uuid": "^9.0.3",
         "@typescript-eslint/eslint-plugin": "^5.54.0",
         "@typescript-eslint/parser": "^5.54.0",
         "@vercel/ncc": "^0.33.4",
@@ -160,15 +160,6 @@
         "uuid": "^3.3.2"
       }
     },
-    "node_modules/@actions/tool-cache/node_modules/uuid": {
-      "version": "3.4.0",
-      "resolved": "https://registry.npmjs.org/uuid/-/uuid-3.4.0.tgz",
-      "integrity": "sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A==",
-      "deprecated": "Please upgrade  to version 7 or higher.  Older versions may use Math.random() in certain circumstances, which is known to be problematic.  See https://v8.dev/blog/math-random for details.",
-      "bin": {
-        "uuid": "bin/uuid"
-      }
-    },
     "node_modules/@azure/abort-controller": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/@azure/abort-controller/-/abort-controller-1.1.0.tgz",
@@ -1659,6 +1650,21 @@
       "integrity": "sha512-wOuvG1SN4Us4rez+tylwwwCV1psiNVOkJeM3AUWUNWg/jDQY2+HE/444y5gc+jBmRqASOm2Oeh5c1axHobwRKQ==",
       "dev": true
     },
+    "node_modules/@types/lodash": {
+      "version": "4.14.197",
+      "resolved": "https://registry.npmjs.org/@types/lodash/-/lodash-4.14.197.tgz",
+      "integrity": "sha512-BMVOiWs0uNxHVlHBgzTIqJYmj+PgCo4euloGF+5m4okL3rEYzM2EEv78mw8zWSMM57dM7kVIgJ2QDvwHSoCI5g==",
+      "dev": true
+    },
+    "node_modules/@types/lodash.memoize": {
+      "version": "4.1.7",
+      "resolved": "https://registry.npmjs.org/@types/lodash.memoize/-/lodash.memoize-4.1.7.tgz",
+      "integrity": "sha512-lGN7WeO4vO6sICVpf041Q7BX/9k1Y24Zo3FY0aUezr1QlKznpjzsDk3T3wvH8ofYzoK0QupN9TWcFAFZlyPwQQ==",
+      "dev": true,
+      "dependencies": {
+        "@types/lodash": "*"
+      }
+    },
     "node_modules/@types/node": {
       "version": "16.11.25",
       "resolved": "https://registry.npmjs.org/@types/node/-/node-16.11.25.tgz",
@@ -1699,12 +1705,6 @@
         "@types/node": "*"
       }
     },
-    "node_modules/@types/uuid": {
-      "version": "9.0.3",
-      "resolved": "https://registry.npmjs.org/@types/uuid/-/uuid-9.0.3.tgz",
-      "integrity": "sha512-taHQQH/3ZyI3zP8M/puluDEIEvtQHVYcC6y3N8ijFtAd28+Ey/G4sg1u2gB01S8MwybLOKAp9/yCMu/uR5l3Ug==",
-      "dev": true
-    },
     "node_modules/@types/yargs": {
       "version": "16.0.4",
       "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-16.0.4.tgz",
@@ -4989,6 +4989,11 @@
       "resolved": "https://registry.npmjs.org/lodash.get/-/lodash.get-4.4.2.tgz",
       "integrity": "sha1-LRd/ZS+jHpObRDjVNBSZ36OCXpk="
     },
+    "node_modules/lodash.memoize": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/lodash.memoize/-/lodash.memoize-4.1.2.tgz",
+      "integrity": "sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag=="
+    },
     "node_modules/lodash.merge": {
       "version": "4.6.2",
       "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
@@ -6186,11 +6191,12 @@
       }
     },
     "node_modules/uuid": {
-      "version": "9.0.0",
+      "version": "3.3.2",
-      "resolved": "https://registry.npmjs.org/uuid/-/uuid-9.0.0.tgz",
+      "resolved": "https://registry.npmjs.org/uuid/-/uuid-3.3.2.tgz",
-      "integrity": "sha512-MXcSTerfPa4uqyzStbRoTgt5XIe3x5+42+q1sDuy3R5MDk66URdLMOZe5aPX/SQd+kuYAh0FdP/pO28IkQyTeg==",
+      "integrity": "sha512-yXJmeNaw3DnnKAOKJE51sL/ZaYfWJRl1pK9dr19YFCu0ObS231AB1/LbqTKRAQ5kw8A90rA6fr4riOUpTZvQZA==",
+      "deprecated": "Please upgrade  to version 7 or higher.  Older versions may use Math.random() in certain circumstances, which is known to be problematic.  See https://v8.dev/blog/math-random for details.",
       "bin": {
-        "uuid": "dist/bin/uuid"
+        "uuid": "bin/uuid"
       }
     },
     "node_modules/v8-to-istanbul": {
@@ -6307,9 +6313,9 @@
       }
     },
     "node_modules/word-wrap": {
-      "version": "1.2.3",
+      "version": "1.2.4",
-      "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.3.tgz",
+      "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.4.tgz",
-      "integrity": "sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==",
+      "integrity": "sha512-2V81OA4ugVo5pRo46hAoD2ivUJx8jXmWXfUkY4KFNw0hEptvN0QfH3K4nHiwzGeKl5rFKedV48QVoqYavy4YpA==",
       "dev": true,
       "engines": {
         "node": ">=0.10.0"
@@ -6573,13 +6579,6 @@
         "@actions/io": "^1.0.1",
         "semver": "^6.1.0",
         "uuid": "^3.3.2"
-      },
-      "dependencies": {
-        "uuid": {
-          "version": "3.4.0",
-          "resolved": "https://registry.npmjs.org/uuid/-/uuid-3.4.0.tgz",
-          "integrity": "sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A=="
-        }
       }
     },
     "@azure/abort-controller": {
@@ -7803,6 +7802,21 @@
       "integrity": "sha512-wOuvG1SN4Us4rez+tylwwwCV1psiNVOkJeM3AUWUNWg/jDQY2+HE/444y5gc+jBmRqASOm2Oeh5c1axHobwRKQ==",
       "dev": true
     },
+    "@types/lodash": {
+      "version": "4.14.197",
+      "resolved": "https://registry.npmjs.org/@types/lodash/-/lodash-4.14.197.tgz",
+      "integrity": "sha512-BMVOiWs0uNxHVlHBgzTIqJYmj+PgCo4euloGF+5m4okL3rEYzM2EEv78mw8zWSMM57dM7kVIgJ2QDvwHSoCI5g==",
+      "dev": true
+    },
+    "@types/lodash.memoize": {
+      "version": "4.1.7",
+      "resolved": "https://registry.npmjs.org/@types/lodash.memoize/-/lodash.memoize-4.1.7.tgz",
+      "integrity": "sha512-lGN7WeO4vO6sICVpf041Q7BX/9k1Y24Zo3FY0aUezr1QlKznpjzsDk3T3wvH8ofYzoK0QupN9TWcFAFZlyPwQQ==",
+      "dev": true,
+      "requires": {
+        "@types/lodash": "*"
+      }
+    },
     "@types/node": {
       "version": "16.11.25",
       "resolved": "https://registry.npmjs.org/@types/node/-/node-16.11.25.tgz",
@@ -7843,12 +7857,6 @@
         "@types/node": "*"
       }
     },
-    "@types/uuid": {
-      "version": "9.0.3",
-      "resolved": "https://registry.npmjs.org/@types/uuid/-/uuid-9.0.3.tgz",
-      "integrity": "sha512-taHQQH/3ZyI3zP8M/puluDEIEvtQHVYcC6y3N8ijFtAd28+Ey/G4sg1u2gB01S8MwybLOKAp9/yCMu/uR5l3Ug==",
-      "dev": true
-    },
     "@types/yargs": {
       "version": "16.0.4",
       "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-16.0.4.tgz",
@@ -10273,6 +10281,11 @@
       "resolved": "https://registry.npmjs.org/lodash.get/-/lodash.get-4.4.2.tgz",
       "integrity": "sha1-LRd/ZS+jHpObRDjVNBSZ36OCXpk="
     },
+    "lodash.memoize": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/lodash.memoize/-/lodash.memoize-4.1.2.tgz",
+      "integrity": "sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag=="
+    },
     "lodash.merge": {
       "version": "4.6.2",
       "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
@@ -11143,9 +11156,9 @@
       }
     },
     "uuid": {
-      "version": "9.0.0",
+      "version": "3.3.2",
-      "resolved": "https://registry.npmjs.org/uuid/-/uuid-9.0.0.tgz",
+      "resolved": "https://registry.npmjs.org/uuid/-/uuid-3.3.2.tgz",
-      "integrity": "sha512-MXcSTerfPa4uqyzStbRoTgt5XIe3x5+42+q1sDuy3R5MDk66URdLMOZe5aPX/SQd+kuYAh0FdP/pO28IkQyTeg=="
+      "integrity": "sha512-yXJmeNaw3DnnKAOKJE51sL/ZaYfWJRl1pK9dr19YFCu0ObS231AB1/LbqTKRAQ5kw8A90rA6fr4riOUpTZvQZA=="
     },
     "v8-to-istanbul": {
       "version": "8.1.0",
@@ -11242,9 +11255,9 @@
       }
     },
     "word-wrap": {
-      "version": "1.2.3",
+      "version": "1.2.4",
-      "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.3.tgz",
+      "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.4.tgz",
-      "integrity": "sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==",
+      "integrity": "sha512-2V81OA4ugVo5pRo46hAoD2ivUJx8jXmWXfUkY4KFNw0hEptvN0QfH3K4nHiwzGeKl5rFKedV48QVoqYavy4YpA==",
       "dev": true
     },
     "wrap-ansi": {

package.json

@@ -33,14 +33,14 @@
     "@actions/http-client": "^1.0.11",
     "@actions/io": "^1.0.2",
     "@actions/tool-cache": "^1.5.4",
-    "semver": "^6.3.1",
+    "lodash.memoize": "^4.1.2",
-    "uuid": "^9.0.0"
+    "semver": "^6.3.1"
   },
   "devDependencies": {
     "@types/jest": "^27.0.2",
+    "@types/lodash.memoize": "^4.1.7",
     "@types/node": "^16.11.25",
     "@types/semver": "^6.0.0",
-    "@types/uuid": "^9.0.3",
     "@typescript-eslint/eslint-plugin": "^5.54.0",
     "@typescript-eslint/parser": "^5.54.0",
     "@vercel/ncc": "^0.33.4",

src/cache-save.ts

@@ -1,8 +1,6 @@
 import * as core from '@actions/core';
 import * as cache from '@actions/cache';
 
-import fs from 'fs';
-
 import {State} from './constants';
 import {getPackageManagerInfo} from './cache-utils';
 
@@ -16,7 +14,7 @@ process.on('uncaughtException', e => {
 
 export async function run() {
   try {
-    const cacheLock = core.getInput('cache');
+    const cacheLock = core.getState(State.CachePackageManager);
     await cachePackages(cacheLock);
   } catch (error) {
     core.setFailed(error.message);
@@ -26,10 +24,9 @@ export async function run() {
 const cachePackages = async (packageManager: string) => {
   const state = core.getState(State.CacheMatchedKey);
   const primaryKey = core.getState(State.CachePrimaryKey);
-  let cachePaths = JSON.parse(
+  const cachePaths = JSON.parse(
     core.getState(State.CachePaths) || '[]'
   ) as string[];
-  cachePaths = cachePaths.filter(fs.existsSync);
 
   const packageManagerInfo = await getPackageManagerInfo(packageManager);
   if (!packageManagerInfo) {

src/cache-utils.ts

@@ -2,6 +2,7 @@ import * as core from '@actions/core';
 import * as exec from '@actions/exec';
 import * as cache from '@actions/cache';
 import * as glob from '@actions/glob';
+import memoize from 'lodash.memoize';
 import path from 'path';
 import fs from 'fs';
 import {unique} from './util';
@@ -111,50 +112,38 @@ export const getPackageManagerInfo = async (packageManager: string) => {
 };
 
 /**
+ * Expands (converts) the string input `cache-dependency-path` to list of directories that
+ * may be project roots
+ *
  * getProjectDirectoriesFromCacheDependencyPath is called twice during `restoreCache`
  *  - first through `getCacheDirectories`
  *  - second from `repoHasYarn3ManagedCache`
  *
- *  it contains expensive IO operation and thus should be memoized
+ * it contains expensive IO operation and thus should be memoized
- */
+ *
-
-let projectDirectoriesMemoized: string[] | null = null;
-/**
- * unit test must reset memoized variables
- */
-export const resetProjectDirectoriesMemoized = () =>
-  (projectDirectoriesMemoized = null);
-/**
- * Expands (converts) the string input `cache-dependency-path` to list of directories that
- * may be project roots
  * @param cacheDependencyPath - either a single string or multiline string with possible glob patterns
  *                              expected to be the result of `core.getInput('cache-dependency-path')`
- * @return list of directories and possible
+ * @return list of directories
  */
-const getProjectDirectoriesFromCacheDependencyPath = async (
+export const getProjectDirectoriesFromCacheDependencyPath = memoize(
-  cacheDependencyPath: string
+  async (cacheDependencyPath: string): Promise<string[]> => {
-): Promise<string[]> => {
+    const globber = await glob.create(cacheDependencyPath);
-  if (projectDirectoriesMemoized !== null) {
+    const cacheDependenciesPaths = await globber.glob();
-    return projectDirectoriesMemoized;
+
+    const existingDirectories: string[] = cacheDependenciesPaths
+      .map(path.dirname)
+      .filter(unique())
+      .map(dirName => fs.realpathSync(dirName))
+      .filter(directory => fs.lstatSync(directory).isDirectory());
+
+    if (!existingDirectories.length)
+      core.warning(
+        `No existing directories found containing cache-dependency-path="${cacheDependencyPath}"`
+      );
+
+    return existingDirectories;
   }
-
+);
-  const globber = await glob.create(cacheDependencyPath);
-  const cacheDependenciesPaths = await globber.glob();
-
-  const existingDirectories: string[] = cacheDependenciesPaths
-    .map(path.dirname)
-    .filter(unique())
-    .map(dirName => fs.realpathSync(dirName))
-    .filter(directory => fs.lstatSync(directory).isDirectory());
-
-  if (!existingDirectories.length)
-    core.warning(
-      `No existing directories found containing cache-dependency-path="${cacheDependencyPath}"`
-    );
-
-  projectDirectoriesMemoized = existingDirectories;
-  return existingDirectories;
-};
 
 /**
  * Finds the cache directories configured for the repo if cache-dependency-path is not empty

src/constants.ts

@@ -5,6 +5,7 @@ export enum LockType {
 }
 
 export enum State {
+  CachePackageManager = 'SETUP_NODE_CACHE_PACKAGE_MANAGER',
   CachePrimaryKey = 'CACHE_KEY',
   CacheMatchedKey = 'CACHE_RESULT',
   CachePaths = 'CACHE_PATHS'

src/distributions/base-distribution.ts

@@ -1,4 +1,3 @@
-import {v4 as uuidv4} from 'uuid';
 import * as tc from '@actions/tool-cache';
 import * as hc from '@actions/http-client';
 import * as core from '@actions/core';
@@ -167,8 +166,9 @@ export default abstract class BaseDistribution {
     const initialUrl = this.getDistributionUrl();
     const osArch: string = this.translateArchToDistUrl(arch);
 
-    // Create temporary folder to download to
+    // Create temporary folder to download in to
-    const tempDownloadFolder = `temp_${uuidv4()}`;
+    const tempDownloadFolder: string =
+      'temp_' + Math.floor(Math.random() * 2000000000);
     const tempDirectory = process.env['RUNNER_TEMP'] || '';
     assert.ok(tempDirectory, 'Expected RUNNER_TEMP to be defined');
     const tempDir: string = path.join(tempDirectory, tempDownloadFolder);

src/main.ts

@@ -9,6 +9,7 @@ import {restoreCache} from './cache-restore';
 import {isCacheFeatureAvailable} from './cache-utils';
 import {getNodejsDistribution} from './distributions/installer-factory';
 import {parseNodeVersionFile, printEnvDetailsAndSetOutput} from './util';
+import {State} from './constants';
 
 export async function run() {
   try {
@@ -60,6 +61,7 @@ export async function run() {
     }
 
     if (cache && isCacheFeatureAvailable()) {
+      core.saveState(State.CachePackageManager, cache);
       const cacheDependencyPath = core.getInput('cache-dependency-path');
       await restoreCache(cache, cacheDependencyPath);
     }