@qilin-agent/experimental-inspector 0.0.0-stage → 3.1.3

package/lib/devtools/chunks/lighthouse-T9ZpmENr.js

@@ -0,0 +1,2 @@
+import { a as e, c as t, d as n, f as r, i, o as a, r as o, s, u as c } from "./lighthouse-DtpzvfT6.js";
+export { r as LighthouseController, o as LighthousePanel, n as LighthouseProtocolService, c as LighthouseReportRenderer, t as LighthouseReportSelector, a as LighthouseStartView, e as LighthouseStatusView, i as LighthouseTimespanView, s as RadioSetting };

package/lib/devtools/chunks/linear_memory_inspector-C50PtM45.js

@@ -0,0 +1,305 @@
+import { n as e } from "./chunk-DF993M8W.js";
+import { $ as t, bt as n, d as r, jt as i, wt as a } from "./common-qd_KLeYO.js";
+import { Gl as o, Hr as s, Ja as c, Jl as l, Md as u, Vr as d, ei as f, hl as p, jd as m, jr as h, ma as g, mo as _, pl as v, wl as y } from "./legacy-Bqn4Q0Tf.js";
+import { d as b } from "./bindings-DgoVEdsr.js";
+import { i as x, n as S, r as C, t as w } from "./components-EJwviLtZ.js";
+//#region node_modules/.pnpm/chrome-devtools-frontend@1.0.1638082/node_modules/chrome-devtools-frontend/front_end/panels/linear_memory_inspector/LinearMemoryInspectorPane.ts
+var T = /* @__PURE__ */ e({
+	Events: () => M,
+	LinearMemoryInspectorPane: () => j,
+	LinearMemoryInspectorView: () => N
+}), E = {
+	noOpenInspections: "No open inspections",
+	memoryInspectorExplanation: "On this page you can inspect binary data.",
+	learnMore: "Learn more"
+}, D = a("panels/linear_memory_inspector/LinearMemoryInspectorPane.ts", E), O = n.bind(void 0, D), k, A = "https://developer.chrome.com/docs/devtools/memory-inspector", j = class e extends i(f) {
+	#e;
+	constructor() {
+		super({ jslog: `${c("linear-memory-inspector").track({ resize: !0 })}` }), this.#e = new s(), this.#e.setPlaceholderElement(this.createPlaceholder()), this.#e.setCloseableTabs(!0), this.#e.setAllowTabReorder(!0, !0), this.#e.addEventListener(d.TabClosed, this.#n, this), this.#e.show(this.contentElement), this.#e.headerElement().setAttribute("jslog", `${_().track({ keydown: "ArrowUp|ArrowLeft|ArrowDown|ArrowRight|Enter|Space" })}`);
+	}
+	createPlaceholder() {
+		let e = document.createElement("div");
+		e.classList.add("empty-state"), e.createChild("span", "empty-state-header").textContent = O(E.noOpenInspections);
+		let t = e.createChild("div", "empty-state-description");
+		t.createChild("span").textContent = O(E.memoryInspectorExplanation);
+		let n = g.create(A, O(E.learnMore), void 0, "learn-more");
+		return t.appendChild(n), e;
+	}
+	static instance() {
+		return k ||= new e(), k;
+	}
+	#t(e) {
+		let t = this.#e.tabView(e);
+		if (t === null) throw Error(`No linear memory inspector view for the given tab id: ${e}`);
+		return t;
+	}
+	create(e, t, n, r) {
+		let i = new N(n, r, e);
+		this.#e.appendTab(e, t, i, void 0, !1, !0), this.#e.selectTab(e);
+	}
+	close(e) {
+		this.#e.closeTab(e, !1);
+	}
+	reveal(e, t) {
+		let n = this.#t(e);
+		t !== void 0 && n.updateAddress(t), this.refreshView(e), this.#e.selectTab(e);
+	}
+	refreshView(e) {
+		this.#t(e).refreshData();
+	}
+	#n(e) {
+		let { tabId: t } = e.data;
+		this.dispatchEventToListeners("ViewClosed", t);
+	}
+}, M = /* @__PURE__ */ function(e) {
+	return e.VIEW_CLOSED = "ViewClosed", e;
+}({}), N = class extends f {
+	#e;
+	#t;
+	#n = 0;
+	#r;
+	#i;
+	#a;
+	firstTimeOpen;
+	#o;
+	constructor(e, t = 0, n, r) {
+		if (super(), t < 0 || t >= e.length()) throw Error("Requested address is out of bounds.");
+		this.#e = e, this.#r = t, this.#i = n, this.#o = !!r, this.firstTimeOpen = !0, this.#a = new S(), this.#a.addEventListener(w.MEMORY_REQUEST, this.#s, this), this.#a.addEventListener(w.ADDRESS_CHANGED, (e) => this.updateAddress(e.data)), this.#a.addEventListener(w.SETTINGS_CHANGED, (e) => this.saveSettings(e.data)), this.#a.addEventListener(w.DELETE_MEMORY_HIGHLIGHT, (e) => {
+			U.instance().removeHighlight(this.#i, e.data), this.refreshData();
+		}), this.#a.show(this.contentElement);
+	}
+	render() {
+		if (this.firstTimeOpen) {
+			let e = U.instance().loadSettings();
+			this.#a.valueTypes = e.valueTypes, this.#a.valueTypeModes = e.modes, this.#a.endianness = e.endianness, this.firstTimeOpen = !1;
+		}
+		this.#t && (this.#a.memory = this.#t, this.#a.memoryOffset = this.#n, this.#a.address = this.#r, this.#a.outerMemoryLength = this.#e.length(), this.#a.highlightInfo = this.#c(), this.#a.hideValueInspector = this.#o);
+	}
+	wasShown() {
+		super.wasShown(), this.refreshData();
+	}
+	saveSettings(e) {
+		U.instance().saveSettings(e);
+	}
+	updateAddress(e) {
+		if (e < 0 || e >= this.#e.length()) throw Error("Requested address is out of bounds.");
+		this.#r = e;
+	}
+	refreshData() {
+		U.getMemoryForAddress(this.#e, this.#r).then(({ memory: e, offset: t }) => {
+			this.#t = e, this.#n = t, this.render();
+		});
+	}
+	#s(e) {
+		let { start: t, end: n, address: r } = e.data;
+		if (r < t || r >= n) throw Error("Requested address is out of bounds.");
+		U.getMemoryRange(this.#e, t, n).then((e) => {
+			this.#t = e, this.#n = t, this.render();
+		});
+	}
+	#c() {
+		let e = U.instance().getHighlightInfo(this.#i);
+		if (e !== void 0) {
+			if (e.startAddress < 0 || e.startAddress >= this.#e.length()) throw Error("HighlightInfo start address is out of bounds.");
+			if (e.size <= 0) throw Error("Highlight size must be a positive number.");
+		}
+		return e;
+	}
+}, P = /* @__PURE__ */ e({
+	LinearMemoryInspectorController: () => U,
+	RemoteArrayBufferWrapper: () => V
+}), F = {
+	couldNotOpenLinearMemory: "Could not open linear memory inspector: failed locating buffer.",
+	openInMemoryInspectorPanel: "Open in Memory inspector panel"
+}, I = a("panels/linear_memory_inspector/LinearMemoryInspectorController.ts", F), L = n.bind(void 0, I), R = "linear-memory-inspector", z = 1e3, B, V = class {
+	#e;
+	constructor(e) {
+		this.#e = e;
+	}
+	length() {
+		return this.#e.byteLength();
+	}
+	async getRange(e, t) {
+		let n = Math.min(t, this.length());
+		if (e < 0 || e > n) return console.error(`Requesting invalid range of memory: (${e}, ${t})`), new Uint8Array();
+		let r = await this.#e.bytes(e, n);
+		return new Uint8Array(r ?? []);
+	}
+};
+async function H(e) {
+	let t = await e.runtimeModel().agent.invoke_callFunctionOn({
+		objectId: e.objectId,
+		functionDeclaration: "function() { return this instanceof ArrayBuffer || (typeof SharedArrayBuffer !== 'undefined' && this instanceof SharedArrayBuffer) ? this : this.buffer; }",
+		silent: !0,
+		objectGroup: R
+	}), n = t.getError();
+	if (n) throw Error(`Remote object representing ArrayBuffer could not be retrieved: ${n}`);
+	return e = e.runtimeModel().createRemoteObject(t.result), new l(e);
+}
+var U = class e extends m {
+	#e = j.instance();
+	#t = /* @__PURE__ */ new Map();
+	#n = /* @__PURE__ */ new Map();
+	#r;
+	constructor() {
+		super(), u.instance().observeModels(y, this), u.instance().addModelListener(v, p.GlobalObjectCleared, this.#o, this), this.#e.addEventListener(M.VIEW_CLOSED, this.#s.bind(this)), u.instance().addModelListener(v, p.DebuggerPaused, this.#a, this);
+		let e = x(), t = {
+			valueTypes: Array.from(e.keys()),
+			valueTypeModes: Array.from(e),
+			endianness: C.LITTLE
+		};
+		this.#r = r.instance().createSetting("lmi-interpreter-settings", t);
+	}
+	static instance() {
+		return B || (B = new e(), B);
+	}
+	static async getMemoryForAddress(e, t) {
+		let n = Math.max(0, t - z / 2), r = n + z;
+		return {
+			memory: await e.getRange(n, r),
+			offset: n
+		};
+	}
+	static async getMemoryRange(e, t, n) {
+		if (t < 0 || t > n || t >= e.length()) throw Error("Requested range is out of bounds.");
+		let r = Math.max(n, t + z);
+		return await e.getRange(t, r);
+	}
+	async evaluateExpression(e, t) {
+		let n = await e.evaluate({ expression: t });
+		if ("error" in n) {
+			console.error(`Tried to evaluate the expression '${t}' but got an error: ${n.error}`);
+			return;
+		}
+		if ("exceptionDetails" in n && n?.exceptionDetails?.text) {
+			console.error(`Tried to evaluate the expression '${t}' but got an exception: ${n.exceptionDetails.text}`);
+			return;
+		}
+		return n.object;
+	}
+	saveSettings(e) {
+		let t = Array.from(e.valueTypes), n = [...e.modes];
+		this.#r.set({
+			valueTypes: t,
+			valueTypeModes: n,
+			endianness: e.endianness
+		});
+	}
+	loadSettings() {
+		let e = this.#r.get();
+		return {
+			valueTypes: new Set(e.valueTypes),
+			modes: new Map(e.valueTypeModes),
+			endianness: e.endianness
+		};
+	}
+	getHighlightInfo(e) {
+		return this.#n.get(e);
+	}
+	removeHighlight(e, t) {
+		this.getHighlightInfo(e) === t && this.#n.delete(e);
+	}
+	setHighlightInfo(e, t) {
+		this.#n.set(e, t);
+	}
+	#i(e) {
+		this.#n.delete(e);
+	}
+	static async retrieveDWARFMemoryObjectAndAddress(e) {
+		if (!(e instanceof b)) return;
+		let n = e, r = e.linearMemoryAddress;
+		if (r === void 0) return;
+		let i = n.callFrame, a = await e.debuggerModel().agent.invoke_evaluateOnCallFrame({
+			callFrameId: i.id,
+			expression: "memories[0]"
+		}), o = a.getError();
+		return o && (console.error(o), t.instance().error(L(F.couldNotOpenLinearMemory))), {
+			obj: e.debuggerModel().runtimeModel().createRemoteObject(a.result),
+			address: r
+		};
+	}
+	static extractObjectSize(e) {
+		return e.linearMemorySize ?? 0;
+	}
+	static extractObjectTypeDescription(e) {
+		let t = e.description;
+		if (!t) return "";
+		let n = t.charAt(t.length - 1), r = t.charAt(t.length - 2);
+		return n === "*" || n === "&" ? r === " " ? t.slice(0, t.length - 2) : t.slice(0, t.length - 1) : t;
+	}
+	static extractObjectName(e, t) {
+		return e.description?.charAt(e.description.length - 1) === "*" ? "*" + t : t;
+	}
+	async reveal({ object: t, expression: n }, r) {
+		let i = await e.retrieveDWARFMemoryObjectAndAddress(t), a = t, o;
+		i !== void 0 && (o = i.address, a = i.obj);
+		let s = await H(a), { internalProperties: c } = await s.object().getOwnProperties(!1), l = (c?.find(({ name: e }) => e === "[[ArrayBufferData]]"))?.value?.value;
+		if (!l) throw Error("Unable to find backing store id for array buffer");
+		let u = c?.find(({ name: e }) => e === "[[WebAssemblyMemory]]")?.value, d = e.extractHighlightInfo(t, n);
+		if (d ? this.setHighlightInfo(l, d) : this.#i(l), this.#t.has(l)) {
+			this.#e.reveal(l, o), h.instance().showView("linear-memory-inspector", r);
+			return;
+		}
+		let f = String(u ? u.description : s.object().description);
+		this.#t.set(l, s.object());
+		let p = new V(s);
+		this.#e.create(l, f, p, o), h.instance().showView("linear-memory-inspector", r);
+	}
+	appendApplicableItems(e, t, n) {
+		if (n.property.object?.isLinearMemoryInspectable()) {
+			let e = n.path(), r = n.property.object;
+			t.debugSection().appendItem(L(F.openInMemoryInspectorPanel), this.reveal.bind(this, new o(r, e)), { jslogContext: "reveal-in-memory-inspector" });
+		}
+	}
+	static extractHighlightInfo(t, n) {
+		if (!(t instanceof b)) return;
+		let r = t.linearMemoryAddress ?? 0, i;
+		try {
+			i = {
+				startAddress: r,
+				size: e.extractObjectSize(t),
+				name: n && e.extractObjectName(t, n),
+				type: e.extractObjectTypeDescription(t)
+			};
+		} catch {
+			i = void 0;
+		}
+		return i;
+	}
+	modelRemoved(e) {
+		for (let [t, n] of this.#t) e === n.runtimeModel() && (this.#t.delete(t), this.#i(t), this.#e.close(t));
+	}
+	#a(e) {
+		let t = e.data;
+		for (let [e, n] of this.#t) if (t.runtimeModel() === n.runtimeModel()) {
+			let n = t.debuggerPausedDetails()?.callFrames[0];
+			n ? this.updateHighlightedMemory(e, n).then(() => this.#e.refreshView(e)) : (this.#i(e), this.#e.refreshView(e));
+		}
+	}
+	#o(e) {
+		this.modelRemoved(e.data.runtimeModel());
+	}
+	#s({ data: e }) {
+		let t = this.#t.get(e);
+		t && t.release(), this.#t.delete(e), this.#i(e);
+	}
+	async updateHighlightedMemory(t, n) {
+		let r = this.getHighlightInfo(t), i = r?.name;
+		if (!r || !i) {
+			this.#i(t);
+			return;
+		}
+		let a = await this.evaluateExpression(n, i);
+		if (!a) {
+			this.#i(t);
+			return;
+		}
+		let o = e.extractHighlightInfo(a, i);
+		!o || !this.#c(o, r) ? this.#i(t) : this.setHighlightInfo(t, o);
+	}
+	#c(e, t) {
+		return e.type === t.type && e.startAddress === t.startAddress;
+	}
+};
+//#endregion
+export { P as LinearMemoryInspectorController, T as LinearMemoryInspectorPane };

package/lib/devtools/chunks/live-metrics-Bs7wxibB.js

@@ -0,0 +1,284 @@
+import { it as e } from "./platform-BzB373NB.js";
+import { At as t, R as n, bt as r, wt as i } from "./common-qd_KLeYO.js";
+import { Ad as a, Fd as o, Md as s, Sl as c, Wc as l, Zf as u, sl as d, tl as f, wl as p } from "./legacy-Bqn4Q0Tf.js";
+import { n as m, t as h } from "./emulation-EtJlEukP.js";
+//#region node_modules/.pnpm/chrome-devtools-frontend@1.0.1638082/node_modules/chrome-devtools-frontend/front_end/models/live-metrics/web-vitals-injected/spec/spec.ts
+var g = "__chromium_devtools_metrics_reporter", _ = "__chromium_devtools_kill_live_metrics", v = {
+	lcpEmulationWarning: "Simulating a new device after the page loads can affect LCP. Reload the page after simulating a new device for accurate LCP data.",
+	lcpVisibilityWarning: "LCP value may be inflated because the page started loading in the background."
+}, y = i("models/live-metrics/LiveMetrics.ts", v), b = r.bind(void 0, y), x = "DevTools Performance Metrics", S, C = class {
+	static #e;
+	static async get() {
+		if (!this.#e) {
+			let e = new URL("./web-vitals-injected/web-vitals-injected.generated.js", new URL("models/live-metrics/LiveMetrics.js", typeof document < "u" ? document.baseURI : new URL("../../", self.location.href).href).href), t = await fetch(e);
+			this.#e = await t.text();
+		}
+		return this.#e;
+	}
+}, w = class r extends t {
+	#e = !1;
+	#t;
+	#n;
+	#r;
+	#i;
+	#a;
+	#o;
+	#s = /* @__PURE__ */ new Map();
+	#c = /* @__PURE__ */ new Map();
+	#l = [];
+	#u;
+	#d = new n();
+	#f = h.tryInstance();
+	constructor() {
+		super();
+		let e = s.instance();
+		e.observeTargets(this, { scoped: !0 }), e.addEventListener(a.AVAILABLE_TARGETS_CHANGED, this.#p, this);
+	}
+	#p() {
+		let e = s.instance().primaryPageTarget();
+		e && e !== this.#t && this.#m(e);
+	}
+	async #m(e) {
+		this.#t && await this.disable(), this.#t = e, await this.enable();
+	}
+	static instance(e = { forceNew: !1 }) {
+		let { forceNew: t } = e;
+		return (!S || t) && (S = new r()), S;
+	}
+	get lcpValue() {
+		return this.#i;
+	}
+	get clsValue() {
+		return this.#a;
+	}
+	get inpValue() {
+		return this.#o;
+	}
+	get interactions() {
+		return this.#s;
+	}
+	get layoutShifts() {
+		return this.#l;
+	}
+	async logInteractionScripts(e) {
+		if (!this.#t) return !1;
+		let t = this.#r;
+		if (!t) return !1;
+		let n = [];
+		for (let t of e.longAnimationFrameTimings) for (let r of t.scripts) {
+			let t = r.startTime + r.duration;
+			if (t < e.startTime) continue;
+			let i = Math.round(t - Math.max(e.startTime, r.startTime));
+			n.push({
+				"Blocking duration": i,
+				"Invoker type": r.invokerType || null,
+				Invoker: r.invoker || null,
+				Function: r.sourceFunctionName || null,
+				Source: r.sourceURL || null,
+				"Char position": r.sourceCharPosition || null
+			});
+		}
+		try {
+			let r = n.length === 50 ? " (limited to 50)" : "", i = e.longAnimationFrameTimings.length === 5 ? " (limited to last 5)" : "";
+			await this.#t.runtimeAgent().invoke_evaluate({
+				expression: `
+          console.group('[DevTools] Long animation frames for ${e.duration}ms ${e.interactionType} interaction');
+          console.log('Scripts${r}:');
+          console.table(${JSON.stringify(n)});
+          console.log('Intersecting long animation frame events${i}:', ${JSON.stringify(e.longAnimationFrameTimings)});
+          console.groupEnd();
+        `,
+				contextId: t
+			});
+		} catch {
+			return !1;
+		}
+		return !0;
+	}
+	#h() {
+		this.#u = Date.now();
+	}
+	async #g(e, t) {
+		if (!this.#t) return null;
+		let n = this.#t.model(p);
+		if (!n) return null;
+		let r = this.#t.model(f);
+		if (!r) return null;
+		let { result: i } = await this.#t.runtimeAgent().invoke_evaluate({
+			expression: `window.getNodeForIndex(${e})`,
+			contextId: t
+		});
+		if (!i) return null;
+		let a;
+		try {
+			return a = n.createRemoteObject(i), await r.pushObjectAsNodeToFrontend(a) || null;
+		} catch {
+			return null;
+		} finally {
+			a?.release();
+		}
+	}
+	#_() {
+		this.dispatchEventToListeners("status", {
+			lcp: this.#i,
+			cls: this.#a,
+			inp: this.#o,
+			interactions: this.#s,
+			layoutShifts: this.#l
+		});
+	}
+	setStatusForTesting(e) {
+		this.#i = e.lcp, this.#a = e.cls, this.#o = e.inp, this.#s = e.interactions, this.#l = e.layoutShifts, this.#_();
+	}
+	async #v(e) {
+		let t = e.data, n = [
+			this.#i?.nodeRef,
+			...this.#s.values().map((e) => e.nodeRef),
+			...this.#l.flatMap((e) => e.affectedNodeRefs)
+		].filter((e) => !!e), r = new Set(n.map((e) => e.backendNodeId())), i = await t.pushNodesByBackendIdsToFrontend(r);
+		if (i) {
+			for (let e = 0; e < n.length; e++) {
+				let t = i.get(n[e].backendNodeId());
+				t && (n[e] = t);
+			}
+			this.#_();
+		}
+	}
+	async #y(t, n) {
+		switch (t.name) {
+			case "LCP": {
+				let e = [], r = {
+					value: t.value,
+					phases: t.phases,
+					warnings: e
+				};
+				if (t.nodeIndex !== void 0) {
+					let e = await this.#g(t.nodeIndex, n);
+					e && (r.nodeRef = e);
+				}
+				this.#u && Date.now() - this.#u < 500 && e.push(b(v.lcpEmulationWarning)), t.startedHidden && e.push(b(v.lcpVisibilityWarning)), this.#i = r;
+				break;
+			}
+			case "CLS": {
+				let e = {
+					value: t.value,
+					clusterShiftIds: t.clusterShiftIds
+				};
+				this.#a = e;
+				break;
+			}
+			case "INP": {
+				let e = {
+					value: t.value,
+					phases: t.phases,
+					interactionId: `interaction-${t.entryGroupId}-${t.startTime}`
+				};
+				this.#o = e;
+				break;
+			}
+			case "InteractionEntry": {
+				let r = e(this.#c, t.entryGroupId, () => []), i = r.find((e) => Math.abs(e.nextPaintTime - t.nextPaintTime) < 8);
+				if (i || (i = {
+					interactionId: `interaction-${t.entryGroupId}-${t.startTime}`,
+					interactionType: t.interactionType,
+					duration: t.duration,
+					eventNames: [],
+					phases: t.phases,
+					startTime: t.startTime,
+					nextPaintTime: t.nextPaintTime,
+					longAnimationFrameTimings: t.longAnimationFrameEntries
+				}, r.push(i), this.#s.set(i.interactionId, i)), i.eventNames.includes(t.eventName) || i.eventNames.push(t.eventName), t.nodeIndex !== void 0) {
+					let e = await this.#g(t.nodeIndex, n);
+					e && (i.nodeRef = e);
+				}
+				break;
+			}
+			case "LayoutShift": {
+				let e = t.affectedNodeIndices.map((e) => this.#g(e, n)), r = (await Promise.all(e)).filter((e) => !!e), i = {
+					score: t.score,
+					uniqueLayoutShiftId: t.uniqueLayoutShiftId,
+					affectedNodeRefs: r
+				};
+				this.#l.push(i);
+				break;
+			}
+			case "reset":
+				this.#i = void 0, this.#a = void 0, this.#o = void 0, this.#s.clear(), this.#l = [];
+				break;
+		}
+		this.#_();
+	}
+	#b(e) {
+		if (!this.#t) return !1;
+		let t = this.#t.model(p)?.executionContext(e);
+		if (!t?.frameId) return !1;
+		let n = this.#t.model(l)?.mainFrame?.id;
+		return !!(n && t.frameId === n);
+	}
+	async #x(e) {
+		let { data: t } = e;
+		t.name === "__chromium_devtools_metrics_reporter" && await this.#d.run(async () => {
+			let e = JSON.parse(t.payload);
+			if (e.name === "reset") {
+				if (!this.#b(t.executionContextId)) return;
+				this.#r = t.executionContextId;
+			}
+			this.#r === t.executionContextId && await this.#y(e, t.executionContextId);
+		});
+	}
+	async #S() {
+		let e = this.#t;
+		if (!e) return;
+		let t = e.model(p);
+		if (!t) return;
+		let n = t.executionContexts().filter((e) => e.name === x && !e.isDefault).map((t) => e.runtimeAgent().invoke_evaluate({
+			expression: `window?.${_}?.()`,
+			contextId: t.id
+		}));
+		await Promise.all(n);
+	}
+	clearInteractions() {
+		this.#s.clear(), this.#_();
+	}
+	clearLayoutShifts() {
+		this.#l = [], this.#_();
+	}
+	async targetAdded(e) {
+		e === s.instance().primaryPageTarget() && (this.#t = e, await this.enable());
+	}
+	async targetRemoved(e) {
+		e === this.#t && (await this.disable(), this.#t = void 0);
+	}
+	async enable() {
+		if (u() || !this.#t || this.#e || this.#t.type() !== o.FRAME) return;
+		let e = this.#t.model(f);
+		if (!e) return;
+		e.addEventListener(d.DocumentUpdated, this.#v, this);
+		let t = this.#t.model(p);
+		if (!t) return;
+		t.addEventListener(c.BindingCalled, this.#x, this), await t.addBinding({
+			name: g,
+			executionContextName: x
+		}), await this.#S();
+		let n = await C.get();
+		if (!this.#t) return;
+		let { identifier: r } = await this.#t?.pageAgent().invoke_addScriptToEvaluateOnNewDocument({
+			source: n,
+			worldName: x,
+			runImmediately: !0
+		});
+		this.#n = r, this.#f?.addEventListener(m.UPDATED, this.#h, this), this.#e = !0;
+	}
+	async disable() {
+		if (!this.#t || !this.#e) return;
+		this.#r = void 0, await this.#S();
+		let e = this.#t.model(p);
+		e && (await e.removeBinding({ name: g }), e.removeEventListener(c.BindingCalled, this.#x, this));
+		let t = this.#t.model(f);
+		t && t.removeEventListener(d.DocumentUpdated, this.#v, this), this.#n && await this.#t.pageAgent().invoke_removeScriptToEvaluateOnNewDocument({ identifier: this.#n }), this.#n = void 0, this.#f?.removeEventListener(m.UPDATED, this.#h, this), this.#e = !1;
+	}
+}, T = /* @__PURE__ */ function(e) {
+	return e.STATUS = "status", e;
+}({});
+//#endregion
+export { w as n, T as t };

package/lib/devtools/chunks/main-C5y6NscM.js

@@ -0,0 +1,2 @@
+import { a as e, i as t, r as n, t as r } from "./main-DcgYyEI0.js";
+export { e as ExecutionContextSelector, t as GlobalAiButton, n as MainImpl, r as SimpleApp };