@intuned/browser-dev 2.2.3-test-build.0

package/dist/common/fuzzySearch/levenshtein-search.js

@@ -0,0 +1,298 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._expand = _expand;
+exports.editDistance = editDistance;
+exports.fuzzySearch = fuzzySearch;
+exports.fuzzySearchCandidates = fuzzySearchCandidates;
+exports.fuzzySearchNgrams = fuzzySearchNgrams;
+exports.isEditDistanceNoGreaterThan = isEditDistanceNoGreaterThan;
+var _utils = require("./utils");
+function isEditDistanceNoGreaterThan(a, b, maxDist) {
+  if (a.length > b.length) {
+    [a, b] = [b, a];
+  }
+  const lenDelta = b.length - a.length;
+  if (lenDelta > maxDist) {
+    return false;
+  }
+  if (maxDist === 0) {
+    return a === b;
+  }
+  let firstDiffIdx;
+  for (firstDiffIdx = 0; firstDiffIdx < a.length; firstDiffIdx++) {
+    if (a[firstDiffIdx] !== b[firstDiffIdx]) break;
+  }
+  if (firstDiffIdx === a.length) {
+    return lenDelta <= maxDist;
+  }
+  let lastDiffIdx;
+  for (lastDiffIdx = a.length - 1; lastDiffIdx >= 0; lastDiffIdx--) {
+    if (a[lastDiffIdx] !== b[lastDiffIdx + lenDelta]) break;
+  }
+  a = a.slice(firstDiffIdx, lastDiffIdx + 1);
+  b = b.slice(firstDiffIdx, lastDiffIdx + 1 + lenDelta);
+  const [dist, length] = _expand(a, b, maxDist);
+  return dist + (b.length - length) <= maxDist;
+}
+function editDistance(a, b) {
+  if (a.length > b.length) {
+    [a, b] = [b, a];
+  }
+  const scores = new Array(a.length + 1);
+  for (let i = 0; i <= a.length; i++) {
+    scores[i] = i;
+  }
+  let _prevScore;
+  let prevScore;
+  for (let i = 0; i < b.length; i++) {
+    scores[0] = i + 1;
+    prevScore = i;
+    for (let k = 0; k < a.length; k++) {
+      _prevScore = scores[k + 1];
+      scores[k + 1] = Math.min(prevScore + +(a[k] !== b[i]), scores[k] + 1, scores[k + 1] + 1);
+      prevScore = _prevScore;
+    }
+  }
+  return scores[a.length];
+}
+function makeChar2needleIdx(needle, maxDist) {
+  const res = {};
+  for (let i = Math.min(needle.length - 1, maxDist); i >= 0; i--) {
+    res[needle[i]] = i;
+  }
+  return res;
+}
+function* fuzzySearch(needle, haystack, maxDist) {
+  if (needle.length > haystack.length + maxDist) return;
+  const ngramLen = Math.floor(needle.length / (maxDist + 1));
+  if (maxDist === 0) {
+    for (const index of (0, _utils.searchExact)(needle, haystack)) {
+      yield {
+        start: index,
+        end: index + needle.length,
+        dist: 0
+      };
+    }
+  } else if (ngramLen >= 10) {
+    yield* fuzzySearchNgrams(needle, haystack, maxDist);
+  } else {
+    yield* fuzzySearchCandidates(needle, haystack, maxDist);
+  }
+}
+function _expand(needle, haystack, maxDist) {
+  maxDist = +maxDist;
+  let firstDiff;
+  for (firstDiff = 0; firstDiff < Math.min(needle.length, haystack.length); firstDiff++) {
+    if (needle.charCodeAt(firstDiff) !== haystack.charCodeAt(firstDiff)) break;
+  }
+  if (firstDiff) {
+    needle = needle.slice(firstDiff);
+    haystack = haystack.slice(firstDiff);
+  }
+  if (!needle) {
+    return [0, firstDiff];
+  } else if (!haystack) {
+    if (needle.length <= maxDist) {
+      return [needle.length, firstDiff];
+    } else {
+      return [null, null];
+    }
+  }
+  if (maxDist === 0) return [null, null];
+  let scores = new Array(needle.length + 1);
+  for (let i = 0; i <= maxDist; i++) {
+    scores[i] = i;
+  }
+  let newScores = new Array(needle.length + 1);
+  let minScore = null;
+  let minScoreIdx = null;
+  let maxGoodScore = maxDist;
+  let firstGoodScoreIdx = 0;
+  let lastGoodScoreIdx = needle.length - 1;
+  for (let haystackIdx = 0; haystackIdx < haystack.length; haystackIdx++) {
+    const char = haystack.charCodeAt(haystackIdx);
+    const needleIdxStart = Math.max(0, firstGoodScoreIdx - 1);
+    const needleIdxLimit = Math.min(haystackIdx + maxDist, needle.length - 1, lastGoodScoreIdx);
+    newScores[0] = scores[0] + 1;
+    firstGoodScoreIdx = newScores[0] <= maxGoodScore ? 0 : null;
+    lastGoodScoreIdx = newScores[0] <= maxGoodScore ? 0 : -1;
+    let needleIdx;
+    for (needleIdx = needleIdxStart; needleIdx < needleIdxLimit; needleIdx++) {
+      const score = newScores[needleIdx + 1] = Math.min(scores[needleIdx] + +(char !== needle.charCodeAt(needleIdx)), scores[needleIdx + 1] + 1, newScores[needleIdx] + 1);
+      if (score <= maxGoodScore) {
+        if (firstGoodScoreIdx === null) firstGoodScoreIdx = needleIdx + 1;
+        lastGoodScoreIdx = Math.max(lastGoodScoreIdx, needleIdx + 1 + (maxGoodScore - score));
+      }
+    }
+    const lastScore = newScores[needleIdx + 1] = Math.min(scores[needleIdx] + +(char !== needle.charCodeAt(needleIdx)), newScores[needleIdx] + 1);
+    if (lastScore <= maxGoodScore) {
+      if (firstGoodScoreIdx === null) firstGoodScoreIdx = needleIdx + 1;
+      lastGoodScoreIdx = needleIdx + 1;
+    }
+    if (needleIdx === needle.length - 1 && (minScore === null || lastScore <= minScore)) {
+      minScore = lastScore;
+      minScoreIdx = haystackIdx;
+      if (minScore < maxGoodScore) maxGoodScore = minScore;
+    }
+    [scores, newScores] = [newScores, scores];
+    if (firstGoodScoreIdx === null) break;
+  }
+  if (minScore !== null && minScore <= maxDist) {
+    return [minScore, minScoreIdx + 1 + firstDiff];
+  } else {
+    return [null, null];
+  }
+}
+function* fuzzySearchNgrams(needle, haystack, maxDist) {
+  const ngramLen = Math.floor(needle.length / (maxDist + 1));
+  const needleLen = needle.length;
+  const haystackLen = haystack.length;
+  for (let ngramStartIdx = 0; ngramStartIdx <= needle.length - ngramLen; ngramStartIdx += ngramLen) {
+    const ngram = needle.slice(ngramStartIdx, ngramStartIdx + ngramLen);
+    const ngramEnd = ngramStartIdx + ngramLen;
+    const needleBeforeReversed = (0, _utils.reverse)(needle.slice(0, ngramStartIdx));
+    const needleAfter = needle.slice(ngramEnd);
+    const startIdx = Math.max(0, ngramStartIdx - maxDist);
+    const endIdx = Math.min(haystackLen, haystackLen - needleLen + ngramEnd + maxDist);
+    for (const haystackMatchIdx of (0, _utils.searchExact)(ngram, haystack, startIdx, endIdx)) {
+      const [distRight, rightExpandSize] = _expand(needleAfter, haystack.slice(haystackMatchIdx + ngramLen, haystackMatchIdx - ngramStartIdx + needleLen + maxDist), maxDist);
+      if (distRight === null) continue;
+      const [distLeft, leftExpandSize] = _expand(needleBeforeReversed, (0, _utils.reverse)(haystack.slice(Math.max(0, haystackMatchIdx - ngramStartIdx - (maxDist - distRight)), haystackMatchIdx)), maxDist - distRight);
+      if (distLeft === null) continue;
+      yield {
+        start: haystackMatchIdx - leftExpandSize,
+        end: haystackMatchIdx + ngramLen + rightExpandSize,
+        dist: distLeft + distRight
+      };
+    }
+  }
+}
+function* fuzzySearchCandidates(needle, haystack, maxDist) {
+  const debugFlag = false;
+  if (debugFlag) console.log(`fuzzySearchCandidates(${needle}, ${haystack}, ${maxDist})`);
+  const needleLen = needle.length;
+  const haystackLen = haystack.length;
+  if (needleLen > haystackLen + maxDist) return;
+  const char2needleIdx = makeChar2needleIdx(needle, maxDist);
+  let prevCandidates = new Map();
+  let candidates = new Map();
+  for (let i = 0; i < haystack.length; i++) {
+    const haystackChar = haystack[i];
+    prevCandidates = candidates;
+    candidates = new Map();
+    const needleIdx = char2needleIdx[haystackChar];
+    if (needleIdx !== undefined) {
+      if (needleIdx + 1 === needleLen) {
+        if (debugFlag) {
+          console.log(`yield ${{
+            start: i,
+            end: i + 1,
+            dist: needleIdx
+          }}`);
+        }
+        yield {
+          start: i,
+          end: i + 1,
+          dist: needleIdx
+        };
+      } else {
+        candidates.set(`${i},${needleIdx + 1},${needleIdx}`, {
+          startIdx: i,
+          needleIdx: needleIdx + 1,
+          dist: needleIdx
+        });
+      }
+    }
+    for (const [, candidate] of prevCandidates) {
+      if (needle[candidate.needleIdx] === haystackChar) {
+        if (candidate.needleIdx + 1 === needleLen) {
+          if (debugFlag) {
+            console.log(`yield ${{
+              start: candidate.startIdx,
+              end: i + 1,
+              dist: candidate.dist
+            }}`);
+          }
+          yield {
+            start: candidate.startIdx,
+            end: i + 1,
+            dist: candidate.dist
+          };
+        } else {
+          candidates.set(`${candidate.startIdx},${candidate.needleIdx + 1},${candidate.dist}`, {
+            startIdx: candidate.startIdx,
+            needleIdx: candidate.needleIdx + 1,
+            dist: candidate.dist
+          });
+        }
+      } else {
+        if (candidate.dist === maxDist) continue;
+        candidates.set(`${candidate.startIdx},${candidate.needleIdx},${candidate.dist + 1}`, {
+          startIdx: candidate.startIdx,
+          needleIdx: candidate.needleIdx,
+          dist: candidate.dist + 1
+        });
+        for (let nSkipped = 1; nSkipped <= maxDist - candidate.dist; nSkipped++) {
+          if (candidate.needleIdx + nSkipped === needleLen) {
+            if (debugFlag) {
+              console.log(`yield ${{
+                start: candidate.startIdx,
+                end: i + 1,
+                dist: candidate.dist + nSkipped
+              }}`);
+            }
+            yield {
+              start: candidate.startIdx,
+              end: i + 1,
+              dist: candidate.dist + nSkipped
+            };
+            break;
+          } else if (needle[candidate.needleIdx + nSkipped] === haystackChar) {
+            if (candidate.needleIdx + nSkipped + 1 === needleLen) {
+              if (debugFlag) {
+                console.log(`yield ${{
+                  start: candidate.startIdx,
+                  end: i + 1,
+                  dist: candidate.dist + nSkipped
+                }}`);
+              }
+              yield {
+                start: candidate.startIdx,
+                end: i + 1,
+                dist: candidate.dist + nSkipped
+              };
+            } else {
+              candidates.set(`${candidate.startIdx},${candidate.needleIdx + 1 + nSkipped},${candidate.dist + nSkipped}`, {
+                startIdx: candidate.startIdx,
+                needleIdx: candidate.needleIdx + 1 + nSkipped,
+                dist: candidate.dist + nSkipped
+              });
+            }
+            break;
+          }
+        }
+        if (i + 1 < haystackLen && candidate.needleIdx + 1 < needleLen) {
+          candidates.set(`${candidate.startIdx},${candidate.needleIdx + 1},${candidate.dist + 1}`, {
+            startIdx: candidate.startIdx,
+            needleIdx: candidate.needleIdx + 1,
+            dist: candidate.dist + 1
+          });
+        }
+      }
+    }
+    if (debugFlag) console.log(candidates);
+  }
+  for (const [, candidate] of candidates) {
+    candidate.dist += needle.length - candidate.needleIdx;
+    if (candidate.dist <= maxDist) {
+      yield {
+        start: candidate.startIdx,
+        end: haystack.length,
+        dist: candidate.dist
+      };
+    }
+  }
+}

package/dist/common/fuzzySearch/utils.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.reverse = reverse;
+exports.searchExact = searchExact;
+function* searchExact(needle, haystack, startIndex = 0, endIndex = null) {
+  const needleLen = needle.length;
+  if (needleLen === 0) return;
+  if (endIndex === null) {
+    endIndex = haystack.length;
+  }
+  let index;
+  while ((index = haystack.indexOf(needle, startIndex)) > -1) {
+    if (index + needle.length > endIndex) break;
+    yield index;
+    startIndex = index + 1;
+  }
+}
+function reverse(string) {
+  return string.split("").reverse().join("");
+}

package/dist/common/getModelProvider.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getModelProvider = getModelProvider;
+function getModelProvider(modelName) {
+  const openaiPrefixes = ["gpt-3", "gpt-4", "o1", "o3", "gpt", "o4"];
+  if (openaiPrefixes.some(prefix => modelName.startsWith(prefix))) {
+    return "openai";
+  } else if (modelName.startsWith("claude")) {
+    return "anthropic";
+  } else if (modelName.startsWith("gemini")) {
+    return "google_vertexai";
+  } else {
+    return "unknown";
+  }
+}

package/dist/common/getSimplifiedHtml.js

@@ -0,0 +1,122 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSimplifiedHtml = getSimplifiedHtml;
+async function getSimplifiedHtml(containerHandle, options) {
+  const tagName = await containerHandle.evaluateHandle(element => element.tagName.toLowerCase());
+  const ALLOWED_ATTRIBUTES = ["aria-label", "data-name", "name", "type", "placeholder", "value", "role", "title", "href", "id", "alt", new RegExp(/^data-/)];
+  const shouldReturnFullHtml = (await tagName.jsonValue()) === "html";
+  const optionsWithDefault = {
+    shouldIncludeOnClick: false,
+    shouldIncludeContentAsProp: false,
+    keepOnlyVisibleElements: true,
+    shouldReturnFullHtml,
+    ...options
+  };
+  const simplifiedHtml = await containerHandle.evaluate((element, {
+    optionsWithDefault,
+    ALLOWED_ATTRIBUTES
+  }) => {
+    function truthyFilter(value) {
+      return Boolean(value);
+    }
+    function isElementNode(node) {
+      return node.nodeType === node.ELEMENT_NODE;
+    }
+    const hasAnyAllowedAttribute = (element, allowedAttributes) => {
+      const elementAttributes = element.getAttributeNames();
+      const hasAllowedAttribute = !!allowedAttributes.some(attr => {
+        if (typeof attr === "string") {
+          return element.hasAttribute(attr);
+        } else if (attr instanceof RegExp) {
+          return elementAttributes.some(attrName => attr.test(attrName));
+        }
+      });
+      return hasAllowedAttribute;
+    };
+    function isElementVisible(style) {
+      return style.opacity !== "" && style.display !== "none" && style.visibility !== "hidden" && style.opacity !== "0";
+    }
+    function isElementInteractive(element, style) {
+      return element.tagName === "A" || element.tagName === "INPUT" || element.tagName === "BUTTON" || element.tagName === "SELECT" || element.tagName === "TEXTAREA" || element.hasAttribute("onclick") || element.hasAttribute("onmousedown") || element.hasAttribute("onmouseup") || element.hasAttribute("onkeydown") || element.hasAttribute("onkeyup") || style.cursor === "pointer";
+    }
+    function getDocumentFromIframeElementSafely(element) {
+      try {
+        if (element.contentWindow && element.contentWindow.document) {
+          return element.contentWindow.document.documentElement;
+        }
+      } catch (error) {
+        return undefined;
+      }
+    }
+    function isInputWithValue(element) {
+      return element.tagName === "INPUT" && element.value && element.value.trim();
+    }
+    function generateSimplifiedDom(element, interactiveElements, document, allowedAttributes, shouldIncludeContentAsProp, keepOnlyVisibleElements) {
+      var _element$textContent;
+      if (element.nodeType === 3 && (_element$textContent = element.textContent) !== null && _element$textContent !== void 0 && _element$textContent.trim()) {
+        return document.createTextNode(element.textContent + " ");
+      }
+      const shouldSkipElementChecks = optionsWithDefault.shouldIncludeIframes ? ["BODY", "HTML", "IFRAME"] : ["BODY", "HTML"].includes(element.nodeName);
+      if (!isElementNode(element)) {
+        return null;
+      }
+      const style = window.getComputedStyle(element);
+      const isVisible = isElementVisible(style) || shouldSkipElementChecks;
+      if (keepOnlyVisibleElements && !isVisible && !isInputWithValue(element)) {
+        return null;
+      }
+      let children = optionsWithDefault.shouldIncludeIframes && element.nodeName === "IFRAME" ? [getDocumentFromIframeElementSafely(element)].filter(Boolean) : Array.from(element.childNodes).map(c => generateSimplifiedDom(c, interactiveElements, document, allowedAttributes, shouldIncludeContentAsProp, keepOnlyVisibleElements)).filter(truthyFilter);
+      if (element.tagName === "BODY") children = children.filter(c => c.nodeType !== 3);
+      const interactive = isElementInteractive(element, style) || element.hasAttribute("role");
+      const hasLabel = element.hasAttribute("aria-label") || element.hasAttribute("name");
+      const hasAllowedAttribute = hasAnyAllowedAttribute(element, allowedAttributes);
+      let includeNode = interactive || hasLabel || hasAllowedAttribute || shouldSkipElementChecks;
+      if (children.length === 0 && !hasAnyAllowedAttribute(element, allowedAttributes)) {
+        return null;
+      }
+      if (children.length === 1 && !hasAnyAllowedAttribute(element, allowedAttributes) && children[0].nodeType !== 3 && !(shouldSkipElementChecks && optionsWithDefault.shouldReturnFullHtml)) {
+        return children[0];
+      }
+      if (!includeNode && children.length === 0) return null;
+      if (!includeNode && children.some(c => c.nodeType === 3)) {
+        includeNode = true;
+      }
+      if (!includeNode && children.length === 1) {
+        return children[0];
+      }
+      const container = element.cloneNode();
+      const allAttributes = element.getAttributeNames();
+      const listOfAttributesToRemove = allAttributes.filter(attr => {
+        const isAllowedString = allowedAttributes.includes(attr);
+        const isAllowedRegExp = allowedAttributes.some(regex => regex instanceof RegExp && regex.test(attr));
+        return !isAllowedString && !isAllowedRegExp;
+      });
+      for (const attr of listOfAttributesToRemove) {
+        container.removeAttribute(attr);
+      }
+      if (interactive) {
+        interactiveElements.push(element);
+      }
+      if (shouldIncludeContentAsProp && element.textContent) {
+        container.setAttribute("content", element.textContent);
+      }
+      children.forEach(child => container.appendChild(child));
+      return container;
+    }
+    function getSimplifiedDomFromElement(htmlElement, shouldIncludeOnClick, shouldIncludeContentAsProp, keepOnlyVisibleElements) {
+      const interactiveElements = [];
+      const allowedAttributes = shouldIncludeOnClick ? [...ALLOWED_ATTRIBUTES, "onclick"] : ALLOWED_ATTRIBUTES;
+      const simplifiedDom = generateSimplifiedDom(htmlElement, interactiveElements, htmlElement.ownerDocument, allowedAttributes, shouldIncludeContentAsProp, keepOnlyVisibleElements);
+      if (!simplifiedDom) return "";
+      return simplifiedDom.outerHTML;
+    }
+    return getSimplifiedDomFromElement(element, optionsWithDefault.shouldIncludeOnClick, optionsWithDefault.shouldIncludeContentAsProp, optionsWithDefault.keepOnlyVisibleElements);
+  }, {
+    optionsWithDefault,
+    ALLOWED_ATTRIBUTES
+  });
+  return simplifiedHtml;
+}

package/dist/common/hashObject.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hashObject = hashObject;
+var crypto = _interopRequireWildcard(require("crypto"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _serialize(obj, treatArraysAsUnsortedLists) {
+  if (obj instanceof Map) {
+    return _serialize(Array.from(obj.entries()), treatArraysAsUnsortedLists);
+  } else if (Array.isArray(obj)) {
+    let serializedSortedArray = obj.map(el => _serialize(el, treatArraysAsUnsortedLists));
+    if (treatArraysAsUnsortedLists) {
+      serializedSortedArray = serializedSortedArray.sort();
+    }
+    return `[${serializedSortedArray.join(",")}]`;
+  } else if (typeof obj === "object" && obj !== null) {
+    let acc = "";
+    const keys = Object.keys(obj).sort();
+    acc += `{${JSON.stringify(keys)}`;
+    for (let i = 0; i < keys.length; i++) {
+      acc += `${_serialize(obj[keys[i]], treatArraysAsUnsortedLists)},`;
+    }
+    return `${acc}}`;
+  }
+  return `${JSON.stringify(obj)}`;
+}
+function hashObject(obj, treatArraysAsUnsortedLists = false, hashAlgorithm = "SHA256", encoding = "hex") {
+  const hash = crypto.createHash(hashAlgorithm);
+  return hash.update(_serialize(obj, treatArraysAsUnsortedLists)).digest(encoding);
+}