@qontinui/ui-bridge 0.2.0 → 0.3.1

package/dist/core/index.js

@@ -1,1553 +1,5 @@
 'use strict';
 
-// src/core/element-identifier.ts
-var ID_ATTRIBUTES = ["data-ui-id", "data-testid", "data-awas-element", "id"];
-function generateXPath(element) {
-  if (element.id) {
-    return `//*[@id="${element.id}"]`;
-  }
-  const parts = [];
-  let current = element;
-  while (current && current.nodeType === Node.ELEMENT_NODE) {
-    let selector = current.nodeName.toLowerCase();
-    const uiId = current.getAttribute("data-ui-id");
-    if (uiId) {
-      selector += `[@data-ui-id="${uiId}"]`;
-      parts.unshift(selector);
-      break;
-    }
-    const testId = current.getAttribute("data-testid");
-    if (testId) {
-      selector += `[@data-testid="${testId}"]`;
-      parts.unshift(selector);
-      break;
-    }
-    const id = current.id;
-    if (id) {
-      selector += `[@id="${id}"]`;
-      parts.unshift(selector);
-      break;
-    }
-    const parentEl = current.parentElement;
-    if (parentEl) {
-      const currentEl = current;
-      const siblings = Array.from(parentEl.children).filter(
-        (child) => child.nodeName === currentEl.nodeName
-      );
-      if (siblings.length > 1) {
-        const index = siblings.indexOf(currentEl) + 1;
-        selector += `[${index}]`;
-      }
-    }
-    parts.unshift(selector);
-    current = parentEl;
-  }
-  return "/" + parts.join("/");
-}
-function generateCSSSelector(element) {
-  const uiId = element.getAttribute("data-ui-id");
-  if (uiId) {
-    return `[data-ui-id="${uiId}"]`;
-  }
-  const testId = element.getAttribute("data-testid");
-  if (testId) {
-    return `[data-testid="${testId}"]`;
-  }
-  const awasId = element.getAttribute("data-awas-element");
-  if (awasId) {
-    return `[data-awas-element="${awasId}"]`;
-  }
-  if (element.id) {
-    return `#${CSS.escape(element.id)}`;
-  }
-  const path = [];
-  let current = element;
-  while (current && current.nodeType === Node.ELEMENT_NODE) {
-    let selector = current.nodeName.toLowerCase();
-    const parentUiId = current.getAttribute("data-ui-id");
-    if (parentUiId && current !== element) {
-      path.unshift(`[data-ui-id="${parentUiId}"]`);
-      break;
-    }
-    const parentTestId = current.getAttribute("data-testid");
-    if (parentTestId && current !== element) {
-      path.unshift(`[data-testid="${parentTestId}"]`);
-      break;
-    }
-    if (current.id) {
-      path.unshift(`#${CSS.escape(current.id)}`);
-      break;
-    }
-    const parentEl = current.parentElement;
-    if (parentEl) {
-      const currentEl = current;
-      const siblings = Array.from(parentEl.children);
-      const sameTagSiblings = siblings.filter(
-        (s) => s.nodeName === currentEl.nodeName
-      );
-      if (sameTagSiblings.length > 1) {
-        const index = siblings.indexOf(currentEl) + 1;
-        selector += `:nth-child(${index})`;
-      }
-    }
-    path.unshift(selector);
-    current = current.parentElement;
-  }
-  return path.join(" > ");
-}
-function getBestIdentifier(element) {
-  const uiId = element.getAttribute("data-ui-id");
-  if (uiId) return uiId;
-  const testId = element.getAttribute("data-testid");
-  if (testId) return testId;
-  const awasId = element.getAttribute("data-awas-element");
-  if (awasId) return awasId;
-  if (element.id) return element.id;
-  return generateCSSSelector(element);
-}
-function createElementIdentifier(element) {
-  return {
-    uiId: element.getAttribute("data-ui-id") || void 0,
-    testId: element.getAttribute("data-testid") || void 0,
-    awasId: element.getAttribute("data-awas-element") || void 0,
-    htmlId: element.id || void 0,
-    xpath: generateXPath(element),
-    selector: generateCSSSelector(element)
-  };
-}
-function findElementByIdentifier(identifier, root = document) {
-  if (typeof identifier === "string") {
-    const byUiId = root.querySelector(`[data-ui-id="${identifier}"]`);
-    if (byUiId) return byUiId;
-    const byTestId = root.querySelector(`[data-testid="${identifier}"]`);
-    if (byTestId) return byTestId;
-    const byAwasId = root.querySelector(`[data-awas-element="${identifier}"]`);
-    if (byAwasId) return byAwasId;
-    const byId = root.querySelector(`#${CSS.escape(identifier)}`);
-    if (byId) return byId;
-    try {
-      const bySelector = root.querySelector(identifier);
-      if (bySelector) return bySelector;
-    } catch {
-    }
-    try {
-      const result = document.evaluate(
-        identifier,
-        root,
-        null,
-        XPathResult.FIRST_ORDERED_NODE_TYPE,
-        null
-      );
-      if (result.singleNodeValue instanceof HTMLElement) {
-        return result.singleNodeValue;
-      }
-    } catch {
-    }
-    return null;
-  }
-  if (identifier.uiId) {
-    const el = root.querySelector(`[data-ui-id="${identifier.uiId}"]`);
-    if (el) return el;
-  }
-  if (identifier.testId) {
-    const el = root.querySelector(`[data-testid="${identifier.testId}"]`);
-    if (el) return el;
-  }
-  if (identifier.awasId) {
-    const el = root.querySelector(`[data-awas-element="${identifier.awasId}"]`);
-    if (el) return el;
-  }
-  if (identifier.htmlId) {
-    const el = root.querySelector(`#${CSS.escape(identifier.htmlId)}`);
-    if (el) return el;
-  }
-  if (identifier.selector) {
-    try {
-      const el = root.querySelector(identifier.selector);
-      if (el) return el;
-    } catch {
-    }
-  }
-  if (identifier.xpath) {
-    try {
-      const result = document.evaluate(
-        identifier.xpath,
-        root,
-        null,
-        XPathResult.FIRST_ORDERED_NODE_TYPE,
-        null
-      );
-      if (result.singleNodeValue instanceof HTMLElement) {
-        return result.singleNodeValue;
-      }
-    } catch {
-    }
-  }
-  return null;
-}
-function findAllElementsByIdentifier(pattern, root = document) {
-  const results = [];
-  try {
-    const elements = root.querySelectorAll(pattern);
-    results.push(...Array.from(elements));
-    if (results.length > 0) return results;
-  } catch {
-  }
-  const partials = [
-    `[data-ui-id*="${pattern}"]`,
-    `[data-testid*="${pattern}"]`,
-    `[data-awas-element*="${pattern}"]`,
-    `[id*="${pattern}"]`
-  ];
-  for (const selector of partials) {
-    try {
-      const elements = root.querySelectorAll(selector);
-      for (const el of elements) {
-        if (!results.includes(el)) {
-          results.push(el);
-        }
-      }
-    } catch {
-    }
-  }
-  return results;
-}
-function elementMatchesIdentifier(element, identifier) {
-  if (typeof identifier === "string") {
-    return element.getAttribute("data-ui-id") === identifier || element.getAttribute("data-testid") === identifier || element.getAttribute("data-awas-element") === identifier || element.id === identifier || element.matches(identifier);
-  }
-  return identifier.uiId && element.getAttribute("data-ui-id") === identifier.uiId || identifier.testId && element.getAttribute("data-testid") === identifier.testId || identifier.awasId && element.getAttribute("data-awas-element") === identifier.awasId || identifier.htmlId && element.id === identifier.htmlId || false;
-}
-
-// src/ai/fuzzy-matcher.ts
-var DEFAULT_FUZZY_CONFIG = {
-  threshold: 0.7,
-  levenshteinWeight: 0.3,
-  jaroWinklerWeight: 0.4,
-  ngramWeight: 0.3,
-  ngramSize: 2,
-  caseSensitive: false,
-  ignoreWhitespace: true
-};
-function levenshteinDistance(s1, s2) {
-  const len1 = s1.length;
-  const len2 = s2.length;
-  const matrix = Array(len1 + 1).fill(null).map(() => Array(len2 + 1).fill(0));
-  for (let i = 0; i <= len1; i++) matrix[i][0] = i;
-  for (let j = 0; j <= len2; j++) matrix[0][j] = j;
-  for (let i = 1; i <= len1; i++) {
-    for (let j = 1; j <= len2; j++) {
-      const cost = s1[i - 1] === s2[j - 1] ? 0 : 1;
-      matrix[i][j] = Math.min(
-        matrix[i - 1][j] + 1,
-        // deletion
-        matrix[i][j - 1] + 1,
-        // insertion
-        matrix[i - 1][j - 1] + cost
-        // substitution
-      );
-    }
-  }
-  return matrix[len1][len2];
-}
-function levenshteinSimilarity(s1, s2) {
-  if (s1.length === 0 && s2.length === 0) return 1;
-  if (s1.length === 0 || s2.length === 0) return 0;
-  const distance = levenshteinDistance(s1, s2);
-  const maxLength = Math.max(s1.length, s2.length);
-  return 1 - distance / maxLength;
-}
-function jaroSimilarity(s1, s2) {
-  if (s1.length === 0 && s2.length === 0) return 1;
-  if (s1.length === 0 || s2.length === 0) return 0;
-  const matchDistance = Math.floor(Math.max(s1.length, s2.length) / 2) - 1;
-  const s1Matches = new Array(s1.length).fill(false);
-  const s2Matches = new Array(s2.length).fill(false);
-  let matches = 0;
-  let transpositions = 0;
-  for (let i = 0; i < s1.length; i++) {
-    const start = Math.max(0, i - matchDistance);
-    const end = Math.min(i + matchDistance + 1, s2.length);
-    for (let j = start; j < end; j++) {
-      if (s2Matches[j] || s1[i] !== s2[j]) continue;
-      s1Matches[i] = true;
-      s2Matches[j] = true;
-      matches++;
-      break;
-    }
-  }
-  if (matches === 0) return 0;
-  let k = 0;
-  for (let i = 0; i < s1.length; i++) {
-    if (!s1Matches[i]) continue;
-    while (!s2Matches[k]) k++;
-    if (s1[i] !== s2[k]) transpositions++;
-    k++;
-  }
-  return (matches / s1.length + matches / s2.length + (matches - transpositions / 2) / matches) / 3;
-}
-function jaroWinklerSimilarity(s1, s2, prefixScale = 0.1) {
-  const jaroSim = jaroSimilarity(s1, s2);
-  let prefixLength = 0;
-  const maxPrefix = Math.min(4, Math.min(s1.length, s2.length));
-  for (let i = 0; i < maxPrefix; i++) {
-    if (s1[i] === s2[i]) {
-      prefixLength++;
-    } else {
-      break;
-    }
-  }
-  return jaroSim + prefixLength * prefixScale * (1 - jaroSim);
-}
-function generateNgrams(s, n) {
-  const ngrams = /* @__PURE__ */ new Set();
-  if (s.length < n) {
-    ngrams.add(s);
-    return ngrams;
-  }
-  for (let i = 0; i <= s.length - n; i++) {
-    ngrams.add(s.substring(i, i + n));
-  }
-  return ngrams;
-}
-function ngramSimilarity(s1, s2, n = 2) {
-  if (s1.length === 0 && s2.length === 0) return 1;
-  if (s1.length === 0 || s2.length === 0) return 0;
-  const ngrams1 = generateNgrams(s1, n);
-  const ngrams2 = generateNgrams(s2, n);
-  let intersection = 0;
-  for (const ngram of ngrams1) {
-    if (ngrams2.has(ngram)) {
-      intersection++;
-    }
-  }
-  const union = ngrams1.size + ngrams2.size - intersection;
-  return union === 0 ? 0 : intersection / union;
-}
-function normalizeString(s, config = {}) {
-  let normalized = s;
-  if (!config.caseSensitive) {
-    normalized = normalized.toLowerCase();
-  }
-  if (config.ignoreWhitespace !== false) {
-    normalized = normalized.replace(/\s+/g, " ").trim();
-  }
-  return normalized;
-}
-function fuzzyMatch(source, target, config = {}) {
-  const finalConfig = { ...DEFAULT_FUZZY_CONFIG, ...config };
-  const normalizedSource = normalizeString(source, finalConfig);
-  const normalizedTarget = normalizeString(target, finalConfig);
-  const levenshteinScore = levenshteinSimilarity(normalizedSource, normalizedTarget);
-  const jaroWinklerScore = jaroWinklerSimilarity(normalizedSource, normalizedTarget);
-  const ngramScore = ngramSimilarity(normalizedSource, normalizedTarget, finalConfig.ngramSize);
-  const similarity = levenshteinScore * finalConfig.levenshteinWeight + jaroWinklerScore * finalConfig.jaroWinklerWeight + ngramScore * finalConfig.ngramWeight;
-  return {
-    similarity,
-    isMatch: similarity >= finalConfig.threshold,
-    scores: {
-      levenshtein: levenshteinScore,
-      jaroWinkler: jaroWinklerScore,
-      ngram: ngramScore
-    },
-    normalizedSource,
-    normalizedTarget
-  };
-}
-function tokenize(s) {
-  return s.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[_-]/g, " ").replace(/\s+/g, " ").trim().toLowerCase().split(" ").filter((token) => token.length > 0);
-}
-
-// src/ai/alias-generator.ts
-var DEFAULT_ALIAS_CONFIG = {
-  includeText: true,
-  includeAriaLabel: true,
-  includePlaceholder: true,
-  includeTitle: true,
-  includeSynonyms: true,
-  maxAliases: 20,
-  minLength: 2,
-  maxLength: 50
-};
-var SYNONYMS = {
-  // Submit-related
-  submit: ["send", "go", "confirm", "ok", "apply", "save", "done", "finish"],
-  send: ["submit", "deliver", "post"],
-  save: ["submit", "store", "keep", "apply"],
-  cancel: ["close", "dismiss", "abort", "back", "exit", "quit", "nevermind"],
-  close: ["cancel", "dismiss", "exit", "x"],
-  delete: ["remove", "trash", "erase", "clear", "destroy"],
-  remove: ["delete", "clear", "discard"],
-  edit: ["modify", "change", "update", "alter"],
-  update: ["edit", "modify", "save", "refresh"],
-  add: ["create", "new", "plus", "insert"],
-  create: ["add", "new", "make"],
-  search: ["find", "lookup", "query", "filter"],
-  find: ["search", "locate", "lookup"],
-  login: ["signin", "sign in", "log in", "authenticate", "enter"],
-  logout: ["signout", "sign out", "log out", "exit"],
-  register: ["signup", "sign up", "join", "create account"],
-  next: ["continue", "forward", "proceed", "advance"],
-  previous: ["back", "backward", "return", "prior"],
-  back: ["previous", "return", "backward"],
-  start: ["begin", "launch", "initiate", "run", "execute"],
-  stop: ["end", "halt", "pause", "terminate"],
-  enable: ["activate", "turn on", "switch on"],
-  disable: ["deactivate", "turn off", "switch off"],
-  show: ["display", "reveal", "view", "open"],
-  hide: ["conceal", "collapse", "close"],
-  expand: ["open", "show", "unfold", "reveal"],
-  collapse: ["close", "hide", "fold", "minimize"],
-  yes: ["ok", "confirm", "agree", "accept"],
-  no: ["cancel", "decline", "reject", "deny"],
-  help: ["support", "assistance", "info", "information", "faq"],
-  settings: ["preferences", "options", "config", "configuration"],
-  profile: ["account", "user", "me"],
-  download: ["export", "save", "get"],
-  upload: ["import", "load", "attach"],
-  refresh: ["reload", "update", "sync"],
-  copy: ["duplicate", "clone"],
-  paste: ["insert"],
-  select: ["choose", "pick"],
-  toggle: ["switch", "flip"],
-  // Form fields
-  email: ["e-mail", "mail"],
-  password: ["pass", "pwd", "secret"],
-  username: ["user", "login", "account", "name"],
-  firstname: ["first name", "given name", "forename"],
-  lastname: ["last name", "surname", "family name"],
-  fullname: ["full name", "name", "complete name"],
-  phone: ["telephone", "tel", "mobile", "cell"],
-  address: ["location", "street"],
-  city: ["town"],
-  country: ["nation"],
-  zip: ["zipcode", "postal", "postal code", "postcode"],
-  // Navigation
-  home: ["main", "start", "dashboard"],
-  menu: ["navigation", "nav"],
-  sidebar: ["side bar", "side panel", "side menu"]
-};
-var ELEMENT_ACTION_WORDS = {
-  button: ["button", "btn", "click"],
-  input: ["input", "field", "textbox", "box"],
-  textarea: ["textarea", "text area", "text field", "multiline"],
-  select: ["select", "dropdown", "combo", "picker", "chooser"],
-  checkbox: ["checkbox", "check", "tick"],
-  radio: ["radio", "option", "choice"],
-  link: ["link", "anchor", "href"],
-  form: ["form"],
-  menu: ["menu"],
-  menuitem: ["menu item", "option"],
-  tab: ["tab"],
-  dialog: ["dialog", "modal", "popup"],
-  switch: ["switch", "toggle"],
-  slider: ["slider", "range"]
-};
-function normalizeAlias(text) {
-  return text.toLowerCase().replace(/[^\w\s]/g, " ").replace(/\s+/g, " ").trim();
-}
-function extractWords(text) {
-  const tokens = tokenize(text);
-  return tokens.filter((t) => t.length >= 2);
-}
-function generateTextAliases(text, config) {
-  if (!text || !config.includeText) return [];
-  const aliases = [];
-  const normalized = normalizeAlias(text);
-  if (normalized.length >= config.minLength && normalized.length <= config.maxLength) {
-    aliases.push(normalized);
-  }
-  const words = extractWords(text);
-  for (const word of words) {
-    if (word.length >= config.minLength) {
-      aliases.push(word);
-    }
-  }
-  if (words.length >= 2 && words.length <= 4) {
-    const twoWords = words.slice(0, 2).join(" ");
-    if (twoWords.length <= config.maxLength) {
-      aliases.push(twoWords);
-    }
-    if (words.length > 2) {
-      const lastTwo = words.slice(-2).join(" ");
-      if (lastTwo.length <= config.maxLength) {
-        aliases.push(lastTwo);
-      }
-    }
-  }
-  return aliases;
-}
-function generateSynonyms(aliases, config) {
-  if (!config.includeSynonyms) return [];
-  const synonyms = [];
-  for (const alias of aliases) {
-    const words = alias.toLowerCase().split(/\s+/);
-    for (const word of words) {
-      if (SYNONYMS[word]) {
-        for (const synonym of SYNONYMS[word]) {
-          const newAlias = alias.toLowerCase().replace(word, synonym);
-          if (newAlias !== alias.toLowerCase()) {
-            synonyms.push(newAlias);
-          }
-          if (synonym.length >= config.minLength) {
-            synonyms.push(synonym);
-          }
-        }
-      }
-    }
-  }
-  return synonyms;
-}
-function generateTypeAliases(elementType) {
-  const type = elementType.toLowerCase();
-  return ELEMENT_ACTION_WORDS[type] || [type];
-}
-function generateAliases(input, config = {}) {
-  const finalConfig = { ...DEFAULT_ALIAS_CONFIG, ...config };
-  const aliasSet = /* @__PURE__ */ new Set();
-  const addAlias = (alias) => {
-    const normalized = normalizeAlias(alias);
-    if (normalized.length >= finalConfig.minLength && normalized.length <= finalConfig.maxLength) {
-      aliasSet.add(normalized);
-    }
-  };
-  const addAliases = (aliases2) => {
-    for (const alias of aliases2) {
-      addAlias(alias);
-    }
-  };
-  if (finalConfig.includeText && input.textContent) {
-    addAliases(generateTextAliases(input.textContent, finalConfig));
-  }
-  if (finalConfig.includeAriaLabel && input.ariaLabel) {
-    addAliases(generateTextAliases(input.ariaLabel, finalConfig));
-  }
-  if (finalConfig.includeAriaLabel && input.ariaLabelledBy) {
-    addAliases(generateTextAliases(input.ariaLabelledBy, finalConfig));
-  }
-  if (finalConfig.includePlaceholder && input.placeholder) {
-    addAliases(generateTextAliases(input.placeholder, finalConfig));
-  }
-  if (finalConfig.includeTitle && input.title) {
-    addAliases(generateTextAliases(input.title, finalConfig));
-  }
-  if (input.labelText) {
-    addAliases(generateTextAliases(input.labelText, finalConfig));
-  }
-  if (input.id) {
-    addAliases(extractWords(input.id));
-  }
-  if (input.name) {
-    addAliases(extractWords(input.name));
-  }
-  if (input.value && (input.elementType === "button" || input.inputType === "submit" || input.inputType === "button")) {
-    addAliases(generateTextAliases(input.value, finalConfig));
-  }
-  if (input.elementType) {
-    addAliases(generateTypeAliases(input.elementType));
-  }
-  if (input.inputType) {
-    addAlias(input.inputType);
-    if (input.inputType === "email") {
-      addAliases(["email", "e-mail", "email address"]);
-    } else if (input.inputType === "password") {
-      addAliases(["password", "pass", "pwd"]);
-    } else if (input.inputType === "tel") {
-      addAliases(["phone", "telephone", "mobile"]);
-    } else if (input.inputType === "url") {
-      addAliases(["url", "website", "link", "address"]);
-    } else if (input.inputType === "search") {
-      addAliases(["search", "find", "query"]);
-    }
-  }
-  if (finalConfig.includeSynonyms) {
-    const currentAliases = Array.from(aliasSet);
-    addAliases(generateSynonyms(currentAliases, finalConfig));
-  }
-  let aliases = Array.from(aliasSet);
-  aliases.sort((a, b) => a.length - b.length);
-  if (aliases.length > finalConfig.maxAliases) {
-    aliases = aliases.slice(0, finalConfig.maxAliases);
-  }
-  return aliases;
-}
-function generateDescription(input) {
-  const parts = [];
-  let name = input.ariaLabel || input.labelText || input.textContent || input.placeholder || input.title || input.id || input.name;
-  if (name) {
-    name = name.trim();
-    if (name.length > 30) {
-      name = name.substring(0, 27) + "...";
-    }
-    parts.push(`"${name}"`);
-  }
-  const typeWords = ELEMENT_ACTION_WORDS[input.elementType || ""] || [input.elementType || "element"];
-  parts.push(typeWords[0]);
-  if (input.inputType && input.inputType !== "text") {
-    parts.push(`(${input.inputType})`);
-  }
-  return parts.join(" ");
-}
-
-// src/core/registry.ts
-function getElementState(element) {
-  const rect = element.getBoundingClientRect();
-  const computedStyle = window.getComputedStyle(element);
-  const state = {
-    visible: isElementVisible(element, rect, computedStyle),
-    enabled: !isElementDisabled(element),
-    focused: document.activeElement === element,
-    rect: {
-      x: rect.x,
-      y: rect.y,
-      width: rect.width,
-      height: rect.height,
-      top: rect.top,
-      right: rect.right,
-      bottom: rect.bottom,
-      left: rect.left
-    },
-    textContent: element.textContent?.trim() || void 0,
-    computedStyles: {
-      display: computedStyle.display,
-      visibility: computedStyle.visibility,
-      opacity: computedStyle.opacity,
-      pointerEvents: computedStyle.pointerEvents
-    }
-  };
-  if (element instanceof HTMLInputElement) {
-    state.value = element.value;
-    if (element.type === "checkbox" || element.type === "radio") {
-      state.checked = element.checked;
-    }
-  } else if (element instanceof HTMLTextAreaElement) {
-    state.value = element.value;
-  } else if (element instanceof HTMLSelectElement) {
-    state.value = element.value;
-    state.selectedOptions = Array.from(element.selectedOptions).map((opt) => opt.value);
-  }
-  return state;
-}
-function isElementVisible(element, rect, style) {
-  if (rect.width === 0 || rect.height === 0) return false;
-  if (style.display === "none") return false;
-  if (style.visibility === "hidden") return false;
-  if (parseFloat(style.opacity) === 0) return false;
-  const inViewport = rect.top < window.innerHeight && rect.bottom > 0 && rect.left < window.innerWidth && rect.right > 0;
-  return inViewport;
-}
-function isElementDisabled(element) {
-  if ("disabled" in element && element.disabled) {
-    return true;
-  }
-  if (element.getAttribute("aria-disabled") === "true") {
-    return true;
-  }
-  return false;
-}
-function inferActions(type) {
-  const baseActions = ["focus", "blur", "hover"];
-  switch (type) {
-    case "button":
-      return [...baseActions, "click", "doubleClick", "rightClick"];
-    case "input":
-      return [...baseActions, "click", "type", "clear"];
-    case "textarea":
-      return [...baseActions, "click", "type", "clear"];
-    case "select":
-      return [...baseActions, "click", "select"];
-    case "checkbox":
-      return [...baseActions, "click", "check", "uncheck", "toggle"];
-    case "radio":
-      return [...baseActions, "click", "check"];
-    case "link":
-      return [...baseActions, "click"];
-    case "form":
-      return ["focus", "blur"];
-    case "menu":
-    case "menuitem":
-      return [...baseActions, "click"];
-    case "tab":
-      return [...baseActions, "click"];
-    case "dialog":
-      return ["focus", "blur"];
-    case "custom":
-    default:
-      return [...baseActions, "click"];
-  }
-}
-function inferElementType(element) {
-  const tagName = element.tagName.toLowerCase();
-  const role = element.getAttribute("role");
-  if (role) {
-    switch (role) {
-      case "button":
-        return "button";
-      case "textbox":
-        return "input";
-      case "checkbox":
-        return "checkbox";
-      case "radio":
-        return "radio";
-      case "link":
-        return "link";
-      case "listbox":
-      case "combobox":
-        return "select";
-      case "menu":
-        return "menu";
-      case "menuitem":
-        return "menuitem";
-      case "tab":
-        return "tab";
-      case "dialog":
-        return "dialog";
-    }
-  }
-  switch (tagName) {
-    case "button":
-      return "button";
-    case "input": {
-      const inputType = element.type;
-      if (inputType === "checkbox") return "checkbox";
-      if (inputType === "radio") return "radio";
-      if (inputType === "submit" || inputType === "button") return "button";
-      return "input";
-    }
-    case "textarea":
-      return "textarea";
-    case "select":
-      return "select";
-    case "a":
-      return "link";
-    case "form":
-      return "form";
-    default:
-      return "custom";
-  }
-}
-var UIBridgeRegistry = class {
-  constructor(options = {}) {
-    this.elements = /* @__PURE__ */ new Map();
-    this.components = /* @__PURE__ */ new Map();
-    this.workflows = /* @__PURE__ */ new Map();
-    this.eventListeners = /* @__PURE__ */ new Map();
-    // State management
-    this.states = /* @__PURE__ */ new Map();
-    this.stateGroups = /* @__PURE__ */ new Map();
-    this.transitions = /* @__PURE__ */ new Map();
-    this.activeStates = /* @__PURE__ */ new Set();
-    this.options = options;
-  }
-  /**
-   * Emit an event
-   */
-  emit(type, data) {
-    const event = {
-      type,
-      timestamp: Date.now(),
-      data
-    };
-    this.options.onEvent?.(event);
-    const listeners = this.eventListeners.get(type);
-    if (listeners) {
-      for (const listener of listeners) {
-        try {
-          listener(event);
-        } catch (error) {
-          console.error(`Error in event listener for ${type}:`, error);
-        }
-      }
-    }
-    if (this.options.verbose) {
-      console.log("[UIBridge]", type, data);
-    }
-  }
-  /**
-   * Register an event listener
-   */
-  on(type, listener) {
-    if (!this.eventListeners.has(type)) {
-      this.eventListeners.set(type, /* @__PURE__ */ new Set());
-    }
-    this.eventListeners.get(type).add(listener);
-    return () => {
-      this.eventListeners.get(type)?.delete(listener);
-    };
-  }
-  /**
-   * Remove an event listener
-   */
-  off(type, listener) {
-    this.eventListeners.get(type)?.delete(listener);
-  }
-  /**
-   * Register an element
-   */
-  registerElement(id, element, options = {}) {
-    const type = options.type ?? inferElementType(element);
-    const actions = options.actions ?? inferActions(type);
-    const existingUiId = element.getAttribute("data-ui-id");
-    const actualId = existingUiId || id;
-    if (!existingUiId) {
-      element.setAttribute("data-ui-id", actualId);
-    }
-    const registered = {
-      id: actualId,
-      element,
-      type,
-      label: options.label,
-      actions,
-      customActions: options.customActions,
-      getState: () => getElementState(element),
-      getIdentifier: () => createElementIdentifier(element),
-      registeredAt: Date.now(),
-      mounted: true
-    };
-    this.elements.set(actualId, registered);
-    this.emit("element:registered", { id: actualId, type, label: options.label });
-    return registered;
-  }
-  /**
-   * Unregister an element
-   */
-  unregisterElement(id) {
-    const registered = this.elements.get(id);
-    if (registered) {
-      registered.mounted = false;
-      registered.element.removeAttribute("data-ui-id");
-      this.elements.delete(id);
-      this.emit("element:unregistered", { id });
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Get a registered element
-   */
-  getElement(id) {
-    return this.elements.get(id);
-  }
-  /**
-   * Get all registered elements
-   */
-  getAllElements() {
-    return Array.from(this.elements.values());
-  }
-  /**
-   * Find element by DOM element reference
-   */
-  findByDOMElement(element) {
-    for (const registered of this.elements.values()) {
-      if (registered.element === element) {
-        return registered;
-      }
-    }
-    return void 0;
-  }
-  /**
-   * Search for elements using AI search criteria
-   */
-  searchElements(criteria) {
-    const results = [];
-    const threshold = criteria.fuzzyThreshold ?? 0.7;
-    for (const element of this.elements.values()) {
-      if (!element.mounted) continue;
-      const state = element.getState();
-      if (!criteria.fuzzy && !state.visible) continue;
-      const aliases = element.aliases ?? this.generateElementAliases(element);
-      const textContent = state.textContent?.trim() || "";
-      const label = element.label || "";
-      let maxScore = 0;
-      const matchReasons = [];
-      const scores = {};
-      if (criteria.text) {
-        if (textContent.toLowerCase() === criteria.text.toLowerCase() || label.toLowerCase() === criteria.text.toLowerCase()) {
-          maxScore = 1;
-          matchReasons.push("exact text match");
-          scores.text = 1;
-        } else if (criteria.fuzzy !== false) {
-          const textResult = fuzzyMatch(criteria.text, textContent, { threshold });
-          const labelResult = fuzzyMatch(criteria.text, label, { threshold });
-          const bestResult = textResult.similarity > labelResult.similarity ? textResult : labelResult;
-          if (bestResult.isMatch) {
-            scores.text = bestResult.similarity;
-            if (bestResult.similarity > maxScore) {
-              maxScore = bestResult.similarity;
-              matchReasons.push(`text similarity: ${(bestResult.similarity * 100).toFixed(0)}%`);
-            }
-          }
-        }
-      }
-      if (criteria.textContains) {
-        if (textContent.toLowerCase().includes(criteria.textContains.toLowerCase()) || label.toLowerCase().includes(criteria.textContains.toLowerCase())) {
-          const containsScore = 0.85;
-          scores.text = Math.max(scores.text ?? 0, containsScore);
-          if (containsScore > maxScore) {
-            maxScore = containsScore;
-            matchReasons.push("text contains");
-          }
-        }
-      }
-      if (criteria.accessibleName) {
-        const ariaLabel = element.element.getAttribute("aria-label") || "";
-        const accessibleName = ariaLabel || label || textContent;
-        if (accessibleName.toLowerCase() === criteria.accessibleName.toLowerCase()) {
-          scores.accessibility = 1;
-          if (1 > maxScore) {
-            maxScore = 1;
-            matchReasons.push("accessible name match");
-          }
-        } else if (criteria.fuzzy !== false) {
-          const result = fuzzyMatch(criteria.accessibleName, accessibleName, { threshold });
-          if (result.isMatch) {
-            scores.accessibility = result.similarity;
-            if (result.similarity > maxScore) {
-              maxScore = result.similarity;
-              matchReasons.push(`accessible name similarity: ${(result.similarity * 100).toFixed(0)}%`);
-            }
-          }
-        }
-      }
-      if (criteria.role) {
-        const role = element.element.getAttribute("role") || this.inferRole(element.type);
-        if (role?.toLowerCase() === criteria.role.toLowerCase()) {
-          scores.role = 1;
-          if (1 > maxScore) {
-            maxScore = 1;
-            matchReasons.push(`role: ${criteria.role}`);
-          }
-        }
-      }
-      if (criteria.type) {
-        if (element.type === criteria.type) {
-          const typeScore = 0.9;
-          scores.role = Math.max(scores.role ?? 0, typeScore);
-          if (typeScore > maxScore) {
-            maxScore = typeScore;
-            matchReasons.push(`type: ${criteria.type}`);
-          }
-        }
-      }
-      for (const alias of aliases) {
-        const searchText = criteria.text || criteria.textContains || criteria.accessibleName;
-        if (searchText) {
-          if (alias.toLowerCase() === searchText.toLowerCase()) {
-            scores.fuzzy = 1;
-            if (1 > maxScore) {
-              maxScore = 1;
-              matchReasons.push(`alias: "${alias}"`);
-            }
-          } else if (criteria.fuzzy !== false) {
-            const result = fuzzyMatch(searchText, alias, { threshold });
-            if (result.isMatch && result.similarity > (scores.fuzzy ?? 0)) {
-              scores.fuzzy = result.similarity;
-              if (result.similarity > maxScore) {
-                maxScore = result.similarity;
-                matchReasons.push(`fuzzy alias: "${alias}"`);
-              }
-            }
-          }
-        }
-      }
-      if (maxScore >= threshold) {
-        const aiElement = {
-          id: element.id,
-          type: element.type,
-          label: element.label,
-          tagName: element.element.tagName.toLowerCase(),
-          role: element.element.getAttribute("role") || void 0,
-          accessibleName: element.element.getAttribute("aria-label") || element.label,
-          actions: element.actions,
-          state,
-          registered: true,
-          description: element.description || generateDescription({
-            textContent,
-            ariaLabel: element.element.getAttribute("aria-label"),
-            elementType: element.type,
-            id: element.id,
-            labelText: element.label
-          }),
-          aliases,
-          purpose: element.purpose,
-          suggestedActions: [],
-          semanticType: element.semanticType
-        };
-        results.push({
-          element: aiElement,
-          confidence: maxScore,
-          matchReasons,
-          scores
-        });
-      }
-    }
-    results.sort((a, b) => b.confidence - a.confidence);
-    return results;
-  }
-  /**
-   * Find element by visible text
-   */
-  findByText(text, fuzzy = true) {
-    const results = this.searchElements({ text, fuzzy, fuzzyThreshold: fuzzy ? 0.7 : 1 });
-    if (results.length > 0) {
-      return this.elements.get(results[0].element.id);
-    }
-    return void 0;
-  }
-  /**
-   * Find element by accessible name
-   */
-  findByAccessibleName(name) {
-    const results = this.searchElements({ accessibleName: name, fuzzy: true });
-    if (results.length > 0) {
-      return this.elements.get(results[0].element.id);
-    }
-    return void 0;
-  }
-  /**
-   * Generate aliases for an element
-   */
-  generateElementAliases(element) {
-    const state = element.getState();
-    return generateAliases({
-      textContent: state.textContent,
-      ariaLabel: element.element.getAttribute("aria-label"),
-      placeholder: element.element.getAttribute("placeholder"),
-      title: element.element.getAttribute("title"),
-      elementType: element.type,
-      tagName: element.element.tagName.toLowerCase(),
-      id: element.id,
-      labelText: element.label
-    });
-  }
-  /**
-   * Infer ARIA role from element type
-   */
-  inferRole(type) {
-    const roleMap = {
-      button: "button",
-      input: "textbox",
-      select: "combobox",
-      checkbox: "checkbox",
-      radio: "radio",
-      link: "link",
-      form: void 0,
-      textarea: "textbox",
-      menu: "menu",
-      menuitem: "menuitem",
-      tab: "tab",
-      dialog: "dialog",
-      custom: void 0,
-      switch: "switch",
-      slider: "slider",
-      combobox: "combobox",
-      listbox: "listbox",
-      option: "option",
-      textbox: "textbox",
-      generic: void 0
-    };
-    return roleMap[type];
-  }
-  /**
-   * Register a component
-   */
-  registerComponent(id, options) {
-    const registered = {
-      id,
-      name: options.name,
-      description: options.description,
-      actions: options.actions?.map((a) => ({
-        id: a.id,
-        label: a.label,
-        description: a.description,
-        handler: a.handler
-      })) ?? [],
-      elementIds: options.elementIds,
-      registeredAt: Date.now(),
-      mounted: true
-    };
-    this.components.set(id, registered);
-    this.emit("component:registered", { id, name: options.name });
-    return registered;
-  }
-  /**
-   * Unregister a component
-   */
-  unregisterComponent(id) {
-    const component = this.components.get(id);
-    if (component) {
-      component.mounted = false;
-      this.components.delete(id);
-      this.emit("component:unregistered", { id });
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Get a registered component
-   */
-  getComponent(id) {
-    return this.components.get(id);
-  }
-  /**
-   * Get all registered components
-   */
-  getAllComponents() {
-    return Array.from(this.components.values());
-  }
-  /**
-   * Register a workflow
-   */
-  registerWorkflow(workflow) {
-    this.workflows.set(workflow.id, workflow);
-    return workflow;
-  }
-  /**
-   * Unregister a workflow
-   */
-  unregisterWorkflow(id) {
-    return this.workflows.delete(id);
-  }
-  /**
-   * Get a workflow
-   */
-  getWorkflow(id) {
-    return this.workflows.get(id);
-  }
-  /**
-   * Get all workflows
-   */
-  getAllWorkflows() {
-    return Array.from(this.workflows.values());
-  }
-  // ==========================================================================
-  // State Management
-  // ==========================================================================
-  /**
-   * Register a state
-   */
-  registerState(state) {
-    this.states.set(state.id, state);
-    this.emit("element:registered", { id: state.id, type: "state", name: state.name });
-    return state;
-  }
-  /**
-   * Unregister a state
-   */
-  unregisterState(id) {
-    const state = this.states.get(id);
-    if (state) {
-      this.activeStates.delete(id);
-      this.states.delete(id);
-      this.emit("element:unregistered", { id, type: "state" });
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Get a registered state
-   */
-  getState(id) {
-    return this.states.get(id);
-  }
-  /**
-   * Get all registered states
-   */
-  getAllStates() {
-    return Array.from(this.states.values());
-  }
-  /**
-   * Register a state group
-   */
-  registerStateGroup(group) {
-    this.stateGroups.set(group.id, group);
-    return group;
-  }
-  /**
-   * Unregister a state group
-   */
-  unregisterStateGroup(id) {
-    return this.stateGroups.delete(id);
-  }
-  /**
-   * Get a state group
-   */
-  getStateGroup(id) {
-    return this.stateGroups.get(id);
-  }
-  /**
-   * Get all state groups
-   */
-  getAllStateGroups() {
-    return Array.from(this.stateGroups.values());
-  }
-  /**
-   * Register a transition
-   */
-  registerTransition(transition) {
-    this.transitions.set(transition.id, transition);
-    return transition;
-  }
-  /**
-   * Unregister a transition
-   */
-  unregisterTransition(id) {
-    return this.transitions.delete(id);
-  }
-  /**
-   * Get a transition
-   */
-  getTransition(id) {
-    return this.transitions.get(id);
-  }
-  /**
-   * Get all transitions
-   */
-  getAllTransitions() {
-    return Array.from(this.transitions.values());
-  }
-  /**
-   * Get currently active states
-   */
-  getActiveStates() {
-    return Array.from(this.activeStates);
-  }
-  /**
-   * Check if a state is active
-   */
-  isStateActive(id) {
-    return this.activeStates.has(id);
-  }
-  /**
-   * Activate a state
-   */
-  activateState(id) {
-    const state = this.states.get(id);
-    if (!state) {
-      return false;
-    }
-    for (const activeId of this.activeStates) {
-      const activeState = this.states.get(activeId);
-      if (activeState?.blocking && activeState.id !== id) {
-        return false;
-      }
-      if (activeState?.blocks?.includes(id)) {
-        return false;
-      }
-    }
-    const wasActive = this.activeStates.has(id);
-    this.activeStates.add(id);
-    if (!wasActive) {
-      this.emit("element:stateChanged", {
-        stateId: id,
-        active: true,
-        activeStates: this.getActiveStates()
-      });
-    }
-    return true;
-  }
-  /**
-   * Deactivate a state
-   */
-  deactivateState(id) {
-    const wasActive = this.activeStates.has(id);
-    this.activeStates.delete(id);
-    if (wasActive) {
-      this.emit("element:stateChanged", {
-        stateId: id,
-        active: false,
-        activeStates: this.getActiveStates()
-      });
-    }
-    return wasActive;
-  }
-  /**
-   * Activate multiple states
-   */
-  activateStates(ids) {
-    const activated = [];
-    for (const id of ids) {
-      if (this.activateState(id)) {
-        activated.push(id);
-      }
-    }
-    return activated;
-  }
-  /**
-   * Deactivate multiple states
-   */
-  deactivateStates(ids) {
-    const deactivated = [];
-    for (const id of ids) {
-      if (this.deactivateState(id)) {
-        deactivated.push(id);
-      }
-    }
-    return deactivated;
-  }
-  /**
-   * Activate a state group (all states in the group)
-   */
-  activateStateGroup(groupId) {
-    const group = this.stateGroups.get(groupId);
-    if (!group) return [];
-    return this.activateStates(group.states);
-  }
-  /**
-   * Deactivate a state group (all states in the group)
-   */
-  deactivateStateGroup(groupId) {
-    const group = this.stateGroups.get(groupId);
-    if (!group) return [];
-    return this.deactivateStates(group.states);
-  }
-  /**
-   * Check if a transition can be executed from current state
-   */
-  canExecuteTransition(transitionId) {
-    const transition = this.transitions.get(transitionId);
-    if (!transition) return false;
-    return transition.fromStates.some((stateId) => this.activeStates.has(stateId));
-  }
-  /**
-   * Execute a transition
-   */
-  async executeTransition(transitionId) {
-    const startTime = performance.now();
-    const transition = this.transitions.get(transitionId);
-    if (!transition) {
-      return {
-        success: false,
-        activatedStates: [],
-        deactivatedStates: [],
-        error: `Transition not found: ${transitionId}`,
-        durationMs: performance.now() - startTime
-      };
-    }
-    if (!this.canExecuteTransition(transitionId)) {
-      return {
-        success: false,
-        activatedStates: [],
-        deactivatedStates: [],
-        error: "Precondition not met: none of the fromStates are active",
-        failedPhase: "precondition",
-        durationMs: performance.now() - startTime
-      };
-    }
-    try {
-      const deactivated = this.deactivateStates(transition.exitStates);
-      if (transition.exitGroups) {
-        for (const groupId of transition.exitGroups) {
-          deactivated.push(...this.deactivateStateGroup(groupId));
-        }
-      }
-      const activated = this.activateStates(transition.activateStates);
-      if (transition.activateGroups) {
-        for (const groupId of transition.activateGroups) {
-          activated.push(...this.activateStateGroup(groupId));
-        }
-      }
-      return {
-        success: true,
-        activatedStates: activated,
-        deactivatedStates: deactivated,
-        durationMs: performance.now() - startTime
-      };
-    } catch (error) {
-      return {
-        success: false,
-        activatedStates: [],
-        deactivatedStates: [],
-        error: error instanceof Error ? error.message : String(error),
-        failedPhase: "execution",
-        durationMs: performance.now() - startTime
-      };
-    }
-  }
-  /**
-   * Find a path from current state to target states
-   *
-   * Uses a simple BFS algorithm for pathfinding.
-   * For more advanced pathfinding (Dijkstra, A*), use the Python state manager service.
-   */
-  findPath(targetStates) {
-    if (targetStates.every((t) => this.activeStates.has(t))) {
-      return {
-        found: true,
-        transitions: [],
-        totalCost: 0,
-        targetStates,
-        estimatedSteps: 0
-      };
-    }
-    const queue = [
-      { activeStates: new Set(this.activeStates), path: [], cost: 0 }
-    ];
-    const visited = /* @__PURE__ */ new Set();
-    while (queue.length > 0) {
-      const current = queue.shift();
-      const stateKey = Array.from(current.activeStates).sort().join(",");
-      if (visited.has(stateKey)) continue;
-      visited.add(stateKey);
-      if (targetStates.every((t) => current.activeStates.has(t))) {
-        return {
-          found: true,
-          transitions: current.path,
-          totalCost: current.cost,
-          targetStates,
-          estimatedSteps: current.path.length
-        };
-      }
-      for (const transition of this.transitions.values()) {
-        const canExecute = transition.fromStates.some((s) => current.activeStates.has(s));
-        if (!canExecute) continue;
-        const newActive = new Set(current.activeStates);
-        for (const s of transition.exitStates) newActive.delete(s);
-        for (const s of transition.activateStates) newActive.add(s);
-        const newCost = current.cost + (transition.pathCost ?? 1);
-        queue.push({
-          activeStates: newActive,
-          path: [...current.path, transition.id],
-          cost: newCost
-        });
-      }
-    }
-    return {
-      found: false,
-      transitions: [],
-      totalCost: 0,
-      targetStates,
-      estimatedSteps: 0
-    };
-  }
-  /**
-   * Navigate to target states using pathfinding
-   */
-  async navigateTo(targetStates) {
-    const startTime = performance.now();
-    const path = this.findPath(targetStates);
-    if (!path.found) {
-      return {
-        success: false,
-        path,
-        executedTransitions: [],
-        finalActiveStates: this.getActiveStates(),
-        error: `No path found to target states: ${targetStates.join(", ")}`,
-        durationMs: performance.now() - startTime
-      };
-    }
-    const executedTransitions = [];
-    for (const transitionId of path.transitions) {
-      const result = await this.executeTransition(transitionId);
-      if (!result.success) {
-        return {
-          success: false,
-          path,
-          executedTransitions,
-          finalActiveStates: this.getActiveStates(),
-          error: result.error,
-          durationMs: performance.now() - startTime
-        };
-      }
-      executedTransitions.push(transitionId);
-    }
-    return {
-      success: true,
-      path,
-      executedTransitions,
-      finalActiveStates: this.getActiveStates(),
-      durationMs: performance.now() - startTime
-    };
-  }
-  /**
-   * Create a state snapshot
-   */
-  createStateSnapshot() {
-    return {
-      timestamp: Date.now(),
-      activeStates: this.getActiveStates(),
-      states: this.getAllStates(),
-      groups: this.getAllStateGroups(),
-      transitions: this.getAllTransitions()
-    };
-  }
-  /**
-   * Create a snapshot of the current state
-   */
-  createSnapshot() {
-    return {
-      timestamp: Date.now(),
-      elements: this.getAllElements().map((el) => ({
-        id: el.id,
-        type: el.type,
-        label: el.label,
-        identifier: el.getIdentifier(),
-        state: el.getState(),
-        actions: el.actions,
-        customActions: el.customActions ? Object.keys(el.customActions) : void 0
-      })),
-      components: this.getAllComponents().map((comp) => ({
-        id: comp.id,
-        name: comp.name,
-        description: comp.description,
-        actions: comp.actions.map((a) => a.id),
-        elementIds: comp.elementIds
-      })),
-      workflows: this.getAllWorkflows().map((wf) => ({
-        id: wf.id,
-        name: wf.name,
-        description: wf.description,
-        stepCount: wf.steps.length
-      }))
-    };
-  }
-  /**
-   * Clear all registrations
-   */
-  clear() {
-    this.elements.clear();
-    this.components.clear();
-    this.workflows.clear();
-    this.eventListeners.clear();
-    this.states.clear();
-    this.stateGroups.clear();
-    this.transitions.clear();
-    this.activeStates.clear();
-  }
-  /**
-   * Get registry statistics
-   */
-  getStats() {
-    const elements = this.getAllElements();
-    const components = this.getAllComponents();
-    return {
-      elementCount: elements.length,
-      componentCount: components.length,
-      workflowCount: this.workflows.size,
-      mountedElementCount: elements.filter((e) => e.mounted).length,
-      mountedComponentCount: components.filter((c) => c.mounted).length,
-      stateCount: this.states.size,
-      stateGroupCount: this.stateGroups.size,
-      transitionCount: this.transitions.size,
-      activeStateCount: this.activeStates.size
-    };
-  }
-};
-var globalRegistry = null;
-function getGlobalRegistry() {
-  if (!globalRegistry) {
-    globalRegistry = new UIBridgeRegistry();
-  }
-  return globalRegistry;
-}
-function setGlobalRegistry(registry) {
-  globalRegistry = registry;
-}
-function resetGlobalRegistry() {
-  globalRegistry?.clear();
-  globalRegistry = null;
-}
-
 // src/core/websocket-client.ts
 function generateId() {
   return `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
@@ -1983,19 +435,7 @@ function createWSClient(config) {
   return new UIBridgeWSClient(config);
 }
 
-exports.ID_ATTRIBUTES = ID_ATTRIBUTES;
-exports.UIBridgeRegistry = UIBridgeRegistry;
 exports.UIBridgeWSClient = UIBridgeWSClient;
-exports.createElementIdentifier = createElementIdentifier;
 exports.createWSClient = createWSClient;
-exports.elementMatchesIdentifier = elementMatchesIdentifier;
-exports.findAllElementsByIdentifier = findAllElementsByIdentifier;
-exports.findElementByIdentifier = findElementByIdentifier;
-exports.generateCSSSelector = generateCSSSelector;
-exports.generateXPath = generateXPath;
-exports.getBestIdentifier = getBestIdentifier;
-exports.getGlobalRegistry = getGlobalRegistry;
-exports.resetGlobalRegistry = resetGlobalRegistry;
-exports.setGlobalRegistry = setGlobalRegistry;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map