@@ -18079,23 +18079,112 @@ class SyntaxTree {
 		}
 	}
 
+	/**
+	 * Writes a parsed node and everything under it, its children taking ids
+	 * after it in source order; a child already written stands as its id.
+	 * @param {import("estree").Node} root the node the parser made
+	 * @returns {number} its id
+	 */
+	addEstree(root) {
+		const types = getTreeNodeTypes();
+		// Pairs of a node and where its id goes: a slot from 0, a list item as
+		// `-2 - index`, `-1` for the root.
+		/** @type {EXPECTED_ANY[]} */
+		const work = [root, -1];
+		let rootNode = 0;
+		while (work.length > 0) {
+			const target = /** @type {number} */ (work.pop());
+			const object = /** @type {Record<string, EXPECTED_ANY>} */ (work.pop());
+			const type = /** @type {Record<string, number>} */ (NodeType)[
+				object.type
+			];
+			const descriptor = types[type];
+			if (descriptor === undefined) {
+				throw new Error(`Unknown node type ${object.type}`);
+			}
+			const node = this.add(type, object.start, object.end);
+			if (target === -1) rootNode = node;
+			else if (target >= 0) this._slots[target] = node;
+			else this._listItems[-2 - target] = node;
+			const base = this._bases[node];
+			const fields = descriptor.fields;
+			// Pushed last field first, so the first comes off the stack first.
+			for (let f = fields.length - 1; f >= 0; f--) {
+				const field = fields[f];
+				const value = object[field.name];
+				switch (field.kind) {
+					case FIELD_NODE:
+						if (typeof value === "number") {
+							this._slots[base + field.slot] = value;
+						} else if (value) {
+							work.push(value, base + field.slot);
+						}
+						break;
+					case FIELD_LIST: {
+						// An edition before attributes leaves them off an import or export.
+						const length = value === undefined ? 0 : value.length;
+						const list = this._reserveList(length);
+						this._slots[base + field.slot] = list;
+						const start = this._listStarts[list];
+						for (let i = length - 1; i >= 0; i--) {
+							const item = value[i];
+							if (typeof item === "number") {
+								this._listItems[start + i] = item;
+							} else if (item !== null) {
+								work.push(item, -2 - (start + i));
+							}
+						}
+						break;
+					}
+					case FIELD_FLAG:
+						if (value) this._flags[node] |= field.slot;
+						break;
+					case FIELD_OPTIONAL:
+						if (value !== undefined) {
+							this._slots[base + field.slot] = this._values.push(value);
+						}
+						break;
+					case FIELD_VALUE:
+						this._slots[base + field.slot] = this._values.push(value);
+						break;
+					default:
+						if (value !== null) {
+							this._slots[base + field.slot] = this._values.push(value);
+						}
+				}
+			}
+		}
+		return rootNode;
+	}
+
 	/**
 	 * @param {(number | null)[]} nodes the list's items, null for a hole
 	 * @returns {number} the list, from 1
 	 */
 	_addList(nodes) {
+		const list = this._reserveList(nodes.length);
+		const start = this._listStarts[list];
+		for (let i = 0; i < nodes.length; i++) {
+			const item = nodes[i];
+			this._listItems[start + i] = item === null ? 0 : item;
+		}
+		return list;
+	}
+
+	/**
+	 * @param {number} length how many items the list holds, each `0` until set
+	 * @returns {number} the list, from 1
+	 */
+	_reserveList(length) {
 		const list = ++this._listCount;
 		this._listStarts = growColumn(this._listStarts, list + 1);
 		this._listLengths = growColumn(this._listLengths, list + 1);
 		const start = this._listItemTop;
-		this._listItemTop += nodes.length;
+		this._listItemTop += length;
 		this._listItems = growColumn(this._listItems, this._listItemTop);
-		for (let i = 0; i < nodes.length; i++) {
-			const item = nodes[i];
-			this._listItems[start + i] = item === null ? 0 : item;
-		}
+		this._listItems.fill(0, start, this._listItemTop);
 		this._listStarts[list] = start;
-		this._listLengths[list] = nodes.length;
+		this._listLengths[list] = length;
 		return list;
 	}