@ncukondo/reference-manager 0.16.0 → 0.16.1

package/dist/chunks/format-BPeCbpFG.js

@@ -0,0 +1,924 @@
+import { j as jsxRuntimeExports } from "./jsx-runtime-Q5cUjSur.js";
+import { useFocus, useStdout, useInput, Box, Text } from "ink";
+import { useState, useMemo, useEffect, useCallback } from "react";
+const ANSI_BACKGROUND_OFFSET = 10;
+const wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
+const wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+const wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+const styles = {
+  modifier: {
+    reset: [0, 0],
+    // 21 isn't widely supported and 22 does the same thing
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    overline: [53, 55],
+    inverse: [7, 27],
+    hidden: [8, 28],
+    strikethrough: [9, 29]
+  },
+  color: {
+    black: [30, 39],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    white: [37, 39],
+    // Bright color
+    blackBright: [90, 39],
+    gray: [90, 39],
+    // Alias of `blackBright`
+    grey: [90, 39],
+    // Alias of `blackBright`
+    redBright: [91, 39],
+    greenBright: [92, 39],
+    yellowBright: [93, 39],
+    blueBright: [94, 39],
+    magentaBright: [95, 39],
+    cyanBright: [96, 39],
+    whiteBright: [97, 39]
+  },
+  bgColor: {
+    bgBlack: [40, 49],
+    bgRed: [41, 49],
+    bgGreen: [42, 49],
+    bgYellow: [43, 49],
+    bgBlue: [44, 49],
+    bgMagenta: [45, 49],
+    bgCyan: [46, 49],
+    bgWhite: [47, 49],
+    // Bright color
+    bgBlackBright: [100, 49],
+    bgGray: [100, 49],
+    // Alias of `bgBlackBright`
+    bgGrey: [100, 49],
+    // Alias of `bgBlackBright`
+    bgRedBright: [101, 49],
+    bgGreenBright: [102, 49],
+    bgYellowBright: [103, 49],
+    bgBlueBright: [104, 49],
+    bgMagentaBright: [105, 49],
+    bgCyanBright: [106, 49],
+    bgWhiteBright: [107, 49]
+  }
+};
+Object.keys(styles.modifier);
+const foregroundColorNames = Object.keys(styles.color);
+const backgroundColorNames = Object.keys(styles.bgColor);
+[...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+  const codes = /* @__PURE__ */ new Map();
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
+      };
+      group[styleName] = styles[styleName];
+      codes.set(style[0], style[1]);
+    }
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
+    });
+  }
+  Object.defineProperty(styles, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer = Number.parseInt(colorString, 16);
+        return [
+          /* eslint-disable no-bitwise */
+          integer >> 16 & 255,
+          integer >> 8 & 255,
+          integer & 255
+          /* eslint-enable no-bitwise */
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+      enumerable: false
+    }
+  });
+  return styles;
+}
+const ansiStyles = assembleStyles();
+function isAmbiguous(x) {
+  return x === 161 || x === 164 || x === 167 || x === 168 || x === 170 || x === 173 || x === 174 || x >= 176 && x <= 180 || x >= 182 && x <= 186 || x >= 188 && x <= 191 || x === 198 || x === 208 || x === 215 || x === 216 || x >= 222 && x <= 225 || x === 230 || x >= 232 && x <= 234 || x === 236 || x === 237 || x === 240 || x === 242 || x === 243 || x >= 247 && x <= 250 || x === 252 || x === 254 || x === 257 || x === 273 || x === 275 || x === 283 || x === 294 || x === 295 || x === 299 || x >= 305 && x <= 307 || x === 312 || x >= 319 && x <= 322 || x === 324 || x >= 328 && x <= 331 || x === 333 || x === 338 || x === 339 || x === 358 || x === 359 || x === 363 || x === 462 || x === 464 || x === 466 || x === 468 || x === 470 || x === 472 || x === 474 || x === 476 || x === 593 || x === 609 || x === 708 || x === 711 || x >= 713 && x <= 715 || x === 717 || x === 720 || x >= 728 && x <= 731 || x === 733 || x === 735 || x >= 768 && x <= 879 || x >= 913 && x <= 929 || x >= 931 && x <= 937 || x >= 945 && x <= 961 || x >= 963 && x <= 969 || x === 1025 || x >= 1040 && x <= 1103 || x === 1105 || x === 8208 || x >= 8211 && x <= 8214 || x === 8216 || x === 8217 || x === 8220 || x === 8221 || x >= 8224 && x <= 8226 || x >= 8228 && x <= 8231 || x === 8240 || x === 8242 || x === 8243 || x === 8245 || x === 8251 || x === 8254 || x === 8308 || x === 8319 || x >= 8321 && x <= 8324 || x === 8364 || x === 8451 || x === 8453 || x === 8457 || x === 8467 || x === 8470 || x === 8481 || x === 8482 || x === 8486 || x === 8491 || x === 8531 || x === 8532 || x >= 8539 && x <= 8542 || x >= 8544 && x <= 8555 || x >= 8560 && x <= 8569 || x === 8585 || x >= 8592 && x <= 8601 || x === 8632 || x === 8633 || x === 8658 || x === 8660 || x === 8679 || x === 8704 || x === 8706 || x === 8707 || x === 8711 || x === 8712 || x === 8715 || x === 8719 || x === 8721 || x === 8725 || x === 8730 || x >= 8733 && x <= 8736 || x === 8739 || x === 8741 || x >= 8743 && x <= 8748 || x === 8750 || x >= 8756 && x <= 8759 || x === 8764 || x === 8765 || x === 8776 || x === 8780 || x === 8786 || x === 8800 || x === 8801 || x >= 8804 && x <= 8807 || x === 8810 || x === 8811 || x === 8814 || x === 8815 || x === 8834 || x === 8835 || x === 8838 || x === 8839 || x === 8853 || x === 8857 || x === 8869 || x === 8895 || x === 8978 || x >= 9312 && x <= 9449 || x >= 9451 && x <= 9547 || x >= 9552 && x <= 9587 || x >= 9600 && x <= 9615 || x >= 9618 && x <= 9621 || x === 9632 || x === 9633 || x >= 9635 && x <= 9641 || x === 9650 || x === 9651 || x === 9654 || x === 9655 || x === 9660 || x === 9661 || x === 9664 || x === 9665 || x >= 9670 && x <= 9672 || x === 9675 || x >= 9678 && x <= 9681 || x >= 9698 && x <= 9701 || x === 9711 || x === 9733 || x === 9734 || x === 9737 || x === 9742 || x === 9743 || x === 9756 || x === 9758 || x === 9792 || x === 9794 || x === 9824 || x === 9825 || x >= 9827 && x <= 9829 || x >= 9831 && x <= 9834 || x === 9836 || x === 9837 || x === 9839 || x === 9886 || x === 9887 || x === 9919 || x >= 9926 && x <= 9933 || x >= 9935 && x <= 9939 || x >= 9941 && x <= 9953 || x === 9955 || x === 9960 || x === 9961 || x >= 9963 && x <= 9969 || x === 9972 || x >= 9974 && x <= 9977 || x === 9979 || x === 9980 || x === 9982 || x === 9983 || x === 10045 || x >= 10102 && x <= 10111 || x >= 11094 && x <= 11097 || x >= 12872 && x <= 12879 || x >= 57344 && x <= 63743 || x >= 65024 && x <= 65039 || x === 65533 || x >= 127232 && x <= 127242 || x >= 127248 && x <= 127277 || x >= 127280 && x <= 127337 || x >= 127344 && x <= 127373 || x === 127375 || x === 127376 || x >= 127387 && x <= 127404 || x >= 917760 && x <= 917999 || x >= 983040 && x <= 1048573 || x >= 1048576 && x <= 1114109;
+}
+function isFullWidth(x) {
+  return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 65510;
+}
+function isWide(x) {
+  return x >= 4352 && x <= 4447 || x === 8986 || x === 8987 || x === 9001 || x === 9002 || x >= 9193 && x <= 9196 || x === 9200 || x === 9203 || x === 9725 || x === 9726 || x === 9748 || x === 9749 || x >= 9776 && x <= 9783 || x >= 9800 && x <= 9811 || x === 9855 || x >= 9866 && x <= 9871 || x === 9875 || x === 9889 || x === 9898 || x === 9899 || x === 9917 || x === 9918 || x === 9924 || x === 9925 || x === 9934 || x === 9940 || x === 9962 || x === 9970 || x === 9971 || x === 9973 || x === 9978 || x === 9981 || x === 9989 || x === 9994 || x === 9995 || x === 10024 || x === 10060 || x === 10062 || x >= 10067 && x <= 10069 || x === 10071 || x >= 10133 && x <= 10135 || x === 10160 || x === 10175 || x === 11035 || x === 11036 || x === 11088 || x === 11093 || x >= 11904 && x <= 11929 || x >= 11931 && x <= 12019 || x >= 12032 && x <= 12245 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12353 && x <= 12438 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12773 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 42124 || x >= 42128 && x <= 42182 || x >= 43360 && x <= 43388 || x >= 44032 && x <= 55203 || x >= 63744 && x <= 64255 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 94176 && x <= 94180 || x >= 94192 && x <= 94198 || x >= 94208 && x <= 101589 || x >= 101631 && x <= 101662 || x >= 101760 && x <= 101874 || x >= 110576 && x <= 110579 || x >= 110581 && x <= 110587 || x === 110589 || x === 110590 || x >= 110592 && x <= 110882 || x === 110898 || x >= 110928 && x <= 110930 || x === 110933 || x >= 110948 && x <= 110951 || x >= 110960 && x <= 111355 || x >= 119552 && x <= 119638 || x >= 119648 && x <= 119670 || x === 126980 || x === 127183 || x === 127374 || x >= 127377 && x <= 127386 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x === 127568 || x === 127569 || x >= 127584 && x <= 127589 || x >= 127744 && x <= 127776 || x >= 127789 && x <= 127797 || x >= 127799 && x <= 127868 || x >= 127870 && x <= 127891 || x >= 127904 && x <= 127946 || x >= 127951 && x <= 127955 || x >= 127968 && x <= 127984 || x === 127988 || x >= 127992 && x <= 128062 || x === 128064 || x >= 128066 && x <= 128252 || x >= 128255 && x <= 128317 || x >= 128331 && x <= 128334 || x >= 128336 && x <= 128359 || x === 128378 || x === 128405 || x === 128406 || x === 128420 || x >= 128507 && x <= 128591 || x >= 128640 && x <= 128709 || x === 128716 || x >= 128720 && x <= 128722 || x >= 128725 && x <= 128728 || x >= 128732 && x <= 128735 || x === 128747 || x === 128748 || x >= 128756 && x <= 128764 || x >= 128992 && x <= 129003 || x === 129008 || x >= 129292 && x <= 129338 || x >= 129340 && x <= 129349 || x >= 129351 && x <= 129535 || x >= 129648 && x <= 129660 || x >= 129664 && x <= 129674 || x >= 129678 && x <= 129734 || x === 129736 || x >= 129741 && x <= 129756 || x >= 129759 && x <= 129770 || x >= 129775 && x <= 129784 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141;
+}
+function validate(codePoint) {
+  if (!Number.isSafeInteger(codePoint)) {
+    throw new TypeError(`Expected a code point, got \`${typeof codePoint}\`.`);
+  }
+}
+function eastAsianWidth(codePoint, { ambiguousAsWide = false } = {}) {
+  validate(codePoint);
+  if (isFullWidth(codePoint) || isWide(codePoint) || ambiguousAsWide && isAmbiguous(codePoint)) {
+    return 2;
+  }
+  return 1;
+}
+function isFullwidthCodePoint(codePoint) {
+  if (!Number.isInteger(codePoint)) {
+    return false;
+  }
+  return isFullWidth(codePoint) || isWide(codePoint);
+}
+const ESCAPES = /* @__PURE__ */ new Set([27, 155]);
+const CODE_POINT_0 = "0".codePointAt(0);
+const CODE_POINT_9 = "9".codePointAt(0);
+const MAX_ANSI_SEQUENCE_LENGTH = 19;
+const endCodesSet = /* @__PURE__ */ new Set();
+const endCodesMap = /* @__PURE__ */ new Map();
+for (const [start, end] of ansiStyles.codes) {
+  endCodesSet.add(ansiStyles.color.ansi(end));
+  endCodesMap.set(ansiStyles.color.ansi(start), ansiStyles.color.ansi(end));
+}
+function getEndCode(code) {
+  if (endCodesSet.has(code)) {
+    return code;
+  }
+  if (endCodesMap.has(code)) {
+    return endCodesMap.get(code);
+  }
+  code = code.slice(2);
+  if (code.includes(";")) {
+    code = code[0] + "0";
+  }
+  const returnValue = ansiStyles.codes.get(Number.parseInt(code, 10));
+  if (returnValue) {
+    return ansiStyles.color.ansi(returnValue);
+  }
+  return ansiStyles.reset.open;
+}
+function findNumberIndex(string) {
+  for (let index = 0; index < string.length; index++) {
+    const codePoint = string.codePointAt(index);
+    if (codePoint >= CODE_POINT_0 && codePoint <= CODE_POINT_9) {
+      return index;
+    }
+  }
+  return -1;
+}
+function parseAnsiCode(string, offset) {
+  string = string.slice(offset, offset + MAX_ANSI_SEQUENCE_LENGTH);
+  const startIndex = findNumberIndex(string);
+  if (startIndex !== -1) {
+    let endIndex = string.indexOf("m", startIndex);
+    if (endIndex === -1) {
+      endIndex = string.length;
+    }
+    return string.slice(0, endIndex + 1);
+  }
+}
+function tokenize(string, endCharacter = Number.POSITIVE_INFINITY) {
+  const returnValue = [];
+  let index = 0;
+  let visibleCount = 0;
+  while (index < string.length) {
+    const codePoint = string.codePointAt(index);
+    if (ESCAPES.has(codePoint)) {
+      const code = parseAnsiCode(string, index);
+      if (code) {
+        returnValue.push({
+          type: "ansi",
+          code,
+          endCode: getEndCode(code)
+        });
+        index += code.length;
+        continue;
+      }
+    }
+    const isFullWidth2 = isFullwidthCodePoint(codePoint);
+    const character = String.fromCodePoint(codePoint);
+    returnValue.push({
+      type: "character",
+      value: character,
+      isFullWidth: isFullWidth2
+    });
+    index += character.length;
+    visibleCount += isFullWidth2 ? 2 : character.length;
+    if (visibleCount >= endCharacter) {
+      break;
+    }
+  }
+  return returnValue;
+}
+function reduceAnsiCodes(codes) {
+  let returnValue = [];
+  for (const code of codes) {
+    if (code.code === ansiStyles.reset.open) {
+      returnValue = [];
+    } else if (endCodesSet.has(code.code)) {
+      returnValue = returnValue.filter((returnValueCode) => returnValueCode.endCode !== code.code);
+    } else {
+      returnValue = returnValue.filter((returnValueCode) => returnValueCode.endCode !== code.endCode);
+      returnValue.push(code);
+    }
+  }
+  return returnValue;
+}
+function undoAnsiCodes(codes) {
+  const reduced = reduceAnsiCodes(codes);
+  const endCodes = reduced.map(({ endCode }) => endCode);
+  return endCodes.reverse().join("");
+}
+function sliceAnsi(string, start, end) {
+  const tokens = tokenize(string, end);
+  let activeCodes = [];
+  let position = 0;
+  let returnValue = "";
+  let include = false;
+  for (const token of tokens) {
+    if (end !== void 0 && position >= end) {
+      break;
+    }
+    if (token.type === "ansi") {
+      activeCodes.push(token);
+      if (include) {
+        returnValue += token.code;
+      }
+    } else {
+      if (!include && position >= start) {
+        include = true;
+        activeCodes = reduceAnsiCodes(activeCodes);
+        returnValue = activeCodes.map(({ code }) => code).join("");
+      }
+      if (include) {
+        returnValue += token.value;
+      }
+      position += token.isFullWidth ? 2 : token.value.length;
+    }
+  }
+  returnValue += undoAnsiCodes(activeCodes);
+  return returnValue;
+}
+function ansiRegex({ onlyFirst = false } = {}) {
+  const ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
+  const osc = `(?:\\u001B\\][\\s\\S]*?${ST})`;
+  const csi = "[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]";
+  const pattern = `${osc}|${csi}`;
+  return new RegExp(pattern, onlyFirst ? void 0 : "g");
+}
+const regex = ansiRegex();
+function stripAnsi(string) {
+  if (typeof string !== "string") {
+    throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
+  }
+  return string.replace(regex, "");
+}
+const segmenter = new Intl.Segmenter();
+const zeroWidthClusterRegex = new RegExp("^(?:\\p{Default_Ignorable_Code_Point}|\\p{Control}|\\p{Mark}|\\p{Surrogate})+$", "v");
+const leadingNonPrintingRegex = new RegExp("^[\\p{Default_Ignorable_Code_Point}\\p{Control}\\p{Format}\\p{Mark}\\p{Surrogate}]+", "v");
+const rgiEmojiRegex = new RegExp("^\\p{RGI_Emoji}$", "v");
+function baseVisible(segment) {
+  return segment.replace(leadingNonPrintingRegex, "");
+}
+function isZeroWidthCluster(segment) {
+  return zeroWidthClusterRegex.test(segment);
+}
+function trailingHalfwidthWidth(segment, eastAsianWidthOptions) {
+  let extra = 0;
+  if (segment.length > 1) {
+    for (const char of segment.slice(1)) {
+      if (char >= "＀" && char <= "￯") {
+        extra += eastAsianWidth(char.codePointAt(0), eastAsianWidthOptions);
+      }
+    }
+  }
+  return extra;
+}
+function stringWidth(input, options = {}) {
+  if (typeof input !== "string" || input.length === 0) {
+    return 0;
+  }
+  const {
+    ambiguousIsNarrow = true,
+    countAnsiEscapeCodes = false
+  } = options;
+  let string = input;
+  if (!countAnsiEscapeCodes) {
+    string = stripAnsi(string);
+  }
+  if (string.length === 0) {
+    return 0;
+  }
+  let width = 0;
+  const eastAsianWidthOptions = { ambiguousAsWide: !ambiguousIsNarrow };
+  for (const { segment } of segmenter.segment(string)) {
+    if (isZeroWidthCluster(segment)) {
+      continue;
+    }
+    if (rgiEmojiRegex.test(segment)) {
+      width += 2;
+      continue;
+    }
+    const codePoint = baseVisible(segment).codePointAt(0);
+    width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+    width += trailingHalfwidthWidth(segment, eastAsianWidthOptions);
+  }
+  return width;
+}
+function getIndexOfNearestSpace(string, wantedIndex, shouldSearchRight) {
+  if (string.charAt(wantedIndex) === " ") {
+    return wantedIndex;
+  }
+  const direction = shouldSearchRight ? 1 : -1;
+  for (let index = 0; index <= 3; index++) {
+    const finalIndex = wantedIndex + index * direction;
+    if (string.charAt(finalIndex) === " ") {
+      return finalIndex;
+    }
+  }
+  return wantedIndex;
+}
+function cliTruncate(text, columns, options = {}) {
+  const {
+    position = "end",
+    space = false,
+    preferTruncationOnSpace = false
+  } = options;
+  let { truncationCharacter = "…" } = options;
+  if (typeof text !== "string") {
+    throw new TypeError(`Expected \`input\` to be a string, got ${typeof text}`);
+  }
+  if (typeof columns !== "number") {
+    throw new TypeError(`Expected \`columns\` to be a number, got ${typeof columns}`);
+  }
+  if (columns < 1) {
+    return "";
+  }
+  const length = stringWidth(text);
+  if (length <= columns) {
+    return text;
+  }
+  if (columns === 1) {
+    return truncationCharacter;
+  }
+  const ANSI = {
+    ESC: 27,
+    LEFT_BRACKET: 91,
+    LETTER_M: 109
+  };
+  const isSgrParameter = (code) => code >= 48 && code <= 57 || code === 59;
+  function leadingSgrSpanEndIndex(string) {
+    let index = 0;
+    while (index + 2 < string.length && string.codePointAt(index) === ANSI.ESC && string.codePointAt(index + 1) === ANSI.LEFT_BRACKET) {
+      let j = index + 2;
+      while (j < string.length && isSgrParameter(string.codePointAt(j))) {
+        j++;
+      }
+      if (j < string.length && string.codePointAt(j) === ANSI.LETTER_M) {
+        index = j + 1;
+        continue;
+      }
+      break;
+    }
+    return index;
+  }
+  function trailingSgrSpanStartIndex(string) {
+    let start = string.length;
+    while (start > 1 && string.codePointAt(start - 1) === ANSI.LETTER_M) {
+      let j = start - 2;
+      while (j >= 0 && isSgrParameter(string.codePointAt(j))) {
+        j--;
+      }
+      if (j >= 1 && string.codePointAt(j - 1) === ANSI.ESC && string.codePointAt(j) === ANSI.LEFT_BRACKET) {
+        start = j - 1;
+        continue;
+      }
+      break;
+    }
+    return start;
+  }
+  function appendWithInheritedStyleFromEnd(visible, suffix) {
+    const start = trailingSgrSpanStartIndex(visible);
+    if (start === visible.length) {
+      return visible + suffix;
+    }
+    return visible.slice(0, start) + suffix + visible.slice(start);
+  }
+  function prependWithInheritedStyleFromStart(prefix, visible) {
+    const end = leadingSgrSpanEndIndex(visible);
+    if (end === 0) {
+      return prefix + visible;
+    }
+    return visible.slice(0, end) + prefix + visible.slice(end);
+  }
+  if (position === "start") {
+    if (preferTruncationOnSpace) {
+      const nearestSpace = getIndexOfNearestSpace(text, length - columns + 1, true);
+      const right2 = sliceAnsi(text, nearestSpace, length).trim();
+      return prependWithInheritedStyleFromStart(truncationCharacter, right2);
+    }
+    if (space) {
+      truncationCharacter += " ";
+    }
+    const right = sliceAnsi(text, length - columns + stringWidth(truncationCharacter), length);
+    return prependWithInheritedStyleFromStart(truncationCharacter, right);
+  }
+  if (position === "middle") {
+    if (space) {
+      truncationCharacter = ` ${truncationCharacter} `;
+    }
+    const half = Math.floor(columns / 2);
+    if (preferTruncationOnSpace) {
+      const spaceNearFirstBreakPoint = getIndexOfNearestSpace(text, half);
+      const spaceNearSecondBreakPoint = getIndexOfNearestSpace(text, length - (columns - half) + 1, true);
+      return sliceAnsi(text, 0, spaceNearFirstBreakPoint) + truncationCharacter + sliceAnsi(text, spaceNearSecondBreakPoint, length).trim();
+    }
+    return sliceAnsi(text, 0, half) + truncationCharacter + sliceAnsi(text, length - (columns - half) + stringWidth(truncationCharacter), length);
+  }
+  if (position === "end") {
+    if (preferTruncationOnSpace) {
+      const nearestSpace = getIndexOfNearestSpace(text, columns - 1);
+      const left2 = sliceAnsi(text, 0, nearestSpace);
+      return appendWithInheritedStyleFromEnd(left2, truncationCharacter);
+    }
+    if (space) {
+      truncationCharacter = ` ${truncationCharacter}`;
+    }
+    const left = sliceAnsi(text, 0, columns - stringWidth(truncationCharacter));
+    return appendWithInheritedStyleFromEnd(left, truncationCharacter);
+  }
+  throw new Error(`Expected \`options.position\` to be either \`start\`, \`middle\` or \`end\`, got ${position}`);
+}
+const SORT_OPTIONS = [
+  { id: "updated-desc", label: "Updated (newest first)", requiresQuery: false },
+  { id: "updated-asc", label: "Updated (oldest first)", requiresQuery: false },
+  { id: "created-desc", label: "Created (newest first)", requiresQuery: false },
+  { id: "created-asc", label: "Created (oldest first)", requiresQuery: false },
+  { id: "published-desc", label: "Published (newest first)", requiresQuery: false },
+  { id: "published-asc", label: "Published (oldest first)", requiresQuery: false },
+  { id: "relevance", label: "Relevance", requiresQuery: true }
+];
+function getSortShortLabel(sortOption) {
+  switch (sortOption) {
+    case "updated-desc":
+      return "Updated ↓";
+    case "updated-asc":
+      return "Updated ↑";
+    case "created-desc":
+      return "Created ↓";
+    case "created-asc":
+      return "Created ↑";
+    case "published-desc":
+      return "Published ↓";
+    case "published-asc":
+      return "Published ↑";
+    case "relevance":
+      return "Relevance";
+  }
+}
+function createDateComparator(getDate, descending) {
+  return (a, b) => {
+    const dateA = getDate(a)?.getTime() ?? 0;
+    const dateB = getDate(b)?.getTime() ?? 0;
+    return descending ? dateB - dateA : dateA - dateB;
+  };
+}
+function sortChoices(choices, sortOption) {
+  if (sortOption === "relevance") return [...choices];
+  const sorted = [...choices];
+  const comparators = {
+    "updated-desc": createDateComparator((c) => c.updatedDate, true),
+    "updated-asc": createDateComparator((c) => c.updatedDate, false),
+    "created-desc": createDateComparator((c) => c.createdDate, true),
+    "created-asc": createDateComparator((c) => c.createdDate, false),
+    "published-desc": createDateComparator((c) => c.publishedDate, true),
+    "published-asc": createDateComparator((c) => c.publishedDate, false)
+  };
+  return sorted.sort(comparators[sortOption]);
+}
+function defaultFilter(query, choices) {
+  if (!query.trim()) return choices;
+  const lowerQuery = query.toLowerCase();
+  return choices.filter(
+    (choice) => choice.title.toLowerCase().includes(lowerQuery) || choice.subtitle?.toLowerCase().includes(lowerQuery) || choice.meta?.toLowerCase().includes(lowerQuery)
+  );
+}
+function truncate(text, maxWidth) {
+  return cliTruncate(text, maxWidth, { position: "end" });
+}
+function getNavigationDelta(key, input, visibleCount, maxIndex) {
+  if (key.upArrow) return -1;
+  if (key.downArrow) return 1;
+  if (key.pageUp) return -visibleCount;
+  if (key.pageDown) return visibleCount;
+  if (key.ctrl && input === "a") return -maxIndex - 1;
+  if (key.ctrl && input === "e") return maxIndex + 1;
+  return null;
+}
+function parseKeyAction(input, key, visibleCount, maxIndex) {
+  if (key.escape) return { type: "cancel" };
+  if (key.return) return { type: "submit" };
+  const navDelta = getNavigationDelta(key, input, visibleCount, maxIndex);
+  if (navDelta !== null) return { type: "navigate", delta: navDelta };
+  if (key.ctrl && input === "s") return { type: "sort" };
+  if (key.tab) return { type: "toggle" };
+  if (key.backspace || key.delete) return { type: "backspace" };
+  if (input && !key.ctrl && !key.meta) return { type: "input", char: input };
+  return { type: "none" };
+}
+function ChoiceItem({
+  choice,
+  isSelected,
+  isFocused,
+  contentWidth
+}) {
+  const indent = "      ";
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs(Box, { flexDirection: "column", paddingY: 0, children: [
+    /* @__PURE__ */ jsxRuntimeExports.jsxs(Box, { flexDirection: "row", children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx(Box, { width: 2, children: /* @__PURE__ */ jsxRuntimeExports.jsx(Text, { color: "cyan", children: isFocused ? "❯" : " " }) }),
+      /* @__PURE__ */ jsxRuntimeExports.jsx(Box, { width: 2, children: /* @__PURE__ */ jsxRuntimeExports.jsx(Text, { color: isSelected ? "green" : "gray", children: isSelected ? "◉" : "○" }) }),
+      /* @__PURE__ */ jsxRuntimeExports.jsx(Box, { width: 1, children: /* @__PURE__ */ jsxRuntimeExports.jsx(Text, { children: " " }) }),
+      /* @__PURE__ */ jsxRuntimeExports.jsx(Box, { children: isFocused ? /* @__PURE__ */ jsxRuntimeExports.jsx(Text, { color: "cyan", bold: true, children: truncate(choice.title, contentWidth) }) : /* @__PURE__ */ jsxRuntimeExports.jsx(Text, { color: "blue", children: truncate(choice.title, contentWidth) }) })
+    ] }),
+    choice.subtitle && /* @__PURE__ */ jsxRuntimeExports.jsx(Box, { children: /* @__PURE__ */ jsxRuntimeExports.jsxs(Text, { dimColor: true, children: [
+      indent,
+      truncate(choice.subtitle, contentWidth)
+    ] }) }),
+    choice.meta && /* @__PURE__ */ jsxRuntimeExports.jsx(Box, { children: /* @__PURE__ */ jsxRuntimeExports.jsxs(Text, { dimColor: true, children: [
+      indent,
+      truncate(choice.meta, contentWidth)
+    ] }) })
+  ] });
+}
+function ScrollIndicator({
+  direction,
+  count,
+  visible
+}) {
+  const arrow = direction === "up" ? "↑" : "↓";
+  const label = direction === "up" ? "more above" : "more below";
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(Box, { height: 1, children: visible && count > 0 ? /* @__PURE__ */ jsxRuntimeExports.jsxs(Text, { dimColor: true, children: [
+    " ",
+    arrow,
+    " ",
+    count,
+    " ",
+    label
+  ] }) : /* @__PURE__ */ jsxRuntimeExports.jsx(Text, { children: " " }) });
+}
+function ChoiceList({
+  choices,
+  selectedIds,
+  focusIndex,
+  scrollOffset,
+  contentWidth
+}) {
+  if (choices.length === 0) {
+    return /* @__PURE__ */ jsxRuntimeExports.jsx(Box, { paddingY: 1, children: /* @__PURE__ */ jsxRuntimeExports.jsx(Text, { dimColor: true, children: "No results found" }) });
+  }
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(Box, { flexDirection: "column", children: choices.map((choice, visibleIndex) => {
+    const actualIndex = scrollOffset + visibleIndex;
+    return /* @__PURE__ */ jsxRuntimeExports.jsx(Box, { flexDirection: "row", children: /* @__PURE__ */ jsxRuntimeExports.jsx(
+      ChoiceItem,
+      {
+        choice,
+        isSelected: selectedIds.has(choice.id),
+        isFocused: actualIndex === focusIndex,
+        contentWidth
+      }
+    ) }, choice.id);
+  }) });
+}
+function SortMenu({
+  options,
+  focusIndex,
+  currentSort
+}) {
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs(
+    Box,
+    {
+      flexDirection: "column",
+      marginBottom: 1,
+      paddingX: 1,
+      borderStyle: "round",
+      borderColor: "yellow",
+      children: [
+        /* @__PURE__ */ jsxRuntimeExports.jsx(Box, { marginBottom: 1, children: /* @__PURE__ */ jsxRuntimeExports.jsx(Text, { bold: true, color: "yellow", children: "Sort by:" }) }),
+        options.map((opt, index) => {
+          const isFocused = index === focusIndex;
+          const isCurrent = opt.id === currentSort;
+          const checkMark = isCurrent ? " ✓" : "";
+          return /* @__PURE__ */ jsxRuntimeExports.jsx(Box, { children: isFocused ? /* @__PURE__ */ jsxRuntimeExports.jsxs(Text, { color: "cyan", children: [
+            "❯ ",
+            opt.label,
+            checkMark
+          ] }) : /* @__PURE__ */ jsxRuntimeExports.jsxs(Text, { children: [
+            "  ",
+            opt.label,
+            checkMark
+          ] }) }, opt.id);
+        }),
+        /* @__PURE__ */ jsxRuntimeExports.jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsxRuntimeExports.jsx(Text, { dimColor: true, children: "↑↓:select Enter:confirm Esc:cancel" }) })
+      ]
+    }
+  );
+}
+function SearchableMultiSelect({
+  choices,
+  filterFn = defaultFilter,
+  visibleCount: visibleCountProp,
+  onSubmit,
+  onCancel,
+  placeholder = "Type to search...",
+  header,
+  footer,
+  defaultSort = "updated-desc"
+}) {
+  const [query, setQuery] = useState("");
+  const [selectedIds, setSelectedIds] = useState(/* @__PURE__ */ new Set());
+  const [focusIndex, setFocusIndex] = useState(0);
+  const [scrollOffset, setScrollOffset] = useState(0);
+  const [sortOption, setSortOption] = useState(defaultSort);
+  const [showSortMenu, setShowSortMenu] = useState(false);
+  const [sortMenuIndex, setSortMenuIndex] = useState(0);
+  const { isFocused } = useFocus({ autoFocus: true });
+  const { stdout } = useStdout();
+  const terminalWidth = stdout?.columns ?? 80;
+  const terminalHeight = stdout?.rows ?? 24;
+  const contentWidth = terminalWidth - 8;
+  const itemHeight = 3;
+  const reservedLines = 10;
+  const calculatedVisibleCount = Math.max(
+    1,
+    Math.floor((terminalHeight - reservedLines) / itemHeight)
+  );
+  const visibleCount = visibleCountProp ?? calculatedVisibleCount;
+  const filteredChoices = useMemo(() => filterFn(query, choices), [query, choices, filterFn]);
+  const availableSortOptions = useMemo(
+    () => SORT_OPTIONS.filter((opt) => !opt.requiresQuery || query.trim().length > 0),
+    [query]
+  );
+  const sortedChoices = useMemo(
+    () => sortOption === "relevance" ? filteredChoices : sortChoices(filteredChoices, sortOption),
+    [filteredChoices, sortOption]
+  );
+  const maxIndex = sortedChoices.length - 1;
+  useEffect(() => {
+    setFocusIndex(0);
+    setScrollOffset(0);
+  }, [query]);
+  useEffect(() => {
+    if (focusIndex < scrollOffset) {
+      setScrollOffset(focusIndex);
+    } else if (focusIndex >= scrollOffset + visibleCount) {
+      setScrollOffset(focusIndex - visibleCount + 1);
+    }
+  }, [focusIndex, scrollOffset, visibleCount]);
+  const visibleChoices = useMemo(
+    () => sortedChoices.slice(scrollOffset, scrollOffset + visibleCount),
+    [sortedChoices, scrollOffset, visibleCount]
+  );
+  const toggleSelection = useCallback(() => {
+    const currentChoice = sortedChoices[focusIndex];
+    if (!currentChoice) return;
+    setSelectedIds((prev) => {
+      const newSet = new Set(prev);
+      if (newSet.has(currentChoice.id)) {
+        newSet.delete(currentChoice.id);
+      } else {
+        newSet.add(currentChoice.id);
+      }
+      return newSet;
+    });
+  }, [sortedChoices, focusIndex]);
+  useInput(
+    (_input, key) => {
+      if (key.escape) {
+        setShowSortMenu(false);
+        return;
+      }
+      if (key.return) {
+        const selected = availableSortOptions[sortMenuIndex];
+        if (selected) {
+          setSortOption(selected.id);
+          setFocusIndex(0);
+          setScrollOffset(0);
+        }
+        setShowSortMenu(false);
+        return;
+      }
+      if (key.upArrow) {
+        setSortMenuIndex((prev) => Math.max(0, prev - 1));
+        return;
+      }
+      if (key.downArrow) {
+        setSortMenuIndex((prev) => Math.min(availableSortOptions.length - 1, prev + 1));
+        return;
+      }
+    },
+    { isActive: isFocused && showSortMenu }
+  );
+  useInput(
+    (input, key) => {
+      const action = parseKeyAction(input, key, visibleCount, maxIndex);
+      switch (action.type) {
+        case "cancel":
+          onCancel();
+          break;
+        case "submit":
+          onSubmit(choices.filter((c) => selectedIds.has(c.id)));
+          break;
+        case "navigate":
+          setFocusIndex((prev) => Math.max(0, Math.min(maxIndex, prev + action.delta)));
+          break;
+        case "toggle":
+          toggleSelection();
+          break;
+        case "backspace":
+          setQuery((prev) => prev.slice(0, -1));
+          break;
+        case "input":
+          setQuery((prev) => prev + action.char);
+          break;
+        case "sort":
+          setSortMenuIndex(availableSortOptions.findIndex((o) => o.id === sortOption));
+          setShowSortMenu(true);
+          break;
+      }
+    },
+    { isActive: isFocused && !showSortMenu }
+  );
+  const totalItems = sortedChoices.length;
+  const showScrollIndicator = totalItems > visibleCount;
+  const footerText = footer ?? (showScrollIndicator ? `↑↓:move Tab:select ^S:sort Enter:confirm (${focusIndex + 1}/${totalItems})` : "↑↓:move Tab:select ^S:sort Enter:confirm Esc:cancel");
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs(Box, { flexDirection: "column", paddingX: 1, children: [
+    header && /* @__PURE__ */ jsxRuntimeExports.jsx(Box, { marginBottom: 1, children: /* @__PURE__ */ jsxRuntimeExports.jsx(Text, { bold: true, color: "cyan", children: header }) }),
+    /* @__PURE__ */ jsxRuntimeExports.jsxs(Box, { marginBottom: 1, paddingX: 1, borderStyle: "round", borderColor: "cyan", children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx(Text, { color: "green", children: "❯ " }),
+      /* @__PURE__ */ jsxRuntimeExports.jsx(Text, { children: query || /* @__PURE__ */ jsxRuntimeExports.jsx(Text, { dimColor: true, children: placeholder }) }),
+      /* @__PURE__ */ jsxRuntimeExports.jsx(Text, { color: "gray", children: "▎" })
+    ] }),
+    /* @__PURE__ */ jsxRuntimeExports.jsxs(Box, { marginBottom: 1, paddingX: 1, justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx(Box, { children: selectedIds.size > 0 ? /* @__PURE__ */ jsxRuntimeExports.jsxs(Text, { color: "yellow", children: [
+        selectedIds.size,
+        " selected / ",
+        totalItems,
+        " results"
+      ] }) : /* @__PURE__ */ jsxRuntimeExports.jsxs(Text, { dimColor: true, children: [
+        totalItems,
+        " results"
+      ] }) }),
+      /* @__PURE__ */ jsxRuntimeExports.jsx(Box, { children: /* @__PURE__ */ jsxRuntimeExports.jsxs(Text, { dimColor: true, children: [
+        "Sort: ",
+        getSortShortLabel(sortOption)
+      ] }) })
+    ] }),
+    /* @__PURE__ */ jsxRuntimeExports.jsx(Box, { flexDirection: "column", height: visibleCount * itemHeight + 2, children: showSortMenu ? /* @__PURE__ */ jsxRuntimeExports.jsx(
+      SortMenu,
+      {
+        options: availableSortOptions,
+        focusIndex: sortMenuIndex,
+        currentSort: sortOption
+      }
+    ) : /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx(ScrollIndicator, { direction: "up", count: scrollOffset, visible: showScrollIndicator }),
+      /* @__PURE__ */ jsxRuntimeExports.jsx(
+        ChoiceList,
+        {
+          choices: visibleChoices,
+          selectedIds,
+          focusIndex,
+          scrollOffset,
+          contentWidth
+        }
+      ),
+      /* @__PURE__ */ jsxRuntimeExports.jsx(
+        ScrollIndicator,
+        {
+          direction: "down",
+          count: totalItems - scrollOffset - visibleCount,
+          visible: showScrollIndicator
+        }
+      )
+    ] }) }),
+    /* @__PURE__ */ jsxRuntimeExports.jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsxRuntimeExports.jsx(Text, { dimColor: true, children: footerText }) })
+  ] });
+}
+function formatSingleAuthor(author) {
+  if (author.literal) {
+    return author.literal;
+  }
+  if (author.family) {
+    if (author.given) {
+      const initial = author.given.charAt(0).toUpperCase();
+      return `${author.family}, ${initial}.`;
+    }
+    return author.family;
+  }
+  return "";
+}
+function formatAuthors(authors) {
+  if (!authors || authors.length === 0) {
+    return "";
+  }
+  if (authors.length > 3) {
+    const first = authors[0];
+    if (!first) {
+      return "";
+    }
+    return `${formatSingleAuthor(first)}, et al.`;
+  }
+  const formatted = authors.map(formatSingleAuthor);
+  if (formatted.length === 1) {
+    return formatted[0] ?? "";
+  }
+  const allButLast = formatted.slice(0, -1).join(", ");
+  const last = formatted[formatted.length - 1] ?? "";
+  return `${allButLast}, & ${last}`;
+}
+export {
+  SearchableMultiSelect as S,
+  formatAuthors as f
+};
+//# sourceMappingURL=format-BPeCbpFG.js.map