feat: init

node_modules/fzf/README.md

@@ -0,0 +1,51 @@
+# FZF for JavaScript
+
+[![Tests](https://github.com/ajitid/fzf-for-js/actions/workflows/main.yml/badge.svg?branch=dev)](https://github.com/ajitid/fzf-for-js/actions/workflows/main.yml)
+[![Docs deployment status](https://img.shields.io/netlify/e4324b0d-d5b2-4139-a688-e58f32a5af6b?label=Docs&logo=netlify)](https://app.netlify.com/sites/fzf/deploys)
+
+[//]: # "Image, text and counter/assist image needs to follow this order to be correctly aligned"
+
+<img src="assets/landing.gif" align="right" />
+
+[Docs](https://fzf.netlify.app) · [Demo](https://fzf.netlify.app/docs/latest/basic) · [GitHub](https://github.com/ajitid/fzf-for-js) · [NPM](https://www.npmjs.com/package/fzf)
+
+Originally available as [a fuzzy finder for CLIs](https://github.com/junegunn/fzf), FZF for JavaScript is a port of FZF's main algorithm so it can be used in browser context.
+
+<img src="assets/landing-assist.png" width="100%" height="0.001px" />
+
+## Quick look
+
+Install FZF for JavaScript using:
+
+```sh
+npm i fzf
+```
+
+Then you can use it like:
+
+<!-- prettier-ignore -->
+```js
+import { Fzf } from 'fzf'
+
+const list = ['go', 'javascript', 'python', 'rust', 
+              'swift', 'kotlin', 'elixir', 'java', 
+              'lisp', 'v', 'zig', 'nim', 'rescript', 
+              'd', 'haskell']
+
+const fzf = new Fzf(list)
+const entries = fzf.find('li')
+console.log('ranking is:')
+entries.forEach(entry => console.log(entry.item)) // lisp kotlin elixir
+```
+
+For more ways to use this library, [visit documentation](https://fzf.netlify.app/).
+
+## Motivation
+
+Command palette is becoming ubiquitous – you can find it in code editors ([Sublime Text](https://www.sublimetext.com/blog/articles/sublime-text-2-beta), VS Code), design tools ([Figma](https://forum.figma.com/t/new-quick-actions-menu/1788)), project management apps ([Height](https://twitter.com/michaelvillar/status/1347276324772192256), [Linear](https://linear.app/)), source control tools ([Fork](https://fork.dev/blog/posts/quick-launch/), Sublime Merge). Web apps are becoming more prevalent as well. FZF has a great fuzzy finding mechanism which could be used outside of CLI and into these palettes.
+
+There is [a very good read](https://capiche.com/e/consumer-dev-tools-command-palette) about command palettes if you want to learn more.
+
+## Thanks
+
+- Junegunn Choi (author of FZF, [website](https://junegunn.kr/)) – for making his work available and accessible to us. You can [sponsor his project](https://github.com/junegunn/fzf).

node_modules/fzf/dist/types/algo.d.ts

@@ -0,0 +1,15 @@
+import { Slab } from "./slab";
+import { Rune } from "./runes";
+export interface Result {
+    start: number;
+    end: number;
+    score: number;
+}
+export declare const SCORE_MATCH = 16, SCORE_GAP_START = -3, SCORE_GAP_EXTENTION = -1, BONUS_BOUNDARY: number, BONUS_NON_WORD: number, BONUS_CAMEL_123: number, BONUS_CONSECUTIVE: number, BONUS_FIRST_CHAR_MULTIPLIER = 2;
+export type AlgoFn = (caseSensitive: boolean, normalize: boolean, forward: boolean, input: Rune[], pattern: Rune[], withPos: boolean, slab: Slab | null) => [Result, Set<number> | null];
+export declare const fuzzyMatchV2: AlgoFn;
+export declare const fuzzyMatchV1: AlgoFn;
+export declare const exactMatchNaive: AlgoFn;
+export declare const prefixMatch: AlgoFn;
+export declare const suffixMatch: AlgoFn;
+export declare const equalMatch: AlgoFn;

node_modules/fzf/dist/types/char.d.ts

@@ -0,0 +1,4 @@
+import { Rune } from "./runes";
+export declare const isWhitespace: (rune: Rune) => boolean;
+export declare const whitespacesAtStart: (runes: Rune[]) => number;
+export declare const whitespacesAtEnd: (runes: Rune[]) => number;

node_modules/fzf/dist/types/extended.d.ts

@@ -0,0 +1,10 @@
+import { AlgoFn } from "./algo";
+import { buildPatternForExtendedMatch } from "./pattern";
+import { Rune } from "./runes";
+type Offset = [number, number];
+export declare function computeExtendedMatch(text: Rune[], pattern: ReturnType<typeof buildPatternForExtendedMatch>, fuzzyAlgo: AlgoFn, forward: boolean): {
+    offsets: Offset[];
+    totalScore: number;
+    allPos: Set<number>;
+};
+export {};

node_modules/fzf/dist/types/finders.d.ts

@@ -0,0 +1,41 @@
+import { AlgoFn } from "./algo";
+import { Rune } from "./runes";
+import { FzfResultItem, BaseOptions, SyncOptions, AsyncOptions, Tiebreaker, Token, Selector } from "./types";
+export type ArrayElement<ArrayType extends readonly unknown[]> = ArrayType extends readonly (infer ElementType)[] ? ElementType : never;
+type SortAttrs<U> = {
+    sort?: true;
+    tiebreakers?: Tiebreaker<U>[];
+} | {
+    sort: false;
+};
+type BaseOptsToUse<U> = Omit<Partial<BaseOptions<U>>, "sort" | "tiebreakers"> & SortAttrs<U>;
+type BaseOptionsTuple<U> = U extends string ? [options?: BaseOptsToUse<U>] : [options: BaseOptsToUse<U> & {
+    selector: Selector<U>;
+}];
+export declare abstract class BaseFinder<L extends ReadonlyArray<any>> {
+    runesList: Rune[][];
+    items: L;
+    readonly opts: BaseOptions<ArrayElement<L>>;
+    algoFn: AlgoFn;
+    constructor(list: L, ...optionsTuple: BaseOptionsTuple<ArrayElement<L>>);
+}
+export type SyncOptsToUse<U> = BaseOptsToUse<U> & Partial<Pick<SyncOptions<U>, "match">>;
+export type SyncOptionsTuple<U> = U extends string ? [options?: SyncOptsToUse<U>] : [options: SyncOptsToUse<U> & {
+    selector: Selector<U>;
+}];
+export declare class SyncFinder<L extends ReadonlyArray<any>> extends BaseFinder<L> {
+    readonly opts: SyncOptions<ArrayElement<L>>;
+    constructor(list: L, ...optionsTuple: SyncOptionsTuple<ArrayElement<L>>);
+    find(query: string): FzfResultItem<ArrayElement<L>>[];
+}
+export type AsyncOptsToUse<U> = BaseOptsToUse<U> & Partial<Pick<AsyncOptions<U>, "match">>;
+export type AsyncOptionsTuple<U> = U extends string ? [options?: AsyncOptsToUse<U>] : [options: AsyncOptsToUse<U> & {
+    selector: Selector<U>;
+}];
+export declare class AsyncFinder<L extends ReadonlyArray<any>> extends BaseFinder<L> {
+    readonly opts: AsyncOptions<ArrayElement<L>>;
+    token: Token;
+    constructor(list: L, ...optionsTuple: AsyncOptionsTuple<ArrayElement<L>>);
+    find(query: string): Promise<FzfResultItem<ArrayElement<L>>[]>;
+}
+export {};

node_modules/fzf/dist/types/main.d.ts

@@ -0,0 +1,22 @@
+import { SyncFinder, AsyncFinder } from "./finders";
+import type { ArrayElement, SyncOptionsTuple, SyncOptsToUse, AsyncOptionsTuple, AsyncOptsToUse } from "./finders";
+import type { SyncOptions, AsyncOptions } from "./types";
+export type { FzfResultItem, Selector, Tiebreaker } from "./types";
+export * from "./matchers";
+export * from "./tiebreakers";
+export type FzfOptions<U = string> = U extends string ? SyncOptsToUse<U> : SyncOptsToUse<U> & {
+    selector: SyncOptions<U>["selector"];
+};
+export declare class Fzf<L extends ReadonlyArray<any>> {
+    private finder;
+    find: SyncFinder<L>["find"];
+    constructor(list: L, ...optionsTuple: SyncOptionsTuple<ArrayElement<L>>);
+}
+export type AsyncFzfOptions<U = string> = U extends string ? AsyncOptsToUse<U> : AsyncOptsToUse<U> & {
+    selector: AsyncOptions<U>["selector"];
+};
+export declare class AsyncFzf<L extends ReadonlyArray<any>> {
+    private finder;
+    find: AsyncFinder<L>["find"];
+    constructor(list: L, ...optionsTuple: AsyncOptionsTuple<ArrayElement<L>>);
+}

node_modules/fzf/dist/types/matchers.d.ts

@@ -0,0 +1,6 @@
+import type { SyncFinder, AsyncFinder } from "./finders";
+import { FzfResultItem, Token } from "./types";
+export declare function basicMatch<U>(this: SyncFinder<ReadonlyArray<U>>, query: string): FzfResultItem<U>[];
+export declare function extendedMatch<U>(this: SyncFinder<ReadonlyArray<U>>, query: string): FzfResultItem<U>[];
+export declare function asyncBasicMatch<U>(this: AsyncFinder<ReadonlyArray<U>>, query: string, token: Token): Promise<FzfResultItem<U>[]>;
+export declare function asyncExtendedMatch<U>(this: AsyncFinder<ReadonlyArray<U>>, query: string, token: Token): Promise<FzfResultItem<U>[]>;

node_modules/fzf/dist/types/normalize.d.ts

@@ -0,0 +1,2 @@
+import { Rune } from "./runes";
+export declare function normalizeRune(rune: Rune): Rune;

node_modules/fzf/dist/types/numerics.d.ts

@@ -0,0 +1,5 @@
+export type Int16 = Int16Array[0];
+export type Int32 = Int32Array[0];
+export declare function toShort(number: number): Int16;
+export declare function toInt(number: number): Int32;
+export declare function maxInt16(num1: number, num2: number): number;

node_modules/fzf/dist/types/pattern.d.ts

@@ -0,0 +1,36 @@
+import { Rune } from "./runes";
+import { Casing } from "./types";
+export declare enum TermType {
+    Fuzzy = 0,
+    Exact = 1,
+    Prefix = 2,
+    Suffix = 3,
+    Equal = 4
+}
+export declare const termTypeMap: {
+    0: import("./algo").AlgoFn;
+    1: import("./algo").AlgoFn;
+    2: import("./algo").AlgoFn;
+    3: import("./algo").AlgoFn;
+    4: import("./algo").AlgoFn;
+};
+interface Term {
+    typ: TermType;
+    inv: boolean;
+    text: Rune[];
+    caseSensitive: boolean;
+    normalize: boolean;
+}
+type TermSet = Term[];
+export declare function buildPatternForExtendedMatch(fuzzy: boolean, caseMode: Casing, normalize: boolean, str: string): {
+    str: string;
+    termSets: TermSet[];
+    sortable: boolean;
+    cacheable: boolean;
+    fuzzy: boolean;
+};
+export declare const buildPatternForBasicMatch: (query: string, casing: Casing, normalize: boolean) => {
+    queryRunes: number[];
+    caseSensitive: boolean;
+};
+export {};

node_modules/fzf/dist/types/runes.d.ts

@@ -0,0 +1,4 @@
+import { Int32 } from "./numerics";
+export type Rune = Int32;
+export declare const strToRunes: (str: string) => number[];
+export declare const runesToStr: (runes: Rune[]) => string;

node_modules/fzf/dist/types/slab.d.ts

@@ -0,0 +1,5 @@
+export interface Slab {
+    i16: Int16Array;
+    i32: Int32Array;
+}
+export declare const slab: Slab;

node_modules/fzf/dist/types/tiebreakers.d.ts

@@ -0,0 +1,3 @@
+import type { FzfResultItem, Selector } from "./types";
+export declare function byLengthAsc<U>(a: FzfResultItem<U>, b: FzfResultItem<U>, selector: Selector<U>): number;
+export declare function byStartAsc<U>(a: FzfResultItem<U>, b: FzfResultItem<U>): number;

node_modules/fzf/dist/types/types.d.ts

@@ -0,0 +1,138 @@
+import type { Result } from "./algo";
+import type { SyncFinder, AsyncFinder } from "./finders";
+export interface Token {
+    cancelled: boolean;
+}
+export type Casing = "smart-case" | "case-sensitive" | "case-insensitive";
+export interface FzfResultItem<U = string> extends Result {
+    item: U;
+    positions: Set<number>;
+}
+export type Selector<U> = BaseOptions<U>["selector"];
+export type Tiebreaker<U> = (a: FzfResultItem<U>, b: FzfResultItem<U>, selector: Selector<U>) => number;
+export interface BaseOptions<U> {
+    /**
+     * If `limit` is 32, top 32 items that matches your query will be returned.
+     * By default all matched items are returned.
+     *
+     * @defaultValue `Infinity`
+     */
+    limit: number;
+    /**
+     * For each item in the list, target a specific property of the item to search for.
+     */
+    selector: (v: U) => string;
+    /**
+     * Defines what type of case sensitive search you want.
+     *
+     * @defaultValue `"smart-case"`
+     */
+    casing: Casing;
+    /**
+     * If true, FZF will try to remove diacritics from list items.
+     * This is useful if the list contains items with diacritics but
+     * you want to query with plain A-Z letters.
+     *
+     * @example
+     * Zoë →  Zoe
+     * blessèd →  blessed
+     *
+     * @defaultValue `true`
+     */
+    normalize: boolean;
+    /**
+     * Fuzzy algo to choose. Each algo has their own advantages, see here:
+     * https://github.com/junegunn/fzf/blob/4c9cab3f8ae7b55f7124d7c3cf7ac6b4cc3db210/src/algo/algo.go#L5
+     * If asssigned `false`, an exact match will be made instead of a fuzzy one.
+     *
+     * @defaultValue `"v2"`
+     */
+    fuzzy: "v1" | "v2" | false;
+    /**
+     * A list of functions that act as fallback and help to
+     * sort result entries when the score between two entries is tied.
+     *
+     * Consider a tiebreaker to be a [JS array sort](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort)
+     * compare function with an added third argument which is `options.selector`.
+     *
+     * If multiple tiebreakers are given, they are evaluated left to right until
+     * one breaks the tie.
+     *
+     * Note that tiebreakers cannot be used if `sort=false`.
+     *
+     * FZF ships with these tiebreakers:
+     * - `byLengthAsc`
+     * - `byStartAsc`
+     *
+     * @defaultValue `[]`
+     *
+     * @example
+     * ```js
+     * function byLengthAsc(a, b, selector) {
+     *   return selector(a.item).length - selector(b.item).length;
+     * }
+     *
+     * const fzf = new Fzf(list, { tiebreakers: [byLengthAsc] })
+     * ```
+     * This will result in following result entries having same score sorted like this:
+     *    FROM                TO
+     * axaa                axaa
+     * bxbbbb              bxbbbb
+     * cxcccccccccc        dxddddddd
+     * dxddddddd           cxcccccccccc
+     */
+    tiebreakers: Tiebreaker<U>[];
+    /**
+     * If `true`, result items will be sorted in descending order by their score.
+     *
+     * If `false`, result items won't be sorted and tiebreakers won't affect the
+     * sort order either. In this case, the items are returned in the same order
+     * as they are in the input list.
+     *
+     * @defaultValue `true`
+     */
+    sort: boolean;
+    /**
+     * If `false`, matching will be done from backwards.
+     *
+     * @defaultValue `true`
+     *
+     * @example
+     * /breeds/pyrenees when queried with "re"
+     * with forward=true  : /b**re**eds/pyrenees
+     * with forward=false : /breeds/py**re**nees
+     *
+     * Doing forward=false is useful, for example, if one needs to match a file
+     * path and they prefer querying for the file name over directory names
+     * present in the path.
+     */
+    forward: boolean;
+}
+export type SyncOptions<U> = BaseOptions<U> & {
+    /**
+     * A function that is responsible for matching list items with the query.
+     *
+     * We ship with two match functions - `basicMatch` and `extendedMatch`.
+     *
+     * If `extendedMatch` is used, you can add special patterns to narrow down your search.
+     * To read about how they can be used, see [this section](https://github.com/junegunn/fzf/tree/7191ebb615f5d6ebbf51d598d8ec853a65e2274d#search-syntax).
+     * For a quick glance, see [this piece](https://github.com/junegunn/fzf/blob/764316a53d0eb60b315f0bbcd513de58ed57a876/src/pattern.go#L12-L19).
+     *
+     * @defaultValue `basicMatch`
+     */
+    match: (this: SyncFinder<ReadonlyArray<U>>, query: string) => FzfResultItem<U>[];
+};
+export type AsyncOptions<U> = BaseOptions<U> & {
+    /**
+     * A function that is responsible for matching list items with the query.
+     *
+     * We ship with two match functions - `asyncBasicMatch` and `asyncExtendedMatch`.
+     *
+     * If `asyncExtendedMatch` is used, you can add special patterns to narrow down your search.
+     * To read about how they can be used, see [this section](https://github.com/junegunn/fzf/tree/7191ebb615f5d6ebbf51d598d8ec853a65e2274d#search-syntax).
+     * For a quick glance, see [this piece](https://github.com/junegunn/fzf/blob/764316a53d0eb60b315f0bbcd513de58ed57a876/src/pattern.go#L12-L19).
+     *
+     * @defaultValue `asyncBasicMatch`
+     */
+    match: (this: AsyncFinder<ReadonlyArray<U>>, query: string, token: Token) => Promise<FzfResultItem<U>[]>;
+};

node_modules/fzf/license.txt

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2021, Ajit
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

node_modules/fzf/package.json

@@ -0,0 +1,89 @@
+{
+  "===== INFO =====": "",
+  "name": "fzf",
+  "version": "0.5.2",
+  "description": "Do fuzzy matching using FZF algorithm in JavaScript",
+  "license": "BSD-3-Clause",
+  "keywords": [
+    "fzf",
+    "fuzzy-search",
+    "fuzzy-match",
+    "fuzzy",
+    "search",
+    "find"
+  ],
+  "homepage": "https://fzf.netlify.app",
+  "repository": "ajitid/fzf-for-js",
+  "author": {
+    "name": "Ajit",
+    "email": "zlksnkwork+pkgnfo@gmail.com",
+    "url": "https://hemarkable.com"
+  },
+  "===== SCRIPTS =====": "",
+  "scripts": {
+    "dev": "vite -c vite-for-docs.config.ts",
+    "build": "npm run build:modules && npm run build:types",
+    "postbuild": "node scripts/postbuild.js",
+    "build:modules": "tsc && vite build && vite build -c vite-legacy.config.ts",
+    "build:types": "tsc -p tsconfig-to-build-types.json --outDir dist/types",
+    "build:only-docs": "tsc && vite build -c vite-for-docs.config.ts",
+    "build:docs": "npm run fill-with-old-docs && npm run build:only-docs",
+    "fill-with-old-docs": "node scripts/fill-with-old-docs.js",
+    "prepack": "node scripts/prepack.cjs",
+    "postpack": "node scripts/postpack.cjs",
+    "test": "jest",
+    "test:watch": "jest --watch -o",
+    "test:cov": "jest --coverage",
+    "format": "prettier --write ."
+  },
+  "===== BUILD =====": "",
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/fzf.umd.js",
+  "module": "./dist/fzf.es.js",
+  "exports": {
+    ".": {
+      "types": "./dist/types/main.d.ts",
+      "import": "./dist/fzf.es.js",
+      "require": "./dist/fzf.umd.js"
+    }
+  },
+  "types": "./dist/types/main.d.ts",
+  "===== HINTING =====": "",
+  "sideEffects": false,
+  "===== DEPS =====": "",
+  "devDependencies": {
+    "@mdx-js/mdx": "^2.1.1",
+    "@mdx-js/react": "^2.1.1",
+    "@mdx-js/rollup": "^2.1.1",
+    "@tailwindcss/typography": "^0.5.2",
+    "@types/jest": "^29.4.0",
+    "@types/mdx": "^2.0.1",
+    "@types/react": "^17.0.0",
+    "@types/react-dom": "^17.0.0",
+    "@vitejs/plugin-react-refresh": "^1.3.1",
+    "autoprefixer": "^10.2.6",
+    "glob": "^7.1.7",
+    "history": "^5.0.0",
+    "jest": "^29.4.3",
+    "jest-expect-message": "^1.1.3",
+    "postcss": "^8.3.5",
+    "prettier": "^2.6.2",
+    "preval.macro": "^5.0.0",
+    "prism-react-renderer": "^1.2.1",
+    "react": "^17.0.0",
+    "react-dom": "^17.0.0",
+    "react-git-info": "^2.0.0",
+    "react-router": "^6.8.1",
+    "react-router-dom": "^6.8.1",
+    "remark-gfm": "^3.0.1",
+    "shelljs": "^0.8.4",
+    "tailwindcss": "^3.0.24",
+    "ts-jest": "^29.0.5",
+    "typescript": "^4.9.4",
+    "vite": "^2.9.13",
+    "vite-plugin-babel-macros": "^1.0.5"
+  },
+  "type": "module"
+}