playwright-core 1.55.0-alpha-2025-08-04 → 1.55.0-alpha-2025-08-05

package/lib/server/dom.js

@@ -377,11 +377,6 @@ class ElementHandle extends js.JSHandle {
         return { hitTargetDescription: error };
       }
       hitTargetInterceptionHandle = handle;
-      progress.cleanupWhenAborted(() => {
-        hitTargetInterceptionHandle.evaluate((h) => h.stop()).catch((e) => {
-        });
-        hitTargetInterceptionHandle.dispose();
-      });
     }
     const actionResult = await this._page.frameManager.waitForSignalsCreatedBy(progress, options.waitAfter === true, async () => {
       if (options.__testHookBeforePointerAction)
@@ -410,6 +405,10 @@ class ElementHandle extends js.JSHandle {
       if (options.__testHookAfterPointerAction)
         await progress.race(options.__testHookAfterPointerAction());
       return "done";
+    }).finally(() => {
+      const stopPromise = hitTargetInterceptionHandle?.evaluate((h) => h.stop()).catch(() => {
+      });
+      stopPromise?.then(() => hitTargetInterceptionHandle?.dispose());
     });
     if (actionResult !== "done")
       return actionResult;

package/lib/server/firefox/ffBrowser.js

@@ -225,7 +225,7 @@ class FFBrowserContext extends import_browserContext.BrowserContext {
   possiblyUninitializedPages() {
     return this._ffPages().map((ffPage) => ffPage._page);
   }
-  async doCreateNewPage(markAsServerSideOnly) {
+  async doCreateNewPage() {
     const { targetId } = await this._browser.session.send("Browser.newPage", {
       browserContextId: this._browserContextId
     }).catch((e) => {
@@ -233,10 +233,7 @@ class FFBrowserContext extends import_browserContext.BrowserContext {
         throw new Error(`Invalid timezone ID: ${this._options.timezoneId}`);
       throw e;
     });
-    const page = this._browser._ffPages.get(targetId)._page;
-    if (markAsServerSideOnly)
-      page.markAsServerSideOnly();
-    return page;
+    return this._browser._ffPages.get(targetId)._page;
   }
   async doGetCookies(urls) {
     const { cookies } = await this._browser.session.send("Browser.getCookies", { browserContextId: this._browserContextId });

package/lib/server/frames.js

@@ -119,13 +119,15 @@ class FrameManager {
       return action();
     const barrier = new SignalBarrier(progress);
     this._signalBarriers.add(barrier);
-    progress.cleanupWhenAborted(() => this._signalBarriers.delete(barrier));
-    const result = await action();
-    await progress.race(this._page.delegate.inputActionEpilogue());
-    await barrier.waitFor();
-    this._signalBarriers.delete(barrier);
-    await new Promise((0, import_utils.makeWaitForNextTask)());
-    return result;
+    try {
+      const result = await action();
+      await progress.race(this._page.delegate.inputActionEpilogue());
+      await barrier.waitFor();
+      await new Promise((0, import_utils.makeWaitForNextTask)());
+      return result;
+    } finally {
+      this._signalBarriers.delete(barrier);
+    }
   }
   frameWillPotentiallyRequestNavigation() {
     for (const barrier of this._signalBarriers)
@@ -711,17 +713,16 @@ class Frame extends import_instrumentation.SdkObject {
     }
   }
   async setContent(progress, html, options) {
+    const tag = `--playwright--set--content--${this._id}--${++this._setContentCounter}--`;
     await this.raceNavigationAction(progress, async () => {
       const waitUntil = options.waitUntil === void 0 ? "load" : options.waitUntil;
       progress.log(`setting frame content, waiting until "${waitUntil}"`);
-      const tag = `--playwright--set--content--${this._id}--${++this._setContentCounter}--`;
       const context = await progress.race(this._utilityContext());
       const tagPromise = new import_manualPromise.ManualPromise();
       this._page.frameManager._consoleMessageTags.set(tag, () => {
         this._onClearLifecycle();
         tagPromise.resolve();
       });
-      progress.cleanupWhenAborted(() => this._page.frameManager._consoleMessageTags.delete(tag));
       const lifecyclePromise = progress.race(tagPromise).then(() => this._waitForLoadState(progress, waitUntil));
       const contentPromise = progress.race(context.evaluate(({ html: html2, tag: tag2 }) => {
         document.open();
@@ -731,6 +732,8 @@ class Frame extends import_instrumentation.SdkObject {
       }, { html, tag }));
       await Promise.all([contentPromise, lifecyclePromise]);
       return null;
+    }).finally(() => {
+      this._page.frameManager._consoleMessageTags.delete(tag);
     });
   }
   name() {
@@ -1202,21 +1205,21 @@ class Frame extends import_instrumentation.SdkObject {
       const injectedScript = await progress.race(context.injectedScript());
       const handle = await progress.race(injectedScript.evaluateHandle((injected, { expression: expression2, isFunction: isFunction2, polling, arg: arg2 }) => {
         const predicate = () => {
-          let result3 = globalThis.eval(expression2);
+          let result2 = globalThis.eval(expression2);
           if (isFunction2 === true) {
-            result3 = result3(arg2);
+            result2 = result2(arg2);
           } else if (isFunction2 === false) {
-            result3 = result3;
+            result2 = result2;
           } else {
-            if (typeof result3 === "function")
-              result3 = result3(arg2);
+            if (typeof result2 === "function")
+              result2 = result2(arg2);
           }
-          return result3;
+          return result2;
         };
         let fulfill;
         let reject;
         let aborted = false;
-        const result2 = new Promise((f, r) => {
+        const result = new Promise((f, r) => {
           fulfill = f;
           reject = r;
         });
@@ -1238,12 +1241,17 @@ class Frame extends import_instrumentation.SdkObject {
           }
         };
         next();
-        return { result: result2, abort: () => aborted = true };
+        return { result, abort: () => aborted = true };
       }, { expression, isFunction, polling: options.pollingInterval, arg }));
-      progress.cleanupWhenAborted(() => handle.evaluate((h) => h.abort()).finally(() => handle.dispose()));
-      const result = await progress.race(handle.evaluateHandle((h) => h.result));
-      handle.dispose();
-      return result;
+      try {
+        return await progress.race(handle.evaluateHandle((h) => h.result));
+      } catch (error) {
+        await handle.evaluate((h) => h.abort()).catch(() => {
+        });
+        throw error;
+      } finally {
+        handle.dispose();
+      }
     });
   }
   async waitForFunctionValueInUtility(progress, pageFunction) {

package/lib/server/page.js

@@ -70,7 +70,6 @@ class Page extends import_instrumentation.SdkObject {
     this._workers = /* @__PURE__ */ new Map();
     this.requestInterceptors = [];
     this.video = null;
-    this._isServerSideOnly = false;
     this._locatorHandlers = /* @__PURE__ */ new Map();
     this._lastLocatorHandlerUid = 0;
     this._locatorHandlerRunningCounter = 0;
@@ -90,6 +89,7 @@ class Page extends import_instrumentation.SdkObject {
     if (delegate.pdf)
       this.pdf = delegate.pdf.bind(delegate);
     this.coverage = delegate.coverage ? delegate.coverage() : null;
+    this.isStorageStatePage = browserContext.isCreatingStorageStatePage();
   }
   static {
     this.Events = {
@@ -140,12 +140,12 @@ class Page extends import_instrumentation.SdkObject {
     return this._initializedPromise;
   }
   emitOnContext(event, ...args) {
-    if (this._isServerSideOnly)
+    if (this.isStorageStatePage)
       return;
     this.browserContext.emit(event, ...args);
   }
   emitOnContextOnceInitialized(event, ...args) {
-    if (this._isServerSideOnly)
+    if (this.isStorageStatePage)
       return;
     if (this._initialized)
       this.browserContext.emit(event, ...args);
@@ -213,10 +213,14 @@ class Page extends import_instrumentation.SdkObject {
     await progress.race(this.browserContext.exposePlaywrightBindingIfNeeded());
     const binding = new PageBinding(name, playwrightBinding, needsHandle);
     this._pageBindings.set(name, binding);
-    progress.cleanupWhenAborted(() => this._pageBindings.delete(name));
-    await progress.race(this.delegate.addInitScript(binding.initScript));
-    await progress.race(this.safeNonStallingEvaluateInAllFrames(binding.initScript.source, "main"));
-    return binding;
+    try {
+      await progress.race(this.delegate.addInitScript(binding.initScript));
+      await progress.race(this.safeNonStallingEvaluateInAllFrames(binding.initScript.source, "main"));
+      return binding;
+    } catch (error) {
+      this._pageBindings.delete(name);
+      throw error;
+    }
   }
   async removeExposedBindings(bindings) {
     bindings = bindings.filter((binding) => this._pageBindings.get(binding.name) === binding);
@@ -229,12 +233,15 @@ class Page extends import_instrumentation.SdkObject {
   }
   async setExtraHTTPHeaders(progress, headers) {
     const oldHeaders = this._extraHTTPHeaders;
-    this._extraHTTPHeaders = headers;
-    progress.cleanupWhenAborted(async () => {
+    try {
+      this._extraHTTPHeaders = headers;
+      await progress.race(this.delegate.updateExtraHTTPHeaders());
+    } catch (error) {
       this._extraHTTPHeaders = oldHeaders;
-      await this.delegate.updateExtraHTTPHeaders();
-    });
-    await progress.race(this.delegate.updateExtraHTTPHeaders());
+      this.delegate.updateExtraHTTPHeaders().catch(() => {
+      });
+      throw error;
+    }
   }
   extraHTTPHeaders() {
     return this._extraHTTPHeaders;
@@ -369,10 +376,6 @@ class Page extends import_instrumentation.SdkObject {
   }
   async emulateMedia(progress, options) {
     const oldEmulatedMedia = { ...this._emulatedMedia };
-    progress.cleanupWhenAborted(async () => {
-      this._emulatedMedia = oldEmulatedMedia;
-      await this.delegate.updateEmulateMedia();
-    });
     if (options.media !== void 0)
       this._emulatedMedia.media = options.media;
     if (options.colorScheme !== void 0)
@@ -383,7 +386,14 @@ class Page extends import_instrumentation.SdkObject {
       this._emulatedMedia.forcedColors = options.forcedColors;
     if (options.contrast !== void 0)
       this._emulatedMedia.contrast = options.contrast;
-    await progress.race(this.delegate.updateEmulateMedia());
+    try {
+      await progress.race(this.delegate.updateEmulateMedia());
+    } catch (error) {
+      this._emulatedMedia = oldEmulatedMedia;
+      this.delegate.updateEmulateMedia().catch(() => {
+      });
+      throw error;
+    }
   }
   emulatedMedia() {
     const contextOptions = this.browserContext._options;
@@ -397,12 +407,15 @@ class Page extends import_instrumentation.SdkObject {
   }
   async setViewportSize(progress, viewportSize) {
     const oldEmulatedSize = this._emulatedSize;
-    progress.cleanupWhenAborted(async () => {
+    try {
+      this._setEmulatedSize({ viewport: { ...viewportSize }, screen: { ...viewportSize } });
+      await progress.race(this.delegate.updateEmulatedViewportSize());
+    } catch (error) {
       this._emulatedSize = oldEmulatedSize;
-      await this.delegate.updateEmulatedViewportSize();
-    });
-    this._setEmulatedSize({ viewport: { ...viewportSize }, screen: { ...viewportSize } });
-    await progress.race(this.delegate.updateEmulatedViewportSize());
+      this.delegate.updateEmulatedViewportSize().catch(() => {
+      });
+      throw error;
+    }
   }
   setEmulatedSizeFromWindowOpen(emulatedSize) {
     this._setEmulatedSize(emulatedSize);
@@ -423,8 +436,13 @@ class Page extends import_instrumentation.SdkObject {
   async addInitScript(progress, source) {
     const initScript = new InitScript(source);
     this.initScripts.push(initScript);
-    progress.cleanupWhenAborted(() => this.removeInitScripts([initScript]));
-    await progress.race(this.delegate.addInitScript(initScript));
+    try {
+      await progress.race(this.delegate.addInitScript(initScript));
+    } catch (error) {
+      this.removeInitScripts([initScript]).catch(() => {
+      });
+      throw error;
+    }
     return initScript;
   }
   async removeInitScripts(initScripts) {
@@ -630,9 +648,6 @@ class Page extends import_instrumentation.SdkObject {
     await Promise.all(this.frames().map((frame) => frame.hideHighlight().catch(() => {
     })));
   }
-  markAsServerSideOnly() {
-    this._isServerSideOnly = true;
-  }
   async snapshotForAI(progress) {
     this.lastSnapshotFrameIds = [];
     const snapshot = await snapshotFrameForAI(progress, this.mainFrame(), 0, this.lastSnapshotFrameIds);

package/lib/server/progress.js

@@ -30,17 +30,11 @@ class ProgressController {
   constructor(metadata, sdkObject) {
     this._forceAbortPromise = new import_manualPromise.ManualPromise();
     this._donePromise = new import_manualPromise.ManualPromise();
-    // Cleanups to be run only in the case of abort.
-    this._cleanups = [];
     this._state = "before";
     this.metadata = metadata;
     this._sdkObject = sdkObject;
-    this._logName = sdkObject.logName || "api";
     this._forceAbortPromise.catch((e) => null);
   }
-  setLogName(logName) {
-    this._logName = logName;
-  }
   async abort(error) {
     if (this._state === "running") {
       error[kAbortErrorSymbol] = true;
@@ -56,12 +50,7 @@ class ProgressController {
       log: (message) => {
         if (this._state === "running")
           this.metadata.log.push(message);
-        this._sdkObject.instrumentation.onCallLog(this._sdkObject, this.metadata, this._logName, message);
-      },
-      cleanupWhenAborted: (cleanup) => {
-        if (this._state !== "running")
-          throw new Error("Internal error: cannot register cleanup after operation has finished.");
-        this._cleanups.push(cleanup);
+        this._sdkObject.instrumentation.onCallLog(this._sdkObject, this.metadata, this._sdkObject.logName || "api", message);
       },
       metadata: this.metadata,
       race: (promise) => {
@@ -91,7 +80,6 @@ class ProgressController {
       return result;
     } catch (error) {
       this._state = { error };
-      await Promise.all(this._cleanups.splice(0).map((cleanup) => runCleanup(error, cleanup)));
       throw error;
     } finally {
       clearTimeout(timer);
@@ -99,12 +87,6 @@ class ProgressController {
     }
   }
 }
-async function runCleanup(error, cleanup) {
-  try {
-    await cleanup(error);
-  } catch (e) {
-  }
-}
 const kAbortErrorSymbol = Symbol("kAbortError");
 function isAbortError(error) {
   return !!error[kAbortErrorSymbol];

package/lib/server/recorder/recorderUtils.js

@@ -22,7 +22,6 @@ __export(recorderUtils_exports, {
   collapseActions: () => collapseActions,
   frameForAction: () => frameForAction,
   generateFrameSelector: () => generateFrameSelector,
-  isAssertAction: () => isAssertAction,
   mainFrameForAction: () => mainFrameForAction,
   metadataToCallLog: () => metadataToCallLog,
   shouldMergeAction: () => shouldMergeAction
@@ -76,9 +75,6 @@ async function frameForAction(pageAliases, actionInContext, action) {
     throw new Error("Internal error: frame not found");
   return result.frame;
 }
-function isAssertAction(action) {
-  return action.name.startsWith("assert");
-}
 function isSameAction(a, b) {
   return a.action.name === b.action.name && a.frame.pageAlias === b.frame.pageAlias && a.frame.framePath.join("|") === b.frame.framePath.join("|");
 }
@@ -155,7 +151,6 @@ async function generateFrameSelectorInParent(parent, frame) {
   collapseActions,
   frameForAction,
   generateFrameSelector,
-  isAssertAction,
   mainFrameForAction,
   metadataToCallLog,
   shouldMergeAction

package/lib/server/recorder.js

@@ -48,8 +48,6 @@ var import_utils2 = require("./../utils");
 var import_frames = require("./frames");
 var import_page = require("./page");
 var import_recorderRunner = require("./recorder/recorderRunner");
-var import_ariaSnapshot = require("../utils/isomorphic/ariaSnapshot");
-var import_utilsBundle = require("../utilsBundle");
 const recorderSymbol = Symbol("recorderSymbol");
 const RecorderEvent = {
   PausedStateChanged: "pausedStateChanged",
@@ -442,58 +440,9 @@ class Recorder extends import_events.default {
     };
     return actionInContext;
   }
-  async _maybeGenerateAssertAction(frame, actionInContext) {
-    const lastAction = getLastFrameAction(frame);
-    if ((0, import_recorderUtils.isAssertAction)(actionInContext.action))
-      return;
-    if (lastAction && ((0, import_recorderUtils.isAssertAction)(lastAction.action) || (0, import_recorderUtils.shouldMergeAction)(actionInContext, lastAction)))
-      return;
-    const newSnapshot = actionInContext.action.ariaSnapshot;
-    if (!newSnapshot)
-      return;
-    const lastSnapshot = lastAction?.action.ariaSnapshot || `- document [ref=e1]
-`;
-    if (!lastSnapshot)
-      return;
-    const callMetadata = (0, import_instrumentation.serverSideCallMetadata)();
-    const controller = new import_progress.ProgressController(callMetadata, frame);
-    const selector = await controller.run(async (progress) => {
-      const ref = (0, import_ariaSnapshot.findNewElementRef)(import_utilsBundle.yaml, lastSnapshot, newSnapshot);
-      if (!ref)
-        return;
-      const { resolvedSelector } = await frame.resolveSelector(progress, `aria-ref=${ref}`, { mainWorld: true }).catch(() => ({ resolvedSelector: void 0 }));
-      if (!resolvedSelector)
-        return;
-      const isVisible = await frame._page.mainFrame().isVisible(progress, resolvedSelector, { strict: true }).catch(() => false);
-      return isVisible ? resolvedSelector : void 0;
-    }).catch(() => void 0);
-    if (!selector)
-      return;
-    if (!actionInContext.frame.framePath.length && "selector" in actionInContext.action && actionInContext.action.selector === selector)
-      return;
-    const assertActionInContext = {
-      frame: {
-        pageGuid: actionInContext.frame.pageGuid,
-        pageAlias: actionInContext.frame.pageAlias,
-        framePath: []
-      },
-      action: {
-        name: "assertVisible",
-        selector,
-        signals: []
-      },
-      startTime: actionInContext.startTime,
-      endTime: actionInContext.startTime
-    };
-    return assertActionInContext;
-  }
   async _performAction(frame, action) {
     const actionInContext = await this._createActionInContext(frame, action);
-    const assertActionInContext = await this._maybeGenerateAssertAction(frame, actionInContext);
-    if (assertActionInContext)
-      this._signalProcessor.addAction(assertActionInContext);
     this._signalProcessor.addAction(actionInContext);
-    setLastFrameAction(frame, actionInContext);
     if (actionInContext.action.name !== "openPage" && actionInContext.action.name !== "closePage")
       await (0, import_recorderRunner.performAction)(this._pageAliases, actionInContext);
     actionInContext.endTime = (0, import_utils2.monotonicTime)();
@@ -501,7 +450,6 @@ class Recorder extends import_events.default {
   async _recordAction(frame, action) {
     const actionInContext = await this._createActionInContext(frame, action);
     this._signalProcessor.addAction(actionInContext);
-    setLastFrameAction(frame, actionInContext);
   }
   _onFrameNavigated(frame, page) {
     const pageAlias = this._pageAliases.get(page);
@@ -535,13 +483,6 @@ function languageForFile(file) {
     return "csharp";
   return "javascript";
 }
-const kLastFrameActionSymbol = Symbol("lastFrameAction");
-function getLastFrameAction(frame) {
-  return frame[kLastFrameActionSymbol];
-}
-function setLastFrameAction(frame, action) {
-  frame[kLastFrameActionSymbol] = action;
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Recorder,

package/lib/server/socksClientCertificatesInterceptor.js

@@ -175,9 +175,7 @@ class SocksProxyConnection {
           "Content-Length: " + Buffer.byteLength(responseBody),
           "",
           responseBody
-        ].join("\r\n"), () => {
-          this._browserEncrypted.destroy();
-        });
+        ].join("\r\n"));
       }
     });
   }

package/lib/server/webkit/wkBrowser.js

@@ -210,12 +210,9 @@ class WKBrowserContext extends import_browserContext.BrowserContext {
   possiblyUninitializedPages() {
     return this._wkPages().map((wkPage) => wkPage._page);
   }
-  async doCreateNewPage(markAsServerSideOnly) {
+  async doCreateNewPage() {
     const { pageProxyId } = await this._browser._browserSession.send("Playwright.createPage", { browserContextId: this._browserContextId });
-    const page = this._browser._wkPages.get(pageProxyId)._page;
-    if (markAsServerSideOnly)
-      page.markAsServerSideOnly();
-    return page;
+    return this._browser._wkPages.get(pageProxyId)._page;
   }
   async doGetCookies(urls) {
     const { cookies } = await this._browser._browserSession.send("Playwright.getAllCookies", { browserContextId: this._browserContextId });

package/lib/server/webkit/wkPage.js

@@ -100,7 +100,7 @@ class WKPage {
     }
   }
   async _initializePageProxySession() {
-    if (this._page.browserContext.isCreatingStorageStatePage())
+    if (this._page.isStorageStatePage)
       return;
     const promises = [
       this._pageProxySession.send("Dialog.enable"),
@@ -169,7 +169,7 @@ class WKPage {
       promises.push(session.send("Network.setResourceCachingDisabled", { disabled: true }));
       promises.push(session.send("Network.addInterception", { url: ".*", stage: "request", isRegex: true }));
     }
-    if (this._page.browserContext.isCreatingStorageStatePage()) {
+    if (this._page.isStorageStatePage) {
       await Promise.all(promises);
       return;
     }

package/lib/utils/isomorphic/ariaSnapshot.js

@@ -20,7 +20,6 @@ var ariaSnapshot_exports = {};
 __export(ariaSnapshot_exports, {
   KeyParser: () => KeyParser,
   ParserError: () => ParserError,
-  findNewElementRef: () => findNewElementRef,
   parseAriaSnapshot: () => parseAriaSnapshot,
   parseAriaSnapshotUnsafe: () => parseAriaSnapshotUnsafe,
   valueOrRegex: () => valueOrRegex
@@ -333,10 +332,6 @@ class KeyParser {
     return result;
   }
   _applyAttribute(node, key, value, errorPos) {
-    if (this._options.allowRef && key === "ref") {
-      node.ref = value;
-      return;
-    }
     if (key === "checked") {
       this._assert(value === "true" || value === "false" || value === "mixed", 'Value of "checked" attribute must be a boolean or "mixed"', errorPos);
       node.checked = value === "true" ? true : value === "false" ? false : "mixed";
@@ -372,8 +367,6 @@ class KeyParser {
       node.selected = value === "true";
       return;
     }
-    if (this._options.allowUnknownAttributes)
-      return;
     this._assert(false, `Unsupported attribute [${key}]`, errorPos);
   }
   _assert(value, message, valuePos) {
@@ -387,56 +380,10 @@ class ParserError extends Error {
     this.pos = pos;
   }
 }
-function findNewElementRef(yaml, fromSnapshot, toSnapshot) {
-  function fillMap(root, map, position) {
-    let size = 1;
-    let childPosition = position + size;
-    for (const child of root.children || []) {
-      if (child.kind === "role") {
-        size += fillMap(child, map, childPosition);
-        childPosition += size;
-      } else {
-        size++;
-        childPosition++;
-      }
-    }
-    if (!["none", "presentation", "fragment", "iframe", "generic"].includes(root.role) && typeof root.name === "string" && root.name) {
-      let byRole = map.get(root.role);
-      if (!byRole) {
-        byRole = /* @__PURE__ */ new Map();
-        map.set(root.role, byRole);
-      }
-      const existing = byRole.get(root.name);
-      const sizeAndPosition = size * 100 - position;
-      if (!existing || existing.sizeAndPosition < sizeAndPosition)
-        byRole.set(root.name, { node: root, sizeAndPosition });
-    }
-    return size;
-  }
-  const fromMap = /* @__PURE__ */ new Map();
-  const from = parseAriaSnapshotUnsafe(yaml, fromSnapshot, { allowRef: true, allowUnknownAttributes: true });
-  if (from.kind === "role")
-    fillMap(from, fromMap, 0);
-  const toMap = /* @__PURE__ */ new Map();
-  const to = parseAriaSnapshotUnsafe(yaml, toSnapshot, { allowRef: true, allowUnknownAttributes: true });
-  if (to.kind === "role")
-    fillMap(to, toMap, 0);
-  const result = [];
-  for (const [role, byRole] of toMap) {
-    for (const [name, byName] of byRole) {
-      const inFrom = fromMap.get(role)?.get(name);
-      if (!inFrom)
-        result.push(byName);
-    }
-  }
-  result.sort((a, b) => b.sizeAndPosition - a.sizeAndPosition);
-  return result.find((r) => r.node.ref)?.node.ref;
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   KeyParser,
   ParserError,
-  findNewElementRef,
   parseAriaSnapshot,
   parseAriaSnapshotUnsafe,
   valueOrRegex