@intuned/browser-dev 0.1.4-dev.0

package/dist/common/Logger/index.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.logger = void 0;
+var _nodeUtil = require("node:util");
+var _chalk = _interopRequireDefault(require("chalk"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const format = _nodeUtil.formatWithOptions.bind(undefined, {
+  colors: true
+});
+const LOG_LEVEL_COLORS = {
+  TRACE: _chalk.default.gray,
+  DEBUG: _chalk.default.blue,
+  INFO: _chalk.default.green,
+  WARN: _chalk.default.yellow,
+  ERROR: _chalk.default.red
+};
+class Logger {
+  logFunction(entry) {
+    const {
+      level,
+      timestamp,
+      message,
+      meta
+    } = entry;
+    const date = new Date(timestamp);
+    const levelColor = LOG_LEVEL_COLORS[level];
+    if (meta === undefined) {
+      process.stderr.write(`${format(date)} [@intuned/sdk][${levelColor(level)}] ${message}\n`);
+    } else {
+      process.stderr.write(`${format(date)} [@intuned/sdk][${levelColor(level)}] ${message} ${format(meta)}\n`);
+    }
+  }
+  log(level, message, meta) {
+    this.logFunction({
+      level,
+      message,
+      meta: meta && Object.keys(meta).length === 0 ? undefined : meta,
+      timestamp: Date.now()
+    });
+  }
+  trace(message, meta) {
+    this.log("TRACE", message, meta);
+  }
+  debug(message, meta) {
+    this.log("DEBUG", message, meta);
+  }
+  info(message, meta) {
+    this.log("INFO", message, meta);
+  }
+  warn(message, meta) {
+    this.log("WARN", message, meta);
+  }
+  error(message, meta) {
+    this.log("ERROR", message, meta);
+  }
+}
+const logger = exports.logger = new Logger();

package/dist/common/Logger/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/common/SdkError.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.captureUserStack = exports.SdkError = void 0;
+var _stackUtils = _interopRequireDefault(require("stack-utils"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const stack = new _stackUtils.default({
+  cwd: process.cwd(),
+  internals: _stackUtils.default.nodeInternals()
+});
+class SdkError extends Error {
+  constructor(message, userStack) {
+    super(message);
+    this.name = "SdkError";
+    this.stack = `${this.name}: ${this.message}\nCaused by:\n${userStack}`;
+  }
+}
+exports.SdkError = SdkError;
+const captureUserStack = () => {
+  const traces = stack.capture();
+  const filteredTraces = traces.filter(i => {
+    const fileName = i.getFileName();
+    const typeName = i.getTypeName();
+    if (typeName === "Proxy") return false;
+    if (fileName !== null && fileName !== void 0 && fileName.includes("dist/commands/") || fileName !== null && fileName !== void 0 && fileName.includes("captureUserStack") || fileName !== null && fileName !== void 0 && fileName.includes("SdkError")) return false;
+    return true;
+  });
+  const originalStack = filteredTraces.map(formatCallSite);
+  return originalStack.join("\n");
+};
+exports.captureUserStack = captureUserStack;
+function formatCallSite(callSite) {
+  const functionName = callSite.getFunctionName() || "anonymous";
+  const methodName = callSite.getMethodName();
+  const typeName = callSite.getTypeName();
+  const fileName = callSite.getFileName();
+  const lineNumber = callSite.getLineNumber();
+  const columnNumber = callSite.getColumnNumber();
+  let methodPart = functionName;
+  if (methodName && functionName !== methodName) {
+    methodPart = `${functionName} [as ${methodName}]`;
+  }
+  let typePart = "";
+  if (typeName) {
+    typePart = `${typeName}.`;
+  }
+  return `at ${typePart}${methodPart} (${fileName === null || fileName === void 0 ? void 0 : fileName.replace(process.cwd(), ".")}:${lineNumber}:${columnNumber})`;
+}

package/dist/common/aiModelsValidations.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SUPPPORTED_GPT_MODELS = exports.SUPPPORTED_CLAUDE_MODELS = exports.SUPPORTED_MODELS = exports.MODELS_MAPPINGS = exports.MAX_TOKENS_OVERRIDES = exports.GPT_MODELS = exports.GOOGLE_MODELS = exports.CLAUDE_VISION_SUPPORTED_MODELS = exports.CLAUDE_MODELS_MAPPINGS = exports.CLAUDE_MODELS = void 0;
+const CLAUDE_MODELS = exports.CLAUDE_MODELS = ["claude-opus-4-20250514", "claude-sonnet-4-20250514", "claude-3-7-sonnet-20250219", "claude-3-5-sonnet-20241022", "claude-3-5-sonnet-20240620", "claude-3-5-haiku-20241022", "claude-3-opus-20240229", "claude-3-sonnet-20240229", "claude-3-haiku-20240307"];
+const MAX_TOKENS_OVERRIDES = exports.MAX_TOKENS_OVERRIDES = {
+  "claude-3-5-sonnet-20240620": 8192,
+  "gemini-1.5-pro-002": 8192,
+  "gemini-1.5-flash-8b-002": 8192,
+  "gemini-1.5-flash-002": 8192,
+  "gemini-2.0-flash-exp": 8192
+};
+const CLAUDE_VISION_SUPPORTED_MODELS = exports.CLAUDE_VISION_SUPPORTED_MODELS = [...CLAUDE_MODELS];
+const CLAUDE_MODELS_MAPPINGS = exports.CLAUDE_MODELS_MAPPINGS = {
+  "claude-3-haiku": "claude-3-haiku-20240307",
+  "claude-3-5-haiku": "claude-3-5-haiku-20241022",
+  "claude-3-opus": "claude-3-opus-20240229",
+  "claude-3-sonnet": "claude-3-sonnet-20240229",
+  "claude-3.5-sonnet": "claude-3-5-sonnet-20241022",
+  "claude-4-sonnet": "claude-sonnet-4-20250514",
+  "claude-4-opus": "claude-opus-4-20250514"
+};
+const GPT_MODELS = exports.GPT_MODELS = ["gpt-4.1", "gpt-4.1-mini", "gpt-4.1-nano", "gpt-4o", "gpt-4o-mini", "gpt-4o-audio-preview", "gpt-4-turbo", "gpt-4", "gpt-3.5-turbo", "o1", "o1-mini", "o1-preview", "o3-mini", "o3", "o4-mini", "chatgpt-4o-latest", "gpt4-turbo"];
+const GOOGLE_MODELS = exports.GOOGLE_MODELS = ["gemini-2.5-pro", "gemini-2.5-flash", "gemini-2.5-flash-lite", "gemini-2.5-flash-lite-preview-06-17", "gemini-2.0-flash", "gemini-1.5-pro", "gemini-1.5-pro-latest", "gemini-1.5-flash", "gemini-1.5-flash-latest", "gemini-1.5-flash-8b", "gemini-1.5-flash-8b-latest"];
+const MODELS_MAPPINGS = exports.MODELS_MAPPINGS = {
+  ...CLAUDE_MODELS_MAPPINGS
+};
+const SUPPPORTED_CLAUDE_MODELS = exports.SUPPPORTED_CLAUDE_MODELS = ["claude-3-5-haiku-20241022", "claude-3-5-haiku-latest", "claude-3-5-sonnet-20240620", "claude-3-5-sonnet-20241022", "claude-3-5-sonnet-latest", "claude-3-7-sonnet-20250219", "claude-3-7-sonnet-latest", "claude-3-haiku-20240307", "claude-4-opus-20250514", "claude-4-sonnet-20250514", "claude-opus-4-1", "claude-opus-4-1-20250805", "claude-opus-4-20250514", "claude-sonnet-4-20250514"];
+const SUPPPORTED_GPT_MODELS = exports.SUPPPORTED_GPT_MODELS = ["gpt-3.5-turbo", "gpt-3.5-turbo-0125", "gpt-3.5-turbo-0301", "gpt-3.5-turbo-0613", "gpt-3.5-turbo-1106", "gpt-3.5-turbo-16k", "gpt-3.5-turbo-16k-0613", "gpt-3.5-turbo-instruct", "gpt-3.5-turbo-instruct-0914", "gpt-4", "gpt-4-0314", "gpt-4-0613", "gpt-4-32k", "gpt-4-32k-0314", "gpt-4-32k-0613", "gpt-4-turbo", "gpt-4-turbo-2024-04-09", "gpt-4.1", "gpt-4.1-2025-04-14", "gpt-4.1-mini", "gpt-4.1-mini-2025-04-14", "gpt-4.1-nano", "gpt-4.1-nano-2025-04-14", "gpt-4o", "gpt-4o-2024-05-13", "gpt-4o-2024-08-06", "gpt-4o-2024-11-20", "gpt-4o-mini", "gpt-4o-mini-2024-07-18", "gpt-5", "gpt-5-2025-08-07", "gpt-5-chat", "gpt-5-chat-latest", "gpt-5-mini", "gpt-5-mini-2025-08-07", "gpt-5-nano", "gpt-5-nano-2025-08-07", "o1", "o1-2024-12-17", "o1-mini", "o1-mini-2024-09-12", "o1-pro", "o1-pro-2025-03-19", "o3", "o3-2025-04-16", "o3-deep-research", "o3-deep-research-2025-06-26", "o3-mini", "o3-mini-2025-01-31", "o3-pro", "o3-pro-2025-06-10", "o4-mini", "o4-mini-2025-04-16", "o4-mini-deep-research", "o4-mini-deep-research-2025-06-26"];
+const SUPPORTED_MODELS = exports.SUPPORTED_MODELS = [...SUPPPORTED_CLAUDE_MODELS, ...SUPPPORTED_GPT_MODELS];

package/dist/common/ensureBrowserScripts.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ensureBrowserScripts = ensureBrowserScripts;
+var _script = require("./script");
+async function ensureBrowserScripts(page) {
+  const pageHasScript = await page.evaluate('() => typeof window.__INTUNED__ !== "undefined"');
+  if (pageHasScript) {
+    return;
+  }
+  await page.evaluate(_script.BROWSER_SCRIPT);
+}

package/dist/common/extendedTest.js

@@ -0,0 +1,157 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "afterAll", {
+  enumerable: true,
+  get: function () {
+    return _vitest.afterAll;
+  }
+});
+Object.defineProperty(exports, "afterEach", {
+  enumerable: true,
+  get: function () {
+    return _vitest.afterEach;
+  }
+});
+Object.defineProperty(exports, "beforeAll", {
+  enumerable: true,
+  get: function () {
+    return _vitest.beforeAll;
+  }
+});
+Object.defineProperty(exports, "beforeEach", {
+  enumerable: true,
+  get: function () {
+    return _vitest.beforeEach;
+  }
+});
+Object.defineProperty(exports, "describe", {
+  enumerable: true,
+  get: function () {
+    return _vitest.describe;
+  }
+});
+exports.expect = void 0;
+Object.defineProperty(exports, "it", {
+  enumerable: true,
+  get: function () {
+    return _vitest.it;
+  }
+});
+exports.test = void 0;
+Object.defineProperty(exports, "vi", {
+  enumerable: true,
+  get: function () {
+    return _vitest.vi;
+  }
+});
+var dotenv = _interopRequireWildcard(require("dotenv"));
+var _vitest = require("vitest");
+var _nanoid = require("nanoid");
+var _extractionHelpers = require("./extractionHelpers");
+var _script = require("./script");
+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); }
+dotenv.config();
+const loadRuntime = async () => {
+  try {
+    const runtime = await Promise.resolve().then(() => _interopRequireWildcard(require("@intuned/runtime")));
+    return {
+      withPlaywrightContext: runtime.withPlaywrightContext,
+      runWithContext: runtime.runWithContext,
+      getDownloadDirectoryPath: runtime.getDownloadDirectoryPath
+    };
+  } catch {
+    return {
+      withPlaywrightContext: null,
+      runWithContext: null,
+      getDownloadDirectoryPath: null
+    };
+  }
+};
+const withPlaywright = (name, testFn, {
+  headless,
+  trace,
+  runId,
+  jobId,
+  jobRunId,
+  queueId
+}) => {
+  return async () => {
+    const runtime = await loadRuntime();
+    if (!runtime.runWithContext || !runtime.withPlaywrightContext || !runtime.getDownloadDirectoryPath) {
+      throw new Error("@intuned/runtime is required for running tests. Please install it as a dependency.");
+    }
+    return runtime.runWithContext({
+      runId: runId ?? (0, _nanoid.nanoid)(),
+      extendedPayloads: [],
+      runEnvironment: "IDE",
+      jobId,
+      jobRunId,
+      queueId
+    }, async () => {
+      const downloadsPath = runtime.getDownloadDirectoryPath();
+      await runtime.withPlaywrightContext({
+        headless: headless ?? true,
+        downloadsPath
+      }, async (context, page) => {
+        context.setDefaultTimeout(10000);
+        try {
+          await context.addInitScript({
+            content: _script.BROWSER_SCRIPT
+          });
+          for (const page of context.pages()) {
+            await page.evaluate(_script.BROWSER_SCRIPT);
+          }
+        } catch (error) {
+          console.error("Error reading browser scripts:", error);
+        }
+        if (trace) {
+          await context.tracing.start({
+            screenshots: true
+          });
+        }
+        await testFn({
+          context: context,
+          page
+        });
+        if (trace) {
+          await context.tracing.stop({
+            path: `./reports/traces/${name}.zip`
+          });
+        }
+        return {};
+      });
+    });
+  };
+};
+const test = (name, fn, options = {}) => {
+  if (process.env.CI) {
+    options.headless = true;
+  } else {
+    options.timeout = 1000000;
+  }
+  return (0, _vitest.test)(name, withPlaywright(name, fn, options), options);
+};
+exports.test = test;
+_vitest.expect.extend({
+  async toHaveText(locator, expectedText) {
+    const textContent = await locator.textContent();
+    const pass = !!textContent && (0, _extractionHelpers.compressStringSpaces)(textContent) === expectedText;
+    return {
+      pass,
+      message: () => `Expected locator with selector "${locator}" to have text "${expectedText}", but it has "${textContent}"`
+    };
+  }
+});
+test.skip = _vitest.test.skip;
+test.only = (name, fn, options = {}) => {
+  if (process.env.CI) {
+    options.headless = true;
+  } else {
+    options.timeout = 1000000;
+  }
+  return _vitest.test.only(name, withPlaywright(name, fn, options), options);
+};
+const expect = exports.expect = _vitest.expect;

package/dist/common/extractionHelpers.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.compressStringSpaces = compressStringSpaces;
+exports.selectLocatorsUsingXpath = selectLocatorsUsingXpath;
+exports.splitContainerIntoListLocators = splitContainerIntoListLocators;
+function compressStringSpaces(str) {
+  return str.replace(/\s+/g, " ").trim();
+}
+async function splitContainerIntoListLocators(locator) {
+  const childrenLocators = await locator.locator(":scope > *").all();
+  return childrenLocators;
+}
+async function selectLocatorsUsingXpath(page, xpath) {
+  const trimmed = xpath.replace(/^(\/+)/, "");
+  return await page.locator(`//${trimmed}`).all();
+}

package/dist/common/formatZodError.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatZodError = formatZodError;
+function formatZodError(zodError) {
+  const formattedErrors = zodError.errors.map(error => {
+    const path = error.path.map(segment => {
+      return typeof segment === "number" ? `[${segment}]` : segment;
+    }).join(".");
+    if (path) {
+      return `${path} is invalid - ${error.message}`;
+    }
+    return error.message;
+  });
+  return formattedErrors;
+}

package/dist/common/fuzzySearch/fuzzySearch.test.js

@@ -0,0 +1,250 @@
+"use strict";
+
+var _ = _interopRequireWildcard(require("lodash"));
+var _vitest = require("vitest");
+var _utils = require("./utils");
+var _levenshteinSearch = require("./levenshtein-search");
+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); }
+(0, _vitest.describe)("searchExact", () => {
+  const search = (needle, haystack, ...args) => [...(0, _utils.searchExact)(needle, haystack, ...args)];
+  (0, _vitest.test)("empty needle", () => {
+    (0, _vitest.expect)(search("", "TEXT")).toEqual([]);
+  });
+  (0, _vitest.test)("empty haystack", () => {
+    (0, _vitest.expect)(search("PATTERN", "")).toEqual([]);
+  });
+  const testCases = {
+    identical: ["abc", "abc", [0]],
+    substring: ["abc", "-ab-abc-ab-", [4]],
+    "double first item": ["def", "abcddefg", [4]],
+    "missing second item": ["bde", "abcdefg", []],
+    "completely different": ["abc", "def", []],
+    startswith: ["abc", "abcd", [0]],
+    endswith: ["bcd", "abcd", [1]],
+    "multiple matches": ["abc", "-abc-abc-abc-", [1, 5, 9]]
+  };
+  for (const [name, data] of _.toPairs(testCases)) {
+    const [needle, haystack, expected] = data;
+    (0, _vitest.test)(`searchExact, '${name}' -> ${expected}`, () => {
+      (0, _vitest.expect)(search(needle, haystack)).toEqual(expected);
+    });
+  }
+  for (const [start, expected] of [[1, [1, 5, 9]], [2, [5, 9]], [5, [5, 9]], [6, [9]]]) {
+    (0, _vitest.test)(`searchExact('abc', '-abc-abc-abc-', ${start},) -> ${expected}`, () => {
+      (0, _vitest.expect)(search("abc", "-abc-abc-abc-", start)).toEqual(expected);
+    });
+  }
+  for (const [start, end, expected] of [[0, 3, []], [0, 4, [1]], [0, 7, [1]], [0, 8, [1, 5]], [0, 11, [1, 5]], [0, 12, [1, 5, 9]], [1, 13, [1, 5, 9]], [2, 13, [5, 9]], [5, 13, [5, 9]], [6, 13, [9]], [3, 7, []], [4, 10, [5]]]) {
+    (0, _vitest.test)(`searchExact('abc', '-abc-abc-abc-', ${start}, ${end}) -> ${expected}`, () => {
+      (0, _vitest.expect)(search("abc", "-abc-abc-abc-", start, end)).toEqual(expected);
+    });
+  }
+});
+(0, _vitest.describe)("editDistance", () => {
+  for (const [a, b, dist] of [["", "", 0], ["a", "", 1], ["abc", "abc", 0], ["abc", "def", 3], ["elephant", "relevant", 3], ["abc", "aabc", 1], ["abc", "abbc", 1], ["abc", "abcc", 1], ["abc", "-abc", 1], ["abc", "a-bc", 1], ["abc", "ab-c", 1], ["abc", "abc-", 1], ["aabccdeefgg", "abcdefg", 4]]) {
+    (0, _vitest.test)(`editDistance(${a}, ${b}) == ${dist}`, () => {
+      (0, _vitest.expect)((0, _levenshteinSearch.editDistance)(a, b)).toBe(dist);
+      (0, _vitest.expect)((0, _levenshteinSearch.editDistance)(b, a)).toBe(dist);
+    });
+  }
+});
+(0, _vitest.describe)("fuzzySearch string", () => {
+  const testedFunctions = [_levenshteinSearch.fuzzySearch, _levenshteinSearch.fuzzySearchNgrams, _levenshteinSearch.fuzzySearchCandidates];
+  const longstr = string => string.replace(/\s+/g, "");
+  const testCases = {
+    "identical sequence": ["PATTERN", "PATTERN", [[0, [[0, 7, 0]]]]],
+    substring: ["PATTERN", "----------PATTERN---------", [[0, [[10, 17, 0]]], [1, [[10, 17, 0]]], [2, [[10, 17, 0]]]]],
+    "double first item": ["def", "abcddefg", [[1, [[4, 7, 0]]]]],
+    "double last item": ["def", "abcdeffg", [[1, [[3, 6, 0]]]]],
+    "double first items": ["defgh", "abcdedefghi", [[3, [[5, 10, 0]]]]],
+    "double last items": ["cdefgh", "abcdefghghi", [[3, [[2, 8, 0]]]]],
+    "missing second item": ["bde", "abcdefg", [[1, [[1, 5, 1]]]]],
+    "missing second to last item": ["bce", "abcdefg", [[1, [[1, 5, 1]]], [2, [[1, 5, 1]]]]],
+    "one missing in middle": ["PATTERN", "----------PATERN---------", [[0, []], [1, [[10, 16, 1]]], [2, [[10, 16, 1]]]]],
+    "one changed in middle": ["PATTERN", "----------PAT-ERN---------", [[0, []], [1, [[10, 17, 1]]], [2, [[10, 17, 1]]]]],
+    "one extra in middle": ["PATTERN", "----------PATT-ERN---------", [[0, []], [1, [[10, 18, 1]]], [2, [[10, 18, 1]]]]],
+    "one extra repeating in middle": ["PATTERN", "----------PATTTERN---------", [[0, []], [1, [[10, 18, 1]]], [2, [[10, 18, 1]]]]],
+    "one extra repeating at end": ["PATTERN", "----------PATTERNN---------", [[0, [[10, 17, 0]]], [1, [[10, 17, 0]]], [2, [[10, 17, 0]]]]],
+    "one missing at end": ["defg", "abcdef", [[1, [[3, 6, 1]]]]],
+    "DNA search": ["TGCACTGTAGGGATAACAAT", longstr(`
+        GACTAGCACTGTAGGGATAACAATTTCACACAGGTGGACAATTACATTGAAAATCACAGATTG
+        GTCACACACACATTGGACATACATAGAAACACACACACATACATTAGATACGAACATAGAAAC
+        ACACATTAGACGCGTACATAGACACAAACACATTGACAGGCAGTTCAGATGATGACGCCCGAC
+        TGATACTCGCGTAGTCGTGGGAGGCAAGGCACACAGGGGATAGG
+      `), [[2, [[3, 24, 1]]]]],
+    "protein search 1": ["GGGTTLTTSS", longstr(`
+        XXXXXXXXXXXXXXXXXXXGGGTTVTTSSAAAAAAAAAAAAAGGGTTLTTSSAAAAAAAAAAA
+        AAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBGGGTTLTTSS
+      `), [[0, [[42, 52, 0], [99, 109, 0]]], [1, [[19, 29, 1], [42, 52, 0], [99, 109, 0]]], [2, [[19, 29, 1], [42, 52, 0], [99, 109, 0]]]]],
+    "protein search 2": ["GGGTTLTTSS", longstr(`
+        XXXXXXXXXXXXXXXXXXXGGGTTVTTSSAAAAAAAAAAAAAGGGTTVTTSSAAAAAAAAAAA
+        AAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBGGGTTLTTSS
+      `), [[0, [[99, 109, 0]]], [1, [[19, 29, 1], [42, 52, 1], [99, 109, 0]]], [2, [[19, 29, 1], [42, 52, 1], [99, 109, 0]]]]]
+  };
+  for (const func of testedFunctions) {
+    const search = (needle, haystack, maxDist) => _.chain([...func(needle, haystack, maxDist)]).uniqWith(_.isEqual).sortBy(["start", "end", "dist"]).value();
+    (0, _vitest.expect)(search("abc", "abc", 0)).toEqual([{
+      start: 0,
+      end: 3,
+      dist: 0
+    }]);
+    (0, _vitest.expect)(search("abc", "a-c", 0)).toEqual([]);
+    (0, _vitest.expect)(search("abc", "a-c", 1)).toEqual([{
+      start: 0,
+      end: 3,
+      dist: 1
+    }]);
+    (0, _vitest.expect)(search("abcdefghij", "abcdefghij", 0)).toEqual([{
+      start: 0,
+      end: 10,
+      dist: 0
+    }]);
+    (0, _vitest.expect)(search("abcdefghij", "abcdefghij", 1)).toContainEqual({
+      start: 0,
+      end: 10,
+      dist: 0
+    });
+    (0, _vitest.expect)(search("abcdefghij", "abcdefghi", 1)).toContainEqual({
+      start: 0,
+      end: 9,
+      dist: 1
+    });
+    for (const [name, data] of _.toPairs(testCases)) {
+      const [needle, haystack, maxDist2expectedMatches] = data;
+      for (const [maxDist, expectedMatches] of maxDist2expectedMatches) {
+        const expectedMatchObjs = expectedMatches.map(([start, end, dist]) => {
+          return {
+            start,
+            end,
+            dist
+          };
+        });
+        (0, _vitest.test)(`${func.name}, '${name}', maxDist=${maxDist} -> ${expectedMatches}`, () => {
+          (0, _vitest.expect)(search(needle, haystack, maxDist)).toEqual(_vitest.expect.arrayContaining(expectedMatchObjs));
+        });
+      }
+    }
+  }
+});
+(0, _vitest.describe)("fuzzySearch array of strings", () => {
+  const testedFunctions = [_levenshteinSearch.fuzzySearchCandidates];
+  for (const func of testedFunctions) {
+    (0, _vitest.test)(`${func.name}`, () => {
+      const search = (needle, haystack, maxDist) => _.sortedUniqBy([...func(needle, haystack, maxDist)], _.isEqual);
+      (0, _vitest.expect)(search(["a", "b", "c"], ["a", "b", "c"], 0)).toEqual([{
+        start: 0,
+        end: 3,
+        dist: 0
+      }]);
+      (0, _vitest.expect)(search(["abc", "def", "ghi"], ["abc", "def", "ghi"], 0)).toEqual([{
+        start: 0,
+        end: 3,
+        dist: 0
+      }]);
+      (0, _vitest.expect)(search(["a", "b", "c"], ["a", "d", "c"], 0)).toEqual([]);
+      (0, _vitest.expect)(search(["abc", "def", "ghi"], ["abc", "xyz", "ghi"], 1)).toEqual([{
+        start: 0,
+        end: 3,
+        dist: 1
+      }]);
+    });
+  }
+});
+(0, _vitest.test)("isEditDistanceNoGreaterThan", () => {
+  function m(str, n) {
+    let result = "";
+    for (;;) {
+      if (n & 1) result += str;
+      n >>= 1;
+      if (n) str += str;else break;
+    }
+    return result;
+  }
+  (0, _vitest.expect)((0, _levenshteinSearch.isEditDistanceNoGreaterThan)("a", "a", 0)).toBe(true);
+  (0, _vitest.expect)((0, _levenshteinSearch.isEditDistanceNoGreaterThan)("a", "b", 0)).toBe(false);
+  (0, _vitest.expect)((0, _levenshteinSearch.isEditDistanceNoGreaterThan)("a", "b", 1)).toBe(true);
+  (0, _vitest.expect)((0, _levenshteinSearch.isEditDistanceNoGreaterThan)("aaaaa", "aaaaa", 0)).toBe(true);
+  (0, _vitest.expect)((0, _levenshteinSearch.isEditDistanceNoGreaterThan)("aaaaa", "baaaa", 0)).toBe(false);
+  (0, _vitest.expect)((0, _levenshteinSearch.isEditDistanceNoGreaterThan)("aaaaa", "aabaa", 0)).toBe(false);
+  (0, _vitest.expect)((0, _levenshteinSearch.isEditDistanceNoGreaterThan)("aaaaa", "aaaab", 0)).toBe(false);
+  (0, _vitest.expect)((0, _levenshteinSearch.isEditDistanceNoGreaterThan)("aaaaa", "aabaa", 1)).toBe(true);
+  (0, _vitest.expect)((0, _levenshteinSearch.isEditDistanceNoGreaterThan)("aaaaa", "aabba", 1)).toBe(false);
+  const x100 = m("x", 100);
+  for (const [a, b, dist] of [["aaaaa", "bbbbb", 5], [`${x100}yz${x100}`, m("x", 200), 2], [`${x100}yz${x100}`, m("x", 202), 2], [`${x100}yz${x100}yz${x100}`, m("x", 304), 4]]) {
+    if (dist > 0) {
+      (0, _vitest.expect)((0, _levenshteinSearch.isEditDistanceNoGreaterThan)(a, b, dist - 1)).toBe(false);
+    }
+    (0, _vitest.expect)((0, _levenshteinSearch.isEditDistanceNoGreaterThan)(a, b, dist)).toBe(true);
+    (0, _vitest.expect)((0, _levenshteinSearch.isEditDistanceNoGreaterThan)(a, b, dist + 1)).toBe(true);
+  }
+});
+(0, _vitest.describe)("_expand() unit tests", () => {
+  (0, _vitest.test)("both empty", () => {
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("", "", 0)).toEqual([0, 0]);
+  });
+  (0, _vitest.test)("empty needle", () => {
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("", "haystack", 0)).toEqual([0, 0]);
+  });
+  (0, _vitest.test)("both empty", () => {
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("needle", "", 0)).toEqual([null, null]);
+  });
+  (0, _vitest.test)("identical", () => {
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("abc", "abc", 0)).toEqual([0, 3]);
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("abc", "abc", 1)).toEqual([0, 3]);
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("abc", "abc", 2)).toEqual([0, 3]);
+  });
+  (0, _vitest.test)("first item missing", () => {
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("abcd", "bcd", 0)).toEqual([null, null]);
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("abcd", "bcd", 1)).toEqual([1, 3]);
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("abcd", "bcd", 2)).toEqual([1, 3]);
+  });
+  (0, _vitest.test)("first second missing", () => {
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("abcd", "acd", 0)).toEqual([null, null]);
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("abcd", "acd", 1)).toEqual([1, 3]);
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("abcd", "acd", 2)).toEqual([1, 3]);
+  });
+  (0, _vitest.test)("before last missing", () => {
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("abcd", "abd", 0)).toEqual([null, null]);
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("abcd", "abd", 1)).toEqual([1, 3]);
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("abcd", "abd", 2)).toEqual([1, 3]);
+  });
+  (0, _vitest.test)("last missing", () => {
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("abcd", "abc", 0)).toEqual([null, null]);
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("abcd", "abc", 1)).toEqual([1, 3]);
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("abcd", "abc", 2)).toEqual([1, 3]);
+  });
+  (0, _vitest.test)("completely different", () => {
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("abc", "def", 0)).toEqual([null, null]);
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("abc", "def", 1)).toEqual([null, null]);
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("abc", "def", 2)).toEqual([null, null]);
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("abc", "def", 3)).toEqual([3, 3]);
+  });
+  (0, _vitest.test)("startswith", () => {
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("abc", "abcd", 0)).toEqual([0, 3]);
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("abc", "abcd", 1)).toEqual([0, 3]);
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("abc", "abcd", 2)).toEqual([0, 3]);
+  });
+  (0, _vitest.test)("missing at start, middle, and end", () => {
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("abcd", "-ab-cd-", 0)).toEqual([null, null]);
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("abcd", "-ab-cd-", 1)).toEqual([null, null]);
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("abcd", "-ab-cd-", 2)).toEqual([2, 6]);
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("abcd", "-ab-cd-", 3)).toEqual([2, 6]);
+  });
+  (0, _vitest.test)("long needle", () => {
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("abcdefghijklmnop", "abcdefg-hijk-mnopqrst", 0)).toEqual([null, null]);
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("abcdefghijklmnop", "abcdefg-hijk-mnopqrst", 1)).toEqual([null, null]);
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("abcdefghijklmnop", "abcdefg-hijk-mnopqrst", 2)).toEqual([2, 17]);
+    (0, _vitest.expect)((0, _levenshteinSearch._expand)("abcdefghijklmnop", "abcdefg-hijk-mnopqrst", 3)).toEqual([2, 17]);
+  });
+});
+(0, _vitest.describe)("super long test", () => {
+  (0, _vitest.test)("super long test", () => {
+    const haystack = "lorem ipsum dolor sit amet consectetur adipiscing elit sed do eiusmod tempor incididunt ut labore et dolore magna aliqua, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua lorem ipsum dolor sit amet consectetur adipiscing elit sed do eiusmod tempor incididunt ut labore et dolore magna aliqua, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua lorem ipsum dolor sit amet consectetur adipiscing elit sed do eiusmod tempor incididunt ut labore et dolore magna aliqua, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua lorem ipsum dolor sit amet consectetur adipiscing elit sed do eiusmod tempor incididunt ut labore et dolore magna aliqua, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua";
+    const needle = "lorem ipsum dolor sit amet consectetur adipiscing elit sed do eiusmod tempor incididunt ut labore et dolore magna aliqua, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua";
+    const results = [];
+    for (const result of (0, _levenshteinSearch.fuzzySearchCandidates)(needle, haystack, 24)) {
+      results.push(result);
+    }
+    console.log(results.reverse());
+  });
+});