scordi-extension 1.14.3 → 1.14.5

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

@@ -1,111 +0,0 @@
-import z from "/vendor/.vite-deps-zod.js__v--13965f26.js";
-import { BaseBlockSchema } from "/src/blocks/types.ts.js";
-import { findElement } from "/src/content/elements/index.ts.js";
-export const ScrollBlockSchema = BaseBlockSchema.extend({
-  name: z.literal("scroll"),
-  scrollType: z.enum(["toElement", "toBottom", "byDistance", "untilLoaded"]).optional(),
-  distance: z.number().optional(),
-  behavior: z.enum(["auto", "smooth"]).optional(),
-  maxScrolls: z.number().optional(),
-  waitAfterScroll: z.number().optional()
-});
-export function validateScrollBlock(data) {
-  return ScrollBlockSchema.parse(data);
-}
-export async function handlerScroll(data) {
-  try {
-    const {
-      selector = "",
-      scrollType = "toBottom",
-      distance = 500,
-      behavior = "smooth",
-      maxScrolls = 50,
-      waitAfterScroll = 300,
-      findBy = "cssSelector",
-      option
-    } = data;
-    switch (scrollType) {
-      case "toElement":
-        if (!selector) {
-          throw new Error("Selector is required for toElement scroll type");
-        }
-        return await scrollToElement(selector, findBy, option, behavior);
-      case "toBottom":
-        return await scrollToBottom(behavior, waitAfterScroll);
-      case "byDistance":
-        return await scrollByDistance(distance, behavior);
-      case "untilLoaded":
-        return await scrollUntilLoaded(maxScrolls, distance, behavior, waitAfterScroll);
-      default:
-        throw new Error(`Unknown scroll type: ${scrollType}`);
-    }
-  } catch (error) {
-    return {
-      hasError: true,
-      message: error instanceof Error ? error.message : "Unknown error in scroll handler",
-      data: false
-    };
-  }
-}
-async function scrollToElement(selector, findBy, option, behavior) {
-  const element = await findElement({ selector, findBy, option });
-  if (!element) {
-    return {
-      hasError: true,
-      message: "Element not found for scrolling",
-      data: false
-    };
-  }
-  const targetElement = Array.isArray(element) ? element[0] : element;
-  targetElement.scrollIntoView({ behavior, block: "center" });
-  return { data: true };
-}
-async function scrollToBottom(behavior, waitAfterScroll) {
-  let lastHeight = document.body.scrollHeight;
-  let attempts = 0;
-  const maxAttempts = 50;
-  while (attempts < maxAttempts) {
-    window.scrollTo({
-      top: document.body.scrollHeight,
-      behavior
-    });
-    await new Promise((resolve) => setTimeout(resolve, waitAfterScroll));
-    const newHeight = document.body.scrollHeight;
-    if (newHeight === lastHeight) {
-      break;
-    }
-    lastHeight = newHeight;
-    attempts++;
-  }
-  return { data: true };
-}
-async function scrollByDistance(distance, behavior) {
-  window.scrollBy({
-    top: distance,
-    behavior
-  });
-  return { data: true };
-}
-async function scrollUntilLoaded(maxScrolls, distance, behavior, waitAfterScroll) {
-  let scrollCount = 0;
-  let lastHeight = document.body.scrollHeight;
-  while (scrollCount < maxScrolls) {
-    window.scrollBy({
-      top: distance,
-      behavior
-      // Use provided behavior
-    });
-    await new Promise((resolve) => setTimeout(resolve, waitAfterScroll));
-    const newHeight = document.body.scrollHeight;
-    const scrollTop = window.pageYOffset || document.documentElement.scrollTop;
-    const windowHeight = window.innerHeight;
-    if (scrollTop + windowHeight >= newHeight - 10) {
-      if (newHeight === lastHeight) {
-        break;
-      }
-    }
-    lastHeight = newHeight;
-    scrollCount++;
-  }
-  return { data: true };
-}

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

@@ -1,56 +0,0 @@
-import { findElement } from "/src/content/elements/index.ts.js";
-import { BaseBlockSchema } from "/src/blocks/types.ts.js";
-import z from "/vendor/.vite-deps-zod.js__v--13965f26.js";
-export const SetValueFormsBlockSchema = BaseBlockSchema.extend({
-  name: z.literal("set-value-form"),
-  setValue: z.string(),
-  type: z.enum(["text-field", "select", "checkbox"]).optional()
-});
-export function validateSetValueFormsBlock(data) {
-  return SetValueFormsBlockSchema.parse(data);
-}
-export async function handlerSetValueForm(data) {
-  try {
-    const { selector = "", setValue, type = "text-field", findBy = "cssSelector" } = data;
-    if (!selector) {
-      throw new Error("Selector is required for set-value-form block");
-    }
-    const element = await findElement({ selector, findBy, option: data.option });
-    if (!element) {
-      throw new Error("Form element not found");
-    }
-    setFormValue(element, setValue, type);
-    return { data: "Form element updated successfully" };
-  } catch (error) {
-    return {
-      hasError: true,
-      message: error instanceof Error ? error.message : "Unknown error in set-value-form handler",
-      data: null
-    };
-  }
-}
-function setFormValue(element, value, type) {
-  switch (type) {
-    case "text-field":
-      if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) {
-        element.value = value;
-        element.dispatchEvent(new Event("input", { bubbles: true }));
-        element.dispatchEvent(new Event("change", { bubbles: true }));
-      }
-      break;
-    case "select":
-      if (element instanceof HTMLSelectElement) {
-        element.value = value;
-        element.dispatchEvent(new Event("change", { bubbles: true }));
-      }
-      break;
-    case "checkbox":
-      if (element instanceof HTMLInputElement && element.type === "checkbox") {
-        element.checked = value === "true" || value === "checked";
-        element.dispatchEvent(new Event("change", { bubbles: true }));
-      }
-      break;
-    default:
-      throw new Error(`Unsupported form element type: ${type}`);
-  }
-}

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

@@ -1,24 +0,0 @@
-import z from "/vendor/.vite-deps-zod.js__v--13965f26.js";
-export const WaitBlockSchema = z.object({
-  name: z.literal("wait"),
-  duration: z.number().min(0)
-});
-export function validateWaitBlock(data) {
-  return WaitBlockSchema.parse(data);
-}
-export async function handlerWait(data) {
-  try {
-    const { duration } = data;
-    console.log(`[Wait] Waiting for ${duration}ms...`);
-    await new Promise((resolve) => setTimeout(resolve, duration));
-    console.log(`[Wait] Wait completed after ${duration}ms`);
-    return { data: true };
-  } catch (error) {
-    console.log(error);
-    return {
-      hasError: true,
-      message: error instanceof Error ? error.message : "Unknown error in wait handler",
-      data: false
-    };
-  }
-}

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

@@ -1,163 +0,0 @@
-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 { 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 { 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 { 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,
-  "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 "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

@@ -1,11 +0,0 @@
-import { z } from "/vendor/.vite-deps-zod.js__v--13965f26.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()
-  })
-});

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

@@ -1,51 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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();
-    });
-  }
-}

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

@@ -1,32 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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));
-  }
-}