scordi-extension 1.14.6 → 1.14.7

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();
+    });
+  }
+}

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;
+    });
+  }
+}