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

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/87/clone_8741d656a737c57873a2cb137fc3c2a2

@@ -0,0 +1,24 @@
+c912f366fe0025ea74e0e76e58277147
+'use strict'
+
+module.exports = clone
+
+var getPrototypeOf = Object.getPrototypeOf || function (obj) {
+  return obj.__proto__
+}
+
+function clone (obj) {
+  if (obj === null || typeof obj !== 'object')
+    return obj
+
+  if (obj instanceof Object)
+    var copy = { __proto__: getPrototypeOf(obj) }
+  else
+    var copy = Object.create(null)
+
+  Object.getOwnPropertyNames(obj).forEach(function (key) {
+    Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key))
+  })
+
+  return copy
+}

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/87/version_870188990057b0e5b35d6d9bd63f0eb6

@@ -0,0 +1,48 @@
+266cc320868c85e5ccd008f0c56b51c5
+/*:nodoc:*
+ * class ActionVersion
+ *
+ * Support action for printing program version
+ * This class inherited from [[Action]]
+ **/
+'use strict';
+
+var util = require('util');
+
+var Action = require('../action');
+
+//
+// Constants
+//
+var c = require('../const');
+
+/*:nodoc:*
+ * new ActionVersion(options)
+ * - options (object): options hash see [[Action.new]]
+ *
+ **/
+var ActionVersion = module.exports = function ActionVersion(options) {
+  options = options || {};
+  options.defaultValue = (options.defaultValue ? options.defaultValue : c.SUPPRESS);
+  options.dest = (options.dest || c.SUPPRESS);
+  options.nargs = 0;
+  this.version = options.version;
+  Action.call(this, options);
+};
+util.inherits(ActionVersion, Action);
+
+/*:nodoc:*
+ * ActionVersion#call(parser, namespace, values, optionString) -> Void
+ * - parser (ArgumentParser): current parser
+ * - namespace (Namespace): namespace for output data
+ * - values (Array): parsed values
+ * - optionString (Array): input option string(not parsed)
+ *
+ * Print version and exit
+ **/
+ActionVersion.prototype.call = function (parser) {
+  var version = this.version || parser.version;
+  var formatter = parser._getFormatter();
+  formatter.addText(version);
+  parser.exit(0, formatter.formatHelp());
+};

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/89/true_89b39ea93e164e1bb913772edd7a31cb

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

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/8a/ProtectableMap_8a9fe29cb67257b4a7d9e2a2bdff47de

@@ -0,0 +1,91 @@
+675b6cf48fa59b78022271c2ff290e5b
+"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.ProtectableMap = void 0;
+const ProtectableMapView_1 = require("./ProtectableMapView");
+/**
+ * The ProtectableMap provides an easy way for an API to expose a `Map<K, V>` property
+ * while intercepting and validating any write operations that are performed by
+ * consumers of the API.
+ *
+ * @remarks
+ * The ProtectableMap itself is intended to be a private object that only its owner
+ * can access directly.  Any operations performed directly on the ProtectableMap will
+ * bypass the hooks and any validation they perform.  The public property that is exposed
+ * to API consumers should return {@link ProtectableMap.protectedView} instead.
+ *
+ * For example, suppose you want to share your `Map<string, number>` data structure,
+ * but you want to enforce that the key must always be an upper case string:
+ * You could use the onSet() hook to validate the keys and throw an exception
+ * if the key is not uppercase.
+ *
+ * @public
+ */
+class ProtectableMap {
+    constructor(parameters) {
+        this._protectedView = new ProtectableMapView_1.ProtectableMapView(this, parameters);
+    }
+    /**
+     * The owner of the protectable map should return this object via its public API.
+     */
+    get protectedView() {
+        return this._protectedView;
+    }
+    // ---------------------------------------------------------------------------
+    // lib.es2015.collections contract - write operations
+    /**
+     * Removes all entries from the map.
+     * This operation does NOT invoke the ProtectableMap onClear() hook.
+     */
+    clear() {
+        this._protectedView._clearUnprotected();
+    }
+    /**
+     * Removes the specified key from the map.
+     * This operation does NOT invoke the ProtectableMap onDelete() hook.
+     */
+    delete(key) {
+        return this._protectedView._deleteUnprotected(key);
+    }
+    /**
+     * Sets a value for the specified key.
+     * This operation does NOT invoke the ProtectableMap onSet() hook.
+     */
+    set(key, value) {
+        this._protectedView._setUnprotected(key, value);
+        return this;
+    }
+    // ---------------------------------------------------------------------------
+    // lib.es2015.collections contract - read operations
+    /**
+     * Performs an operation for each (key, value) entries in the map.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    forEach(callbackfn, thisArg) {
+        this._protectedView.forEach(callbackfn);
+    }
+    /**
+     * Retrieves the value for the specified key.
+     * @returns undefined if the value is undefined OR if the key is missing;
+     * otherwise returns the value associated with the key.
+     */
+    get(key) {
+        return this._protectedView.get(key);
+    }
+    /**
+     * Returns true if the specified key belongs to the map.
+     */
+    has(key) {
+        return this._protectedView.has(key);
+    }
+    /**
+     * Returns the number of (key, value) entries in the map.
+     */
+    get size() {
+        return this._protectedView.size;
+    }
+}
+exports.ProtectableMap = ProtectableMap;
+//# sourceMappingURL=ProtectableMap.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/8a/SyncWaterfallHook_8a739b54c97de3d2f978d3f281705b85

@@ -0,0 +1,58 @@
+bb1ace26baa22d9956395e12a3ce424f
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const Hook = require("./Hook");
+const HookCodeFactory = require("./HookCodeFactory");
+
+class SyncWaterfallHookCodeFactory extends HookCodeFactory {
+	content({ onError, onResult, resultReturns, rethrowIfPossible }) {
+		return this.callTapsSeries({
+			onError: (i, err) => onError(err),
+			onResult: (i, result, next) => {
+				let code = "";
+				code += `if(${result} !== undefined) {\n`;
+				code += `${this._args[0]} = ${result};\n`;
+				code += `}\n`;
+				code += next();
+				return code;
+			},
+			onDone: () => onResult(this._args[0]),
+			doneReturns: resultReturns,
+			rethrowIfPossible
+		});
+	}
+}
+
+const factory = new SyncWaterfallHookCodeFactory();
+
+const TAP_ASYNC = () => {
+	throw new Error("tapAsync is not supported on a SyncWaterfallHook");
+};
+
+const TAP_PROMISE = () => {
+	throw new Error("tapPromise is not supported on a SyncWaterfallHook");
+};
+
+const COMPILE = function(options) {
+	factory.setup(this, options);
+	return factory.create(options);
+};
+
+function SyncWaterfallHook(args = [], name = undefined) {
+	if (args.length < 1)
+		throw new Error("Waterfall hooks must have at least one argument");
+	const hook = new Hook(args, name);
+	hook.constructor = SyncWaterfallHook;
+	hook.tapAsync = TAP_ASYNC;
+	hook.tapPromise = TAP_PROMISE;
+	hook.compile = COMPILE;
+	return hook;
+}
+
+SyncWaterfallHook.prototype = null;
+
+module.exports = SyncWaterfallHook;

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/8c/FileWriter_8c34d45ee75dae06e4593e27ec9e6c99

@@ -0,0 +1,64 @@
+2bd3843a04954cbe1b80441bd5a869f5
+"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.FileWriter = void 0;
+const Import_1 = require("./Import");
+const fsx = Import_1.Import.lazy('fs-extra', require);
+/**
+ * API for interacting with file handles.
+ * @public
+ */
+class FileWriter {
+    constructor(fileDescriptor, filePath) {
+        this._fileDescriptor = fileDescriptor;
+        this.filePath = filePath;
+    }
+    /**
+     * Opens a new file handle to the file at the specified path and given mode.
+     * Behind the scenes it uses `fs.openSync()`.
+     * The behaviour of this function is platform specific.
+     * See: https://nodejs.org/docs/latest-v8.x/api/fs.html#fs_fs_open_path_flags_mode_callback
+     * @param filePath - The absolute or relative path to the file handle that should be opened.
+     * @param flags - The flags for opening the handle
+     */
+    static open(filePath, flags) {
+        return new FileWriter(fsx.openSync(filePath, FileWriter._convertFlagsForNode(flags)), filePath);
+    }
+    /**
+     * Helper function to convert the file writer array to a Node.js style string (e.g. "wx" or "a").
+     * @param flags - The flags that should be converted.
+     */
+    static _convertFlagsForNode(flags) {
+        flags = Object.assign({ append: false, exclusive: false }, flags);
+        return [flags.append ? 'a' : 'w', flags.exclusive ? 'x' : ''].join('');
+    }
+    /**
+     * Writes some text to the given file handle. Throws if the file handle has been closed.
+     * Behind the scenes it uses `fs.writeSync()`.
+     * @param text - The text to write to the file.
+     */
+    write(text) {
+        if (!this._fileDescriptor) {
+            throw new Error(`Cannot write to file, file descriptor has already been released.`);
+        }
+        fsx.writeSync(this._fileDescriptor, text);
+    }
+    /**
+     * Closes the file handle permanently. No operations can be made on this file handle after calling this.
+     * Behind the scenes it uses `fs.closeSync()` and releases the file descriptor to be re-used.
+     *
+     * @remarks
+     * The `close()` method can be called more than once; additional calls are ignored.
+     */
+    close() {
+        const fd = this._fileDescriptor;
+        if (fd) {
+            this._fileDescriptor = undefined;
+            fsx.closeSync(fd);
+        }
+    }
+}
+exports.FileWriter = FileWriter;
+//# sourceMappingURL=FileWriter.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/8c/colors_8c84db0002e69a4cfd1c0798f7f1c18a

@@ -0,0 +1,200 @@
+f0d451e3a2b40f9237471e116ff67589
+/*
+
+The MIT License (MIT)
+
+Original Library
+  - Copyright (c) Marak Squires
+
+Additional functionality
+ - Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+*/
+
+var colors = {};
+module['exports'] = colors;
+
+colors.themes = {};
+
+var util = require('util');
+var ansiStyles = colors.styles = require('./styles');
+var defineProps = Object.defineProperties;
+var newLineRegex = new RegExp(/[\r\n]+/g);
+
+colors.supportsColor = require('./system/supports-colors').supportsColor;
+
+if (typeof colors.enabled === 'undefined') {
+  colors.enabled = colors.supportsColor() !== false;
+}
+
+colors.enable = function() {
+  colors.enabled = true;
+};
+
+colors.disable = function() {
+  colors.enabled = false;
+};
+
+colors.stripColors = colors.strip = function(str) {
+  return ('' + str).replace(/\x1B\[\d+m/g, '');
+};
+
+// eslint-disable-next-line no-unused-vars
+var stylize = colors.stylize = function stylize(str, style) {
+  if (!colors.enabled) {
+    return str+'';
+  }
+
+  return ansiStyles[style].open + str + ansiStyles[style].close;
+};
+
+var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
+var escapeStringRegexp = function(str) {
+  if (typeof str !== 'string') {
+    throw new TypeError('Expected a string');
+  }
+  return str.replace(matchOperatorsRe, '\\$&');
+};
+
+function build(_styles) {
+  var builder = function builder() {
+    return applyStyle.apply(builder, arguments);
+  };
+  builder._styles = _styles;
+  // __proto__ is used because we must return a function, but there is
+  // no way to create a function with a different prototype.
+  builder.__proto__ = proto;
+  return builder;
+}
+
+var styles = (function() {
+  var ret = {};
+  ansiStyles.grey = ansiStyles.gray;
+  Object.keys(ansiStyles).forEach(function(key) {
+    ansiStyles[key].closeRe =
+      new RegExp(escapeStringRegexp(ansiStyles[key].close), 'g');
+    ret[key] = {
+      get: function() {
+        return build(this._styles.concat(key));
+      },
+    };
+  });
+  return ret;
+})();
+
+var proto = defineProps(function colors() {}, styles);
+
+function applyStyle() {
+  var args = Array.prototype.slice.call(arguments);
+
+  var str = args.map(function(arg) {
+    if (arg !== undefined && arg.constructor === String) {
+      return arg;
+    } else {
+      return util.inspect(arg);
+    }
+  }).join(' ');
+
+  if (!colors.enabled || !str) {
+    return str;
+  }
+
+  var newLinesPresent = str.indexOf('\n') != -1;
+
+  var nestedStyles = this._styles;
+
+  var i = nestedStyles.length;
+  while (i--) {
+    var code = ansiStyles[nestedStyles[i]];
+    str = code.open + str.replace(code.closeRe, code.open) + code.close;
+    if (newLinesPresent) {
+      str = str.replace(newLineRegex, code.close + '\n' + code.open);
+    }
+  }
+
+  return str;
+}
+
+colors.setTheme = function(theme) {
+  if (typeof theme === 'string') {
+    console.log('colors.setTheme now only accepts an object, not a string.  ' +
+      'If you are trying to set a theme from a file, it is now your (the ' +
+      'caller\'s) responsibility to require the file.  The old syntax ' +
+      'looked like colors.setTheme(__dirname + ' +
+      '\'/../themes/generic-logging.js\'); The new syntax looks like '+
+      'colors.setTheme(require(__dirname + ' +
+      '\'/../themes/generic-logging.js\'));');
+    return;
+  }
+  for (var style in theme) {
+    (function(style) {
+      colors[style] = function(str) {
+        if (typeof theme[style] === 'object') {
+          var out = str;
+          for (var i in theme[style]) {
+            out = colors[theme[style][i]](out);
+          }
+          return out;
+        }
+        return colors[theme[style]](str);
+      };
+    })(style);
+  }
+};
+
+function init() {
+  var ret = {};
+  Object.keys(styles).forEach(function(name) {
+    ret[name] = {
+      get: function() {
+        return build([name]);
+      },
+    };
+  });
+  return ret;
+}
+
+var sequencer = function sequencer(map, str) {
+  var exploded = str.split('');
+  exploded = exploded.map(map);
+  return exploded.join('');
+};
+
+// custom formatter methods
+colors.trap = require('./custom/trap');
+colors.zalgo = require('./custom/zalgo');
+
+// maps
+colors.maps = {};
+colors.maps.america = require('./maps/america');
+colors.maps.zebra = require('./maps/zebra');
+colors.maps.rainbow = require('./maps/rainbow');
+colors.maps.random = require('./maps/random');
+
+for (var map in colors.maps) {
+  (function(map) {
+    colors[map] = function(str) {
+      return sequencer(colors.maps[map], str);
+    };
+  })(map);
+}
+
+defineProps(colors, init());

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/8c/index_8ceede9e1085ff23f8671d696ecd7bdb

@@ -0,0 +1,46 @@
+6651fa67e2dd28e2aecaa055067b1e19
+"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.CommandLineHelper = exports.DynamicCommandLineParser = exports.CommandLineParser = exports.CommandLineParameterProvider = exports.CommandLineRemainder = exports.CommandLineChoiceListParameter = exports.CommandLineChoiceParameter = exports.CommandLineIntegerListParameter = exports.CommandLineIntegerParameter = exports.CommandLineStringListParameter = exports.CommandLineStringParameter = exports.CommandLineFlagParameter = exports.CommandLineParameterWithArgument = exports.CommandLineParameter = exports.CommandLineParameterKind = exports.ScopedCommandLineAction = exports.DynamicCommandLineAction = exports.CommandLineAction = void 0;
+/**
+ * An object-oriented command-line parser for TypeScript projects.
+ *
+ * @packageDocumentation
+ */
+var CommandLineAction_1 = require("./providers/CommandLineAction");
+Object.defineProperty(exports, "CommandLineAction", { enumerable: true, get: function () { return CommandLineAction_1.CommandLineAction; } });
+var DynamicCommandLineAction_1 = require("./providers/DynamicCommandLineAction");
+Object.defineProperty(exports, "DynamicCommandLineAction", { enumerable: true, get: function () { return DynamicCommandLineAction_1.DynamicCommandLineAction; } });
+var ScopedCommandLineAction_1 = require("./providers/ScopedCommandLineAction");
+Object.defineProperty(exports, "ScopedCommandLineAction", { enumerable: true, get: function () { return ScopedCommandLineAction_1.ScopedCommandLineAction; } });
+var BaseClasses_1 = require("./parameters/BaseClasses");
+Object.defineProperty(exports, "CommandLineParameterKind", { enumerable: true, get: function () { return BaseClasses_1.CommandLineParameterKind; } });
+Object.defineProperty(exports, "CommandLineParameter", { enumerable: true, get: function () { return BaseClasses_1.CommandLineParameter; } });
+Object.defineProperty(exports, "CommandLineParameterWithArgument", { enumerable: true, get: function () { return BaseClasses_1.CommandLineParameterWithArgument; } });
+var CommandLineFlagParameter_1 = require("./parameters/CommandLineFlagParameter");
+Object.defineProperty(exports, "CommandLineFlagParameter", { enumerable: true, get: function () { return CommandLineFlagParameter_1.CommandLineFlagParameter; } });
+var CommandLineStringParameter_1 = require("./parameters/CommandLineStringParameter");
+Object.defineProperty(exports, "CommandLineStringParameter", { enumerable: true, get: function () { return CommandLineStringParameter_1.CommandLineStringParameter; } });
+var CommandLineStringListParameter_1 = require("./parameters/CommandLineStringListParameter");
+Object.defineProperty(exports, "CommandLineStringListParameter", { enumerable: true, get: function () { return CommandLineStringListParameter_1.CommandLineStringListParameter; } });
+var CommandLineIntegerParameter_1 = require("./parameters/CommandLineIntegerParameter");
+Object.defineProperty(exports, "CommandLineIntegerParameter", { enumerable: true, get: function () { return CommandLineIntegerParameter_1.CommandLineIntegerParameter; } });
+var CommandLineIntegerListParameter_1 = require("./parameters/CommandLineIntegerListParameter");
+Object.defineProperty(exports, "CommandLineIntegerListParameter", { enumerable: true, get: function () { return CommandLineIntegerListParameter_1.CommandLineIntegerListParameter; } });
+var CommandLineChoiceParameter_1 = require("./parameters/CommandLineChoiceParameter");
+Object.defineProperty(exports, "CommandLineChoiceParameter", { enumerable: true, get: function () { return CommandLineChoiceParameter_1.CommandLineChoiceParameter; } });
+var CommandLineChoiceListParameter_1 = require("./parameters/CommandLineChoiceListParameter");
+Object.defineProperty(exports, "CommandLineChoiceListParameter", { enumerable: true, get: function () { return CommandLineChoiceListParameter_1.CommandLineChoiceListParameter; } });
+var CommandLineRemainder_1 = require("./parameters/CommandLineRemainder");
+Object.defineProperty(exports, "CommandLineRemainder", { enumerable: true, get: function () { return CommandLineRemainder_1.CommandLineRemainder; } });
+var CommandLineParameterProvider_1 = require("./providers/CommandLineParameterProvider");
+Object.defineProperty(exports, "CommandLineParameterProvider", { enumerable: true, get: function () { return CommandLineParameterProvider_1.CommandLineParameterProvider; } });
+var CommandLineParser_1 = require("./providers/CommandLineParser");
+Object.defineProperty(exports, "CommandLineParser", { enumerable: true, get: function () { return CommandLineParser_1.CommandLineParser; } });
+var DynamicCommandLineParser_1 = require("./providers/DynamicCommandLineParser");
+Object.defineProperty(exports, "DynamicCommandLineParser", { enumerable: true, get: function () { return DynamicCommandLineParser_1.DynamicCommandLineParser; } });
+var CommandLineHelper_1 = require("./CommandLineHelper");
+Object.defineProperty(exports, "CommandLineHelper", { enumerable: true, get: function () { return CommandLineHelper_1.CommandLineHelper; } });
+//# sourceMappingURL=index.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/8e/append_8e1ed839104f64988fca6d92799f11c8

@@ -0,0 +1,54 @@
+65faa0e421d708696f307bbdef47c0a3
+/*:nodoc:*
+ * class ActionAppend
+ *
+ * This action stores a list, and appends each argument value to the list.
+ * This is useful to allow an option to be specified multiple times.
+ * This class inherided from [[Action]]
+ *
+ **/
+
+'use strict';
+
+var util = require('util');
+
+var Action = require('../action');
+
+// Constants
+var c = require('../const');
+
+/*:nodoc:*
+ * new ActionAppend(options)
+ * - options (object): options hash see [[Action.new]]
+ *
+ * Note: options.nargs should be optional for constants
+ * and more then zero for other
+ **/
+var ActionAppend = module.exports = function ActionAppend(options) {
+  options = options || {};
+  if (this.nargs <= 0) {
+    throw new Error('nargs for append actions must be > 0; if arg ' +
+        'strings are not supplying the value to append, ' +
+        'the append const action may be more appropriate');
+  }
+  if (!!this.constant && this.nargs !== c.OPTIONAL) {
+    throw new Error('nargs must be OPTIONAL to supply const');
+  }
+  Action.call(this, options);
+};
+util.inherits(ActionAppend, Action);
+
+/*:nodoc:*
+ * ActionAppend#call(parser, namespace, values, optionString) -> Void
+ * - parser (ArgumentParser): current parser
+ * - namespace (Namespace): namespace for output data
+ * - values (Array): parsed values
+ * - optionString (Array): input option string(not parsed)
+ *
+ * Call the action. Save result in namespace object
+ **/
+ActionAppend.prototype.call = function (parser, namespace, values) {
+  var items = (namespace[this.dest] || []).slice();
+  items.push(values);
+  namespace.set(this.dest, items);
+};