patchright-core 1.57.0 → 1.58.2

package/lib/server/webkit/wkPage.js

@@ -31,10 +31,8 @@ __export(wkPage_exports, {
   WKPage: () => WKPage
 });
 module.exports = __toCommonJS(wkPage_exports);
-var import_path = __toESM(require("path"));
 var import_utils = require("../../utils");
 var import_headers = require("../../utils/isomorphic/headers");
-var import_crypto = require("../utils/crypto");
 var import_eventsHelper = require("../utils/eventsHelper");
 var import_hostPlatform = require("../utils/hostPlatform");
 var import_stackTrace = require("../../utils/isomorphic/stackTrace");
@@ -51,12 +49,14 @@ var import_wkInput = require("./wkInput");
 var import_wkInterceptableRequest = require("./wkInterceptableRequest");
 var import_wkProvisionalPage = require("./wkProvisionalPage");
 var import_wkWorkers = require("./wkWorkers");
-var import_debugLogger = require("../utils/debugLogger");
 var import_webkit = require("./webkit");
+var import_registry = require("../registry");
 const UTILITY_WORLD_NAME = "__playwright_utility_world__";
+const enableFrameSessions = !process.env.WK_DISABLE_FRAME_SESSIONS && parseInt(import_registry.registry.findExecutable("webkit").revision, 10) >= 2245;
 class WKPage {
   constructor(browserContext, pageProxySession, opener) {
     this._provisionalPage = null;
+    this._targetIdToFrameSession = /* @__PURE__ */ new Map();
     this._requestIdToRequest = /* @__PURE__ */ new Map();
     this._requestIdToRequestWillBeSentEvent = /* @__PURE__ */ new Map();
     this._sessionListeners = [];
@@ -66,7 +66,6 @@ class WKPage {
     };
     this._lastConsoleMessage = null;
     this._requestIdToResponseReceivedPayloadEvent = /* @__PURE__ */ new Map();
-    this._recordingVideoFile = null;
     this._screencastGeneration = 0;
     this._pageProxySession = pageProxySession;
     this._opener = opener;
@@ -116,16 +115,7 @@ class WKPage {
       for (const [key, value] of this._browserContext._permissions)
         promises.push(this._grantPermissions(key, value));
     }
-    if (this._browserContext._options.recordVideo) {
-      const outputFile = import_path.default.join(this._browserContext._options.recordVideo.dir, (0, import_crypto.createGuid)() + ".webm");
-      promises.push(this._browserContext._ensureVideosPath().then(() => {
-        return this._startVideo({
-          // validateBrowserContextOptions ensures correct video size.
-          ...this._browserContext._options.recordVideo.size,
-          outputFile
-        });
-      }));
-    }
+    promises.push(this._initializeVideoRecording());
     await Promise.all(promises);
   }
   _setSession(session) {
@@ -159,10 +149,13 @@ class WKPage {
       session.send("Page.createUserWorld", { name: UTILITY_WORLD_NAME }).catch((_) => {
       }),
       // Worlds are per-process
-      session.send("Console.enable"),
       session.send("Network.enable"),
       this._workers.initializeSession(session)
     ];
+    if (enableFrameSessions)
+      this._initializeFrameSessions(frameTree.frameTree, promises);
+    else
+      promises.push(session.send("Console.enable"));
     if (this._page.browserContext.needsPlaywrightBinding())
       promises.push(session.send("Runtime.addBinding", { name: import_page.PageBinding.kBindingName }));
     if (this._page.needsRequestInterception()) {
@@ -219,6 +212,13 @@ class WKPage {
     promises.push(session.send("Page.overrideSetting", { setting: "FixedBackgroundsPaintRelativeToDocument", value: contextOptions.isMobile }));
     await Promise.all(promises);
   }
+  _initializeFrameSessions(frame, promises) {
+    const session = this._targetIdToFrameSession.get(`frame-${frame.frame.id}`);
+    if (session)
+      promises.push(session.initialize());
+    for (const childFrame of frame.childFrames || [])
+      this._initializeFrameSessions(childFrame, promises);
+  }
   _onDidCommitProvisionalTarget(event) {
     const { oldTargetId, newTargetId } = event;
     (0, import_utils.assert)(this._provisionalPage);
@@ -244,6 +244,9 @@ class WKPage {
         this._session.markAsCrashed();
         this._page._didCrash();
       }
+    } else if (this._targetIdToFrameSession.has(targetId)) {
+      this._targetIdToFrameSession.get(targetId).dispose();
+      this._targetIdToFrameSession.delete(targetId);
     }
   }
   didClose() {
@@ -257,7 +260,7 @@ class WKPage {
       this._provisionalPage.dispose();
       this._provisionalPage = null;
     }
-    this._firstNonInitialNavigationCommittedReject(new import_errors.TargetClosedError());
+    this._firstNonInitialNavigationCommittedReject(new import_errors.TargetClosedError(this._page.closeReason()));
     this._page._didClose();
   }
   dispatchMessageToSession(message) {
@@ -288,8 +291,15 @@ class WKPage {
         session.dispatchMessage({ id: message.id, error: { message: e.message } });
       });
     });
-    if (targetInfo.type === "frame")
+    if (targetInfo.type === "frame") {
+      if (enableFrameSessions) {
+        const wkFrame = new WKFrame(this, session);
+        this._targetIdToFrameSession.set(targetInfo.targetId, wkFrame);
+        await wkFrame.initialize().catch((e) => {
+        });
+      }
       return;
+    }
     (0, import_utils.assert)(targetInfo.type === "page", "Only page targets are expected in WebKit, received: " + targetInfo.type);
     if (!targetInfo.isProvisional) {
       (0, import_utils.assert)(!this._page.initializedOrUndefined());
@@ -331,6 +341,8 @@ class WKPage {
       this._provisionalPage._session.dispatchMessage(JSON.parse(message));
     else if (this._session.sessionId === targetId)
       this._session.dispatchMessage(JSON.parse(message));
+    else if (this._targetIdToFrameSession.has(targetId))
+      this._targetIdToFrameSession.get(targetId)._session.dispatchMessage(JSON.parse(message));
     else
       throw new Error("Unknown target: " + targetId);
   }
@@ -453,7 +465,7 @@ class WKPage {
   }
   async navigateFrame(frame, url, referrer) {
     if (this._pageProxySession.isDisposed())
-      throw new import_errors.TargetClosedError();
+      throw new import_errors.TargetClosedError(this._page.closeReason());
     const pageProxyId = this._pageProxySession.sessionId;
     const result = await this._pageProxySession.connection.browserSession.send("Playwright.navigate", { url, pageProxyId, frameId: frame._id, referrer });
     return { newDocumentId: result.loaderId };
@@ -748,7 +760,6 @@ class WKPage {
     await this._updateState("Page.setBootstrapScript", { source: this._calculateBootstrapScript() });
   }
   async closePage(runBeforeUnload) {
-    await this._stopVideo();
     await this._pageProxySession.sendMayFail("Target.close", {
       targetId: this._session.sessionId,
       runBeforeUnload
@@ -762,22 +773,11 @@ class WKPage {
       return import_hostPlatform.hostPlatform === "mac10.15" ? 55 : 59;
     return 0;
   }
-  async _startVideo(options) {
-    (0, import_utils.assert)(!this._recordingVideoFile);
-    const { screencastId } = await this._pageProxySession.send("Screencast.startVideo", {
-      file: this._browserContext._browser.options.channel === "webkit-wsl" ? await (0, import_webkit.translatePathToWSL)(options.outputFile) : options.outputFile,
-      width: options.width,
-      height: options.height,
-      toolbarHeight: this._toolbarHeight()
-    });
-    this._recordingVideoFile = options.outputFile;
-    this._browserContext._browser._videoStarted(this._browserContext, screencastId, options.outputFile, this._page.waitForInitializedOrError());
-  }
-  async _stopVideo() {
-    if (!this._recordingVideoFile)
-      return;
-    await this._pageProxySession.sendMayFail("Screencast.stopVideo");
-    this._recordingVideoFile = null;
+  async _initializeVideoRecording() {
+    const screencast = this._page.screencast;
+    const videoOptions = screencast.launchVideoRecorder();
+    if (videoOptions)
+      await screencast.startVideoRecording(videoOptions);
   }
   validateScreenshotDimension(side, omitDeviceScaleFactor) {
     if (process.platform === "darwin")
@@ -845,23 +845,27 @@ class WKPage {
       throw e;
     });
   }
-  async setScreencastOptions(options) {
-    if (options) {
-      const so = { ...options, toolbarHeight: this._toolbarHeight() };
-      const { generation } = await this._pageProxySession.send("Screencast.startScreencast", so);
-      this._screencastGeneration = generation;
-    } else {
-      await this._pageProxySession.send("Screencast.stopScreencast");
-    }
+  async startScreencast(options) {
+    const { generation } = await this._pageProxySession.send("Screencast.startScreencast", {
+      quality: options.quality,
+      width: options.width,
+      height: options.height,
+      toolbarHeight: this._toolbarHeight()
+    });
+    this._screencastGeneration = generation;
+  }
+  async stopScreencast() {
+    await this._pageProxySession.sendMayFail("Screencast.stopScreencast");
   }
   _onScreencastFrame(event) {
     const generation = this._screencastGeneration;
-    this._page.throttleScreencastFrameAck(() => {
-      this._pageProxySession.send("Screencast.screencastFrameAck", { generation }).catch((e) => import_debugLogger.debugLogger.log("error", e));
+    this._page.screencast.throttleFrameAck(() => {
+      this._pageProxySession.sendMayFail("Screencast.screencastFrameAck", { generation });
     });
     const buffer = Buffer.from(event.data, "base64");
     this._page.emit(import_page.Page.Events.ScreencastFrame, {
       buffer,
+      frameSwapWallTime: event.timestamp ? event.timestamp * 1e3 : Date.now(),
       width: event.deviceWidth,
       height: event.deviceHeight
     });
@@ -886,7 +890,7 @@ class WKPage {
     const pageProxyId = this._pageProxySession.sessionId;
     const objectId = handle._objectId;
     if (this._browserContext._browser?.options.channel === "webkit-wsl")
-      paths = await Promise.all(paths.map((path2) => (0, import_webkit.translatePathToWSL)(path2)));
+      paths = await Promise.all(paths.map((path) => (0, import_webkit.translatePathToWSL)(path)));
     await Promise.all([
       this._pageProxySession.connection.browserSession.send("Playwright.grantFileReadAccess", { pageProxyId, paths }),
       this._session.send("DOM.setInputFiles", { objectId, paths })
@@ -1085,6 +1089,31 @@ class WKPage {
     return true;
   }
 }
+class WKFrame {
+  constructor(page, session) {
+    this._sessionListeners = [];
+    this._initializePromise = null;
+    this._page = page;
+    this._session = session;
+  }
+  async initialize() {
+    if (this._initializePromise)
+      return this._initializePromise;
+    this._initializePromise = this._initializeImpl();
+    return this._initializePromise;
+  }
+  async _initializeImpl() {
+    this._sessionListeners = [
+      import_eventsHelper.eventsHelper.addEventListener(this._session, "Console.messageAdded", (event) => this._page._onConsoleMessage(event)),
+      import_eventsHelper.eventsHelper.addEventListener(this._session, "Console.messageRepeatCountUpdated", (event) => this._page._onConsoleRepeatCountUpdated(event))
+    ];
+    await this._session.send("Console.enable");
+  }
+  dispose() {
+    import_eventsHelper.eventsHelper.removeEventListeners(this._sessionListeners);
+    this._session.dispose();
+  }
+}
 function parseRemoteAddress(value) {
   if (!value)
     return;

package/lib/utils/isomorphic/ariaSnapshot.js

@@ -20,12 +20,26 @@ var ariaSnapshot_exports = {};
 __export(ariaSnapshot_exports, {
   KeyParser: () => KeyParser,
   ParserError: () => ParserError,
-  ariaPropsEqual: () => ariaPropsEqual,
+  ariaNodesEqual: () => ariaNodesEqual,
+  findNewNode: () => findNewNode,
+  hasPointerCursor: () => hasPointerCursor,
   parseAriaSnapshot: () => parseAriaSnapshot,
   parseAriaSnapshotUnsafe: () => parseAriaSnapshotUnsafe,
   textValue: () => textValue
 });
 module.exports = __toCommonJS(ariaSnapshot_exports);
+function ariaNodesEqual(a, b) {
+  if (a.role !== b.role || a.name !== b.name)
+    return false;
+  if (!ariaPropsEqual(a, b) || hasPointerCursor(a) !== hasPointerCursor(b))
+    return false;
+  const aKeys = Object.keys(a.props);
+  const bKeys = Object.keys(b.props);
+  return aKeys.length === bKeys.length && aKeys.every((k) => a.props[k] === b.props[k]);
+}
+function hasPointerCursor(ariaNode) {
+  return ariaNode.box.cursor === "pointer";
+}
 function ariaPropsEqual(a, b) {
   return a.active === b.active && a.checked === b.checked && a.disabled === b.disabled && a.expanded === b.expanded && a.selected === b.selected && a.level === b.level && a.pressed === b.pressed;
 }
@@ -386,11 +400,55 @@ class ParserError extends Error {
     this.pos = pos;
   }
 }
+function findNewNode(from, to) {
+  function fillMap(root, map, position) {
+    let size = 1;
+    let childPosition = position + size;
+    for (const child of root.children || []) {
+      if (typeof child === "string") {
+        size++;
+        childPosition++;
+      } else {
+        size += fillMap(child, map, childPosition);
+        childPosition += size;
+      }
+    }
+    if (!["none", "presentation", "fragment", "iframe", "generic"].includes(root.role) && 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();
+  if (from)
+    fillMap(from, fromMap, 0);
+  const toMap = /* @__PURE__ */ new Map();
+  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[0]?.node;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   KeyParser,
   ParserError,
-  ariaPropsEqual,
+  ariaNodesEqual,
+  findNewNode,
+  hasPointerCursor,
   parseAriaSnapshot,
   parseAriaSnapshotUnsafe,
   textValue

package/lib/utils/isomorphic/lruCache.js

@@ -0,0 +1,51 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lruCache_exports = {};
+__export(lruCache_exports, {
+  LRUCache: () => LRUCache
+});
+module.exports = __toCommonJS(lruCache_exports);
+class LRUCache {
+  constructor(maxSize) {
+    this._maxSize = maxSize;
+    this._map = /* @__PURE__ */ new Map();
+    this._size = 0;
+  }
+  getOrCompute(key, compute) {
+    if (this._map.has(key)) {
+      const result2 = this._map.get(key);
+      this._map.delete(key);
+      this._map.set(key, result2);
+      return result2.value;
+    }
+    const result = compute();
+    while (this._map.size && this._size + result.size > this._maxSize) {
+      const [firstKey, firstValue] = this._map.entries().next().value;
+      this._size -= firstValue.size;
+      this._map.delete(firstKey);
+    }
+    this._map.set(key, result);
+    this._size += result.size;
+    return result.value;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LRUCache
+});

package/lib/utils/isomorphic/protocolMetainfo.js

@@ -71,6 +71,7 @@ const methodMetainfo = /* @__PURE__ */ new Map([
   ["WebSocket.waitForEventInfo", { title: 'Wait for event "{info.event}"', snapshot: true }],
   ["ElectronApplication.waitForEventInfo", { title: 'Wait for event "{info.event}"', snapshot: true }],
   ["AndroidDevice.waitForEventInfo", { title: 'Wait for event "{info.event}"', snapshot: true }],
+  ["PageAgent.waitForEventInfo", { title: 'Wait for event "{info.event}"', snapshot: true }],
   ["BrowserContext.addCookies", { title: "Add cookies", group: "configuration" }],
   ["BrowserContext.addInitScript", { title: "Add init script", group: "configuration" }],
   ["BrowserContext.clearCookies", { title: "Clear cookies", group: "configuration" }],
@@ -92,6 +93,7 @@ const methodMetainfo = /* @__PURE__ */ new Map([
   ["BrowserContext.pause", { title: "Pause" }],
   ["BrowserContext.enableRecorder", { internal: true }],
   ["BrowserContext.disableRecorder", { internal: true }],
+  ["BrowserContext.exposeConsoleApi", { internal: true }],
   ["BrowserContext.newCDPSession", { title: "Create CDP session", group: "configuration" }],
   ["BrowserContext.harStart", { internal: true }],
   ["BrowserContext.harExport", { internal: true }],
@@ -143,6 +145,7 @@ const methodMetainfo = /* @__PURE__ */ new Map([
   ["Page.stopCSSCoverage", { title: "Stop CSS coverage", group: "configuration" }],
   ["Page.bringToFront", { title: "Bring to front" }],
   ["Page.updateSubscription", { internal: true }],
+  ["Page.agent", { internal: true }],
   ["Frame.evalOnSelector", { title: "Evaluate", snapshot: true, pausesBeforeAction: true }],
   ["Frame.evalOnSelectorAll", { title: "Evaluate", snapshot: true, pausesBeforeAction: true }],
   ["Frame.addScriptTag", { title: "Add script tag", snapshot: true, pausesBeforeAction: true }],
@@ -314,7 +317,12 @@ const methodMetainfo = /* @__PURE__ */ new Map([
   ["AndroidDevice.connectToWebView", { title: "Connect to Web View" }],
   ["AndroidDevice.close", { internal: true }],
   ["JsonPipe.send", { internal: true }],
-  ["JsonPipe.close", { internal: true }]
+  ["JsonPipe.close", { internal: true }],
+  ["PageAgent.perform", { title: 'Perform "{task}"' }],
+  ["PageAgent.expect", { title: 'Expect "{expectation}"' }],
+  ["PageAgent.extract", { title: 'Extract "{query}"' }],
+  ["PageAgent.dispose", { internal: true }],
+  ["PageAgent.usage", { title: "Get agent usage", group: "configuration" }]
 ]);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/utils/isomorphic/stringUtils.js

@@ -18,6 +18,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var stringUtils_exports = {};
 __export(stringUtils_exports, {
+  ansiRegex: () => ansiRegex,
   cacheNormalizedWhitespaces: () => cacheNormalizedWhitespaces,
   escapeForAttributeSelector: () => escapeForAttributeSelector,
   escapeForTextSelector: () => escapeForTextSelector,
@@ -26,11 +27,15 @@ __export(stringUtils_exports, {
   escapeRegExp: () => escapeRegExp,
   escapeTemplateString: () => escapeTemplateString,
   escapeWithQuotes: () => escapeWithQuotes,
+  formatObject: () => formatObject,
+  formatObjectOrVoid: () => formatObjectOrVoid,
   isString: () => isString,
   longestCommonSubstring: () => longestCommonSubstring,
   normalizeEscapedRegexQuotes: () => normalizeEscapedRegexQuotes,
   normalizeWhiteSpace: () => normalizeWhiteSpace,
+  parseRegex: () => parseRegex,
   quoteCSSAttributeValue: () => quoteCSSAttributeValue,
+  stripAnsiEscapes: () => stripAnsiEscapes,
   toSnakeCase: () => toSnakeCase,
   toTitleCase: () => toTitleCase,
   trimString: () => trimString,
@@ -60,6 +65,31 @@ function toTitleCase(name) {
 function toSnakeCase(name) {
   return name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").toLowerCase();
 }
+function formatObject(value, indent = "  ", mode = "multiline") {
+  if (typeof value === "string")
+    return escapeWithQuotes(value, "'");
+  if (Array.isArray(value))
+    return `[${value.map((o) => formatObject(o)).join(", ")}]`;
+  if (typeof value === "object") {
+    const keys = Object.keys(value).filter((key) => value[key] !== void 0).sort();
+    if (!keys.length)
+      return "{}";
+    const tokens = [];
+    for (const key of keys)
+      tokens.push(`${key}: ${formatObject(value[key])}`);
+    if (mode === "multiline")
+      return `{
+${tokens.join(`,
+${indent}`)}
+}`;
+    return `{ ${tokens.join(", ")} }`;
+  }
+  return String(value);
+}
+function formatObjectOrVoid(value, indent = "  ") {
+  const result = formatObject(value, indent);
+  return result === "{}" ? "" : result;
+}
 function quoteCSSAttributeValue(text) {
   return `"${text.replace(/["\\]/g, (char) => "\\" + char)}"`;
 }
@@ -133,8 +163,23 @@ function longestCommonSubstring(s1, s2) {
   }
   return s1.slice(endingIndex - maxLen, endingIndex);
 }
+function parseRegex(regex) {
+  if (regex[0] !== "/")
+    throw new Error(`Invalid regex, must start with '/': ${regex}`);
+  const lastSlash = regex.lastIndexOf("/");
+  if (lastSlash <= 0)
+    throw new Error(`Invalid regex, must end with '/' followed by optional flags: ${regex}`);
+  const source = regex.slice(1, lastSlash);
+  const flags = regex.slice(lastSlash + 1);
+  return new RegExp(source, flags);
+}
+const ansiRegex = new RegExp("([\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~])))", "g");
+function stripAnsiEscapes(str) {
+  return str.replace(ansiRegex, "");
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ansiRegex,
   cacheNormalizedWhitespaces,
   escapeForAttributeSelector,
   escapeForTextSelector,
@@ -143,11 +188,15 @@ function longestCommonSubstring(s1, s2) {
   escapeRegExp,
   escapeTemplateString,
   escapeWithQuotes,
+  formatObject,
+  formatObjectOrVoid,
   isString,
   longestCommonSubstring,
   normalizeEscapedRegexQuotes,
   normalizeWhiteSpace,
+  parseRegex,
   quoteCSSAttributeValue,
+  stripAnsiEscapes,
   toSnakeCase,
   toTitleCase,
   trimString,

package/lib/utils/isomorphic/trace/entries.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var entries_exports = {};
+module.exports = __toCommonJS(entries_exports);