scordi-extension 1.14.6 → 1.14.8

package/dist/src/content/elements/finders/IframeSelector.ts.js

@@ -0,0 +1,32 @@
+import { ElementSelector } from "/src/content/elements/finders/ElementSelector.ts.js";
+export class IframSelector extends ElementSelector {
+  async find(data, documentCtx = document) {
+    const { selector, option } = data;
+    const { multiple = false } = option || {};
+    if (!selector || selector.trim() === "") {
+      return null;
+    }
+    const parts = selector.split("|>").map((part) => part.trim());
+    if (parts.length !== 2) {
+      return null;
+    }
+    const iframeSelector = parts[0];
+    const targetSelector = parts[1];
+    if (!iframeSelector || !targetSelector) {
+      return null;
+    }
+    try {
+      const iframe = documentCtx.querySelector(iframeSelector);
+      if (!iframe || !iframe.contentDocument) return null;
+      const iframeDoc = iframe.contentDocument;
+      if (multiple) {
+        return Array.from(iframeDoc.querySelectorAll(targetSelector));
+      } else {
+        return iframeDoc.querySelector(targetSelector);
+      }
+    } catch (error) {
+      console.error("Iframe Selector error:", error);
+      return null;
+    }
+  }
+}

package/dist/src/content/elements/finders/ShadowDOMSelector.ts.js

@@ -0,0 +1,38 @@
+import { ElementSelector } from "/src/content/elements/finders/ElementSelector.ts.js";
+export class ShadowDOMSelector extends ElementSelector {
+  async find(data, documentCtx = document) {
+    const { selector, option } = data;
+    const { multiple = false } = option || {};
+    if (!selector || selector.trim() === "") {
+      return null;
+    }
+    const parts = selector.split(">>").map((part) => part.trim());
+    let currentContext = documentCtx;
+    try {
+      for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        const isLast = i === parts.length - 1;
+        if (!part) {
+          return null;
+        }
+        if (isLast && multiple) {
+          return Array.from(currentContext.querySelectorAll(part));
+        }
+        const element = currentContext.querySelector(part);
+        if (!element) return null;
+        if (isLast) {
+          return element;
+        }
+        if (element.shadowRoot) {
+          currentContext = element.shadowRoot;
+        } else {
+          return null;
+        }
+      }
+    } catch (error) {
+      console.error("Shadow DOM Selector error:", error);
+      return null;
+    }
+    return null;
+  }
+}

package/dist/src/content/elements/finders/XPathFinder.ts.js

@@ -0,0 +1,32 @@
+import { ElementSelector } from "/src/content/elements/finders/ElementSelector.ts.js";
+export class XPathSelector extends ElementSelector {
+  async find(data, documentCtx = document) {
+    const { selector, option } = data;
+    const { multiple = false } = option || {};
+    try {
+      const result = documentCtx.evaluate(
+        selector,
+        documentCtx,
+        null,
+        multiple ? XPathResult.ORDERED_NODE_SNAPSHOT_TYPE : XPathResult.FIRST_ORDERED_NODE_TYPE,
+        null
+      );
+      if (multiple) {
+        const nodes = [];
+        for (let i = 0; i < result.snapshotLength; i++) {
+          const node = result.snapshotItem(i);
+          if (node && node.nodeType === Node.ELEMENT_NODE) {
+            nodes.push(node);
+          }
+        }
+        return Promise.resolve(nodes.length > 0 ? nodes : null);
+      } else {
+        const node = result.singleNodeValue;
+        return node && node.nodeType === Node.ELEMENT_NODE ? node : null;
+      }
+    } catch (error) {
+      console.error("XPath error:", error);
+      return null;
+    }
+  }
+}

package/dist/src/content/elements/index.ts.js

@@ -0,0 +1,26 @@
+import { CssSelector } from "/src/content/elements/finders/CssSelector.ts.js";
+import { IframSelector } from "/src/content/elements/finders/IframeSelector.ts.js";
+import { ShadowDOMSelector } from "/src/content/elements/finders/ShadowDOMSelector.ts.js";
+import { XPathSelector } from "/src/content/elements/finders/XPathFinder.ts.js";
+export async function findElement(data, documentCtx = document) {
+  const { selector, findBy = "cssSelector", option } = data;
+  const { waitForSelector = false, waitSelectorTimeout = 5e3 } = option || {};
+  const selectorInstance = buildSelector(selector, findBy);
+  if (waitForSelector) {
+    return selectorInstance.waitForElement(data, documentCtx, waitSelectorTimeout);
+  }
+  return selectorInstance.find(data, documentCtx);
+}
+function buildSelector(selector, findBy) {
+  if (findBy === "xpath") {
+    return new XPathSelector();
+  }
+  if (selector.includes(">>")) {
+    return new ShadowDOMSelector();
+  }
+  if (selector.includes("|>")) {
+    return new IframSelector();
+  }
+  return new CssSelector();
+}
+export { CSSSelectorGenerator } from "/src/content/elements/utils/CSSSelectorGenerator.ts.js";

package/dist/src/content/elements/utils/CSSSelectorGenerator.ts.js

@@ -0,0 +1,72 @@
+export class CSSSelectorGenerator {
+  /**
+   * 요소의 안정적인 CSS 셀렉터 생성
+   * @param element 대상 요소
+   * @returns 생성된 CSS 셀렉터
+   */
+  static generate(element) {
+    const staticAttributes = ["data-testid", "aria-label", "title", "alt", "role"];
+    for (const attr of staticAttributes) {
+      const value = element.getAttribute(attr);
+      if (value && !this.isDynamicValue(value)) {
+        return `[${attr}="${CSS.escape(value)}"]`;
+      }
+    }
+    const tagName = element.tagName.toLowerCase();
+    const parent = element.parentElement;
+    if (parent) {
+      const siblings = Array.from(parent.children);
+      const index = siblings.indexOf(element) + 1;
+      if (siblings.length > 1) {
+        return `${tagName}:nth-child(${index})`;
+      }
+    }
+    if (parent) {
+      const parentSelector = this.generateParentSelector(parent);
+      if (parentSelector) {
+        return `${parentSelector} > ${tagName}:nth-child(${Array.from(parent.children).indexOf(element) + 1})`;
+      }
+    }
+    return tagName;
+  }
+  /**
+   * 부모 요소의 셀렉터 생성
+   */
+  static generateParentSelector(parent) {
+    const tagName = parent.tagName.toLowerCase();
+    const staticAttributes = ["data-testid", "aria-label", "title", "alt", "role"];
+    for (const attr of staticAttributes) {
+      const value = parent.getAttribute(attr);
+      if (value && !this.isDynamicValue(value)) {
+        return `[${attr}="${CSS.escape(value)}"]`;
+      }
+    }
+    const grandParent = parent.parentElement;
+    if (grandParent) {
+      const siblings = Array.from(grandParent.children);
+      const index = siblings.indexOf(parent) + 1;
+      if (siblings.length > 1) {
+        return `${tagName}:nth-child(${index})`;
+      }
+    }
+    return tagName;
+  }
+  /**
+   * 동적 값 패턴 감지
+   * @param value 확인할 값
+   * @returns 동적 값 여부
+   */
+  static isDynamicValue(value) {
+    const dynamicPatterns = [
+      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
+      // UUID
+      /^\d{13}$/,
+      // timestamp
+      /^[a-zA-Z0-9]{16,}$/,
+      // long random string
+      /^[a-zA-Z0-9]+-\d+$/
+      // name-123 pattern
+    ];
+    return dynamicPatterns.some((pattern) => pattern.test(value));
+  }
+}

package/dist/src/content/elements/utils/XPathGenerator.ts.js

@@ -0,0 +1,62 @@
+export class XPathGenerator {
+  /**
+   * 요소의 XPath 생성
+   * @param element 대상 요소
+   * @returns 생성된 XPath
+   */
+  static generate(element) {
+    const path = [];
+    let current = element;
+    while (current && current.nodeType === Node.ELEMENT_NODE) {
+      let selector = current.tagName.toLowerCase();
+      const siblings = Array.from(current.parentElement?.children || []).filter((sibling) => sibling.tagName === current.tagName);
+      if (siblings.length > 1) {
+        const index = siblings.indexOf(current) + 1;
+        selector += `[${index}]`;
+      }
+      const attributes = this.getStableAttributes(current);
+      if (attributes.length > 0) {
+        selector += `[@${attributes.join(" and @")}]`;
+      }
+      path.unshift(selector);
+      current = current.parentElement;
+    }
+    return "/" + path.join("/");
+  }
+  /**
+   * 요소의 안정적인 속성들을 반환
+   * @param element 대상 요소
+   * @returns 안정적인 속성 배열
+   */
+  static getStableAttributes(element) {
+    const stableAttributes = [];
+    const stableAttrs = ["data-testid", "aria-label", "title", "alt", "role"];
+    for (const attr of stableAttrs) {
+      const value = element.getAttribute(attr);
+      if (value && !this.isDynamicValue(value)) {
+        stableAttributes.push(`${attr}="${value}"`);
+      }
+    }
+    return stableAttributes;
+  }
+  /**
+   * 동적 값 패턴 감지
+   * @param value 확인할 값
+   * @returns 동적 값 여부
+   */
+  static isDynamicValue(value) {
+    const dynamicPatterns = [
+      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
+      // UUID
+      /^\d{13}$/,
+      // timestamp
+      /^[a-zA-Z0-9]{16,}$/,
+      // long random string
+      /^[a-zA-Z0-9]+-\d+$/,
+      // name-123 pattern
+      /^[a-zA-Z0-9]+_[a-zA-Z0-9]+$/
+      // underscore pattern
+    ];
+    return dynamicPatterns.some((pattern) => pattern.test(value));
+  }
+}

package/dist/src/content/handler/ExternalMessageHandler.ts.js

@@ -0,0 +1,78 @@
+export class ExternalMessageHandler {
+  constructor(kernel) {
+    this.kernel = kernel;
+  }
+  /**
+   * 웹페이지로부터의 window message 리스너 초기화
+   */
+  initializeMessageListener() {
+    window.addEventListener("message", this.handleWindowMessage.bind(this));
+  }
+  /**
+   * 웹페이지로부터의 window message 처리
+   */
+  async handleWindowMessage(event) {
+    if (event.source !== window) return;
+    const message = event.data;
+    switch (message.type) {
+      case "8G_EXTENSION_CHECK":
+        this.handleExtensionCheck();
+        break;
+      case "8G_COLLECT_WORKFLOW":
+        await this.handleCollectWorkflow(message);
+        break;
+      default:
+        break;
+    }
+  }
+  /**
+   * 확장 프로그램 설치 확인 요청 처리
+   */
+  handleExtensionCheck() {
+    const response = {
+      type: "8G_EXTENSION_RESPONSE",
+      installed: true,
+      version: "1.0.0"
+    };
+    this.kernel.sendToWebpage(response);
+  }
+  /**
+   * 워크플로우 수집 요청 처리
+   */
+  async handleCollectWorkflow(message) {
+    try {
+      this.validateCollectWorkflowMessage(message);
+      const backgroundMessage = {
+        type: "COLLECT_WORKFLOW_NEW_TAB",
+        data: {
+          targetUrl: message.targetUrl,
+          workflow: message.workflow,
+          closeTabAfterCollection: message.closeTabAfterCollection !== false,
+          activateTab: message.activateTab === true
+        }
+      };
+      try {
+        const response = await this.kernel.sendToBackground(backgroundMessage);
+        const successResponse = this.kernel.createSuccessResponse(message.requestId, response);
+        this.kernel.sendToWebpage(successResponse);
+      } catch (error) {
+        const errorResponse = this.kernel.createErrorResponse(message.requestId, error);
+        this.kernel.sendToWebpage(errorResponse);
+      }
+    } catch (error) {
+      const errorResponse = this.kernel.createErrorResponse(message.requestId, error);
+      this.kernel.sendToWebpage(errorResponse);
+    }
+  }
+  validateCollectWorkflowMessage(message) {
+    if (!message.targetUrl) {
+      throw new Error("Target URL is required");
+    }
+    if (!message.workflow) {
+      throw new Error("Workflow is required");
+    }
+    if (!message.workflow.start || !Array.isArray(message.workflow.steps)) {
+      throw new Error("Workflow must have start and steps");
+    }
+  }
+}

package/dist/src/content/handler/InternalMessageHandler.ts.js

@@ -0,0 +1,18 @@
+import { isExecuteBlockMessage } from "/src/types/internal-messages.ts.js";
+export class InternalMessageHandler {
+  constructor(kernel) {
+    this.kernel = kernel;
+  }
+  /**
+   * Background script로부터의 메시지 리스너 초기화
+   */
+  initializeMessageListener() {
+    chrome.runtime.onMessage.addListener((message, _sender, sendResponse) => {
+      if (isExecuteBlockMessage(message)) {
+        this.kernel.handleRuntimeMessage(message).then((result) => sendResponse(result)).catch((error) => sendResponse(this.kernel.createErrorResponse("", error)));
+        return true;
+      }
+      return false;
+    });
+  }
+}

package/dist/src/content/kernel/MessageKernel.ts.js

@@ -0,0 +1,83 @@
+import {
+  isErrorResponse
+} from "/src/types/internal-messages.ts.js";
+export class MessageKernel {
+  /**
+   * Background script로 메시지 전송
+   */
+  async sendToBackground(message) {
+    return new Promise((resolve, reject) => {
+      chrome.runtime.sendMessage(message, (response) => {
+        if (chrome.runtime.lastError) {
+          reject(new Error(chrome.runtime.lastError.message || "Communication error"));
+        } else if (isErrorResponse(response)) {
+          reject(new Error(response.message));
+        } else {
+          resolve(response);
+        }
+      });
+    });
+  }
+  /**
+   * Content script에서 Block 실행
+   */
+  async executeBlock(block) {
+    const { BlockHandler } = await import("/src/blocks/index.ts.js");
+    const { synchronizedLock } = await import("/src/content/utils/index.ts.js");
+    await synchronizedLock.getLock();
+    try {
+      return await BlockHandler.executeBlock(block);
+    } finally {
+      synchronizedLock.releaseLock();
+    }
+  }
+  /**
+   * Chrome runtime 메시지 처리 (Background -> Content)
+   */
+  async handleRuntimeMessage(message) {
+    if (message?.isBlock && message?.type === "EXECUTE_BLOCK") {
+      try {
+        const result = await this.executeBlock(message.data);
+        return result;
+      } catch (error) {
+        return {
+          $isError: true,
+          message: error instanceof Error ? error.message : "Unknown error",
+          data: {}
+        };
+      }
+    }
+    throw new Error("Invalid message type");
+  }
+  /**
+   * Window message를 웹페이지로 전송
+   */
+  sendToWebpage(message) {
+    window.postMessage(message, "*");
+  }
+  /**
+   * 에러 응답 생성 헬퍼
+   */
+  createErrorResponse(requestId, error) {
+    return {
+      type: "8G_COLLECT_RESPONSE",
+      requestId,
+      success: false,
+      result: {
+        error: error instanceof Error ? error.message : "Unknown error",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
+  }
+  /**
+   * 성공 응답 생성 헬퍼
+   */
+  createSuccessResponse(requestId, result) {
+    return {
+      type: "8G_COLLECT_RESPONSE",
+      requestId,
+      success: true,
+      result
+    };
+  }
+}

package/dist/src/content/main.tsx-loader.js

@@ -0,0 +1,22 @@
+(function () {
+  'use strict';
+
+  const injectTime = performance.now();
+  (async () => {
+    if ("vendor/crx-client-preamble.js")
+      await import(
+        /* @vite-ignore */
+        chrome.runtime.getURL("vendor/crx-client-preamble.js")
+      );
+    await import(
+      /* @vite-ignore */
+      chrome.runtime.getURL("vendor/vite-client.js")
+    );
+    const { onExecute } = await import(
+      /* @vite-ignore */
+      chrome.runtime.getURL("src/content/main.tsx.js")
+    );
+    onExecute?.({ perf: { injectTime, loadTime: performance.now() - injectTime } });
+  })().catch(console.error);
+
+})();

package/dist/src/content/main.tsx.js

@@ -0,0 +1,27 @@
+import __vite__cjsImport0_react_jsxDevRuntime from "/vendor/.vite-deps-react_jsx-dev-runtime.js__v--e2a1f584.js"; const jsxDEV = __vite__cjsImport0_react_jsxDevRuntime["jsxDEV"];
+import __vite__cjsImport1_reactDom_client from "/vendor/.vite-deps-react-dom_client.js__v--e2a1f584.js"; const createRoot = __vite__cjsImport1_reactDom_client["createRoot"];
+import { MessageKernel } from "/src/content/kernel/MessageKernel.ts.js";
+import { InternalMessageHandler } from "/src/content/handler/InternalMessageHandler.ts.js";
+import { ExternalMessageHandler } from "/src/content/handler/ExternalMessageHandler.ts.js";
+import { ConfirmationUIContainer } from "/src/content/components/ConfirmationUI.tsx.js";
+(() => {
+  if (window.is8gExtensionInjected) return;
+  window.is8gExtensionInjected = true;
+  console.log("[8G Extension] Content script initialized on:", window.location.href);
+  const messageKernel = new MessageKernel();
+  const internalHandler = new InternalMessageHandler(messageKernel);
+  const externalHandler = new ExternalMessageHandler(messageKernel);
+  internalHandler.initializeMessageListener();
+  externalHandler.initializeMessageListener();
+  const uiRoot = document.createElement("div");
+  uiRoot.id = "8g-confirmation-ui-root";
+  uiRoot.style.cssText = "all: initial; position: fixed; z-index: 2147483647;";
+  document.body.appendChild(uiRoot);
+  const root = createRoot(uiRoot);
+  root.render(/* @__PURE__ */ jsxDEV(ConfirmationUIContainer, {}, void 0, false, {
+    fileName: "/Users/kerry/Documents/GitHub/8g-extension/src/content/main.tsx",
+    lineNumber: 34,
+    columnNumber: 15
+  }, this));
+  console.log("[8G Extension] Confirmation UI mounted");
+})();

package/dist/src/content/utils/index.ts.js

@@ -0,0 +1 @@
+export { synchronizedLock } from "/src/content/utils/synchronizedLock.ts.js";

package/dist/src/content/utils/synchronizedLock.ts.js

@@ -0,0 +1,35 @@
+class SynchronizedLock {
+  isLocked = false;
+  waitQueue = [];
+  async getLock() {
+    return new Promise((resolve) => {
+      if (!this.isLocked) {
+        this.isLocked = true;
+        resolve();
+      } else {
+        this.waitQueue.push(resolve);
+      }
+    });
+  }
+  releaseLock() {
+    if (!this.isLocked) {
+      console.warn("[SynchronizedLock] Attempting to release an unlocked lock");
+      return;
+    }
+    this.isLocked = false;
+    if (this.waitQueue.length > 0) {
+      const nextResolve = this.waitQueue.shift();
+      if (nextResolve) {
+        this.isLocked = true;
+        nextResolve();
+      }
+    }
+  }
+  isCurrentlyLocked() {
+    return this.isLocked;
+  }
+  getQueueLength() {
+    return this.waitQueue.length;
+  }
+}
+export const synchronizedLock = new SynchronizedLock();

package/dist/src/popup/index.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <title>Vite Dev Mode</title>
+    <script src="/assets/loading-page-1924caaa.js" type="module"></script>
+  </head>
+  <body
+    style="font-family: Arial, sans-serif; padding: 20px; text-align: center"
+  >
+    <h1>Vite Dev Mode</h1>
+  </body>
+</html>

package/dist/src/types/internal-messages.ts.js

@@ -0,0 +1,15 @@
+export function isExecuteBlockMessage(message) {
+  return message && message.isBlock === true && message.type === "EXECUTE_BLOCK";
+}
+export function isCdpClickMessage(message) {
+  return message && message.type === "CDP_CLICK";
+}
+export function isCdpKeypressMessage(message) {
+  return message && message.type === "CDP_KEYPRESS";
+}
+export function isFetchApiMessage(message) {
+  return message && message.type === "FETCH_API";
+}
+export function isErrorResponse(response) {
+  return response && response.$isError === true;
+}

package/dist/vendor/.vite-deps-chunk-2TUXWMP5.js__v--9054997c.js

@@ -0,0 +1,45 @@
+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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+export {
+  __require,
+  __commonJS,
+  __export,
+  __toESM,
+  __publicField
+};

package/dist/vendor/.vite-deps-chunk-2TUXWMP5.js__v--e2a1f584.js

@@ -0,0 +1,45 @@
+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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+export {
+  __require,
+  __commonJS,
+  __export,
+  __toESM,
+  __publicField
+};