claude-autopm 2.12.3 → 3.0.1

package/packages/plugin-cloud/node_modules/pure-rand/lib/pure-rand-default.js

@@ -0,0 +1,34 @@
+"use strict";
+exports.__esModule = true;
+exports.unsafeUniformIntDistribution = exports.unsafeUniformBigIntDistribution = exports.unsafeUniformArrayIntDistribution = exports.uniformIntDistribution = exports.uniformBigIntDistribution = exports.uniformArrayIntDistribution = exports.xoroshiro128plus = exports.xorshift128plus = exports.mersenne = exports.congruential32 = exports.unsafeSkipN = exports.unsafeGenerateN = exports.skipN = exports.generateN = exports.__commitHash = exports.__version = exports.__type = void 0;
+var RandomGenerator_1 = require("./generator/RandomGenerator");
+exports.generateN = RandomGenerator_1.generateN;
+exports.skipN = RandomGenerator_1.skipN;
+exports.unsafeGenerateN = RandomGenerator_1.unsafeGenerateN;
+exports.unsafeSkipN = RandomGenerator_1.unsafeSkipN;
+var LinearCongruential_1 = require("./generator/LinearCongruential");
+exports.congruential32 = LinearCongruential_1.congruential32;
+var MersenneTwister_1 = require("./generator/MersenneTwister");
+exports.mersenne = MersenneTwister_1["default"];
+var XorShift_1 = require("./generator/XorShift");
+exports.xorshift128plus = XorShift_1.xorshift128plus;
+var XoroShiro_1 = require("./generator/XoroShiro");
+exports.xoroshiro128plus = XoroShiro_1.xoroshiro128plus;
+var UniformArrayIntDistribution_1 = require("./distribution/UniformArrayIntDistribution");
+exports.uniformArrayIntDistribution = UniformArrayIntDistribution_1.uniformArrayIntDistribution;
+var UniformBigIntDistribution_1 = require("./distribution/UniformBigIntDistribution");
+exports.uniformBigIntDistribution = UniformBigIntDistribution_1.uniformBigIntDistribution;
+var UniformIntDistribution_1 = require("./distribution/UniformIntDistribution");
+exports.uniformIntDistribution = UniformIntDistribution_1.uniformIntDistribution;
+var UnsafeUniformArrayIntDistribution_1 = require("./distribution/UnsafeUniformArrayIntDistribution");
+exports.unsafeUniformArrayIntDistribution = UnsafeUniformArrayIntDistribution_1.unsafeUniformArrayIntDistribution;
+var UnsafeUniformBigIntDistribution_1 = require("./distribution/UnsafeUniformBigIntDistribution");
+exports.unsafeUniformBigIntDistribution = UnsafeUniformBigIntDistribution_1.unsafeUniformBigIntDistribution;
+var UnsafeUniformIntDistribution_1 = require("./distribution/UnsafeUniformIntDistribution");
+exports.unsafeUniformIntDistribution = UnsafeUniformIntDistribution_1.unsafeUniformIntDistribution;
+var __type = 'commonjs';
+exports.__type = __type;
+var __version = '6.1.0';
+exports.__version = __version;
+var __commitHash = 'a413dd2b721516be2ef29adffb515c5ae67bfbad';
+exports.__commitHash = __commitHash;

package/packages/plugin-cloud/node_modules/pure-rand/lib/pure-rand.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+exports.__esModule = true;
+var prand = require("./pure-rand-default");
+exports["default"] = prand;
+__exportStar(require("./pure-rand-default"), exports);

package/packages/plugin-cloud/node_modules/pure-rand/lib/types/distribution/Distribution.d.ts

@@ -0,0 +1,2 @@
+import { RandomGenerator } from '../generator/RandomGenerator.js';
+export type Distribution<T> = (rng: RandomGenerator) => [T, RandomGenerator];

package/packages/plugin-cloud/node_modules/pure-rand/lib/types/distribution/UniformArrayIntDistribution.d.ts

@@ -0,0 +1,6 @@
+import { Distribution } from './Distribution.js';
+import { RandomGenerator } from '../generator/RandomGenerator.js';
+import { ArrayInt } from './internals/ArrayInt.js';
+declare function uniformArrayIntDistribution(from: ArrayInt, to: ArrayInt): Distribution<ArrayInt>;
+declare function uniformArrayIntDistribution(from: ArrayInt, to: ArrayInt, rng: RandomGenerator): [ArrayInt, RandomGenerator];
+export { uniformArrayIntDistribution };

package/packages/plugin-cloud/node_modules/pure-rand/lib/types/distribution/UniformBigIntDistribution.d.ts

@@ -0,0 +1,5 @@
+import { Distribution } from './Distribution.js';
+import { RandomGenerator } from '../generator/RandomGenerator.js';
+declare function uniformBigIntDistribution(from: bigint, to: bigint): Distribution<bigint>;
+declare function uniformBigIntDistribution(from: bigint, to: bigint, rng: RandomGenerator): [bigint, RandomGenerator];
+export { uniformBigIntDistribution };

package/packages/plugin-cloud/node_modules/pure-rand/lib/types/distribution/UniformIntDistribution.d.ts

@@ -0,0 +1,5 @@
+import { Distribution } from './Distribution.js';
+import { RandomGenerator } from '../generator/RandomGenerator.js';
+declare function uniformIntDistribution(from: number, to: number): Distribution<number>;
+declare function uniformIntDistribution(from: number, to: number, rng: RandomGenerator): [number, RandomGenerator];
+export { uniformIntDistribution };

package/packages/plugin-cloud/node_modules/pure-rand/lib/types/distribution/UnsafeUniformArrayIntDistribution.d.ts

@@ -0,0 +1,3 @@
+import { RandomGenerator } from '../generator/RandomGenerator.js';
+import { ArrayInt } from './internals/ArrayInt.js';
+export declare function unsafeUniformArrayIntDistribution(from: ArrayInt, to: ArrayInt, rng: RandomGenerator): ArrayInt;

package/packages/plugin-cloud/node_modules/pure-rand/lib/types/distribution/UnsafeUniformBigIntDistribution.d.ts

@@ -0,0 +1,2 @@
+import { RandomGenerator } from '../generator/RandomGenerator.js';
+export declare function unsafeUniformBigIntDistribution(from: bigint, to: bigint, rng: RandomGenerator): bigint;

package/packages/plugin-cloud/node_modules/pure-rand/lib/types/distribution/UnsafeUniformIntDistribution.d.ts

@@ -0,0 +1,2 @@
+import { RandomGenerator } from '../generator/RandomGenerator.js';
+export declare function unsafeUniformIntDistribution(from: number, to: number, rng: RandomGenerator): number;

package/packages/plugin-cloud/node_modules/pure-rand/lib/types/distribution/internals/ArrayInt.d.ts

@@ -0,0 +1,13 @@
+export type ArrayInt = {
+    sign: -1 | 1;
+    data: number[];
+};
+export declare function addArrayIntToNew(arrayIntA: ArrayInt, arrayIntB: ArrayInt): ArrayInt;
+export declare function addOneToPositiveArrayInt(arrayInt: ArrayInt): ArrayInt;
+export declare function substractArrayIntToNew(arrayIntA: ArrayInt, arrayIntB: ArrayInt): ArrayInt;
+export declare function trimArrayIntInplace(arrayInt: ArrayInt): ArrayInt;
+export type ArrayInt64 = Required<ArrayInt> & {
+    data: [number, number];
+};
+export declare function fromNumberToArrayInt64(out: ArrayInt64, n: number): ArrayInt64;
+export declare function substractArrayInt64(out: ArrayInt64, arrayIntA: ArrayInt64, arrayIntB: ArrayInt64): ArrayInt64;

package/packages/plugin-cloud/node_modules/pure-rand/lib/types/distribution/internals/UnsafeUniformArrayIntDistributionInternal.d.ts

@@ -0,0 +1,3 @@
+import { RandomGenerator } from '../../generator/RandomGenerator.js';
+import { ArrayInt } from './ArrayInt.js';
+export declare function unsafeUniformArrayIntDistributionInternal(out: ArrayInt['data'], rangeSize: ArrayInt['data'], rng: RandomGenerator): ArrayInt['data'];

package/packages/plugin-cloud/node_modules/pure-rand/lib/types/distribution/internals/UnsafeUniformIntDistributionInternal.d.ts

@@ -0,0 +1,2 @@
+import { RandomGenerator } from '../../generator/RandomGenerator.js';
+export declare function unsafeUniformIntDistributionInternal(rangeSize: number, rng: RandomGenerator): number;

package/packages/plugin-cloud/node_modules/pure-rand/lib/types/generator/LinearCongruential.d.ts

@@ -0,0 +1,6 @@
+import { RandomGenerator } from './RandomGenerator.js';
+declare function fromState(state: readonly number[]): RandomGenerator;
+export declare const congruential32: ((seed: number) => RandomGenerator) & {
+    fromState: typeof fromState;
+};
+export {};

package/packages/plugin-cloud/node_modules/pure-rand/lib/types/generator/MersenneTwister.d.ts

@@ -0,0 +1,6 @@
+import { RandomGenerator } from './RandomGenerator.js';
+declare function fromState(state: readonly number[]): RandomGenerator;
+declare const _default: ((seed: number) => RandomGenerator) & {
+    fromState: typeof fromState;
+};
+export default _default;

package/packages/plugin-cloud/node_modules/pure-rand/lib/types/generator/RandomGenerator.d.ts

@@ -0,0 +1,12 @@
+export interface RandomGenerator {
+    clone(): RandomGenerator;
+    next(): [number, RandomGenerator];
+    jump?(): RandomGenerator;
+    unsafeNext(): number;
+    unsafeJump?(): void;
+    getState?(): readonly number[];
+}
+export declare function unsafeGenerateN(rng: RandomGenerator, num: number): number[];
+export declare function generateN(rng: RandomGenerator, num: number): [number[], RandomGenerator];
+export declare function unsafeSkipN(rng: RandomGenerator, num: number): void;
+export declare function skipN(rng: RandomGenerator, num: number): RandomGenerator;

package/packages/plugin-cloud/node_modules/pure-rand/lib/types/generator/XorShift.d.ts

@@ -0,0 +1,6 @@
+import { RandomGenerator } from './RandomGenerator.js';
+declare function fromState(state: readonly number[]): RandomGenerator;
+export declare const xorshift128plus: ((seed: number) => RandomGenerator) & {
+    fromState: typeof fromState;
+};
+export {};

package/packages/plugin-cloud/node_modules/pure-rand/lib/types/generator/XoroShiro.d.ts

@@ -0,0 +1,6 @@
+import { RandomGenerator } from './RandomGenerator.js';
+declare function fromState(state: readonly number[]): RandomGenerator;
+export declare const xoroshiro128plus: ((seed: number) => RandomGenerator) & {
+    fromState: typeof fromState;
+};
+export {};

package/packages/plugin-cloud/node_modules/pure-rand/lib/types/pure-rand-default.d.ts

@@ -0,0 +1,16 @@
+import { RandomGenerator, generateN, skipN, unsafeGenerateN, unsafeSkipN } from './generator/RandomGenerator.js';
+import { congruential32 } from './generator/LinearCongruential.js';
+import mersenne from './generator/MersenneTwister.js';
+import { xorshift128plus } from './generator/XorShift.js';
+import { xoroshiro128plus } from './generator/XoroShiro.js';
+import { Distribution } from './distribution/Distribution.js';
+import { uniformArrayIntDistribution } from './distribution/UniformArrayIntDistribution.js';
+import { uniformBigIntDistribution } from './distribution/UniformBigIntDistribution.js';
+import { uniformIntDistribution } from './distribution/UniformIntDistribution.js';
+import { unsafeUniformArrayIntDistribution } from './distribution/UnsafeUniformArrayIntDistribution.js';
+import { unsafeUniformBigIntDistribution } from './distribution/UnsafeUniformBigIntDistribution.js';
+import { unsafeUniformIntDistribution } from './distribution/UnsafeUniformIntDistribution.js';
+declare const __type: string;
+declare const __version: string;
+declare const __commitHash: string;
+export { __type, __version, __commitHash, RandomGenerator, generateN, skipN, unsafeGenerateN, unsafeSkipN, congruential32, mersenne, xorshift128plus, xoroshiro128plus, Distribution, uniformArrayIntDistribution, uniformBigIntDistribution, uniformIntDistribution, unsafeUniformArrayIntDistribution, unsafeUniformBigIntDistribution, unsafeUniformIntDistribution, };

package/packages/plugin-cloud/node_modules/pure-rand/lib/types/pure-rand.d.ts

@@ -0,0 +1,3 @@
+import * as prand from './pure-rand-default.js';
+export default prand;
+export * from './pure-rand-default.js';

package/packages/plugin-cloud/node_modules/pure-rand/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "pure-rand",
+  "version": "6.1.0",
+  "description": " Pure random number generator written in TypeScript",
+  "type": "commonjs",
+  "main": "lib/pure-rand.js",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "require": {
+        "types": "./lib/types/pure-rand.d.ts",
+        "default": "./lib/pure-rand.js"
+      },
+      "import": {
+        "types": "./lib/esm/types/pure-rand.d.ts",
+        "default": "./lib/esm/pure-rand.js"
+      }
+    }
+  },
+  "module": "lib/esm/pure-rand.js",
+  "types": "lib/types/pure-rand.d.ts",
+  "files": [
+    "lib"
+  ],
+  "sideEffects": false,
+  "packageManager": "yarn@4.1.1",
+  "scripts": {
+    "format:check": "prettier --list-different .",
+    "format": "prettier --write .",
+    "build": "tsc && tsc -p ./tsconfig.declaration.json",
+    "build:esm": "tsc --module es2015 --outDir lib/esm --moduleResolution node && tsc -p ./tsconfig.declaration.json --outDir lib/esm/types && cp package.esm-template.json lib/esm/package.json",
+    "build:prod": "yarn build && yarn build:esm && node postbuild/main.cjs",
+    "build:prod-ci": "cross-env EXPECT_GITHUB_SHA=true yarn build:prod",
+    "test": "jest --config jest.config.js --coverage",
+    "build:bench:old": "tsc --outDir lib-reference/",
+    "build:bench:new": "tsc --outDir lib-test/",
+    "bench": "node perf/benchmark.cjs"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dubzzz/pure-rand.git"
+  },
+  "author": "Nicolas DUBIEN <github@dubien.org>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/dubzzz/pure-rand/issues"
+  },
+  "homepage": "https://github.com/dubzzz/pure-rand#readme",
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.11.30",
+    "cross-env": "^7.0.3",
+    "fast-check": "^3.16.0",
+    "jest": "^29.7.0",
+    "prettier": "3.2.5",
+    "replace-in-file": "^7.1.0",
+    "source-map-support": "^0.5.21",
+    "tinybench": "^2.6.0",
+    "ts-jest": "^29.1.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.2"
+  },
+  "keywords": [
+    "seed",
+    "random",
+    "prng",
+    "generator",
+    "pure",
+    "rand",
+    "mersenne",
+    "random number generator",
+    "fastest",
+    "fast"
+  ],
+  "funding": [
+    {
+      "type": "individual",
+      "url": "https://github.com/sponsors/dubzzz"
+    },
+    {
+      "type": "opencollective",
+      "url": "https://opencollective.com/fast-check"
+    }
+  ]
+}

package/packages/plugin-cloud/node_modules/signal-exit/LICENSE.txt

@@ -0,0 +1,16 @@
+The ISC License
+
+Copyright (c) 2015, Contributors
+
+Permission to use, copy, modify, and/or distribute this software
+for any purpose with or without fee is hereby granted, provided
+that the above copyright notice and this permission notice
+appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE
+LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES
+OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/packages/plugin-cloud/node_modules/signal-exit/README.md

@@ -0,0 +1,39 @@
+# signal-exit
+
+[![Build Status](https://travis-ci.org/tapjs/signal-exit.png)](https://travis-ci.org/tapjs/signal-exit)
+[![Coverage](https://coveralls.io/repos/tapjs/signal-exit/badge.svg?branch=master)](https://coveralls.io/r/tapjs/signal-exit?branch=master)
+[![NPM version](https://img.shields.io/npm/v/signal-exit.svg)](https://www.npmjs.com/package/signal-exit)
+[![Standard Version](https://img.shields.io/badge/release-standard%20version-brightgreen.svg)](https://github.com/conventional-changelog/standard-version)
+
+When you want to fire an event no matter how a process exits:
+
+* reaching the end of execution.
+* explicitly having `process.exit(code)` called.
+* having `process.kill(pid, sig)` called.
+* receiving a fatal signal from outside the process
+
+Use `signal-exit`.
+
+```js
+var onExit = require('signal-exit')
+
+onExit(function (code, signal) {
+  console.log('process exited!')
+})
+```
+
+## API
+
+`var remove = onExit(function (code, signal) {}, options)`
+
+The return value of the function is a function that will remove the
+handler.
+
+Note that the function *only* fires for signals if the signal would
+cause the process to exit.  That is, there are no other listeners, and
+it is a fatal signal.
+
+## Options
+
+* `alwaysLast`: Run this handler after any other signal or exit
+  handlers.  This causes `process.emit` to be monkeypatched.

package/packages/plugin-cloud/node_modules/signal-exit/index.js

@@ -0,0 +1,202 @@
+// Note: since nyc uses this module to output coverage, any lines
+// that are in the direct sync flow of nyc's outputCoverage are
+// ignored, since we can never get coverage for them.
+// grab a reference to node's real process object right away
+var process = global.process
+
+const processOk = function (process) {
+  return process &&
+    typeof process === 'object' &&
+    typeof process.removeListener === 'function' &&
+    typeof process.emit === 'function' &&
+    typeof process.reallyExit === 'function' &&
+    typeof process.listeners === 'function' &&
+    typeof process.kill === 'function' &&
+    typeof process.pid === 'number' &&
+    typeof process.on === 'function'
+}
+
+// some kind of non-node environment, just no-op
+/* istanbul ignore if */
+if (!processOk(process)) {
+  module.exports = function () {
+    return function () {}
+  }
+} else {
+  var assert = require('assert')
+  var signals = require('./signals.js')
+  var isWin = /^win/i.test(process.platform)
+
+  var EE = require('events')
+  /* istanbul ignore if */
+  if (typeof EE !== 'function') {
+    EE = EE.EventEmitter
+  }
+
+  var emitter
+  if (process.__signal_exit_emitter__) {
+    emitter = process.__signal_exit_emitter__
+  } else {
+    emitter = process.__signal_exit_emitter__ = new EE()
+    emitter.count = 0
+    emitter.emitted = {}
+  }
+
+  // Because this emitter is a global, we have to check to see if a
+  // previous version of this library failed to enable infinite listeners.
+  // I know what you're about to say.  But literally everything about
+  // signal-exit is a compromise with evil.  Get used to it.
+  if (!emitter.infinite) {
+    emitter.setMaxListeners(Infinity)
+    emitter.infinite = true
+  }
+
+  module.exports = function (cb, opts) {
+    /* istanbul ignore if */
+    if (!processOk(global.process)) {
+      return function () {}
+    }
+    assert.equal(typeof cb, 'function', 'a callback must be provided for exit handler')
+
+    if (loaded === false) {
+      load()
+    }
+
+    var ev = 'exit'
+    if (opts && opts.alwaysLast) {
+      ev = 'afterexit'
+    }
+
+    var remove = function () {
+      emitter.removeListener(ev, cb)
+      if (emitter.listeners('exit').length === 0 &&
+          emitter.listeners('afterexit').length === 0) {
+        unload()
+      }
+    }
+    emitter.on(ev, cb)
+
+    return remove
+  }
+
+  var unload = function unload () {
+    if (!loaded || !processOk(global.process)) {
+      return
+    }
+    loaded = false
+
+    signals.forEach(function (sig) {
+      try {
+        process.removeListener(sig, sigListeners[sig])
+      } catch (er) {}
+    })
+    process.emit = originalProcessEmit
+    process.reallyExit = originalProcessReallyExit
+    emitter.count -= 1
+  }
+  module.exports.unload = unload
+
+  var emit = function emit (event, code, signal) {
+    /* istanbul ignore if */
+    if (emitter.emitted[event]) {
+      return
+    }
+    emitter.emitted[event] = true
+    emitter.emit(event, code, signal)
+  }
+
+  // { <signal>: <listener fn>, ... }
+  var sigListeners = {}
+  signals.forEach(function (sig) {
+    sigListeners[sig] = function listener () {
+      /* istanbul ignore if */
+      if (!processOk(global.process)) {
+        return
+      }
+      // If there are no other listeners, an exit is coming!
+      // Simplest way: remove us and then re-send the signal.
+      // We know that this will kill the process, so we can
+      // safely emit now.
+      var listeners = process.listeners(sig)
+      if (listeners.length === emitter.count) {
+        unload()
+        emit('exit', null, sig)
+        /* istanbul ignore next */
+        emit('afterexit', null, sig)
+        /* istanbul ignore next */
+        if (isWin && sig === 'SIGHUP') {
+          // "SIGHUP" throws an `ENOSYS` error on Windows,
+          // so use a supported signal instead
+          sig = 'SIGINT'
+        }
+        /* istanbul ignore next */
+        process.kill(process.pid, sig)
+      }
+    }
+  })
+
+  module.exports.signals = function () {
+    return signals
+  }
+
+  var loaded = false
+
+  var load = function load () {
+    if (loaded || !processOk(global.process)) {
+      return
+    }
+    loaded = true
+
+    // This is the number of onSignalExit's that are in play.
+    // It's important so that we can count the correct number of
+    // listeners on signals, and don't wait for the other one to
+    // handle it instead of us.
+    emitter.count += 1
+
+    signals = signals.filter(function (sig) {
+      try {
+        process.on(sig, sigListeners[sig])
+        return true
+      } catch (er) {
+        return false
+      }
+    })
+
+    process.emit = processEmit
+    process.reallyExit = processReallyExit
+  }
+  module.exports.load = load
+
+  var originalProcessReallyExit = process.reallyExit
+  var processReallyExit = function processReallyExit (code) {
+    /* istanbul ignore if */
+    if (!processOk(global.process)) {
+      return
+    }
+    process.exitCode = code || /* istanbul ignore next */ 0
+    emit('exit', process.exitCode, null)
+    /* istanbul ignore next */
+    emit('afterexit', process.exitCode, null)
+    /* istanbul ignore next */
+    originalProcessReallyExit.call(process, process.exitCode)
+  }
+
+  var originalProcessEmit = process.emit
+  var processEmit = function processEmit (ev, arg) {
+    if (ev === 'exit' && processOk(global.process)) {
+      /* istanbul ignore else */
+      if (arg !== undefined) {
+        process.exitCode = arg
+      }
+      var ret = originalProcessEmit.apply(this, arguments)
+      /* istanbul ignore next */
+      emit('exit', process.exitCode, null)
+      /* istanbul ignore next */
+      emit('afterexit', process.exitCode, null)
+      /* istanbul ignore next */
+      return ret
+    } else {
+      return originalProcessEmit.apply(this, arguments)
+    }
+  }
+}

package/packages/plugin-cloud/node_modules/signal-exit/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "signal-exit",
+  "version": "3.0.7",
+  "description": "when you want to fire an event no matter how a process exits.",
+  "main": "index.js",
+  "scripts": {
+    "test": "tap",
+    "snap": "tap",
+    "preversion": "npm test",
+    "postversion": "npm publish",
+    "prepublishOnly": "git push origin --follow-tags"
+  },
+  "files": [
+    "index.js",
+    "signals.js"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tapjs/signal-exit.git"
+  },
+  "keywords": [
+    "signal",
+    "exit"
+  ],
+  "author": "Ben Coe <ben@npmjs.com>",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/tapjs/signal-exit/issues"
+  },
+  "homepage": "https://github.com/tapjs/signal-exit",
+  "devDependencies": {
+    "chai": "^3.5.0",
+    "coveralls": "^3.1.1",
+    "nyc": "^15.1.0",
+    "standard-version": "^9.3.1",
+    "tap": "^15.1.1"
+  }
+}

package/packages/plugin-cloud/node_modules/signal-exit/signals.js

@@ -0,0 +1,53 @@
+// This is not the set of all possible signals.
+//
+// It IS, however, the set of all signals that trigger
+// an exit on either Linux or BSD systems.  Linux is a
+// superset of the signal names supported on BSD, and
+// the unknown signals just fail to register, so we can
+// catch that easily enough.
+//
+// Don't bother with SIGKILL.  It's uncatchable, which
+// means that we can't fire any callbacks anyway.
+//
+// If a user does happen to register a handler on a non-
+// fatal signal like SIGWINCH or something, and then
+// exit, it'll end up firing `process.emit('exit')`, so
+// the handler will be fired anyway.
+//
+// SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised
+// artificially, inherently leave the process in a
+// state from which it is not safe to try and enter JS
+// listeners.
+module.exports = [
+  'SIGABRT',
+  'SIGALRM',
+  'SIGHUP',
+  'SIGINT',
+  'SIGTERM'
+]
+
+if (process.platform !== 'win32') {
+  module.exports.push(
+    'SIGVTALRM',
+    'SIGXCPU',
+    'SIGXFSZ',
+    'SIGUSR2',
+    'SIGTRAP',
+    'SIGSYS',
+    'SIGQUIT',
+    'SIGIOT'
+    // should detect profiler and enable/disable accordingly.
+    // see #21
+    // 'SIGPROF'
+  )
+}
+
+if (process.platform === 'linux') {
+  module.exports.push(
+    'SIGIO',
+    'SIGPOLL',
+    'SIGPWR',
+    'SIGSTKFLT',
+    'SIGUNUSED'
+  )
+}

package/packages/plugin-cloud/node_modules/strip-final-newline/index.js

@@ -0,0 +1,16 @@
+'use strict';
+
+module.exports = input => {
+	const LF = typeof input === 'string' ? '\n' : '\n'.charCodeAt();
+	const CR = typeof input === 'string' ? '\r' : '\r'.charCodeAt();
+
+	if (input[input.length - 1] === LF) {
+		input = input.slice(0, input.length - 1);
+	}
+
+	if (input[input.length - 1] === CR) {
+		input = input.slice(0, input.length - 1);
+	}
+
+	return input;
+};

package/packages/plugin-cloud/node_modules/strip-final-newline/license

@@ -0,0 +1,9 @@
+MIT License
+
+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.