@jsii/runtime 1.72.0 → 1.74.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsii/runtime",
-  "version": "1.72.0",
+  "version": "1.74.0",
   "description": "jsii runtime kernel process",
   "license": "Apache-2.0",
   "author": {
@@ -34,17 +34,17 @@
     "package": "package-js"
   },
   "dependencies": {
-    "@jsii/kernel": "^1.72.0",
-    "@jsii/check-node": "1.72.0",
-    "@jsii/spec": "^1.72.0"
+    "@jsii/kernel": "^1.74.0",
+    "@jsii/check-node": "1.74.0",
+    "@jsii/spec": "^1.74.0"
   },
   "devDependencies": {
-    "@scope/jsii-calc-base": "^1.72.0",
-    "@scope/jsii-calc-lib": "^1.72.0",
-    "jsii-build-tools": "^1.72.0",
+    "@scope/jsii-calc-base": "^1.74.0",
+    "@scope/jsii-calc-lib": "^1.74.0",
+    "jsii-build-tools": "^1.74.0",
     "jsii-calc": "^3.20.120",
     "source-map-loader": "^4.0.1",
     "webpack": "^5.75.0",
-    "webpack-cli": "^5.0.0"
+    "webpack-cli": "^5.0.1"
   }
 }

package/webpack/lib/program.js

@@ -3449,7 +3449,7 @@ var __webpack_modules__ = {
                 this.piped = false;
             }
         }
-        const MiniPass = __webpack_require__(2253);
+        const MiniPass = __webpack_require__(3201);
         const zlib = __webpack_require__(3704);
         const ReadEntry = __webpack_require__(7847);
         const WriteEntry = __webpack_require__(8418);
@@ -4407,7 +4407,7 @@ var __webpack_modules__ = {
     },
     7847: (module, __unused_webpack_exports, __webpack_require__) => {
         "use strict";
-        const MiniPass = __webpack_require__(2253);
+        const MiniPass = __webpack_require__(3201);
         const normPath = __webpack_require__(4240);
         const SLURP = Symbol("slurp");
         module.exports = class ReadEntry extends MiniPass {
@@ -5459,7 +5459,7 @@ var __webpack_modules__ = {
     },
     8418: (module, __unused_webpack_exports, __webpack_require__) => {
         "use strict";
-        const MiniPass = __webpack_require__(2253);
+        const MiniPass = __webpack_require__(3201);
         const Pax = __webpack_require__(9154);
         const Header = __webpack_require__(5017);
         const fs = __webpack_require__(7147);
@@ -5914,6 +5914,451 @@ var __webpack_modules__ = {
         const getType = stat => stat.isFile() ? "File" : stat.isDirectory() ? "Directory" : stat.isSymbolicLink() ? "SymbolicLink" : "Unsupported";
         module.exports = WriteEntry;
     },
+    3201: (module, __unused_webpack_exports, __webpack_require__) => {
+        "use strict";
+        const proc = typeof process === "object" && process ? process : {
+            stdout: null,
+            stderr: null
+        };
+        const EE = __webpack_require__(2361);
+        const Stream = __webpack_require__(2781);
+        const SD = __webpack_require__(1576).StringDecoder;
+        const EOF = Symbol("EOF");
+        const MAYBE_EMIT_END = Symbol("maybeEmitEnd");
+        const EMITTED_END = Symbol("emittedEnd");
+        const EMITTING_END = Symbol("emittingEnd");
+        const EMITTED_ERROR = Symbol("emittedError");
+        const CLOSED = Symbol("closed");
+        const READ = Symbol("read");
+        const FLUSH = Symbol("flush");
+        const FLUSHCHUNK = Symbol("flushChunk");
+        const ENCODING = Symbol("encoding");
+        const DECODER = Symbol("decoder");
+        const FLOWING = Symbol("flowing");
+        const PAUSED = Symbol("paused");
+        const RESUME = Symbol("resume");
+        const BUFFER = Symbol("buffer");
+        const PIPES = Symbol("pipes");
+        const BUFFERLENGTH = Symbol("bufferLength");
+        const BUFFERPUSH = Symbol("bufferPush");
+        const BUFFERSHIFT = Symbol("bufferShift");
+        const OBJECTMODE = Symbol("objectMode");
+        const DESTROYED = Symbol("destroyed");
+        const EMITDATA = Symbol("emitData");
+        const EMITEND = Symbol("emitEnd");
+        const EMITEND2 = Symbol("emitEnd2");
+        const ASYNC = Symbol("async");
+        const defer = fn => Promise.resolve().then(fn);
+        const doIter = global._MP_NO_ITERATOR_SYMBOLS_ !== "1";
+        const ASYNCITERATOR = doIter && Symbol.asyncIterator || Symbol("asyncIterator not implemented");
+        const ITERATOR = doIter && Symbol.iterator || Symbol("iterator not implemented");
+        const isEndish = ev => ev === "end" || ev === "finish" || ev === "prefinish";
+        const isArrayBuffer = b => b instanceof ArrayBuffer || typeof b === "object" && b.constructor && b.constructor.name === "ArrayBuffer" && b.byteLength >= 0;
+        const isArrayBufferView = b => !Buffer.isBuffer(b) && ArrayBuffer.isView(b);
+        class Pipe {
+            constructor(src, dest, opts) {
+                this.src = src;
+                this.dest = dest;
+                this.opts = opts;
+                this.ondrain = () => src[RESUME]();
+                dest.on("drain", this.ondrain);
+            }
+            unpipe() {
+                this.dest.removeListener("drain", this.ondrain);
+            }
+            proxyErrors() {}
+            end() {
+                this.unpipe();
+                if (this.opts.end) this.dest.end();
+            }
+        }
+        class PipeProxyErrors extends Pipe {
+            unpipe() {
+                this.src.removeListener("error", this.proxyErrors);
+                super.unpipe();
+            }
+            constructor(src, dest, opts) {
+                super(src, dest, opts);
+                this.proxyErrors = er => dest.emit("error", er);
+                src.on("error", this.proxyErrors);
+            }
+        }
+        module.exports = class Minipass extends Stream {
+            constructor(options) {
+                super();
+                this[FLOWING] = false;
+                this[PAUSED] = false;
+                this[PIPES] = [];
+                this[BUFFER] = [];
+                this[OBJECTMODE] = options && options.objectMode || false;
+                if (this[OBJECTMODE]) this[ENCODING] = null; else this[ENCODING] = options && options.encoding || null;
+                if (this[ENCODING] === "buffer") this[ENCODING] = null;
+                this[ASYNC] = options && !!options.async || false;
+                this[DECODER] = this[ENCODING] ? new SD(this[ENCODING]) : null;
+                this[EOF] = false;
+                this[EMITTED_END] = false;
+                this[EMITTING_END] = false;
+                this[CLOSED] = false;
+                this[EMITTED_ERROR] = null;
+                this.writable = true;
+                this.readable = true;
+                this[BUFFERLENGTH] = 0;
+                this[DESTROYED] = false;
+                if (options && options.debugExposeBuffer === true) {
+                    Object.defineProperty(this, "buffer", {
+                        get: () => this[BUFFER]
+                    });
+                }
+                if (options && options.debugExposePipes === true) {
+                    Object.defineProperty(this, "pipes", {
+                        get: () => this[PIPES]
+                    });
+                }
+            }
+            get bufferLength() {
+                return this[BUFFERLENGTH];
+            }
+            get encoding() {
+                return this[ENCODING];
+            }
+            set encoding(enc) {
+                if (this[OBJECTMODE]) throw new Error("cannot set encoding in objectMode");
+                if (this[ENCODING] && enc !== this[ENCODING] && (this[DECODER] && this[DECODER].lastNeed || this[BUFFERLENGTH])) throw new Error("cannot change encoding");
+                if (this[ENCODING] !== enc) {
+                    this[DECODER] = enc ? new SD(enc) : null;
+                    if (this[BUFFER].length) this[BUFFER] = this[BUFFER].map((chunk => this[DECODER].write(chunk)));
+                }
+                this[ENCODING] = enc;
+            }
+            setEncoding(enc) {
+                this.encoding = enc;
+            }
+            get objectMode() {
+                return this[OBJECTMODE];
+            }
+            set objectMode(om) {
+                this[OBJECTMODE] = this[OBJECTMODE] || !!om;
+            }
+            get ["async"]() {
+                return this[ASYNC];
+            }
+            set ["async"](a) {
+                this[ASYNC] = this[ASYNC] || !!a;
+            }
+            write(chunk, encoding, cb) {
+                if (this[EOF]) throw new Error("write after end");
+                if (this[DESTROYED]) {
+                    this.emit("error", Object.assign(new Error("Cannot call write after a stream was destroyed"), {
+                        code: "ERR_STREAM_DESTROYED"
+                    }));
+                    return true;
+                }
+                if (typeof encoding === "function") cb = encoding, encoding = "utf8";
+                if (!encoding) encoding = "utf8";
+                const fn = this[ASYNC] ? defer : f => f();
+                if (!this[OBJECTMODE] && !Buffer.isBuffer(chunk)) {
+                    if (isArrayBufferView(chunk)) chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength); else if (isArrayBuffer(chunk)) chunk = Buffer.from(chunk); else if (typeof chunk !== "string") this.objectMode = true;
+                }
+                if (this[OBJECTMODE]) {
+                    if (this.flowing && this[BUFFERLENGTH] !== 0) this[FLUSH](true);
+                    if (this.flowing) this.emit("data", chunk); else this[BUFFERPUSH](chunk);
+                    if (this[BUFFERLENGTH] !== 0) this.emit("readable");
+                    if (cb) fn(cb);
+                    return this.flowing;
+                }
+                if (!chunk.length) {
+                    if (this[BUFFERLENGTH] !== 0) this.emit("readable");
+                    if (cb) fn(cb);
+                    return this.flowing;
+                }
+                if (typeof chunk === "string" && !(encoding === this[ENCODING] && !this[DECODER].lastNeed)) {
+                    chunk = Buffer.from(chunk, encoding);
+                }
+                if (Buffer.isBuffer(chunk) && this[ENCODING]) chunk = this[DECODER].write(chunk);
+                if (this.flowing && this[BUFFERLENGTH] !== 0) this[FLUSH](true);
+                if (this.flowing) this.emit("data", chunk); else this[BUFFERPUSH](chunk);
+                if (this[BUFFERLENGTH] !== 0) this.emit("readable");
+                if (cb) fn(cb);
+                return this.flowing;
+            }
+            read(n) {
+                if (this[DESTROYED]) return null;
+                if (this[BUFFERLENGTH] === 0 || n === 0 || n > this[BUFFERLENGTH]) {
+                    this[MAYBE_EMIT_END]();
+                    return null;
+                }
+                if (this[OBJECTMODE]) n = null;
+                if (this[BUFFER].length > 1 && !this[OBJECTMODE]) {
+                    if (this.encoding) this[BUFFER] = [ this[BUFFER].join("") ]; else this[BUFFER] = [ Buffer.concat(this[BUFFER], this[BUFFERLENGTH]) ];
+                }
+                const ret = this[READ](n || null, this[BUFFER][0]);
+                this[MAYBE_EMIT_END]();
+                return ret;
+            }
+            [READ](n, chunk) {
+                if (n === chunk.length || n === null) this[BUFFERSHIFT](); else {
+                    this[BUFFER][0] = chunk.slice(n);
+                    chunk = chunk.slice(0, n);
+                    this[BUFFERLENGTH] -= n;
+                }
+                this.emit("data", chunk);
+                if (!this[BUFFER].length && !this[EOF]) this.emit("drain");
+                return chunk;
+            }
+            end(chunk, encoding, cb) {
+                if (typeof chunk === "function") cb = chunk, chunk = null;
+                if (typeof encoding === "function") cb = encoding, encoding = "utf8";
+                if (chunk) this.write(chunk, encoding);
+                if (cb) this.once("end", cb);
+                this[EOF] = true;
+                this.writable = false;
+                if (this.flowing || !this[PAUSED]) this[MAYBE_EMIT_END]();
+                return this;
+            }
+            [RESUME]() {
+                if (this[DESTROYED]) return;
+                this[PAUSED] = false;
+                this[FLOWING] = true;
+                this.emit("resume");
+                if (this[BUFFER].length) this[FLUSH](); else if (this[EOF]) this[MAYBE_EMIT_END](); else this.emit("drain");
+            }
+            resume() {
+                return this[RESUME]();
+            }
+            pause() {
+                this[FLOWING] = false;
+                this[PAUSED] = true;
+            }
+            get destroyed() {
+                return this[DESTROYED];
+            }
+            get flowing() {
+                return this[FLOWING];
+            }
+            get paused() {
+                return this[PAUSED];
+            }
+            [BUFFERPUSH](chunk) {
+                if (this[OBJECTMODE]) this[BUFFERLENGTH] += 1; else this[BUFFERLENGTH] += chunk.length;
+                this[BUFFER].push(chunk);
+            }
+            [BUFFERSHIFT]() {
+                if (this[BUFFER].length) {
+                    if (this[OBJECTMODE]) this[BUFFERLENGTH] -= 1; else this[BUFFERLENGTH] -= this[BUFFER][0].length;
+                }
+                return this[BUFFER].shift();
+            }
+            [FLUSH](noDrain) {
+                do {} while (this[FLUSHCHUNK](this[BUFFERSHIFT]()));
+                if (!noDrain && !this[BUFFER].length && !this[EOF]) this.emit("drain");
+            }
+            [FLUSHCHUNK](chunk) {
+                return chunk ? (this.emit("data", chunk), this.flowing) : false;
+            }
+            pipe(dest, opts) {
+                if (this[DESTROYED]) return;
+                const ended = this[EMITTED_END];
+                opts = opts || {};
+                if (dest === proc.stdout || dest === proc.stderr) opts.end = false; else opts.end = opts.end !== false;
+                opts.proxyErrors = !!opts.proxyErrors;
+                if (ended) {
+                    if (opts.end) dest.end();
+                } else {
+                    this[PIPES].push(!opts.proxyErrors ? new Pipe(this, dest, opts) : new PipeProxyErrors(this, dest, opts));
+                    if (this[ASYNC]) defer((() => this[RESUME]())); else this[RESUME]();
+                }
+                return dest;
+            }
+            unpipe(dest) {
+                const p = this[PIPES].find((p => p.dest === dest));
+                if (p) {
+                    this[PIPES].splice(this[PIPES].indexOf(p), 1);
+                    p.unpipe();
+                }
+            }
+            addListener(ev, fn) {
+                return this.on(ev, fn);
+            }
+            on(ev, fn) {
+                const ret = super.on(ev, fn);
+                if (ev === "data" && !this[PIPES].length && !this.flowing) this[RESUME](); else if (ev === "readable" && this[BUFFERLENGTH] !== 0) super.emit("readable"); else if (isEndish(ev) && this[EMITTED_END]) {
+                    super.emit(ev);
+                    this.removeAllListeners(ev);
+                } else if (ev === "error" && this[EMITTED_ERROR]) {
+                    if (this[ASYNC]) defer((() => fn.call(this, this[EMITTED_ERROR]))); else fn.call(this, this[EMITTED_ERROR]);
+                }
+                return ret;
+            }
+            get emittedEnd() {
+                return this[EMITTED_END];
+            }
+            [MAYBE_EMIT_END]() {
+                if (!this[EMITTING_END] && !this[EMITTED_END] && !this[DESTROYED] && this[BUFFER].length === 0 && this[EOF]) {
+                    this[EMITTING_END] = true;
+                    this.emit("end");
+                    this.emit("prefinish");
+                    this.emit("finish");
+                    if (this[CLOSED]) this.emit("close");
+                    this[EMITTING_END] = false;
+                }
+            }
+            emit(ev, data, ...extra) {
+                if (ev !== "error" && ev !== "close" && ev !== DESTROYED && this[DESTROYED]) return; else if (ev === "data") {
+                    return !data ? false : this[ASYNC] ? defer((() => this[EMITDATA](data))) : this[EMITDATA](data);
+                } else if (ev === "end") {
+                    return this[EMITEND]();
+                } else if (ev === "close") {
+                    this[CLOSED] = true;
+                    if (!this[EMITTED_END] && !this[DESTROYED]) return;
+                    const ret = super.emit("close");
+                    this.removeAllListeners("close");
+                    return ret;
+                } else if (ev === "error") {
+                    this[EMITTED_ERROR] = data;
+                    const ret = super.emit("error", data);
+                    this[MAYBE_EMIT_END]();
+                    return ret;
+                } else if (ev === "resume") {
+                    const ret = super.emit("resume");
+                    this[MAYBE_EMIT_END]();
+                    return ret;
+                } else if (ev === "finish" || ev === "prefinish") {
+                    const ret = super.emit(ev);
+                    this.removeAllListeners(ev);
+                    return ret;
+                }
+                const ret = super.emit(ev, data, ...extra);
+                this[MAYBE_EMIT_END]();
+                return ret;
+            }
+            [EMITDATA](data) {
+                for (const p of this[PIPES]) {
+                    if (p.dest.write(data) === false) this.pause();
+                }
+                const ret = super.emit("data", data);
+                this[MAYBE_EMIT_END]();
+                return ret;
+            }
+            [EMITEND]() {
+                if (this[EMITTED_END]) return;
+                this[EMITTED_END] = true;
+                this.readable = false;
+                if (this[ASYNC]) defer((() => this[EMITEND2]())); else this[EMITEND2]();
+            }
+            [EMITEND2]() {
+                if (this[DECODER]) {
+                    const data = this[DECODER].end();
+                    if (data) {
+                        for (const p of this[PIPES]) {
+                            p.dest.write(data);
+                        }
+                        super.emit("data", data);
+                    }
+                }
+                for (const p of this[PIPES]) {
+                    p.end();
+                }
+                const ret = super.emit("end");
+                this.removeAllListeners("end");
+                return ret;
+            }
+            collect() {
+                const buf = [];
+                if (!this[OBJECTMODE]) buf.dataLength = 0;
+                const p = this.promise();
+                this.on("data", (c => {
+                    buf.push(c);
+                    if (!this[OBJECTMODE]) buf.dataLength += c.length;
+                }));
+                return p.then((() => buf));
+            }
+            concat() {
+                return this[OBJECTMODE] ? Promise.reject(new Error("cannot concat in objectMode")) : this.collect().then((buf => this[OBJECTMODE] ? Promise.reject(new Error("cannot concat in objectMode")) : this[ENCODING] ? buf.join("") : Buffer.concat(buf, buf.dataLength)));
+            }
+            promise() {
+                return new Promise(((resolve, reject) => {
+                    this.on(DESTROYED, (() => reject(new Error("stream destroyed"))));
+                    this.on("error", (er => reject(er)));
+                    this.on("end", (() => resolve()));
+                }));
+            }
+            [ASYNCITERATOR]() {
+                const next = () => {
+                    const res = this.read();
+                    if (res !== null) return Promise.resolve({
+                        done: false,
+                        value: res
+                    });
+                    if (this[EOF]) return Promise.resolve({
+                        done: true
+                    });
+                    let resolve = null;
+                    let reject = null;
+                    const onerr = er => {
+                        this.removeListener("data", ondata);
+                        this.removeListener("end", onend);
+                        reject(er);
+                    };
+                    const ondata = value => {
+                        this.removeListener("error", onerr);
+                        this.removeListener("end", onend);
+                        this.pause();
+                        resolve({
+                            value,
+                            done: !!this[EOF]
+                        });
+                    };
+                    const onend = () => {
+                        this.removeListener("error", onerr);
+                        this.removeListener("data", ondata);
+                        resolve({
+                            done: true
+                        });
+                    };
+                    const ondestroy = () => onerr(new Error("stream destroyed"));
+                    return new Promise(((res, rej) => {
+                        reject = rej;
+                        resolve = res;
+                        this.once(DESTROYED, ondestroy);
+                        this.once("error", onerr);
+                        this.once("end", onend);
+                        this.once("data", ondata);
+                    }));
+                };
+                return {
+                    next
+                };
+            }
+            [ITERATOR]() {
+                const next = () => {
+                    const value = this.read();
+                    const done = value === null;
+                    return {
+                        value,
+                        done
+                    };
+                };
+                return {
+                    next
+                };
+            }
+            destroy(er) {
+                if (this[DESTROYED]) {
+                    if (er) this.emit("error", er); else this.emit(DESTROYED);
+                    return this;
+                }
+                this[DESTROYED] = true;
+                this[BUFFER].length = 0;
+                this[BUFFERLENGTH] = 0;
+                if (typeof this.close === "function" && !this[CLOSED]) this.close();
+                if (er) this.emit("error", er); else this.emit(DESTROYED);
+                return this;
+            }
+            static isStream(s) {
+                return !!s && (s instanceof Minipass || s instanceof Stream || s instanceof EE && (typeof s.pipe === "function" || typeof s.write === "function" && typeof s.end === "function"));
+            }
+        };
+    },
     3459: (__unused_webpack_module, exports) => {
         "use strict";
         exports.fromCallback = function(fn) {
@@ -13808,7 +14253,7 @@ var __webpack_modules__ = {
                     strictTypesError(it, `type "${t}" not allowed by context "${it.dataTypes.join(",")}"`);
                 }
             }));
-            it.dataTypes = it.dataTypes.filter((t => includesType(types, t)));
+            narrowSchemaTypes(it, types);
         }
         function checkMultipleTypes(it, ts) {
             if (ts.length > 1 && !(ts.length === 2 && ts.includes("null"))) {
@@ -13833,6 +14278,13 @@ var __webpack_modules__ = {
         function includesType(ts, t) {
             return ts.includes(t) || t === "integer" && ts.includes("number");
         }
+        function narrowSchemaTypes(it, withTypes) {
+            const ts = [];
+            for (const t of it.dataTypes) {
+                if (includesType(withTypes, t)) ts.push(t); else if (withTypes.includes("integer") && t === "number") ts.push("integer");
+            }
+            it.dataTypes = ts;
+        }
         function strictTypesError(it, msg) {
             const schemaPath = it.schemaEnv.baseId + it.errSchemaPath;
             msg += ` at "${schemaPath}" (strictTypes)`;
@@ -16798,7 +17250,7 @@ var __webpack_modules__ = {
     },
     4147: module => {
         "use strict";
-        module.exports = JSON.parse('{"name":"@jsii/runtime","version":"1.72.0","description":"jsii runtime kernel process","license":"Apache-2.0","author":{"name":"Amazon Web Services","url":"https://aws.amazon.com"},"homepage":"https://github.com/aws/jsii","bugs":{"url":"https://github.com/aws/jsii/issues"},"repository":{"type":"git","url":"https://github.com/aws/jsii.git","directory":"packages/@jsii/runtime"},"engines":{"node":">= 14.6.0"},"main":"lib/index.js","types":"lib/index.d.ts","bin":{"jsii-runtime":"bin/jsii-runtime"},"scripts":{"build":"tsc --build && chmod +x bin/jsii-runtime && npx webpack-cli && npm run lint","watch":"tsc --build -w","lint":"eslint . --ext .js,.ts --ignore-path=.gitignore --ignore-pattern=webpack.config.js","lint:fix":"yarn lint --fix","test":"jest","test:update":"jest -u","package":"package-js"},"dependencies":{"@jsii/kernel":"^1.72.0","@jsii/check-node":"1.72.0","@jsii/spec":"^1.72.0"},"devDependencies":{"@scope/jsii-calc-base":"^1.72.0","@scope/jsii-calc-lib":"^1.72.0","jsii-build-tools":"^1.72.0","jsii-calc":"^3.20.120","source-map-loader":"^4.0.1","webpack":"^5.75.0","webpack-cli":"^5.0.0"}}');
+        module.exports = JSON.parse('{"name":"@jsii/runtime","version":"1.74.0","description":"jsii runtime kernel process","license":"Apache-2.0","author":{"name":"Amazon Web Services","url":"https://aws.amazon.com"},"homepage":"https://github.com/aws/jsii","bugs":{"url":"https://github.com/aws/jsii/issues"},"repository":{"type":"git","url":"https://github.com/aws/jsii.git","directory":"packages/@jsii/runtime"},"engines":{"node":">= 14.6.0"},"main":"lib/index.js","types":"lib/index.d.ts","bin":{"jsii-runtime":"bin/jsii-runtime"},"scripts":{"build":"tsc --build && chmod +x bin/jsii-runtime && npx webpack-cli && npm run lint","watch":"tsc --build -w","lint":"eslint . --ext .js,.ts --ignore-path=.gitignore --ignore-pattern=webpack.config.js","lint:fix":"yarn lint --fix","test":"jest","test:update":"jest -u","package":"package-js"},"dependencies":{"@jsii/kernel":"^1.74.0","@jsii/check-node":"1.74.0","@jsii/spec":"^1.74.0"},"devDependencies":{"@scope/jsii-calc-base":"^1.74.0","@scope/jsii-calc-lib":"^1.74.0","jsii-build-tools":"^1.74.0","jsii-calc":"^3.20.120","source-map-loader":"^4.0.1","webpack":"^5.75.0","webpack-cli":"^5.0.1"}}');
     },
     5277: module => {
         "use strict";