scordi-extension 1.14.6 → 1.14.8

package/dist/src/blocks/WaitForConditionBlock.ts.js

@@ -0,0 +1,187 @@
+import z from "/vendor/.vite-deps-zod.js__v--e2a1f584.js";
+export const WaitForConditionBlockSchema = z.object({
+  name: z.literal("wait-for-condition"),
+  conditions: z.object({
+    urlPattern: z.string().optional(),
+    elementExists: z.object({
+      selector: z.string(),
+      findBy: z.enum(["cssSelector", "xpath"])
+    }).optional(),
+    cookieExists: z.string().optional(),
+    storageKey: z.object({
+      type: z.enum(["localStorage", "sessionStorage"]),
+      key: z.string()
+    }).optional(),
+    userConfirmation: z.boolean().optional(),
+    message: z.string().optional(),
+    buttonText: z.string().optional()
+  }).refine(
+    (data) => {
+      return data.urlPattern !== void 0 || data.elementExists !== void 0 || data.cookieExists !== void 0 || data.storageKey !== void 0 || data.userConfirmation === true;
+    },
+    {
+      message: "At least one condition must be specified"
+    }
+  ),
+  mode: z.enum(["auto", "manual", "auto-or-manual"]).optional(),
+  pollingIntervalMs: z.number().min(100).optional(),
+  timeoutMs: z.number().min(1e3).optional(),
+  position: z.enum(["top-left", "top-right", "bottom-left", "bottom-right"]).optional()
+});
+export function validateWaitForConditionBlock(data) {
+  return WaitForConditionBlockSchema.parse(data);
+}
+export async function handlerWaitForCondition(data) {
+  try {
+    const {
+      conditions,
+      mode = "auto-or-manual",
+      pollingIntervalMs = 1e3,
+      timeoutMs = 3e5,
+      position = "bottom-right"
+    } = data;
+    console.log("[WaitForCondition] Starting wait with conditions:", conditions);
+    console.log("[WaitForCondition] Mode:", mode, "Timeout:", timeoutMs);
+    const hasAutoConditions = !!(conditions.urlPattern || conditions.elementExists || conditions.cookieExists || conditions.storageKey);
+    const hasManualConfirmation = conditions.userConfirmation === true;
+    let userConfirmedPromise = null;
+    let confirmResolve = null;
+    if ((mode === "manual" || mode === "auto-or-manual") && hasManualConfirmation) {
+      userConfirmedPromise = new Promise((resolve) => {
+        confirmResolve = resolve;
+      });
+      window.dispatchEvent(
+        new CustomEvent("8g-show-confirmation-ui", {
+          detail: {
+            message: conditions.message || "작업을 완료하셨나요?",
+            buttonText: conditions.buttonText || "완료",
+            position,
+            onConfirm: confirmResolve
+          }
+        })
+      );
+    }
+    const checkAutoConditions = async () => {
+      if (conditions.urlPattern) {
+        try {
+          const regex = new RegExp(conditions.urlPattern);
+          if (regex.test(window.location.href)) {
+            return {
+              success: true,
+              reason: "urlPattern",
+              message: `URL matches pattern: ${conditions.urlPattern}`
+            };
+          }
+        } catch (error) {
+          console.warn("[WaitForCondition] Invalid URL pattern:", error);
+        }
+      }
+      if (conditions.elementExists) {
+        const { selector, findBy } = conditions.elementExists;
+        let element = null;
+        if (findBy === "cssSelector") {
+          element = document.querySelector(selector);
+        } else if (findBy === "xpath") {
+          const xpathResult = document.evaluate(
+            selector,
+            document,
+            null,
+            XPathResult.FIRST_ORDERED_NODE_TYPE,
+            null
+          );
+          element = xpathResult.singleNodeValue;
+        }
+        if (element) {
+          return {
+            success: true,
+            reason: "elementExists",
+            message: `Element found: ${selector}`
+          };
+        }
+      }
+      if (conditions.cookieExists) {
+        const cookies = document.cookie.split(";");
+        const cookieExists = cookies.some((cookie) => {
+          const [name] = cookie.trim().split("=");
+          return name === conditions.cookieExists;
+        });
+        if (cookieExists) {
+          return {
+            success: true,
+            reason: "cookieExists",
+            message: `Cookie found: ${conditions.cookieExists}`
+          };
+        }
+      }
+      if (conditions.storageKey) {
+        const { type, key } = conditions.storageKey;
+        const storage = type === "localStorage" ? window.localStorage : window.sessionStorage;
+        const value = storage.getItem(key);
+        if (value !== null) {
+          return {
+            success: true,
+            reason: "storageKey",
+            message: `Storage key found: ${type}.${key}`
+          };
+        }
+      }
+      return null;
+    };
+    return new Promise((resolve) => {
+      let intervalId = null;
+      let resolved = false;
+      const cleanup = () => {
+        if (intervalId) {
+          clearInterval(intervalId);
+          intervalId = null;
+        }
+        window.dispatchEvent(new CustomEvent("8g-hide-confirmation-ui"));
+      };
+      const resolveWith = (result) => {
+        if (resolved) return;
+        resolved = true;
+        cleanup();
+        console.log("[WaitForCondition] Resolved with:", result);
+        resolve({ data: result });
+      };
+      const timeoutId = setTimeout(() => {
+        resolveWith({
+          success: false,
+          reason: "timeout",
+          message: `Timeout after ${timeoutMs}ms`
+        });
+      }, timeoutMs);
+      if ((mode === "auto" || mode === "auto-or-manual") && hasAutoConditions) {
+        intervalId = setInterval(async () => {
+          const result = await checkAutoConditions();
+          if (result) {
+            clearTimeout(timeoutId);
+            resolveWith(result);
+          }
+        }, pollingIntervalMs);
+      }
+      if ((mode === "manual" || mode === "auto-or-manual") && userConfirmedPromise) {
+        userConfirmedPromise.then(() => {
+          clearTimeout(timeoutId);
+          resolveWith({
+            success: true,
+            reason: "userConfirmation",
+            message: "User confirmed completion"
+          });
+        });
+      }
+      if (mode === "manual" && !hasAutoConditions) {
+      }
+    });
+  } catch (error) {
+    console.error("[WaitForCondition] Error:", error);
+    return {
+      hasError: true,
+      message: error instanceof Error ? error.message : "Unknown error in wait-for-condition handler",
+      data: {
+        success: false,
+        message: error instanceof Error ? error.message : "Unknown error"
+      }
+    };
+  }
+}

package/dist/src/blocks/index.ts.js

@@ -0,0 +1,174 @@
+export { BaseBlockSchema } from "/src/blocks/types.ts.js";
+export { createSchema, createArraySchema, Schema } from "/src/blocks/AiParseDataBlock.ts.js";
+export { GetTextBlockSchema } from "/src/blocks/GetTextBlock.ts.js";
+export { GetAttributeValueBlockSchema } from "/src/blocks/GetAttributeValueBlock.ts.js";
+export { GetValueFormsBlockSchema } from "/src/blocks/GetValueFormBlock.ts.js";
+export { SetValueFormsBlockSchema } from "/src/blocks/SetValueFormBlock.ts.js";
+export { ClearValueFormsBlockSchema } from "/src/blocks/ClearValueFormBlock.ts.js";
+export { ElementExistsBlockSchema } from "/src/blocks/ElementExistsBlock.ts.js";
+export { EventClickBlockSchema } from "/src/blocks/EventClickBlock.ts.js";
+export { KeypressBlockSchema } from "/src/blocks/KeypressBlock.ts.js";
+export { WaitBlockSchema } from "/src/blocks/WaitBlock.ts.js";
+export { WaitForConditionBlockSchema } from "/src/blocks/WaitForConditionBlock.ts.js";
+export { SaveAssetsBlockSchema } from "/src/blocks/SaveAssetsBlock.ts.js";
+export { GetElementDataBlockSchema } from "/src/blocks/GetElementDataBlock.ts.js";
+export { ScrollBlockSchema } from "/src/blocks/ScrollBlock.ts.js";
+export { AiParseDataBlockSchema } from "/src/blocks/AiParseDataBlock.ts.js";
+export { FetchApiBlockSchema } from "/src/blocks/FetchApiBlock.ts.js";
+export { DataExtractBlockSchema } from "/src/blocks/DataExtractBlock.ts.js";
+import { handlerGetText, validateGetTextBlock } from "/src/blocks/GetTextBlock.ts.js";
+import {
+  handlerGetAttributeValue,
+  validateGetAttributeValueBlock
+} from "/src/blocks/GetAttributeValueBlock.ts.js";
+import {
+  handlerGetValueForm,
+  validateGetValueFormsBlock
+} from "/src/blocks/GetValueFormBlock.ts.js";
+import {
+  handlerSetValueForm,
+  validateSetValueFormsBlock
+} from "/src/blocks/SetValueFormBlock.ts.js";
+import {
+  handlerClearValueForm,
+  validateClearValueFormsBlock
+} from "/src/blocks/ClearValueFormBlock.ts.js";
+import {
+  handlerElementExists,
+  validateElementExistsBlock
+} from "/src/blocks/ElementExistsBlock.ts.js";
+import { handlerEventClick, validateEventClickBlock } from "/src/blocks/EventClickBlock.ts.js";
+import { handlerKeypress, validateKeypressBlock } from "/src/blocks/KeypressBlock.ts.js";
+import { handlerWait, validateWaitBlock } from "/src/blocks/WaitBlock.ts.js";
+import {
+  handlerWaitForCondition,
+  validateWaitForConditionBlock
+} from "/src/blocks/WaitForConditionBlock.ts.js";
+import { handlerSaveAssets, validateSaveAssetsBlock } from "/src/blocks/SaveAssetsBlock.ts.js";
+import {
+  handlerGetElementData,
+  validateGetElementDataBlock
+} from "/src/blocks/GetElementDataBlock.ts.js";
+import { handlerScroll, validateScrollBlock } from "/src/blocks/ScrollBlock.ts.js";
+import { handlerAiParseData, validateAiParseDataBlock } from "/src/blocks/AiParseDataBlock.ts.js";
+import { handlerFetchApi, validateFetchApiBlock } from "/src/blocks/FetchApiBlock.ts.js";
+import { handlerDataExtract, validateDataExtractBlock } from "/src/blocks/DataExtractBlock.ts.js";
+import { GetTextBlockSchema as GetTextBlockSchema2 } from "/src/blocks/GetTextBlock.ts.js";
+import { GetAttributeValueBlockSchema as GetAttributeValueBlockSchema2 } from "/src/blocks/GetAttributeValueBlock.ts.js";
+import { GetValueFormsBlockSchema as GetValueFormsBlockSchema2 } from "/src/blocks/GetValueFormBlock.ts.js";
+import { SetValueFormsBlockSchema as SetValueFormsBlockSchema2 } from "/src/blocks/SetValueFormBlock.ts.js";
+import { ClearValueFormsBlockSchema as ClearValueFormsBlockSchema2 } from "/src/blocks/ClearValueFormBlock.ts.js";
+import { ElementExistsBlockSchema as ElementExistsBlockSchema2 } from "/src/blocks/ElementExistsBlock.ts.js";
+import { EventClickBlockSchema as EventClickBlockSchema2 } from "/src/blocks/EventClickBlock.ts.js";
+import { KeypressBlockSchema as KeypressBlockSchema2 } from "/src/blocks/KeypressBlock.ts.js";
+import { WaitBlockSchema as WaitBlockSchema2 } from "/src/blocks/WaitBlock.ts.js";
+import { WaitForConditionBlockSchema as WaitForConditionBlockSchema2 } from "/src/blocks/WaitForConditionBlock.ts.js";
+import { SaveAssetsBlockSchema as SaveAssetsBlockSchema2 } from "/src/blocks/SaveAssetsBlock.ts.js";
+import { GetElementDataBlockSchema as GetElementDataBlockSchema2 } from "/src/blocks/GetElementDataBlock.ts.js";
+import { ScrollBlockSchema as ScrollBlockSchema2 } from "/src/blocks/ScrollBlock.ts.js";
+import { AiParseDataBlockSchema as AiParseDataBlockSchema2 } from "/src/blocks/AiParseDataBlock.ts.js";
+import { FetchApiBlockSchema as FetchApiBlockSchema2 } from "/src/blocks/FetchApiBlock.ts.js";
+import { DataExtractBlockSchema as DataExtractBlockSchema2 } from "/src/blocks/DataExtractBlock.ts.js";
+export const AllBlockSchemas = {
+  "get-text": GetTextBlockSchema2,
+  "attribute-value": GetAttributeValueBlockSchema2,
+  "get-value-form": GetValueFormsBlockSchema2,
+  "set-value-form": SetValueFormsBlockSchema2,
+  "clear-value-form": ClearValueFormsBlockSchema2,
+  "element-exists": ElementExistsBlockSchema2,
+  "event-click": EventClickBlockSchema2,
+  "keypress": KeypressBlockSchema2,
+  "wait": WaitBlockSchema2,
+  "wait-for-condition": WaitForConditionBlockSchema2,
+  "save-assets": SaveAssetsBlockSchema2,
+  "get-element-data": GetElementDataBlockSchema2,
+  "scroll": ScrollBlockSchema2,
+  "ai-parse-data": AiParseDataBlockSchema2,
+  "fetch-api": FetchApiBlockSchema2,
+  "data-extract": DataExtractBlockSchema2
+};
+export class BlockHandler {
+  // Implementation
+  static async executeBlock(block) {
+    try {
+      switch (block.name) {
+        case "get-text": {
+          const validatedBlock = validateGetTextBlock(block);
+          return await handlerGetText(validatedBlock);
+        }
+        case "attribute-value": {
+          const validatedBlock = validateGetAttributeValueBlock(block);
+          return await handlerGetAttributeValue(validatedBlock);
+        }
+        case "get-value-form": {
+          const validatedBlock = validateGetValueFormsBlock(block);
+          return await handlerGetValueForm(validatedBlock);
+        }
+        case "set-value-form": {
+          const validatedBlock = validateSetValueFormsBlock(block);
+          return await handlerSetValueForm(validatedBlock);
+        }
+        case "clear-value-form": {
+          const validatedBlock = validateClearValueFormsBlock(block);
+          return await handlerClearValueForm(validatedBlock);
+        }
+        case "element-exists": {
+          const validatedBlock = validateElementExistsBlock(block);
+          return await handlerElementExists(validatedBlock);
+        }
+        case "event-click": {
+          const validatedBlock = validateEventClickBlock(block);
+          return await handlerEventClick(validatedBlock);
+        }
+        case "keypress": {
+          const validatedBlock = validateKeypressBlock(block);
+          return await handlerKeypress(validatedBlock);
+        }
+        case "wait": {
+          const validatedBlock = validateWaitBlock(block);
+          return await handlerWait(validatedBlock);
+        }
+        case "wait-for-condition": {
+          const validatedBlock = validateWaitForConditionBlock(block);
+          return await handlerWaitForCondition(validatedBlock);
+        }
+        case "save-assets": {
+          const validatedBlock = validateSaveAssetsBlock(block);
+          return await handlerSaveAssets(validatedBlock);
+        }
+        case "get-element-data": {
+          const validatedBlock = validateGetElementDataBlock(block);
+          return await handlerGetElementData(validatedBlock);
+        }
+        case "scroll": {
+          const validatedBlock = validateScrollBlock(block);
+          return await handlerScroll(validatedBlock);
+        }
+        case "ai-parse-data": {
+          const validatedBlock = validateAiParseDataBlock(block);
+          return await handlerAiParseData(validatedBlock);
+        }
+        case "fetch-api": {
+          const validatedBlock = validateFetchApiBlock(block);
+          return await handlerFetchApi(validatedBlock);
+        }
+        case "data-extract": {
+          const validatedBlock = validateDataExtractBlock(block);
+          return await handlerDataExtract(validatedBlock);
+        }
+        default:
+          return {
+            hasError: true,
+            message: `Unknown block type: ${block.name}`,
+            data: null
+          };
+      }
+    } catch (error) {
+      return {
+        hasError: true,
+        message: error instanceof Error ? error.message : "Unknown error in block execution",
+        data: null
+      };
+    }
+  }
+}

package/dist/src/blocks/types.ts.js

@@ -0,0 +1,12 @@
+import { z } from "/vendor/.vite-deps-zod.js__v--e2a1f584.js";
+export const BaseBlockSchema = z.object({
+  name: z.string(),
+  selector: z.string(),
+  findBy: z.enum(["cssSelector", "xpath"]),
+  option: z.object({
+    waitForSelector: z.boolean().optional(),
+    waitSelectorTimeout: z.number().optional(),
+    multiple: z.boolean().optional()
+  })
+});
+export { AllBlockSchemas } from "/src/blocks/index.ts.js";

package/dist/src/content/components/ConfirmationUI.tsx.js

@@ -0,0 +1,236 @@
+import { createHotContext as __vite__createHotContext } from "/vendor/vite-client.js";import.meta.hot = __vite__createHotContext("/src/content/components/ConfirmationUI.tsx.js");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 * as RefreshRuntime from "/vendor/react-refresh.js";
+const inWebWorker = typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope;
+let prevRefreshReg;
+let prevRefreshSig;
+if (import.meta.hot && !inWebWorker) {
+  if (!window.$RefreshReg$) {
+    throw new Error(
+      "@vitejs/plugin-react can't detect preamble. Something is wrong."
+    );
+  }
+  prevRefreshReg = window.$RefreshReg$;
+  prevRefreshSig = window.$RefreshSig$;
+  window.$RefreshReg$ = RefreshRuntime.getRefreshReg("/Users/kerry/Documents/GitHub/8g-extension/src/content/components/ConfirmationUI.tsx");
+  window.$RefreshSig$ = RefreshRuntime.createSignatureFunctionForTransform;
+}
+var _s = $RefreshSig$(), _s2 = $RefreshSig$();
+import __vite__cjsImport3_react from "/vendor/.vite-deps-react.js__v--e2a1f584.js"; const useEffect = __vite__cjsImport3_react["useEffect"]; const useState = __vite__cjsImport3_react["useState"];
+import __vite__cjsImport4_reactDom from "/vendor/.vite-deps-react-dom.js__v--e2a1f584.js"; const createPortal = __vite__cjsImport4_reactDom["createPortal"];
+const positionStyles = {
+  "top-left": {
+    top: "20px",
+    left: "20px"
+  },
+  "top-right": {
+    top: "20px",
+    right: "20px"
+  },
+  "bottom-left": {
+    bottom: "20px",
+    left: "20px"
+  },
+  "bottom-right": {
+    bottom: "20px",
+    right: "20px"
+  }
+};
+export function ConfirmationUI({
+  message,
+  buttonText,
+  position,
+  onConfirm,
+  visible
+}) {
+  _s();
+  const [isAnimating, setIsAnimating] = useState(false);
+  useEffect(() => {
+    if (visible) {
+      setTimeout(() => setIsAnimating(true), 10);
+    } else {
+      setIsAnimating(false);
+    }
+  }, [visible]);
+  if (!visible) return null;
+  const handleConfirm = () => {
+    setIsAnimating(false);
+    setTimeout(() => {
+      onConfirm();
+    }, 200);
+  };
+  const containerStyle = {
+    position: "fixed",
+    ...positionStyles[position],
+    zIndex: 2147483647,
+    // Maximum z-index
+    backgroundColor: "#ffffff",
+    border: "2px solid #4f46e5",
+    borderRadius: "12px",
+    padding: "16px 20px",
+    boxShadow: "0 10px 25px rgba(0, 0, 0, 0.2)",
+    display: "flex",
+    flexDirection: "column",
+    gap: "12px",
+    minWidth: "280px",
+    maxWidth: "400px",
+    fontFamily: '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif',
+    transform: isAnimating ? "scale(1)" : "scale(0.9)",
+    opacity: isAnimating ? 1 : 0,
+    transition: "transform 0.2s ease-out, opacity 0.2s ease-out"
+  };
+  const messageStyle = {
+    margin: 0,
+    fontSize: "14px",
+    lineHeight: "1.5",
+    color: "#1f2937",
+    fontWeight: 500
+  };
+  const buttonStyle = {
+    backgroundColor: "#4f46e5",
+    color: "#ffffff",
+    border: "none",
+    borderRadius: "8px",
+    padding: "10px 16px",
+    fontSize: "14px",
+    fontWeight: 600,
+    cursor: "pointer",
+    transition: "background-color 0.2s ease",
+    outline: "none"
+  };
+  const buttonHoverStyle = {
+    backgroundColor: "#4338ca"
+  };
+  return createPortal(
+    /* @__PURE__ */ jsxDEV(
+      "div",
+      {
+        style: containerStyle,
+        onClick: (e) => e.stopPropagation(),
+        children: [
+          /* @__PURE__ */ jsxDEV("p", { style: messageStyle, children: message }, void 0, false, {
+            fileName: "/Users/kerry/Documents/GitHub/8g-extension/src/content/components/ConfirmationUI.tsx",
+            lineNumber: 132,
+            columnNumber: 7
+          }, this),
+          /* @__PURE__ */ jsxDEV(
+            "button",
+            {
+              style: buttonStyle,
+              onMouseEnter: (e) => {
+                e.currentTarget.style.backgroundColor = buttonHoverStyle.backgroundColor;
+              },
+              onMouseLeave: (e) => {
+                e.currentTarget.style.backgroundColor = buttonStyle.backgroundColor;
+              },
+              onClick: handleConfirm,
+              children: buttonText
+            },
+            void 0,
+            false,
+            {
+              fileName: "/Users/kerry/Documents/GitHub/8g-extension/src/content/components/ConfirmationUI.tsx",
+              lineNumber: 133,
+              columnNumber: 7
+            },
+            this
+          )
+        ]
+      },
+      void 0,
+      true,
+      {
+        fileName: "/Users/kerry/Documents/GitHub/8g-extension/src/content/components/ConfirmationUI.tsx",
+        lineNumber: 128,
+        columnNumber: 5
+      },
+      this
+    ),
+    document.body
+  );
+}
+_s(ConfirmationUI, "U13FD0PO4FR4rREA5Sq0cx8yDCA=");
+_c = ConfirmationUI;
+export function ConfirmationUIContainer() {
+  _s2();
+  const [uiState, setUiState] = useState({
+    visible: false,
+    message: "",
+    buttonText: "",
+    position: "bottom-right",
+    onConfirm: null
+  });
+  useEffect(() => {
+    const handleShow = (event) => {
+      const customEvent = event;
+      const { message, buttonText, position, onConfirm } = customEvent.detail;
+      console.log("[ConfirmationUI] Show event received:", { message, buttonText, position });
+      setUiState({
+        visible: true,
+        message,
+        buttonText,
+        position,
+        onConfirm
+      });
+    };
+    const handleHide = () => {
+      console.log("[ConfirmationUI] Hide event received");
+      setUiState((prev) => ({
+        ...prev,
+        visible: false
+      }));
+    };
+    window.addEventListener("8g-show-confirmation-ui", handleShow);
+    window.addEventListener("8g-hide-confirmation-ui", handleHide);
+    return () => {
+      window.removeEventListener("8g-show-confirmation-ui", handleShow);
+      window.removeEventListener("8g-hide-confirmation-ui", handleHide);
+    };
+  }, []);
+  const handleConfirm = () => {
+    console.log("[ConfirmationUI] User confirmed");
+    if (uiState.onConfirm) {
+      uiState.onConfirm();
+    }
+    setUiState((prev) => ({
+      ...prev,
+      visible: false
+    }));
+  };
+  return /* @__PURE__ */ jsxDEV(
+    ConfirmationUI,
+    {
+      message: uiState.message,
+      buttonText: uiState.buttonText,
+      position: uiState.position,
+      onConfirm: handleConfirm,
+      visible: uiState.visible
+    },
+    void 0,
+    false,
+    {
+      fileName: "/Users/kerry/Documents/GitHub/8g-extension/src/content/components/ConfirmationUI.tsx",
+      lineNumber: 213,
+      columnNumber: 5
+    },
+    this
+  );
+}
+_s2(ConfirmationUIContainer, "UwvSFkkcpfVXM3XMbs+084GMpNI=");
+_c2 = ConfirmationUIContainer;
+var _c, _c2;
+$RefreshReg$(_c, "ConfirmationUI");
+$RefreshReg$(_c2, "ConfirmationUIContainer");
+if (import.meta.hot && !inWebWorker) {
+  window.$RefreshReg$ = prevRefreshReg;
+  window.$RefreshSig$ = prevRefreshSig;
+}
+if (import.meta.hot && !inWebWorker) {
+  RefreshRuntime.__hmr_import(import.meta.url).then((currentExports) => {
+    RefreshRuntime.registerExportsForReactRefresh("/Users/kerry/Documents/GitHub/8g-extension/src/content/components/ConfirmationUI.tsx", currentExports);
+    import.meta.hot.accept((nextExports) => {
+      if (!nextExports) return;
+      const invalidateMessage = RefreshRuntime.validateRefreshBoundaryAndEnqueueUpdate("/Users/kerry/Documents/GitHub/8g-extension/src/content/components/ConfirmationUI.tsx", currentExports, nextExports);
+      if (invalidateMessage) import.meta.hot.invalidate(invalidateMessage);
+    });
+  });
+}

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

@@ -0,0 +1,51 @@
+import { ElementSelector } from "/src/content/elements/finders/ElementSelector.ts.js";
+export class CssSelector extends ElementSelector {
+  async find(data, documentCtx = document) {
+    const { selector, option } = data;
+    const { multiple = false } = option || {};
+    try {
+      const processedSelector = this.processCustomPseudoSelectors(selector, documentCtx);
+      if (multiple) {
+        return Array.from(documentCtx.querySelectorAll(processedSelector));
+      } else {
+        return documentCtx.querySelector(processedSelector);
+      }
+    } catch (error) {
+      console.error("CSS Selector error:", error);
+      return null;
+    }
+  }
+  processCustomPseudoSelectors(selector, documentCtx) {
+    const containsRegex = /:contains\(['"]([^'"]*)['"]\)/g;
+    if (containsRegex.test(selector)) {
+      this.markElementsWithText(documentCtx);
+      return selector.replace(
+        /:contains\(['"]([^'"]*)['"]\)/g,
+        (_match, text) => `[data-contains="${text}"]`
+      );
+    }
+    const equalRegex = /:equal\(['"]([^'"]*)['"]\)/g;
+    if (equalRegex.test(selector)) {
+      this.markElementsWithText(documentCtx);
+      return selector.replace(
+        /:equal\(['"]([^'"]*)['"]\)/g,
+        (_match, text) => `[data-equal="${text}"]`
+      );
+    }
+    return selector;
+  }
+  markElementsWithText(documentCtx) {
+    const allElements = documentCtx.querySelectorAll("*");
+    allElements.forEach((element) => {
+      const text = element.textContent?.trim() || "";
+      if (text) {
+        element.setAttribute("data-contains", text);
+        const childNodes = Array.from(element.childNodes);
+        const directText = childNodes.filter((node) => node.nodeType === Node.TEXT_NODE).map((node) => node.textContent?.trim() || "").join(" ").trim();
+        if (directText && directText === text || element.children.length === 0 && text) {
+          element.setAttribute("data-equal", text);
+        }
+      }
+    });
+  }
+}

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

@@ -0,0 +1,20 @@
+export class ElementSelector {
+  async waitForElement(data, documentCtx, timeout) {
+    return new Promise((resolve) => {
+      const startTime = Date.now();
+      const checkElement = async () => {
+        const element = await this.find(data, documentCtx);
+        if (element && (Array.isArray(element) ? element.length > 0 : true)) {
+          resolve(element);
+          return;
+        }
+        if (Date.now() - startTime >= timeout) {
+          resolve(null);
+          return;
+        }
+        setTimeout(checkElement, 100);
+      };
+      checkElement();
+    });
+  }
+}