issy 0.5.2 → 0.5.3

package/dist/main.js

@@ -0,0 +1,2220 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/main.ts
+import {
+  cpSync,
+  existsSync as existsSync2,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
+import { dirname as dirname2, join as join2, resolve as resolve2 } from "node:path";
+import { fileURLToPath } from "node:url";
+// ../core/src/lib/issues.ts
+import { existsSync } from "node:fs";
+import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+
+// ../../node_modules/.bun/fractional-indexing@3.2.0/node_modules/fractional-indexing/src/index.js
+var BASE_62_DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+function midpoint(a, b, digits) {
+  const zero = digits[0];
+  if (b != null && a >= b) {
+    throw new Error(a + " >= " + b);
+  }
+  if (a.slice(-1) === zero || b && b.slice(-1) === zero) {
+    throw new Error("trailing zero");
+  }
+  if (b) {
+    let n = 0;
+    while ((a[n] || zero) === b[n]) {
+      n++;
+    }
+    if (n > 0) {
+      return b.slice(0, n) + midpoint(a.slice(n), b.slice(n), digits);
+    }
+  }
+  const digitA = a ? digits.indexOf(a[0]) : 0;
+  const digitB = b != null ? digits.indexOf(b[0]) : digits.length;
+  if (digitB - digitA > 1) {
+    const midDigit = Math.round(0.5 * (digitA + digitB));
+    return digits[midDigit];
+  } else {
+    if (b && b.length > 1) {
+      return b.slice(0, 1);
+    } else {
+      return digits[digitA] + midpoint(a.slice(1), null, digits);
+    }
+  }
+}
+function validateInteger(int) {
+  if (int.length !== getIntegerLength(int[0])) {
+    throw new Error("invalid integer part of order key: " + int);
+  }
+}
+function getIntegerLength(head) {
+  if (head >= "a" && head <= "z") {
+    return head.charCodeAt(0) - 97 + 2;
+  } else if (head >= "A" && head <= "Z") {
+    return 90 - head.charCodeAt(0) + 2;
+  } else {
+    throw new Error("invalid order key head: " + head);
+  }
+}
+function getIntegerPart(key) {
+  const integerPartLength = getIntegerLength(key[0]);
+  if (integerPartLength > key.length) {
+    throw new Error("invalid order key: " + key);
+  }
+  return key.slice(0, integerPartLength);
+}
+function validateOrderKey(key, digits) {
+  if (key === "A" + digits[0].repeat(26)) {
+    throw new Error("invalid order key: " + key);
+  }
+  const i = getIntegerPart(key);
+  const f = key.slice(i.length);
+  if (f.slice(-1) === digits[0]) {
+    throw new Error("invalid order key: " + key);
+  }
+}
+function incrementInteger(x, digits) {
+  validateInteger(x);
+  const [head, ...digs] = x.split("");
+  let carry = true;
+  for (let i = digs.length - 1;carry && i >= 0; i--) {
+    const d = digits.indexOf(digs[i]) + 1;
+    if (d === digits.length) {
+      digs[i] = digits[0];
+    } else {
+      digs[i] = digits[d];
+      carry = false;
+    }
+  }
+  if (carry) {
+    if (head === "Z") {
+      return "a" + digits[0];
+    }
+    if (head === "z") {
+      return null;
+    }
+    const h = String.fromCharCode(head.charCodeAt(0) + 1);
+    if (h > "a") {
+      digs.push(digits[0]);
+    } else {
+      digs.pop();
+    }
+    return h + digs.join("");
+  } else {
+    return head + digs.join("");
+  }
+}
+function decrementInteger(x, digits) {
+  validateInteger(x);
+  const [head, ...digs] = x.split("");
+  let borrow = true;
+  for (let i = digs.length - 1;borrow && i >= 0; i--) {
+    const d = digits.indexOf(digs[i]) - 1;
+    if (d === -1) {
+      digs[i] = digits.slice(-1);
+    } else {
+      digs[i] = digits[d];
+      borrow = false;
+    }
+  }
+  if (borrow) {
+    if (head === "a") {
+      return "Z" + digits.slice(-1);
+    }
+    if (head === "A") {
+      return null;
+    }
+    const h = String.fromCharCode(head.charCodeAt(0) - 1);
+    if (h < "Z") {
+      digs.push(digits.slice(-1));
+    } else {
+      digs.pop();
+    }
+    return h + digs.join("");
+  } else {
+    return head + digs.join("");
+  }
+}
+function generateKeyBetween(a, b, digits = BASE_62_DIGITS) {
+  if (a != null) {
+    validateOrderKey(a, digits);
+  }
+  if (b != null) {
+    validateOrderKey(b, digits);
+  }
+  if (a != null && b != null && a >= b) {
+    throw new Error(a + " >= " + b);
+  }
+  if (a == null) {
+    if (b == null) {
+      return "a" + digits[0];
+    }
+    const ib2 = getIntegerPart(b);
+    const fb2 = b.slice(ib2.length);
+    if (ib2 === "A" + digits[0].repeat(26)) {
+      return ib2 + midpoint("", fb2, digits);
+    }
+    if (ib2 < b) {
+      return ib2;
+    }
+    const res = decrementInteger(ib2, digits);
+    if (res == null) {
+      throw new Error("cannot decrement any more");
+    }
+    return res;
+  }
+  if (b == null) {
+    const ia2 = getIntegerPart(a);
+    const fa2 = a.slice(ia2.length);
+    const i2 = incrementInteger(ia2, digits);
+    return i2 == null ? ia2 + midpoint(fa2, null, digits) : i2;
+  }
+  const ia = getIntegerPart(a);
+  const fa = a.slice(ia.length);
+  const ib = getIntegerPart(b);
+  const fb = b.slice(ib.length);
+  if (ia === ib) {
+    return ia + midpoint(fa, fb, digits);
+  }
+  const i = incrementInteger(ia, digits);
+  if (i == null) {
+    throw new Error("cannot increment any more");
+  }
+  if (i < b) {
+    return i;
+  }
+  return ia + midpoint(fa, null, digits);
+}
+function generateNKeysBetween(a, b, n, digits = BASE_62_DIGITS) {
+  if (n === 0) {
+    return [];
+  }
+  if (n === 1) {
+    return [generateKeyBetween(a, b, digits)];
+  }
+  if (b == null) {
+    let c2 = generateKeyBetween(a, b, digits);
+    const result = [c2];
+    for (let i = 0;i < n - 1; i++) {
+      c2 = generateKeyBetween(c2, b, digits);
+      result.push(c2);
+    }
+    return result;
+  }
+  if (a == null) {
+    let c2 = generateKeyBetween(a, b, digits);
+    const result = [c2];
+    for (let i = 0;i < n - 1; i++) {
+      c2 = generateKeyBetween(a, c2, digits);
+      result.push(c2);
+    }
+    result.reverse();
+    return result;
+  }
+  const mid = Math.floor(n / 2);
+  const c = generateKeyBetween(a, b, digits);
+  return [
+    ...generateNKeysBetween(a, c, mid, digits),
+    c,
+    ...generateNKeysBetween(c, b, n - mid - 1, digits)
+  ];
+}
+
+// ../core/src/lib/issues.ts
+var issyDir = null;
+var issuesDir = null;
+function setIssyDir(dir) {
+  issyDir = dir;
+  issuesDir = join(dir, "issues");
+}
+function getIssyDir() {
+  if (!issyDir) {
+    throw new Error("Issy directory not initialized. Call resolveIssyDir() first.");
+  }
+  return issyDir;
+}
+function getIssuesDir() {
+  if (!issuesDir) {
+    throw new Error("Issues directory not initialized. Call resolveIssyDir() first.");
+  }
+  return issuesDir;
+}
+async function ensureIssuesDir() {
+  await mkdir(getIssuesDir(), { recursive: true });
+}
+function findIssyDirUpward(fromPath) {
+  let current = resolve(fromPath);
+  for (let i = 0;i < 20; i++) {
+    const candidate = join(current, ".issy");
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = dirname(current);
+    if (parent === current)
+      break;
+    current = parent;
+  }
+  return null;
+}
+function findLegacyIssuesDirUpward(fromPath) {
+  let current = resolve(fromPath);
+  for (let i = 0;i < 20; i++) {
+    const candidate = join(current, ".issues");
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = dirname(current);
+    if (parent === current)
+      break;
+    current = parent;
+  }
+  return null;
+}
+function findGitRoot(fromPath) {
+  let current = resolve(fromPath);
+  for (let i = 0;i < 20; i++) {
+    const gitDir = join(current, ".git");
+    if (existsSync(gitDir)) {
+      return current;
+    }
+    const parent = dirname(current);
+    if (parent === current)
+      break;
+    current = parent;
+  }
+  return null;
+}
+function resolveIssyDir() {
+  if (process.env.ISSY_DIR) {
+    const dir = resolve(process.env.ISSY_DIR);
+    setIssyDir(dir);
+    return dir;
+  }
+  const startDir = process.env.ISSY_ROOT || process.cwd();
+  const found = findIssyDirUpward(startDir);
+  if (found) {
+    setIssyDir(found);
+    return found;
+  }
+  const gitRoot = findGitRoot(startDir);
+  if (gitRoot) {
+    const gitIssyDir = join(gitRoot, ".issy");
+    setIssyDir(gitIssyDir);
+    return gitIssyDir;
+  }
+  const fallback = join(resolve(startDir), ".issy");
+  setIssyDir(fallback);
+  return fallback;
+}
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!match) {
+    return { frontmatter: {}, body: content };
+  }
+  const [, frontmatterStr, body] = match;
+  const frontmatter = {};
+  for (const line of frontmatterStr.split(`
+`)) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx > 0) {
+      const key = line.slice(0, colonIdx).trim();
+      const value = line.slice(colonIdx + 1).trim();
+      frontmatter[key] = value;
+    }
+  }
+  return { frontmatter, body };
+}
+function generateFrontmatter(data) {
+  const lines = ["---"];
+  lines.push(`title: ${data.title}`);
+  lines.push(`description: ${data.description}`);
+  lines.push(`priority: ${data.priority}`);
+  if (data.scope) {
+    lines.push(`scope: ${data.scope}`);
+  }
+  lines.push(`type: ${data.type}`);
+  if (data.labels) {
+    lines.push(`labels: ${data.labels}`);
+  }
+  lines.push(`status: ${data.status}`);
+  if (data.order) {
+    lines.push(`order: ${data.order}`);
+  }
+  lines.push(`created: ${data.created}`);
+  if (data.updated) {
+    lines.push(`updated: ${data.updated}`);
+  }
+  lines.push("---");
+  return lines.join(`
+`);
+}
+function getIssueIdFromFilename(filename) {
+  const match = filename.match(/^(\d+)-/);
+  return match ? match[1] : filename.replace(".md", "");
+}
+function createSlug(title) {
+  return title.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").slice(0, 50);
+}
+function formatDate(date = new Date) {
+  return date.toISOString().slice(0, 19);
+}
+async function getIssueFiles() {
+  try {
+    const files = await readdir(getIssuesDir());
+    return files.filter((f) => f.endsWith(".md") && /^\d{4}-/.test(f));
+  } catch {
+    return [];
+  }
+}
+async function getNextIssueNumber() {
+  const files = await getIssueFiles();
+  if (files.length === 0)
+    return "0001";
+  const numbers = files.map((f) => parseInt(getIssueIdFromFilename(f), 10)).filter((n) => !Number.isNaN(n));
+  const max = Math.max(...numbers, 0);
+  return String(max + 1).padStart(4, "0");
+}
+async function getIssue(id) {
+  const files = await getIssueFiles();
+  const paddedId = id.padStart(4, "0");
+  const file = files.find((f) => f.startsWith(paddedId) || getIssueIdFromFilename(f) === paddedId);
+  if (!file)
+    return null;
+  const filepath = join(getIssuesDir(), file);
+  const content = await readFile(filepath, "utf-8");
+  const { frontmatter, body } = parseFrontmatter(content);
+  return {
+    id: getIssueIdFromFilename(file),
+    filename: file,
+    frontmatter,
+    content: body
+  };
+}
+async function getAllIssues() {
+  const files = await getIssueFiles();
+  const issues = [];
+  for (const file of files) {
+    const filepath = join(getIssuesDir(), file);
+    const content = await readFile(filepath, "utf-8");
+    const { frontmatter, body } = parseFrontmatter(content);
+    issues.push({
+      id: getIssueIdFromFilename(file),
+      filename: file,
+      frontmatter,
+      content: body
+    });
+  }
+  return issues.sort((a, b) => {
+    const orderA = a.frontmatter.order;
+    const orderB = b.frontmatter.order;
+    if (orderA && orderB)
+      return orderA < orderB ? -1 : orderA > orderB ? 1 : 0;
+    if (orderA && !orderB)
+      return -1;
+    if (!orderA && orderB)
+      return 1;
+    return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+  });
+}
+async function getOpenIssuesByOrder() {
+  const allIssues = await getAllIssues();
+  return allIssues.filter((i) => i.frontmatter.status === "open");
+}
+function computeOrderKey(openIssues, options, excludeId) {
+  const issues = excludeId ? openIssues.filter((i) => i.id !== excludeId.padStart(4, "0")) : openIssues;
+  if (options.first) {
+    if (issues.length === 0)
+      return generateKeyBetween(null, null);
+    const firstOrder = issues[0].frontmatter.order || null;
+    return generateKeyBetween(null, firstOrder);
+  }
+  if (options.last) {
+    if (issues.length === 0)
+      return generateKeyBetween(null, null);
+    const lastOrder2 = issues[issues.length - 1].frontmatter.order || null;
+    return generateKeyBetween(lastOrder2, null);
+  }
+  if (options.after) {
+    const targetId = options.after.padStart(4, "0");
+    const idx = issues.findIndex((i) => i.id === targetId);
+    if (idx === -1)
+      throw new Error(`Issue #${options.after} not found among open issues. The --after target must be an open issue.`);
+    const afterOrder = issues[idx].frontmatter.order || null;
+    const nextOrder = idx + 1 < issues.length ? issues[idx + 1].frontmatter.order || null : null;
+    return generateKeyBetween(afterOrder, nextOrder);
+  }
+  if (options.before) {
+    const targetId = options.before.padStart(4, "0");
+    const idx = issues.findIndex((i) => i.id === targetId);
+    if (idx === -1)
+      throw new Error(`Issue #${options.before} not found among open issues. The --before target must be an open issue.`);
+    const beforeOrder = issues[idx].frontmatter.order || null;
+    const prevOrder = idx > 0 ? issues[idx - 1].frontmatter.order || null : null;
+    return generateKeyBetween(prevOrder, beforeOrder);
+  }
+  if (issues.length === 0) {
+    return generateKeyBetween(null, null);
+  }
+  const lastOrder = issues[issues.length - 1].frontmatter.order || null;
+  return generateKeyBetween(lastOrder, null);
+}
+function generateBatchOrderKeys(count) {
+  return generateNKeysBetween(null, null, count);
+}
+async function createIssue(input) {
+  await ensureIssuesDir();
+  if (!input.title) {
+    throw new Error("Title is required");
+  }
+  const priority = input.priority || "medium";
+  const scope = input.scope;
+  const type = input.type || "improvement";
+  if (!["high", "medium", "low"].includes(priority)) {
+    throw new Error("Priority must be: high, medium, or low");
+  }
+  if (scope && !["small", "medium", "large"].includes(scope)) {
+    throw new Error("Scope must be: small, medium, or large");
+  }
+  if (!["bug", "improvement"].includes(type)) {
+    throw new Error("Type must be: bug or improvement");
+  }
+  const issueNumber = await getNextIssueNumber();
+  const slug = createSlug(input.title);
+  const filename = `${issueNumber}-${slug}.md`;
+  const frontmatter = {
+    title: input.title,
+    description: input.description || input.title,
+    priority,
+    scope: scope || undefined,
+    type,
+    labels: input.labels || undefined,
+    status: "open",
+    order: input.order || undefined,
+    created: formatDate()
+  };
+  const content = `${generateFrontmatter(frontmatter)}
+
+## Details
+
+<!-- Add detailed description here -->
+
+`;
+  await writeFile(join(getIssuesDir(), filename), content);
+  return {
+    id: issueNumber,
+    filename,
+    frontmatter,
+    content: `
+## Details
+
+<!-- Add detailed description here -->
+
+`
+  };
+}
+async function updateIssue(id, input) {
+  const issue = await getIssue(id);
+  if (!issue) {
+    throw new Error(`Issue not found: ${id}`);
+  }
+  const updatedFrontmatter = {
+    ...issue.frontmatter,
+    ...input.title && { title: input.title },
+    ...input.description && { description: input.description },
+    ...input.priority && { priority: input.priority },
+    ...input.scope && { scope: input.scope },
+    ...input.type && { type: input.type },
+    ...input.labels !== undefined && {
+      labels: input.labels || undefined
+    },
+    ...input.status && { status: input.status },
+    ...input.order && { order: input.order },
+    updated: formatDate()
+  };
+  const content = `${generateFrontmatter(updatedFrontmatter)}
+${issue.content}`;
+  await writeFile(join(getIssuesDir(), issue.filename), content);
+  return {
+    ...issue,
+    frontmatter: updatedFrontmatter
+  };
+}
+async function closeIssue(id) {
+  return updateIssue(id, { status: "closed" });
+}
+async function reopenIssue(id, order) {
+  return updateIssue(id, { status: "open", order });
+}
+async function getOnCloseContent() {
+  try {
+    const onClosePath = join(getIssyDir(), "on_close.md");
+    return await readFile(onClosePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function getNextIssue() {
+  const openIssues = await getOpenIssuesByOrder();
+  return openIssues.length > 0 ? openIssues[0] : null;
+}
+// ../core/src/lib/query-parser.ts
+var SUPPORTED_QUALIFIERS = new Set([
+  "is",
+  "priority",
+  "scope",
+  "type",
+  "label",
+  "sort"
+]);
+function parseQuery(query) {
+  const qualifiers = {};
+  const searchTextParts = [];
+  if (!query || !query.trim()) {
+    return { qualifiers, searchText: "" };
+  }
+  const tokens = tokenizeQuery(query);
+  for (const token of tokens) {
+    const colonIndex = token.indexOf(":");
+    if (colonIndex > 0 && colonIndex < token.length - 1) {
+      const key = token.substring(0, colonIndex);
+      const value = token.substring(colonIndex + 1);
+      if (SUPPORTED_QUALIFIERS.has(key)) {
+        qualifiers[key] = value;
+      } else {
+        searchTextParts.push(token);
+      }
+    } else {
+      searchTextParts.push(token);
+    }
+  }
+  return {
+    qualifiers,
+    searchText: searchTextParts.join(" ").trim()
+  };
+}
+function tokenizeQuery(query) {
+  const tokens = [];
+  let currentToken = "";
+  let inQuotes = false;
+  let quoteChar = "";
+  for (let i = 0;i < query.length; i++) {
+    const char = query[i];
+    if ((char === '"' || char === "'") && !inQuotes) {
+      inQuotes = true;
+      quoteChar = char;
+    } else if (char === quoteChar && inQuotes) {
+      inQuotes = false;
+      quoteChar = "";
+    } else if (char === " " && !inQuotes) {
+      if (currentToken) {
+        tokens.push(currentToken);
+        currentToken = "";
+      }
+    } else {
+      currentToken += char;
+    }
+  }
+  if (currentToken) {
+    tokens.push(currentToken);
+  }
+  return tokens;
+}
+// ../../node_modules/.bun/fuse.js@7.1.0/node_modules/fuse.js/dist/fuse.mjs
+function isArray(value) {
+  return !Array.isArray ? getTag(value) === "[object Array]" : Array.isArray(value);
+}
+var INFINITY = 1 / 0;
+function baseToString(value) {
+  if (typeof value == "string") {
+    return value;
+  }
+  let result = value + "";
+  return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+}
+function toString(value) {
+  return value == null ? "" : baseToString(value);
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isNumber(value) {
+  return typeof value === "number";
+}
+function isBoolean(value) {
+  return value === true || value === false || isObjectLike(value) && getTag(value) == "[object Boolean]";
+}
+function isObject(value) {
+  return typeof value === "object";
+}
+function isObjectLike(value) {
+  return isObject(value) && value !== null;
+}
+function isDefined(value) {
+  return value !== undefined && value !== null;
+}
+function isBlank(value) {
+  return !value.trim().length;
+}
+function getTag(value) {
+  return value == null ? value === undefined ? "[object Undefined]" : "[object Null]" : Object.prototype.toString.call(value);
+}
+var INCORRECT_INDEX_TYPE = "Incorrect 'index' type";
+var LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY = (key) => `Invalid value for key ${key}`;
+var PATTERN_LENGTH_TOO_LARGE = (max) => `Pattern length exceeds max of ${max}.`;
+var MISSING_KEY_PROPERTY = (name) => `Missing ${name} property in key`;
+var INVALID_KEY_WEIGHT_VALUE = (key) => `Property 'weight' in key '${key}' must be a positive integer`;
+var hasOwn = Object.prototype.hasOwnProperty;
+
+class KeyStore {
+  constructor(keys) {
+    this._keys = [];
+    this._keyMap = {};
+    let totalWeight = 0;
+    keys.forEach((key) => {
+      let obj = createKey(key);
+      this._keys.push(obj);
+      this._keyMap[obj.id] = obj;
+      totalWeight += obj.weight;
+    });
+    this._keys.forEach((key) => {
+      key.weight /= totalWeight;
+    });
+  }
+  get(keyId) {
+    return this._keyMap[keyId];
+  }
+  keys() {
+    return this._keys;
+  }
+  toJSON() {
+    return JSON.stringify(this._keys);
+  }
+}
+function createKey(key) {
+  let path = null;
+  let id = null;
+  let src = null;
+  let weight = 1;
+  let getFn = null;
+  if (isString(key) || isArray(key)) {
+    src = key;
+    path = createKeyPath(key);
+    id = createKeyId(key);
+  } else {
+    if (!hasOwn.call(key, "name")) {
+      throw new Error(MISSING_KEY_PROPERTY("name"));
+    }
+    const name = key.name;
+    src = name;
+    if (hasOwn.call(key, "weight")) {
+      weight = key.weight;
+      if (weight <= 0) {
+        throw new Error(INVALID_KEY_WEIGHT_VALUE(name));
+      }
+    }
+    path = createKeyPath(name);
+    id = createKeyId(name);
+    getFn = key.getFn;
+  }
+  return { path, id, weight, src, getFn };
+}
+function createKeyPath(key) {
+  return isArray(key) ? key : key.split(".");
+}
+function createKeyId(key) {
+  return isArray(key) ? key.join(".") : key;
+}
+function get(obj, path) {
+  let list = [];
+  let arr = false;
+  const deepGet = (obj2, path2, index) => {
+    if (!isDefined(obj2)) {
+      return;
+    }
+    if (!path2[index]) {
+      list.push(obj2);
+    } else {
+      let key = path2[index];
+      const value = obj2[key];
+      if (!isDefined(value)) {
+        return;
+      }
+      if (index === path2.length - 1 && (isString(value) || isNumber(value) || isBoolean(value))) {
+        list.push(toString(value));
+      } else if (isArray(value)) {
+        arr = true;
+        for (let i = 0, len = value.length;i < len; i += 1) {
+          deepGet(value[i], path2, index + 1);
+        }
+      } else if (path2.length) {
+        deepGet(value, path2, index + 1);
+      }
+    }
+  };
+  deepGet(obj, isString(path) ? path.split(".") : path, 0);
+  return arr ? list : list[0];
+}
+var MatchOptions = {
+  includeMatches: false,
+  findAllMatches: false,
+  minMatchCharLength: 1
+};
+var BasicOptions = {
+  isCaseSensitive: false,
+  ignoreDiacritics: false,
+  includeScore: false,
+  keys: [],
+  shouldSort: true,
+  sortFn: (a, b) => a.score === b.score ? a.idx < b.idx ? -1 : 1 : a.score < b.score ? -1 : 1
+};
+var FuzzyOptions = {
+  location: 0,
+  threshold: 0.6,
+  distance: 100
+};
+var AdvancedOptions = {
+  useExtendedSearch: false,
+  getFn: get,
+  ignoreLocation: false,
+  ignoreFieldNorm: false,
+  fieldNormWeight: 1
+};
+var Config = {
+  ...BasicOptions,
+  ...MatchOptions,
+  ...FuzzyOptions,
+  ...AdvancedOptions
+};
+var SPACE = /[^ ]+/g;
+function norm(weight = 1, mantissa = 3) {
+  const cache = new Map;
+  const m = Math.pow(10, mantissa);
+  return {
+    get(value) {
+      const numTokens = value.match(SPACE).length;
+      if (cache.has(numTokens)) {
+        return cache.get(numTokens);
+      }
+      const norm2 = 1 / Math.pow(numTokens, 0.5 * weight);
+      const n = parseFloat(Math.round(norm2 * m) / m);
+      cache.set(numTokens, n);
+      return n;
+    },
+    clear() {
+      cache.clear();
+    }
+  };
+}
+
+class FuseIndex {
+  constructor({
+    getFn = Config.getFn,
+    fieldNormWeight = Config.fieldNormWeight
+  } = {}) {
+    this.norm = norm(fieldNormWeight, 3);
+    this.getFn = getFn;
+    this.isCreated = false;
+    this.setIndexRecords();
+  }
+  setSources(docs = []) {
+    this.docs = docs;
+  }
+  setIndexRecords(records = []) {
+    this.records = records;
+  }
+  setKeys(keys = []) {
+    this.keys = keys;
+    this._keysMap = {};
+    keys.forEach((key, idx) => {
+      this._keysMap[key.id] = idx;
+    });
+  }
+  create() {
+    if (this.isCreated || !this.docs.length) {
+      return;
+    }
+    this.isCreated = true;
+    if (isString(this.docs[0])) {
+      this.docs.forEach((doc, docIndex) => {
+        this._addString(doc, docIndex);
+      });
+    } else {
+      this.docs.forEach((doc, docIndex) => {
+        this._addObject(doc, docIndex);
+      });
+    }
+    this.norm.clear();
+  }
+  add(doc) {
+    const idx = this.size();
+    if (isString(doc)) {
+      this._addString(doc, idx);
+    } else {
+      this._addObject(doc, idx);
+    }
+  }
+  removeAt(idx) {
+    this.records.splice(idx, 1);
+    for (let i = idx, len = this.size();i < len; i += 1) {
+      this.records[i].i -= 1;
+    }
+  }
+  getValueForItemAtKeyId(item, keyId) {
+    return item[this._keysMap[keyId]];
+  }
+  size() {
+    return this.records.length;
+  }
+  _addString(doc, docIndex) {
+    if (!isDefined(doc) || isBlank(doc)) {
+      return;
+    }
+    let record = {
+      v: doc,
+      i: docIndex,
+      n: this.norm.get(doc)
+    };
+    this.records.push(record);
+  }
+  _addObject(doc, docIndex) {
+    let record = { i: docIndex, $: {} };
+    this.keys.forEach((key, keyIndex) => {
+      let value = key.getFn ? key.getFn(doc) : this.getFn(doc, key.path);
+      if (!isDefined(value)) {
+        return;
+      }
+      if (isArray(value)) {
+        let subRecords = [];
+        const stack = [{ nestedArrIndex: -1, value }];
+        while (stack.length) {
+          const { nestedArrIndex, value: value2 } = stack.pop();
+          if (!isDefined(value2)) {
+            continue;
+          }
+          if (isString(value2) && !isBlank(value2)) {
+            let subRecord = {
+              v: value2,
+              i: nestedArrIndex,
+              n: this.norm.get(value2)
+            };
+            subRecords.push(subRecord);
+          } else if (isArray(value2)) {
+            value2.forEach((item, k) => {
+              stack.push({
+                nestedArrIndex: k,
+                value: item
+              });
+            });
+          } else
+            ;
+        }
+        record.$[keyIndex] = subRecords;
+      } else if (isString(value) && !isBlank(value)) {
+        let subRecord = {
+          v: value,
+          n: this.norm.get(value)
+        };
+        record.$[keyIndex] = subRecord;
+      }
+    });
+    this.records.push(record);
+  }
+  toJSON() {
+    return {
+      keys: this.keys,
+      records: this.records
+    };
+  }
+}
+function createIndex(keys, docs, { getFn = Config.getFn, fieldNormWeight = Config.fieldNormWeight } = {}) {
+  const myIndex = new FuseIndex({ getFn, fieldNormWeight });
+  myIndex.setKeys(keys.map(createKey));
+  myIndex.setSources(docs);
+  myIndex.create();
+  return myIndex;
+}
+function parseIndex(data, { getFn = Config.getFn, fieldNormWeight = Config.fieldNormWeight } = {}) {
+  const { keys, records } = data;
+  const myIndex = new FuseIndex({ getFn, fieldNormWeight });
+  myIndex.setKeys(keys);
+  myIndex.setIndexRecords(records);
+  return myIndex;
+}
+function computeScore$1(pattern, {
+  errors = 0,
+  currentLocation = 0,
+  expectedLocation = 0,
+  distance = Config.distance,
+  ignoreLocation = Config.ignoreLocation
+} = {}) {
+  const accuracy = errors / pattern.length;
+  if (ignoreLocation) {
+    return accuracy;
+  }
+  const proximity = Math.abs(expectedLocation - currentLocation);
+  if (!distance) {
+    return proximity ? 1 : accuracy;
+  }
+  return accuracy + proximity / distance;
+}
+function convertMaskToIndices(matchmask = [], minMatchCharLength = Config.minMatchCharLength) {
+  let indices = [];
+  let start = -1;
+  let end = -1;
+  let i = 0;
+  for (let len = matchmask.length;i < len; i += 1) {
+    let match = matchmask[i];
+    if (match && start === -1) {
+      start = i;
+    } else if (!match && start !== -1) {
+      end = i - 1;
+      if (end - start + 1 >= minMatchCharLength) {
+        indices.push([start, end]);
+      }
+      start = -1;
+    }
+  }
+  if (matchmask[i - 1] && i - start >= minMatchCharLength) {
+    indices.push([start, i - 1]);
+  }
+  return indices;
+}
+var MAX_BITS = 32;
+function search(text, pattern, patternAlphabet, {
+  location = Config.location,
+  distance = Config.distance,
+  threshold = Config.threshold,
+  findAllMatches = Config.findAllMatches,
+  minMatchCharLength = Config.minMatchCharLength,
+  includeMatches = Config.includeMatches,
+  ignoreLocation = Config.ignoreLocation
+} = {}) {
+  if (pattern.length > MAX_BITS) {
+    throw new Error(PATTERN_LENGTH_TOO_LARGE(MAX_BITS));
+  }
+  const patternLen = pattern.length;
+  const textLen = text.length;
+  const expectedLocation = Math.max(0, Math.min(location, textLen));
+  let currentThreshold = threshold;
+  let bestLocation = expectedLocation;
+  const computeMatches = minMatchCharLength > 1 || includeMatches;
+  const matchMask = computeMatches ? Array(textLen) : [];
+  let index;
+  while ((index = text.indexOf(pattern, bestLocation)) > -1) {
+    let score = computeScore$1(pattern, {
+      currentLocation: index,
+      expectedLocation,
+      distance,
+      ignoreLocation
+    });
+    currentThreshold = Math.min(score, currentThreshold);
+    bestLocation = index + patternLen;
+    if (computeMatches) {
+      let i = 0;
+      while (i < patternLen) {
+        matchMask[index + i] = 1;
+        i += 1;
+      }
+    }
+  }
+  bestLocation = -1;
+  let lastBitArr = [];
+  let finalScore = 1;
+  let binMax = patternLen + textLen;
+  const mask = 1 << patternLen - 1;
+  for (let i = 0;i < patternLen; i += 1) {
+    let binMin = 0;
+    let binMid = binMax;
+    while (binMin < binMid) {
+      const score2 = computeScore$1(pattern, {
+        errors: i,
+        currentLocation: expectedLocation + binMid,
+        expectedLocation,
+        distance,
+        ignoreLocation
+      });
+      if (score2 <= currentThreshold) {
+        binMin = binMid;
+      } else {
+        binMax = binMid;
+      }
+      binMid = Math.floor((binMax - binMin) / 2 + binMin);
+    }
+    binMax = binMid;
+    let start = Math.max(1, expectedLocation - binMid + 1);
+    let finish = findAllMatches ? textLen : Math.min(expectedLocation + binMid, textLen) + patternLen;
+    let bitArr = Array(finish + 2);
+    bitArr[finish + 1] = (1 << i) - 1;
+    for (let j = finish;j >= start; j -= 1) {
+      let currentLocation = j - 1;
+      let charMatch = patternAlphabet[text.charAt(currentLocation)];
+      if (computeMatches) {
+        matchMask[currentLocation] = +!!charMatch;
+      }
+      bitArr[j] = (bitArr[j + 1] << 1 | 1) & charMatch;
+      if (i) {
+        bitArr[j] |= (lastBitArr[j + 1] | lastBitArr[j]) << 1 | 1 | lastBitArr[j + 1];
+      }
+      if (bitArr[j] & mask) {
+        finalScore = computeScore$1(pattern, {
+          errors: i,
+          currentLocation,
+          expectedLocation,
+          distance,
+          ignoreLocation
+        });
+        if (finalScore <= currentThreshold) {
+          currentThreshold = finalScore;
+          bestLocation = currentLocation;
+          if (bestLocation <= expectedLocation) {
+            break;
+          }
+          start = Math.max(1, 2 * expectedLocation - bestLocation);
+        }
+      }
+    }
+    const score = computeScore$1(pattern, {
+      errors: i + 1,
+      currentLocation: expectedLocation,
+      expectedLocation,
+      distance,
+      ignoreLocation
+    });
+    if (score > currentThreshold) {
+      break;
+    }
+    lastBitArr = bitArr;
+  }
+  const result = {
+    isMatch: bestLocation >= 0,
+    score: Math.max(0.001, finalScore)
+  };
+  if (computeMatches) {
+    const indices = convertMaskToIndices(matchMask, minMatchCharLength);
+    if (!indices.length) {
+      result.isMatch = false;
+    } else if (includeMatches) {
+      result.indices = indices;
+    }
+  }
+  return result;
+}
+function createPatternAlphabet(pattern) {
+  let mask = {};
+  for (let i = 0, len = pattern.length;i < len; i += 1) {
+    const char = pattern.charAt(i);
+    mask[char] = (mask[char] || 0) | 1 << len - i - 1;
+  }
+  return mask;
+}
+var stripDiacritics = String.prototype.normalize ? (str) => str.normalize("NFD").replace(/[\u0300-\u036F\u0483-\u0489\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08D3-\u08E1\u08E3-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09FE\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AFA-\u0AFF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B62\u0B63\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0C00-\u0C04\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0D00-\u0D03\u0D3B\u0D3C\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D82\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EB9\u0EBB\u0EBC\u0EC8-\u0ECD\u0F18\u0F19\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F\u109A-\u109D\u135D-\u135F\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u180B-\u180D\u1885\u1886\u18A9\u1920-\u192B\u1930-\u193B\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F\u1AB0-\u1ABE\u1B00-\u1B04\u1B34-\u1B44\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BE6-\u1BF3\u1C24-\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF2-\u1CF4\u1CF7-\u1CF9\u1DC0-\u1DF9\u1DFB-\u1DFF\u20D0-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA66F-\uA672\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA880\uA881\uA8B4-\uA8C5\uA8E0-\uA8F1\uA8FF\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9E5\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F]/g, "") : (str) => str;
+
+class BitapSearch {
+  constructor(pattern, {
+    location = Config.location,
+    threshold = Config.threshold,
+    distance = Config.distance,
+    includeMatches = Config.includeMatches,
+    findAllMatches = Config.findAllMatches,
+    minMatchCharLength = Config.minMatchCharLength,
+    isCaseSensitive = Config.isCaseSensitive,
+    ignoreDiacritics = Config.ignoreDiacritics,
+    ignoreLocation = Config.ignoreLocation
+  } = {}) {
+    this.options = {
+      location,
+      threshold,
+      distance,
+      includeMatches,
+      findAllMatches,
+      minMatchCharLength,
+      isCaseSensitive,
+      ignoreDiacritics,
+      ignoreLocation
+    };
+    pattern = isCaseSensitive ? pattern : pattern.toLowerCase();
+    pattern = ignoreDiacritics ? stripDiacritics(pattern) : pattern;
+    this.pattern = pattern;
+    this.chunks = [];
+    if (!this.pattern.length) {
+      return;
+    }
+    const addChunk = (pattern2, startIndex) => {
+      this.chunks.push({
+        pattern: pattern2,
+        alphabet: createPatternAlphabet(pattern2),
+        startIndex
+      });
+    };
+    const len = this.pattern.length;
+    if (len > MAX_BITS) {
+      let i = 0;
+      const remainder = len % MAX_BITS;
+      const end = len - remainder;
+      while (i < end) {
+        addChunk(this.pattern.substr(i, MAX_BITS), i);
+        i += MAX_BITS;
+      }
+      if (remainder) {
+        const startIndex = len - MAX_BITS;
+        addChunk(this.pattern.substr(startIndex), startIndex);
+      }
+    } else {
+      addChunk(this.pattern, 0);
+    }
+  }
+  searchIn(text) {
+    const { isCaseSensitive, ignoreDiacritics, includeMatches } = this.options;
+    text = isCaseSensitive ? text : text.toLowerCase();
+    text = ignoreDiacritics ? stripDiacritics(text) : text;
+    if (this.pattern === text) {
+      let result2 = {
+        isMatch: true,
+        score: 0
+      };
+      if (includeMatches) {
+        result2.indices = [[0, text.length - 1]];
+      }
+      return result2;
+    }
+    const {
+      location,
+      distance,
+      threshold,
+      findAllMatches,
+      minMatchCharLength,
+      ignoreLocation
+    } = this.options;
+    let allIndices = [];
+    let totalScore = 0;
+    let hasMatches = false;
+    this.chunks.forEach(({ pattern, alphabet, startIndex }) => {
+      const { isMatch, score, indices } = search(text, pattern, alphabet, {
+        location: location + startIndex,
+        distance,
+        threshold,
+        findAllMatches,
+        minMatchCharLength,
+        includeMatches,
+        ignoreLocation
+      });
+      if (isMatch) {
+        hasMatches = true;
+      }
+      totalScore += score;
+      if (isMatch && indices) {
+        allIndices = [...allIndices, ...indices];
+      }
+    });
+    let result = {
+      isMatch: hasMatches,
+      score: hasMatches ? totalScore / this.chunks.length : 1
+    };
+    if (hasMatches && includeMatches) {
+      result.indices = allIndices;
+    }
+    return result;
+  }
+}
+
+class BaseMatch {
+  constructor(pattern) {
+    this.pattern = pattern;
+  }
+  static isMultiMatch(pattern) {
+    return getMatch(pattern, this.multiRegex);
+  }
+  static isSingleMatch(pattern) {
+    return getMatch(pattern, this.singleRegex);
+  }
+  search() {}
+}
+function getMatch(pattern, exp) {
+  const matches = pattern.match(exp);
+  return matches ? matches[1] : null;
+}
+
+class ExactMatch extends BaseMatch {
+  constructor(pattern) {
+    super(pattern);
+  }
+  static get type() {
+    return "exact";
+  }
+  static get multiRegex() {
+    return /^="(.*)"$/;
+  }
+  static get singleRegex() {
+    return /^=(.*)$/;
+  }
+  search(text) {
+    const isMatch = text === this.pattern;
+    return {
+      isMatch,
+      score: isMatch ? 0 : 1,
+      indices: [0, this.pattern.length - 1]
+    };
+  }
+}
+
+class InverseExactMatch extends BaseMatch {
+  constructor(pattern) {
+    super(pattern);
+  }
+  static get type() {
+    return "inverse-exact";
+  }
+  static get multiRegex() {
+    return /^!"(.*)"$/;
+  }
+  static get singleRegex() {
+    return /^!(.*)$/;
+  }
+  search(text) {
+    const index = text.indexOf(this.pattern);
+    const isMatch = index === -1;
+    return {
+      isMatch,
+      score: isMatch ? 0 : 1,
+      indices: [0, text.length - 1]
+    };
+  }
+}
+
+class PrefixExactMatch extends BaseMatch {
+  constructor(pattern) {
+    super(pattern);
+  }
+  static get type() {
+    return "prefix-exact";
+  }
+  static get multiRegex() {
+    return /^\^"(.*)"$/;
+  }
+  static get singleRegex() {
+    return /^\^(.*)$/;
+  }
+  search(text) {
+    const isMatch = text.startsWith(this.pattern);
+    return {
+      isMatch,
+      score: isMatch ? 0 : 1,
+      indices: [0, this.pattern.length - 1]
+    };
+  }
+}
+
+class InversePrefixExactMatch extends BaseMatch {
+  constructor(pattern) {
+    super(pattern);
+  }
+  static get type() {
+    return "inverse-prefix-exact";
+  }
+  static get multiRegex() {
+    return /^!\^"(.*)"$/;
+  }
+  static get singleRegex() {
+    return /^!\^(.*)$/;
+  }
+  search(text) {
+    const isMatch = !text.startsWith(this.pattern);
+    return {
+      isMatch,
+      score: isMatch ? 0 : 1,
+      indices: [0, text.length - 1]
+    };
+  }
+}
+
+class SuffixExactMatch extends BaseMatch {
+  constructor(pattern) {
+    super(pattern);
+  }
+  static get type() {
+    return "suffix-exact";
+  }
+  static get multiRegex() {
+    return /^"(.*)"\$$/;
+  }
+  static get singleRegex() {
+    return /^(.*)\$$/;
+  }
+  search(text) {
+    const isMatch = text.endsWith(this.pattern);
+    return {
+      isMatch,
+      score: isMatch ? 0 : 1,
+      indices: [text.length - this.pattern.length, text.length - 1]
+    };
+  }
+}
+
+class InverseSuffixExactMatch extends BaseMatch {
+  constructor(pattern) {
+    super(pattern);
+  }
+  static get type() {
+    return "inverse-suffix-exact";
+  }
+  static get multiRegex() {
+    return /^!"(.*)"\$$/;
+  }
+  static get singleRegex() {
+    return /^!(.*)\$$/;
+  }
+  search(text) {
+    const isMatch = !text.endsWith(this.pattern);
+    return {
+      isMatch,
+      score: isMatch ? 0 : 1,
+      indices: [0, text.length - 1]
+    };
+  }
+}
+
+class FuzzyMatch extends BaseMatch {
+  constructor(pattern, {
+    location = Config.location,
+    threshold = Config.threshold,
+    distance = Config.distance,
+    includeMatches = Config.includeMatches,
+    findAllMatches = Config.findAllMatches,
+    minMatchCharLength = Config.minMatchCharLength,
+    isCaseSensitive = Config.isCaseSensitive,
+    ignoreDiacritics = Config.ignoreDiacritics,
+    ignoreLocation = Config.ignoreLocation
+  } = {}) {
+    super(pattern);
+    this._bitapSearch = new BitapSearch(pattern, {
+      location,
+      threshold,
+      distance,
+      includeMatches,
+      findAllMatches,
+      minMatchCharLength,
+      isCaseSensitive,
+      ignoreDiacritics,
+      ignoreLocation
+    });
+  }
+  static get type() {
+    return "fuzzy";
+  }
+  static get multiRegex() {
+    return /^"(.*)"$/;
+  }
+  static get singleRegex() {
+    return /^(.*)$/;
+  }
+  search(text) {
+    return this._bitapSearch.searchIn(text);
+  }
+}
+
+class IncludeMatch extends BaseMatch {
+  constructor(pattern) {
+    super(pattern);
+  }
+  static get type() {
+    return "include";
+  }
+  static get multiRegex() {
+    return /^'"(.*)"$/;
+  }
+  static get singleRegex() {
+    return /^'(.*)$/;
+  }
+  search(text) {
+    let location = 0;
+    let index;
+    const indices = [];
+    const patternLen = this.pattern.length;
+    while ((index = text.indexOf(this.pattern, location)) > -1) {
+      location = index + patternLen;
+      indices.push([index, location - 1]);
+    }
+    const isMatch = !!indices.length;
+    return {
+      isMatch,
+      score: isMatch ? 0 : 1,
+      indices
+    };
+  }
+}
+var searchers = [
+  ExactMatch,
+  IncludeMatch,
+  PrefixExactMatch,
+  InversePrefixExactMatch,
+  InverseSuffixExactMatch,
+  SuffixExactMatch,
+  InverseExactMatch,
+  FuzzyMatch
+];
+var searchersLen = searchers.length;
+var SPACE_RE = / +(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)/;
+var OR_TOKEN = "|";
+function parseQuery2(pattern, options = {}) {
+  return pattern.split(OR_TOKEN).map((item) => {
+    let query = item.trim().split(SPACE_RE).filter((item2) => item2 && !!item2.trim());
+    let results = [];
+    for (let i = 0, len = query.length;i < len; i += 1) {
+      const queryItem = query[i];
+      let found = false;
+      let idx = -1;
+      while (!found && ++idx < searchersLen) {
+        const searcher = searchers[idx];
+        let token = searcher.isMultiMatch(queryItem);
+        if (token) {
+          results.push(new searcher(token, options));
+          found = true;
+        }
+      }
+      if (found) {
+        continue;
+      }
+      idx = -1;
+      while (++idx < searchersLen) {
+        const searcher = searchers[idx];
+        let token = searcher.isSingleMatch(queryItem);
+        if (token) {
+          results.push(new searcher(token, options));
+          break;
+        }
+      }
+    }
+    return results;
+  });
+}
+var MultiMatchSet = new Set([FuzzyMatch.type, IncludeMatch.type]);
+
+class ExtendedSearch {
+  constructor(pattern, {
+    isCaseSensitive = Config.isCaseSensitive,
+    ignoreDiacritics = Config.ignoreDiacritics,
+    includeMatches = Config.includeMatches,
+    minMatchCharLength = Config.minMatchCharLength,
+    ignoreLocation = Config.ignoreLocation,
+    findAllMatches = Config.findAllMatches,
+    location = Config.location,
+    threshold = Config.threshold,
+    distance = Config.distance
+  } = {}) {
+    this.query = null;
+    this.options = {
+      isCaseSensitive,
+      ignoreDiacritics,
+      includeMatches,
+      minMatchCharLength,
+      findAllMatches,
+      ignoreLocation,
+      location,
+      threshold,
+      distance
+    };
+    pattern = isCaseSensitive ? pattern : pattern.toLowerCase();
+    pattern = ignoreDiacritics ? stripDiacritics(pattern) : pattern;
+    this.pattern = pattern;
+    this.query = parseQuery2(this.pattern, this.options);
+  }
+  static condition(_, options) {
+    return options.useExtendedSearch;
+  }
+  searchIn(text) {
+    const query = this.query;
+    if (!query) {
+      return {
+        isMatch: false,
+        score: 1
+      };
+    }
+    const { includeMatches, isCaseSensitive, ignoreDiacritics } = this.options;
+    text = isCaseSensitive ? text : text.toLowerCase();
+    text = ignoreDiacritics ? stripDiacritics(text) : text;
+    let numMatches = 0;
+    let allIndices = [];
+    let totalScore = 0;
+    for (let i = 0, qLen = query.length;i < qLen; i += 1) {
+      const searchers2 = query[i];
+      allIndices.length = 0;
+      numMatches = 0;
+      for (let j = 0, pLen = searchers2.length;j < pLen; j += 1) {
+        const searcher = searchers2[j];
+        const { isMatch, indices, score } = searcher.search(text);
+        if (isMatch) {
+          numMatches += 1;
+          totalScore += score;
+          if (includeMatches) {
+            const type = searcher.constructor.type;
+            if (MultiMatchSet.has(type)) {
+              allIndices = [...allIndices, ...indices];
+            } else {
+              allIndices.push(indices);
+            }
+          }
+        } else {
+          totalScore = 0;
+          numMatches = 0;
+          allIndices.length = 0;
+          break;
+        }
+      }
+      if (numMatches) {
+        let result = {
+          isMatch: true,
+          score: totalScore / numMatches
+        };
+        if (includeMatches) {
+          result.indices = allIndices;
+        }
+        return result;
+      }
+    }
+    return {
+      isMatch: false,
+      score: 1
+    };
+  }
+}
+var registeredSearchers = [];
+function register(...args) {
+  registeredSearchers.push(...args);
+}
+function createSearcher(pattern, options) {
+  for (let i = 0, len = registeredSearchers.length;i < len; i += 1) {
+    let searcherClass = registeredSearchers[i];
+    if (searcherClass.condition(pattern, options)) {
+      return new searcherClass(pattern, options);
+    }
+  }
+  return new BitapSearch(pattern, options);
+}
+var LogicalOperator = {
+  AND: "$and",
+  OR: "$or"
+};
+var KeyType = {
+  PATH: "$path",
+  PATTERN: "$val"
+};
+var isExpression = (query) => !!(query[LogicalOperator.AND] || query[LogicalOperator.OR]);
+var isPath = (query) => !!query[KeyType.PATH];
+var isLeaf = (query) => !isArray(query) && isObject(query) && !isExpression(query);
+var convertToExplicit = (query) => ({
+  [LogicalOperator.AND]: Object.keys(query).map((key) => ({
+    [key]: query[key]
+  }))
+});
+function parse(query, options, { auto = true } = {}) {
+  const next = (query2) => {
+    let keys = Object.keys(query2);
+    const isQueryPath = isPath(query2);
+    if (!isQueryPath && keys.length > 1 && !isExpression(query2)) {
+      return next(convertToExplicit(query2));
+    }
+    if (isLeaf(query2)) {
+      const key = isQueryPath ? query2[KeyType.PATH] : keys[0];
+      const pattern = isQueryPath ? query2[KeyType.PATTERN] : query2[key];
+      if (!isString(pattern)) {
+        throw new Error(LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY(key));
+      }
+      const obj = {
+        keyId: createKeyId(key),
+        pattern
+      };
+      if (auto) {
+        obj.searcher = createSearcher(pattern, options);
+      }
+      return obj;
+    }
+    let node = {
+      children: [],
+      operator: keys[0]
+    };
+    keys.forEach((key) => {
+      const value = query2[key];
+      if (isArray(value)) {
+        value.forEach((item) => {
+          node.children.push(next(item));
+        });
+      }
+    });
+    return node;
+  };
+  if (!isExpression(query)) {
+    query = convertToExplicit(query);
+  }
+  return next(query);
+}
+function computeScore(results, { ignoreFieldNorm = Config.ignoreFieldNorm }) {
+  results.forEach((result) => {
+    let totalScore = 1;
+    result.matches.forEach(({ key, norm: norm2, score }) => {
+      const weight = key ? key.weight : null;
+      totalScore *= Math.pow(score === 0 && weight ? Number.EPSILON : score, (weight || 1) * (ignoreFieldNorm ? 1 : norm2));
+    });
+    result.score = totalScore;
+  });
+}
+function transformMatches(result, data) {
+  const matches = result.matches;
+  data.matches = [];
+  if (!isDefined(matches)) {
+    return;
+  }
+  matches.forEach((match) => {
+    if (!isDefined(match.indices) || !match.indices.length) {
+      return;
+    }
+    const { indices, value } = match;
+    let obj = {
+      indices,
+      value
+    };
+    if (match.key) {
+      obj.key = match.key.src;
+    }
+    if (match.idx > -1) {
+      obj.refIndex = match.idx;
+    }
+    data.matches.push(obj);
+  });
+}
+function transformScore(result, data) {
+  data.score = result.score;
+}
+function format(results, docs, {
+  includeMatches = Config.includeMatches,
+  includeScore = Config.includeScore
+} = {}) {
+  const transformers = [];
+  if (includeMatches)
+    transformers.push(transformMatches);
+  if (includeScore)
+    transformers.push(transformScore);
+  return results.map((result) => {
+    const { idx } = result;
+    const data = {
+      item: docs[idx],
+      refIndex: idx
+    };
+    if (transformers.length) {
+      transformers.forEach((transformer) => {
+        transformer(result, data);
+      });
+    }
+    return data;
+  });
+}
+
+class Fuse {
+  constructor(docs, options = {}, index) {
+    this.options = { ...Config, ...options };
+    if (this.options.useExtendedSearch && false) {}
+    this._keyStore = new KeyStore(this.options.keys);
+    this.setCollection(docs, index);
+  }
+  setCollection(docs, index) {
+    this._docs = docs;
+    if (index && !(index instanceof FuseIndex)) {
+      throw new Error(INCORRECT_INDEX_TYPE);
+    }
+    this._myIndex = index || createIndex(this.options.keys, this._docs, {
+      getFn: this.options.getFn,
+      fieldNormWeight: this.options.fieldNormWeight
+    });
+  }
+  add(doc) {
+    if (!isDefined(doc)) {
+      return;
+    }
+    this._docs.push(doc);
+    this._myIndex.add(doc);
+  }
+  remove(predicate = () => false) {
+    const results = [];
+    for (let i = 0, len = this._docs.length;i < len; i += 1) {
+      const doc = this._docs[i];
+      if (predicate(doc, i)) {
+        this.removeAt(i);
+        i -= 1;
+        len -= 1;
+        results.push(doc);
+      }
+    }
+    return results;
+  }
+  removeAt(idx) {
+    this._docs.splice(idx, 1);
+    this._myIndex.removeAt(idx);
+  }
+  getIndex() {
+    return this._myIndex;
+  }
+  search(query, { limit = -1 } = {}) {
+    const {
+      includeMatches,
+      includeScore,
+      shouldSort,
+      sortFn,
+      ignoreFieldNorm
+    } = this.options;
+    let results = isString(query) ? isString(this._docs[0]) ? this._searchStringList(query) : this._searchObjectList(query) : this._searchLogical(query);
+    computeScore(results, { ignoreFieldNorm });
+    if (shouldSort) {
+      results.sort(sortFn);
+    }
+    if (isNumber(limit) && limit > -1) {
+      results = results.slice(0, limit);
+    }
+    return format(results, this._docs, {
+      includeMatches,
+      includeScore
+    });
+  }
+  _searchStringList(query) {
+    const searcher = createSearcher(query, this.options);
+    const { records } = this._myIndex;
+    const results = [];
+    records.forEach(({ v: text, i: idx, n: norm2 }) => {
+      if (!isDefined(text)) {
+        return;
+      }
+      const { isMatch, score, indices } = searcher.searchIn(text);
+      if (isMatch) {
+        results.push({
+          item: text,
+          idx,
+          matches: [{ score, value: text, norm: norm2, indices }]
+        });
+      }
+    });
+    return results;
+  }
+  _searchLogical(query) {
+    const expression = parse(query, this.options);
+    const evaluate = (node, item, idx) => {
+      if (!node.children) {
+        const { keyId, searcher } = node;
+        const matches = this._findMatches({
+          key: this._keyStore.get(keyId),
+          value: this._myIndex.getValueForItemAtKeyId(item, keyId),
+          searcher
+        });
+        if (matches && matches.length) {
+          return [
+            {
+              idx,
+              item,
+              matches
+            }
+          ];
+        }
+        return [];
+      }
+      const res = [];
+      for (let i = 0, len = node.children.length;i < len; i += 1) {
+        const child = node.children[i];
+        const result = evaluate(child, item, idx);
+        if (result.length) {
+          res.push(...result);
+        } else if (node.operator === LogicalOperator.AND) {
+          return [];
+        }
+      }
+      return res;
+    };
+    const records = this._myIndex.records;
+    const resultMap = {};
+    const results = [];
+    records.forEach(({ $: item, i: idx }) => {
+      if (isDefined(item)) {
+        let expResults = evaluate(expression, item, idx);
+        if (expResults.length) {
+          if (!resultMap[idx]) {
+            resultMap[idx] = { idx, item, matches: [] };
+            results.push(resultMap[idx]);
+          }
+          expResults.forEach(({ matches }) => {
+            resultMap[idx].matches.push(...matches);
+          });
+        }
+      }
+    });
+    return results;
+  }
+  _searchObjectList(query) {
+    const searcher = createSearcher(query, this.options);
+    const { keys, records } = this._myIndex;
+    const results = [];
+    records.forEach(({ $: item, i: idx }) => {
+      if (!isDefined(item)) {
+        return;
+      }
+      let matches = [];
+      keys.forEach((key, keyIndex) => {
+        matches.push(...this._findMatches({
+          key,
+          value: item[keyIndex],
+          searcher
+        }));
+      });
+      if (matches.length) {
+        results.push({
+          idx,
+          item,
+          matches
+        });
+      }
+    });
+    return results;
+  }
+  _findMatches({ key, value, searcher }) {
+    if (!isDefined(value)) {
+      return [];
+    }
+    let matches = [];
+    if (isArray(value)) {
+      value.forEach(({ v: text, i: idx, n: norm2 }) => {
+        if (!isDefined(text)) {
+          return;
+        }
+        const { isMatch, score, indices } = searcher.searchIn(text);
+        if (isMatch) {
+          matches.push({
+            score,
+            key,
+            value: text,
+            idx,
+            norm: norm2,
+            indices
+          });
+        }
+      });
+    } else {
+      const { v: text, n: norm2 } = value;
+      const { isMatch, score, indices } = searcher.searchIn(text);
+      if (isMatch) {
+        matches.push({ score, key, value: text, norm: norm2, indices });
+      }
+    }
+    return matches;
+  }
+}
+Fuse.version = "7.1.0";
+Fuse.createIndex = createIndex;
+Fuse.parseIndex = parseIndex;
+Fuse.config = Config;
+{
+  Fuse.parseQuery = parse;
+}
+{
+  register(ExtendedSearch);
+}
+
+// ../core/src/lib/search.ts
+var FUSE_OPTIONS = {
+  keys: [
+    { name: "frontmatter.title", weight: 1 },
+    { name: "frontmatter.description", weight: 0.7 },
+    { name: "frontmatter.labels", weight: 0.5 },
+    { name: "content", weight: 0.3 }
+  ],
+  threshold: 0.4,
+  ignoreLocation: true,
+  includeScore: true
+};
+function createSearchIndex(issues) {
+  return new Fuse(issues, FUSE_OPTIONS);
+}
+function sortIssues(issues, sortBy) {
+  const sortOption = sortBy.toLowerCase();
+  if (sortOption === "roadmap") {
+    issues.sort((a, b) => {
+      const orderA = a.frontmatter.order;
+      const orderB = b.frontmatter.order;
+      if (orderA && orderB)
+        return orderA < orderB ? -1 : orderA > orderB ? 1 : 0;
+      if (orderA && !orderB)
+        return -1;
+      if (!orderA && orderB)
+        return 1;
+      return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+    });
+  } else if (sortOption === "priority") {
+    const priorityOrder = {
+      high: 0,
+      medium: 1,
+      low: 2
+    };
+    issues.sort((a, b) => {
+      const priorityA = priorityOrder[a.frontmatter.priority] ?? 999;
+      const priorityB = priorityOrder[b.frontmatter.priority] ?? 999;
+      if (priorityA !== priorityB)
+        return priorityA - priorityB;
+      return b.id.localeCompare(a.id);
+    });
+  } else if (sortOption === "scope") {
+    const scopeOrder = {
+      small: 0,
+      medium: 1,
+      large: 2
+    };
+    issues.sort((a, b) => {
+      const scopeA = a.frontmatter.scope ? scopeOrder[a.frontmatter.scope] ?? 99 : 99;
+      const scopeB = b.frontmatter.scope ? scopeOrder[b.frontmatter.scope] ?? 99 : 99;
+      if (scopeA !== scopeB)
+        return scopeA - scopeB;
+      return b.id.localeCompare(a.id);
+    });
+  } else if (sortOption === "created") {
+    issues.sort((a, b) => {
+      const dateA = a.frontmatter.created || "";
+      const dateB = b.frontmatter.created || "";
+      if (dateA !== dateB)
+        return dateB.localeCompare(dateA);
+      return b.id.localeCompare(a.id);
+    });
+  } else if (sortOption === "created-asc") {
+    issues.sort((a, b) => {
+      const dateA = a.frontmatter.created || "";
+      const dateB = b.frontmatter.created || "";
+      if (dateA !== dateB)
+        return dateA.localeCompare(dateB);
+      return a.id.localeCompare(b.id);
+    });
+  } else if (sortOption === "updated") {
+    issues.sort((a, b) => {
+      const dateA = a.frontmatter.updated || a.frontmatter.created || "";
+      const dateB = b.frontmatter.updated || b.frontmatter.created || "";
+      if (dateA !== dateB)
+        return dateB.localeCompare(dateA);
+      return b.id.localeCompare(a.id);
+    });
+  } else if (sortOption === "id") {
+    issues.sort((a, b) => b.id.localeCompare(a.id));
+  } else {
+    issues.sort((a, b) => {
+      const orderA = a.frontmatter.order;
+      const orderB = b.frontmatter.order;
+      if (orderA && orderB)
+        return orderA < orderB ? -1 : orderA > orderB ? 1 : 0;
+      if (orderA && !orderB)
+        return -1;
+      if (!orderA && orderB)
+        return 1;
+      return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+    });
+  }
+}
+function filterByQuery(issues, query) {
+  const parsed = parseQuery(query);
+  let result = issues.filter((issue) => {
+    if (parsed.qualifiers.is) {
+      const statusValue = parsed.qualifiers.is.toLowerCase();
+      if (statusValue === "open" || statusValue === "closed") {
+        if (issue.frontmatter.status !== statusValue) {
+          return false;
+        }
+      }
+    }
+    if (parsed.qualifiers.priority) {
+      const priorityValue = parsed.qualifiers.priority.toLowerCase();
+      if (priorityValue === "high" || priorityValue === "medium" || priorityValue === "low") {
+        if (issue.frontmatter.priority !== priorityValue) {
+          return false;
+        }
+      }
+    }
+    if (parsed.qualifiers.scope) {
+      const scopeValue = parsed.qualifiers.scope.toLowerCase();
+      if (scopeValue === "small" || scopeValue === "medium" || scopeValue === "large") {
+        if (issue.frontmatter.scope !== scopeValue) {
+          return false;
+        }
+      }
+    }
+    if (parsed.qualifiers.type) {
+      const typeValue = parsed.qualifiers.type.toLowerCase();
+      if (typeValue === "bug" || typeValue === "improvement") {
+        if (issue.frontmatter.type !== typeValue) {
+          return false;
+        }
+      }
+    }
+    if (parsed.qualifiers.label) {
+      const labelQuery = parsed.qualifiers.label.toLowerCase();
+      const issueLabels = (issue.frontmatter.labels || "").toLowerCase();
+      if (!issueLabels.includes(labelQuery)) {
+        return false;
+      }
+    }
+    return true;
+  });
+  if (!parsed.searchText.trim()) {
+    const sortBy = parsed.qualifiers.sort?.toLowerCase() || "roadmap";
+    sortIssues(result, sortBy);
+  }
+  if (parsed.searchText.trim()) {
+    const searchQuery = parsed.searchText.trim();
+    const idMatches = [];
+    const nonIdMatches = [];
+    const normalizedQuery = searchQuery.replace(/^0+/, "");
+    for (const issue of result) {
+      const normalizedId = issue.id.replace(/^0+/, "");
+      if (normalizedId.startsWith(normalizedQuery) || issue.id.startsWith(searchQuery)) {
+        idMatches.push(issue);
+      }
+    }
+    const fuse = createSearchIndex(result);
+    const searchResults = fuse.search(searchQuery);
+    const matchedIds = new Set(searchResults.map((r) => r.item.id));
+    const idMatchSet = new Set(idMatches.map((i) => i.id));
+    for (const issue of result) {
+      if (!idMatchSet.has(issue.id) && matchedIds.has(issue.id)) {
+        nonIdMatches.push(issue);
+      }
+    }
+    nonIdMatches.sort((a, b) => {
+      const aScore = searchResults.find((r) => r.item.id === a.id)?.score ?? 1;
+      const bScore = searchResults.find((r) => r.item.id === b.id)?.score ?? 1;
+      return aScore - bScore;
+    });
+    result = [...idMatches, ...nonIdMatches];
+  }
+  return result;
+}
+// src/main.ts
+var args = process.argv.slice(2);
+if (args[0] === "--version" || args[0] === "-v") {
+  console.log(`issy v${process.env.ISSY_PKG_VERSION || "unknown"}`);
+  process.exit(0);
+}
+var issyDir2 = resolveIssyDir();
+var issuesDir2 = join2(issyDir2, "issues");
+process.env.ISSY_DIR = issyDir2;
+process.env.ISSY_ROOT = dirname2(issyDir2);
+var legacyDir = findLegacyIssuesDirUpward(process.env.ISSY_ROOT || process.cwd());
+if (legacyDir && args[0] !== "migrate" && args[0] !== "init") {
+  if (!existsSync2(issyDir2)) {
+    console.warn(`⚠️  Legacy .issues/ directory detected at ${legacyDir}`);
+    console.warn(`   Run "issy migrate" to upgrade to the new .issy/ structure.
+`);
+  }
+}
+var CLI_COMMANDS = new Set([
+  "list",
+  "search",
+  "read",
+  "create",
+  "update",
+  "close",
+  "reopen",
+  "next",
+  "help",
+  "--help",
+  "-h"
+]);
+if (args[0] === "migrate") {
+  migrate();
+} else if (args[0] === "init") {
+  init();
+} else if (CLI_COMMANDS.has(args[0] || "")) {
+  const dir = dirname2(fileURLToPath(import.meta.url));
+  const cli = await import(resolve2(dir, "cli.js"));
+  await cli.ready;
+  process.exit(0);
+} else {
+  const portIdx = args.findIndex((arg) => arg === "--port" || arg === "-p");
+  if (portIdx >= 0 && args[portIdx + 1]) {
+    process.env.ISSUES_PORT = args[portIdx + 1];
+  }
+  await import("@miketromba/issy-app");
+}
+function migrate() {
+  const startDir = process.env.ISSY_ROOT || process.cwd();
+  const legacy = findLegacyIssuesDirUpward(startDir);
+  if (!legacy) {
+    console.log("No legacy .issues/ directory found. Nothing to migrate.");
+    process.exit(0);
+  }
+  if (existsSync2(issyDir2) && existsSync2(issuesDir2)) {
+    console.log(".issy/issues/ already exists. Migration may have already been completed.");
+    process.exit(1);
+  }
+  console.log(`Migrating ${legacy} → ${issuesDir2}`);
+  mkdirSync(issuesDir2, { recursive: true });
+  const files = readdirSync(legacy).filter((f) => f.endsWith(".md") && /^\d{4}-/.test(f));
+  const issueData = files.map((f) => {
+    const content = readFileSync(join2(legacy, f), "utf-8");
+    const { frontmatter } = parseFrontmatter(content);
+    return { filename: f, content, frontmatter };
+  }).sort((a, b) => a.filename.localeCompare(b.filename));
+  const openIssues = issueData.filter((i) => i.frontmatter.status === "open");
+  const orderKeys = generateBatchOrderKeys(openIssues.length);
+  const orderMap = new Map;
+  openIssues.forEach((issue, idx) => {
+    orderMap.set(issue.filename, orderKeys[idx]);
+  });
+  for (const issue of issueData) {
+    let content = issue.content;
+    const orderKey = orderMap.get(issue.filename);
+    if (orderKey) {
+      content = content.replace(/^(---\n[\s\S]*?)(status: \w+)/m, `$1$2
+order: ${orderKey}`);
+    }
+    writeFileSync(join2(issuesDir2, issue.filename), content);
+  }
+  const otherFiles = readdirSync(legacy).filter((f) => !files.includes(f));
+  for (const f of otherFiles) {
+    try {
+      cpSync(join2(legacy, f), join2(issuesDir2, f), { recursive: true });
+    } catch {}
+  }
+  rmSync(legacy, { recursive: true });
+  console.log(`✅ Migrated ${files.length} issue(s) to ${issuesDir2}`);
+  if (openIssues.length > 0) {
+    console.log(`   Assigned roadmap order to ${openIssues.length} open issue(s).`);
+  }
+  console.log(`   Removed ${legacy}`);
+  process.exit(0);
+}
+function init() {
+  const shouldSeed = args.includes("--seed");
+  if (!existsSync2(issuesDir2)) {
+    mkdirSync(issuesDir2, { recursive: true });
+  }
+  if (shouldSeed) {
+    const hasIssues = existsSync2(issuesDir2) && readdirSync(issuesDir2).some((f) => f.endsWith(".md"));
+    if (!hasIssues) {
+      const firstOrderKey = computeOrderKey([], {});
+      const welcome = `---
+title: Welcome to issy
+description: Your first issue in this repo
+priority: medium
+type: improvement
+status: open
+order: ${firstOrderKey}
+created: ${new Date().toISOString().slice(0, 19)}
+---
+
+## Details
+
+- This issue was created automatically on first run.
+- Edit it, close it, or delete it to get started.
+`;
+      writeFileSync(join2(issuesDir2, "0001-welcome-to-issy.md"), welcome);
+    }
+  }
+  console.log(`Initialized ${issyDir2}`);
+  process.exit(0);
+}