pxd 0.0.64 → 0.1.2

package/dist/utils/date.js

@@ -1,12 +1,12 @@
 import dayjs from "dayjs/esm/index.js";
 import dayjsDurationPlugin from "dayjs/esm/plugin/duration/index.js";
-import dayjsMillisecondTokenPlugin from "../plugins/dayjs-millisecond-token.js";
+import { dayjsMillisecondTokenPlugin } from "../plugins/dayjs-millisecond-token.js";
 export { dayjs, dayjsDurationPlugin, dayjsMillisecondTokenPlugin };
 export function getAllDatesBetween(startDate, endDate, format = "string") {
   const start = dayjs(startDate);
   const end = dayjs(endDate);
   if (!start.isValid() || !end.isValid()) {
-    throw new TypeError("\u65E0\u6548\u7684\u65E5\u671F\u8F93\u5165");
+    throw new TypeError("Invalid date input");
   }
   const startDateNormalized = start.isAfter(end) ? end : start;
   const endDateNormalized = start.isAfter(end) ? start : end;
@@ -34,12 +34,3 @@ export function getAllDatesBetween(startDate, endDate, format = "string") {
     dates: formattedDates
   };
 }
-export function getMonthDays(year, month) {
-  const firstDay = dayjs().year(year).month(month - 1).date(1);
-  const lastDay = firstDay.endOf("month");
-  return {
-    days: lastDay.date(),
-    firstDay: firstDay.day(),
-    lastDay: lastDay.day()
-  };
-}

package/dist/utils/dom.d.ts

@@ -1,16 +1,14 @@
-export declare function getElementRectFromContainer(elementOrRect: Element | DOMRect, viewportOrRect: Element | DOMRect): {
+import type { ComponentPublicInstance, MaybeRefOrGetter } from 'vue';
+type ElementType = null | string | object | SVGElement | HTMLElement | ComponentPublicInstance;
+export declare function getStyle(el: HTMLElement): CSSStyleDeclaration;
+export declare function getElement(el?: MaybeRefOrGetter<ElementType>, from?: MaybeRefOrGetter<HTMLElement>): HTMLElement | null;
+/** Whether the element scrolls with the viewport instead of scrolling on its own. */
+export declare function isViewportScroll(el: HTMLElement): boolean;
+/** Viewport-relative top offset for scrollspy */
+export declare function getElementOffsetFromScrollContainer(element: Element, scrollContainer: HTMLElement): {
     top: number;
-    bottom: number;
     left: number;
-    right: number;
-    width: number;
-    height: number;
-    scrollTop: number;
-    scrollBottom: number;
-    scrollLeft: number;
-    scrollRight: number;
 };
-export declare function getStyle(el: HTMLElement): CSSStyleDeclaration;
 export declare function isScrollable(el: HTMLElement): {
     x: boolean;
     y: boolean;
@@ -19,24 +17,24 @@ export declare function hasScrollbar(el: HTMLElement): {
     x: boolean;
     y: boolean;
 };
-export declare function getScrollContainer(el: HTMLElement, isHorizontal?: boolean): Window | HTMLElement;
-export declare function getScrollPositions(el: HTMLElement | Window | Document): {
+export declare function getScrollTarget(el: HTMLElement, isHorizontal?: boolean): Window | HTMLElement;
+export declare function getScrollElement(target?: Window | Document | HTMLElement | null): HTMLElement;
+/** Event target for scroll listeners. Document scrolling fires on `window`, not `documentElement`. */
+export declare function getScrollListener(target?: Window | Document | HTMLElement | null): HTMLElement | (Window & typeof globalThis);
+export declare function getScrollPosition(el: HTMLElement | Window | Document): {
     scrollTop: number;
     scrollLeft: number;
     scrollWidth: number;
     scrollHeight: number;
+    clientWidth: number;
+    clientHeight: number;
 };
-export declare function getScrollElByContainer(target: any): HTMLElement;
-export interface ScrollbarSize {
+export declare function getScrollbarSize(element?: HTMLElement): {
     width: number;
     height: number;
-}
-/**
- * 获取滚动条尺寸（宽度和高度）
- * @param element - 要测量的元素，默认为document.body
- * @returns 包含滚动条宽度和高度的对象
- */
-export declare function getScrollbarSize(element?: HTMLElement): ScrollbarSize;
+};
 export declare function getViewportRect(): DOMRect;
 export declare function isOverflowScrollable(ele: Element): boolean;
 export declare function awaitAnimationEnd(element?: Element): Promise<void>;
+export declare function resolveScrollBehavior(behavior: ScrollBehavior, prefersMotionReduce?: MaybeRefOrGetter<boolean>): ScrollBehavior;
+export {};

package/dist/utils/dom.js

@@ -1,29 +1,44 @@
+import { toValue } from "./helper.js";
 import { isServer } from "./is.js";
 function getWindowTop() {
   return [window, document, document.documentElement];
 }
-export function getElementRectFromContainer(elementOrRect, viewportOrRect) {
-  const selfRect = elementOrRect instanceof Element ? elementOrRect.getBoundingClientRect() : elementOrRect;
-  const wrapRect = viewportOrRect instanceof Element ? viewportOrRect.getBoundingClientRect() : viewportOrRect;
-  return {
-    top: selfRect.top,
-    bottom: selfRect.bottom,
-    left: selfRect.left,
-    right: selfRect.right,
-    width: selfRect.width,
-    height: selfRect.height,
-    scrollTop: selfRect.top - wrapRect.top,
-    scrollBottom: selfRect.bottom - wrapRect.top,
-    scrollLeft: selfRect.left - wrapRect.left,
-    scrollRight: selfRect.right - wrapRect.left
-  };
-}
 export function getStyle(el) {
   if (isServer() || !el) {
     return {};
   }
   return document.defaultView?.getComputedStyle(el, null) || el.style;
 }
+export function getElement(el, from) {
+  el = toValue(el);
+  if (!el || isServer()) {
+    return null;
+  }
+  if (typeof el === "string") {
+    return (toValue(from) || document).querySelector(el);
+  }
+  if (el instanceof Element) {
+    return el;
+  }
+  return el?.$el ?? el;
+}
+export function isViewportScroll(el) {
+  return getWindowTop().includes(el) || el === document.body;
+}
+export function getElementOffsetFromScrollContainer(element, scrollContainer) {
+  const elementRect = element.getBoundingClientRect();
+  if (isViewportScroll(scrollContainer)) {
+    return {
+      top: elementRect.top,
+      left: elementRect.left
+    };
+  }
+  const containerRect = scrollContainer.getBoundingClientRect();
+  return {
+    top: elementRect.top - containerRect.top,
+    left: elementRect.left - containerRect.left
+  };
+}
 export function isScrollable(el) {
   const { overflowX, overflowY } = getStyle(el);
   const allowValues = ["scroll", "auto", "overlay"];
@@ -42,7 +57,7 @@ export function hasScrollbar(el) {
     y: scrollHeight > clientHeight
   };
 }
-export function getScrollContainer(el, isHorizontal) {
+export function getScrollTarget(el, isHorizontal) {
   const windowTop = getWindowTop();
   let parent = el;
   const direction = isHorizontal ? "x" : "y";
@@ -50,28 +65,36 @@ export function getScrollContainer(el, isHorizontal) {
     if (windowTop.includes(parent)) {
       return window;
     }
-    if (isScrollable(parent)[direction] && hasScrollbar(parent)[direction]) {
+    if (isScrollable(parent)[direction]) {
       return parent;
     }
     parent = parent.parentNode;
   }
   return parent;
 }
-export function getScrollPositions(el) {
-  const targetEl = el instanceof HTMLElement ? el : document.documentElement;
-  return {
-    scrollTop: targetEl.scrollTop,
-    scrollLeft: targetEl.scrollLeft,
-    scrollWidth: targetEl.scrollWidth,
-    scrollHeight: targetEl.scrollHeight
-  };
-}
-export function getScrollElByContainer(target) {
+export function getScrollElement(target) {
   if (!target || getWindowTop().includes(target)) {
     return document.documentElement;
   }
   return target;
 }
+export function getScrollListener(target) {
+  if (!target || getWindowTop().includes(target)) {
+    return window;
+  }
+  return target;
+}
+export function getScrollPosition(el) {
+  const target = el instanceof HTMLElement ? el : document.documentElement;
+  return {
+    scrollTop: target.scrollTop,
+    scrollLeft: target.scrollLeft,
+    scrollWidth: target.scrollWidth,
+    scrollHeight: target.scrollHeight,
+    clientWidth: target.clientWidth,
+    clientHeight: target.clientHeight
+  };
+}
 export function getScrollbarSize(element) {
   if (!element) {
     const div = document.createElement("div");
@@ -117,3 +140,9 @@ export async function awaitAnimationEnd(element) {
   const animations = element?.getAnimations?.() ?? [];
   await Promise.allSettled(animations.map((a) => a.finished));
 }
+export function resolveScrollBehavior(behavior, prefersMotionReduce) {
+  if (behavior === "auto") {
+    return toValue(prefersMotionReduce) ? "instant" : "smooth";
+  }
+  return behavior;
+}

package/dist/utils/event.d.ts

@@ -1,4 +1,4 @@
-import type { Nullable } from '../types/shared';
+import type { Callback, Nullable } from '../types/shared';
 export declare function NOOP(): void;
 type EventHandler<E extends Event = Event> = (event: E) => void;
 export declare function on<E extends Event = Event>(el: Nullable<EventTarget>, event: string, handler: EventHandler<E>, options?: AddEventListenerOptions): () => void;
@@ -6,9 +6,21 @@ export declare function off<E extends Event = Event>(el: Nullable<EventTarget>,
 export declare function once<E extends Event = Event>(el: Nullable<EventTarget>, event: string, handler: EventHandler<E>, options?: AddEventListenerOptions): void;
 export declare function cachedOn<E extends Event = Event>(el: Nullable<EventTarget>, event: string, handler: EventHandler<E>, options?: AddEventListenerOptions): () => void;
 export declare function cachedOff<E extends Event = Event>(el: Nullable<EventTarget>, event: string, handler: EventHandler<E>, options?: AddEventListenerOptions): void;
-export declare function sleep(ms: number): Promise<unknown>;
 export declare function preventDefaultScroll(ev: Event): boolean;
 export declare function raf(fn: FrameRequestCallback): number;
 export declare function caf(id: number): void;
 export declare function doubleRaf(fn: FrameRequestCallback): number;
+interface ThrottleByRafReturnType<T extends Callback> {
+    (...args: Parameters<T>): void;
+    cancel: () => void;
+}
+interface ScheduleByRafOptions {
+    defer?: boolean;
+}
+interface ScheduleByRafReturnType {
+    (): void;
+    cancel: () => void;
+}
+export declare function scheduleByRaf(callback: Callback, options?: ScheduleByRafOptions): ScheduleByRafReturnType;
+export declare function throttleByRaf<T extends Callback>(callback: T): ThrottleByRafReturnType<T>;
 export {};

package/dist/utils/event.js

@@ -1,8 +1,12 @@
+import { nextTick } from "vue";
 import { isOverflowScrollable } from "./dom.js";
 import { isServer } from "./is.js";
 export function NOOP() {
 }
 const eventCache = /* @__PURE__ */ new WeakMap();
+function getCacheKey(event, options) {
+  return `${event}__${options?.capture ? "capture" : "bubble"}`;
+}
 export function on(el, event, handler, options) {
   if (!el) {
     return () => {
@@ -33,25 +37,23 @@ export function cachedOn(el, event, handler, options) {
     return () => {
     };
   }
-  const cacheKey = `__cached_${event}`;
+  const cacheKey = getCacheKey(event, options);
   let elementCache = eventCache.get(el);
   if (!elementCache) {
-    elementCache = {};
+    elementCache = /* @__PURE__ */ new Map();
     eventCache.set(el, elementCache);
   }
-  const cachedEventHandlers = elementCache[cacheKey];
-  if (cachedEventHandlers) {
-    if (!cachedEventHandlers.includes(handler)) {
-      cachedEventHandlers.push(handler);
-    }
+  let entry = elementCache.get(cacheKey);
+  if (entry) {
+    entry.handlers.add(handler);
     return () => cachedOff(el, event, handler, options);
   }
+  const handlers = /* @__PURE__ */ new Set([handler]);
   const scheduler = (ev) => {
-    const list = elementCache?.[cacheKey];
-    list?.slice(1).forEach((h) => h(ev));
+    handlers.forEach((h) => h(ev));
   };
-  const handlers = [scheduler, handler];
-  elementCache[cacheKey] = handlers;
+  entry = { scheduler, handlers };
+  elementCache.set(cacheKey, entry);
   el.addEventListener(event, scheduler, options);
   return () => cachedOff(el, event, handler, options);
 }
@@ -59,34 +61,26 @@ export function cachedOff(el, event, handler, options) {
   if (!el) {
     return;
   }
-  const cacheKey = `__cached_${event}`;
   const elementCache = eventCache.get(el);
   if (!elementCache) {
     return;
   }
-  const cachedEventHandlers = elementCache[cacheKey];
-  if (!cachedEventHandlers) {
+  const cacheKey = getCacheKey(event, options);
+  const entry = elementCache.get(cacheKey);
+  if (!entry) {
     return;
   }
-  const index = cachedEventHandlers.indexOf(handler);
-  if (index === -1) {
+  if (!entry.handlers.delete(handler)) {
     return;
   }
-  cachedEventHandlers.splice(index, 1);
-  if (cachedEventHandlers.length <= 1) {
-    const scheduler = cachedEventHandlers[0];
-    if (scheduler) {
-      el.removeEventListener(event, scheduler, options);
-    }
-    delete elementCache[cacheKey];
-    if (Object.keys(elementCache).length === 0) {
+  if (entry.handlers.size === 0) {
+    el.removeEventListener(event, entry.scheduler, options);
+    elementCache.delete(cacheKey);
+    if (elementCache.size === 0) {
       eventCache.delete(el);
     }
   }
 }
-export function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
 export function preventDefaultScroll(ev) {
   const _target = ev.target;
   if (_target instanceof Element && isOverflowScrollable(_target)) {
@@ -112,3 +106,47 @@ export function caf(id) {
 export function doubleRaf(fn) {
   return raf(() => raf(fn));
 }
+export function scheduleByRaf(callback, options = {}) {
+  let animationFrameId = 0;
+  const schedule = () => {
+    if (isServer() || animationFrameId) {
+      return;
+    }
+    animationFrameId = raf(() => {
+      animationFrameId = 0;
+      if (options.defer) {
+        void nextTick(callback);
+        return;
+      }
+      callback();
+    });
+  };
+  schedule.cancel = () => {
+    if (!animationFrameId) {
+      return;
+    }
+    caf(animationFrameId);
+    animationFrameId = 0;
+  };
+  return schedule;
+}
+export function throttleByRaf(callback) {
+  let animationFrameId = 0;
+  const throttle = (...args) => {
+    if (animationFrameId) {
+      return;
+    }
+    animationFrameId = raf(() => {
+      animationFrameId = 0;
+      callback(...args);
+    });
+  };
+  throttle.cancel = () => {
+    if (!animationFrameId) {
+      return;
+    }
+    caf(animationFrameId);
+    animationFrameId = 0;
+  };
+  return throttle;
+}

package/dist/utils/format.d.ts

@@ -1,10 +1,6 @@
 import type { Nullable } from '../types/shared/utils';
 /** string -> String */
 export declare function capitalize(text: string): string;
-/** kabab-case -> kababCase */
-export declare function camelize(str: string): string;
-/** kabab-case -> KababCase */
-export declare function pascalize(text: string): string;
 /** KababCase -> kabab-case */
 export declare function uncapitalize(text: string): string;
 /** 'kabab-case' -> 'Kabab Case' */
@@ -13,7 +9,12 @@ export declare function isTruthyProp(value: unknown): boolean;
 export declare function clampValue(n: number, min: number, max: number): number;
 export declare function isExternalLink(href: string): boolean;
 export declare function toArray(value: unknown): any[];
+export declare function toNumber(value: unknown): number;
 export declare function getCssUnitValue(value: Nullable<string | number>, fallbackValue?: string): string;
+export declare function parseUnitValue(target: string | number): {
+    number: number;
+    unit: string;
+};
 /**
  * Increase string a value with unit
  *

package/dist/utils/format.js

@@ -1,15 +1,9 @@
+import { isNil } from "../utils/is.js";
 const INTEGER_REGEX = /^-?\d+$/;
 const FLOATING_REGEX = /^-?\d+\.?\d*/;
 export function capitalize(text) {
   return text.charAt(0).toUpperCase() + text.slice(1).toLowerCase();
 }
-const camelizeRE = /-(\w)/g;
-export function camelize(str) {
-  return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
-}
-export function pascalize(text) {
-  return text.charAt(0).toUpperCase() + text.slice(1).replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
-}
 export function uncapitalize(text) {
   return text.charAt(0).toLowerCase() + text.slice(1).replace(/([A-Z])/g, "-$1").toLowerCase();
 }
@@ -20,9 +14,12 @@ export function isTruthyProp(value) {
   return Boolean(value) || value === "";
 }
 export function clampValue(n, min, max) {
-  return min != null && max != null ? Math.min(Math.max(n, min), max) : n;
+  return Math.min(Math.max(n, min), max);
 }
 export function isExternalLink(href) {
+  if (href.startsWith("//")) {
+    return true;
+  }
   const firstChar = href.slice(0, 1);
   if (["#", "/"].includes(firstChar)) {
     return false;
@@ -30,7 +27,7 @@ export function isExternalLink(href) {
   return true;
 }
 export function toArray(value) {
-  if (value === null || value === void 0) {
+  if (isNil(value)) {
     return [];
   }
   if (Array.isArray(value)) {
@@ -44,8 +41,17 @@ export function toArray(value) {
   }
   return [value];
 }
+export function toNumber(value) {
+  if (isNil(value)) {
+    return 0;
+  }
+  if (typeof value === "number") {
+    return value;
+  }
+  return Number(value);
+}
 export function getCssUnitValue(value, fallbackValue) {
-  if (value == null || value === "") {
+  if (isNil(value) || value === "") {
     return fallbackValue;
   }
   if (typeof value === "number" || INTEGER_REGEX.test(String(value))) {
@@ -53,13 +59,27 @@ export function getCssUnitValue(value, fallbackValue) {
   }
   return String(value);
 }
+export function parseUnitValue(target) {
+  if (typeof target === "string") {
+    const string = String(target);
+    const value = string.match(FLOATING_REGEX)?.[0] || "";
+    const unit = string.slice(value.length);
+    return {
+      number: Number.parseFloat(value),
+      unit
+    };
+  }
+  return {
+    number: target,
+    unit: ""
+  };
+}
 export function increaseWithUnit(target, delta) {
   if (typeof target === "number") {
     return target + delta;
   }
-  const value = String(target).match(FLOATING_REGEX)?.[0] || "";
-  const unit = String(target).slice(value.length);
-  const result = Number.parseFloat(value) + delta;
+  const { number, unit } = parseUnitValue(target);
+  const result = number + delta;
   if (Number.isNaN(result)) {
     return target;
   }

package/dist/utils/fuzzy-match.d.ts

@@ -0,0 +1,2 @@
+export declare function isFuzzyMatch(text: string, search: string, keywords?: string[]): boolean;
+export declare function getFuzzyMatchScore(text: string, search: string, keywords?: string[]): number;

package/dist/utils/fuzzy-match.js

@@ -0,0 +1,182 @@
+const whitespacePattern = /\s/;
+const whitespaceReplacePattern = /\s+/g;
+let cachedSearch = null;
+let cachedPreparedSearch = null;
+const HAYSTACK_CACHE_MAX = 4096;
+const HAYSTACK_CACHE_MAX_LENGTH = 128;
+const haystackCache = /* @__PURE__ */ new Map();
+function getPreparedHaystack(text) {
+  const cached = haystackCache.get(text);
+  if (cached) {
+    return cached;
+  }
+  const lower = text.toLowerCase();
+  const prepared = {
+    lower,
+    compact: whitespacePattern.test(lower) ? lower.replace(whitespaceReplacePattern, "") : lower
+  };
+  if (text.length <= HAYSTACK_CACHE_MAX_LENGTH) {
+    if (haystackCache.size >= HAYSTACK_CACHE_MAX) {
+      haystackCache.clear();
+    }
+    haystackCache.set(text, prepared);
+  }
+  return prepared;
+}
+export function isFuzzyMatch(text, search, keywords) {
+  if (!search) {
+    return true;
+  }
+  const { needle, compactNeedle } = prepareSearch(search);
+  if (!needle) {
+    return true;
+  }
+  if (text && matchesOne(getPreparedHaystack(text), needle, compactNeedle)) {
+    return true;
+  }
+  if (keywords && keywords.length > 0) {
+    for (const kw of keywords) {
+      if (kw && matchesOne(getPreparedHaystack(kw), needle, compactNeedle)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+export function getFuzzyMatchScore(text, search, keywords) {
+  if (!search) {
+    return 0;
+  }
+  const { needle, compactNeedle } = prepareSearch(search);
+  if (!needle) {
+    return 0;
+  }
+  let score = getMatchScore(getPreparedHaystack(text), needle, compactNeedle);
+  if (score === 1e3) {
+    return score;
+  }
+  if (keywords && keywords.length > 0) {
+    for (const keyword of keywords) {
+      score = Math.max(score, getMatchScore(getPreparedHaystack(keyword), needle, compactNeedle));
+      if (score === 1e3) {
+        return score;
+      }
+    }
+  }
+  return score;
+}
+function scoreBase(haystack, needle) {
+  if (!haystack) {
+    return 0;
+  }
+  if (haystack === needle) {
+    return 1e3;
+  }
+  const contiguousIndex = haystack.indexOf(needle);
+  if (contiguousIndex !== -1) {
+    return getContiguousMatchScore(haystack, needle, contiguousIndex);
+  }
+  const subsequence = getSubsequenceMatch(haystack, needle);
+  if (subsequence) {
+    return getSubsequenceMatchScore(haystack, needle, subsequence);
+  }
+  return 0;
+}
+function getMatchScore(prepared, needle, compactNeedle) {
+  const score = scoreBase(prepared.lower, needle);
+  if (score > 0 || prepared.compact === prepared.lower && compactNeedle === needle) {
+    return score;
+  }
+  return scoreBase(prepared.compact, compactNeedle);
+}
+function matchesBase(haystack, needle) {
+  if (!haystack) {
+    return false;
+  }
+  if (haystack === needle) {
+    return true;
+  }
+  if (haystack.startsWith(needle)) {
+    return true;
+  }
+  if (haystack.includes(needle)) {
+    return true;
+  }
+  return hasFuzzySubsequenceMatch(haystack, needle);
+}
+function matchesOne(prepared, needle, compactNeedle) {
+  if (matchesBase(prepared.lower, needle)) {
+    return true;
+  }
+  if (prepared.compact !== prepared.lower || compactNeedle !== needle) {
+    return matchesBase(prepared.compact, compactNeedle);
+  }
+  return false;
+}
+function prepareSearch(search) {
+  if (search === cachedSearch && cachedPreparedSearch) {
+    return cachedPreparedSearch;
+  }
+  const needle = search.toLowerCase().trim();
+  const preparedSearch = {
+    needle,
+    compactNeedle: whitespacePattern.test(needle) ? needle.replace(whitespaceReplacePattern, "") : needle
+  };
+  cachedSearch = search;
+  cachedPreparedSearch = preparedSearch;
+  return preparedSearch;
+}
+function getContiguousMatchScore(haystack, needle, index) {
+  const boundaryBonus = index === 0 || /\W/.test(haystack[index - 1]) ? 30 : 0;
+  const positionBonus = (haystack.length - index) / haystack.length * 20;
+  return 700 + boundaryBonus + getLengthScore(haystack, needle) + positionBonus;
+}
+function getLengthScore(haystack, needle) {
+  return needle.length / haystack.length * 100;
+}
+function hasFuzzySubsequenceMatch(haystack, needle) {
+  let ni = 0;
+  if (needle.length > haystack.length) {
+    return false;
+  }
+  for (let hi = 0; hi < haystack.length && ni < needle.length; hi++) {
+    if (haystack[hi] === needle[ni]) {
+      ni++;
+    }
+  }
+  return ni >= needle.length;
+}
+function getSubsequenceMatchScore(haystack, needle, match) {
+  const span = match.lastIndex - match.firstIndex + 1;
+  const gapPenalty = span - needle.length;
+  const positionBonus = (haystack.length - match.firstIndex) / haystack.length * 20;
+  const continuityBonus = match.longestRun / needle.length * 100;
+  return 200 + continuityBonus + getLengthScore(haystack, needle) + positionBonus - gapPenalty * 5;
+}
+function getSubsequenceMatch(haystack, needle) {
+  if (needle.length > haystack.length) {
+    return null;
+  }
+  let needleIndex = 0;
+  let firstIndex = -1;
+  let lastIndex = -1;
+  let currentRun = 0;
+  let longestRun = 0;
+  for (let haystackIndex = 0; haystackIndex < haystack.length; haystackIndex++) {
+    if (haystack[haystackIndex] !== needle[needleIndex]) {
+      currentRun = 0;
+      continue;
+    }
+    if (firstIndex === -1) {
+      firstIndex = haystackIndex;
+    }
+    lastIndex = haystackIndex;
+    needleIndex++;
+    currentRun++;
+    longestRun = Math.max(longestRun, currentRun);
+    if (needleIndex === needle.length) {
+      return { firstIndex, lastIndex, longestRun };
+    }
+  }
+  return null;
+}