@aws-cdk/integ-runner/lib/workers/extract/index.js

CDK Integration Testing Tool

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
var __typeError = (msg) => {
  throw TypeError(msg);
};
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __esm = (fn, res) => function __init() {
  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __commonJS = (cb, mod) => function __require() {
  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var __decorateClass = (decorators, target, key, kind) => {
  var result2 = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
  for (var i3 = decorators.length - 1, decorator; i3 >= 0; i3--)
    if (decorator = decorators[i3])
      result2 = (kind ? decorator(target, key, result2) : decorator(result2)) || result2;
  if (kind && result2) __defProp(target, key, result2);
  return result2;
};
var __using = (stack, value, async) => {
  if (value != null) {
    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
    var dispose, inner;
    if (async) dispose = value[__knownSymbol("asyncDispose")];
    if (dispose === void 0) {
      dispose = value[__knownSymbol("dispose")];
      if (async) inner = dispose;
    }
    if (typeof dispose !== "function") __typeError("Object not disposable");
    if (inner) dispose = function() {
      try {
        inner.call(this);
      } catch (e3) {
        return Promise.reject(e3);
      }
    };
    stack.push([async, dispose, value]);
  } else if (async) {
    stack.push([async]);
  }
  return value;
};
var __callDispose = (stack, error3, hasError) => {
  var E2 = typeof SuppressedError === "function" ? SuppressedError : function(e3, s3, m3, _3) {
    return _3 = Error(m3), _3.name = "SuppressedError", _3.error = e3, _3.suppressed = s3, _3;
  };
  var fail = (e3) => error3 = hasError ? new E2(e3, error3, "An error was suppressed during disposal") : (hasError = true, e3);
  var next = (it) => {
    while (it = stack.pop()) {
      try {
        var result2 = it[1] && it[1].call(it[2]);
        if (it[0]) return Promise.resolve(result2).then(next, (e3) => (fail(e3), next()));
      } catch (e3) {
        fail(e3);
      }
    }
    if (hasError) throw error3;
  };
  return next();
};

// ../../../node_modules/workerpool/src/requireFoolWebpack.js
var require_requireFoolWebpack = __commonJS({
  "../../../node_modules/workerpool/src/requireFoolWebpack.js"(exports, module) {
    var requireFoolWebpack = eval(
      `typeof require !== 'undefined' ? require : function (module) { throw new Error('Module " + module + " not found.') }`
    );
    module.exports = requireFoolWebpack;
  }
});

// ../../../node_modules/workerpool/src/environment.js
var require_environment = __commonJS({
  "../../../node_modules/workerpool/src/environment.js"(exports2, module2) {
    var requireFoolWebpack2 = require_requireFoolWebpack();
    var isNode = /* @__PURE__ */ __name(function(nodeProcess) {
      return typeof nodeProcess !== "undefined" && nodeProcess.versions != null && nodeProcess.versions.node != null;
    }, "isNode");
    module2.exports.isNode = isNode;
    module2.exports.platform = typeof process !== "undefined" && isNode(process) ? "node" : "browser";
    var worker_threads = tryRequireFoolWebpack("worker_threads");
    module2.exports.isMainThread = module2.exports.platform === "node" ? (!worker_threads || worker_threads.isMainThread) && !process.connected : typeof Window !== "undefined";
    module2.exports.cpus = module2.exports.platform === "browser" ? self.navigator.hardwareConcurrency : requireFoolWebpack2("os").cpus().length;
    function tryRequireFoolWebpack(module3) {
      try {
        return requireFoolWebpack2(module3);
      } catch (err) {
        return null;
      }
    }
    __name(tryRequireFoolWebpack, "tryRequireFoolWebpack");
  }
});

// ../../../node_modules/workerpool/src/Promise.js
var require_Promise = __commonJS({
  "../../../node_modules/workerpool/src/Promise.js"(exports2, module2) {
    "use strict";
    function Promise2(handler, parent) {
      var me = this;
      if (!(this instanceof Promise2)) {
        throw new SyntaxError("Constructor must be called with the new operator");
      }
      if (typeof handler !== "function") {
        throw new SyntaxError("Function parameter handler(resolve, reject) missing");
      }
      var _onSuccess = [];
      var _onFail = [];
      this.resolved = false;
      this.rejected = false;
      this.pending = true;
      var _process = /* @__PURE__ */ __name(function(onSuccess, onFail) {
        _onSuccess.push(onSuccess);
        _onFail.push(onFail);
      }, "_process");
      this.then = function(onSuccess, onFail) {
        return new Promise2(function(resolve10, reject) {
          var s3 = onSuccess ? _then(onSuccess, resolve10, reject) : resolve10;
          var f3 = onFail ? _then(onFail, resolve10, reject) : reject;
          _process(s3, f3);
        }, me);
      };
      var _resolve = /* @__PURE__ */ __name(function(result2) {
        me.resolved = true;
        me.rejected = false;
        me.pending = false;
        _onSuccess.forEach(function(fn) {
          fn(result2);
        });
        _process = /* @__PURE__ */ __name(function(onSuccess, onFail) {
          onSuccess(result2);
        }, "_process");
        _resolve = _reject = /* @__PURE__ */ __name(function() {
        }, "_reject");
        return me;
      }, "_resolve");
      var _reject = /* @__PURE__ */ __name(function(error3) {
        me.resolved = false;
        me.rejected = true;
        me.pending = false;
        _onFail.forEach(function(fn) {
          fn(error3);
        });
        _process = /* @__PURE__ */ __name(function(onSuccess, onFail) {
          onFail(error3);
        }, "_process");
        _resolve = _reject = /* @__PURE__ */ __name(function() {
        }, "_reject");
        return me;
      }, "_reject");
      this.cancel = function() {
        if (parent) {
          parent.cancel();
        } else {
          _reject(new CancellationError());
        }
        return me;
      };
      this.timeout = function(delay) {
        if (parent) {
          parent.timeout(delay);
        } else {
          var timer = setTimeout(function() {
            _reject(new TimeoutError("Promise timed out after " + delay + " ms"));
          }, delay);
          me.always(function() {
            clearTimeout(timer);
          });
        }
        return me;
      };
      handler(function(result2) {
        _resolve(result2);
      }, function(error3) {
        _reject(error3);
      });
    }
    __name(Promise2, "Promise");
    function _then(callback, resolve10, reject) {
      return function(result2) {
        try {
          var res = callback(result2);
          if (res && typeof res.then === "function" && typeof res["catch"] === "function") {
            res.then(resolve10, reject);
          } else {
            resolve10(res);
          }
        } catch (error3) {
          reject(error3);
        }
      };
    }
    __name(_then, "_then");
    Promise2.prototype["catch"] = function(onFail) {
      return this.then(null, onFail);
    };
    Promise2.prototype.always = function(fn) {
      return this.then(fn, fn);
    };
    Promise2.all = function(promises3) {
      return new Promise2(function(resolve10, reject) {
        var remaining = promises3.length, results = [];
        if (remaining) {
          promises3.forEach(function(p3, i3) {
            p3.then(function(result2) {
              results[i3] = result2;
              remaining--;
              if (remaining == 0) {
                resolve10(results);
              }
            }, function(error3) {
              remaining = 0;
              reject(error3);
            });
          });
        } else {
          resolve10(results);
        }
      });
    };
    Promise2.defer = function() {
      var resolver = {};
      resolver.promise = new Promise2(function(resolve10, reject) {
        resolver.resolve = resolve10;
        resolver.reject = reject;
      });
      return resolver;
    };
    function CancellationError(message2) {
      this.message = message2 || "promise cancelled";
      this.stack = new Error().stack;
    }
    __name(CancellationError, "CancellationError");
    CancellationError.prototype = new Error();
    CancellationError.prototype.constructor = Error;
    CancellationError.prototype.name = "CancellationError";
    Promise2.CancellationError = CancellationError;
    function TimeoutError(message2) {
      this.message = message2 || "timeout exceeded";
      this.stack = new Error().stack;
    }
    __name(TimeoutError, "TimeoutError");
    TimeoutError.prototype = new Error();
    TimeoutError.prototype.constructor = Error;
    TimeoutError.prototype.name = "TimeoutError";
    Promise2.TimeoutError = TimeoutError;
    module2.exports = Promise2;
  }
});

// ../../../node_modules/workerpool/src/generated/embeddedWorker.js
var require_embeddedWorker = __commonJS({
  "../../../node_modules/workerpool/src/generated/embeddedWorker.js"(exports2, module2) {
    module2.exports = `!function(){var __webpack_modules__={577:function(e){e.exports=function(e,r){this.message=e,this.transfer=r}}},__webpack_module_cache__={};function __webpack_require__(e){var r=__webpack_module_cache__[e];return void 0!==r||(r=__webpack_module_cache__[e]={exports:{}},__webpack_modules__[e](r,r.exports,__webpack_require__)),r.exports}var __webpack_exports__={};!function(){var exports=__webpack_exports__,__webpack_unused_export__;function _typeof(e){return(_typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}var Transfer=__webpack_require__(577),requireFoolWebpack=eval("typeof require !== 'undefined' ? require : function (module) { throw new Error('Module \\" + module + \\" not found.') }"),TERMINATE_METHOD_ID="__workerpool-terminate__",worker={exit:function(){}},WorkerThreads,parentPort;if("undefined"!=typeof self&&"function"==typeof postMessage&&"function"==typeof addEventListener)worker.on=function(e,r){addEventListener(e,function(e){r(e.data)})},worker.send=function(e){postMessage(e)};else{if("undefined"==typeof process)throw new Error("Script must be executed as a worker");try{WorkerThreads=requireFoolWebpack("worker_threads")}catch(error){if("object"!==_typeof(error)||null===error||"MODULE_NOT_FOUND"!==error.code)throw error}WorkerThreads&&null!==WorkerThreads.parentPort?(parentPort=WorkerThreads.parentPort,worker.send=parentPort.postMessage.bind(parentPort),worker.on=parentPort.on.bind(parentPort)):(worker.on=process.on.bind(process),worker.send=function(e){process.send(e)},worker.on("disconnect",function(){process.exit(1)})),worker.exit=process.exit.bind(process)}function convertError(o){return Object.getOwnPropertyNames(o).reduce(function(e,r){return Object.defineProperty(e,r,{value:o[r],enumerable:!0})},{})}function isPromise(e){return e&&"function"==typeof e.then&&"function"==typeof e.catch}worker.methods={},worker.methods.run=function(e,r){e=new Function("return ("+e+").apply(null, arguments);");return e.apply(e,r)},worker.methods.methods=function(){return Object.keys(worker.methods)},worker.terminationHandler=void 0,worker.cleanupAndExit=function(e){function r(){worker.exit(e)}if(!worker.terminationHandler)return r();var o=worker.terminationHandler(e);isPromise(o)?o.then(r,r):r()};var currentRequestId=null;worker.on("message",function(r){if(r===TERMINATE_METHOD_ID)return worker.cleanupAndExit(0);try{var e=worker.methods[r.method];if(!e)throw new Error('Unknown method "'+r.method+'"');currentRequestId=r.id;var o=e.apply(e,r.params);isPromise(o)?o.then(function(e){e instanceof Transfer?worker.send({id:r.id,result:e.message,error:null},e.transfer):worker.send({id:r.id,result:e,error:null}),currentRequestId=null}).catch(function(e){worker.send({id:r.id,result:null,error:convertError(e)}),currentRequestId=null}):(o instanceof Transfer?worker.send({id:r.id,result:o.message,error:null},o.transfer):worker.send({id:r.id,result:o,error:null}),currentRequestId=null)}catch(e){worker.send({id:r.id,result:null,error:convertError(e)})}}),worker.register=function(e,r){if(e)for(var o in e)e.hasOwnProperty(o)&&(worker.methods[o]=e[o]);r&&(worker.terminationHandler=r.onTerminate),worker.send("ready")},worker.emit=function(e){currentRequestId&&(e instanceof Transfer?worker.send({id:currentRequestId,isEvent:!0,payload:e.message},e.transfer):worker.send({id:currentRequestId,isEvent:!0,payload:e}))},__webpack_unused_export__=worker.register,worker.emit}()}();`;
  }
});

// ../../../node_modules/workerpool/src/WorkerHandler.js
var require_WorkerHandler = __commonJS({
  "../../../node_modules/workerpool/src/WorkerHandler.js"(exports2, module2) {
    "use strict";
    var Promise2 = require_Promise();
    var environment = require_environment();
    var requireFoolWebpack2 = require_requireFoolWebpack();
    var TERMINATE_METHOD_ID2 = "__workerpool-terminate__";
    function ensureWorkerThreads() {
      var WorkerThreads2 = tryRequireWorkerThreads();
      if (!WorkerThreads2) {
        throw new Error("WorkerPool: workerType = 'thread' is not supported, Node >= 11.7.0 required");
      }
      return WorkerThreads2;
    }
    __name(ensureWorkerThreads, "ensureWorkerThreads");
    function ensureWebWorker() {
      if (typeof Worker !== "function" && (typeof Worker !== "object" || typeof Worker.prototype.constructor !== "function")) {
        throw new Error("WorkerPool: Web Workers not supported");
      }
    }
    __name(ensureWebWorker, "ensureWebWorker");
    function tryRequireWorkerThreads() {
      try {
        return requireFoolWebpack2("worker_threads");
      } catch (error3) {
        if (typeof error3 === "object" && error3 !== null && error3.code === "MODULE_NOT_FOUND") {
          return null;
        } else {
          throw error3;
        }
      }
    }
    __name(tryRequireWorkerThreads, "tryRequireWorkerThreads");
    function getDefaultWorker() {
      if (environment.platform === "browser") {
        if (typeof Blob === "undefined") {
          throw new Error("Blob not supported by the browser");
        }
        if (!window.URL || typeof window.URL.createObjectURL !== "function") {
          throw new Error("URL.createObjectURL not supported by the browser");
        }
        var blob = new Blob([require_embeddedWorker()], { type: "text/javascript" });
        return window.URL.createObjectURL(blob);
      } else {
        return __dirname + "/worker.js";
      }
    }
    __name(getDefaultWorker, "getDefaultWorker");
    function setupWorker(script, options) {
      if (options.workerType === "web") {
        ensureWebWorker();
        return setupBrowserWorker(script, options.workerOpts, Worker);
      } else if (options.workerType === "thread") {
        WorkerThreads2 = ensureWorkerThreads();
        return setupWorkerThreadWorker(script, WorkerThreads2, options.workerThreadOpts);
      } else if (options.workerType === "process" || !options.workerType) {
        return setupProcessWorker(script, resolveForkOptions(options), requireFoolWebpack2("child_process"));
      } else {
        if (environment.platform === "browser") {
          ensureWebWorker();
          return setupBrowserWorker(script, options.workerOpts, Worker);
        } else {
          var WorkerThreads2 = tryRequireWorkerThreads();
          if (WorkerThreads2) {
            return setupWorkerThreadWorker(script, WorkerThreads2, options.workerThreadOpts);
          } else {
            return setupProcessWorker(script, resolveForkOptions(options), requireFoolWebpack2("child_process"));
          }
        }
      }
    }
    __name(setupWorker, "setupWorker");
    function setupBrowserWorker(script, workerOpts, Worker2) {
      var worker3 = new Worker2(script, workerOpts);
      worker3.isBrowserWorker = true;
      worker3.on = function(event, callback) {
        this.addEventListener(event, function(message2) {
          callback(message2.data);
        });
      };
      worker3.send = function(message2, transfer) {
        this.postMessage(message2, transfer);
      };
      return worker3;
    }
    __name(setupBrowserWorker, "setupBrowserWorker");
    function setupWorkerThreadWorker(script, WorkerThreads2, workerThreadOptions) {
      var worker3 = new WorkerThreads2.Worker(script, {
        stdout: false,
        // automatically pipe worker.STDOUT to process.STDOUT
        stderr: false,
        // automatically pipe worker.STDERR to process.STDERR
        ...workerThreadOptions
      });
      worker3.isWorkerThread = true;
      worker3.send = function(message2, transfer) {
        this.postMessage(message2, transfer);
      };
      worker3.kill = function() {
        this.terminate();
        return true;
      };
      worker3.disconnect = function() {
        this.terminate();
      };
      return worker3;
    }
    __name(setupWorkerThreadWorker, "setupWorkerThreadWorker");
    function setupProcessWorker(script, options, child_process3) {
      var worker3 = child_process3.fork(
        script,
        options.forkArgs,
        options.forkOpts
      );
      var send = worker3.send;
      worker3.send = function(message2) {
        return send.call(worker3, message2);
      };
      worker3.isChildProcess = true;
      return worker3;
    }
    __name(setupProcessWorker, "setupProcessWorker");
    function resolveForkOptions(opts) {
      opts = opts || {};
      var processExecArgv = process.execArgv.join(" ");
      var inspectorActive = processExecArgv.indexOf("--inspect") !== -1;
      var debugBrk = processExecArgv.indexOf("--debug-brk") !== -1;
      var execArgv = [];
      if (inspectorActive) {
        execArgv.push("--inspect=" + opts.debugPort);
        if (debugBrk) {
          execArgv.push("--debug-brk");
        }
      }
      process.execArgv.forEach(function(arg) {
        if (arg.indexOf("--max-old-space-size") > -1) {
          execArgv.push(arg);
        }
      });
      return Object.assign({}, opts, {
        forkArgs: opts.forkArgs,
        forkOpts: Object.assign({}, opts.forkOpts, {
          execArgv: (opts.forkOpts && opts.forkOpts.execArgv || []).concat(execArgv)
        })
      });
    }
    __name(resolveForkOptions, "resolveForkOptions");
    function objectToError(obj) {
      var temp = new Error("");
      var props = Object.keys(obj);
      for (var i3 = 0; i3 < props.length; i3++) {
        temp[props[i3]] = obj[props[i3]];
      }
      return temp;
    }
    __name(objectToError, "objectToError");
    function WorkerHandler(script, _options) {
      var me = this;
      var options = _options || {};
      this.script = script || getDefaultWorker();
      this.worker = setupWorker(this.script, options);
      this.debugPort = options.debugPort;
      this.forkOpts = options.forkOpts;
      this.forkArgs = options.forkArgs;
      this.workerOpts = options.workerOpts;
      this.workerThreadOpts = options.workerThreadOpts;
      this.workerTerminateTimeout = options.workerTerminateTimeout;
      if (!script) {
        this.worker.ready = true;
      }
      this.requestQueue = [];
      this.worker.on("message", function(response) {
        if (me.terminated) {
          return;
        }
        if (typeof response === "string" && response === "ready") {
          me.worker.ready = true;
          dispatchQueuedRequests();
        } else {
          var id = response.id;
          var task = me.processing[id];
          if (task !== void 0) {
            if (response.isEvent) {
              if (task.options && typeof task.options.on === "function") {
                task.options.on(response.payload);
              }
            } else {
              delete me.processing[id];
              if (me.terminating === true) {
                me.terminate();
              }
              if (response.error) {
                task.resolver.reject(objectToError(response.error));
              } else {
                task.resolver.resolve(response.result);
              }
            }
          }
        }
      });
      function onError(error3) {
        me.terminated = true;
        for (var id in me.processing) {
          if (me.processing[id] !== void 0) {
            me.processing[id].resolver.reject(error3);
          }
        }
        me.processing = /* @__PURE__ */ Object.create(null);
      }
      __name(onError, "onError");
      function dispatchQueuedRequests() {
        for (const request2 of me.requestQueue.splice(0)) {
          me.worker.send(request2.message, request2.transfer);
        }
      }
      __name(dispatchQueuedRequests, "dispatchQueuedRequests");
      var worker3 = this.worker;
      this.worker.on("error", onError);
      this.worker.on("exit", function(exitCode, signalCode) {
        var message2 = "Workerpool Worker terminated Unexpectedly\n";
        message2 += "    exitCode: `" + exitCode + "`\n";
        message2 += "    signalCode: `" + signalCode + "`\n";
        message2 += "    workerpool.script: `" + me.script + "`\n";
        message2 += "    spawnArgs: `" + worker3.spawnargs + "`\n";
        message2 += "    spawnfile: `" + worker3.spawnfile + "`\n";
        message2 += "    stdout: `" + worker3.stdout + "`\n";
        message2 += "    stderr: `" + worker3.stderr + "`\n";
        onError(new Error(message2));
      });
      this.processing = /* @__PURE__ */ Object.create(null);
      this.terminating = false;
      this.terminated = false;
      this.cleaning = false;
      this.terminationHandler = null;
      this.lastId = 0;
    }
    __name(WorkerHandler, "WorkerHandler");
    WorkerHandler.prototype.methods = function() {
      return this.exec("methods");
    };
    WorkerHandler.prototype.exec = function(method, params, resolver, options) {
      if (!resolver) {
        resolver = Promise2.defer();
      }
      var id = ++this.lastId;
      this.processing[id] = {
        id,
        resolver,
        options
      };
      var request2 = {
        message: {
          id,
          method,
          params
        },
        transfer: options && options.transfer
      };
      if (this.terminated) {
        resolver.reject(new Error("Worker is terminated"));
      } else if (this.worker.ready) {
        this.worker.send(request2.message, request2.transfer);
      } else {
        this.requestQueue.push(request2);
      }
      var me = this;
      return resolver.promise.catch(function(error3) {
        if (error3 instanceof Promise2.CancellationError || error3 instanceof Promise2.TimeoutError) {
          delete me.processing[id];
          return me.terminateAndNotify(true).then(function() {
            throw error3;
          }, function(err) {
            throw err;
          });
        } else {
          throw error3;
        }
      });
    };
    WorkerHandler.prototype.busy = function() {
      return this.cleaning || Object.keys(this.processing).length > 0;
    };
    WorkerHandler.prototype.terminate = function(force, callback) {
      var me = this;
      if (force) {
        for (var id in this.processing) {
          if (this.processing[id] !== void 0) {
            this.processing[id].resolver.reject(new Error("Worker terminated"));
          }
        }
        this.processing = /* @__PURE__ */ Object.create(null);
      }
      if (typeof callback === "function") {
        this.terminationHandler = callback;
      }
      if (!this.busy()) {
        var cleanup = /* @__PURE__ */ __name(function(err) {
          me.terminated = true;
          me.cleaning = false;
          if (me.worker != null && me.worker.removeAllListeners) {
            me.worker.removeAllListeners("message");
          }
          me.worker = null;
          me.terminating = false;
          if (me.terminationHandler) {
            me.terminationHandler(err, me);
          } else if (err) {
            throw err;
          }
        }, "cleanup");
        if (this.worker) {
          if (typeof this.worker.kill === "function") {
            if (this.worker.killed) {
              cleanup(new Error("worker already killed!"));
              return;
            }
            var cleanExitTimeout = setTimeout(function() {
              if (me.worker) {
                me.worker.kill();
              }
            }, this.workerTerminateTimeout);
            this.worker.once("exit", function() {
              clearTimeout(cleanExitTimeout);
              if (me.worker) {
                me.worker.killed = true;
              }
              cleanup();
            });
            if (this.worker.ready) {
              this.worker.send(TERMINATE_METHOD_ID2);
            } else {
              this.requestQueue.push({ message: TERMINATE_METHOD_ID2 });
            }
            this.cleaning = true;
            return;
          } else if (typeof this.worker.terminate === "function") {
            this.worker.terminate();
            this.worker.killed = true;
          } else {
            throw new Error("Failed to terminate worker");
          }
        }
        cleanup();
      } else {
        this.terminating = true;
      }
    };
    WorkerHandler.prototype.terminateAndNotify = function(force, timeout) {
      var resolver = Promise2.defer();
      if (timeout) {
        resolver.promise.timeout(timeout);
      }
      this.terminate(force, function(err, worker3) {
        if (err) {
          resolver.reject(err);
        } else {
          resolver.resolve(worker3);
        }
      });
      return resolver.promise;
    };
    module2.exports = WorkerHandler;
    module2.exports._tryRequireWorkerThreads = tryRequireWorkerThreads;
    module2.exports._setupProcessWorker = setupProcessWorker;
    module2.exports._setupBrowserWorker = setupBrowserWorker;
    module2.exports._setupWorkerThreadWorker = setupWorkerThreadWorker;
    module2.exports.ensureWorkerThreads = ensureWorkerThreads;
  }
});

// ../../../node_modules/workerpool/src/debug-port-allocator.js
var require_debug_port_allocator = __commonJS({
  "../../../node_modules/workerpool/src/debug-port-allocator.js"(exports2, module2) {
    "use strict";
    var MAX_PORTS = 65535;
    module2.exports = DebugPortAllocator;
    function DebugPortAllocator() {
      this.ports = /* @__PURE__ */ Object.create(null);
      this.length = 0;
    }
    __name(DebugPortAllocator, "DebugPortAllocator");
    DebugPortAllocator.prototype.nextAvailableStartingAt = function(starting) {
      while (this.ports[starting] === true) {
        starting++;
      }
      if (starting >= MAX_PORTS) {
        throw new Error("WorkerPool debug port limit reached: " + starting + ">= " + MAX_PORTS);
      }
      this.ports[starting] = true;
      this.length++;
      return starting;
    };
    DebugPortAllocator.prototype.releasePort = function(port) {
      delete this.ports[port];
      this.length--;
    };
  }
});

// ../../../node_modules/workerpool/src/Pool.js
var require_Pool = __commonJS({
  "../../../node_modules/workerpool/src/Pool.js"(exports2, module2) {
    var Promise2 = require_Promise();
    var WorkerHandler = require_WorkerHandler();
    var environment = require_environment();
    var DebugPortAllocator = require_debug_port_allocator();
    var DEBUG_PORT_ALLOCATOR = new DebugPortAllocator();
    function Pool(script, options) {
      if (typeof script === "string") {
        this.script = script || null;
      } else {
        this.script = null;
        options = script;
      }
      this.workers = [];
      this.tasks = [];
      options = options || {};
      this.forkArgs = Object.freeze(options.forkArgs || []);
      this.forkOpts = Object.freeze(options.forkOpts || {});
      this.workerOpts = Object.freeze(options.workerOpts || {});
      this.workerThreadOpts = Object.freeze(options.workerThreadOpts || {});
      this.debugPortStart = options.debugPortStart || 43210;
      this.nodeWorker = options.nodeWorker;
      this.workerType = options.workerType || options.nodeWorker || "auto";
      this.maxQueueSize = options.maxQueueSize || Infinity;
      this.workerTerminateTimeout = options.workerTerminateTimeout || 1e3;
      this.onCreateWorker = options.onCreateWorker || (() => null);
      this.onTerminateWorker = options.onTerminateWorker || (() => null);
      if (options && "maxWorkers" in options) {
        validateMaxWorkers(options.maxWorkers);
        this.maxWorkers = options.maxWorkers;
      } else {
        this.maxWorkers = Math.max((environment.cpus || 4) - 1, 1);
      }
      if (options && "minWorkers" in options) {
        if (options.minWorkers === "max") {
          this.minWorkers = this.maxWorkers;
        } else {
          validateMinWorkers(options.minWorkers);
          this.minWorkers = options.minWorkers;
          this.maxWorkers = Math.max(this.minWorkers, this.maxWorkers);
        }
        this._ensureMinWorkers();
      }
      this._boundNext = this._next.bind(this);
      if (this.workerType === "thread") {
        WorkerHandler.ensureWorkerThreads();
      }
    }
    __name(Pool, "Pool");
    Pool.prototype.exec = function(method, params, options) {
      if (params && !Array.isArray(params)) {
        throw new TypeError('Array expected as argument "params"');
      }
      if (typeof method === "string") {
        var resolver = Promise2.defer();
        if (this.tasks.length >= this.maxQueueSize) {
          throw new Error("Max queue size of " + this.maxQueueSize + " reached");
        }
        var tasks = this.tasks;
        var task = {
          method,
          params,
          resolver,
          timeout: null,
          options
        };
        tasks.push(task);
        var originalTimeout = resolver.promise.timeout;
        resolver.promise.timeout = /* @__PURE__ */ __name(function timeout(delay) {
          if (tasks.indexOf(task) !== -1) {
            task.timeout = delay;
            return resolver.promise;
          } else {
            return originalTimeout.call(resolver.promise, delay);
          }
        }, "timeout");
        this._next();
        return resolver.promise;
      } else if (typeof method === "function") {
        return this.exec("run", [String(method), params]);
      } else {
        throw new TypeError('Function or string expected as argument "method"');
      }
    };
    Pool.prototype.proxy = function() {
      if (arguments.length > 0) {
        throw new Error("No arguments expected");
      }
      var pool = this;
      return this.exec("methods").then(function(methods) {
        var proxy = {};
        methods.forEach(function(method) {
          proxy[method] = function() {
            return pool.exec(method, Array.prototype.slice.call(arguments));
          };
        });
        return proxy;
      });
    };
    Pool.prototype._next = function() {
      if (this.tasks.length > 0) {
        var worker3 = this._getWorker();
        if (worker3) {
          var me = this;
          var task = this.tasks.shift();
          if (task.resolver.promise.pending) {
            var promise = worker3.exec(task.method, task.params, task.resolver, task.options).then(me._boundNext).catch(function() {
              if (worker3.terminated) {
                return me._removeWorker(worker3);
              }
            }).then(function() {
              me._next();
            });
            if (typeof task.timeout === "number") {
              promise.timeout(task.timeout);
            }
          } else {
            me._next();
          }
        }
      }
    };
    Pool.prototype._getWorker = function() {
      var workers = this.workers;
      for (var i3 = 0; i3 < workers.length; i3++) {
        var worker3 = workers[i3];
        if (worker3.busy() === false) {
          return worker3;
        }
      }
      if (workers.length < this.maxWorkers) {
        worker3 = this._createWorkerHandler();
        workers.push(worker3);
        return worker3;
      }
      return null;
    };
    Pool.prototype._removeWorker = function(worker3) {
      var me = this;
      DEBUG_PORT_ALLOCATOR.releasePort(worker3.debugPort);
      this._removeWorkerFromList(worker3);
      this._ensureMinWorkers();
      return new Promise2(function(resolve10, reject) {
        worker3.terminate(false, function(err) {
          me.onTerminateWorker({
            forkArgs: worker3.forkArgs,
            forkOpts: worker3.forkOpts,
            workerThreadOpts: worker3.workerThreadOpts,
            script: worker3.script
          });
          if (err) {
            reject(err);
          } else {
            resolve10(worker3);
          }
        });
      });
    };
    Pool.prototype._removeWorkerFromList = function(worker3) {
      var index = this.workers.indexOf(worker3);
      if (index !== -1) {
        this.workers.splice(index, 1);
      }
    };
    Pool.prototype.terminate = function(force, timeout) {
      var me = this;
      this.tasks.forEach(function(task) {
        task.resolver.reject(new Error("Pool terminated"));
      });
      this.tasks.length = 0;
      var f3 = /* @__PURE__ */ __name(function(worker3) {
        DEBUG_PORT_ALLOCATOR.releasePort(worker3.debugPort);
        this._removeWorkerFromList(worker3);
      }, "f");
      var removeWorker = f3.bind(this);
      var promises3 = [];
      var workers = this.workers.slice();
      workers.forEach(function(worker3) {
        var termPromise = worker3.terminateAndNotify(force, timeout).then(removeWorker).always(function() {
          me.onTerminateWorker({
            forkArgs: worker3.forkArgs,
            forkOpts: worker3.forkOpts,
            workerThreadOpts: worker3.workerThreadOpts,
            script: worker3.script
          });
        });
        promises3.push(termPromise);
      });
      return Promise2.all(promises3);
    };
    Pool.prototype.stats = function() {
      var totalWorkers = this.workers.length;
      var busyWorkers = this.workers.filter(function(worker3) {
        return worker3.busy();
      }).length;
      return {
        totalWorkers,
        busyWorkers,
        idleWorkers: totalWorkers - busyWorkers,
        pendingTasks: this.tasks.length,
        activeTasks: busyWorkers
      };
    };
    Pool.prototype._ensureMinWorkers = function() {
      if (this.minWorkers) {
        for (var i3 = this.workers.length; i3 < this.minWorkers; i3++) {
          this.workers.push(this._createWorkerHandler());
        }
      }
    };
    Pool.prototype._createWorkerHandler = function() {
      const overriddenParams = this.onCreateWorker({
        forkArgs: this.forkArgs,
        forkOpts: this.forkOpts,
        workerOpts: this.workerOpts,
        workerThreadOpts: this.workerThreadOpts,
        script: this.script
      }) || {};
      return new WorkerHandler(overriddenParams.script || this.script, {
        forkArgs: overriddenParams.forkArgs || this.forkArgs,
        forkOpts: overriddenParams.forkOpts || this.forkOpts,
        workerOpts: overriddenParams.workerOpts || this.workerOpts,
        workerThreadOpts: overriddenParams.workerThreadOpts || this.workerThreadOpts,
        debugPort: DEBUG_PORT_ALLOCATOR.nextAvailableStartingAt(this.debugPortStart),
        workerType: this.workerType,
        workerTerminateTimeout: this.workerTerminateTimeout
      });
    };
    function validateMaxWorkers(maxWorkers) {
      if (!isNumber(maxWorkers) || !isInteger(maxWorkers) || maxWorkers < 1) {
        throw new TypeError("Option maxWorkers must be an integer number >= 1");
      }
    }
    __name(validateMaxWorkers, "validateMaxWorkers");
    function validateMinWorkers(minWorkers) {
      if (!isNumber(minWorkers) || !isInteger(minWorkers) || minWorkers < 0) {
        throw new TypeError("Option minWorkers must be an integer number >= 0");
      }
    }
    __name(validateMinWorkers, "validateMinWorkers");
    function isNumber(value) {
      return typeof value === "number";
    }
    __name(isNumber, "isNumber");
    function isInteger(value) {
      return Math.round(value) == value;
    }
    __name(isInteger, "isInteger");
    module2.exports = Pool;
  }
});

// ../../../node_modules/workerpool/src/transfer.js
var require_transfer = __commonJS({
  "../../../node_modules/workerpool/src/transfer.js"(exports2, module2) {
    function Transfer2(message2, transfer) {
      this.message = message2;
      this.transfer = transfer;
    }
    __name(Transfer2, "Transfer");
    module2.exports = Transfer2;
  }
});

// ../../../node_modules/workerpool/src/worker.js
var require_worker = __commonJS({
  "../../../node_modules/workerpool/src/worker.js"(exports, module) {
    var Transfer = require_transfer();
    var requireFoolWebpack = eval(
      `typeof require !== 'undefined' ? require : function (module) { throw new Error('Module " + module + " not found.') }`
    );
    var TERMINATE_METHOD_ID = "__workerpool-terminate__";
    var worker = {
      exit: /* @__PURE__ */ __name(function() {
      }, "exit")
    };
    if (typeof self !== "undefined" && typeof postMessage === "function" && typeof addEventListener === "function") {
      worker.on = function(event, callback) {
        addEventListener(event, function(message2) {
          callback(message2.data);
        });
      };
      worker.send = function(message2) {
        postMessage(message2);
      };
    } else if (typeof process !== "undefined") {
      try {
        WorkerThreads = requireFoolWebpack("worker_threads");
      } catch (error3) {
        if (typeof error3 === "object" && error3 !== null && error3.code === "MODULE_NOT_FOUND") {
        } else {
          throw error3;
        }
      }
      if (WorkerThreads && /* if there is a parentPort, we are in a WorkerThread */
      WorkerThreads.parentPort !== null) {
        parentPort = WorkerThreads.parentPort;
        worker.send = parentPort.postMessage.bind(parentPort);
        worker.on = parentPort.on.bind(parentPort);
        worker.exit = process.exit.bind(process);
      } else {
        worker.on = process.on.bind(process);
        worker.send = function(message2) {
          process.send(message2);
        };
        worker.on("disconnect", function() {
          process.exit(1);
        });
        worker.exit = process.exit.bind(process);
      }
    } else {
      throw new Error("Script must be executed as a worker");
    }
    var WorkerThreads;
    var parentPort;
    function convertError(error3) {
      return Object.getOwnPropertyNames(error3).reduce(function(product, name) {
        return Object.defineProperty(product, name, {
          value: error3[name],
          enumerable: true
        });
      }, {});
    }
    __name(convertError, "convertError");
    function isPromise(value) {
      return value && typeof value.then === "function" && typeof value.catch === "function";
    }
    __name(isPromise, "isPromise");
    worker.methods = {};
    worker.methods.run = /* @__PURE__ */ __name(function run(fn, args) {
      var f3 = new Function("return (" + fn + ").apply(null, arguments);");
      return f3.apply(f3, args);
    }, "run");
    worker.methods.methods = /* @__PURE__ */ __name(function methods() {
      return Object.keys(worker.methods);
    }, "methods");
    worker.terminationHandler = void 0;
    worker.cleanupAndExit = function(code) {
      var _exit = /* @__PURE__ */ __name(function() {
        worker.exit(code);
      }, "_exit");
      if (!worker.terminationHandler) {
        return _exit();
      }
      var result2 = worker.terminationHandler(code);
      if (isPromise(result2)) {
        result2.then(_exit, _exit);
      } else {
        _exit();
      }
    };
    var currentRequestId = null;
    worker.on("message", function(request2) {
      if (request2 === TERMINATE_METHOD_ID) {
        return worker.cleanupAndExit(0);
      }
      try {
        var method = worker.methods[request2.method];
        if (method) {
          currentRequestId = request2.id;
          var result2 = method.apply(method, request2.params);
          if (isPromise(result2)) {
            result2.then(function(result3) {
              if (result3 instanceof Transfer) {
                worker.send({
                  id: request2.id,
                  result: result3.message,
                  error: null
                }, result3.transfer);
              } else {
                worker.send({
                  id: request2.id,
                  result: result3,
                  error: null
                });
              }
              currentRequestId = null;
            }).catch(function(err) {
              worker.send({
                id: request2.id,
                result: null,
                error: convertError(err)
              });
              currentRequestId = null;
            });
          } else {
            if (result2 instanceof Transfer) {
              worker.send({
                id: request2.id,
                result: result2.message,
                error: null
              }, result2.transfer);
            } else {
              worker.send({
                id: request2.id,
                result: result2,
                error: null
              });
            }
            currentRequestId = null;
          }
        } else {
          throw new Error('Unknown method "' + request2.method + '"');
        }
      } catch (err) {
        worker.send({
          id: request2.id,
          result: null,
          error: convertError(err)
        });
      }
    });
    worker.register = function(methods, options) {
      if (methods) {
        for (var name in methods) {
          if (methods.hasOwnProperty(name)) {
            worker.methods[name] = methods[name];
          }
        }
      }
      if (options) {
        worker.terminationHandler = options.onTerminate;
      }
      worker.send("ready");
    };
    worker.emit = function(payload) {
      if (currentRequestId) {
        if (payload instanceof Transfer) {
          worker.send({
            id: currentRequestId,
            isEvent: true,
            payload: payload.message
          }, payload.transfer);
          return;
        }
        worker.send({
          id: currentRequestId,
          isEvent: true,
          payload
        });
      }
    };
    if (typeof exports !== "undefined") {
      exports.add = worker.register;
      exports.emit = worker.emit;
    }
  }
});

// ../../../node_modules/workerpool/src/index.js
var require_src = __commonJS({
  "../../../node_modules/workerpool/src/index.js"(exports2) {
    var environment = require_environment();
    exports2.pool = /* @__PURE__ */ __name(function pool(script, options) {
      var Pool = require_Pool();
      return new Pool(script, options);
    }, "pool");
    exports2.worker = /* @__PURE__ */ __name(function worker3(methods, options) {
      var worker4 = require_worker();
      worker4.add(methods, options);
    }, "worker");
    exports2.workerEmit = /* @__PURE__ */ __name(function workerEmit3(payload) {
      var worker3 = require_worker();
      worker3.emit(payload);
    }, "workerEmit");
    exports2.Promise = require_Promise();
    exports2.Transfer = require_transfer();
    exports2.platform = environment.platform;
    exports2.isMainThread = environment.isMainThread;
    exports2.cpus = environment.cpus;
  }
});

// ../../../node_modules/@aws-cdk/cx-api/lib/cxapi.js
var require_cxapi = __commonJS({
  "../../../node_modules/@aws-cdk/cx-api/lib/cxapi.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.SSMPARAM_NO_INVALIDATE = exports2.PROVIDER_ERROR_KEY = exports2.TOOLKIT_VERSION_ENV = exports2.CLI_VERSION_ENV = exports2.CLI_ASM_VERSION_ENV = exports2.DEFAULT_REGION_ENV = exports2.DEFAULT_ACCOUNT_ENV = exports2.CONTEXT_OVERFLOW_LOCATION_ENV = exports2.CONTEXT_ENV = exports2.OUTDIR_ENV = void 0;
    exports2.OUTDIR_ENV = "CDK_OUTDIR";
    exports2.CONTEXT_ENV = "CDK_CONTEXT_JSON";
    exports2.CONTEXT_OVERFLOW_LOCATION_ENV = "CONTEXT_OVERFLOW_LOCATION_ENV";
    exports2.DEFAULT_ACCOUNT_ENV = "CDK_DEFAULT_ACCOUNT";
    exports2.DEFAULT_REGION_ENV = "CDK_DEFAULT_REGION";
    exports2.CLI_ASM_VERSION_ENV = "CDK_CLI_ASM_VERSION";
    exports2.CLI_VERSION_ENV = "CDK_CLI_VERSION";
    exports2.TOOLKIT_VERSION_ENV = "CDK_TOOLKIT_VERSION";
    exports2.PROVIDER_ERROR_KEY = "$providerError";
    exports2.SSMPARAM_NO_INVALIDATE = "[cdk:skip]";
  }
});

// ../../../node_modules/@aws-cdk/cx-api/lib/context/vpc.js
var require_vpc = __commonJS({
  "../../../node_modules/@aws-cdk/cx-api/lib/context/vpc.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.VpcSubnetGroupType = void 0;
    var VpcSubnetGroupType2;
    (function(VpcSubnetGroupType3) {
      VpcSubnetGroupType3["PUBLIC"] = "Public";
      VpcSubnetGroupType3["PRIVATE"] = "Private";
      VpcSubnetGroupType3["ISOLATED"] = "Isolated";
    })(VpcSubnetGroupType2 || (exports2.VpcSubnetGroupType = VpcSubnetGroupType2 = {}));
  }
});

// ../../../node_modules/@aws-cdk/cx-api/lib/context/ami.js
var require_ami = __commonJS({
  "../../../node_modules/@aws-cdk/cx-api/lib/context/ami.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
  }
});

// ../../../node_modules/@aws-cdk/cx-api/lib/context/load-balancer.js
var require_load_balancer = __commonJS({
  "../../../node_modules/@aws-cdk/cx-api/lib/context/load-balancer.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.LoadBalancerIpAddressType = void 0;
    var LoadBalancerIpAddressType2;
    (function(LoadBalancerIpAddressType3) {
      LoadBalancerIpAddressType3["IPV4"] = "ipv4";
      LoadBalancerIpAddressType3["DUAL_STACK"] = "dualstack";
      LoadBalancerIpAddressType3["DUAL_STACK_WITHOUT_PUBLIC_IPV4"] = "dualstack-without-public-ipv4";
    })(LoadBalancerIpAddressType2 || (exports2.LoadBalancerIpAddressType = LoadBalancerIpAddressType2 = {}));
  }
});

// ../../../node_modules/@aws-cdk/cx-api/lib/context/availability-zones.js
var require_availability_zones = __commonJS({
  "../../../node_modules/@aws-cdk/cx-api/lib/context/availability-zones.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.AVAILABILITY_ZONE_FALLBACK_CONTEXT_KEY = void 0;
    exports2.AVAILABILITY_ZONE_FALLBACK_CONTEXT_KEY = "aws:cdk:availability-zones:fallback";
  }
});

// ../../../node_modules/@aws-cdk/cx-api/lib/context/endpoint-service-availability-zones.js
var require_endpoint_service_availability_zones = __commonJS({
  "../../../node_modules/@aws-cdk/cx-api/lib/context/endpoint-service-availability-zones.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.ENDPOINT_SERVICE_AVAILABILITY_ZONE_PROVIDER = void 0;
    exports2.ENDPOINT_SERVICE_AVAILABILITY_ZONE_PROVIDER = "endpoint-service-availability-zones";
  }
});

// ../../../node_modules/@aws-cdk/cx-api/lib/context/security-group.js
var require_security_group = __commonJS({
  "../../../node_modules/@aws-cdk/cx-api/lib/context/security-group.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
  }
});

// ../../../node_modules/@aws-cdk/cx-api/lib/context/key.js
var require_key = __commonJS({
  "../../../node_modules/@aws-cdk/cx-api/lib/context/key.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
  }
});

// ../../../node_modules/@aws-cdk/cx-api/.warnings.jsii.js
var require_warnings_jsii = __commonJS({
  "../../../node_modules/@aws-cdk/cx-api/.warnings.jsii.js"(exports2, module2) {
    function _aws_cdk_cx_api_VpcSubnetGroupType(p3) {
    }
    __name(_aws_cdk_cx_api_VpcSubnetGroupType, "_aws_cdk_cx_api_VpcSubnetGroupType");
    function _aws_cdk_cx_api_VpcSubnet(p3) {
    }
    __name(_aws_cdk_cx_api_VpcSubnet, "_aws_cdk_cx_api_VpcSubnet");
    function _aws_cdk_cx_api_VpcSubnetGroup(p3) {
      if (p3 == null)
        return;
      visitedObjects.add(p3);
      try {
        if (p3.subnets != null) {
          for (const o3 of p3.subnets)
            if (!visitedObjects.has(o3))
              _aws_cdk_cx_api_VpcSubnet(o3);
        }
        if (!visitedObjects