@browsermation/browser-engine 0.0.12 → 0.0.16

package/dist/node_modules/playwright-core/lib/server/harBackend.js

@@ -0,0 +1,157 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var harBackend_exports = {};
+__export(harBackend_exports, {
+  HarBackend: () => HarBackend
+});
+module.exports = __toCommonJS(harBackend_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_crypto = require("./utils/crypto");
+const redirectStatus = [301, 302, 303, 307, 308];
+class HarBackend {
+  constructor(harFile, baseDir, zipFile) {
+    this.id = (0, import_crypto.createGuid)();
+    this._harFile = harFile;
+    this._baseDir = baseDir;
+    this._zipFile = zipFile;
+  }
+  async lookup(url, method, headers, postData, isNavigationRequest) {
+    let entry;
+    try {
+      entry = await this._harFindResponse(url, method, headers, postData);
+    } catch (e) {
+      return { action: "error", message: "HAR error: " + e.message };
+    }
+    if (!entry)
+      return { action: "noentry" };
+    if (entry.request.url !== url && isNavigationRequest)
+      return { action: "redirect", redirectURL: entry.request.url };
+    const response = entry.response;
+    try {
+      const buffer = await this._loadContent(response.content);
+      return {
+        action: "fulfill",
+        status: response.status,
+        headers: response.headers,
+        body: buffer
+      };
+    } catch (e) {
+      return { action: "error", message: e.message };
+    }
+  }
+  async _loadContent(content) {
+    const file = content._file;
+    let buffer;
+    if (file) {
+      if (this._zipFile)
+        buffer = await this._zipFile.read(file);
+      else
+        buffer = await import_fs.default.promises.readFile(import_path.default.resolve(this._baseDir, file));
+    } else {
+      buffer = Buffer.from(content.text || "", content.encoding === "base64" ? "base64" : "utf-8");
+    }
+    return buffer;
+  }
+  async _harFindResponse(url, method, headers, postData) {
+    const harLog = this._harFile.log;
+    const visited = /* @__PURE__ */ new Set();
+    while (true) {
+      const entries = [];
+      for (const candidate of harLog.entries) {
+        if (candidate.request.url !== url || candidate.request.method !== method)
+          continue;
+        if (method === "POST" && postData && candidate.request.postData) {
+          const buffer = await this._loadContent(candidate.request.postData);
+          if (!buffer.equals(postData)) {
+            const boundary = multipartBoundary(headers);
+            if (!boundary)
+              continue;
+            const candidataBoundary = multipartBoundary(candidate.request.headers);
+            if (!candidataBoundary)
+              continue;
+            if (postData.toString().replaceAll(boundary, "") !== buffer.toString().replaceAll(candidataBoundary, ""))
+              continue;
+          }
+        }
+        entries.push(candidate);
+      }
+      if (!entries.length)
+        return;
+      let entry = entries[0];
+      if (entries.length > 1) {
+        const list = [];
+        for (const candidate of entries) {
+          const matchingHeaders = countMatchingHeaders(candidate.request.headers, headers);
+          list.push({ candidate, matchingHeaders });
+        }
+        list.sort((a, b) => b.matchingHeaders - a.matchingHeaders);
+        entry = list[0].candidate;
+      }
+      if (visited.has(entry))
+        throw new Error(`Found redirect cycle for ${url}`);
+      visited.add(entry);
+      const locationHeader = entry.response.headers.find((h) => h.name.toLowerCase() === "location");
+      if (redirectStatus.includes(entry.response.status) && locationHeader) {
+        const locationURL = new URL(locationHeader.value, url);
+        url = locationURL.toString();
+        if ((entry.response.status === 301 || entry.response.status === 302) && method === "POST" || entry.response.status === 303 && !["GET", "HEAD"].includes(method)) {
+          method = "GET";
+        }
+        continue;
+      }
+      return entry;
+    }
+  }
+  dispose() {
+    this._zipFile?.close();
+  }
+}
+function countMatchingHeaders(harHeaders, headers) {
+  const set = new Set(headers.map((h) => h.name.toLowerCase() + ":" + h.value));
+  let matches = 0;
+  for (const h of harHeaders) {
+    if (set.has(h.name.toLowerCase() + ":" + h.value))
+      ++matches;
+  }
+  return matches;
+}
+function multipartBoundary(headers) {
+  const contentType = headers.find((h) => h.name.toLowerCase() === "content-type");
+  if (!contentType?.value.includes("multipart/form-data"))
+    return void 0;
+  const boundary = contentType.value.match(/boundary=(\S+)/);
+  if (boundary)
+    return boundary[1];
+  return void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HarBackend
+});

package/dist/node_modules/playwright-core/lib/server/helper.js

@@ -0,0 +1,96 @@
+"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 helper_exports = {};
+__export(helper_exports, {
+  helper: () => helper
+});
+module.exports = __toCommonJS(helper_exports);
+var import_debugLogger = require("./utils/debugLogger");
+var import_eventsHelper = require("./utils/eventsHelper");
+const MAX_LOG_LENGTH = process.env.MAX_LOG_LENGTH ? +process.env.MAX_LOG_LENGTH : Infinity;
+class Helper {
+  static completeUserURL(urlString) {
+    if (urlString.startsWith("localhost") || urlString.startsWith("127.0.0.1"))
+      urlString = "http://" + urlString;
+    return urlString;
+  }
+  static enclosingIntRect(rect) {
+    const x = Math.floor(rect.x + 1e-3);
+    const y = Math.floor(rect.y + 1e-3);
+    const x2 = Math.ceil(rect.x + rect.width - 1e-3);
+    const y2 = Math.ceil(rect.y + rect.height - 1e-3);
+    return { x, y, width: x2 - x, height: y2 - y };
+  }
+  static enclosingIntSize(size) {
+    return { width: Math.floor(size.width + 1e-3), height: Math.floor(size.height + 1e-3) };
+  }
+  static getViewportSizeFromWindowFeatures(features) {
+    const widthString = features.find((f) => f.startsWith("width="));
+    const heightString = features.find((f) => f.startsWith("height="));
+    const width = widthString ? parseInt(widthString.substring(6), 10) : NaN;
+    const height = heightString ? parseInt(heightString.substring(7), 10) : NaN;
+    if (!Number.isNaN(width) && !Number.isNaN(height))
+      return { width, height };
+    return null;
+  }
+  static waitForEvent(progress, emitter, event, predicate) {
+    const listeners = [];
+    const dispose = () => import_eventsHelper.eventsHelper.removeEventListeners(listeners);
+    const promise = progress.race(new Promise((resolve, reject) => {
+      listeners.push(import_eventsHelper.eventsHelper.addEventListener(emitter, event, (eventArg) => {
+        try {
+          if (predicate && !predicate(eventArg))
+            return;
+          resolve(eventArg);
+        } catch (e) {
+          reject(e);
+        }
+      }));
+    })).finally(() => dispose());
+    return { promise, dispose };
+  }
+  static secondsToRoundishMillis(value) {
+    return (value * 1e6 | 0) / 1e3;
+  }
+  static millisToRoundishMillis(value) {
+    return (value * 1e3 | 0) / 1e3;
+  }
+  static debugProtocolLogger(protocolLogger) {
+    return (direction, message) => {
+      if (protocolLogger)
+        protocolLogger(direction, message);
+      if (import_debugLogger.debugLogger.isEnabled("protocol")) {
+        let text = JSON.stringify(message);
+        if (text.length > MAX_LOG_LENGTH)
+          text = text.substring(0, MAX_LOG_LENGTH / 2) + " <<<<<( LOG TRUNCATED )>>>>> " + text.substring(text.length - MAX_LOG_LENGTH / 2);
+        import_debugLogger.debugLogger.log("protocol", (direction === "send" ? "SEND \u25BA " : "\u25C0 RECV ") + text);
+      }
+    };
+  }
+  static formatBrowserLogs(logs, disconnectReason) {
+    if (!disconnectReason && !logs.length)
+      return "";
+    return "\n" + (disconnectReason ? disconnectReason + "\n" : "") + logs.join("\n");
+  }
+}
+const helper = Helper;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  helper
+});

package/dist/node_modules/playwright-core/lib/server/index.js

@@ -0,0 +1,58 @@
+"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 server_exports = {};
+__export(server_exports, {
+  DispatcherConnection: () => import_dispatcher.DispatcherConnection,
+  PlaywrightDispatcher: () => import_playwrightDispatcher.PlaywrightDispatcher,
+  Registry: () => import_registry.Registry,
+  RootDispatcher: () => import_dispatcher.RootDispatcher,
+  createPlaywright: () => import_playwright.createPlaywright,
+  installBrowsersForNpmInstall: () => import_registry.installBrowsersForNpmInstall,
+  installRootRedirect: () => import_traceViewer.installRootRedirect,
+  openTraceInBrowser: () => import_traceViewer.openTraceInBrowser,
+  openTraceViewerApp: () => import_traceViewer.openTraceViewerApp,
+  registry: () => import_registry.registry,
+  registryDirectory: () => import_registry.registryDirectory,
+  runTraceViewerApp: () => import_traceViewer.runTraceViewerApp,
+  startTraceViewerServer: () => import_traceViewer.startTraceViewerServer,
+  writeDockerVersion: () => import_registry.writeDockerVersion
+});
+module.exports = __toCommonJS(server_exports);
+var import_registry = require("./registry");
+var import_dispatcher = require("./dispatchers/dispatcher");
+var import_playwrightDispatcher = require("./dispatchers/playwrightDispatcher");
+var import_playwright = require("./playwright");
+var import_traceViewer = require("./trace/viewer/traceViewer");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DispatcherConnection,
+  PlaywrightDispatcher,
+  Registry,
+  RootDispatcher,
+  createPlaywright,
+  installBrowsersForNpmInstall,
+  installRootRedirect,
+  openTraceInBrowser,
+  openTraceViewerApp,
+  registry,
+  registryDirectory,
+  runTraceViewerApp,
+  startTraceViewerServer,
+  writeDockerVersion
+});

package/dist/node_modules/playwright-core/lib/server/input.js

@@ -0,0 +1,277 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var input_exports = {};
+__export(input_exports, {
+  Keyboard: () => Keyboard,
+  Mouse: () => Mouse,
+  Touchscreen: () => Touchscreen,
+  keypadLocation: () => keypadLocation,
+  resolveSmartModifier: () => resolveSmartModifier,
+  resolveSmartModifierString: () => resolveSmartModifierString
+});
+module.exports = __toCommonJS(input_exports);
+var import_utils = require("../utils");
+var keyboardLayout = __toESM(require("./usKeyboardLayout"));
+var import_dom = require("./dom");
+const keypadLocation = keyboardLayout.keypadLocation;
+const kModifiers = ["Alt", "Control", "Meta", "Shift"];
+class Keyboard {
+  constructor(raw, page) {
+    this._pressedModifiers = /* @__PURE__ */ new Set();
+    this._pressedKeys = /* @__PURE__ */ new Set();
+    this._raw = raw;
+    this._page = page;
+  }
+  async down(progress, key) {
+    const description = this._keyDescriptionForString(key);
+    const autoRepeat = this._pressedKeys.has(description.code);
+    this._pressedKeys.add(description.code);
+    if (kModifiers.includes(description.key))
+      this._pressedModifiers.add(description.key);
+    await this._raw.keydown(progress, this._pressedModifiers, key, description, autoRepeat);
+  }
+  _keyDescriptionForString(str) {
+    const keyString = resolveSmartModifierString(str);
+    let description = usKeyboardLayout.get(keyString);
+    if (!description)
+      throw new import_dom.NonRecoverableDOMError(`Unknown key: "${keyString}"`);
+    const shift = this._pressedModifiers.has("Shift");
+    description = shift && description.shifted ? description.shifted : description;
+    if (this._pressedModifiers.size > 1 || !this._pressedModifiers.has("Shift") && this._pressedModifiers.size === 1)
+      return { ...description, text: "" };
+    return description;
+  }
+  async up(progress, key) {
+    const description = this._keyDescriptionForString(key);
+    if (kModifiers.includes(description.key))
+      this._pressedModifiers.delete(description.key);
+    this._pressedKeys.delete(description.code);
+    await this._raw.keyup(progress, this._pressedModifiers, key, description);
+  }
+  async insertText(progress, text) {
+    await this._raw.sendText(progress, text);
+  }
+  async type(progress, text, options) {
+    const delay = options && options.delay || void 0;
+    for (const char of text) {
+      if (usKeyboardLayout.has(char)) {
+        await this.press(progress, char, { delay });
+      } else {
+        if (delay)
+          await progress.wait(delay);
+        await this.insertText(progress, char);
+      }
+    }
+  }
+  async press(progress, key, options = {}) {
+    function split(keyString) {
+      const keys = [];
+      let building = "";
+      for (const char of keyString) {
+        if (char === "+" && building) {
+          keys.push(building);
+          building = "";
+        } else {
+          building += char;
+        }
+      }
+      keys.push(building);
+      return keys;
+    }
+    const tokens = split(key);
+    key = tokens[tokens.length - 1];
+    for (let i = 0; i < tokens.length - 1; ++i)
+      await this.down(progress, tokens[i]);
+    await this.down(progress, key);
+    if (options.delay)
+      await progress.wait(options.delay);
+    await this.up(progress, key);
+    for (let i = tokens.length - 2; i >= 0; --i)
+      await this.up(progress, tokens[i]);
+  }
+  async ensureModifiers(progress, mm) {
+    const modifiers = mm.map(resolveSmartModifier);
+    for (const modifier of modifiers) {
+      if (!kModifiers.includes(modifier))
+        throw new Error("Unknown modifier " + modifier);
+    }
+    const restore = Array.from(this._pressedModifiers);
+    for (const key of kModifiers) {
+      const needDown = modifiers.includes(key);
+      const isDown = this._pressedModifiers.has(key);
+      if (needDown && !isDown)
+        await this.down(progress, key);
+      else if (!needDown && isDown)
+        await this.up(progress, key);
+    }
+    return restore;
+  }
+  _modifiers() {
+    return this._pressedModifiers;
+  }
+}
+function resolveSmartModifierString(key) {
+  if (key === "ControlOrMeta")
+    return process.platform === "darwin" ? "Meta" : "Control";
+  return key;
+}
+function resolveSmartModifier(m) {
+  return resolveSmartModifierString(m);
+}
+class Mouse {
+  constructor(raw, page) {
+    this._x = 0;
+    this._y = 0;
+    this._lastButton = "none";
+    this._buttons = /* @__PURE__ */ new Set();
+    this._raw = raw;
+    this._page = page;
+    this._keyboard = this._page.keyboard;
+  }
+  currentPoint() {
+    return { x: this._x, y: this._y };
+  }
+  async move(progress, x, y, options = {}) {
+    const { steps = 1 } = options;
+    const fromX = this._x;
+    const fromY = this._y;
+    this._x = x;
+    this._y = y;
+    for (let i = 1; i <= steps; i++) {
+      const middleX = fromX + (x - fromX) * (i / steps);
+      const middleY = fromY + (y - fromY) * (i / steps);
+      await this._raw.move(progress, middleX, middleY, this._lastButton, this._buttons, this._keyboard._modifiers(), !!options.forClick);
+    }
+  }
+  async down(progress, options = {}) {
+    const { button = "left", clickCount = 1 } = options;
+    this._lastButton = button;
+    this._buttons.add(button);
+    await this._raw.down(progress, this._x, this._y, this._lastButton, this._buttons, this._keyboard._modifiers(), clickCount);
+  }
+  async up(progress, options = {}) {
+    const { button = "left", clickCount = 1 } = options;
+    this._lastButton = "none";
+    this._buttons.delete(button);
+    await this._raw.up(progress, this._x, this._y, button, this._buttons, this._keyboard._modifiers(), clickCount);
+  }
+  async click(progress, x, y, options = {}) {
+    const { delay = null, clickCount = 1, steps } = options;
+    if (delay) {
+      await this.move(progress, x, y, { forClick: true, steps });
+      for (let cc = 1; cc <= clickCount; ++cc) {
+        await this.down(progress, { ...options, clickCount: cc });
+        await progress.wait(delay);
+        await this.up(progress, { ...options, clickCount: cc });
+        if (cc < clickCount)
+          await progress.wait(delay);
+      }
+    } else {
+      const promises = [];
+      const movePromise = this.move(progress, x, y, { forClick: true, steps });
+      if (steps !== void 0 && steps > 1)
+        await movePromise;
+      else
+        promises.push(movePromise);
+      for (let cc = 1; cc <= clickCount; ++cc) {
+        promises.push(this.down(progress, { ...options, clickCount: cc }));
+        promises.push(this.up(progress, { ...options, clickCount: cc }));
+      }
+      await Promise.all(promises);
+    }
+  }
+  async wheel(progress, deltaX, deltaY) {
+    await this._raw.wheel(progress, this._x, this._y, this._buttons, this._keyboard._modifiers(), deltaX, deltaY);
+  }
+}
+const aliases = /* @__PURE__ */ new Map([
+  ["ShiftLeft", ["Shift"]],
+  ["ControlLeft", ["Control"]],
+  ["AltLeft", ["Alt"]],
+  ["MetaLeft", ["Meta"]],
+  ["Enter", ["\n", "\r"]]
+]);
+const usKeyboardLayout = buildLayoutClosure(keyboardLayout.USKeyboardLayout);
+function buildLayoutClosure(layout) {
+  const result = /* @__PURE__ */ new Map();
+  for (const code in layout) {
+    const definition = layout[code];
+    const description = {
+      key: definition.key || "",
+      keyCode: definition.keyCode || 0,
+      keyCodeWithoutLocation: definition.keyCodeWithoutLocation || definition.keyCode || 0,
+      code,
+      text: definition.text || "",
+      location: definition.location || 0
+    };
+    if (definition.key.length === 1)
+      description.text = description.key;
+    let shiftedDescription;
+    if (definition.shiftKey) {
+      (0, import_utils.assert)(definition.shiftKey.length === 1);
+      shiftedDescription = { ...description };
+      shiftedDescription.key = definition.shiftKey;
+      shiftedDescription.text = definition.shiftKey;
+      if (definition.shiftKeyCode)
+        shiftedDescription.keyCode = definition.shiftKeyCode;
+    }
+    result.set(code, { ...description, shifted: shiftedDescription });
+    if (aliases.has(code)) {
+      for (const alias of aliases.get(code))
+        result.set(alias, description);
+    }
+    if (definition.location)
+      continue;
+    if (description.key.length === 1)
+      result.set(description.key, description);
+    if (shiftedDescription)
+      result.set(shiftedDescription.key, { ...shiftedDescription, shifted: void 0 });
+  }
+  return result;
+}
+class Touchscreen {
+  constructor(raw, page) {
+    this._raw = raw;
+    this._page = page;
+  }
+  async tap(progress, x, y) {
+    if (!this._page.browserContext._options.hasTouch)
+      throw new Error("hasTouch must be enabled on the browser context before using the touchscreen.");
+    await this._raw.tap(progress, x, y, this._page.keyboard._modifiers());
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Keyboard,
+  Mouse,
+  Touchscreen,
+  keypadLocation,
+  resolveSmartModifier,
+  resolveSmartModifierString
+});

package/dist/node_modules/playwright-core/lib/server/instrumentation.js

@@ -0,0 +1,69 @@
+"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 instrumentation_exports = {};
+__export(instrumentation_exports, {
+  SdkObject: () => SdkObject,
+  createInstrumentation: () => createInstrumentation,
+  createRootSdkObject: () => createRootSdkObject
+});
+module.exports = __toCommonJS(instrumentation_exports);
+var import_events = require("events");
+var import_crypto = require("./utils/crypto");
+class SdkObject extends import_events.EventEmitter {
+  constructor(parent, guidPrefix, guid) {
+    super();
+    this.guid = guid || `${guidPrefix || ""}@${(0, import_crypto.createGuid)()}`;
+    this.setMaxListeners(0);
+    this.attribution = { ...parent.attribution };
+    this.instrumentation = parent.instrumentation;
+  }
+}
+function createRootSdkObject() {
+  const fakeParent = { attribution: {}, instrumentation: createInstrumentation() };
+  const root = new SdkObject(fakeParent);
+  root.guid = "";
+  return root;
+}
+function createInstrumentation() {
+  const listeners = /* @__PURE__ */ new Map();
+  return new Proxy({}, {
+    get: (obj, prop) => {
+      if (typeof prop !== "string")
+        return obj[prop];
+      if (prop === "addListener")
+        return (listener, context) => listeners.set(listener, context);
+      if (prop === "removeListener")
+        return (listener) => listeners.delete(listener);
+      if (!prop.startsWith("on"))
+        return obj[prop];
+      return async (sdkObject, ...params) => {
+        for (const [listener, context] of listeners) {
+          if (!context || sdkObject.attribution.context === context)
+            await listener[prop]?.(sdkObject, ...params);
+        }
+      };
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SdkObject,
+  createInstrumentation,
+  createRootSdkObject
+});