feature: vor und nachteile

praesentation/node_modules/@antfu/ni/dist/index.cjs

@@ -0,0 +1,51 @@
+'use strict';
+
+const runner = require('./shared/ni.C82eau-4.cjs');
+require('node:path');
+require('node:process');
+require('readline');
+require('events');
+require('node:module');
+require('child_process');
+require('path');
+require('process');
+require('stream');
+require('node:fs');
+require('os');
+require('tty');
+require('node:os');
+require('fs');
+require('fs/promises');
+require('node:fs/promises');
+
+
+
+exports.AGENTS = runner.AGENTS;
+exports.CLI_TEMP_DIR = runner.CLI_TEMP_DIR;
+exports.COMMANDS = runner.COMMANDS;
+exports.INSTALL_PAGE = runner.INSTALL_PAGE;
+exports.LOCKS = runner.LOCKS;
+exports.UnsupportedCommand = runner.UnsupportedCommand;
+exports.cmdExists = runner.cmdExists;
+exports.constructCommand = runner.constructCommand;
+exports.detect = runner.detect;
+exports.exclude = runner.exclude;
+exports.formatPackageWithUrl = runner.formatPackageWithUrl;
+exports.getCliCommand = runner.getCliCommand;
+exports.getCommand = runner.getCommand;
+exports.getConfig = runner.getConfig;
+exports.getDefaultAgent = runner.getDefaultAgent;
+exports.getGlobalAgent = runner.getGlobalAgent;
+exports.limitText = runner.limitText;
+exports.parseNa = runner.parseNa;
+exports.parseNi = runner.parseNi;
+exports.parseNlx = runner.parseNlx;
+exports.parseNr = runner.parseNr;
+exports.parseNu = runner.parseNu;
+exports.parseNun = runner.parseNun;
+exports.remove = runner.remove;
+exports.resolveCommand = runner.resolveCommand;
+exports.run = runner.run;
+exports.runCli = runner.runCli;
+exports.serializeCommand = runner.serializeCommand;
+exports.writeFileSafe = runner.writeFileSafe;

praesentation/node_modules/@antfu/ni/dist/index.d.cts

@@ -0,0 +1,129 @@
+import { Buffer } from 'node:buffer';
+
+type Agent = 'npm' | 'yarn' | 'yarn@berry' | 'pnpm' | 'pnpm@6' | 'bun' | 'deno';
+type AgentName = 'npm' | 'yarn' | 'pnpm' | 'bun' | 'deno';
+type AgentCommandValue = (string | number)[] | ((args: string[]) => string[]) | null;
+interface AgentCommands {
+    'agent': AgentCommandValue;
+    'run': AgentCommandValue;
+    'install': AgentCommandValue;
+    'frozen': AgentCommandValue;
+    'global': AgentCommandValue;
+    'add': AgentCommandValue;
+    'upgrade': AgentCommandValue;
+    'upgrade-interactive': AgentCommandValue;
+    'execute': AgentCommandValue;
+    'execute-local': AgentCommandValue;
+    'uninstall': AgentCommandValue;
+    'global_uninstall': AgentCommandValue;
+}
+type Command = keyof AgentCommands;
+interface ResolvedCommand {
+    /**
+     * CLI command.
+     */
+    command: string;
+    /**
+     * Arguments for the CLI command, merged with user arguments.
+     */
+    args: string[];
+}
+
+declare const COMMANDS: {
+    npm: AgentCommands;
+    yarn: AgentCommands;
+    'yarn@berry': AgentCommands;
+    pnpm: AgentCommands;
+    'pnpm@6': AgentCommands;
+    bun: AgentCommands;
+    deno: AgentCommands;
+};
+/**
+ * Resolve the command for the agent merging the command arguments with the provided arguments.
+ *
+ * For example, to show how to install `@antfu/ni` globally using `pnpm`:
+ * ```js
+ * import { resolveCommand } from 'package-manager-detector/commands'
+ * const { command, args } = resolveCommand('pnpm', 'global', ['@antfu/ni'])
+ * console.log(`${command} ${args.join(' ')}`) // 'pnpm add -g @antfu/ni'
+ * ```
+ *
+ * @param agent The agent to use.
+ * @param command the command to resolve.
+ * @param args The arguments to pass to the command.
+ * @returns {ResolvedCommand} The resolved command or `null` if the agent command is not found.
+ */
+declare function resolveCommand(agent: Agent, command: Command, args: string[]): ResolvedCommand | null;
+/**
+ * Construct the command from the agent command merging the command arguments with the provided arguments.
+ * @param value {AgentCommandValue} The agent command to use.
+ * @param args The arguments to pass to the command.
+ * @returns {ResolvedCommand} The resolved command or `null` if the command is `null`.
+ */
+declare function constructCommand(value: AgentCommandValue, args: string[]): ResolvedCommand | null;
+
+declare const AGENTS: Agent[];
+declare const LOCKS: Record<string, AgentName>;
+declare const INSTALL_PAGE: Record<Agent, string>;
+
+interface Config {
+    defaultAgent: Agent | 'prompt';
+    globalAgent: Agent;
+}
+declare function getConfig(): Promise<Config>;
+declare function getDefaultAgent(programmatic?: boolean): Promise<Agent | "prompt">;
+declare function getGlobalAgent(): Promise<Agent>;
+
+interface DetectOptions {
+    autoInstall?: boolean;
+    programmatic?: boolean;
+    cwd?: string;
+    /**
+     * Should use Volta when present
+     *
+     * @see https://volta.sh/
+     * @default true
+     */
+    detectVolta?: boolean;
+}
+declare function detect({ autoInstall, programmatic, cwd }?: DetectOptions): Promise<Agent | undefined>;
+
+interface RunnerContext {
+    programmatic?: boolean;
+    hasLock?: boolean;
+    cwd?: string;
+}
+type Runner = (agent: Agent, args: string[], ctx?: RunnerContext) => Promise<ResolvedCommand | undefined> | ResolvedCommand | undefined;
+declare function runCli(fn: Runner, options?: DetectOptions & {
+    args?: string[];
+}): Promise<void>;
+declare function getCliCommand(fn: Runner, args: string[], options?: DetectOptions, cwd?: string): Promise<ResolvedCommand | undefined>;
+declare function run(fn: Runner, args: string[], options?: DetectOptions): Promise<void>;
+
+declare class UnsupportedCommand extends Error {
+    constructor({ agent, command }: {
+        agent: Agent;
+        command: Command;
+    });
+}
+declare function getCommand(agent: Agent, command: Command, args?: string[]): ResolvedCommand;
+declare const parseNi: Runner;
+declare const parseNr: Runner;
+declare const parseNu: Runner;
+declare const parseNun: Runner;
+declare const parseNlx: Runner;
+declare const parseNa: Runner;
+declare function serializeCommand(command?: ResolvedCommand): string | undefined;
+
+declare const CLI_TEMP_DIR: string;
+declare function remove<T>(arr: T[], v: T): T[];
+declare function exclude<T>(arr: T[], ...v: T[]): T[];
+declare function cmdExists(cmd: string): boolean;
+/**
+ * Write file safely avoiding conflicts
+ */
+declare function writeFileSafe(path: string, data?: string | Buffer): Promise<boolean>;
+declare function limitText(text: string, maxWidth: number): string;
+declare function formatPackageWithUrl(pkg: string, url?: string, limits?: number): string;
+
+export { AGENTS, CLI_TEMP_DIR, COMMANDS, type DetectOptions, INSTALL_PAGE, LOCKS, type Runner, type RunnerContext, UnsupportedCommand, cmdExists, constructCommand, detect, exclude, formatPackageWithUrl, getCliCommand, getCommand, getConfig, getDefaultAgent, getGlobalAgent, limitText, parseNa, parseNi, parseNlx, parseNr, parseNu, parseNun, remove, resolveCommand, run, runCli, serializeCommand, writeFileSafe };

praesentation/node_modules/@antfu/ni/dist/index.d.mts

@@ -0,0 +1,129 @@
+import { Buffer } from 'node:buffer';
+
+type Agent = 'npm' | 'yarn' | 'yarn@berry' | 'pnpm' | 'pnpm@6' | 'bun' | 'deno';
+type AgentName = 'npm' | 'yarn' | 'pnpm' | 'bun' | 'deno';
+type AgentCommandValue = (string | number)[] | ((args: string[]) => string[]) | null;
+interface AgentCommands {
+    'agent': AgentCommandValue;
+    'run': AgentCommandValue;
+    'install': AgentCommandValue;
+    'frozen': AgentCommandValue;
+    'global': AgentCommandValue;
+    'add': AgentCommandValue;
+    'upgrade': AgentCommandValue;
+    'upgrade-interactive': AgentCommandValue;
+    'execute': AgentCommandValue;
+    'execute-local': AgentCommandValue;
+    'uninstall': AgentCommandValue;
+    'global_uninstall': AgentCommandValue;
+}
+type Command = keyof AgentCommands;
+interface ResolvedCommand {
+    /**
+     * CLI command.
+     */
+    command: string;
+    /**
+     * Arguments for the CLI command, merged with user arguments.
+     */
+    args: string[];
+}
+
+declare const COMMANDS: {
+    npm: AgentCommands;
+    yarn: AgentCommands;
+    'yarn@berry': AgentCommands;
+    pnpm: AgentCommands;
+    'pnpm@6': AgentCommands;
+    bun: AgentCommands;
+    deno: AgentCommands;
+};
+/**
+ * Resolve the command for the agent merging the command arguments with the provided arguments.
+ *
+ * For example, to show how to install `@antfu/ni` globally using `pnpm`:
+ * ```js
+ * import { resolveCommand } from 'package-manager-detector/commands'
+ * const { command, args } = resolveCommand('pnpm', 'global', ['@antfu/ni'])
+ * console.log(`${command} ${args.join(' ')}`) // 'pnpm add -g @antfu/ni'
+ * ```
+ *
+ * @param agent The agent to use.
+ * @param command the command to resolve.
+ * @param args The arguments to pass to the command.
+ * @returns {ResolvedCommand} The resolved command or `null` if the agent command is not found.
+ */
+declare function resolveCommand(agent: Agent, command: Command, args: string[]): ResolvedCommand | null;
+/**
+ * Construct the command from the agent command merging the command arguments with the provided arguments.
+ * @param value {AgentCommandValue} The agent command to use.
+ * @param args The arguments to pass to the command.
+ * @returns {ResolvedCommand} The resolved command or `null` if the command is `null`.
+ */
+declare function constructCommand(value: AgentCommandValue, args: string[]): ResolvedCommand | null;
+
+declare const AGENTS: Agent[];
+declare const LOCKS: Record<string, AgentName>;
+declare const INSTALL_PAGE: Record<Agent, string>;
+
+interface Config {
+    defaultAgent: Agent | 'prompt';
+    globalAgent: Agent;
+}
+declare function getConfig(): Promise<Config>;
+declare function getDefaultAgent(programmatic?: boolean): Promise<Agent | "prompt">;
+declare function getGlobalAgent(): Promise<Agent>;
+
+interface DetectOptions {
+    autoInstall?: boolean;
+    programmatic?: boolean;
+    cwd?: string;
+    /**
+     * Should use Volta when present
+     *
+     * @see https://volta.sh/
+     * @default true
+     */
+    detectVolta?: boolean;
+}
+declare function detect({ autoInstall, programmatic, cwd }?: DetectOptions): Promise<Agent | undefined>;
+
+interface RunnerContext {
+    programmatic?: boolean;
+    hasLock?: boolean;
+    cwd?: string;
+}
+type Runner = (agent: Agent, args: string[], ctx?: RunnerContext) => Promise<ResolvedCommand | undefined> | ResolvedCommand | undefined;
+declare function runCli(fn: Runner, options?: DetectOptions & {
+    args?: string[];
+}): Promise<void>;
+declare function getCliCommand(fn: Runner, args: string[], options?: DetectOptions, cwd?: string): Promise<ResolvedCommand | undefined>;
+declare function run(fn: Runner, args: string[], options?: DetectOptions): Promise<void>;
+
+declare class UnsupportedCommand extends Error {
+    constructor({ agent, command }: {
+        agent: Agent;
+        command: Command;
+    });
+}
+declare function getCommand(agent: Agent, command: Command, args?: string[]): ResolvedCommand;
+declare const parseNi: Runner;
+declare const parseNr: Runner;
+declare const parseNu: Runner;
+declare const parseNun: Runner;
+declare const parseNlx: Runner;
+declare const parseNa: Runner;
+declare function serializeCommand(command?: ResolvedCommand): string | undefined;
+
+declare const CLI_TEMP_DIR: string;
+declare function remove<T>(arr: T[], v: T): T[];
+declare function exclude<T>(arr: T[], ...v: T[]): T[];
+declare function cmdExists(cmd: string): boolean;
+/**
+ * Write file safely avoiding conflicts
+ */
+declare function writeFileSafe(path: string, data?: string | Buffer): Promise<boolean>;
+declare function limitText(text: string, maxWidth: number): string;
+declare function formatPackageWithUrl(pkg: string, url?: string, limits?: number): string;
+
+export { AGENTS, CLI_TEMP_DIR, COMMANDS, type DetectOptions, INSTALL_PAGE, LOCKS, type Runner, type RunnerContext, UnsupportedCommand, cmdExists, constructCommand, detect, exclude, formatPackageWithUrl, getCliCommand, getCommand, getConfig, getDefaultAgent, getGlobalAgent, limitText, parseNa, parseNi, parseNlx, parseNr, parseNu, parseNun, remove, resolveCommand, run, runCli, serializeCommand, writeFileSafe };

praesentation/node_modules/@antfu/ni/dist/index.d.ts

@@ -0,0 +1,129 @@
+import { Buffer } from 'node:buffer';
+
+type Agent = 'npm' | 'yarn' | 'yarn@berry' | 'pnpm' | 'pnpm@6' | 'bun' | 'deno';
+type AgentName = 'npm' | 'yarn' | 'pnpm' | 'bun' | 'deno';
+type AgentCommandValue = (string | number)[] | ((args: string[]) => string[]) | null;
+interface AgentCommands {
+    'agent': AgentCommandValue;
+    'run': AgentCommandValue;
+    'install': AgentCommandValue;
+    'frozen': AgentCommandValue;
+    'global': AgentCommandValue;
+    'add': AgentCommandValue;
+    'upgrade': AgentCommandValue;
+    'upgrade-interactive': AgentCommandValue;
+    'execute': AgentCommandValue;
+    'execute-local': AgentCommandValue;
+    'uninstall': AgentCommandValue;
+    'global_uninstall': AgentCommandValue;
+}
+type Command = keyof AgentCommands;
+interface ResolvedCommand {
+    /**
+     * CLI command.
+     */
+    command: string;
+    /**
+     * Arguments for the CLI command, merged with user arguments.
+     */
+    args: string[];
+}
+
+declare const COMMANDS: {
+    npm: AgentCommands;
+    yarn: AgentCommands;
+    'yarn@berry': AgentCommands;
+    pnpm: AgentCommands;
+    'pnpm@6': AgentCommands;
+    bun: AgentCommands;
+    deno: AgentCommands;
+};
+/**
+ * Resolve the command for the agent merging the command arguments with the provided arguments.
+ *
+ * For example, to show how to install `@antfu/ni` globally using `pnpm`:
+ * ```js
+ * import { resolveCommand } from 'package-manager-detector/commands'
+ * const { command, args } = resolveCommand('pnpm', 'global', ['@antfu/ni'])
+ * console.log(`${command} ${args.join(' ')}`) // 'pnpm add -g @antfu/ni'
+ * ```
+ *
+ * @param agent The agent to use.
+ * @param command the command to resolve.
+ * @param args The arguments to pass to the command.
+ * @returns {ResolvedCommand} The resolved command or `null` if the agent command is not found.
+ */
+declare function resolveCommand(agent: Agent, command: Command, args: string[]): ResolvedCommand | null;
+/**
+ * Construct the command from the agent command merging the command arguments with the provided arguments.
+ * @param value {AgentCommandValue} The agent command to use.
+ * @param args The arguments to pass to the command.
+ * @returns {ResolvedCommand} The resolved command or `null` if the command is `null`.
+ */
+declare function constructCommand(value: AgentCommandValue, args: string[]): ResolvedCommand | null;
+
+declare const AGENTS: Agent[];
+declare const LOCKS: Record<string, AgentName>;
+declare const INSTALL_PAGE: Record<Agent, string>;
+
+interface Config {
+    defaultAgent: Agent | 'prompt';
+    globalAgent: Agent;
+}
+declare function getConfig(): Promise<Config>;
+declare function getDefaultAgent(programmatic?: boolean): Promise<Agent | "prompt">;
+declare function getGlobalAgent(): Promise<Agent>;
+
+interface DetectOptions {
+    autoInstall?: boolean;
+    programmatic?: boolean;
+    cwd?: string;
+    /**
+     * Should use Volta when present
+     *
+     * @see https://volta.sh/
+     * @default true
+     */
+    detectVolta?: boolean;
+}
+declare function detect({ autoInstall, programmatic, cwd }?: DetectOptions): Promise<Agent | undefined>;
+
+interface RunnerContext {
+    programmatic?: boolean;
+    hasLock?: boolean;
+    cwd?: string;
+}
+type Runner = (agent: Agent, args: string[], ctx?: RunnerContext) => Promise<ResolvedCommand | undefined> | ResolvedCommand | undefined;
+declare function runCli(fn: Runner, options?: DetectOptions & {
+    args?: string[];
+}): Promise<void>;
+declare function getCliCommand(fn: Runner, args: string[], options?: DetectOptions, cwd?: string): Promise<ResolvedCommand | undefined>;
+declare function run(fn: Runner, args: string[], options?: DetectOptions): Promise<void>;
+
+declare class UnsupportedCommand extends Error {
+    constructor({ agent, command }: {
+        agent: Agent;
+        command: Command;
+    });
+}
+declare function getCommand(agent: Agent, command: Command, args?: string[]): ResolvedCommand;
+declare const parseNi: Runner;
+declare const parseNr: Runner;
+declare const parseNu: Runner;
+declare const parseNun: Runner;
+declare const parseNlx: Runner;
+declare const parseNa: Runner;
+declare function serializeCommand(command?: ResolvedCommand): string | undefined;
+
+declare const CLI_TEMP_DIR: string;
+declare function remove<T>(arr: T[], v: T): T[];
+declare function exclude<T>(arr: T[], ...v: T[]): T[];
+declare function cmdExists(cmd: string): boolean;
+/**
+ * Write file safely avoiding conflicts
+ */
+declare function writeFileSafe(path: string, data?: string | Buffer): Promise<boolean>;
+declare function limitText(text: string, maxWidth: number): string;
+declare function formatPackageWithUrl(pkg: string, url?: string, limits?: number): string;
+
+export { AGENTS, CLI_TEMP_DIR, COMMANDS, type DetectOptions, INSTALL_PAGE, LOCKS, type Runner, type RunnerContext, UnsupportedCommand, cmdExists, constructCommand, detect, exclude, formatPackageWithUrl, getCliCommand, getCommand, getConfig, getDefaultAgent, getGlobalAgent, limitText, parseNa, parseNi, parseNlx, parseNr, parseNu, parseNun, remove, resolveCommand, run, runCli, serializeCommand, writeFileSafe };

praesentation/node_modules/@antfu/ni/dist/index.mjs

@@ -0,0 +1,17 @@
+export { A as AGENTS, C as CLI_TEMP_DIR, u as COMMANDS, I as INSTALL_PAGE, L as LOCKS, U as UnsupportedCommand, o as cmdExists, v as constructCommand, d as detect, n as exclude, t as formatPackageWithUrl, k as getCliCommand, c as getCommand, g as getConfig, a as getDefaultAgent, b as getGlobalAgent, q as limitText, j as parseNa, p as parseNi, i as parseNlx, e as parseNr, f as parseNu, h as parseNun, m as remove, x as resolveCommand, l as run, r as runCli, s as serializeCommand, w as writeFileSafe } from './shared/ni.CtJepYoh.mjs';
+import 'node:path';
+import 'node:process';
+import 'readline';
+import 'events';
+import 'node:module';
+import 'child_process';
+import 'path';
+import 'process';
+import 'stream';
+import 'node:fs';
+import 'os';
+import 'tty';
+import 'node:os';
+import 'fs';
+import 'fs/promises';
+import 'node:fs/promises';

praesentation/node_modules/@antfu/ni/dist/na.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+const runner = require('./shared/ni.C82eau-4.cjs');
+require('node:path');
+require('node:process');
+require('readline');
+require('events');
+require('node:module');
+require('child_process');
+require('path');
+require('process');
+require('stream');
+require('node:fs');
+require('os');
+require('tty');
+require('node:os');
+require('fs');
+require('fs/promises');
+require('node:fs/promises');
+
+runner.runCli(runner.parseNa);

praesentation/node_modules/@antfu/ni/dist/na.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

praesentation/node_modules/@antfu/ni/dist/na.d.mts

@@ -0,0 +1,2 @@
+
+export {  }

praesentation/node_modules/@antfu/ni/dist/na.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

praesentation/node_modules/@antfu/ni/dist/na.mjs

@@ -0,0 +1,19 @@
+import { r as runCli, j as parseNa } from './shared/ni.CtJepYoh.mjs';
+import 'node:path';
+import 'node:process';
+import 'readline';
+import 'events';
+import 'node:module';
+import 'child_process';
+import 'path';
+import 'process';
+import 'stream';
+import 'node:fs';
+import 'os';
+import 'tty';
+import 'node:os';
+import 'fs';
+import 'fs/promises';
+import 'node:fs/promises';
+
+runCli(parseNa);

praesentation/node_modules/@antfu/ni/dist/nci.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+const runner = require('./shared/ni.C82eau-4.cjs');
+require('node:path');
+require('node:process');
+require('readline');
+require('events');
+require('node:module');
+require('child_process');
+require('path');
+require('process');
+require('stream');
+require('node:fs');
+require('os');
+require('tty');
+require('node:os');
+require('fs');
+require('fs/promises');
+require('node:fs/promises');
+
+runner.runCli(
+  (agent, _, hasLock) => runner.parseNi(agent, ["--frozen-if-present"], hasLock),
+  { autoInstall: true }
+);

praesentation/node_modules/@antfu/ni/dist/nci.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

praesentation/node_modules/@antfu/ni/dist/nci.d.mts

@@ -0,0 +1,2 @@
+
+export {  }

praesentation/node_modules/@antfu/ni/dist/nci.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

praesentation/node_modules/@antfu/ni/dist/nci.mjs

@@ -0,0 +1,22 @@
+import { r as runCli, p as parseNi } from './shared/ni.CtJepYoh.mjs';
+import 'node:path';
+import 'node:process';
+import 'readline';
+import 'events';
+import 'node:module';
+import 'child_process';
+import 'path';
+import 'process';
+import 'stream';
+import 'node:fs';
+import 'os';
+import 'tty';
+import 'node:os';
+import 'fs';
+import 'fs/promises';
+import 'node:fs/promises';
+
+runCli(
+  (agent, _, hasLock) => parseNi(agent, ["--frozen-if-present"], hasLock),
+  { autoInstall: true }
+);

praesentation/node_modules/@antfu/ni/dist/ni.cjs

@@ -0,0 +1,115 @@
+'use strict';
+
+const process = require('node:process');
+const runner = require('./shared/ni.C82eau-4.cjs');
+const fzf_es = require('./shared/ni.BK9cf7FY.cjs');
+require('node:path');
+require('readline');
+require('events');
+require('node:module');
+require('child_process');
+require('path');
+require('process');
+require('stream');
+require('node:fs');
+require('os');
+require('tty');
+require('node:os');
+require('fs');
+require('fs/promises');
+require('node:fs/promises');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const process__default = /*#__PURE__*/_interopDefaultCompat(process);
+
+async function fetchNpmPackages(pattern) {
+  const registryLink = (pattern2) => `https://registry.npmjs.com/-/v1/search?text=${pattern2}&size=35`;
+  const terminalColumns = process__default.stdout?.columns || 80;
+  try {
+    const result = await fetch(registryLink(pattern)).then((res) => res.json());
+    return result.objects.map(({ package: pkg }) => ({
+      title: runner.formatPackageWithUrl(
+        `${pkg.name.padEnd(30, " ")} ${runner.c.blue(`v${pkg.version}`)}`,
+        pkg.links.repository ?? pkg.links.npm,
+        terminalColumns
+      ),
+      value: pkg
+    }));
+  } catch {
+    console.error("Error when fetching npm registry");
+    process__default.exit(1);
+  }
+}
+
+runner.runCli(async (agent, args, ctx) => {
+  const isInteractive = args[0] === "-i";
+  if (isInteractive) {
+    let fetchPattern;
+    if (args[1] && !args[1].startsWith("-")) {
+      fetchPattern = args[1];
+    } else {
+      const { pattern } = await runner.prompts({
+        type: "text",
+        name: "pattern",
+        message: "search for package"
+      });
+      fetchPattern = pattern;
+    }
+    if (!fetchPattern) {
+      process__default.exitCode = 1;
+      return;
+    }
+    const packages = await fetchNpmPackages(fetchPattern);
+    if (!packages.length) {
+      console.error("No results found");
+      process__default.exitCode = 1;
+      return;
+    }
+    const fzf = new fzf_es.Fzf(packages, {
+      selector: (item) => item.title,
+      casing: "case-insensitive"
+    });
+    const { dependency } = await runner.prompts({
+      type: "autocomplete",
+      name: "dependency",
+      choices: packages,
+      instructions: false,
+      message: "choose a package to install",
+      limit: 15,
+      async suggest(input, choices) {
+        const results = fzf.find(input);
+        return results.map((r) => choices.find((c2) => c2.value === r.item.value));
+      }
+    });
+    if (!dependency) {
+      process__default.exitCode = 1;
+      return;
+    }
+    args = runner.exclude(args, "-d", "-p", "-i");
+    const canInstallPeers = ["npm", "pnpm"].includes(agent);
+    const { mode } = await runner.prompts({
+      type: "select",
+      name: "mode",
+      message: `install ${runner.c.yellow(dependency.name)} as`,
+      choices: [
+        {
+          title: "prod",
+          value: "",
+          selected: true
+        },
+        {
+          title: "dev",
+          value: "-D"
+        },
+        {
+          title: `peer`,
+          value: "--save-peer",
+          disabled: !canInstallPeers
+        }
+      ]
+    });
+    args.push(dependency.name, mode);
+  }
+  return runner.parseNi(agent, args, ctx);
+});

praesentation/node_modules/@antfu/ni/dist/ni.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

praesentation/node_modules/@antfu/ni/dist/ni.d.mts

@@ -0,0 +1,2 @@
+
+export {  }

praesentation/node_modules/@antfu/ni/dist/ni.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

praesentation/node_modules/@antfu/ni/dist/ni.mjs

@@ -0,0 +1,109 @@
+import process from 'node:process';
+import { t as formatPackageWithUrl, z as c, r as runCli, y as prompts, n as exclude, p as parseNi } from './shared/ni.CtJepYoh.mjs';
+import { F as Fzf } from './shared/ni.DA7akRvA.mjs';
+import 'node:path';
+import 'readline';
+import 'events';
+import 'node:module';
+import 'child_process';
+import 'path';
+import 'process';
+import 'stream';
+import 'node:fs';
+import 'os';
+import 'tty';
+import 'node:os';
+import 'fs';
+import 'fs/promises';
+import 'node:fs/promises';
+
+async function fetchNpmPackages(pattern) {
+  const registryLink = (pattern2) => `https://registry.npmjs.com/-/v1/search?text=${pattern2}&size=35`;
+  const terminalColumns = process.stdout?.columns || 80;
+  try {
+    const result = await fetch(registryLink(pattern)).then((res) => res.json());
+    return result.objects.map(({ package: pkg }) => ({
+      title: formatPackageWithUrl(
+        `${pkg.name.padEnd(30, " ")} ${c.blue(`v${pkg.version}`)}`,
+        pkg.links.repository ?? pkg.links.npm,
+        terminalColumns
+      ),
+      value: pkg
+    }));
+  } catch {
+    console.error("Error when fetching npm registry");
+    process.exit(1);
+  }
+}
+
+runCli(async (agent, args, ctx) => {
+  const isInteractive = args[0] === "-i";
+  if (isInteractive) {
+    let fetchPattern;
+    if (args[1] && !args[1].startsWith("-")) {
+      fetchPattern = args[1];
+    } else {
+      const { pattern } = await prompts({
+        type: "text",
+        name: "pattern",
+        message: "search for package"
+      });
+      fetchPattern = pattern;
+    }
+    if (!fetchPattern) {
+      process.exitCode = 1;
+      return;
+    }
+    const packages = await fetchNpmPackages(fetchPattern);
+    if (!packages.length) {
+      console.error("No results found");
+      process.exitCode = 1;
+      return;
+    }
+    const fzf = new Fzf(packages, {
+      selector: (item) => item.title,
+      casing: "case-insensitive"
+    });
+    const { dependency } = await prompts({
+      type: "autocomplete",
+      name: "dependency",
+      choices: packages,
+      instructions: false,
+      message: "choose a package to install",
+      limit: 15,
+      async suggest(input, choices) {
+        const results = fzf.find(input);
+        return results.map((r) => choices.find((c2) => c2.value === r.item.value));
+      }
+    });
+    if (!dependency) {
+      process.exitCode = 1;
+      return;
+    }
+    args = exclude(args, "-d", "-p", "-i");
+    const canInstallPeers = ["npm", "pnpm"].includes(agent);
+    const { mode } = await prompts({
+      type: "select",
+      name: "mode",
+      message: `install ${c.yellow(dependency.name)} as`,
+      choices: [
+        {
+          title: "prod",
+          value: "",
+          selected: true
+        },
+        {
+          title: "dev",
+          value: "-D"
+        },
+        {
+          title: `peer`,
+          value: "--save-peer",
+          disabled: !canInstallPeers
+        }
+      ]
+    });
+    args.push(dependency.name, mode);
+  }
+  return parseNi(agent, args, ctx);
+});

praesentation/node_modules/@antfu/ni/dist/nlx.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+const runner = require('./shared/ni.C82eau-4.cjs');
+require('node:path');
+require('node:process');
+require('readline');
+require('events');
+require('node:module');
+require('child_process');
+require('path');
+require('process');
+require('stream');
+require('node:fs');
+require('os');
+require('tty');
+require('node:os');
+require('fs');
+require('fs/promises');
+require('node:fs/promises');
+
+runner.runCli(runner.parseNlx);

praesentation/node_modules/@antfu/ni/dist/nlx.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

praesentation/node_modules/@antfu/ni/dist/nlx.d.mts

@@ -0,0 +1,2 @@
+
+export {  }

praesentation/node_modules/@antfu/ni/dist/nlx.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

praesentation/node_modules/@antfu/ni/dist/nlx.mjs

@@ -0,0 +1,19 @@
+import { r as runCli, i as parseNlx } from './shared/ni.CtJepYoh.mjs';
+import 'node:path';
+import 'node:process';
+import 'readline';
+import 'events';
+import 'node:module';
+import 'child_process';
+import 'path';
+import 'process';
+import 'stream';
+import 'node:fs';
+import 'os';
+import 'tty';
+import 'node:os';
+import 'fs';
+import 'fs/promises';
+import 'node:fs/promises';
+
+runCli(parseNlx);

praesentation/node_modules/@antfu/ni/dist/nr.cjs

@@ -0,0 +1,105 @@
+'use strict';
+
+const process = require('node:process');
+const runner = require('./shared/ni.C82eau-4.cjs');
+const fzf_es = require('./shared/ni.BK9cf7FY.cjs');
+const fs$1 = require('./shared/ni.DWRIF_6-.cjs');
+const fs = require('node:fs');
+const path = require('node:path');
+require('readline');
+require('events');
+require('node:module');
+require('child_process');
+require('path');
+require('process');
+require('stream');
+require('os');
+require('tty');
+require('node:os');
+require('fs');
+require('fs/promises');
+require('node:fs/promises');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const process__default = /*#__PURE__*/_interopDefaultCompat(process);
+
+let storage;
+const storagePath = path.resolve(runner.CLI_TEMP_DIR, "_storage.json");
+async function load(fn) {
+  if (!storage) {
+    storage = fs.existsSync(storagePath) ? JSON.parse(await fs.promises.readFile(storagePath, "utf-8") || "{}") || {} : {};
+  }
+  return storage;
+}
+async function dump() {
+  if (storage)
+    await runner.writeFileSafe(storagePath, JSON.stringify(storage));
+}
+
+runner.runCli(async (agent, args, ctx) => {
+  const storage = await load();
+  if (args[0] === "-") {
+    if (!storage.lastRunCommand) {
+      if (!ctx?.programmatic) {
+        console.error("No last command found");
+        process__default.exit(1);
+      }
+      throw new Error("No last command found");
+    }
+    args[0] = storage.lastRunCommand;
+  }
+  if (args.length === 0 && !ctx?.programmatic) {
+    const pkg = fs$1.getPackageJSON(ctx);
+    const scripts = pkg.scripts || {};
+    const scriptsInfo = pkg["scripts-info"] || {};
+    const names = Object.entries(scripts);
+    if (!names.length)
+      return;
+    const raw = names.filter((i) => !i[0].startsWith("?")).map(([key, cmd]) => ({
+      key,
+      cmd,
+      description: scriptsInfo[key] || scripts[`?${key}`] || cmd
+    }));
+    const terminalColumns = process__default.stdout?.columns || 80;
+    const choices = raw.map(({ key, description }) => ({
+      title: key,
+      value: key,
+      description: runner.limitText(description, terminalColumns - 15)
+    }));
+    const fzf = new fzf_es.Fzf(raw, {
+      selector: (item) => `${item.key} ${item.description}`,
+      casing: "case-insensitive",
+      tiebreakers: [fzf_es.byLengthAsc]
+    });
+    if (storage.lastRunCommand) {
+      const last = choices.find((i) => i.value === storage.lastRunCommand);
+      if (last)
+        choices.unshift(last);
+    }
+    try {
+      const { fn } = await runner.prompts({
+        name: "fn",
+        message: "script to run",
+        type: "autocomplete",
+        choices,
+        async suggest(input, choices2) {
+          if (!input)
+            return choices2;
+          const results = fzf.find(input);
+          return results.map((r) => choices2.find((c) => c.value === r.item.key));
+        }
+      });
+      if (!fn)
+        return;
+      args.push(fn);
+    } catch {
+      process__default.exit(1);
+    }
+  }
+  if (storage.lastRunCommand !== args[0]) {
+    storage.lastRunCommand = args[0];
+    dump();
+  }
+  return runner.parseNr(agent, args);
+});

praesentation/node_modules/@antfu/ni/dist/nr.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

praesentation/node_modules/@antfu/ni/dist/nr.d.mts

@@ -0,0 +1,2 @@
+
+export {  }

praesentation/node_modules/@antfu/ni/dist/nr.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

praesentation/node_modules/@antfu/ni/dist/nr.mjs

@@ -0,0 +1,99 @@
+import process from 'node:process';
+import { C as CLI_TEMP_DIR, w as writeFileSafe, r as runCli, q as limitText, y as prompts, e as parseNr } from './shared/ni.CtJepYoh.mjs';
+import { F as Fzf, b as byLengthAsc } from './shared/ni.DA7akRvA.mjs';
+import { g as getPackageJSON } from './shared/ni.C4mrCGPc.mjs';
+import { existsSync, promises } from 'node:fs';
+import { resolve } from 'node:path';
+import 'readline';
+import 'events';
+import 'node:module';
+import 'child_process';
+import 'path';
+import 'process';
+import 'stream';
+import 'os';
+import 'tty';
+import 'node:os';
+import 'fs';
+import 'fs/promises';
+import 'node:fs/promises';
+
+let storage;
+const storagePath = resolve(CLI_TEMP_DIR, "_storage.json");
+async function load(fn) {
+  if (!storage) {
+    storage = existsSync(storagePath) ? JSON.parse(await promises.readFile(storagePath, "utf-8") || "{}") || {} : {};
+  }
+  return storage;
+}
+async function dump() {
+  if (storage)
+    await writeFileSafe(storagePath, JSON.stringify(storage));
+}
+
+runCli(async (agent, args, ctx) => {
+  const storage = await load();
+  if (args[0] === "-") {
+    if (!storage.lastRunCommand) {
+      if (!ctx?.programmatic) {
+        console.error("No last command found");
+        process.exit(1);
+      }
+      throw new Error("No last command found");
+    }
+    args[0] = storage.lastRunCommand;
+  }
+  if (args.length === 0 && !ctx?.programmatic) {
+    const pkg = getPackageJSON(ctx);
+    const scripts = pkg.scripts || {};
+    const scriptsInfo = pkg["scripts-info"] || {};
+    const names = Object.entries(scripts);
+    if (!names.length)
+      return;
+    const raw = names.filter((i) => !i[0].startsWith("?")).map(([key, cmd]) => ({
+      key,
+      cmd,
+      description: scriptsInfo[key] || scripts[`?${key}`] || cmd
+    }));
+    const terminalColumns = process.stdout?.columns || 80;
+    const choices = raw.map(({ key, description }) => ({
+      title: key,
+      value: key,
+      description: limitText(description, terminalColumns - 15)
+    }));
+    const fzf = new Fzf(raw, {
+      selector: (item) => `${item.key} ${item.description}`,
+      casing: "case-insensitive",
+      tiebreakers: [byLengthAsc]
+    });
+    if (storage.lastRunCommand) {
+      const last = choices.find((i) => i.value === storage.lastRunCommand);
+      if (last)
+        choices.unshift(last);
+    }
+    try {
+      const { fn } = await prompts({
+        name: "fn",
+        message: "script to run",
+        type: "autocomplete",
+        choices,
+        async suggest(input, choices2) {
+          if (!input)
+            return choices2;
+          const results = fzf.find(input);
+          return results.map((r) => choices2.find((c) => c.value === r.item.key));
+        }
+      });
+      if (!fn)
+        return;
+      args.push(fn);
+    } catch {
+      process.exit(1);
+    }
+  }
+  if (storage.lastRunCommand !== args[0]) {
+    storage.lastRunCommand = args[0];
+    dump();
+  }
+  return parseNr(agent, args);
+});

praesentation/node_modules/@antfu/ni/dist/nu.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+const runner = require('./shared/ni.C82eau-4.cjs');
+require('node:path');
+require('node:process');
+require('readline');
+require('events');
+require('node:module');
+require('child_process');
+require('path');
+require('process');
+require('stream');
+require('node:fs');
+require('os');
+require('tty');
+require('node:os');
+require('fs');
+require('fs/promises');
+require('node:fs/promises');
+
+runner.runCli(runner.parseNu);

praesentation/node_modules/@antfu/ni/dist/nu.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

praesentation/node_modules/@antfu/ni/dist/nu.d.mts

@@ -0,0 +1,2 @@
+
+export {  }

praesentation/node_modules/@antfu/ni/dist/nu.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

praesentation/node_modules/@antfu/ni/dist/nu.mjs

@@ -0,0 +1,19 @@
+import { r as runCli, f as parseNu } from './shared/ni.CtJepYoh.mjs';
+import 'node:path';
+import 'node:process';
+import 'readline';
+import 'events';
+import 'node:module';
+import 'child_process';
+import 'path';
+import 'process';
+import 'stream';
+import 'node:fs';
+import 'os';
+import 'tty';
+import 'node:os';
+import 'fs';
+import 'fs/promises';
+import 'node:fs/promises';
+
+runCli(parseNu);

praesentation/node_modules/@antfu/ni/dist/nun.cjs

@@ -0,0 +1,75 @@
+'use strict';
+
+const process = require('node:process');
+const runner = require('./shared/ni.C82eau-4.cjs');
+const fzf_es = require('./shared/ni.BK9cf7FY.cjs');
+const fs = require('./shared/ni.DWRIF_6-.cjs');
+require('node:path');
+require('readline');
+require('events');
+require('node:module');
+require('child_process');
+require('path');
+require('process');
+require('stream');
+require('node:fs');
+require('os');
+require('tty');
+require('node:os');
+require('fs');
+require('fs/promises');
+require('node:fs/promises');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const process__default = /*#__PURE__*/_interopDefaultCompat(process);
+
+runner.runCli(async (agent, args, ctx) => {
+  const isInteractive = !args.length && !ctx?.programmatic;
+  if (isInteractive || args[0] === "-m") {
+    const pkg = fs.getPackageJSON(ctx);
+    const allDependencies = { ...pkg.dependencies, ...pkg.devDependencies };
+    const raw = Object.entries(allDependencies);
+    if (!raw.length) {
+      console.error("No dependencies found");
+      return;
+    }
+    const fzf = new fzf_es.Fzf(raw, {
+      selector: ([dep, version]) => `${dep} ${version}`,
+      casing: "case-insensitive"
+    });
+    const choices = raw.map(([dependency, version]) => ({
+      title: dependency,
+      value: dependency,
+      description: version
+    }));
+    const isMultiple = args[0] === "-m";
+    const type = isMultiple ? "autocompleteMultiselect" : "autocomplete";
+    if (isMultiple)
+      args = runner.exclude(args, "-m");
+    try {
+      const { depsToRemove } = await runner.prompts({
+        type,
+        name: "depsToRemove",
+        choices,
+        instructions: false,
+        message: `remove ${isMultiple ? "dependencies" : "dependency"}`,
+        async suggest(input, choices2) {
+          const results = fzf.find(input);
+          return results.map((r) => choices2.find((c) => c.value === r.item[0]));
+        }
+      });
+      if (!depsToRemove) {
+        process__default.exitCode = 1;
+        return;
+      }
+      const isSingleDependency = typeof depsToRemove === "string";
+      if (isSingleDependency)
+        args.push(depsToRemove);
+      else args.push(...depsToRemove);
+    } catch {
+      process__default.exit(1);
+    }
+  }
+  return runner.parseNun(agent, args);
+});

praesentation/node_modules/@antfu/ni/dist/nun.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

praesentation/node_modules/@antfu/ni/dist/nun.d.mts

@@ -0,0 +1,2 @@
+
+export {  }

praesentation/node_modules/@antfu/ni/dist/nun.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

praesentation/node_modules/@antfu/ni/dist/nun.mjs

@@ -0,0 +1,69 @@
+import process from 'node:process';
+import { r as runCli, n as exclude, y as prompts, h as parseNun } from './shared/ni.CtJepYoh.mjs';
+import { F as Fzf } from './shared/ni.DA7akRvA.mjs';
+import { g as getPackageJSON } from './shared/ni.C4mrCGPc.mjs';
+import 'node:path';
+import 'readline';
+import 'events';
+import 'node:module';
+import 'child_process';
+import 'path';
+import 'process';
+import 'stream';
+import 'node:fs';
+import 'os';
+import 'tty';
+import 'node:os';
+import 'fs';
+import 'fs/promises';
+import 'node:fs/promises';
+
+runCli(async (agent, args, ctx) => {
+  const isInteractive = !args.length && !ctx?.programmatic;
+  if (isInteractive || args[0] === "-m") {
+    const pkg = getPackageJSON(ctx);
+    const allDependencies = { ...pkg.dependencies, ...pkg.devDependencies };
+    const raw = Object.entries(allDependencies);
+    if (!raw.length) {
+      console.error("No dependencies found");
+      return;
+    }
+    const fzf = new Fzf(raw, {
+      selector: ([dep, version]) => `${dep} ${version}`,
+      casing: "case-insensitive"
+    });
+    const choices = raw.map(([dependency, version]) => ({
+      title: dependency,
+      value: dependency,
+      description: version
+    }));
+    const isMultiple = args[0] === "-m";
+    const type = isMultiple ? "autocompleteMultiselect" : "autocomplete";
+    if (isMultiple)
+      args = exclude(args, "-m");
+    try {
+      const { depsToRemove } = await prompts({
+        type,
+        name: "depsToRemove",
+        choices,
+        instructions: false,
+        message: `remove ${isMultiple ? "dependencies" : "dependency"}`,
+        async suggest(input, choices2) {
+          const results = fzf.find(input);
+          return results.map((r) => choices2.find((c) => c.value === r.item[0]));
+        }
+      });
+      if (!depsToRemove) {
+        process.exitCode = 1;
+        return;
+      }
+      const isSingleDependency = typeof depsToRemove === "string";
+      if (isSingleDependency)
+        args.push(depsToRemove);
+      else args.push(...depsToRemove);
+    } catch {
+      process.exit(1);
+    }
+  }
+  return parseNun(agent, args);
+});

praesentation/node_modules/@antfu/ni/dist/shared/ni.BK9cf7FY.cjs

@@ -0,0 +1,921 @@
+'use strict';
+
+/** @license
+ * fzf v0.5.2
+ * Copyright (c) 2021 Ajit
+ * Licensed under BSD 3-Clause
+ */
+const normalized = {
+  216: "O",
+  223: "s",
+  248: "o",
+  273: "d",
+  295: "h",
+  305: "i",
+  320: "l",
+  322: "l",
+  359: "t",
+  383: "s",
+  384: "b",
+  385: "B",
+  387: "b",
+  390: "O",
+  392: "c",
+  393: "D",
+  394: "D",
+  396: "d",
+  398: "E",
+  400: "E",
+  402: "f",
+  403: "G",
+  407: "I",
+  409: "k",
+  410: "l",
+  412: "M",
+  413: "N",
+  414: "n",
+  415: "O",
+  421: "p",
+  427: "t",
+  429: "t",
+  430: "T",
+  434: "V",
+  436: "y",
+  438: "z",
+  477: "e",
+  485: "g",
+  544: "N",
+  545: "d",
+  549: "z",
+  564: "l",
+  565: "n",
+  566: "t",
+  567: "j",
+  570: "A",
+  571: "C",
+  572: "c",
+  573: "L",
+  574: "T",
+  575: "s",
+  576: "z",
+  579: "B",
+  580: "U",
+  581: "V",
+  582: "E",
+  583: "e",
+  584: "J",
+  585: "j",
+  586: "Q",
+  587: "q",
+  588: "R",
+  589: "r",
+  590: "Y",
+  591: "y",
+  592: "a",
+  593: "a",
+  595: "b",
+  596: "o",
+  597: "c",
+  598: "d",
+  599: "d",
+  600: "e",
+  603: "e",
+  604: "e",
+  605: "e",
+  606: "e",
+  607: "j",
+  608: "g",
+  609: "g",
+  610: "G",
+  613: "h",
+  614: "h",
+  616: "i",
+  618: "I",
+  619: "l",
+  620: "l",
+  621: "l",
+  623: "m",
+  624: "m",
+  625: "m",
+  626: "n",
+  627: "n",
+  628: "N",
+  629: "o",
+  633: "r",
+  634: "r",
+  635: "r",
+  636: "r",
+  637: "r",
+  638: "r",
+  639: "r",
+  640: "R",
+  641: "R",
+  642: "s",
+  647: "t",
+  648: "t",
+  649: "u",
+  651: "v",
+  652: "v",
+  653: "w",
+  654: "y",
+  655: "Y",
+  656: "z",
+  657: "z",
+  663: "c",
+  665: "B",
+  666: "e",
+  667: "G",
+  668: "H",
+  669: "j",
+  670: "k",
+  671: "L",
+  672: "q",
+  686: "h",
+  867: "a",
+  868: "e",
+  869: "i",
+  870: "o",
+  871: "u",
+  872: "c",
+  873: "d",
+  874: "h",
+  875: "m",
+  876: "r",
+  877: "t",
+  878: "v",
+  879: "x",
+  7424: "A",
+  7427: "B",
+  7428: "C",
+  7429: "D",
+  7431: "E",
+  7432: "e",
+  7433: "i",
+  7434: "J",
+  7435: "K",
+  7436: "L",
+  7437: "M",
+  7438: "N",
+  7439: "O",
+  7440: "O",
+  7441: "o",
+  7442: "o",
+  7443: "o",
+  7446: "o",
+  7447: "o",
+  7448: "P",
+  7449: "R",
+  7450: "R",
+  7451: "T",
+  7452: "U",
+  7453: "u",
+  7454: "u",
+  7455: "m",
+  7456: "V",
+  7457: "W",
+  7458: "Z",
+  7522: "i",
+  7523: "r",
+  7524: "u",
+  7525: "v",
+  7834: "a",
+  7835: "s",
+  8305: "i",
+  8341: "h",
+  8342: "k",
+  8343: "l",
+  8344: "m",
+  8345: "n",
+  8346: "p",
+  8347: "s",
+  8348: "t",
+  8580: "c"
+};
+for (let i = "\u0300".codePointAt(0); i <= "\u036F".codePointAt(0); ++i) {
+  const diacritic = String.fromCodePoint(i);
+  for (const asciiChar of "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz") {
+    const withDiacritic = (asciiChar + diacritic).normalize();
+    const withDiacriticCodePoint = withDiacritic.codePointAt(0);
+    if (withDiacriticCodePoint > 126) {
+      normalized[withDiacriticCodePoint] = asciiChar;
+    }
+  }
+}
+const ranges = {
+  a: [7844, 7863],
+  e: [7870, 7879],
+  o: [7888, 7907],
+  u: [7912, 7921]
+};
+for (const lowerChar of Object.keys(ranges)) {
+  const upperChar = lowerChar.toUpperCase();
+  for (let i = ranges[lowerChar][0]; i <= ranges[lowerChar][1]; ++i) {
+    normalized[i] = i % 2 === 0 ? upperChar : lowerChar;
+  }
+}
+function normalizeRune(rune) {
+  if (rune < 192 || rune > 8580) {
+    return rune;
+  }
+  const normalizedChar = normalized[rune];
+  if (normalizedChar !== void 0)
+    return normalizedChar.codePointAt(0);
+  return rune;
+}
+function toShort(number) {
+  return number;
+}
+function toInt(number) {
+  return number;
+}
+function maxInt16(num1, num2) {
+  return num1 > num2 ? num1 : num2;
+}
+const strToRunes = (str) => str.split("").map((s) => s.codePointAt(0));
+const whitespaceRunes = new Set(
+  " \f\n\r	\v\xA0\u1680\u2028\u2029\u202F\u205F\u3000\uFEFF".split("").map((v) => v.codePointAt(0))
+);
+for (let codePoint = "\u2000".codePointAt(0); codePoint <= "\u200A".codePointAt(0); codePoint++) {
+  whitespaceRunes.add(codePoint);
+}
+const MAX_ASCII = "\x7F".codePointAt(0);
+const CAPITAL_A_RUNE = "A".codePointAt(0);
+const CAPITAL_Z_RUNE = "Z".codePointAt(0);
+const SMALL_A_RUNE = "a".codePointAt(0);
+const SMALL_Z_RUNE = "z".codePointAt(0);
+const NUMERAL_ZERO_RUNE = "0".codePointAt(0);
+const NUMERAL_NINE_RUNE = "9".codePointAt(0);
+function indexAt(index, max, forward) {
+  if (forward) {
+    return index;
+  }
+  return max - index - 1;
+}
+const SCORE_MATCH = 16, SCORE_GAP_START = -3, SCORE_GAP_EXTENTION = -1, BONUS_BOUNDARY = SCORE_MATCH / 2, BONUS_NON_WORD = SCORE_MATCH / 2, BONUS_CAMEL_123 = BONUS_BOUNDARY + SCORE_GAP_EXTENTION, BONUS_CONSECUTIVE = -(SCORE_GAP_START + SCORE_GAP_EXTENTION), BONUS_FIRST_CHAR_MULTIPLIER = 2;
+function createPosSet(withPos) {
+  if (withPos) {
+    return /* @__PURE__ */ new Set();
+  }
+  return null;
+}
+function alloc16(offset, slab2, size) {
+  if (slab2 !== null && slab2.i16.length > offset + size) {
+    const subarray = slab2.i16.subarray(offset, offset + size);
+    return [offset + size, subarray];
+  }
+  return [offset, new Int16Array(size)];
+}
+function alloc32(offset, slab2, size) {
+  if (slab2 !== null && slab2.i32.length > offset + size) {
+    const subarray = slab2.i32.subarray(offset, offset + size);
+    return [offset + size, subarray];
+  }
+  return [offset, new Int32Array(size)];
+}
+function charClassOfAscii(rune) {
+  if (rune >= SMALL_A_RUNE && rune <= SMALL_Z_RUNE) {
+    return 1;
+  } else if (rune >= CAPITAL_A_RUNE && rune <= CAPITAL_Z_RUNE) {
+    return 2;
+  } else if (rune >= NUMERAL_ZERO_RUNE && rune <= NUMERAL_NINE_RUNE) {
+    return 4;
+  } else {
+    return 0;
+  }
+}
+function charClassOfNonAscii(rune) {
+  const char = String.fromCodePoint(rune);
+  if (char !== char.toUpperCase()) {
+    return 1;
+  } else if (char !== char.toLowerCase()) {
+    return 2;
+  } else if (char.match(/\p{Number}/gu) !== null) {
+    return 4;
+  } else if (char.match(/\p{Letter}/gu) !== null) {
+    return 3;
+  }
+  return 0;
+}
+function charClassOf(rune) {
+  if (rune <= MAX_ASCII) {
+    return charClassOfAscii(rune);
+  }
+  return charClassOfNonAscii(rune);
+}
+function bonusFor(prevClass, currClass) {
+  if (prevClass === 0 && currClass !== 0) {
+    return BONUS_BOUNDARY;
+  } else if (prevClass === 1 && currClass === 2 || prevClass !== 4 && currClass === 4) {
+    return BONUS_CAMEL_123;
+  } else if (currClass === 0) {
+    return BONUS_NON_WORD;
+  }
+  return 0;
+}
+function bonusAt(input, idx) {
+  if (idx === 0) {
+    return BONUS_BOUNDARY;
+  }
+  return bonusFor(charClassOf(input[idx - 1]), charClassOf(input[idx]));
+}
+function trySkip(input, caseSensitive, char, from) {
+  let rest = input.slice(from);
+  let idx = rest.indexOf(char);
+  if (idx === 0) {
+    return from;
+  }
+  if (!caseSensitive && char >= SMALL_A_RUNE && char <= SMALL_Z_RUNE) {
+    if (idx > 0) {
+      rest = rest.slice(0, idx);
+    }
+    const uidx = rest.indexOf(char - 32);
+    if (uidx >= 0) {
+      idx = uidx;
+    }
+  }
+  if (idx < 0) {
+    return -1;
+  }
+  return from + idx;
+}
+function isAscii(runes) {
+  for (const rune of runes) {
+    if (rune >= 128) {
+      return false;
+    }
+  }
+  return true;
+}
+function asciiFuzzyIndex(input, pattern, caseSensitive) {
+  if (!isAscii(input)) {
+    return 0;
+  }
+  if (!isAscii(pattern)) {
+    return -1;
+  }
+  let firstIdx = 0, idx = 0;
+  for (let pidx = 0; pidx < pattern.length; pidx++) {
+    idx = trySkip(input, caseSensitive, pattern[pidx], idx);
+    if (idx < 0) {
+      return -1;
+    }
+    if (pidx === 0 && idx > 0) {
+      firstIdx = idx - 1;
+    }
+    idx++;
+  }
+  return firstIdx;
+}
+const fuzzyMatchV2 = (caseSensitive, normalize, forward, input, pattern, withPos, slab2) => {
+  const M = pattern.length;
+  if (M === 0) {
+    return [{ start: 0, end: 0, score: 0 }, createPosSet(withPos)];
+  }
+  const N = input.length;
+  if (slab2 !== null && N * M > slab2.i16.length) {
+    return fuzzyMatchV1(caseSensitive, normalize, forward, input, pattern, withPos);
+  }
+  const idx = asciiFuzzyIndex(input, pattern, caseSensitive);
+  if (idx < 0) {
+    return [{ start: -1, end: -1, score: 0 }, null];
+  }
+  let offset16 = 0, offset32 = 0, H0 = null, C0 = null, B = null, F = null;
+  [offset16, H0] = alloc16(offset16, slab2, N);
+  [offset16, C0] = alloc16(offset16, slab2, N);
+  [offset16, B] = alloc16(offset16, slab2, N);
+  [offset32, F] = alloc32(offset32, slab2, M);
+  const [, T] = alloc32(offset32, slab2, N);
+  for (let i = 0; i < T.length; i++) {
+    T[i] = input[i];
+  }
+  let maxScore = toShort(0), maxScorePos = 0;
+  let pidx = 0, lastIdx = 0;
+  const pchar0 = pattern[0];
+  let pchar = pattern[0], prevH0 = toShort(0), prevCharClass = 0, inGap = false;
+  let Tsub = T.subarray(idx);
+  let H0sub = H0.subarray(idx).subarray(0, Tsub.length), C0sub = C0.subarray(idx).subarray(0, Tsub.length), Bsub = B.subarray(idx).subarray(0, Tsub.length);
+  for (let [off, char] of Tsub.entries()) {
+    let charClass = null;
+    if (char <= MAX_ASCII) {
+      charClass = charClassOfAscii(char);
+      if (!caseSensitive && charClass === 2) {
+        char += 32;
+      }
+    } else {
+      charClass = charClassOfNonAscii(char);
+      if (!caseSensitive && charClass === 2) {
+        char = String.fromCodePoint(char).toLowerCase().codePointAt(0);
+      }
+      if (normalize) {
+        char = normalizeRune(char);
+      }
+    }
+    Tsub[off] = char;
+    const bonus = bonusFor(prevCharClass, charClass);
+    Bsub[off] = bonus;
+    prevCharClass = charClass;
+    if (char === pchar) {
+      if (pidx < M) {
+        F[pidx] = toInt(idx + off);
+        pidx++;
+        pchar = pattern[Math.min(pidx, M - 1)];
+      }
+      lastIdx = idx + off;
+    }
+    if (char === pchar0) {
+      const score = SCORE_MATCH + bonus * BONUS_FIRST_CHAR_MULTIPLIER;
+      H0sub[off] = score;
+      C0sub[off] = 1;
+      if (M === 1 && (forward && score > maxScore || !forward && score >= maxScore)) {
+        maxScore = score;
+        maxScorePos = idx + off;
+        if (forward && bonus === BONUS_BOUNDARY) {
+          break;
+        }
+      }
+      inGap = false;
+    } else {
+      if (inGap) {
+        H0sub[off] = maxInt16(prevH0 + SCORE_GAP_EXTENTION, 0);
+      } else {
+        H0sub[off] = maxInt16(prevH0 + SCORE_GAP_START, 0);
+      }
+      C0sub[off] = 0;
+      inGap = true;
+    }
+    prevH0 = H0sub[off];
+  }
+  if (pidx !== M) {
+    return [{ start: -1, end: -1, score: 0 }, null];
+  }
+  if (M === 1) {
+    const result = {
+      start: maxScorePos,
+      end: maxScorePos + 1,
+      score: maxScore
+    };
+    if (!withPos) {
+      return [result, null];
+    }
+    const pos2 = /* @__PURE__ */ new Set();
+    pos2.add(maxScorePos);
+    return [result, pos2];
+  }
+  const f0 = F[0];
+  const width = lastIdx - f0 + 1;
+  let H = null;
+  [offset16, H] = alloc16(offset16, slab2, width * M);
+  {
+    const toCopy = H0.subarray(f0, lastIdx + 1);
+    for (const [i, v] of toCopy.entries()) {
+      H[i] = v;
+    }
+  }
+  let [, C] = alloc16(offset16, slab2, width * M);
+  {
+    const toCopy = C0.subarray(f0, lastIdx + 1);
+    for (const [i, v] of toCopy.entries()) {
+      C[i] = v;
+    }
+  }
+  const Fsub = F.subarray(1);
+  const Psub = pattern.slice(1).slice(0, Fsub.length);
+  for (const [off, f] of Fsub.entries()) {
+    let inGap2 = false;
+    const pchar2 = Psub[off], pidx2 = off + 1, row = pidx2 * width, Tsub2 = T.subarray(f, lastIdx + 1), Bsub2 = B.subarray(f).subarray(0, Tsub2.length), Csub = C.subarray(row + f - f0).subarray(0, Tsub2.length), Cdiag = C.subarray(row + f - f0 - 1 - width).subarray(0, Tsub2.length), Hsub = H.subarray(row + f - f0).subarray(0, Tsub2.length), Hdiag = H.subarray(row + f - f0 - 1 - width).subarray(0, Tsub2.length), Hleft = H.subarray(row + f - f0 - 1).subarray(0, Tsub2.length);
+    Hleft[0] = 0;
+    for (const [off2, char] of Tsub2.entries()) {
+      const col = off2 + f;
+      let s1 = 0, s2 = 0, consecutive = 0;
+      if (inGap2) {
+        s2 = Hleft[off2] + SCORE_GAP_EXTENTION;
+      } else {
+        s2 = Hleft[off2] + SCORE_GAP_START;
+      }
+      if (pchar2 === char) {
+        s1 = Hdiag[off2] + SCORE_MATCH;
+        let b = Bsub2[off2];
+        consecutive = Cdiag[off2] + 1;
+        if (b === BONUS_BOUNDARY) {
+          consecutive = 1;
+        } else if (consecutive > 1) {
+          b = maxInt16(b, maxInt16(BONUS_CONSECUTIVE, B[col - consecutive + 1]));
+        }
+        if (s1 + b < s2) {
+          s1 += Bsub2[off2];
+          consecutive = 0;
+        } else {
+          s1 += b;
+        }
+      }
+      Csub[off2] = consecutive;
+      inGap2 = s1 < s2;
+      const score = maxInt16(maxInt16(s1, s2), 0);
+      if (pidx2 === M - 1 && (forward && score > maxScore || !forward && score >= maxScore)) {
+        maxScore = score;
+        maxScorePos = col;
+      }
+      Hsub[off2] = score;
+    }
+  }
+  const pos = createPosSet(withPos);
+  let j = f0;
+  if (withPos && pos !== null) {
+    let i = M - 1;
+    j = maxScorePos;
+    let preferMatch = true;
+    while (true) {
+      const I = i * width, j0 = j - f0, s = H[I + j0];
+      let s1 = 0, s2 = 0;
+      if (i > 0 && j >= F[i]) {
+        s1 = H[I - width + j0 - 1];
+      }
+      if (j > F[i]) {
+        s2 = H[I + j0 - 1];
+      }
+      if (s > s1 && (s > s2 || s === s2 && preferMatch)) {
+        pos.add(j);
+        if (i === 0) {
+          break;
+        }
+        i--;
+      }
+      preferMatch = C[I + j0] > 1 || I + width + j0 + 1 < C.length && C[I + width + j0 + 1] > 0;
+      j--;
+    }
+  }
+  return [{ start: j, end: maxScorePos + 1, score: maxScore }, pos];
+};
+function calculateScore(caseSensitive, normalize, text, pattern, sidx, eidx, withPos) {
+  let pidx = 0, score = 0, inGap = false, consecutive = 0, firstBonus = toShort(0);
+  const pos = createPosSet(withPos);
+  let prevCharClass = 0;
+  if (sidx > 0) {
+    prevCharClass = charClassOf(text[sidx - 1]);
+  }
+  for (let idx = sidx; idx < eidx; idx++) {
+    let rune = text[idx];
+    const charClass = charClassOf(rune);
+    if (!caseSensitive) {
+      if (rune >= CAPITAL_A_RUNE && rune <= CAPITAL_Z_RUNE) {
+        rune += 32;
+      } else if (rune > MAX_ASCII) {
+        rune = String.fromCodePoint(rune).toLowerCase().codePointAt(0);
+      }
+    }
+    if (normalize) {
+      rune = normalizeRune(rune);
+    }
+    if (rune === pattern[pidx]) {
+      if (withPos && pos !== null) {
+        pos.add(idx);
+      }
+      score += SCORE_MATCH;
+      let bonus = bonusFor(prevCharClass, charClass);
+      if (consecutive === 0) {
+        firstBonus = bonus;
+      } else {
+        if (bonus === BONUS_BOUNDARY) {
+          firstBonus = bonus;
+        }
+        bonus = maxInt16(maxInt16(bonus, firstBonus), BONUS_CONSECUTIVE);
+      }
+      if (pidx === 0) {
+        score += bonus * BONUS_FIRST_CHAR_MULTIPLIER;
+      } else {
+        score += bonus;
+      }
+      inGap = false;
+      consecutive++;
+      pidx++;
+    } else {
+      if (inGap) {
+        score += SCORE_GAP_EXTENTION;
+      } else {
+        score += SCORE_GAP_START;
+      }
+      inGap = true;
+      consecutive = 0;
+      firstBonus = 0;
+    }
+    prevCharClass = charClass;
+  }
+  return [score, pos];
+}
+const fuzzyMatchV1 = (caseSensitive, normalize, forward, text, pattern, withPos, slab2) => {
+  if (pattern.length === 0) {
+    return [{ start: 0, end: 0, score: 0 }, null];
+  }
+  if (asciiFuzzyIndex(text, pattern, caseSensitive) < 0) {
+    return [{ start: -1, end: -1, score: 0 }, null];
+  }
+  let pidx = 0, sidx = -1, eidx = -1;
+  const lenRunes = text.length;
+  const lenPattern = pattern.length;
+  for (let index = 0; index < lenRunes; index++) {
+    let rune = text[indexAt(index, lenRunes, forward)];
+    if (!caseSensitive) {
+      if (rune >= CAPITAL_A_RUNE && rune <= CAPITAL_Z_RUNE) {
+        rune += 32;
+      } else if (rune > MAX_ASCII) {
+        rune = String.fromCodePoint(rune).toLowerCase().codePointAt(0);
+      }
+    }
+    if (normalize) {
+      rune = normalizeRune(rune);
+    }
+    const pchar = pattern[indexAt(pidx, lenPattern, forward)];
+    if (rune === pchar) {
+      if (sidx < 0) {
+        sidx = index;
+      }
+      pidx++;
+      if (pidx === lenPattern) {
+        eidx = index + 1;
+        break;
+      }
+    }
+  }
+  if (sidx >= 0 && eidx >= 0) {
+    pidx--;
+    for (let index = eidx - 1; index >= sidx; index--) {
+      const tidx = indexAt(index, lenRunes, forward);
+      let rune = text[tidx];
+      if (!caseSensitive) {
+        if (rune >= CAPITAL_A_RUNE && rune <= CAPITAL_Z_RUNE) {
+          rune += 32;
+        } else if (rune > MAX_ASCII) {
+          rune = String.fromCodePoint(rune).toLowerCase().codePointAt(0);
+        }
+      }
+      const pidx_ = indexAt(pidx, lenPattern, forward);
+      const pchar = pattern[pidx_];
+      if (rune === pchar) {
+        pidx--;
+        if (pidx < 0) {
+          sidx = index;
+          break;
+        }
+      }
+    }
+    if (!forward) {
+      const sidxTemp = sidx;
+      sidx = lenRunes - eidx;
+      eidx = lenRunes - sidxTemp;
+    }
+    const [score, pos] = calculateScore(
+      caseSensitive,
+      normalize,
+      text,
+      pattern,
+      sidx,
+      eidx,
+      withPos
+    );
+    return [{ start: sidx, end: eidx, score }, pos];
+  }
+  return [{ start: -1, end: -1, score: 0 }, null];
+};
+const exactMatchNaive = (caseSensitive, normalize, forward, text, pattern, withPos, slab2) => {
+  if (pattern.length === 0) {
+    return [{ start: 0, end: 0, score: 0 }, null];
+  }
+  const lenRunes = text.length;
+  const lenPattern = pattern.length;
+  if (lenRunes < lenPattern) {
+    return [{ start: -1, end: -1, score: 0 }, null];
+  }
+  if (asciiFuzzyIndex(text, pattern, caseSensitive) < 0) {
+    return [{ start: -1, end: -1, score: 0 }, null];
+  }
+  let pidx = 0;
+  let bestPos = -1, bonus = toShort(0), bestBonus = toShort(-1);
+  for (let index = 0; index < lenRunes; index++) {
+    const index_ = indexAt(index, lenRunes, forward);
+    let rune = text[index_];
+    if (!caseSensitive) {
+      if (rune >= CAPITAL_A_RUNE && rune <= CAPITAL_Z_RUNE) {
+        rune += 32;
+      } else if (rune > MAX_ASCII) {
+        rune = String.fromCodePoint(rune).toLowerCase().codePointAt(0);
+      }
+    }
+    if (normalize) {
+      rune = normalizeRune(rune);
+    }
+    const pidx_ = indexAt(pidx, lenPattern, forward);
+    const pchar = pattern[pidx_];
+    if (pchar === rune) {
+      if (pidx_ === 0) {
+        bonus = bonusAt(text, index_);
+      }
+      pidx++;
+      if (pidx === lenPattern) {
+        if (bonus > bestBonus) {
+          bestPos = index;
+          bestBonus = bonus;
+        }
+        if (bonus === BONUS_BOUNDARY) {
+          break;
+        }
+        index -= pidx - 1;
+        pidx = 0;
+        bonus = 0;
+      }
+    } else {
+      index -= pidx;
+      pidx = 0;
+      bonus = 0;
+    }
+  }
+  if (bestPos >= 0) {
+    let sidx = 0, eidx = 0;
+    if (forward) {
+      sidx = bestPos - lenPattern + 1;
+      eidx = bestPos + 1;
+    } else {
+      sidx = lenRunes - (bestPos + 1);
+      eidx = lenRunes - (bestPos - lenPattern + 1);
+    }
+    const [score] = calculateScore(caseSensitive, normalize, text, pattern, sidx, eidx, false);
+    return [{ start: sidx, end: eidx, score }, null];
+  }
+  return [{ start: -1, end: -1, score: 0 }, null];
+};
+const SLAB_16_SIZE = 100 * 1024;
+const SLAB_32_SIZE = 2048;
+function makeSlab(size16, size32) {
+  return {
+    i16: new Int16Array(size16),
+    i32: new Int32Array(size32)
+  };
+}
+const slab = makeSlab(SLAB_16_SIZE, SLAB_32_SIZE);
+const buildPatternForBasicMatch = (query, casing, normalize) => {
+  let caseSensitive = false;
+  switch (casing) {
+    case "smart-case":
+      if (query.toLowerCase() !== query) {
+        caseSensitive = true;
+      }
+      break;
+    case "case-sensitive":
+      caseSensitive = true;
+      break;
+    case "case-insensitive":
+      query = query.toLowerCase();
+      caseSensitive = false;
+      break;
+  }
+  let queryRunes = strToRunes(query);
+  if (normalize) {
+    queryRunes = queryRunes.map(normalizeRune);
+  }
+  return {
+    queryRunes,
+    caseSensitive
+  };
+};
+function getResultFromScoreMap(scoreMap, limit) {
+  const scoresInDesc = Object.keys(scoreMap).map((v) => parseInt(v, 10)).sort((a, b) => b - a);
+  let result = [];
+  for (const score of scoresInDesc) {
+    result = result.concat(scoreMap[score]);
+    if (result.length >= limit) {
+      break;
+    }
+  }
+  return result;
+}
+function getBasicMatchIter(scoreMap, queryRunes, caseSensitive) {
+  return (idx) => {
+    const itemRunes = this.runesList[idx];
+    if (queryRunes.length > itemRunes.length)
+      return;
+    let [match, positions] = this.algoFn(
+      caseSensitive,
+      this.opts.normalize,
+      this.opts.forward,
+      itemRunes,
+      queryRunes,
+      true,
+      slab
+    );
+    if (match.start === -1)
+      return;
+    if (this.opts.fuzzy === false) {
+      positions = /* @__PURE__ */ new Set();
+      for (let position = match.start; position < match.end; ++position) {
+        positions.add(position);
+      }
+    }
+    const scoreKey = this.opts.sort ? match.score : 0;
+    if (scoreMap[scoreKey] === void 0) {
+      scoreMap[scoreKey] = [];
+    }
+    scoreMap[scoreKey].push({
+      item: this.items[idx],
+      ...match,
+      positions: positions != null ? positions : /* @__PURE__ */ new Set()
+    });
+  };
+}
+function basicMatch(query) {
+  const { queryRunes, caseSensitive } = buildPatternForBasicMatch(
+    query,
+    this.opts.casing,
+    this.opts.normalize
+  );
+  const scoreMap = {};
+  const iter2 = getBasicMatchIter.bind(this)(
+    scoreMap,
+    queryRunes,
+    caseSensitive
+  );
+  for (let i = 0, len = this.runesList.length; i < len; ++i) {
+    iter2(i);
+  }
+  return getResultFromScoreMap(scoreMap, this.opts.limit);
+}
+const defaultOpts = {
+  limit: Infinity,
+  selector: (v) => v,
+  casing: "smart-case",
+  normalize: true,
+  fuzzy: "v2",
+  tiebreakers: [],
+  sort: true,
+  forward: true
+};
+class BaseFinder {
+  constructor(list, ...optionsTuple) {
+    this.opts = { ...defaultOpts, ...optionsTuple[0] };
+    this.items = list;
+    this.runesList = list.map((item) => strToRunes(this.opts.selector(item).normalize()));
+    this.algoFn = exactMatchNaive;
+    switch (this.opts.fuzzy) {
+      case "v2":
+        this.algoFn = fuzzyMatchV2;
+        break;
+      case "v1":
+        this.algoFn = fuzzyMatchV1;
+        break;
+    }
+  }
+}
+const syncDefaultOpts = {
+  ...defaultOpts,
+  match: basicMatch
+};
+class SyncFinder extends BaseFinder {
+  constructor(list, ...optionsTuple) {
+    super(list, ...optionsTuple);
+    this.opts = { ...syncDefaultOpts, ...optionsTuple[0] };
+  }
+  find(query) {
+    if (query.length === 0 || this.items.length === 0)
+      return this.items.slice(0, this.opts.limit).map(createResultItemWithEmptyPos);
+    query = query.normalize();
+    let result = this.opts.match.bind(this)(query);
+    return postProcessResultItems(result, this.opts);
+  }
+}
+const createResultItemWithEmptyPos = (item) => ({
+  item,
+  start: -1,
+  end: -1,
+  score: 0,
+  positions: /* @__PURE__ */ new Set()
+});
+function postProcessResultItems(result, opts) {
+  if (opts.sort) {
+    const { selector } = opts;
+    result.sort((a, b) => {
+      if (a.score === b.score) {
+        for (const tiebreaker of opts.tiebreakers) {
+          const diff = tiebreaker(a, b, selector);
+          if (diff !== 0) {
+            return diff;
+          }
+        }
+      }
+      return 0;
+    });
+  }
+  if (Number.isFinite(opts.limit)) {
+    result.splice(opts.limit);
+  }
+  return result;
+}
+function byLengthAsc(a, b, selector) {
+  return selector(a.item).length - selector(b.item).length;
+}
+class Fzf {
+  constructor(list, ...optionsTuple) {
+    this.finder = new SyncFinder(list, ...optionsTuple);
+    this.find = this.finder.find.bind(this.finder);
+  }
+}
+
+exports.Fzf = Fzf;
+exports.byLengthAsc = byLengthAsc;

praesentation/node_modules/@antfu/ni/dist/shared/ni.C4mrCGPc.mjs

@@ -0,0 +1,23 @@
+import fs from 'node:fs';
+import { resolve } from 'node:path';
+import process from 'node:process';
+
+function getPackageJSON(ctx) {
+  const cwd = ctx?.cwd ?? process.cwd();
+  const path = resolve(cwd, "package.json");
+  if (fs.existsSync(path)) {
+    try {
+      const raw = fs.readFileSync(path, "utf-8");
+      const data = JSON.parse(raw);
+      return data;
+    } catch (e) {
+      if (!ctx?.programmatic) {
+        console.warn("Failed to parse package.json");
+        process.exit(1);
+      }
+      throw e;
+    }
+  }
+}
+
+export { getPackageJSON as g };

praesentation/node_modules/@antfu/ni/dist/shared/ni.DA7akRvA.mjs

@@ -0,0 +1,918 @@
+/** @license
+ * fzf v0.5.2
+ * Copyright (c) 2021 Ajit
+ * Licensed under BSD 3-Clause
+ */
+const normalized = {
+  216: "O",
+  223: "s",
+  248: "o",
+  273: "d",
+  295: "h",
+  305: "i",
+  320: "l",
+  322: "l",
+  359: "t",
+  383: "s",
+  384: "b",
+  385: "B",
+  387: "b",
+  390: "O",
+  392: "c",
+  393: "D",
+  394: "D",
+  396: "d",
+  398: "E",
+  400: "E",
+  402: "f",
+  403: "G",
+  407: "I",
+  409: "k",
+  410: "l",
+  412: "M",
+  413: "N",
+  414: "n",
+  415: "O",
+  421: "p",
+  427: "t",
+  429: "t",
+  430: "T",
+  434: "V",
+  436: "y",
+  438: "z",
+  477: "e",
+  485: "g",
+  544: "N",
+  545: "d",
+  549: "z",
+  564: "l",
+  565: "n",
+  566: "t",
+  567: "j",
+  570: "A",
+  571: "C",
+  572: "c",
+  573: "L",
+  574: "T",
+  575: "s",
+  576: "z",
+  579: "B",
+  580: "U",
+  581: "V",
+  582: "E",
+  583: "e",
+  584: "J",
+  585: "j",
+  586: "Q",
+  587: "q",
+  588: "R",
+  589: "r",
+  590: "Y",
+  591: "y",
+  592: "a",
+  593: "a",
+  595: "b",
+  596: "o",
+  597: "c",
+  598: "d",
+  599: "d",
+  600: "e",
+  603: "e",
+  604: "e",
+  605: "e",
+  606: "e",
+  607: "j",
+  608: "g",
+  609: "g",
+  610: "G",
+  613: "h",
+  614: "h",
+  616: "i",
+  618: "I",
+  619: "l",
+  620: "l",
+  621: "l",
+  623: "m",
+  624: "m",
+  625: "m",
+  626: "n",
+  627: "n",
+  628: "N",
+  629: "o",
+  633: "r",
+  634: "r",
+  635: "r",
+  636: "r",
+  637: "r",
+  638: "r",
+  639: "r",
+  640: "R",
+  641: "R",
+  642: "s",
+  647: "t",
+  648: "t",
+  649: "u",
+  651: "v",
+  652: "v",
+  653: "w",
+  654: "y",
+  655: "Y",
+  656: "z",
+  657: "z",
+  663: "c",
+  665: "B",
+  666: "e",
+  667: "G",
+  668: "H",
+  669: "j",
+  670: "k",
+  671: "L",
+  672: "q",
+  686: "h",
+  867: "a",
+  868: "e",
+  869: "i",
+  870: "o",
+  871: "u",
+  872: "c",
+  873: "d",
+  874: "h",
+  875: "m",
+  876: "r",
+  877: "t",
+  878: "v",
+  879: "x",
+  7424: "A",
+  7427: "B",
+  7428: "C",
+  7429: "D",
+  7431: "E",
+  7432: "e",
+  7433: "i",
+  7434: "J",
+  7435: "K",
+  7436: "L",
+  7437: "M",
+  7438: "N",
+  7439: "O",
+  7440: "O",
+  7441: "o",
+  7442: "o",
+  7443: "o",
+  7446: "o",
+  7447: "o",
+  7448: "P",
+  7449: "R",
+  7450: "R",
+  7451: "T",
+  7452: "U",
+  7453: "u",
+  7454: "u",
+  7455: "m",
+  7456: "V",
+  7457: "W",
+  7458: "Z",
+  7522: "i",
+  7523: "r",
+  7524: "u",
+  7525: "v",
+  7834: "a",
+  7835: "s",
+  8305: "i",
+  8341: "h",
+  8342: "k",
+  8343: "l",
+  8344: "m",
+  8345: "n",
+  8346: "p",
+  8347: "s",
+  8348: "t",
+  8580: "c"
+};
+for (let i = "\u0300".codePointAt(0); i <= "\u036F".codePointAt(0); ++i) {
+  const diacritic = String.fromCodePoint(i);
+  for (const asciiChar of "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz") {
+    const withDiacritic = (asciiChar + diacritic).normalize();
+    const withDiacriticCodePoint = withDiacritic.codePointAt(0);
+    if (withDiacriticCodePoint > 126) {
+      normalized[withDiacriticCodePoint] = asciiChar;
+    }
+  }
+}
+const ranges = {
+  a: [7844, 7863],
+  e: [7870, 7879],
+  o: [7888, 7907],
+  u: [7912, 7921]
+};
+for (const lowerChar of Object.keys(ranges)) {
+  const upperChar = lowerChar.toUpperCase();
+  for (let i = ranges[lowerChar][0]; i <= ranges[lowerChar][1]; ++i) {
+    normalized[i] = i % 2 === 0 ? upperChar : lowerChar;
+  }
+}
+function normalizeRune(rune) {
+  if (rune < 192 || rune > 8580) {
+    return rune;
+  }
+  const normalizedChar = normalized[rune];
+  if (normalizedChar !== void 0)
+    return normalizedChar.codePointAt(0);
+  return rune;
+}
+function toShort(number) {
+  return number;
+}
+function toInt(number) {
+  return number;
+}
+function maxInt16(num1, num2) {
+  return num1 > num2 ? num1 : num2;
+}
+const strToRunes = (str) => str.split("").map((s) => s.codePointAt(0));
+const whitespaceRunes = new Set(
+  " \f\n\r	\v\xA0\u1680\u2028\u2029\u202F\u205F\u3000\uFEFF".split("").map((v) => v.codePointAt(0))
+);
+for (let codePoint = "\u2000".codePointAt(0); codePoint <= "\u200A".codePointAt(0); codePoint++) {
+  whitespaceRunes.add(codePoint);
+}
+const MAX_ASCII = "\x7F".codePointAt(0);
+const CAPITAL_A_RUNE = "A".codePointAt(0);
+const CAPITAL_Z_RUNE = "Z".codePointAt(0);
+const SMALL_A_RUNE = "a".codePointAt(0);
+const SMALL_Z_RUNE = "z".codePointAt(0);
+const NUMERAL_ZERO_RUNE = "0".codePointAt(0);
+const NUMERAL_NINE_RUNE = "9".codePointAt(0);
+function indexAt(index, max, forward) {
+  if (forward) {
+    return index;
+  }
+  return max - index - 1;
+}
+const SCORE_MATCH = 16, SCORE_GAP_START = -3, SCORE_GAP_EXTENTION = -1, BONUS_BOUNDARY = SCORE_MATCH / 2, BONUS_NON_WORD = SCORE_MATCH / 2, BONUS_CAMEL_123 = BONUS_BOUNDARY + SCORE_GAP_EXTENTION, BONUS_CONSECUTIVE = -(SCORE_GAP_START + SCORE_GAP_EXTENTION), BONUS_FIRST_CHAR_MULTIPLIER = 2;
+function createPosSet(withPos) {
+  if (withPos) {
+    return /* @__PURE__ */ new Set();
+  }
+  return null;
+}
+function alloc16(offset, slab2, size) {
+  if (slab2 !== null && slab2.i16.length > offset + size) {
+    const subarray = slab2.i16.subarray(offset, offset + size);
+    return [offset + size, subarray];
+  }
+  return [offset, new Int16Array(size)];
+}
+function alloc32(offset, slab2, size) {
+  if (slab2 !== null && slab2.i32.length > offset + size) {
+    const subarray = slab2.i32.subarray(offset, offset + size);
+    return [offset + size, subarray];
+  }
+  return [offset, new Int32Array(size)];
+}
+function charClassOfAscii(rune) {
+  if (rune >= SMALL_A_RUNE && rune <= SMALL_Z_RUNE) {
+    return 1;
+  } else if (rune >= CAPITAL_A_RUNE && rune <= CAPITAL_Z_RUNE) {
+    return 2;
+  } else if (rune >= NUMERAL_ZERO_RUNE && rune <= NUMERAL_NINE_RUNE) {
+    return 4;
+  } else {
+    return 0;
+  }
+}
+function charClassOfNonAscii(rune) {
+  const char = String.fromCodePoint(rune);
+  if (char !== char.toUpperCase()) {
+    return 1;
+  } else if (char !== char.toLowerCase()) {
+    return 2;
+  } else if (char.match(/\p{Number}/gu) !== null) {
+    return 4;
+  } else if (char.match(/\p{Letter}/gu) !== null) {
+    return 3;
+  }
+  return 0;
+}
+function charClassOf(rune) {
+  if (rune <= MAX_ASCII) {
+    return charClassOfAscii(rune);
+  }
+  return charClassOfNonAscii(rune);
+}
+function bonusFor(prevClass, currClass) {
+  if (prevClass === 0 && currClass !== 0) {
+    return BONUS_BOUNDARY;
+  } else if (prevClass === 1 && currClass === 2 || prevClass !== 4 && currClass === 4) {
+    return BONUS_CAMEL_123;
+  } else if (currClass === 0) {
+    return BONUS_NON_WORD;
+  }
+  return 0;
+}
+function bonusAt(input, idx) {
+  if (idx === 0) {
+    return BONUS_BOUNDARY;
+  }
+  return bonusFor(charClassOf(input[idx - 1]), charClassOf(input[idx]));
+}
+function trySkip(input, caseSensitive, char, from) {
+  let rest = input.slice(from);
+  let idx = rest.indexOf(char);
+  if (idx === 0) {
+    return from;
+  }
+  if (!caseSensitive && char >= SMALL_A_RUNE && char <= SMALL_Z_RUNE) {
+    if (idx > 0) {
+      rest = rest.slice(0, idx);
+    }
+    const uidx = rest.indexOf(char - 32);
+    if (uidx >= 0) {
+      idx = uidx;
+    }
+  }
+  if (idx < 0) {
+    return -1;
+  }
+  return from + idx;
+}
+function isAscii(runes) {
+  for (const rune of runes) {
+    if (rune >= 128) {
+      return false;
+    }
+  }
+  return true;
+}
+function asciiFuzzyIndex(input, pattern, caseSensitive) {
+  if (!isAscii(input)) {
+    return 0;
+  }
+  if (!isAscii(pattern)) {
+    return -1;
+  }
+  let firstIdx = 0, idx = 0;
+  for (let pidx = 0; pidx < pattern.length; pidx++) {
+    idx = trySkip(input, caseSensitive, pattern[pidx], idx);
+    if (idx < 0) {
+      return -1;
+    }
+    if (pidx === 0 && idx > 0) {
+      firstIdx = idx - 1;
+    }
+    idx++;
+  }
+  return firstIdx;
+}
+const fuzzyMatchV2 = (caseSensitive, normalize, forward, input, pattern, withPos, slab2) => {
+  const M = pattern.length;
+  if (M === 0) {
+    return [{ start: 0, end: 0, score: 0 }, createPosSet(withPos)];
+  }
+  const N = input.length;
+  if (slab2 !== null && N * M > slab2.i16.length) {
+    return fuzzyMatchV1(caseSensitive, normalize, forward, input, pattern, withPos);
+  }
+  const idx = asciiFuzzyIndex(input, pattern, caseSensitive);
+  if (idx < 0) {
+    return [{ start: -1, end: -1, score: 0 }, null];
+  }
+  let offset16 = 0, offset32 = 0, H0 = null, C0 = null, B = null, F = null;
+  [offset16, H0] = alloc16(offset16, slab2, N);
+  [offset16, C0] = alloc16(offset16, slab2, N);
+  [offset16, B] = alloc16(offset16, slab2, N);
+  [offset32, F] = alloc32(offset32, slab2, M);
+  const [, T] = alloc32(offset32, slab2, N);
+  for (let i = 0; i < T.length; i++) {
+    T[i] = input[i];
+  }
+  let maxScore = toShort(0), maxScorePos = 0;
+  let pidx = 0, lastIdx = 0;
+  const pchar0 = pattern[0];
+  let pchar = pattern[0], prevH0 = toShort(0), prevCharClass = 0, inGap = false;
+  let Tsub = T.subarray(idx);
+  let H0sub = H0.subarray(idx).subarray(0, Tsub.length), C0sub = C0.subarray(idx).subarray(0, Tsub.length), Bsub = B.subarray(idx).subarray(0, Tsub.length);
+  for (let [off, char] of Tsub.entries()) {
+    let charClass = null;
+    if (char <= MAX_ASCII) {
+      charClass = charClassOfAscii(char);
+      if (!caseSensitive && charClass === 2) {
+        char += 32;
+      }
+    } else {
+      charClass = charClassOfNonAscii(char);
+      if (!caseSensitive && charClass === 2) {
+        char = String.fromCodePoint(char).toLowerCase().codePointAt(0);
+      }
+      if (normalize) {
+        char = normalizeRune(char);
+      }
+    }
+    Tsub[off] = char;
+    const bonus = bonusFor(prevCharClass, charClass);
+    Bsub[off] = bonus;
+    prevCharClass = charClass;
+    if (char === pchar) {
+      if (pidx < M) {
+        F[pidx] = toInt(idx + off);
+        pidx++;
+        pchar = pattern[Math.min(pidx, M - 1)];
+      }
+      lastIdx = idx + off;
+    }
+    if (char === pchar0) {
+      const score = SCORE_MATCH + bonus * BONUS_FIRST_CHAR_MULTIPLIER;
+      H0sub[off] = score;
+      C0sub[off] = 1;
+      if (M === 1 && (forward && score > maxScore || !forward && score >= maxScore)) {
+        maxScore = score;
+        maxScorePos = idx + off;
+        if (forward && bonus === BONUS_BOUNDARY) {
+          break;
+        }
+      }
+      inGap = false;
+    } else {
+      if (inGap) {
+        H0sub[off] = maxInt16(prevH0 + SCORE_GAP_EXTENTION, 0);
+      } else {
+        H0sub[off] = maxInt16(prevH0 + SCORE_GAP_START, 0);
+      }
+      C0sub[off] = 0;
+      inGap = true;
+    }
+    prevH0 = H0sub[off];
+  }
+  if (pidx !== M) {
+    return [{ start: -1, end: -1, score: 0 }, null];
+  }
+  if (M === 1) {
+    const result = {
+      start: maxScorePos,
+      end: maxScorePos + 1,
+      score: maxScore
+    };
+    if (!withPos) {
+      return [result, null];
+    }
+    const pos2 = /* @__PURE__ */ new Set();
+    pos2.add(maxScorePos);
+    return [result, pos2];
+  }
+  const f0 = F[0];
+  const width = lastIdx - f0 + 1;
+  let H = null;
+  [offset16, H] = alloc16(offset16, slab2, width * M);
+  {
+    const toCopy = H0.subarray(f0, lastIdx + 1);
+    for (const [i, v] of toCopy.entries()) {
+      H[i] = v;
+    }
+  }
+  let [, C] = alloc16(offset16, slab2, width * M);
+  {
+    const toCopy = C0.subarray(f0, lastIdx + 1);
+    for (const [i, v] of toCopy.entries()) {
+      C[i] = v;
+    }
+  }
+  const Fsub = F.subarray(1);
+  const Psub = pattern.slice(1).slice(0, Fsub.length);
+  for (const [off, f] of Fsub.entries()) {
+    let inGap2 = false;
+    const pchar2 = Psub[off], pidx2 = off + 1, row = pidx2 * width, Tsub2 = T.subarray(f, lastIdx + 1), Bsub2 = B.subarray(f).subarray(0, Tsub2.length), Csub = C.subarray(row + f - f0).subarray(0, Tsub2.length), Cdiag = C.subarray(row + f - f0 - 1 - width).subarray(0, Tsub2.length), Hsub = H.subarray(row + f - f0).subarray(0, Tsub2.length), Hdiag = H.subarray(row + f - f0 - 1 - width).subarray(0, Tsub2.length), Hleft = H.subarray(row + f - f0 - 1).subarray(0, Tsub2.length);
+    Hleft[0] = 0;
+    for (const [off2, char] of Tsub2.entries()) {
+      const col = off2 + f;
+      let s1 = 0, s2 = 0, consecutive = 0;
+      if (inGap2) {
+        s2 = Hleft[off2] + SCORE_GAP_EXTENTION;
+      } else {
+        s2 = Hleft[off2] + SCORE_GAP_START;
+      }
+      if (pchar2 === char) {
+        s1 = Hdiag[off2] + SCORE_MATCH;
+        let b = Bsub2[off2];
+        consecutive = Cdiag[off2] + 1;
+        if (b === BONUS_BOUNDARY) {
+          consecutive = 1;
+        } else if (consecutive > 1) {
+          b = maxInt16(b, maxInt16(BONUS_CONSECUTIVE, B[col - consecutive + 1]));
+        }
+        if (s1 + b < s2) {
+          s1 += Bsub2[off2];
+          consecutive = 0;
+        } else {
+          s1 += b;
+        }
+      }
+      Csub[off2] = consecutive;
+      inGap2 = s1 < s2;
+      const score = maxInt16(maxInt16(s1, s2), 0);
+      if (pidx2 === M - 1 && (forward && score > maxScore || !forward && score >= maxScore)) {
+        maxScore = score;
+        maxScorePos = col;
+      }
+      Hsub[off2] = score;
+    }
+  }
+  const pos = createPosSet(withPos);
+  let j = f0;
+  if (withPos && pos !== null) {
+    let i = M - 1;
+    j = maxScorePos;
+    let preferMatch = true;
+    while (true) {
+      const I = i * width, j0 = j - f0, s = H[I + j0];
+      let s1 = 0, s2 = 0;
+      if (i > 0 && j >= F[i]) {
+        s1 = H[I - width + j0 - 1];
+      }
+      if (j > F[i]) {
+        s2 = H[I + j0 - 1];
+      }
+      if (s > s1 && (s > s2 || s === s2 && preferMatch)) {
+        pos.add(j);
+        if (i === 0) {
+          break;
+        }
+        i--;
+      }
+      preferMatch = C[I + j0] > 1 || I + width + j0 + 1 < C.length && C[I + width + j0 + 1] > 0;
+      j--;
+    }
+  }
+  return [{ start: j, end: maxScorePos + 1, score: maxScore }, pos];
+};
+function calculateScore(caseSensitive, normalize, text, pattern, sidx, eidx, withPos) {
+  let pidx = 0, score = 0, inGap = false, consecutive = 0, firstBonus = toShort(0);
+  const pos = createPosSet(withPos);
+  let prevCharClass = 0;
+  if (sidx > 0) {
+    prevCharClass = charClassOf(text[sidx - 1]);
+  }
+  for (let idx = sidx; idx < eidx; idx++) {
+    let rune = text[idx];
+    const charClass = charClassOf(rune);
+    if (!caseSensitive) {
+      if (rune >= CAPITAL_A_RUNE && rune <= CAPITAL_Z_RUNE) {
+        rune += 32;
+      } else if (rune > MAX_ASCII) {
+        rune = String.fromCodePoint(rune).toLowerCase().codePointAt(0);
+      }
+    }
+    if (normalize) {
+      rune = normalizeRune(rune);
+    }
+    if (rune === pattern[pidx]) {
+      if (withPos && pos !== null) {
+        pos.add(idx);
+      }
+      score += SCORE_MATCH;
+      let bonus = bonusFor(prevCharClass, charClass);
+      if (consecutive === 0) {
+        firstBonus = bonus;
+      } else {
+        if (bonus === BONUS_BOUNDARY) {
+          firstBonus = bonus;
+        }
+        bonus = maxInt16(maxInt16(bonus, firstBonus), BONUS_CONSECUTIVE);
+      }
+      if (pidx === 0) {
+        score += bonus * BONUS_FIRST_CHAR_MULTIPLIER;
+      } else {
+        score += bonus;
+      }
+      inGap = false;
+      consecutive++;
+      pidx++;
+    } else {
+      if (inGap) {
+        score += SCORE_GAP_EXTENTION;
+      } else {
+        score += SCORE_GAP_START;
+      }
+      inGap = true;
+      consecutive = 0;
+      firstBonus = 0;
+    }
+    prevCharClass = charClass;
+  }
+  return [score, pos];
+}
+const fuzzyMatchV1 = (caseSensitive, normalize, forward, text, pattern, withPos, slab2) => {
+  if (pattern.length === 0) {
+    return [{ start: 0, end: 0, score: 0 }, null];
+  }
+  if (asciiFuzzyIndex(text, pattern, caseSensitive) < 0) {
+    return [{ start: -1, end: -1, score: 0 }, null];
+  }
+  let pidx = 0, sidx = -1, eidx = -1;
+  const lenRunes = text.length;
+  const lenPattern = pattern.length;
+  for (let index = 0; index < lenRunes; index++) {
+    let rune = text[indexAt(index, lenRunes, forward)];
+    if (!caseSensitive) {
+      if (rune >= CAPITAL_A_RUNE && rune <= CAPITAL_Z_RUNE) {
+        rune += 32;
+      } else if (rune > MAX_ASCII) {
+        rune = String.fromCodePoint(rune).toLowerCase().codePointAt(0);
+      }
+    }
+    if (normalize) {
+      rune = normalizeRune(rune);
+    }
+    const pchar = pattern[indexAt(pidx, lenPattern, forward)];
+    if (rune === pchar) {
+      if (sidx < 0) {
+        sidx = index;
+      }
+      pidx++;
+      if (pidx === lenPattern) {
+        eidx = index + 1;
+        break;
+      }
+    }
+  }
+  if (sidx >= 0 && eidx >= 0) {
+    pidx--;
+    for (let index = eidx - 1; index >= sidx; index--) {
+      const tidx = indexAt(index, lenRunes, forward);
+      let rune = text[tidx];
+      if (!caseSensitive) {
+        if (rune >= CAPITAL_A_RUNE && rune <= CAPITAL_Z_RUNE) {
+          rune += 32;
+        } else if (rune > MAX_ASCII) {
+          rune = String.fromCodePoint(rune).toLowerCase().codePointAt(0);
+        }
+      }
+      const pidx_ = indexAt(pidx, lenPattern, forward);
+      const pchar = pattern[pidx_];
+      if (rune === pchar) {
+        pidx--;
+        if (pidx < 0) {
+          sidx = index;
+          break;
+        }
+      }
+    }
+    if (!forward) {
+      const sidxTemp = sidx;
+      sidx = lenRunes - eidx;
+      eidx = lenRunes - sidxTemp;
+    }
+    const [score, pos] = calculateScore(
+      caseSensitive,
+      normalize,
+      text,
+      pattern,
+      sidx,
+      eidx,
+      withPos
+    );
+    return [{ start: sidx, end: eidx, score }, pos];
+  }
+  return [{ start: -1, end: -1, score: 0 }, null];
+};
+const exactMatchNaive = (caseSensitive, normalize, forward, text, pattern, withPos, slab2) => {
+  if (pattern.length === 0) {
+    return [{ start: 0, end: 0, score: 0 }, null];
+  }
+  const lenRunes = text.length;
+  const lenPattern = pattern.length;
+  if (lenRunes < lenPattern) {
+    return [{ start: -1, end: -1, score: 0 }, null];
+  }
+  if (asciiFuzzyIndex(text, pattern, caseSensitive) < 0) {
+    return [{ start: -1, end: -1, score: 0 }, null];
+  }
+  let pidx = 0;
+  let bestPos = -1, bonus = toShort(0), bestBonus = toShort(-1);
+  for (let index = 0; index < lenRunes; index++) {
+    const index_ = indexAt(index, lenRunes, forward);
+    let rune = text[index_];
+    if (!caseSensitive) {
+      if (rune >= CAPITAL_A_RUNE && rune <= CAPITAL_Z_RUNE) {
+        rune += 32;
+      } else if (rune > MAX_ASCII) {
+        rune = String.fromCodePoint(rune).toLowerCase().codePointAt(0);
+      }
+    }
+    if (normalize) {
+      rune = normalizeRune(rune);
+    }
+    const pidx_ = indexAt(pidx, lenPattern, forward);
+    const pchar = pattern[pidx_];
+    if (pchar === rune) {
+      if (pidx_ === 0) {
+        bonus = bonusAt(text, index_);
+      }
+      pidx++;
+      if (pidx === lenPattern) {
+        if (bonus > bestBonus) {
+          bestPos = index;
+          bestBonus = bonus;
+        }
+        if (bonus === BONUS_BOUNDARY) {
+          break;
+        }
+        index -= pidx - 1;
+        pidx = 0;
+        bonus = 0;
+      }
+    } else {
+      index -= pidx;
+      pidx = 0;
+      bonus = 0;
+    }
+  }
+  if (bestPos >= 0) {
+    let sidx = 0, eidx = 0;
+    if (forward) {
+      sidx = bestPos - lenPattern + 1;
+      eidx = bestPos + 1;
+    } else {
+      sidx = lenRunes - (bestPos + 1);
+      eidx = lenRunes - (bestPos - lenPattern + 1);
+    }
+    const [score] = calculateScore(caseSensitive, normalize, text, pattern, sidx, eidx, false);
+    return [{ start: sidx, end: eidx, score }, null];
+  }
+  return [{ start: -1, end: -1, score: 0 }, null];
+};
+const SLAB_16_SIZE = 100 * 1024;
+const SLAB_32_SIZE = 2048;
+function makeSlab(size16, size32) {
+  return {
+    i16: new Int16Array(size16),
+    i32: new Int32Array(size32)
+  };
+}
+const slab = makeSlab(SLAB_16_SIZE, SLAB_32_SIZE);
+const buildPatternForBasicMatch = (query, casing, normalize) => {
+  let caseSensitive = false;
+  switch (casing) {
+    case "smart-case":
+      if (query.toLowerCase() !== query) {
+        caseSensitive = true;
+      }
+      break;
+    case "case-sensitive":
+      caseSensitive = true;
+      break;
+    case "case-insensitive":
+      query = query.toLowerCase();
+      caseSensitive = false;
+      break;
+  }
+  let queryRunes = strToRunes(query);
+  if (normalize) {
+    queryRunes = queryRunes.map(normalizeRune);
+  }
+  return {
+    queryRunes,
+    caseSensitive
+  };
+};
+function getResultFromScoreMap(scoreMap, limit) {
+  const scoresInDesc = Object.keys(scoreMap).map((v) => parseInt(v, 10)).sort((a, b) => b - a);
+  let result = [];
+  for (const score of scoresInDesc) {
+    result = result.concat(scoreMap[score]);
+    if (result.length >= limit) {
+      break;
+    }
+  }
+  return result;
+}
+function getBasicMatchIter(scoreMap, queryRunes, caseSensitive) {
+  return (idx) => {
+    const itemRunes = this.runesList[idx];
+    if (queryRunes.length > itemRunes.length)
+      return;
+    let [match, positions] = this.algoFn(
+      caseSensitive,
+      this.opts.normalize,
+      this.opts.forward,
+      itemRunes,
+      queryRunes,
+      true,
+      slab
+    );
+    if (match.start === -1)
+      return;
+    if (this.opts.fuzzy === false) {
+      positions = /* @__PURE__ */ new Set();
+      for (let position = match.start; position < match.end; ++position) {
+        positions.add(position);
+      }
+    }
+    const scoreKey = this.opts.sort ? match.score : 0;
+    if (scoreMap[scoreKey] === void 0) {
+      scoreMap[scoreKey] = [];
+    }
+    scoreMap[scoreKey].push({
+      item: this.items[idx],
+      ...match,
+      positions: positions != null ? positions : /* @__PURE__ */ new Set()
+    });
+  };
+}
+function basicMatch(query) {
+  const { queryRunes, caseSensitive } = buildPatternForBasicMatch(
+    query,
+    this.opts.casing,
+    this.opts.normalize
+  );
+  const scoreMap = {};
+  const iter2 = getBasicMatchIter.bind(this)(
+    scoreMap,
+    queryRunes,
+    caseSensitive
+  );
+  for (let i = 0, len = this.runesList.length; i < len; ++i) {
+    iter2(i);
+  }
+  return getResultFromScoreMap(scoreMap, this.opts.limit);
+}
+const defaultOpts = {
+  limit: Infinity,
+  selector: (v) => v,
+  casing: "smart-case",
+  normalize: true,
+  fuzzy: "v2",
+  tiebreakers: [],
+  sort: true,
+  forward: true
+};
+class BaseFinder {
+  constructor(list, ...optionsTuple) {
+    this.opts = { ...defaultOpts, ...optionsTuple[0] };
+    this.items = list;
+    this.runesList = list.map((item) => strToRunes(this.opts.selector(item).normalize()));
+    this.algoFn = exactMatchNaive;
+    switch (this.opts.fuzzy) {
+      case "v2":
+        this.algoFn = fuzzyMatchV2;
+        break;
+      case "v1":
+        this.algoFn = fuzzyMatchV1;
+        break;
+    }
+  }
+}
+const syncDefaultOpts = {
+  ...defaultOpts,
+  match: basicMatch
+};
+class SyncFinder extends BaseFinder {
+  constructor(list, ...optionsTuple) {
+    super(list, ...optionsTuple);
+    this.opts = { ...syncDefaultOpts, ...optionsTuple[0] };
+  }
+  find(query) {
+    if (query.length === 0 || this.items.length === 0)
+      return this.items.slice(0, this.opts.limit).map(createResultItemWithEmptyPos);
+    query = query.normalize();
+    let result = this.opts.match.bind(this)(query);
+    return postProcessResultItems(result, this.opts);
+  }
+}
+const createResultItemWithEmptyPos = (item) => ({
+  item,
+  start: -1,
+  end: -1,
+  score: 0,
+  positions: /* @__PURE__ */ new Set()
+});
+function postProcessResultItems(result, opts) {
+  if (opts.sort) {
+    const { selector } = opts;
+    result.sort((a, b) => {
+      if (a.score === b.score) {
+        for (const tiebreaker of opts.tiebreakers) {
+          const diff = tiebreaker(a, b, selector);
+          if (diff !== 0) {
+            return diff;
+          }
+        }
+      }
+      return 0;
+    });
+  }
+  if (Number.isFinite(opts.limit)) {
+    result.splice(opts.limit);
+  }
+  return result;
+}
+function byLengthAsc(a, b, selector) {
+  return selector(a.item).length - selector(b.item).length;
+}
+class Fzf {
+  constructor(list, ...optionsTuple) {
+    this.finder = new SyncFinder(list, ...optionsTuple);
+    this.find = this.finder.find.bind(this.finder);
+  }
+}
+
+export { Fzf as F, byLengthAsc as b };

praesentation/node_modules/@antfu/ni/dist/shared/ni.DWRIF_6-.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const process = require('node:process');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+const process__default = /*#__PURE__*/_interopDefaultCompat(process);
+
+function getPackageJSON(ctx) {
+  const cwd = ctx?.cwd ?? process__default.cwd();
+  const path$1 = path.resolve(cwd, "package.json");
+  if (fs__default.existsSync(path$1)) {
+    try {
+      const raw = fs__default.readFileSync(path$1, "utf-8");
+      const data = JSON.parse(raw);
+      return data;
+    } catch (e) {
+      if (!ctx?.programmatic) {
+        console.warn("Failed to parse package.json");
+        process__default.exit(1);
+      }
+      throw e;
+    }
+  }
+}
+
+exports.getPackageJSON = getPackageJSON;