@depup/webpack 5.110.3-depup.0 → 5.111.1-depup.0

package/lib/util/LocConverter.js

@@ -63,13 +63,10 @@ class LocConverter {
 				// Retreat on line 1: no `\n` precedes `pos`, the cache stays valid.
 				this.column = pos;
 			} else {
-				// Retreat: count newlines crossed in (pos, this.pos), i.e.
-				// exclude the newline at `this.pos` itself. By convention a
-				// `\n` is the last column of its line, so when `this.pos`
-				// sits on one we're already on the line containing it; only
-				// newlines strictly **before** `this.pos` and at-or-after
-				// `pos` represent crossed line boundaries. The smallest
-				// crossed one is the next newline after the new position.
+				// WHY: A `\n` counts as the last column of its own line here, so a
+				// `this.pos` sitting on one is already on that line. Retreating
+				// therefore crosses only the newlines at or after `pos` and strictly
+				// before `this.pos` — the newline at `this.pos` is not one of them.
 				let i = input.lastIndexOf("\n", this.pos - 1);
 				while (i >= pos) {
 					this._nextNewline = i;

package/lib/util/SourceProcessor.js

@@ -261,20 +261,20 @@ class PrintContext {
 		/** @type {NodePrinter<TPath, TNode, TPrintOptions>} */
 		this._printer = printer;
 		// Printed text by node handle, in two columns rather than one `Map`: the
-		// handles are dense integers, and a stylesheet prints ~300k nodes through
-		// a store that never holds more than a few dozen of them at once.
+		// handles are dense integers, and `_moveEpoch` keeps the live set small.
 		/** @type {string[]} each finished node's printed text */
 		this._storeText = [];
 		/** @type {Int32Array} the epoch each slot was written in */
 		this._storeGen = new Int32Array(0);
 		/** @type {number} current epoch; a slot from an older one reads as absent */
 		this._gen = 1;
-		// Output accumulates into `_tail`, a plain string append, so printing that
-		// never takes anything back costs exactly what appending to one string
-		// costs. A piece is cut off into `_chunks` only for text that may still be
-		// taken back ({@link emitRetractable}) — that is what lets a printer emit
-		// before it knows a later sibling overrides it, without every other emit
-		// paying for the ability. The output is `_chunks` joined, then `_tail`.
+		/** @type {number} lowest slot written since the epoch last moved */
+		this._storeLow = 0x7fffffff;
+		/** @type {number} highest slot written since the epoch last moved */
+		this._storeHigh = -1;
+		// Output is `_chunks` joined, then `_tail`. Printing that never takes
+		// anything back only appends to `_tail`; a piece is cut off into `_chunks`
+		// for retractable text alone, so no other emit pays for that ability.
 		/** @type {string[]} pieces already cut off, in output order */
 		this._chunks = [];
 		/** @type {string} output after the last cut piece */
@@ -285,7 +285,7 @@ class PrintContext {
 		this._flattened = 0;
 		/** @type {[number, number, number, number][]} `[chunkIndex, offsetInChunk, srcLine, srcCol]`, output-ordered; a `srcLine` of -1 is one {@link retract} took back with its piece */
 		this._mappings = [];
-		/** @type {Map<number, number> | null} a retractable piece -> the mapping anchored to it, so taking the piece back takes its mapping too */
+		/** @type {number[] | null} by retractable piece index, the mapping anchored to it, so taking the piece back takes its mapping too */
 		this._retractableMappings = null;
 		// A map is built only for a caller that named the input, and that is known
 		// before printing — so a print nobody asks a map of collects none.
@@ -296,10 +296,9 @@ class PrintContext {
 		this._inserts = [];
 		/** @type {number} next `_inserts` entry not yet flushed */
 		this._insertIdx = 0;
-		// Openers of the nodes being printed in pieces, innermost last, held back
-		// until one of them turns out to have content: a node whose children all
-		// print to nothing can then still be dropped whole, which is the one thing
-		// emitting an opener eagerly would give up.
+		// Openers of the nodes printed in pieces, innermost last, held back until
+		// one has content — which is what lets a node whose children all print to
+		// nothing still be dropped whole.
 		/** @type {string[]} openers not yet emitted, outermost first */
 		this._pending = [];
 		/** @type {[number | undefined, number | undefined, number | undefined] | null} anchor for the first pending opener */
@@ -424,8 +423,25 @@ class PrintContext {
 	 * node's text.
 	 */
 	dropStore() {
-		// Bumping the epoch invalidates every slot at once, so this stays O(1) —
-		// it runs per node, and clearing a column by length would not.
+		this._moveEpoch();
+	}
+
+	/**
+	 * Move the epoch on and release the text every slot written under the old one
+	 * holds. Only the range actually written is walked, so the drop stays O(1)
+	 * per node.
+	 * @returns {void}
+	 */
+	_moveEpoch() {
+		const high = this._storeHigh;
+		if (high !== -1) {
+			// `""` rather than a hole: the column is packed, and a hole in it would
+			// cost every read after this one.
+			const text = this._storeText;
+			for (let i = this._storeLow; i <= high; i++) text[i] = "";
+			this._storeLow = 0x7fffffff;
+			this._storeHigh = -1;
+		}
 		this._gen++;
 	}
 
@@ -469,6 +485,8 @@ class PrintContext {
 		if (n >= this._storeText.length) this._growStore(n + 1);
 		this._storeText[n] = text;
 		this._storeGen[n] = this._gen;
+		if (n < this._storeLow) this._storeLow = n;
+		if (n > this._storeHigh) this._storeHigh = n;
 	}
 
 	/**
@@ -502,14 +520,12 @@ class PrintContext {
 	_emit(text) {
 		this._tail += text;
 		this._tailLength += text.length;
-		// A printer returns its text as a rope of its children's pieces, and
-		// appending a rope onto a rope keeps every fragment of every node reachable
-		// until the output is finally flattened — on a stylesheet of many top-level
-		// rules, a second copy of the whole output. So cut the tail off once it has
-		// grown past a block and force that block flat, which drops every fragment
-		// behind it. Per block rather than per piece: the flattening copy is one
-		// the result would have paid for anyway, but paying it per piece means an
-		// allocation for each, and the pieces are small.
+		// WHY: A printer returns a rope of its children's pieces, and appending a
+		// rope onto a rope keeps every fragment reachable until the output is
+		// flattened — a second copy of a large stylesheet. Cutting the tail once it
+		// passes a block forces that block flat and drops the fragments behind it.
+		// Per block rather than per piece: the copy is one the result pays anyway,
+		// while per piece it would be an allocation each, and the pieces are small.
 		if (this._tailLength >= FLATTEN_BLOCK) this._cutTail();
 	}
 
@@ -552,7 +568,7 @@ class PrintContext {
 	retract(index) {
 		this._chunks[index] = "";
 		if (this._retractableMappings === null) return;
-		const mapping = this._retractableMappings.get(index);
+		const mapping = this._retractableMappings[index];
 		if (mapping !== undefined) this._mappings[mapping][2] = -1;
 	}
 
@@ -598,12 +614,12 @@ class PrintContext {
 		this.anchor(srcOffset, srcLine, srcCol);
 		const mapping = this._mappings.length > before ? before : -1;
 		const at = this.emitRetractable(text === undefined ? this.get(node) : text);
-		this._gen++;
+		this._moveEpoch();
 		if (mapping !== -1) {
-			if (this._retractableMappings === null) {
-				this._retractableMappings = new Map();
-			}
-			this._retractableMappings.set(at, mapping);
+			// Indexed by piece rather than a `Map`: pieces are dense integers, and
+			// nearly every rule minifying goes out as one.
+			if (this._retractableMappings === null) this._retractableMappings = [];
+			this._retractableMappings[at] = mapping;
 		}
 		return at;
 	}
@@ -627,7 +643,7 @@ class PrintContext {
 		this._emit(
 			text === undefined ? this.get(/** @type {TNode} */ (node)) : text
 		);
-		this._gen++;
+		this._moveEpoch();
 	}
 
 	/**
@@ -739,68 +755,44 @@ class PrintContext {
 
 	/**
 	 * @param {SourceMapOptions} options the input's name / content
+	 * @param {string=} code the output {@link result} built, walked for its line breaks
 	 * @returns {SourceMap} the input->output source map
 	 */
-	sourceMap(options) {
+	sourceMap(options, code) {
 		let out = "";
 		let genLine = 0;
 		let genCol = 0;
 		let srcLine = 0;
 		let srcCol = 0;
 		let atLineStart = true;
-		// Where each anchor landed, walked once alongside the mappings — both are
-		// in output order, so this is one pass over the output, not a position
-		// recomputed per mapping. An anchor can sit inside a piece rather than at
-		// its start, since output accumulates into the piece it is appending to.
+		// Walked over the flat output rather than piece by piece: a piece is a rope
+		// until something reads it, and reading each one flattens each one.
+		const text = code === undefined ? this.result() : code;
 		const chunks = this._chunks;
-		const tail = this._tail;
-		/**
-		 * @param {number} i piece index, `chunks.length` being the tail
-		 * @returns {string} that piece
-		 */
-		const pieceAt = (i) => (i === chunks.length ? tail : chunks[i]);
 		let atChunk = 0;
+		let chunkStart = 0;
 		let atOffset = 0;
 		let atLine = 0;
 		let atCol = 0;
-		// Offset of the next newline at or after the cursor, `-1` for none left in
-		// this piece. Carried rather than searched for per mapping: `indexOf` has no
-		// end bound, so asking it again for each of a piece's mappings scans again to
-		// the end of the piece every time — and minified output, the case with no
-		// newlines at all, is the one where that is the whole piece.
-		let nextNewline = pieceAt(0).indexOf("\n");
-		/**
-		 * @param {string} text the piece to walk
-		 * @param {number} to offset to walk to
-		 */
-		const advanceOver = (text, to) => {
-			while (nextNewline !== -1 && nextNewline < to) {
-				atLine++;
-				atCol = 0;
-				atOffset = nextNewline + 1;
-				nextNewline = text.indexOf("\n", atOffset);
-			}
-			atCol += to - atOffset;
-			atOffset = to;
-		};
-		/**
-		 * @param {number} chunk piece index to advance to
-		 * @param {number} offset offset within it
-		 */
-		const advanceTo = (chunk, offset) => {
-			while (atChunk < chunk) {
-				const text = pieceAt(atChunk);
-				advanceOver(text, text.length);
-				atChunk++;
-				atOffset = 0;
-				nextNewline = pieceAt(atChunk).indexOf("\n");
-			}
-			if (offset > atOffset) advanceOver(pieceAt(atChunk), offset);
-		};
+		// Offset of the next newline at or after the cursor, `-1` for none left.
+		// Carried rather than searched for per mapping: `indexOf` has no end bound.
+		let nextNewline = text.indexOf("\n");
 		for (const [chunkIndex, chunkOffset, sl, sc] of this._mappings) {
 			// Its piece was taken back, so there is no output left to anchor.
 			if (sl === -1) continue;
-			advanceTo(chunkIndex, chunkOffset);
+			// A piece's length is stored, so summing them costs nothing per byte.
+			while (atChunk < chunkIndex) chunkStart += chunks[atChunk++].length;
+			const to = chunkStart + chunkOffset;
+			if (to > atOffset) {
+				while (nextNewline !== -1 && nextNewline < to) {
+					atLine++;
+					atCol = 0;
+					atOffset = nextNewline + 1;
+					nextNewline = text.indexOf("\n", atOffset);
+				}
+				atCol += to - atOffset;
+				atOffset = to;
+			}
 			const gl = atLine;
 			const gc = atCol;
 			while (genLine < gl) {
@@ -915,7 +907,11 @@ class PrintContext {
 		if (this._insertIdx < this._inserts.length) this._flushBefore(Infinity);
 		// Nothing was ever cut into its own piece, so there is nothing to join.
 		const chunks = this._chunks;
-		return chunks.length === 0 ? this._tail : chunks.join("") + this._tail;
+		if (chunks.length === 0) return this._tail;
+		// The tail joins as a piece of its own, so the output comes back flat
+		// rather than as a rope over the join that every reader flattens again.
+		this._cutTail();
+		return chunks.join("");
 	}
 }
 
@@ -1018,10 +1014,9 @@ class SourceProcessor {
 			this._grammar(input, this._visitors, undefined, opts);
 			return undefined;
 		}
-		// Handed over whole rather than copied entry by entry: which of them are
-		// print options is the language's to say, and listing them here is what
-		// made every new one an edit to this file. A grammar-only entry riding
-		// along is inert — a printer reads only what its own type declares.
+		// Handed over whole rather than copied entry by entry: which entries are
+		// print options is the language's to say, and a grammar-only one riding
+		// along is inert, since a printer reads only what its own type declares.
 		const ctx = new PrintContext(
 			/** @type {PrintOptions & TPrintOptions} */ (
 				/** @type {unknown} */ ({ ...opts, mode: asked })
@@ -1030,16 +1025,21 @@ class SourceProcessor {
 		);
 		this._grammar(input, this._visitors, ctx, opts);
 		const name = /** @type {{ source?: string, content?: string }} */ (opts);
-		const build = () => ({
-			code: ctx.result(),
-			// Built only for a caller that named the input: building one walks the
-			// whole output for its line breaks, and the minifier prints an inline
-			// `style=""` — which asks for no map — thousands of times a document.
-			map:
-				name.source === undefined
-					? undefined
-					: ctx.sourceMap({ source: name.source, content: name.content })
-		});
+		const build = () => {
+			const code = ctx.result();
+			return {
+				code,
+				// Built only for a caller that named the input: a map walks the whole
+				// output, and an inline `style=""` asks for none thousands of times a page.
+				map:
+					name.source === undefined
+						? undefined
+						: ctx.sourceMap(
+								{ source: name.source, content: name.content },
+								code
+							)
+			};
+		};
 		if (this._deferred !== null) {
 			const finish = this._deferred;
 

package/lib/util/async.js

@@ -0,0 +1,292 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+/**
+ * Wraps the shared completion callback for one item, so an iterator that
+ * reports twice fails loudly instead of settling the run early.
+ * @template E
+ * @param {(err?: E | null) => void} done shared completion callback
+ * @returns {(err?: E | null) => void} completion callback for a single item
+ */
+const once = (done) => {
+	/** @type {((err?: E | null) => void) | undefined} */
+	let pending = done;
+	return (err) => {
+		const fn = pending;
+		if (fn === undefined) throw new Error("Callback was already called");
+		pending = undefined;
+		fn(err);
+	};
+};
+
+/**
+ * Runs `iterator` over every item with unlimited concurrency.
+ * Every item is started from one flat loop, so a synchronous iterator never
+ * grows the stack.
+ * @template T
+ * @template E
+ * @param {Iterable<T>} collection items to iterate
+ * @param {(item: T, callback: (err?: E | null) => void) => void} iterator called once per item
+ * @param {(err?: E | null) => void} callback called when every item is done, or with the first error
+ * @returns {void}
+ */
+const each = (collection, iterator, callback) => {
+	let remaining = 1;
+	let finished = false;
+
+	/**
+	 * @param {(E | null)=} err error
+	 * @returns {void}
+	 */
+	const done = (err) => {
+		if (finished) return;
+		if (err) {
+			finished = true;
+			callback(err);
+			return;
+		}
+		if (--remaining === 0) {
+			finished = true;
+			callback(null);
+		}
+	};
+
+	if (Array.isArray(collection)) {
+		const array = /** @type {T[]} */ (collection);
+		const length = array.length;
+		if (length === 0) return callback(null);
+		remaining = length;
+		// Dispatching continues past an error on purpose: callers rely on every
+		// item being started, e.g. to close every watcher when one close fails.
+		for (let i = 0; i < length; i++) iterator(array[i], once(done));
+		return;
+	}
+
+	// `remaining` starts at 1 so that completion cannot fire while items of a
+	// collection of unknown length are still being dispatched.
+	for (const item of collection) {
+		remaining++;
+		iterator(item, once(done));
+	}
+	done(null);
+};
+
+/**
+ * Runs `iterator` over every item, keeping at most `limit` of them in flight.
+ * A synchronous iterator is drained by the dispatch loop instead of by
+ * recursion, so the stack stays flat however long the collection is.
+ * @template T
+ * @template E
+ * @param {Iterable<T>} collection items to iterate
+ * @param {number} limit maximum number of items in flight
+ * @param {(item: T, callback: (err?: E | null) => void) => void} iterator called once per item
+ * @param {(err?: E | null) => void} callback called when every item is done, or with the first error
+ * @returns {void}
+ */
+const eachLimit = (collection, limit, iterator, callback) => {
+	const array = Array.isArray(collection)
+		? /** @type {T[]} */ (collection)
+		: undefined;
+	const length = array === undefined ? 0 : array.length;
+	const values =
+		array === undefined ? collection[Symbol.iterator]() : undefined;
+	let index = 0;
+	let running = 0;
+	let exhausted = false;
+	let finished = false;
+	let dispatching = false;
+
+	const dispatch = () => {
+		// A re-entrant call returns at once; the loop already running sees the
+		// slot the completed item freed and takes the next one itself.
+		if (dispatching) return;
+		dispatching = true;
+		while (running < limit && !exhausted) {
+			// `finished` is set from `done`, which an iterator may call before it
+			// returns, so it has to be re-read on every turn of this loop.
+			if (finished) break;
+			/** @type {T} */
+			let item;
+			if (array === undefined) {
+				const next = /** @type {Iterator<T>} */ (values).next();
+				if (next.done) {
+					exhausted = true;
+					break;
+				}
+				item = next.value;
+			} else {
+				if (index === length) {
+					exhausted = true;
+					break;
+				}
+				item = array[index++];
+			}
+			running++;
+			iterator(item, once(done));
+		}
+		dispatching = false;
+		if (exhausted && running === 0 && !finished) {
+			finished = true;
+			callback(null);
+		}
+	};
+
+	/**
+	 * @param {(E | null)=} err error
+	 * @returns {void}
+	 */
+	const done = (err) => {
+		if (finished) return;
+		running--;
+		if (err) {
+			finished = true;
+			callback(err);
+			return;
+		}
+		dispatch();
+	};
+
+	if (limit < 1) return callback(null);
+
+	dispatch();
+};
+
+/**
+ * Runs `iterator` over every item with unlimited concurrency and collects the
+ * results in the order of the collection, not the order of completion.
+ * @template T
+ * @template R
+ * @template E
+ * @param {Iterable<T>} collection items to iterate
+ * @param {(item: T, callback: (err?: E | null, result?: R) => void) => void} iterator called once per item
+ * @param {(err?: E | null, results?: R[]) => void} callback called with every result, or with the first error
+ * @returns {void}
+ */
+const map = (collection, iterator, callback) => {
+	const array = Array.isArray(collection)
+		? /** @type {T[]} */ (collection)
+		: undefined;
+	// Pre-sized, because growing it or `Array.from` costs measurably more on
+	// the small collections this is called with.
+	/** @type {R[]} */
+	// eslint-disable-next-line unicorn/no-new-array
+	const results = array === undefined ? [] : new Array(array.length);
+	let remaining = 1;
+	let finished = false;
+
+	/**
+	 * @param {(E | null)=} err error
+	 * @returns {void}
+	 */
+	const settle = (err) => {
+		if (finished) return;
+		if (err) {
+			finished = true;
+			callback(err, results);
+			return;
+		}
+		if (--remaining === 0) {
+			finished = true;
+			callback(null, results);
+		}
+	};
+
+	/**
+	 * @param {number} index position the result of that item belongs at
+	 * @returns {(err?: E | null, result?: R) => void} completion callback for that item
+	 */
+	const createCallback = (index) => {
+		let position = index;
+		return (err, result) => {
+			const at = position;
+			if (at === -1) throw new Error("Callback was already called");
+			position = -1;
+			// A result arriving after the run settled must not reach `results`,
+			// which the callback already handed to the caller.
+			if (finished) return;
+			if (!err) results[at] = /** @type {R} */ (result);
+			settle(err);
+		};
+	};
+
+	if (array !== undefined) {
+		const length = array.length;
+		if (length === 0) return callback(null, results);
+		remaining = length;
+		for (let i = 0; i < length; i++) iterator(array[i], createCallback(i));
+		return;
+	}
+
+	let index = 0;
+	for (const item of collection) {
+		remaining++;
+		iterator(item, createCallback(index++));
+	}
+	results.length = index;
+	settle(null);
+};
+
+/**
+ * Runs `iterator` over every item, at most `limit` of them in flight, and
+ * collects the results in the order of the collection, not of completion.
+ * @template T
+ * @template R
+ * @template E
+ * @param {Iterable<T>} collection items to iterate
+ * @param {number} limit maximum number of items in flight
+ * @param {(item: T, callback: (err?: E | null, result?: R) => void) => void} iterator called once per item
+ * @param {(err?: E | null, results?: R[]) => void} callback called with every result, or with the first error
+ * @returns {void}
+ */
+const mapLimit = (collection, limit, iterator, callback) => {
+	/** @type {R[]} */
+	const results = [];
+	let index = 0;
+	eachLimit(
+		collection,
+		limit,
+		(item, done) => {
+			// the dispatch loop hands out one item at a time, so this counts the
+			// position of the item rather than of whichever finishes first
+			const position = index++;
+			iterator(item, (err, result) => {
+				if (err) return done(err);
+				results[position] = /** @type {R} */ (result);
+				done(null);
+			});
+		},
+		(err) => {
+			if (err) return callback(err);
+			callback(null, results);
+		}
+	);
+};
+
+/**
+ * @template R
+ * @template E
+ * @param {(callback: (err?: E | null, result?: R) => void) => void} task task to run
+ * @param {(err?: E | null, result?: R) => void} callback called when the task is done
+ * @returns {void}
+ */
+const runTask = (task, callback) => task(callback);
+
+/**
+ * Runs every task in parallel and collects the results in task order.
+ * @template R
+ * @template E
+ * @param {((callback: (err?: E | null, result?: R) => void) => void)[]} tasks tasks to run
+ * @param {(err?: E | null, results?: R[]) => void} callback called with every result, or with the first error
+ * @returns {void}
+ */
+const parallel = (tasks, callback) => map(tasks, runTask, callback);
+
+module.exports.each = each;
+module.exports.eachLimit = eachLimit;
+module.exports.map = map;
+module.exports.mapLimit = mapLimit;
+module.exports.parallel = parallel;

package/lib/util/buildDiagnostics.js

@@ -0,0 +1,69 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Haijie Xie @hai-x
+*/
+
+"use strict";
+
+/** @import Module, { BuildDiagnostics, BuildInfo } from "../Module" */
+/** @import ModuleGraph from "../ModuleGraph" */
+
+/**
+ * The diagnostics record of a build info, created on first use so a module nothing reports about carries none.
+ * @param {BuildInfo} buildInfo the build info of the module
+ * @returns {BuildDiagnostics} the record
+ */
+const getBuildDiagnostics = (buildInfo) => {
+	let diagnostics = buildInfo.diagnostics;
+	if (diagnostics === undefined) {
+		diagnostics = buildInfo.diagnostics = {
+			optimizationBailouts: undefined,
+			sideEffectStatement: undefined,
+			ineffectivePureAnnotations: undefined,
+			topLevelThis: undefined,
+			usesEval: undefined,
+			notCacheableReasons: undefined
+		};
+	}
+	return diagnostics;
+};
+
+/**
+ * Records a bailout a parser plugin found, where a module restored from the cache still has it for the module graph to report.
+ * @param {BuildInfo} buildInfo the build info of the module being parsed
+ * @param {string} reason the bailout as reported
+ * @returns {void}
+ */
+const recordOptimizationBailout = (buildInfo, reason) => {
+	const diagnostics = getBuildDiagnostics(buildInfo);
+	const bailouts =
+		diagnostics.optimizationBailouts || (diagnostics.optimizationBailouts = []);
+	bailouts.push(reason);
+};
+
+/**
+ * Replays the bailouts parser plugins recorded for a module into the module graph,
+ * which a module reused from the cache never parses into.
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {Module} module the built or still valid module
+ * @returns {void}
+ */
+const replayOptimizationBailouts = (moduleGraph, module) => {
+	const buildInfo = module.buildInfo;
+	if (buildInfo === undefined) return;
+	const diagnostics = buildInfo.diagnostics;
+	if (
+		diagnostics === undefined ||
+		diagnostics.optimizationBailouts === undefined
+	) {
+		return;
+	}
+	const bailouts = moduleGraph.getOptimizationBailout(module);
+	for (const reason of diagnostics.optimizationBailouts) bailouts.push(reason);
+};
+
+module.exports = {
+	getBuildDiagnostics,
+	recordOptimizationBailout,
+	replayOptimizationBailouts
+};