@intuned/browser-dev 2.2.3-unify-sdks.20

package/dist/common/ensureBrowserScripts.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ensureBrowserScripts = ensureBrowserScripts;
+var _fs = require("fs");
+var _path = require("path");
+async function ensureBrowserScripts(page) {
+  const pageHasScript = await page.evaluate('() => typeof window.__INTUNED__ !== "undefined"');
+  if (pageHasScript) {
+    return;
+  }
+  const scriptPath = (0, _path.join)(__dirname, "..", "common", "browser_scripts.js");
+  const scriptContent = (0, _fs.readFileSync)(scriptPath, "utf-8");
+  await page.evaluate(scriptContent);
+}

package/dist/common/environmentVariables.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getEnvironmentVariable = getEnvironmentVariable;
+function getEnvironmentVariable(name) {
+  if (name === "RUN_ENVIRONMENT") {
+    const value = process.env.RUN_ENVIRONMENT;
+    if (!value) {
+      throw new Error("run environment is not set");
+    }
+    return value;
+  }
+  return undefined;
+}

package/dist/common/eventTracking/getAiTrackingHeaders.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAiTrackingHeaders = getAiTrackingHeaders;
+function getAiTrackingHeaders({
+  environment,
+  type,
+  runId,
+  jobId,
+  jobRunId,
+  queueId
+}) {
+  const headers = new Headers();
+  if (runId) {
+    headers.append("x-intuned-run-id", runId);
+  }
+  if (jobId) {
+    headers.append("x-intuned-job-id", jobId);
+  }
+  if (jobRunId) {
+    headers.append("x-intuned-job-run-id", jobRunId);
+  }
+  if (queueId) {
+    headers.append("x-intuned-queue-id", queueId);
+  }
+  headers.append("x-intuned-environment", environment);
+  headers.append("x-intuned-type", type);
+  return Object.fromEntries(headers);
+}

package/dist/common/eventTracking/getFileTrackingHeaders.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getFilesTrackingHeaders = getFilesTrackingHeaders;
+function getFilesTrackingHeaders({
+  environment,
+  runId,
+  identifier,
+  jobId,
+  jobRunId,
+  queueId
+}) {
+  const headers = new Headers();
+  if (runId) headers.append("x-intuned-run-id", runId);
+  if (identifier) headers.append("x-intuned-identifier", identifier);
+  if (jobId) headers.append("x-intuned-job-id", jobId);
+  if (jobRunId) headers.append("x-intuned-job-run-id", jobRunId);
+  if (queueId) headers.append("x-intuned-queue-id", queueId);
+  headers.append("x-intuned-environment", environment);
+  return Object.fromEntries(headers);
+}

package/dist/common/extendedTest.js

@@ -0,0 +1,148 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RunType = exports.RunEnvironment = void 0;
+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 _runtime = require("@intuned/runtime");
+var _extractionHelpers = require("./extractionHelpers");
+var _fsExtra = require("fs-extra");
+var _nanoid = require("nanoid");
+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();
+let RunEnvironment = exports.RunEnvironment = function (RunEnvironment) {
+  RunEnvironment["IDE"] = "IDE";
+  RunEnvironment["DEPLOYED"] = "DEPLOYED";
+  return RunEnvironment;
+}({});
+let RunType = exports.RunType = function (RunType) {
+  RunType["SYNC"] = "SYNC";
+  RunType["ASYNC"] = "ASYNC";
+  RunType["JOB"] = "JOB";
+  RunType["QUEUE"] = "QUEUE";
+  return RunType;
+}({});
+const withPlaywright = (name, testFn, {
+  headless,
+  trace,
+  runId,
+  jobId,
+  jobRunId,
+  queueId
+}) => {
+  return async () => {
+    return (0, _runtime.runWithContext)({
+      runId: runId ?? (0, _nanoid.nanoid)(),
+      extendedPayloads: [],
+      runEnvironment: RunEnvironment.IDE,
+      jobId,
+      jobRunId,
+      queueId
+    }, async () => {
+      const downloadsPath = (0, _runtime.getDownloadDirectoryPath)();
+      const {
+        page,
+        context
+      } = await (0, _runtime.getProductionPlaywrightConstructs)({
+        headless: headless ?? true,
+        downloadsPath
+      });
+      context.setDefaultTimeout(10000);
+      try {
+        if (trace) {
+          await context.tracing.start({
+            screenshots: true
+          });
+        }
+        await testFn({
+          context,
+          page
+        });
+        if (trace) {
+          await context.tracing.stop({
+            path: `./reports/traces/${name}.zip`
+          });
+        }
+      } finally {
+        await page.close();
+        await context.close();
+        await (0, _fsExtra.remove)(downloadsPath);
+      }
+    });
+  };
+};
+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());
+  });
+});