digital-garden/.obsidian/plugins/home-tab/main.js

/*
THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
if you want to view the source, please visit the github repository of this plugin
*/

var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJS = (cb, mod) => function __require() {
  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// node_modules/font-list/libs/darwin/index.js
var require_darwin = __commonJS({
  "node_modules/font-list/libs/darwin/index.js"(exports, module2) {
    "use strict";
    var path = require("path");
    var execFile = require("child_process").execFile;
    var bin = path.join(__dirname, "fontlist");
    var font_exceptions = ["iconfont"];
    function tryToGetFonts(s) {
      let fonts = [];
      let m = s.match(/\(([\s\S]+)\)/);
      if (m) {
        fonts = m[1].split("\n").map((i) => i.trim()).map((i) => i.replace(/,$/, ""));
      }
      return fonts;
    }
    module2.exports = () => new Promise((resolve, reject) => {
      execFile(bin, { maxBuffer: 1024 * 1024 * 10 }, (error, stdout, stderr) => {
        if (error) {
          reject(error);
          return;
        }
        let fonts = [];
        if (stdout) {
          fonts = fonts.concat(tryToGetFonts(stdout));
        }
        if (stderr) {
          fonts = fonts.concat(tryToGetFonts(stderr));
        }
        fonts = Array.from(new Set(fonts)).filter((i) => i && !font_exceptions.includes(i));
        resolve(fonts);
      });
    });
  }
});

// node_modules/font-list/libs/win32/getByPowerShell.js
var require_getByPowerShell = __commonJS({
  "node_modules/font-list/libs/win32/getByPowerShell.js"(exports, module2) {
    var exec = require("child_process").exec;
    var parse2 = (str) => {
      return str.split("\n").map((ln) => ln.trim()).filter((f) => !!f);
    };
    module2.exports = () => new Promise((resolve, reject) => {
      let cmd = `chcp 65001|powershell -command "chcp 65001|Out-Null;Add-Type -AssemblyName PresentationCore;$families=[Windows.Media.Fonts]::SystemFontFamilies;foreach($family in $families){$name='';if(!$family.FamilyNames.TryGetValue([Windows.Markup.XmlLanguage]::GetLanguage('zh-cn'),[ref]$name)){$name=$family.FamilyNames[[Windows.Markup.XmlLanguage]::GetLanguage('en-us')]}echo $name}"`;
      exec(cmd, { maxBuffer: 1024 * 1024 * 10 }, (err, stdout) => {
        if (err) {
          reject(err);
          return;
        }
        resolve(parse2(stdout));
      });
    });
  }
});

// node_modules/font-list/libs/win32/getByVBS.js
var require_getByVBS = __commonJS({
  "node_modules/font-list/libs/win32/getByVBS.js"(exports, module2) {
    var os = require("os");
    var fs = require("fs");
    var path = require("path");
    var execFile = require("child_process").execFile;
    var util = require("util");
    var p_copyFile = util.promisify(fs.copyFile);
    function tryToGetFonts(s) {
      let a = s.split("\n");
      if (a[0].includes("Microsoft")) {
        a.splice(0, 3);
      }
      a = a.map((i) => {
        i = i.split("	")[0].split(path.sep);
        i = i[i.length - 1];
        if (!i.match(/^[\w\s]+$/)) {
          i = "";
        }
        i = i.replace(/^\s+|\s+$/g, "").replace(/(Regular|常规)$/i, "").replace(/^\s+|\s+$/g, "");
        return i;
      });
      return a.filter((i) => i);
    }
    async function writeToTmpDir(fn2) {
      let tmp_fn = path.join(os.tmpdir(), "node-font-list-fonts.vbs");
      await p_copyFile(fn2, tmp_fn);
      return tmp_fn;
    }
    module2.exports = async () => {
      let fn2 = path.join(__dirname, "fonts.vbs");
      const is_in_asar = fn2.includes("app.asar");
      if (is_in_asar) {
        fn2 = await writeToTmpDir(fn2);
      }
      return new Promise((resolve, reject) => {
        let cmd = `cscript`;
        execFile(cmd, [fn2], { maxBuffer: 1024 * 1024 * 10 }, (err, stdout, stderr) => {
          let fonts = [];
          if (err) {
            reject(err);
            return;
          }
          if (stdout) {
            fonts = fonts.concat(tryToGetFonts(stdout));
          }
          if (stderr) {
            fonts = fonts.concat(tryToGetFonts(stderr));
          }
          resolve(fonts);
        });
      });
    };
  }
});

// node_modules/font-list/libs/win32/index.js
var require_win32 = __commonJS({
  "node_modules/font-list/libs/win32/index.js"(exports, module2) {
    "use strict";
    var os = require("os");
    var getByPowerShell = require_getByPowerShell();
    var getByVBS = require_getByVBS();
    var methods_new = [getByPowerShell, getByVBS];
    var methods_old = [getByVBS, getByPowerShell];
    module2.exports = async () => {
      let fonts = [];
      let os_v = parseInt(os.release());
      let methods = os_v >= 10 ? methods_new : methods_old;
      for (let method of methods) {
        try {
          fonts = await method();
          if (fonts.length > 0)
            break;
        } catch (e) {
          console.log(e);
        }
      }
      return fonts;
    };
  }
});

// node_modules/font-list/libs/linux/index.js
var require_linux = __commonJS({
  "node_modules/font-list/libs/linux/index.js"(exports, module2) {
    var exec = require("child_process").exec;
    var util = require("util");
    var pexec = util.promisify(exec);
    async function binaryExists(binary) {
      const { stdout } = await pexec(`whereis ${binary}`);
      return stdout.length > binary.length + 2;
    }
    module2.exports = async () => {
      const fcListBinary = await binaryExists("fc-list") ? "fc-list" : "fc-list2";
      const cmd = fcListBinary + ' -f "%{family[0]}\\n"';
      const { stdout } = await pexec(cmd, { maxBuffer: 1024 * 1024 * 10 });
      const fonts = stdout.split("\n").filter((f) => !!f);
      return Array.from(new Set(fonts));
    };
  }
});

// node_modules/font-list/index.js
var require_font_list = __commonJS({
  "node_modules/font-list/index.js"(exports) {
    "use strict";
    var platform = void 0;
    try {
      platform = process.platform;
    } catch (e) {
    }
    var getFontsFunc;
    switch (platform) {
      case "darwin":
        getFontsFunc = require_darwin();
        break;
      case "win32":
        getFontsFunc = require_win32();
        break;
      case "linux":
        getFontsFunc = require_linux();
        break;
      default:
    }
    var defaultOptions = {
      disableQuoting: false
    };
    exports.getFonts = async (options) => {
      options = Object.assign({}, defaultOptions, options);
      let fonts = await getFontsFunc();
      fonts = fonts.map((i) => {
        try {
          i = i.replace(/\\u([\da-f]{4})/ig, (m, s) => String.fromCharCode(parseInt(s, 16)));
        } catch (e) {
          console.log(e);
        }
        if (options && options.disableQuoting) {
          if (i.startsWith('"') && i.endsWith('"')) {
            i = `${i.substr(1, i.length - 2)}`;
          }
        } else if (i.includes(" ") && !i.startsWith('"')) {
          i = `"${i}"`;
        }
        return i;
      });
      fonts.sort((a, b) => {
        return a.replace(/^['"]+/, "").toLocaleLowerCase() < b.replace(/^['"]+/, "").toLocaleLowerCase() ? -1 : 1;
      });
      return fonts;
    };
  }
});

// src/main.ts
var main_exports = {};
__export(main_exports, {
  default: () => HomeTab
});
module.exports = __toCommonJS(main_exports);
var import_obsidian19 = require("obsidian");

// src/homeView.ts
var import_obsidian15 = require("obsidian");

// node_modules/svelte/internal/index.mjs
function noop() {
}
var identity = (x) => x;
function assign(tar, src) {
  for (const k in src)
    tar[k] = src[k];
  return tar;
}
function run(fn2) {
  return fn2();
}
function blank_object() {
  return /* @__PURE__ */ Object.create(null);
}
function run_all(fns) {
  fns.forEach(run);
}
function is_function(thing) {
  return typeof thing === "function";
}
function safe_not_equal(a, b) {
  return a != a ? b == b : a !== b || (a && typeof a === "object" || typeof a === "function");
}
var src_url_equal_anchor;
function src_url_equal(element_src, url) {
  if (!src_url_equal_anchor) {
    src_url_equal_anchor = document.createElement("a");
  }
  src_url_equal_anchor.href = url;
  return element_src === src_url_equal_anchor.href;
}
function is_empty(obj) {
  return Object.keys(obj).length === 0;
}
function subscribe(store, ...callbacks) {
  if (store == null) {
    return noop;
  }
  const unsub = store.subscribe(...callbacks);
  return unsub.unsubscribe ? () => unsub.unsubscribe() : unsub;
}
function get_store_value(store) {
  let value;
  subscribe(store, (_) => value = _)();
  return value;
}
function component_subscribe(component, store, callback) {
  component.$$.on_destroy.push(subscribe(store, callback));
}
function create_slot(definition, ctx, $$scope, fn2) {
  if (definition) {
    const slot_ctx = get_slot_context(definition, ctx, $$scope, fn2);
    return definition[0](slot_ctx);
  }
}
function get_slot_context(definition, ctx, $$scope, fn2) {
  return definition[1] && fn2 ? assign($$scope.ctx.slice(), definition[1](fn2(ctx))) : $$scope.ctx;
}
function get_slot_changes(definition, $$scope, dirty, fn2) {
  if (definition[2] && fn2) {
    const lets = definition[2](fn2(dirty));
    if ($$scope.dirty === void 0) {
      return lets;
    }
    if (typeof lets === "object") {
      const merged = [];
      const len = Math.max($$scope.dirty.length, lets.length);
      for (let i = 0; i < len; i += 1) {
        merged[i] = $$scope.dirty[i] | lets[i];
      }
      return merged;
    }
    return $$scope.dirty | lets;
  }
  return $$scope.dirty;
}
function update_slot_base(slot, slot_definition, ctx, $$scope, slot_changes, get_slot_context_fn) {
  if (slot_changes) {
    const slot_context = get_slot_context(slot_definition, ctx, $$scope, get_slot_context_fn);
    slot.p(slot_context, slot_changes);
  }
}
function get_all_dirty_from_scope($$scope) {
  if ($$scope.ctx.length > 32) {
    const dirty = [];
    const length = $$scope.ctx.length / 32;
    for (let i = 0; i < length; i++) {
      dirty[i] = -1;
    }
    return dirty;
  }
  return -1;
}
function exclude_internal_props(props) {
  const result = {};
  for (const k in props)
    if (k[0] !== "$")
      result[k] = props[k];
  return result;
}
function compute_rest_props(props, keys) {
  const rest = {};
  keys = new Set(keys);
  for (const k in props)
    if (!keys.has(k) && k[0] !== "$")
      rest[k] = props[k];
  return rest;
}
function null_to_empty(value) {
  return value == null ? "" : value;
}
var is_client = typeof window !== "undefined";
var now = is_client ? () => window.performance.now() : () => Date.now();
var raf = is_client ? (cb) => requestAnimationFrame(cb) : noop;
var tasks = /* @__PURE__ */ new Set();
function run_tasks(now2) {
  tasks.forEach((task) => {
    if (!task.c(now2)) {
      tasks.delete(task);
      task.f();
    }
  });
  if (tasks.size !== 0)
    raf(run_tasks);
}
function loop(callback) {
  let task;
  if (tasks.size === 0)
    raf(run_tasks);
  return {
    promise: new Promise((fulfill) => {
      tasks.add(task = { c: callback, f: fulfill });
    }),
    abort() {
      tasks.delete(task);
    }
  };
}
var is_hydrating = false;
function start_hydrating() {
  is_hydrating = true;
}
function end_hydrating() {
  is_hydrating = false;
}
function append(target, node) {
  target.appendChild(node);
}
function append_styles(target, style_sheet_id, styles) {
  const append_styles_to = get_root_for_style(target);
  if (!append_styles_to.getElementById(style_sheet_id)) {
    const style = element("style");
    style.id = style_sheet_id;
    style.textContent = styles;
    append_stylesheet(append_styles_to, style);
  }
}
function get_root_for_style(node) {
  if (!node)
    return document;
  const root = node.getRootNode ? node.getRootNode() : node.ownerDocument;
  if (root && root.host) {
    return root;
  }
  return node.ownerDocument;
}
function append_empty_stylesheet(node) {
  const style_element = element("style");
  append_stylesheet(get_root_for_style(node), style_element);
  return style_element.sheet;
}
function append_stylesheet(node, style) {
  append(node.head || node, style);
  return style.sheet;
}
function insert(target, node, anchor) {
  target.insertBefore(node, anchor || null);
}
function detach(node) {
  node.parentNode.removeChild(node);
}
function element(name) {
  return document.createElement(name);
}
function svg_element(name) {
  return document.createElementNS("http://www.w3.org/2000/svg", name);
}
function text(data) {
  return document.createTextNode(data);
}
function space() {
  return text(" ");
}
function empty() {
  return text("");
}
function listen(node, event, handler, options) {
  node.addEventListener(event, handler, options);
  return () => node.removeEventListener(event, handler, options);
}
function prevent_default(fn2) {
  return function(event) {
    event.preventDefault();
    return fn2.call(this, event);
  };
}
function attr(node, attribute, value) {
  if (value == null)
    node.removeAttribute(attribute);
  else if (node.getAttribute(attribute) !== value)
    node.setAttribute(attribute, value);
}
function set_svg_attributes(node, attributes) {
  for (const key in attributes) {
    attr(node, key, attributes[key]);
  }
}
function children(element2) {
  return Array.from(element2.childNodes);
}
function set_data(text2, data) {
  data = "" + data;
  if (text2.wholeText !== data)
    text2.data = data;
}
function set_input_value(input, value) {
  input.value = value == null ? "" : value;
}
function set_style(node, key, value, important) {
  if (value === null) {
    node.style.removeProperty(key);
  } else {
    node.style.setProperty(key, value, important ? "important" : "");
  }
}
function toggle_class(element2, name, toggle) {
  element2.classList[toggle ? "add" : "remove"](name);
}
function custom_event(type, detail, { bubbles = false, cancelable = false } = {}) {
  const e = document.createEvent("CustomEvent");
  e.initCustomEvent(type, bubbles, cancelable, detail);
  return e;
}
var managed_styles = /* @__PURE__ */ new Map();
var active = 0;
function hash(str) {
  let hash4 = 5381;
  let i = str.length;
  while (i--)
    hash4 = (hash4 << 5) - hash4 ^ str.charCodeAt(i);
  return hash4 >>> 0;
}
function create_style_information(doc, node) {
  const info = { stylesheet: append_empty_stylesheet(node), rules: {} };
  managed_styles.set(doc, info);
  return info;
}
function create_rule(node, a, b, duration, delay, ease, fn2, uid = 0) {
  const step = 16.666 / duration;
  let keyframes = "{\n";
  for (let p = 0; p <= 1; p += step) {
    const t = a + (b - a) * ease(p);
    keyframes += p * 100 + `%{${fn2(t, 1 - t)}}
`;
  }
  const rule = keyframes + `100% {${fn2(b, 1 - b)}}
}`;
  const name = `__svelte_${hash(rule)}_${uid}`;
  const doc = get_root_for_style(node);
  const { stylesheet, rules } = managed_styles.get(doc) || create_style_information(doc, node);
  if (!rules[name]) {
    rules[name] = true;
    stylesheet.insertRule(`@keyframes ${name} ${rule}`, stylesheet.cssRules.length);
  }
  const animation = node.style.animation || "";
  node.style.animation = `${animation ? `${animation}, ` : ""}${name} ${duration}ms linear ${delay}ms 1 both`;
  active += 1;
  return name;
}
function delete_rule(node, name) {
  const previous = (node.style.animation || "").split(", ");
  const next = previous.filter(name ? (anim) => anim.indexOf(name) < 0 : (anim) => anim.indexOf("__svelte") === -1);
  const deleted = previous.length - next.length;
  if (deleted) {
    node.style.animation = next.join(", ");
    active -= deleted;
    if (!active)
      clear_rules();
  }
}
function clear_rules() {
  raf(() => {
    if (active)
      return;
    managed_styles.forEach((info) => {
      const { ownerNode } = info.stylesheet;
      if (ownerNode)
        detach(ownerNode);
    });
    managed_styles.clear();
  });
}
var current_component;
function set_current_component(component) {
  current_component = component;
}
function get_current_component() {
  if (!current_component)
    throw new Error("Function called outside component initialization");
  return current_component;
}
function createEventDispatcher() {
  const component = get_current_component();
  return (type, detail, { cancelable = false } = {}) => {
    const callbacks = component.$$.callbacks[type];
    if (callbacks) {
      const event = custom_event(type, detail, { cancelable });
      callbacks.slice().forEach((fn2) => {
        fn2.call(component, event);
      });
      return !event.defaultPrevented;
    }
    return true;
  };
}
var dirty_components = [];
var binding_callbacks = [];
var render_callbacks = [];
var flush_callbacks = [];
var resolved_promise = Promise.resolve();
var update_scheduled = false;
function schedule_update() {
  if (!update_scheduled) {
    update_scheduled = true;
    resolved_promise.then(flush);
  }
}
function add_render_callback(fn2) {
  render_callbacks.push(fn2);
}
var seen_callbacks = /* @__PURE__ */ new Set();
var flushidx = 0;
function flush() {
  const saved_component = current_component;
  do {
    while (flushidx < dirty_components.length) {
      const component = dirty_components[flushidx];
      flushidx++;
      set_current_component(component);
      update(component.$$);
    }
    set_current_component(null);
    dirty_components.length = 0;
    flushidx = 0;
    while (binding_callbacks.length)
      binding_callbacks.pop()();
    for (let i = 0; i < render_callbacks.length; i += 1) {
      const callback = render_callbacks[i];
      if (!seen_callbacks.has(callback)) {
        seen_callbacks.add(callback);
        callback();
      }
    }
    render_callbacks.length = 0;
  } while (dirty_components.length);
  while (flush_callbacks.length) {
    flush_callbacks.pop()();
  }
  update_scheduled = false;
  seen_callbacks.clear();
  set_current_component(saved_component);
}
function update($$) {
  if ($$.fragment !== null) {
    $$.update();
    run_all($$.before_update);
    const dirty = $$.dirty;
    $$.dirty = [-1];
    $$.fragment && $$.fragment.p($$.ctx, dirty);
    $$.after_update.forEach(add_render_callback);
  }
}
var promise;
function wait() {
  if (!promise) {
    promise = Promise.resolve();
    promise.then(() => {
      promise = null;
    });
  }
  return promise;
}
function dispatch(node, direction, kind) {
  node.dispatchEvent(custom_event(`${direction ? "intro" : "outro"}${kind}`));
}
var outroing = /* @__PURE__ */ new Set();
var outros;
function group_outros() {
  outros = {
    r: 0,
    c: [],
    p: outros
  };
}
function check_outros() {
  if (!outros.r) {
    run_all(outros.c);
  }
  outros = outros.p;
}
function transition_in(block, local) {
  if (block && block.i) {
    outroing.delete(block);
    block.i(local);
  }
}
function transition_out(block, local, detach2, callback) {
  if (block && block.o) {
    if (outroing.has(block))
      return;
    outroing.add(block);
    outros.c.push(() => {
      outroing.delete(block);
      if (callback) {
        if (detach2)
          block.d(1);
        callback();
      }
    });
    block.o(local);
  } else if (callback) {
    callback();
  }
}
var null_transition = { duration: 0 };
function create_bidirectional_transition(node, fn2, params, intro) {
  let config = fn2(node, params);
  let t = intro ? 0 : 1;
  let running_program = null;
  let pending_program = null;
  let animation_name = null;
  function clear_animation() {
    if (animation_name)
      delete_rule(node, animation_name);
  }
  function init2(program, duration) {
    const d = program.b - t;
    duration *= Math.abs(d);
    return {
      a: t,
      b: program.b,
      d,
      duration,
      start: program.start,
      end: program.start + duration,
      group: program.group
    };
  }
  function go(b) {
    const { delay = 0, duration = 300, easing = identity, tick: tick2 = noop, css } = config || null_transition;
    const program = {
      start: now() + delay,
      b
    };
    if (!b) {
      program.group = outros;
      outros.r += 1;
    }
    if (running_program || pending_program) {
      pending_program = program;
    } else {
      if (css) {
        clear_animation();
        animation_name = create_rule(node, t, b, duration, delay, easing, css);
      }
      if (b)
        tick2(0, 1);
      running_program = init2(program, duration);
      add_render_callback(() => dispatch(node, b, "start"));
      loop((now2) => {
        if (pending_program && now2 > pending_program.start) {
          running_program = init2(pending_program, duration);
          pending_program = null;
          dispatch(node, running_program.b, "start");
          if (css) {
            clear_animation();
            animation_name = create_rule(node, t, running_program.b, running_program.duration, 0, easing, config.css);
          }
        }
        if (running_program) {
          if (now2 >= running_program.end) {
            tick2(t = running_program.b, 1 - t);
            dispatch(node, running_program.b, "end");
            if (!pending_program) {
              if (running_program.b) {
                clear_animation();
              } else {
                if (!--running_program.group.r)
                  run_all(running_program.group.c);
              }
            }
            running_program = null;
          } else if (now2 >= running_program.start) {
            const p = now2 - running_program.start;
            t = running_program.a + running_program.d * easing(p / running_program.duration);
            tick2(t, 1 - t);
          }
        }
        return !!(running_program || pending_program);
      });
    }
  }
  return {
    run(b) {
      if (is_function(config)) {
        wait().then(() => {
          config = config();
          go(b);
        });
      } else {
        go(b);
      }
    },
    end() {
      clear_animation();
      running_program = pending_program = null;
    }
  };
}
var globals = typeof window !== "undefined" ? window : typeof globalThis !== "undefined" ? globalThis : global;
function outro_and_destroy_block(block, lookup) {
  transition_out(block, 1, 1, () => {
    lookup.delete(block.key);
  });
}
function update_keyed_each(old_blocks, dirty, get_key, dynamic, ctx, list, lookup, node, destroy, create_each_block4, next, get_context) {
  let o = old_blocks.length;
  let n = list.length;
  let i = o;
  const old_indexes = {};
  while (i--)
    old_indexes[old_blocks[i].key] = i;
  const new_blocks = [];
  const new_lookup = /* @__PURE__ */ new Map();
  const deltas = /* @__PURE__ */ new Map();
  i = n;
  while (i--) {
    const child_ctx = get_context(ctx, list, i);
    const key = get_key(child_ctx);
    let block = lookup.get(key);
    if (!block) {
      block = create_each_block4(key, child_ctx);
      block.c();
    } else if (dynamic) {
      block.p(child_ctx, dirty);
    }
    new_lookup.set(key, new_blocks[i] = block);
    if (key in old_indexes)
      deltas.set(key, Math.abs(i - old_indexes[key]));
  }
  const will_move = /* @__PURE__ */ new Set();
  const did_move = /* @__PURE__ */ new Set();
  function insert2(block) {
    transition_in(block, 1);
    block.m(node, next);
    lookup.set(block.key, block);
    next = block.first;
    n--;
  }
  while (o && n) {
    const new_block = new_blocks[n - 1];
    const old_block = old_blocks[o - 1];
    const new_key = new_block.key;
    const old_key = old_block.key;
    if (new_block === old_block) {
      next = new_block.first;
      o--;
      n--;
    } else if (!new_lookup.has(old_key)) {
      destroy(old_block, lookup);
      o--;
    } else if (!lookup.has(new_key) || will_move.has(new_key)) {
      insert2(new_block);
    } else if (did_move.has(old_key)) {
      o--;
    } else if (deltas.get(new_key) > deltas.get(old_key)) {
      did_move.add(new_key);
      insert2(new_block);
    } else {
      will_move.add(old_key);
      o--;
    }
  }
  while (o--) {
    const old_block = old_blocks[o];
    if (!new_lookup.has(old_block.key))
      destroy(old_block, lookup);
  }
  while (n)
    insert2(new_blocks[n - 1]);
  return new_blocks;
}
function get_spread_update(levels, updates) {
  const update2 = {};
  const to_null_out = {};
  const accounted_for = { $$scope: 1 };
  let i = levels.length;
  while (i--) {
    const o = levels[i];
    const n = updates[i];
    if (n) {
      for (const key in o) {
        if (!(key in n))
          to_null_out[key] = 1;
      }
      for (const key in n) {
        if (!accounted_for[key]) {
          update2[key] = n[key];
          accounted_for[key] = 1;
        }
      }
      levels[i] = n;
    } else {
      for (const key in o) {
        accounted_for[key] = 1;
      }
    }
  }
  for (const key in to_null_out) {
    if (!(key in update2))
      update2[key] = void 0;
  }
  return update2;
}
function get_spread_object(spread_props) {
  return typeof spread_props === "object" && spread_props !== null ? spread_props : {};
}
function create_component(block) {
  block && block.c();
}
function mount_component(component, target, anchor, customElement) {
  const { fragment, on_mount, on_destroy, after_update } = component.$$;
  fragment && fragment.m(target, anchor);
  if (!customElement) {
    add_render_callback(() => {
      const new_on_destroy = on_mount.map(run).filter(is_function);
      if (on_destroy) {
        on_destroy.push(...new_on_destroy);
      } else {
        run_all(new_on_destroy);
      }
      component.$$.on_mount = [];
    });
  }
  after_update.forEach(add_render_callback);
}
function destroy_component(component, detaching) {
  const $$ = component.$$;
  if ($$.fragment !== null) {
    run_all($$.on_destroy);
    $$.fragment && $$.fragment.d(detaching);
    $$.on_destroy = $$.fragment = null;
    $$.ctx = [];
  }
}
function make_dirty(component, i) {
  if (component.$$.dirty[0] === -1) {
    dirty_components.push(component);
    schedule_update();
    component.$$.dirty.fill(0);
  }
  component.$$.dirty[i / 31 | 0] |= 1 << i % 31;
}
function init(component, options, instance27, create_fragment27, not_equal, props, append_styles2, dirty = [-1]) {
  const parent_component = current_component;
  set_current_component(component);
  const $$ = component.$$ = {
    fragment: null,
    ctx: null,
    props,
    update: noop,
    not_equal,
    bound: blank_object(),
    on_mount: [],
    on_destroy: [],
    on_disconnect: [],
    before_update: [],
    after_update: [],
    context: new Map(options.context || (parent_component ? parent_component.$$.context : [])),
    callbacks: blank_object(),
    dirty,
    skip_bound: false,
    root: options.target || parent_component.$$.root
  };
  append_styles2 && append_styles2($$.root);
  let ready = false;
  $$.ctx = instance27 ? instance27(component, options.props || {}, (i, ret, ...rest) => {
    const value = rest.length ? rest[0] : ret;
    if ($$.ctx && not_equal($$.ctx[i], $$.ctx[i] = value)) {
      if (!$$.skip_bound && $$.bound[i])
        $$.bound[i](value);
      if (ready)
        make_dirty(component, i);
    }
    return ret;
  }) : [];
  $$.update();
  ready = true;
  run_all($$.before_update);
  $$.fragment = create_fragment27 ? create_fragment27($$.ctx) : false;
  if (options.target) {
    if (options.hydrate) {
      start_hydrating();
      const nodes = children(options.target);
      $$.fragment && $$.fragment.l(nodes);
      nodes.forEach(detach);
    } else {
      $$.fragment && $$.fragment.c();
    }
    if (options.intro)
      transition_in(component.$$.fragment);
    mount_component(component, options.target, options.anchor, options.customElement);
    end_hydrating();
    flush();
  }
  set_current_component(parent_component);
}
var SvelteElement;
if (typeof HTMLElement === "function") {
  SvelteElement = class extends HTMLElement {
    constructor() {
      super();
      this.attachShadow({ mode: "open" });
    }
    connectedCallback() {
      const { on_mount } = this.$$;
      this.$$.on_disconnect = on_mount.map(run).filter(is_function);
      for (const key in this.$$.slotted) {
        this.appendChild(this.$$.slotted[key]);
      }
    }
    attributeChangedCallback(attr2, _oldValue, newValue) {
      this[attr2] = newValue;
    }
    disconnectedCallback() {
      run_all(this.$$.on_disconnect);
    }
    $destroy() {
      destroy_component(this, 1);
      this.$destroy = noop;
    }
    $on(type, callback) {
      const callbacks = this.$$.callbacks[type] || (this.$$.callbacks[type] = []);
      callbacks.push(callback);
      return () => {
        const index = callbacks.indexOf(callback);
        if (index !== -1)
          callbacks.splice(index, 1);
      };
    }
    $set($$props) {
      if (this.$$set && !is_empty($$props)) {
        this.$$.skip_bound = true;
        this.$$set($$props);
        this.$$.skip_bound = false;
      }
    }
  };
}
var SvelteComponent = class {
  $destroy() {
    destroy_component(this, 1);
    this.$destroy = noop;
  }
  $on(type, callback) {
    const callbacks = this.$$.callbacks[type] || (this.$$.callbacks[type] = []);
    callbacks.push(callback);
    return () => {
      const index = callbacks.indexOf(callback);
      if (index !== -1)
        callbacks.splice(index, 1);
    };
  }
  $set($$props) {
    if (this.$$set && !is_empty($$props)) {
      this.$$.skip_bound = true;
      this.$$set($$props);
      this.$$.skip_bound = false;
    }
  }
};

// src/ui/searchBar.svelte
var import_obsidian8 = require("obsidian");

// src/homeTabSearchbar.ts
var import_obsidian7 = require("obsidian");

// node_modules/svelte/store/index.mjs
var subscriber_queue = [];
function writable(value, start2 = noop) {
  let stop;
  const subscribers = /* @__PURE__ */ new Set();
  function set(new_value) {
    if (safe_not_equal(value, new_value)) {
      value = new_value;
      if (stop) {
        const run_queue = !subscriber_queue.length;
        for (const subscriber of subscribers) {
          subscriber[1]();
          subscriber_queue.push(subscriber, value);
        }
        if (run_queue) {
          for (let i = 0; i < subscriber_queue.length; i += 2) {
            subscriber_queue[i][0](subscriber_queue[i + 1]);
          }
          subscriber_queue.length = 0;
        }
      }
    }
  }
  function update2(fn2) {
    set(fn2(value));
  }
  function subscribe2(run2, invalidate = noop) {
    const subscriber = [run2, invalidate];
    subscribers.add(subscriber);
    if (subscribers.size === 1) {
      stop = start2(set) || noop;
    }
    run2(value);
    return () => {
      subscribers.delete(subscriber);
      if (subscribers.size === 0) {
        stop();
        stop = null;
      }
    };
  }
  return { set, update: update2, subscribe: subscribe2 };
}

// src/suggester/homeTabSuggester.ts
var import_obsidian4 = require("obsidian");

// node_modules/fuse.js/dist/fuse.esm.js
function isArray(value) {
  return !Array.isArray ? getTag(value) === "[object Array]" : Array.isArray(value);
}
var INFINITY = 1 / 0;
function baseToString(value) {
  if (typeof value == "string") {
    return value;
  }
  let result = value + "";
  return result == "0" && 1 / value == -INFINITY ? "-0" : result;
}
function toString(value) {
  return value == null ? "" : baseToString(value);
}
function isString(value) {
  return typeof value === "string";
}
function isNumber(value) {
  return typeof value === "number";
}
function isBoolean(value) {
  return value === true || value === false || isObjectLike(value) && getTag(value) == "[object Boolean]";
}
function isObject(value) {
  return typeof value === "object";
}
function isObjectLike(value) {
  return isObject(value) && value !== null;
}
function isDefined(value) {
  return value !== void 0 && value !== null;
}
function isBlank(value) {
  return !value.trim().length;
}
function getTag(value) {
  return value == null ? value === void 0 ? "[object Undefined]" : "[object Null]" : Object.prototype.toString.call(value);
}
var INCORRECT_INDEX_TYPE = "Incorrect 'index' type";
var LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY = (key) => `Invalid value for key ${key}`;
var PATTERN_LENGTH_TOO_LARGE = (max2) => `Pattern length exceeds max of ${max2}.`;
var MISSING_KEY_PROPERTY = (name) => `Missing ${name} property in key`;
var INVALID_KEY_WEIGHT_VALUE = (key) => `Property 'weight' in key '${key}' must be a positive integer`;
var hasOwn = Object.prototype.hasOwnProperty;
var KeyStore = class {
  constructor(keys) {
    this._keys = [];
    this._keyMap = {};
    let totalWeight = 0;
    keys.forEach((key) => {
      let obj = createKey(key);
      totalWeight += obj.weight;
      this._keys.push(obj);
      this._keyMap[obj.id] = obj;
      totalWeight += obj.weight;
    });
    this._keys.forEach((key) => {
      key.weight /= totalWeight;
    });
  }
  get(keyId) {
    return this._keyMap[keyId];
  }
  keys() {
    return this._keys;
  }
  toJSON() {
    return JSON.stringify(this._keys);
  }
};
function createKey(key) {
  let path = null;
  let id = null;
  let src = null;
  let weight = 1;
  let getFn = null;
  if (isString(key) || isArray(key)) {
    src = key;
    path = createKeyPath(key);
    id = createKeyId(key);
  } else {
    if (!hasOwn.call(key, "name")) {
      throw new Error(MISSING_KEY_PROPERTY("name"));
    }
    const name = key.name;
    src = name;
    if (hasOwn.call(key, "weight")) {
      weight = key.weight;
      if (weight <= 0) {
        throw new Error(INVALID_KEY_WEIGHT_VALUE(name));
      }
    }
    path = createKeyPath(name);
    id = createKeyId(name);
    getFn = key.getFn;
  }
  return { path, id, weight, src, getFn };
}
function createKeyPath(key) {
  return isArray(key) ? key : key.split(".");
}
function createKeyId(key) {
  return isArray(key) ? key.join(".") : key;
}
function get(obj, path) {
  let list = [];
  let arr = false;
  const deepGet = (obj2, path2, index) => {
    if (!isDefined(obj2)) {
      return;
    }
    if (!path2[index]) {
      list.push(obj2);
    } else {
      let key = path2[index];
      const value = obj2[key];
      if (!isDefined(value)) {
        return;
      }
      if (index === path2.length - 1 && (isString(value) || isNumber(value) || isBoolean(value))) {
        list.push(toString(value));
      } else if (isArray(value)) {
        arr = true;
        for (let i = 0, len = value.length; i < len; i += 1) {
          deepGet(value[i], path2, index + 1);
        }
      } else if (path2.length) {
        deepGet(value, path2, index + 1);
      }
    }
  };
  deepGet(obj, isString(path) ? path.split(".") : path, 0);
  return arr ? list : list[0];
}
var MatchOptions = {
  includeMatches: false,
  findAllMatches: false,
  minMatchCharLength: 1
};
var BasicOptions = {
  isCaseSensitive: false,
  includeScore: false,
  keys: [],
  shouldSort: true,
  sortFn: (a, b) => a.score === b.score ? a.idx < b.idx ? -1 : 1 : a.score < b.score ? -1 : 1
};
var FuzzyOptions = {
  location: 0,
  threshold: 0.6,
  distance: 100
};
var AdvancedOptions = {
  useExtendedSearch: false,
  getFn: get,
  ignoreLocation: false,
  ignoreFieldNorm: false,
  fieldNormWeight: 1
};
var Config = {
  ...BasicOptions,
  ...MatchOptions,
  ...FuzzyOptions,
  ...AdvancedOptions
};
var SPACE = /[^ ]+/g;
function norm(weight = 1, mantissa = 3) {
  const cache = /* @__PURE__ */ new Map();
  const m = Math.pow(10, mantissa);
  return {
    get(value) {
      const numTokens = value.match(SPACE).length;
      if (cache.has(numTokens)) {
        return cache.get(numTokens);
      }
      const norm2 = 1 / Math.pow(numTokens, 0.5 * weight);
      const n = parseFloat(Math.round(norm2 * m) / m);
      cache.set(numTokens, n);
      return n;
    },
    clear() {
      cache.clear();
    }
  };
}
var FuseIndex = class {
  constructor({
    getFn = Config.getFn,
    fieldNormWeight = Config.fieldNormWeight
  } = {}) {
    this.norm = norm(fieldNormWeight, 3);
    this.getFn = getFn;
    this.isCreated = false;
    this.setIndexRecords();
  }
  setSources(docs = []) {
    this.docs = docs;
  }
  setIndexRecords(records = []) {
    this.records = records;
  }
  setKeys(keys = []) {
    this.keys = keys;
    this._keysMap = {};
    keys.forEach((key, idx) => {
      this._keysMap[key.id] = idx;
    });
  }
  create() {
    if (this.isCreated || !this.docs.length) {
      return;
    }
    this.isCreated = true;
    if (isString(this.docs[0])) {
      this.docs.forEach((doc, docIndex) => {
        this._addString(doc, docIndex);
      });
    } else {
      this.docs.forEach((doc, docIndex) => {
        this._addObject(doc, docIndex);
      });
    }
    this.norm.clear();
  }
  add(doc) {
    const idx = this.size();
    if (isString(doc)) {
      this._addString(doc, idx);
    } else {
      this._addObject(doc, idx);
    }
  }
  removeAt(idx) {
    this.records.splice(idx, 1);
    for (let i = idx, len = this.size(); i < len; i += 1) {
      this.records[i].i -= 1;
    }
  }
  getValueForItemAtKeyId(item, keyId) {
    return item[this._keysMap[keyId]];
  }
  size() {
    return this.records.length;
  }
  _addString(doc, docIndex) {
    if (!isDefined(doc) || isBlank(doc)) {
      return;
    }
    let record = {
      v: doc,
      i: docIndex,
      n: this.norm.get(doc)
    };
    this.records.push(record);
  }
  _addObject(doc, docIndex) {
    let record = { i: docIndex, $: {} };
    this.keys.forEach((key, keyIndex) => {
      let value = key.getFn ? key.getFn(doc) : this.getFn(doc, key.path);
      if (!isDefined(value)) {
        return;
      }
      if (isArray(value)) {
        let subRecords = [];
        const stack = [{ nestedArrIndex: -1, value }];
        while (stack.length) {
          const { nestedArrIndex, value: value2 } = stack.pop();
          if (!isDefined(value2)) {
            continue;
          }
          if (isString(value2) && !isBlank(value2)) {
            let subRecord = {
              v: value2,
              i: nestedArrIndex,
              n: this.norm.get(value2)
            };
            subRecords.push(subRecord);
          } else if (isArray(value2)) {
            value2.forEach((item, k) => {
              stack.push({
                nestedArrIndex: k,
                value: item
              });
            });
          } else
            ;
        }
        record.$[keyIndex] = subRecords;
      } else if (isString(value) && !isBlank(value)) {
        let subRecord = {
          v: value,
          n: this.norm.get(value)
        };
        record.$[keyIndex] = subRecord;
      }
    });
    this.records.push(record);
  }
  toJSON() {
    return {
      keys: this.keys,
      records: this.records
    };
  }
};
function createIndex(keys, docs, { getFn = Config.getFn, fieldNormWeight = Config.fieldNormWeight } = {}) {
  const myIndex = new FuseIndex({ getFn, fieldNormWeight });
  myIndex.setKeys(keys.map(createKey));
  myIndex.setSources(docs);
  myIndex.create();
  return myIndex;
}
function parseIndex(data, { getFn = Config.getFn, fieldNormWeight = Config.fieldNormWeight } = {}) {
  const { keys, records } = data;
  const myIndex = new FuseIndex({ getFn, fieldNormWeight });
  myIndex.setKeys(keys);
  myIndex.setIndexRecords(records);
  return myIndex;
}
function computeScore$1(pattern, {
  errors = 0,
  currentLocation = 0,
  expectedLocation = 0,
  distance = Config.distance,
  ignoreLocation = Config.ignoreLocation
} = {}) {
  const accuracy = errors / pattern.length;
  if (ignoreLocation) {
    return accuracy;
  }
  const proximity = Math.abs(expectedLocation - currentLocation);
  if (!distance) {
    return proximity ? 1 : accuracy;
  }
  return accuracy + proximity / distance;
}
function convertMaskToIndices(matchmask = [], minMatchCharLength = Config.minMatchCharLength) {
  let indices = [];
  let start2 = -1;
  let end2 = -1;
  let i = 0;
  for (let len = matchmask.length; i < len; i += 1) {
    let match = matchmask[i];
    if (match && start2 === -1) {
      start2 = i;
    } else if (!match && start2 !== -1) {
      end2 = i - 1;
      if (end2 - start2 + 1 >= minMatchCharLength) {
        indices.push([start2, end2]);
      }
      start2 = -1;
    }
  }
  if (matchmask[i - 1] && i - start2 >= minMatchCharLength) {
    indices.push([start2, i - 1]);
  }
  return indices;
}
var MAX_BITS = 32;
function search(text2, pattern, patternAlphabet, {
  location = Config.location,
  distance = Config.distance,
  threshold = Config.threshold,
  findAllMatches = Config.findAllMatches,
  minMatchCharLength = Config.minMatchCharLength,
  includeMatches = Config.includeMatches,
  ignoreLocation = Config.ignoreLocation
} = {}) {
  if (pattern.length > MAX_BITS) {
    throw new Error(PATTERN_LENGTH_TOO_LARGE(MAX_BITS));
  }
  const patternLen = pattern.length;
  const textLen = text2.length;
  const expectedLocation = Math.max(0, Math.min(location, textLen));
  let currentThreshold = threshold;
  let bestLocation = expectedLocation;
  const computeMatches = minMatchCharLength > 1 || includeMatches;
  const matchMask = computeMatches ? Array(textLen) : [];
  let index;
  while ((index = text2.indexOf(pattern, bestLocation)) > -1) {
    let score = computeScore$1(pattern, {
      currentLocation: index,
      expectedLocation,
      distance,
      ignoreLocation
    });
    currentThreshold = Math.min(score, currentThreshold);
    bestLocation = index + patternLen;
    if (computeMatches) {
      let i = 0;
      while (i < patternLen) {
        matchMask[index + i] = 1;
        i += 1;
      }
    }
  }
  bestLocation = -1;
  let lastBitArr = [];
  let finalScore = 1;
  let binMax = patternLen + textLen;
  const mask = 1 << patternLen - 1;
  for (let i = 0; i < patternLen; i += 1) {
    let binMin = 0;
    let binMid = binMax;
    while (binMin < binMid) {
      const score2 = computeScore$1(pattern, {
        errors: i,
        currentLocation: expectedLocation + binMid,
        expectedLocation,
        distance,
        ignoreLocation
      });
      if (score2 <= currentThreshold) {
        binMin = binMid;
      } else {
        binMax = binMid;
      }
      binMid = Math.floor((binMax - binMin) / 2 + binMin);
    }
    binMax = binMid;
    let start2 = Math.max(1, expectedLocation - binMid + 1);
    let finish = findAllMatches ? textLen : Math.min(expectedLocation + binMid, textLen) + patternLen;
    let bitArr = Array(finish + 2);
    bitArr[finish + 1] = (1 << i) - 1;
    for (let j = finish; j >= start2; j -= 1) {
      let currentLocation = j - 1;
      let charMatch = patternAlphabet[text2.charAt(currentLocation)];
      if (computeMatches) {
        matchMask[currentLocation] = +!!charMatch;
      }
      bitArr[j] = (bitArr[j + 1] << 1 | 1) & charMatch;
      if (i) {
        bitArr[j] |= (lastBitArr[j + 1] | lastBitArr[j]) << 1 | 1 | lastBitArr[j + 1];
      }
      if (bitArr[j] & mask) {
        finalScore = computeScore$1(pattern, {
          errors: i,
          currentLocation,
          expectedLocation,
          distance,
          ignoreLocation
        });
        if (finalScore <= currentThreshold) {
          currentThreshold = finalScore;
          bestLocation = currentLocation;
          if (bestLocation <= expectedLocation) {
            break;
          }
          start2 = Math.max(1, 2 * expectedLocation - bestLocation);
        }
      }
    }
    const score = computeScore$1(pattern, {
      errors: i + 1,
      currentLocation: expectedLocation,
      expectedLocation,
      distance,
      ignoreLocation
    });
    if (score > currentThreshold) {
      break;
    }
    lastBitArr = bitArr;
  }
  const result = {
    isMatch: bestLocation >= 0,
    score: Math.max(1e-3, finalScore)
  };
  if (computeMatches) {
    const indices = convertMaskToIndices(matchMask, minMatchCharLength);
    if (!indices.length) {
      result.isMatch = false;
    } else if (includeMatches) {
      result.indices = indices;
    }
  }
  return result;
}
function createPatternAlphabet(pattern) {
  let mask = {};
  for (let i = 0, len = pattern.length; i < len; i += 1) {
    const char = pattern.charAt(i);
    mask[char] = (mask[char] || 0) | 1 << len - i - 1;
  }
  return mask;
}
var BitapSearch = class {
  constructor(pattern, {
    location = Config.location,
    threshold = Config.threshold,
    distance = Config.distance,
    includeMatches = Config.includeMatches,
    findAllMatches = Config.findAllMatches,
    minMatchCharLength = Config.minMatchCharLength,
    isCaseSensitive = Config.isCaseSensitive,
    ignoreLocation = Config.ignoreLocation
  } = {}) {
    this.options = {
      location,
      threshold,
      distance,
      includeMatches,
      findAllMatches,
      minMatchCharLength,
      isCaseSensitive,
      ignoreLocation
    };
    this.pattern = isCaseSensitive ? pattern : pattern.toLowerCase();
    this.chunks = [];
    if (!this.pattern.length) {
      return;
    }
    const addChunk = (pattern2, startIndex) => {
      this.chunks.push({
        pattern: pattern2,
        alphabet: createPatternAlphabet(pattern2),
        startIndex
      });
    };
    const len = this.pattern.length;
    if (len > MAX_BITS) {
      let i = 0;
      const remainder = len % MAX_BITS;
      const end2 = len - remainder;
      while (i < end2) {
        addChunk(this.pattern.substr(i, MAX_BITS), i);
        i += MAX_BITS;
      }
      if (remainder) {
        const startIndex = len - MAX_BITS;
        addChunk(this.pattern.substr(startIndex), startIndex);
      }
    } else {
      addChunk(this.pattern, 0);
    }
  }
  searchIn(text2) {
    const { isCaseSensitive, includeMatches } = this.options;
    if (!isCaseSensitive) {
      text2 = text2.toLowerCase();
    }
    if (this.pattern === text2) {
      let result2 = {
        isMatch: true,
        score: 0
      };
      if (includeMatches) {
        result2.indices = [[0, text2.length - 1]];
      }
      return result2;
    }
    const {
      location,
      distance,
      threshold,
      findAllMatches,
      minMatchCharLength,
      ignoreLocation
    } = this.options;
    let allIndices = [];
    let totalScore = 0;
    let hasMatches = false;
    this.chunks.forEach(({ pattern, alphabet, startIndex }) => {
      const { isMatch, score, indices } = search(text2, pattern, alphabet, {
        location: location + startIndex,
        distance,
        threshold,
        findAllMatches,
        minMatchCharLength,
        includeMatches,
        ignoreLocation
      });
      if (isMatch) {
        hasMatches = true;
      }
      totalScore += score;
      if (isMatch && indices) {
        allIndices = [...allIndices, ...indices];
      }
    });
    let result = {
      isMatch: hasMatches,
      score: hasMatches ? totalScore / this.chunks.length : 1
    };
    if (hasMatches && includeMatches) {
      result.indices = allIndices;
    }
    return result;
  }
};
var BaseMatch = class {
  constructor(pattern) {
    this.pattern = pattern;
  }
  static isMultiMatch(pattern) {
    return getMatch(pattern, this.multiRegex);
  }
  static isSingleMatch(pattern) {
    return getMatch(pattern, this.singleRegex);
  }
  search() {
  }
};
function getMatch(pattern, exp) {
  const matches = pattern.match(exp);
  return matches ? matches[1] : null;
}
var ExactMatch = class extends BaseMatch {
  constructor(pattern) {
    super(pattern);
  }
  static get type() {
    return "exact";
  }
  static get multiRegex() {
    return /^="(.*)"$/;
  }
  static get singleRegex() {
    return /^=(.*)$/;
  }
  search(text2) {
    const isMatch = text2 === this.pattern;
    return {
      isMatch,
      score: isMatch ? 0 : 1,
      indices: [0, this.pattern.length - 1]
    };
  }
};
var InverseExactMatch = class extends BaseMatch {
  constructor(pattern) {
    super(pattern);
  }
  static get type() {
    return "inverse-exact";
  }
  static get multiRegex() {
    return /^!"(.*)"$/;
  }
  static get singleRegex() {
    return /^!(.*)$/;
  }
  search(text2) {
    const index = text2.indexOf(this.pattern);
    const isMatch = index === -1;
    return {
      isMatch,
      score: isMatch ? 0 : 1,
      indices: [0, text2.length - 1]
    };
  }
};
var PrefixExactMatch = class extends BaseMatch {
  constructor(pattern) {
    super(pattern);
  }
  static get type() {
    return "prefix-exact";
  }
  static get multiRegex() {
    return /^\^"(.*)"$/;
  }
  static get singleRegex() {
    return /^\^(.*)$/;
  }
  search(text2) {
    const isMatch = text2.startsWith(this.pattern);
    return {
      isMatch,
      score: isMatch ? 0 : 1,
      indices: [0, this.pattern.length - 1]
    };
  }
};
var InversePrefixExactMatch = class extends BaseMatch {
  constructor(pattern) {
    super(pattern);
  }
  static get type() {
    return "inverse-prefix-exact";
  }
  static get multiRegex() {
    return /^!\^"(.*)"$/;
  }
  static get singleRegex() {
    return /^!\^(.*)$/;
  }
  search(text2) {
    const isMatch = !text2.startsWith(this.pattern);
    return {
      isMatch,
      score: isMatch ? 0 : 1,
      indices: [0, text2.length - 1]
    };
  }
};
var SuffixExactMatch = class extends BaseMatch {
  constructor(pattern) {
    super(pattern);
  }
  static get type() {
    return "suffix-exact";
  }
  static get multiRegex() {
    return /^"(.*)"\$$/;
  }
  static get singleRegex() {
    return /^(.*)\$$/;
  }
  search(text2) {
    const isMatch = text2.endsWith(this.pattern);
    return {
      isMatch,
      score: isMatch ? 0 : 1,
      indices: [text2.length - this.pattern.length, text2.length - 1]
    };
  }
};
var InverseSuffixExactMatch = class extends BaseMatch {
  constructor(pattern) {
    super(pattern);
  }
  static get type() {
    return "inverse-suffix-exact";
  }
  static get multiRegex() {
    return /^!"(.*)"\$$/;
  }
  static get singleRegex() {
    return /^!(.*)\$$/;
  }
  search(text2) {
    const isMatch = !text2.endsWith(this.pattern);
    return {
      isMatch,
      score: isMatch ? 0 : 1,
      indices: [0, text2.length - 1]
    };
  }
};
var FuzzyMatch = class extends BaseMatch {
  constructor(pattern, {
    location = Config.location,
    threshold = Config.threshold,
    distance = Config.distance,
    includeMatches = Config.includeMatches,
    findAllMatches = Config.findAllMatches,
    minMatchCharLength = Config.minMatchCharLength,
    isCaseSensitive = Config.isCaseSensitive,
    ignoreLocation = Config.ignoreLocation
  } = {}) {
    super(pattern);
    this._bitapSearch = new BitapSearch(pattern, {
      location,
      threshold,
      distance,
      includeMatches,
      findAllMatches,
      minMatchCharLength,
      isCaseSensitive,
      ignoreLocation
    });
  }
  static get type() {
    return "fuzzy";
  }
  static get multiRegex() {
    return /^"(.*)"$/;
  }
  static get singleRegex() {
    return /^(.*)$/;
  }
  search(text2) {
    return this._bitapSearch.searchIn(text2);
  }
};
var IncludeMatch = class extends BaseMatch {
  constructor(pattern) {
    super(pattern);
  }
  static get type() {
    return "include";
  }
  static get multiRegex() {
    return /^'"(.*)"$/;
  }
  static get singleRegex() {
    return /^'(.*)$/;
  }
  search(text2) {
    let location = 0;
    let index;
    const indices = [];
    const patternLen = this.pattern.length;
    while ((index = text2.indexOf(this.pattern, location)) > -1) {
      location = index + patternLen;
      indices.push([index, location - 1]);
    }
    const isMatch = !!indices.length;
    return {
      isMatch,
      score: isMatch ? 0 : 1,
      indices
    };
  }
};
var searchers = [
  ExactMatch,
  IncludeMatch,
  PrefixExactMatch,
  InversePrefixExactMatch,
  InverseSuffixExactMatch,
  SuffixExactMatch,
  InverseExactMatch,
  FuzzyMatch
];
var searchersLen = searchers.length;
var SPACE_RE = / +(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)/;
var OR_TOKEN = "|";
function parseQuery(pattern, options = {}) {
  return pattern.split(OR_TOKEN).map((item) => {
    let query = item.trim().split(SPACE_RE).filter((item2) => item2 && !!item2.trim());
    let results = [];
    for (let i = 0, len = query.length; i < len; i += 1) {
      const queryItem = query[i];
      let found = false;
      let idx = -1;
      while (!found && ++idx < searchersLen) {
        const searcher = searchers[idx];
        let token = searcher.isMultiMatch(queryItem);
        if (token) {
          results.push(new searcher(token, options));
          found = true;
        }
      }
      if (found) {
        continue;
      }
      idx = -1;
      while (++idx < searchersLen) {
        const searcher = searchers[idx];
        let token = searcher.isSingleMatch(queryItem);
        if (token) {
          results.push(new searcher(token, options));
          break;
        }
      }
    }
    return results;
  });
}
var MultiMatchSet = /* @__PURE__ */ new Set([FuzzyMatch.type, IncludeMatch.type]);
var ExtendedSearch = class {
  constructor(pattern, {
    isCaseSensitive = Config.isCaseSensitive,
    includeMatches = Config.includeMatches,
    minMatchCharLength = Config.minMatchCharLength,
    ignoreLocation = Config.ignoreLocation,
    findAllMatches = Config.findAllMatches,
    location = Config.location,
    threshold = Config.threshold,
    distance = Config.distance
  } = {}) {
    this.query = null;
    this.options = {
      isCaseSensitive,
      includeMatches,
      minMatchCharLength,
      findAllMatches,
      ignoreLocation,
      location,
      threshold,
      distance
    };
    this.pattern = isCaseSensitive ? pattern : pattern.toLowerCase();
    this.query = parseQuery(this.pattern, this.options);
  }
  static condition(_, options) {
    return options.useExtendedSearch;
  }
  searchIn(text2) {
    const query = this.query;
    if (!query) {
      return {
        isMatch: false,
        score: 1
      };
    }
    const { includeMatches, isCaseSensitive } = this.options;
    text2 = isCaseSensitive ? text2 : text2.toLowerCase();
    let numMatches = 0;
    let allIndices = [];
    let totalScore = 0;
    for (let i = 0, qLen = query.length; i < qLen; i += 1) {
      const searchers2 = query[i];
      allIndices.length = 0;
      numMatches = 0;
      for (let j = 0, pLen = searchers2.length; j < pLen; j += 1) {
        const searcher = searchers2[j];
        const { isMatch, indices, score } = searcher.search(text2);
        if (isMatch) {
          numMatches += 1;
          totalScore += score;
          if (includeMatches) {
            const type = searcher.constructor.type;
            if (MultiMatchSet.has(type)) {
              allIndices = [...allIndices, ...indices];
            } else {
              allIndices.push(indices);
            }
          }
        } else {
          totalScore = 0;
          numMatches = 0;
          allIndices.length = 0;
          break;
        }
      }
      if (numMatches) {
        let result = {
          isMatch: true,
          score: totalScore / numMatches
        };
        if (includeMatches) {
          result.indices = allIndices;
        }
        return result;
      }
    }
    return {
      isMatch: false,
      score: 1
    };
  }
};
var registeredSearchers = [];
function register(...args) {
  registeredSearchers.push(...args);
}
function createSearcher(pattern, options) {
  for (let i = 0, len = registeredSearchers.length; i < len; i += 1) {
    let searcherClass = registeredSearchers[i];
    if (searcherClass.condition(pattern, options)) {
      return new searcherClass(pattern, options);
    }
  }
  return new BitapSearch(pattern, options);
}
var LogicalOperator = {
  AND: "$and",
  OR: "$or"
};
var KeyType = {
  PATH: "$path",
  PATTERN: "$val"
};
var isExpression = (query) => !!(query[LogicalOperator.AND] || query[LogicalOperator.OR]);
var isPath = (query) => !!query[KeyType.PATH];
var isLeaf = (query) => !isArray(query) && isObject(query) && !isExpression(query);
var convertToExplicit = (query) => ({
  [LogicalOperator.AND]: Object.keys(query).map((key) => ({
    [key]: query[key]
  }))
});
function parse(query, options, { auto: auto2 = true } = {}) {
  const next = (query2) => {
    let keys = Object.keys(query2);
    const isQueryPath = isPath(query2);
    if (!isQueryPath && keys.length > 1 && !isExpression(query2)) {
      return next(convertToExplicit(query2));
    }
    if (isLeaf(query2)) {
      const key = isQueryPath ? query2[KeyType.PATH] : keys[0];
      const pattern = isQueryPath ? query2[KeyType.PATTERN] : query2[key];
      if (!isString(pattern)) {
        throw new Error(LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY(key));
      }
      const obj = {
        keyId: createKeyId(key),
        pattern
      };
      if (auto2) {
        obj.searcher = createSearcher(pattern, options);
      }
      return obj;
    }
    let node = {
      children: [],
      operator: keys[0]
    };
    keys.forEach((key) => {
      const value = query2[key];
      if (isArray(value)) {
        value.forEach((item) => {
          node.children.push(next(item));
        });
      }
    });
    return node;
  };
  if (!isExpression(query)) {
    query = convertToExplicit(query);
  }
  return next(query);
}
function computeScore(results, { ignoreFieldNorm = Config.ignoreFieldNorm }) {
  results.forEach((result) => {
    let totalScore = 1;
    result.matches.forEach(({ key, norm: norm2, score }) => {
      const weight = key ? key.weight : null;
      totalScore *= Math.pow(score === 0 && weight ? Number.EPSILON : score, (weight || 1) * (ignoreFieldNorm ? 1 : norm2));
    });
    result.score = totalScore;
  });
}
function transformMatches(result, data) {
  const matches = result.matches;
  data.matches = [];
  if (!isDefined(matches)) {
    return;
  }
  matches.forEach((match) => {
    if (!isDefined(match.indices) || !match.indices.length) {
      return;
    }
    const { indices, value } = match;
    let obj = {
      indices,
      value
    };
    if (match.key) {
      obj.key = match.key.src;
    }
    if (match.idx > -1) {
      obj.refIndex = match.idx;
    }
    data.matches.push(obj);
  });
}
function transformScore(result, data) {
  data.score = result.score;
}
function format(results, docs, {
  includeMatches = Config.includeMatches,
  includeScore = Config.includeScore
} = {}) {
  const transformers = [];
  if (includeMatches)
    transformers.push(transformMatches);
  if (includeScore)
    transformers.push(transformScore);
  return results.map((result) => {
    const { idx } = result;
    const data = {
      item: docs[idx],
      refIndex: idx
    };
    if (transformers.length) {
      transformers.forEach((transformer) => {
        transformer(result, data);
      });
    }
    return data;
  });
}
var Fuse = class {
  constructor(docs, options = {}, index) {
    this.options = { ...Config, ...options };
    if (this.options.useExtendedSearch && false) {
      throw new Error(EXTENDED_SEARCH_UNAVAILABLE);
    }
    this._keyStore = new KeyStore(this.options.keys);
    this.setCollection(docs, index);
  }
  setCollection(docs, index) {
    this._docs = docs;
    if (index && !(index instanceof FuseIndex)) {
      throw new Error(INCORRECT_INDEX_TYPE);
    }
    this._myIndex = index || createIndex(this.options.keys, this._docs, {
      getFn: this.options.getFn,
      fieldNormWeight: this.options.fieldNormWeight
    });
  }
  add(doc) {
    if (!isDefined(doc)) {
      return;
    }
    this._docs.push(doc);
    this._myIndex.add(doc);
  }
  remove(predicate = () => false) {
    const results = [];
    for (let i = 0, len = this._docs.length; i < len; i += 1) {
      const doc = this._docs[i];
      if (predicate(doc, i)) {
        this.removeAt(i);
        i -= 1;
        len -= 1;
        results.push(doc);
      }
    }
    return results;
  }
  removeAt(idx) {
    this._docs.splice(idx, 1);
    this._myIndex.removeAt(idx);
  }
  getIndex() {
    return this._myIndex;
  }
  search(query, { limit = -1 } = {}) {
    const {
      includeMatches,
      includeScore,
      shouldSort,
      sortFn,
      ignoreFieldNorm
    } = this.options;
    let results = isString(query) ? isString(this._docs[0]) ? this._searchStringList(query) : this._searchObjectList(query) : this._searchLogical(query);
    computeScore(results, { ignoreFieldNorm });
    if (shouldSort) {
      results.sort(sortFn);
    }
    if (isNumber(limit) && limit > -1) {
      results = results.slice(0, limit);
    }
    return format(results, this._docs, {
      includeMatches,
      includeScore
    });
  }
  _searchStringList(query) {
    const searcher = createSearcher(query, this.options);
    const { records } = this._myIndex;
    const results = [];
    records.forEach(({ v: text2, i: idx, n: norm2 }) => {
      if (!isDefined(text2)) {
        return;
      }
      const { isMatch, score, indices } = searcher.searchIn(text2);
      if (isMatch) {
        results.push({
          item: text2,
          idx,
          matches: [{ score, value: text2, norm: norm2, indices }]
        });
      }
    });
    return results;
  }
  _searchLogical(query) {
    const expression = parse(query, this.options);
    const evaluate = (node, item, idx) => {
      if (!node.children) {
        const { keyId, searcher } = node;
        const matches = this._findMatches({
          key: this._keyStore.get(keyId),
          value: this._myIndex.getValueForItemAtKeyId(item, keyId),
          searcher
        });
        if (matches && matches.length) {
          return [
            {
              idx,
              item,
              matches
            }
          ];
        }
        return [];
      }
      const res = [];
      for (let i = 0, len = node.children.length; i < len; i += 1) {
        const child = node.children[i];
        const result = evaluate(child, item, idx);
        if (result.length) {
          res.push(...result);
        } else if (node.operator === LogicalOperator.AND) {
          return [];
        }
      }
      return res;
    };
    const records = this._myIndex.records;
    const resultMap = {};
    const results = [];
    records.forEach(({ $: item, i: idx }) => {
      if (isDefined(item)) {
        let expResults = evaluate(expression, item, idx);
        if (expResults.length) {
          if (!resultMap[idx]) {
            resultMap[idx] = { idx, item, matches: [] };
            results.push(resultMap[idx]);
          }
          expResults.forEach(({ matches }) => {
            resultMap[idx].matches.push(...matches);
          });
        }
      }
    });
    return results;
  }
  _searchObjectList(query) {
    const searcher = createSearcher(query, this.options);
    const { keys, records } = this._myIndex;
    const results = [];
    records.forEach(({ $: item, i: idx }) => {
      if (!isDefined(item)) {
        return;
      }
      let matches = [];
      keys.forEach((key, keyIndex) => {
        matches.push(...this._findMatches({
          key,
          value: item[keyIndex],
          searcher
        }));
      });
      if (matches.length) {
        results.push({
          idx,
          item,
          matches
        });
      }
    });
    return results;
  }
  _findMatches({ key, value, searcher }) {
    if (!isDefined(value)) {
      return [];
    }
    let matches = [];
    if (isArray(value)) {
      value.forEach(({ v: text2, i: idx, n: norm2 }) => {
        if (!isDefined(text2)) {
          return;
        }
        const { isMatch, score, indices } = searcher.searchIn(text2);
        if (isMatch) {
          matches.push({
            score,
            key,
            value: text2,
            idx,
            norm: norm2,
            indices
          });
        }
      });
    } else {
      const { v: text2, n: norm2 } = value;
      const { isMatch, score, indices } = searcher.searchIn(text2);
      if (isMatch) {
        matches.push({ score, key, value: text2, norm: norm2, indices });
      }
    }
    return matches;
  }
};
Fuse.version = "6.6.2";
Fuse.createIndex = createIndex;
Fuse.parseIndex = parseIndex;
Fuse.config = Config;
{
  Fuse.parseQuery = parse;
}
{
  register(ExtendedSearch);
}

// src/utils/getFilesUtils.ts
var import_obsidian = require("obsidian");

// src/utils/getFileTypeUtils.ts
var fileTypeLookupTable = {
  image: ["jpg", "jpeg", "png", "svg", "gif", "bmp"],
  video: ["mp4", "webm", "ogv", "mov", "mkv"],
  audio: ["mp3", "wav", "m4a", "ogg", "3gp", "flac"],
  markdown: ["md"],
  pdf: ["pdf"],
  canvas: ["canvas"]
};
var fileTypes = ["image", "video", "audio", "markdown", "pdf", "canvas"];
var fileExtensions = [
  "jpg",
  "jpeg",
  "png",
  "svg",
  "gif",
  "bmp",
  "mp4",
  "webm",
  "ogv",
  "mov",
  "mkv",
  "mp3",
  "wav",
  "m4a",
  "ogg",
  "3gp",
  "flac",
  "md",
  "pdf",
  "canvas"
];
function getFileTypeFromExtension(extension) {
  for (const fileType of Object.keys(fileTypeLookupTable)) {
    if (fileTypeLookupTable[fileType].includes(extension)) {
      return fileType;
    }
  }
  return void 0;
}
function getExtensionFromFilename(filename) {
  const extension = filename.match(/\.([^.]+$)/g);
  if (extension) {
    return extension[0].substring(1);
  }
  return void 0;
}
function isValidExtension(extToCheck) {
  const extensions = [
    "jpg",
    "jpeg",
    "png",
    "svg",
    "gif",
    "bmp",
    "mp4",
    "webm",
    "ogv",
    "mov",
    "mkv",
    "mp3",
    "wav",
    "m4a",
    "ogg",
    "3gp",
    "flac",
    "md",
    "pdf"
  ];
  return extensions.includes(extToCheck);
}

// src/utils/getFilesUtils.ts
function getImageFiles() {
  let fileList = [];
  app.vault.getFiles().forEach((file) => {
    if (getFileTypeFromExtension(file.extension) === "image") {
      fileList.push(file);
    }
  });
  return fileList;
}
function getFileAliases(file) {
  var _a, _b, _c;
  let aliases = [];
  const rawAliases = ((_a = app.metadataCache.getFileCache(file)) == null ? void 0 : _a.frontmatter) ? (_c = (_b = app.metadataCache.getFileCache(file)) == null ? void 0 : _b.frontmatter) == null ? void 0 : _c.aliases : void 0;
  if (rawAliases instanceof Array) {
    aliases.push(...rawAliases);
  } else if (typeof rawAliases === "string") {
    rawAliases.replace("[", "").replace("]", "").split(",").forEach((alias) => {
      if (alias.length > 0) {
        aliases.push(alias.trim());
      }
    });
  }
  return aliases;
}
function generateSearchFile(file) {
  return {
    name: file.name,
    basename: file.basename,
    path: file.path,
    aliases: getFileAliases(file),
    isCreated: true,
    file,
    fileType: getFileTypeFromExtension(file.extension),
    extension: file.extension
  };
}
function getUnresolvedLinkPath(cachedFilename, newFilePath) {
  const normalizedFilename = (0, import_obsidian.getLinkpath)(cachedFilename);
  if (newFilePath && !normalizedFilename.includes("/")) {
    return (0, import_obsidian.normalizePath)(`${this.app.fileManager.getNewFileParent("").path}/${normalizedFilename}`);
  }
  return (0, import_obsidian.normalizePath)(normalizedFilename);
}
function getUnresolvedLinkBasename(cachedFilename) {
  const normalizedPath = (0, import_obsidian.getLinkpath)(cachedFilename);
  if (normalizedPath.includes("/")) {
    const regexResult = normalizedPath.match(/.*\/(.*)/);
    return regexResult ? regexResult[1] : normalizedPath;
  }
  return normalizedPath;
}
function generateMarkdownUnresolvedFile(cachedFilename) {
  const filename = getExtensionFromFilename(cachedFilename) ? cachedFilename.replace(".md", "") : cachedFilename;
  return {
    name: `${getUnresolvedLinkBasename(filename)}.md`,
    basename: getUnresolvedLinkBasename(filename),
    path: getUnresolvedLinkPath(`${filename}.md`, true),
    isCreated: false,
    isUnresolved: true,
    fileType: "markdown",
    extension: "md"
  };
}
function getUnresolvedMarkdownFiles() {
  const fileList = [];
  const unresolvedLinkParents = app.metadataCache.unresolvedLinks;
  const unresolvedFilenames = [];
  Object.entries(unresolvedLinkParents).forEach((record) => {
    Object.keys(record[1]).forEach((filename) => {
      if (!getExtensionFromFilename(filename) && !unresolvedFilenames.includes(filename)) {
        unresolvedFilenames.push(filename);
      }
    });
  });
  unresolvedFilenames.forEach((filename) => fileList.push(generateMarkdownUnresolvedFile(filename)));
  return fileList;
}
function getSearchFiles(unresolvedLinks) {
  const files = app.vault.getFiles();
  const fileList = [];
  files.forEach((f) => {
    fileList.push(generateSearchFile(f));
  });
  if (unresolvedLinks) {
    fileList.push(...getUnresolvedMarkdownFiles());
  }
  return fileList;
}
function getParentFolderFromPath(filepath) {
  const regexResult = filepath.match(/([^\/]+)\/[^\/]+\/*$/);
  return regexResult ? regexResult[1] : "/";
}

// src/suggester/fuzzySearch.ts
var DEFAULT_FUSE_OPTIONS = {
  includeScore: true,
  fieldNormWeight: 1.35,
  threshold: 0.2,
  distance: 125,
  useExtendedSearch: true
};
var fuzzySearch = class {
  constructor(searchArray, searchOptions = DEFAULT_FUSE_OPTIONS) {
    this.fuse = new Fuse(searchArray, searchOptions);
  }
  rawSearch(querry, limit) {
    return this.fuse.search(querry, limit ? { limit } : void 0);
  }
  filteredSearch(querry, scoreThreshold = 0.25, maxResults = 5) {
    return this.rawSearch(querry, maxResults).filter((item) => item.score ? item.score < scoreThreshold : true);
  }
  updateSearchArray(newSearchArray) {
    this.fuse.setCollection(newSearchArray);
  }
};
var ArrayFuzzySearch = class extends fuzzySearch {
  constructor(searchArray, searchOptions) {
    super(searchArray, searchOptions);
  }
};
var FileFuzzySearch = class extends fuzzySearch {
  constructor(fileList, searchOptions) {
    const searchArray = fileList;
    super(searchArray, searchOptions);
  }
  getBestMatch(searchResultElement, querry) {
    const searchFile = searchResultElement.item;
    if (!searchFile.aliases)
      return searchFile.basename;
    const searchArray = [];
    searchArray.push(searchFile.basename);
    searchFile.aliases.forEach((alias) => searchArray.push(alias));
    const fuzzySearch2 = new ArrayFuzzySearch(searchArray);
    const bestMatch = fuzzySearch2.rawSearch(querry, 1)[0];
    return bestMatch ? bestMatch.item : searchFile.basename;
  }
};
var ImageFileFuzzySearch = class extends fuzzySearch {
  constructor(imageList, searchOptions) {
    const searchArray = imageList != null ? imageList : getImageFiles();
    super(searchArray, searchOptions);
  }
};
var SurfingItemFuzzySearch = class extends fuzzySearch {
  constructor(surfingItems, searchOptions) {
    super(surfingItems, searchOptions);
  }
};

// src/suggester/suggester.ts
var import_obsidian2 = require("obsidian");

// node_modules/svelte/easing/index.mjs
function cubicOut(t) {
  const f = t - 1;
  return f * f * f + 1;
}
function quintOut(t) {
  return --t * t * t * t * t + 1;
}

// node_modules/svelte/transition/index.mjs
function slide(node, { delay = 0, duration = 400, easing = cubicOut } = {}) {
  const style = getComputedStyle(node);
  const opacity = +style.opacity;
  const height = parseFloat(style.height);
  const padding_top = parseFloat(style.paddingTop);
  const padding_bottom = parseFloat(style.paddingBottom);
  const margin_top = parseFloat(style.marginTop);
  const margin_bottom = parseFloat(style.marginBottom);
  const border_top_width = parseFloat(style.borderTopWidth);
  const border_bottom_width = parseFloat(style.borderBottomWidth);
  return {
    delay,
    duration,
    easing,
    css: (t) => `overflow: hidden;opacity: ${Math.min(t * 20, 1) * opacity};height: ${t * height}px;padding-top: ${t * padding_top}px;padding-bottom: ${t * padding_bottom}px;margin-top: ${t * margin_top}px;margin-bottom: ${t * margin_bottom}px;border-top-width: ${t * border_top_width}px;border-bottom-width: ${t * border_bottom_width}px;`
  };
}

// src/ui/suggesterView.svelte
function add_css(target) {
  append_styles(target, "svelte-mdftrq", ".scrollable.svelte-mdftrq{overflow-y:auto}");
}
function get_each_context(ctx, list, i) {
  const child_ctx = ctx.slice();
  child_ctx[8] = list[i];
  child_ctx[10] = i;
  return child_ctx;
}
function create_if_block(ctx) {
  let div1;
  let div0;
  let each_blocks = [];
  let each_1_lookup = /* @__PURE__ */ new Map();
  let div0_class_value;
  let div0_style_value;
  let t;
  let div1_class_value;
  let div1_transition;
  let current;
  let mounted;
  let dispose;
  let each_value = ctx[2];
  const get_key = (ctx2) => ctx2[8];
  for (let i = 0; i < each_value.length; i += 1) {
    let child_ctx = get_each_context(ctx, each_value, i);
    let key = get_key(child_ctx);
    each_1_lookup.set(key, each_blocks[i] = create_each_block(key, child_ctx));
  }
  let if_block = ctx[0].additionalModalInfo && create_if_block_1(ctx);
  return {
    c() {
      var _a, _b, _c, _d;
      div1 = element("div");
      div0 = element("div");
      for (let i = 0; i < each_blocks.length; i += 1) {
        each_blocks[i].c();
      }
      t = space();
      if (if_block)
        if_block.c();
      attr(div0, "class", div0_class_value = ((_a = ctx[0].suggestionClass) != null ? _a : "suggestion") + " " + ((_b = ctx[0].additionalClasses) != null ? _b : "") + " svelte-mdftrq");
      attr(div0, "style", div0_style_value = (_c = ctx[0].style) != null ? _c : "");
      toggle_class(div0, "scrollable", ctx[0].isScrollable);
      attr(div1, "class", div1_class_value = null_to_empty((_d = ctx[0].containerClass) != null ? _d : "suggestion-container popover suggestion-popover") + " svelte-mdftrq");
    },
    m(target, anchor) {
      insert(target, div1, anchor);
      append(div1, div0);
      for (let i = 0; i < each_blocks.length; i += 1) {
        each_blocks[i].m(div0, null);
      }
      ctx[6](div0);
      append(div1, t);
      if (if_block)
        if_block.m(div1, null);
      current = true;
      if (!mounted) {
        dispose = listen(div1, "mousedown", mousedown_handler);
        mounted = true;
      }
    },
    p(new_ctx, dirty) {
      var _a, _b, _c, _d;
      ctx = new_ctx;
      if (dirty & 14) {
        each_value = ctx[2];
        group_outros();
        each_blocks = update_keyed_each(each_blocks, dirty, get_key, 1, ctx, each_value, each_1_lookup, div0, outro_and_destroy_block, create_each_block, null, get_each_context);
        check_outros();
      }
      if (!current || dirty & 1 && div0_class_value !== (div0_class_value = ((_a = ctx[0].suggestionClass) != null ? _a : "suggestion") + " " + ((_b = ctx[0].additionalClasses) != null ? _b : "") + " svelte-mdftrq")) {
        attr(div0, "class", div0_class_value);
      }
      if (!current || dirty & 1 && div0_style_value !== (div0_style_value = (_c = ctx[0].style) != null ? _c : "")) {
        attr(div0, "style", div0_style_value);
      }
      if (!current || dirty & 1) {
        toggle_class(div0, "scrollable", ctx[0].isScrollable);
      }
      if (ctx[0].additionalModalInfo) {
        if (if_block) {
          if_block.p(ctx, dirty);
        } else {
          if_block = create_if_block_1(ctx);
          if_block.c();
          if_block.m(div1, null);
        }
      } else if (if_block) {
        if_block.d(1);
        if_block = null;
      }
      if (!current || dirty & 1 && div1_class_value !== (div1_class_value = null_to_empty((_d = ctx[0].containerClass) != null ? _d : "suggestion-container popover suggestion-popover") + " svelte-mdftrq")) {
        attr(div1, "class", div1_class_value);
      }
    },
    i(local) {
      if (current)
        return;
      for (let i = 0; i < each_value.length; i += 1) {
        transition_in(each_blocks[i]);
      }
      add_render_callback(() => {
        if (!div1_transition)
          div1_transition = create_bidirectional_transition(div1, slide, { duration: 200, easing: quintOut }, true);
        div1_transition.run(1);
      });
      current = true;
    },
    o(local) {
      for (let i = 0; i < each_blocks.length; i += 1) {
        transition_out(each_blocks[i]);
      }
      if (!div1_transition)
        div1_transition = create_bidirectional_transition(div1, slide, { duration: 200, easing: quintOut }, false);
      div1_transition.run(0);
      current = false;
    },
    d(detaching) {
      if (detaching)
        detach(div1);
      for (let i = 0; i < each_blocks.length; i += 1) {
        each_blocks[i].d();
      }
      ctx[6](null);
      if (if_block)
        if_block.d();
      if (detaching && div1_transition)
        div1_transition.end();
      mounted = false;
      dispose();
    }
  };
}
function create_each_block(key_1, ctx) {
  let first;
  let switch_instance;
  let switch_instance_anchor;
  let current;
  const switch_instance_spread_levels = [
    { index: ctx[10] },
    { suggestion: ctx[8] },
    {
      textInputSuggester: ctx[1]
    },
    {
      selectedItemIndex: ctx[3]
    },
    ctx[1].getDisplayElementProps(ctx[8])
  ];
  var switch_value = ctx[1].getDisplayElementComponentType();
  function switch_props(ctx2) {
    let switch_instance_props = {};
    for (let i = 0; i < switch_instance_spread_levels.length; i += 1) {
      switch_instance_props = assign(switch_instance_props, switch_instance_spread_levels[i]);
    }
    return { props: switch_instance_props };
  }
  if (switch_value) {
    switch_instance = new switch_value(switch_props(ctx));
  }
  return {
    key: key_1,
    first: null,
    c() {
      first = empty();
      if (switch_instance)
        create_component(switch_instance.$$.fragment);
      switch_instance_anchor = empty();
      this.first = first;
    },
    m(target, anchor) {
      insert(target, first, anchor);
      if (switch_instance) {
        mount_component(switch_instance, target, anchor);
      }
      insert(target, switch_instance_anchor, anchor);
      current = true;
    },
    p(new_ctx, dirty) {
      ctx = new_ctx;
      const switch_instance_changes = dirty & 14 ? get_spread_update(switch_instance_spread_levels, [
        dirty & 4 && { index: ctx[10] },
        dirty & 4 && { suggestion: ctx[8] },
        dirty & 2 && {
          textInputSuggester: ctx[1]
        },
        dirty & 8 && {
          selectedItemIndex: ctx[3]
        },
        dirty & 6 && get_spread_object(ctx[1].getDisplayElementProps(ctx[8]))
      ]) : {};
      if (switch_value !== (switch_value = ctx[1].getDisplayElementComponentType())) {
        if (switch_instance) {
          group_outros();
          const old_component = switch_instance;
          transition_out(old_component.$$.fragment, 1, 0, () => {
            destroy_component(old_component, 1);
          });
          check_outros();
        }
        if (switch_value) {
          switch_instance = new switch_value(switch_props(ctx));
          create_component(switch_instance.$$.fragment);
          transition_in(switch_instance.$$.fragment, 1);
          mount_component(switch_instance, switch_instance_anchor.parentNode, switch_instance_anchor);
        } else {
          switch_instance = null;
        }
      } else if (switch_value) {
        switch_instance.$set(switch_instance_changes);
      }
    },
    i(local) {
      if (current)
        return;
      if (switch_instance)
        transition_in(switch_instance.$$.fragment, local);
      current = true;
    },
    o(local) {
      if (switch_instance)
        transition_out(switch_instance.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      if (detaching)
        detach(first);
      if (detaching)
        detach(switch_instance_anchor);
      if (switch_instance)
        destroy_component(switch_instance, detaching);
    }
  };
}
function create_if_block_1(ctx) {
  let div;
  let raw_value = ctx[0].additionalModalInfo.outerHTML + "";
  return {
    c() {
      div = element("div");
      attr(div, "class", "suggester-additional-info");
    },
    m(target, anchor) {
      insert(target, div, anchor);
      div.innerHTML = raw_value;
    },
    p(ctx2, dirty) {
      if (dirty & 1 && raw_value !== (raw_value = ctx2[0].additionalModalInfo.outerHTML + ""))
        div.innerHTML = raw_value;
      ;
    },
    d(detaching) {
      if (detaching)
        detach(div);
    }
  };
}
function create_fragment(ctx) {
  let if_block_anchor;
  let current;
  let if_block = ctx[2] && ctx[2].length > 0 && create_if_block(ctx);
  return {
    c() {
      if (if_block)
        if_block.c();
      if_block_anchor = empty();
    },
    m(target, anchor) {
      if (if_block)
        if_block.m(target, anchor);
      insert(target, if_block_anchor, anchor);
      current = true;
    },
    p(ctx2, [dirty]) {
      if (ctx2[2] && ctx2[2].length > 0) {
        if (if_block) {
          if_block.p(ctx2, dirty);
          if (dirty & 4) {
            transition_in(if_block, 1);
          }
        } else {
          if_block = create_if_block(ctx2);
          if_block.c();
          transition_in(if_block, 1);
          if_block.m(if_block_anchor.parentNode, if_block_anchor);
        }
      } else if (if_block) {
        group_outros();
        transition_out(if_block, 1, 1, () => {
          if_block = null;
        });
        check_outros();
      }
    },
    i(local) {
      if (current)
        return;
      transition_in(if_block);
      current = true;
    },
    o(local) {
      transition_out(if_block);
      current = false;
    },
    d(detaching) {
      if (if_block)
        if_block.d(detaching);
      if (detaching)
        detach(if_block_anchor);
    }
  };
}
var mousedown_handler = (e) => e.preventDefault();
function instance($$self, $$props, $$invalidate) {
  let $suggestionWrapper;
  let { options } = $$props;
  let { textInputSuggester } = $$props;
  let suggester = textInputSuggester.getSuggester();
  let suggestions;
  suggester.suggestionsStore.subscribe((value) => $$invalidate(2, suggestions = value));
  let selectedItemIndex;
  suggester.selectedItemIndexStore.subscribe((value) => $$invalidate(3, selectedItemIndex = value));
  const suggestionWrapper = suggester.suggestionsContainer;
  component_subscribe($$self, suggestionWrapper, (value) => $$invalidate(4, $suggestionWrapper = value));
  function div0_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      $suggestionWrapper = $$value;
      suggestionWrapper.set($suggestionWrapper);
    });
  }
  $$self.$$set = ($$props2) => {
    if ("options" in $$props2)
      $$invalidate(0, options = $$props2.options);
    if ("textInputSuggester" in $$props2)
      $$invalidate(1, textInputSuggester = $$props2.textInputSuggester);
  };
  return [
    options,
    textInputSuggester,
    suggestions,
    selectedItemIndex,
    $suggestionWrapper,
    suggestionWrapper,
    div0_binding
  ];
}
var SuggesterView = class extends SvelteComponent {
  constructor(options) {
    super();
    init(this, options, instance, create_fragment, safe_not_equal, { options: 0, textInputSuggester: 1 }, add_css);
  }
};
var suggesterView_default = SuggesterView;

// node_modules/@popperjs/core/lib/enums.js
var top = "top";
var bottom = "bottom";
var right = "right";
var left = "left";
var auto = "auto";
var basePlacements = [top, bottom, right, left];
var start = "start";
var end = "end";
var clippingParents = "clippingParents";
var viewport = "viewport";
var popper = "popper";
var reference = "reference";
var variationPlacements = /* @__PURE__ */ basePlacements.reduce(function(acc, placement) {
  return acc.concat([placement + "-" + start, placement + "-" + end]);
}, []);
var placements = /* @__PURE__ */ [].concat(basePlacements, [auto]).reduce(function(acc, placement) {
  return acc.concat([placement, placement + "-" + start, placement + "-" + end]);
}, []);
var beforeRead = "beforeRead";
var read = "read";
var afterRead = "afterRead";
var beforeMain = "beforeMain";
var main = "main";
var afterMain = "afterMain";
var beforeWrite = "beforeWrite";
var write = "write";
var afterWrite = "afterWrite";
var modifierPhases = [beforeRead, read, afterRead, beforeMain, main, afterMain, beforeWrite, write, afterWrite];

// node_modules/@popperjs/core/lib/dom-utils/getNodeName.js
function getNodeName(element2) {
  return element2 ? (element2.nodeName || "").toLowerCase() : null;
}

// node_modules/@popperjs/core/lib/dom-utils/getWindow.js
function getWindow(node) {
  if (node == null) {
    return window;
  }
  if (node.toString() !== "[object Window]") {
    var ownerDocument = node.ownerDocument;
    return ownerDocument ? ownerDocument.defaultView || window : window;
  }
  return node;
}

// node_modules/@popperjs/core/lib/dom-utils/instanceOf.js
function isElement(node) {
  var OwnElement = getWindow(node).Element;
  return node instanceof OwnElement || node instanceof Element;
}
function isHTMLElement(node) {
  var OwnElement = getWindow(node).HTMLElement;
  return node instanceof OwnElement || node instanceof HTMLElement;
}
function isShadowRoot(node) {
  if (typeof ShadowRoot === "undefined") {
    return false;
  }
  var OwnElement = getWindow(node).ShadowRoot;
  return node instanceof OwnElement || node instanceof ShadowRoot;
}

// node_modules/@popperjs/core/lib/modifiers/applyStyles.js
function applyStyles(_ref) {
  var state = _ref.state;
  Object.keys(state.elements).forEach(function(name) {
    var style = state.styles[name] || {};
    var attributes = state.attributes[name] || {};
    var element2 = state.elements[name];
    if (!isHTMLElement(element2) || !getNodeName(element2)) {
      return;
    }
    Object.assign(element2.style, style);
    Object.keys(attributes).forEach(function(name2) {
      var value = attributes[name2];
      if (value === false) {
        element2.removeAttribute(name2);
      } else {
        element2.setAttribute(name2, value === true ? "" : value);
      }
    });
  });
}
function effect(_ref2) {
  var state = _ref2.state;
  var initialStyles = {
    popper: {
      position: state.options.strategy,
      left: "0",
      top: "0",
      margin: "0"
    },
    arrow: {
      position: "absolute"
    },
    reference: {}
  };
  Object.assign(state.elements.popper.style, initialStyles.popper);
  state.styles = initialStyles;
  if (state.elements.arrow) {
    Object.assign(state.elements.arrow.style, initialStyles.arrow);
  }
  return function() {
    Object.keys(state.elements).forEach(function(name) {
      var element2 = state.elements[name];
      var attributes = state.attributes[name] || {};
      var styleProperties = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]);
      var style = styleProperties.reduce(function(style2, property) {
        style2[property] = "";
        return style2;
      }, {});
      if (!isHTMLElement(element2) || !getNodeName(element2)) {
        return;
      }
      Object.assign(element2.style, style);
      Object.keys(attributes).forEach(function(attribute) {
        element2.removeAttribute(attribute);
      });
    });
  };
}
var applyStyles_default = {
  name: "applyStyles",
  enabled: true,
  phase: "write",
  fn: applyStyles,
  effect,
  requires: ["computeStyles"]
};

// node_modules/@popperjs/core/lib/utils/getBasePlacement.js
function getBasePlacement(placement) {
  return placement.split("-")[0];
}

// node_modules/@popperjs/core/lib/utils/math.js
var max = Math.max;
var min = Math.min;
var round = Math.round;

// node_modules/@popperjs/core/lib/utils/userAgent.js
function getUAString() {
  var uaData = navigator.userAgentData;
  if (uaData != null && uaData.brands) {
    return uaData.brands.map(function(item) {
      return item.brand + "/" + item.version;
    }).join(" ");
  }
  return navigator.userAgent;
}

// node_modules/@popperjs/core/lib/dom-utils/isLayoutViewport.js
function isLayoutViewport() {
  return !/^((?!chrome|android).)*safari/i.test(getUAString());
}

// node_modules/@popperjs/core/lib/dom-utils/getBoundingClientRect.js
function getBoundingClientRect(element2, includeScale, isFixedStrategy) {
  if (includeScale === void 0) {
    includeScale = false;
  }
  if (isFixedStrategy === void 0) {
    isFixedStrategy = false;
  }
  var clientRect = element2.getBoundingClientRect();
  var scaleX = 1;
  var scaleY = 1;
  if (includeScale && isHTMLElement(element2)) {
    scaleX = element2.offsetWidth > 0 ? round(clientRect.width) / element2.offsetWidth || 1 : 1;
    scaleY = element2.offsetHeight > 0 ? round(clientRect.height) / element2.offsetHeight || 1 : 1;
  }
  var _ref = isElement(element2) ? getWindow(element2) : window, visualViewport = _ref.visualViewport;
  var addVisualOffsets = !isLayoutViewport() && isFixedStrategy;
  var x = (clientRect.left + (addVisualOffsets && visualViewport ? visualViewport.offsetLeft : 0)) / scaleX;
  var y = (clientRect.top + (addVisualOffsets && visualViewport ? visualViewport.offsetTop : 0)) / scaleY;
  var width = clientRect.width / scaleX;
  var height = clientRect.height / scaleY;
  return {
    width,
    height,
    top: y,
    right: x + width,
    bottom: y + height,
    left: x,
    x,
    y
  };
}

// node_modules/@popperjs/core/lib/dom-utils/getLayoutRect.js
function getLayoutRect(element2) {
  var clientRect = getBoundingClientRect(element2);
  var width = element2.offsetWidth;
  var height = element2.offsetHeight;
  if (Math.abs(clientRect.width - width) <= 1) {
    width = clientRect.width;
  }
  if (Math.abs(clientRect.height - height) <= 1) {
    height = clientRect.height;
  }
  return {
    x: element2.offsetLeft,
    y: element2.offsetTop,
    width,
    height
  };
}

// node_modules/@popperjs/core/lib/dom-utils/contains.js
function contains(parent, child) {
  var rootNode = child.getRootNode && child.getRootNode();
  if (parent.contains(child)) {
    return true;
  } else if (rootNode && isShadowRoot(rootNode)) {
    var next = child;
    do {
      if (next && parent.isSameNode(next)) {
        return true;
      }
      next = next.parentNode || next.host;
    } while (next);
  }
  return false;
}

// node_modules/@popperjs/core/lib/dom-utils/getComputedStyle.js
function getComputedStyle2(element2) {
  return getWindow(element2).getComputedStyle(element2);
}

// node_modules/@popperjs/core/lib/dom-utils/isTableElement.js
function isTableElement(element2) {
  return ["table", "td", "th"].indexOf(getNodeName(element2)) >= 0;
}

// node_modules/@popperjs/core/lib/dom-utils/getDocumentElement.js
function getDocumentElement(element2) {
  return ((isElement(element2) ? element2.ownerDocument : element2.document) || window.document).documentElement;
}

// node_modules/@popperjs/core/lib/dom-utils/getParentNode.js
function getParentNode(element2) {
  if (getNodeName(element2) === "html") {
    return element2;
  }
  return element2.assignedSlot || element2.parentNode || (isShadowRoot(element2) ? element2.host : null) || getDocumentElement(element2);
}

// node_modules/@popperjs/core/lib/dom-utils/getOffsetParent.js
function getTrueOffsetParent(element2) {
  if (!isHTMLElement(element2) || getComputedStyle2(element2).position === "fixed") {
    return null;
  }
  return element2.offsetParent;
}
function getContainingBlock(element2) {
  var isFirefox = /firefox/i.test(getUAString());
  var isIE = /Trident/i.test(getUAString());
  if (isIE && isHTMLElement(element2)) {
    var elementCss = getComputedStyle2(element2);
    if (elementCss.position === "fixed") {
      return null;
    }
  }
  var currentNode = getParentNode(element2);
  if (isShadowRoot(currentNode)) {
    currentNode = currentNode.host;
  }
  while (isHTMLElement(currentNode) && ["html", "body"].indexOf(getNodeName(currentNode)) < 0) {
    var css = getComputedStyle2(currentNode);
    if (css.transform !== "none" || css.perspective !== "none" || css.contain === "paint" || ["transform", "perspective"].indexOf(css.willChange) !== -1 || isFirefox && css.willChange === "filter" || isFirefox && css.filter && css.filter !== "none") {
      return currentNode;
    } else {
      currentNode = currentNode.parentNode;
    }
  }
  return null;
}
function getOffsetParent(element2) {
  var window2 = getWindow(element2);
  var offsetParent = getTrueOffsetParent(element2);
  while (offsetParent && isTableElement(offsetParent) && getComputedStyle2(offsetParent).position === "static") {
    offsetParent = getTrueOffsetParent(offsetParent);
  }
  if (offsetParent && (getNodeName(offsetParent) === "html" || getNodeName(offsetParent) === "body" && getComputedStyle2(offsetParent).position === "static")) {
    return window2;
  }
  return offsetParent || getContainingBlock(element2) || window2;
}

// node_modules/@popperjs/core/lib/utils/getMainAxisFromPlacement.js
function getMainAxisFromPlacement(placement) {
  return ["top", "bottom"].indexOf(placement) >= 0 ? "x" : "y";
}

// node_modules/@popperjs/core/lib/utils/within.js
function within(min2, value, max2) {
  return max(min2, min(value, max2));
}
function withinMaxClamp(min2, value, max2) {
  var v = within(min2, value, max2);
  return v > max2 ? max2 : v;
}

// node_modules/@popperjs/core/lib/utils/getFreshSideObject.js
function getFreshSideObject() {
  return {
    top: 0,
    right: 0,
    bottom: 0,
    left: 0
  };
}

// node_modules/@popperjs/core/lib/utils/mergePaddingObject.js
function mergePaddingObject(paddingObject) {
  return Object.assign({}, getFreshSideObject(), paddingObject);
}

// node_modules/@popperjs/core/lib/utils/expandToHashMap.js
function expandToHashMap(value, keys) {
  return keys.reduce(function(hashMap, key) {
    hashMap[key] = value;
    return hashMap;
  }, {});
}

// node_modules/@popperjs/core/lib/modifiers/arrow.js
var toPaddingObject = function toPaddingObject2(padding, state) {
  padding = typeof padding === "function" ? padding(Object.assign({}, state.rects, {
    placement: state.placement
  })) : padding;
  return mergePaddingObject(typeof padding !== "number" ? padding : expandToHashMap(padding, basePlacements));
};
function arrow(_ref) {
  var _state$modifiersData$;
  var state = _ref.state, name = _ref.name, options = _ref.options;
  var arrowElement = state.elements.arrow;
  var popperOffsets2 = state.modifiersData.popperOffsets;
  var basePlacement = getBasePlacement(state.placement);
  var axis = getMainAxisFromPlacement(basePlacement);
  var isVertical = [left, right].indexOf(basePlacement) >= 0;
  var len = isVertical ? "height" : "width";
  if (!arrowElement || !popperOffsets2) {
    return;
  }
  var paddingObject = toPaddingObject(options.padding, state);
  var arrowRect = getLayoutRect(arrowElement);
  var minProp = axis === "y" ? top : left;
  var maxProp = axis === "y" ? bottom : right;
  var endDiff = state.rects.reference[len] + state.rects.reference[axis] - popperOffsets2[axis] - state.rects.popper[len];
  var startDiff = popperOffsets2[axis] - state.rects.reference[axis];
  var arrowOffsetParent = getOffsetParent(arrowElement);
  var clientSize = arrowOffsetParent ? axis === "y" ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;
  var centerToReference = endDiff / 2 - startDiff / 2;
  var min2 = paddingObject[minProp];
  var max2 = clientSize - arrowRect[len] - paddingObject[maxProp];
  var center = clientSize / 2 - arrowRect[len] / 2 + centerToReference;
  var offset2 = within(min2, center, max2);
  var axisProp = axis;
  state.modifiersData[name] = (_state$modifiersData$ = {}, _state$modifiersData$[axisProp] = offset2, _state$modifiersData$.centerOffset = offset2 - center, _state$modifiersData$);
}
function effect2(_ref2) {
  var state = _ref2.state, options = _ref2.options;
  var _options$element = options.element, arrowElement = _options$element === void 0 ? "[data-popper-arrow]" : _options$element;
  if (arrowElement == null) {
    return;
  }
  if (typeof arrowElement === "string") {
    arrowElement = state.elements.popper.querySelector(arrowElement);
    if (!arrowElement) {
      return;
    }
  }
  if (true) {
    if (!isHTMLElement(arrowElement)) {
      console.error(['Popper: "arrow" element must be an HTMLElement (not an SVGElement).', "To use an SVG arrow, wrap it in an HTMLElement that will be used as", "the arrow."].join(" "));
    }
  }
  if (!contains(state.elements.popper, arrowElement)) {
    if (true) {
      console.error(['Popper: "arrow" modifier\'s `element` must be a child of the popper', "element."].join(" "));
    }
    return;
  }
  state.elements.arrow = arrowElement;
}
var arrow_default = {
  name: "arrow",
  enabled: true,
  phase: "main",
  fn: arrow,
  effect: effect2,
  requires: ["popperOffsets"],
  requiresIfExists: ["preventOverflow"]
};

// node_modules/@popperjs/core/lib/utils/getVariation.js
function getVariation(placement) {
  return placement.split("-")[1];
}

// node_modules/@popperjs/core/lib/modifiers/computeStyles.js
var unsetSides = {
  top: "auto",
  right: "auto",
  bottom: "auto",
  left: "auto"
};
function roundOffsetsByDPR(_ref) {
  var x = _ref.x, y = _ref.y;
  var win = window;
  var dpr = win.devicePixelRatio || 1;
  return {
    x: round(x * dpr) / dpr || 0,
    y: round(y * dpr) / dpr || 0
  };
}
function mapToStyles(_ref2) {
  var _Object$assign2;
  var popper2 = _ref2.popper, popperRect = _ref2.popperRect, placement = _ref2.placement, variation = _ref2.variation, offsets = _ref2.offsets, position = _ref2.position, gpuAcceleration = _ref2.gpuAcceleration, adaptive = _ref2.adaptive, roundOffsets = _ref2.roundOffsets, isFixed = _ref2.isFixed;
  var _offsets$x = offsets.x, x = _offsets$x === void 0 ? 0 : _offsets$x, _offsets$y = offsets.y, y = _offsets$y === void 0 ? 0 : _offsets$y;
  var _ref3 = typeof roundOffsets === "function" ? roundOffsets({
    x,
    y
  }) : {
    x,
    y
  };
  x = _ref3.x;
  y = _ref3.y;
  var hasX = offsets.hasOwnProperty("x");
  var hasY = offsets.hasOwnProperty("y");
  var sideX = left;
  var sideY = top;
  var win = window;
  if (adaptive) {
    var offsetParent = getOffsetParent(popper2);
    var heightProp = "clientHeight";
    var widthProp = "clientWidth";
    if (offsetParent === getWindow(popper2)) {
      offsetParent = getDocumentElement(popper2);
      if (getComputedStyle2(offsetParent).position !== "static" && position === "absolute") {
        heightProp = "scrollHeight";
        widthProp = "scrollWidth";
      }
    }
    offsetParent = offsetParent;
    if (placement === top || (placement === left || placement === right) && variation === end) {
      sideY = bottom;
      var offsetY = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.height : offsetParent[heightProp];
      y -= offsetY - popperRect.height;
      y *= gpuAcceleration ? 1 : -1;
    }
    if (placement === left || (placement === top || placement === bottom) && variation === end) {
      sideX = right;
      var offsetX = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.width : offsetParent[widthProp];
      x -= offsetX - popperRect.width;
      x *= gpuAcceleration ? 1 : -1;
    }
  }
  var commonStyles = Object.assign({
    position
  }, adaptive && unsetSides);
  var _ref4 = roundOffsets === true ? roundOffsetsByDPR({
    x,
    y
  }) : {
    x,
    y
  };
  x = _ref4.x;
  y = _ref4.y;
  if (gpuAcceleration) {
    var _Object$assign;
    return Object.assign({}, commonStyles, (_Object$assign = {}, _Object$assign[sideY] = hasY ? "0" : "", _Object$assign[sideX] = hasX ? "0" : "", _Object$assign.transform = (win.devicePixelRatio || 1) <= 1 ? "translate(" + x + "px, " + y + "px)" : "translate3d(" + x + "px, " + y + "px, 0)", _Object$assign));
  }
  return Object.assign({}, commonStyles, (_Object$assign2 = {}, _Object$assign2[sideY] = hasY ? y + "px" : "", _Object$assign2[sideX] = hasX ? x + "px" : "", _Object$assign2.transform = "", _Object$assign2));
}
function computeStyles(_ref5) {
  var state = _ref5.state, options = _ref5.options;
  var _options$gpuAccelerat = options.gpuAcceleration, gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat, _options$adaptive = options.adaptive, adaptive = _options$adaptive === void 0 ? true : _options$adaptive, _options$roundOffsets = options.roundOffsets, roundOffsets = _options$roundOffsets === void 0 ? true : _options$roundOffsets;
  if (true) {
    var transitionProperty = getComputedStyle2(state.elements.popper).transitionProperty || "";
    if (adaptive && ["transform", "top", "right", "bottom", "left"].some(function(property) {
      return transitionProperty.indexOf(property) >= 0;
    })) {
      console.warn(["Popper: Detected CSS transitions on at least one of the following", 'CSS properties: "transform", "top", "right", "bottom", "left".', "\n\n", 'Disable the "computeStyles" modifier\'s `adaptive` option to allow', "for smooth transitions, or remove these properties from the CSS", "transition declaration on the popper element if only transitioning", "opacity or background-color for example.", "\n\n", "We recommend using the popper element as a wrapper around an inner", "element that can have any CSS property transitioned for animations."].join(" "));
    }
  }
  var commonStyles = {
    placement: getBasePlacement(state.placement),
    variation: getVariation(state.placement),
    popper: state.elements.popper,
    popperRect: state.rects.popper,
    gpuAcceleration,
    isFixed: state.options.strategy === "fixed"
  };
  if (state.modifiersData.popperOffsets != null) {
    state.styles.popper = Object.assign({}, state.styles.popper, mapToStyles(Object.assign({}, commonStyles, {
      offsets: state.modifiersData.popperOffsets,
      position: state.options.strategy,
      adaptive,
      roundOffsets
    })));
  }
  if (state.modifiersData.arrow != null) {
    state.styles.arrow = Object.assign({}, state.styles.arrow, mapToStyles(Object.assign({}, commonStyles, {
      offsets: state.modifiersData.arrow,
      position: "absolute",
      adaptive: false,
      roundOffsets
    })));
  }
  state.attributes.popper = Object.assign({}, state.attributes.popper, {
    "data-popper-placement": state.placement
  });
}
var computeStyles_default = {
  name: "computeStyles",
  enabled: true,
  phase: "beforeWrite",
  fn: computeStyles,
  data: {}
};

// node_modules/@popperjs/core/lib/modifiers/eventListeners.js
var passive = {
  passive: true
};
function effect3(_ref) {
  var state = _ref.state, instance27 = _ref.instance, options = _ref.options;
  var _options$scroll = options.scroll, scroll = _options$scroll === void 0 ? true : _options$scroll, _options$resize = options.resize, resize = _options$resize === void 0 ? true : _options$resize;
  var window2 = getWindow(state.elements.popper);
  var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper);
  if (scroll) {
    scrollParents.forEach(function(scrollParent) {
      scrollParent.addEventListener("scroll", instance27.update, passive);
    });
  }
  if (resize) {
    window2.addEventListener("resize", instance27.update, passive);
  }
  return function() {
    if (scroll) {
      scrollParents.forEach(function(scrollParent) {
        scrollParent.removeEventListener("scroll", instance27.update, passive);
      });
    }
    if (resize) {
      window2.removeEventListener("resize", instance27.update, passive);
    }
  };
}
var eventListeners_default = {
  name: "eventListeners",
  enabled: true,
  phase: "write",
  fn: function fn() {
  },
  effect: effect3,
  data: {}
};

// node_modules/@popperjs/core/lib/utils/getOppositePlacement.js
var hash2 = {
  left: "right",
  right: "left",
  bottom: "top",
  top: "bottom"
};
function getOppositePlacement(placement) {
  return placement.replace(/left|right|bottom|top/g, function(matched) {
    return hash2[matched];
  });
}

// node_modules/@popperjs/core/lib/utils/getOppositeVariationPlacement.js
var hash3 = {
  start: "end",
  end: "start"
};
function getOppositeVariationPlacement(placement) {
  return placement.replace(/start|end/g, function(matched) {
    return hash3[matched];
  });
}

// node_modules/@popperjs/core/lib/dom-utils/getWindowScroll.js
function getWindowScroll(node) {
  var win = getWindow(node);
  var scrollLeft = win.pageXOffset;
  var scrollTop = win.pageYOffset;
  return {
    scrollLeft,
    scrollTop
  };
}

// node_modules/@popperjs/core/lib/dom-utils/getWindowScrollBarX.js
function getWindowScrollBarX(element2) {
  return getBoundingClientRect(getDocumentElement(element2)).left + getWindowScroll(element2).scrollLeft;
}

// node_modules/@popperjs/core/lib/dom-utils/getViewportRect.js
function getViewportRect(element2, strategy) {
  var win = getWindow(element2);
  var html = getDocumentElement(element2);
  var visualViewport = win.visualViewport;
  var width = html.clientWidth;
  var height = html.clientHeight;
  var x = 0;
  var y = 0;
  if (visualViewport) {
    width = visualViewport.width;
    height = visualViewport.height;
    var layoutViewport = isLayoutViewport();
    if (layoutViewport || !layoutViewport && strategy === "fixed") {
      x = visualViewport.offsetLeft;
      y = visualViewport.offsetTop;
    }
  }
  return {
    width,
    height,
    x: x + getWindowScrollBarX(element2),
    y
  };
}

// node_modules/@popperjs/core/lib/dom-utils/getDocumentRect.js
function getDocumentRect(element2) {
  var _element$ownerDocumen;
  var html = getDocumentElement(element2);
  var winScroll = getWindowScroll(element2);
  var body = (_element$ownerDocumen = element2.ownerDocument) == null ? void 0 : _element$ownerDocumen.body;
  var width = max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
  var height = max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
  var x = -winScroll.scrollLeft + getWindowScrollBarX(element2);
  var y = -winScroll.scrollTop;
  if (getComputedStyle2(body || html).direction === "rtl") {
    x += max(html.clientWidth, body ? body.clientWidth : 0) - width;
  }
  return {
    width,
    height,
    x,
    y
  };
}

// node_modules/@popperjs/core/lib/dom-utils/isScrollParent.js
function isScrollParent(element2) {
  var _getComputedStyle = getComputedStyle2(element2), overflow = _getComputedStyle.overflow, overflowX = _getComputedStyle.overflowX, overflowY = _getComputedStyle.overflowY;
  return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
}

// node_modules/@popperjs/core/lib/dom-utils/getScrollParent.js
function getScrollParent(node) {
  if (["html", "body", "#document"].indexOf(getNodeName(node)) >= 0) {
    return node.ownerDocument.body;
  }
  if (isHTMLElement(node) && isScrollParent(node)) {
    return node;
  }
  return getScrollParent(getParentNode(node));
}

// node_modules/@popperjs/core/lib/dom-utils/listScrollParents.js
function listScrollParents(element2, list) {
  var _element$ownerDocumen;
  if (list === void 0) {
    list = [];
  }
  var scrollParent = getScrollParent(element2);
  var isBody = scrollParent === ((_element$ownerDocumen = element2.ownerDocument) == null ? void 0 : _element$ownerDocumen.body);
  var win = getWindow(scrollParent);
  var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent;
  var updatedList = list.concat(target);
  return isBody ? updatedList : updatedList.concat(listScrollParents(getParentNode(target)));
}

// node_modules/@popperjs/core/lib/utils/rectToClientRect.js
function rectToClientRect(rect) {
  return Object.assign({}, rect, {
    left: rect.x,
    top: rect.y,
    right: rect.x + rect.width,
    bottom: rect.y + rect.height
  });
}

// node_modules/@popperjs/core/lib/dom-utils/getClippingRect.js
function getInnerBoundingClientRect(element2, strategy) {
  var rect = getBoundingClientRect(element2, false, strategy === "fixed");
  rect.top = rect.top + element2.clientTop;
  rect.left = rect.left + element2.clientLeft;
  rect.bottom = rect.top + element2.clientHeight;
  rect.right = rect.left + element2.clientWidth;
  rect.width = element2.clientWidth;
  rect.height = element2.clientHeight;
  rect.x = rect.left;
  rect.y = rect.top;
  return rect;
}
function getClientRectFromMixedType(element2, clippingParent, strategy) {
  return clippingParent === viewport ? rectToClientRect(getViewportRect(element2, strategy)) : isElement(clippingParent) ? getInnerBoundingClientRect(clippingParent, strategy) : rectToClientRect(getDocumentRect(getDocumentElement(element2)));
}
function getClippingParents(element2) {
  var clippingParents2 = listScrollParents(getParentNode(element2));
  var canEscapeClipping = ["absolute", "fixed"].indexOf(getComputedStyle2(element2).position) >= 0;
  var clipperElement = canEscapeClipping && isHTMLElement(element2) ? getOffsetParent(element2) : element2;
  if (!isElement(clipperElement)) {
    return [];
  }
  return clippingParents2.filter(function(clippingParent) {
    return isElement(clippingParent) && contains(clippingParent, clipperElement) && getNodeName(clippingParent) !== "body";
  });
}
function getClippingRect(element2, boundary, rootBoundary, strategy) {
  var mainClippingParents = boundary === "clippingParents" ? getClippingParents(element2) : [].concat(boundary);
  var clippingParents2 = [].concat(mainClippingParents, [rootBoundary]);
  var firstClippingParent = clippingParents2[0];
  var clippingRect = clippingParents2.reduce(function(accRect, clippingParent) {
    var rect = getClientRectFromMixedType(element2, clippingParent, strategy);
    accRect.top = max(rect.top, accRect.top);
    accRect.right = min(rect.right, accRect.right);
    accRect.bottom = min(rect.bottom, accRect.bottom);
    accRect.left = max(rect.left, accRect.left);
    return accRect;
  }, getClientRectFromMixedType(element2, firstClippingParent, strategy));
  clippingRect.width = clippingRect.right - clippingRect.left;
  clippingRect.height = clippingRect.bottom - clippingRect.top;
  clippingRect.x = clippingRect.left;
  clippingRect.y = clippingRect.top;
  return clippingRect;
}

// node_modules/@popperjs/core/lib/utils/computeOffsets.js
function computeOffsets(_ref) {
  var reference2 = _ref.reference, element2 = _ref.element, placement = _ref.placement;
  var basePlacement = placement ? getBasePlacement(placement) : null;
  var variation = placement ? getVariation(placement) : null;
  var commonX = reference2.x + reference2.width / 2 - element2.width / 2;
  var commonY = reference2.y + reference2.height / 2 - element2.height / 2;
  var offsets;
  switch (basePlacement) {
    case top:
      offsets = {
        x: commonX,
        y: reference2.y - element2.height
      };
      break;
    case bottom:
      offsets = {
        x: commonX,
        y: reference2.y + reference2.height
      };
      break;
    case right:
      offsets = {
        x: reference2.x + reference2.width,
        y: commonY
      };
      break;
    case left:
      offsets = {
        x: reference2.x - element2.width,
        y: commonY
      };
      break;
    default:
      offsets = {
        x: reference2.x,
        y: reference2.y
      };
  }
  var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null;
  if (mainAxis != null) {
    var len = mainAxis === "y" ? "height" : "width";
    switch (variation) {
      case start:
        offsets[mainAxis] = offsets[mainAxis] - (reference2[len] / 2 - element2[len] / 2);
        break;
      case end:
        offsets[mainAxis] = offsets[mainAxis] + (reference2[len] / 2 - element2[len] / 2);
        break;
      default:
    }
  }
  return offsets;
}

// node_modules/@popperjs/core/lib/utils/detectOverflow.js
function detectOverflow(state, options) {
  if (options === void 0) {
    options = {};
  }
  var _options = options, _options$placement = _options.placement, placement = _options$placement === void 0 ? state.placement : _options$placement, _options$strategy = _options.strategy, strategy = _options$strategy === void 0 ? state.strategy : _options$strategy, _options$boundary = _options.boundary, boundary = _options$boundary === void 0 ? clippingParents : _options$boundary, _options$rootBoundary = _options.rootBoundary, rootBoundary = _options$rootBoundary === void 0 ? viewport : _options$rootBoundary, _options$elementConte = _options.elementContext, elementContext = _options$elementConte === void 0 ? popper : _options$elementConte, _options$altBoundary = _options.altBoundary, altBoundary = _options$altBoundary === void 0 ? false : _options$altBoundary, _options$padding = _options.padding, padding = _options$padding === void 0 ? 0 : _options$padding;
  var paddingObject = mergePaddingObject(typeof padding !== "number" ? padding : expandToHashMap(padding, basePlacements));
  var altContext = elementContext === popper ? reference : popper;
  var popperRect = state.rects.popper;
  var element2 = state.elements[altBoundary ? altContext : elementContext];
  var clippingClientRect = getClippingRect(isElement(element2) ? element2 : element2.contextElement || getDocumentElement(state.elements.popper), boundary, rootBoundary, strategy);
  var referenceClientRect = getBoundingClientRect(state.elements.reference);
  var popperOffsets2 = computeOffsets({
    reference: referenceClientRect,
    element: popperRect,
    strategy: "absolute",
    placement
  });
  var popperClientRect = rectToClientRect(Object.assign({}, popperRect, popperOffsets2));
  var elementClientRect = elementContext === popper ? popperClientRect : referenceClientRect;
  var overflowOffsets = {
    top: clippingClientRect.top - elementClientRect.top + paddingObject.top,
    bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom,
    left: clippingClientRect.left - elementClientRect.left + paddingObject.left,
    right: elementClientRect.right - clippingClientRect.right + paddingObject.right
  };
  var offsetData = state.modifiersData.offset;
  if (elementContext === popper && offsetData) {
    var offset2 = offsetData[placement];
    Object.keys(overflowOffsets).forEach(function(key) {
      var multiply = [right, bottom].indexOf(key) >= 0 ? 1 : -1;
      var axis = [top, bottom].indexOf(key) >= 0 ? "y" : "x";
      overflowOffsets[key] += offset2[axis] * multiply;
    });
  }
  return overflowOffsets;
}

// node_modules/@popperjs/core/lib/utils/computeAutoPlacement.js
function computeAutoPlacement(state, options) {
  if (options === void 0) {
    options = {};
  }
  var _options = options, placement = _options.placement, boundary = _options.boundary, rootBoundary = _options.rootBoundary, padding = _options.padding, flipVariations = _options.flipVariations, _options$allowedAutoP = _options.allowedAutoPlacements, allowedAutoPlacements = _options$allowedAutoP === void 0 ? placements : _options$allowedAutoP;
  var variation = getVariation(placement);
  var placements2 = variation ? flipVariations ? variationPlacements : variationPlacements.filter(function(placement2) {
    return getVariation(placement2) === variation;
  }) : basePlacements;
  var allowedPlacements = placements2.filter(function(placement2) {
    return allowedAutoPlacements.indexOf(placement2) >= 0;
  });
  if (allowedPlacements.length === 0) {
    allowedPlacements = placements2;
    if (true) {
      console.error(["Popper: The `allowedAutoPlacements` option did not allow any", "placements. Ensure the `placement` option matches the variation", "of the allowed placements.", 'For example, "auto" cannot be used to allow "bottom-start".', 'Use "auto-start" instead.'].join(" "));
    }
  }
  var overflows = allowedPlacements.reduce(function(acc, placement2) {
    acc[placement2] = detectOverflow(state, {
      placement: placement2,
      boundary,
      rootBoundary,
      padding
    })[getBasePlacement(placement2)];
    return acc;
  }, {});
  return Object.keys(overflows).sort(function(a, b) {
    return overflows[a] - overflows[b];
  });
}

// node_modules/@popperjs/core/lib/modifiers/flip.js
function getExpandedFallbackPlacements(placement) {
  if (getBasePlacement(placement) === auto) {
    return [];
  }
  var oppositePlacement = getOppositePlacement(placement);
  return [getOppositeVariationPlacement(placement), oppositePlacement, getOppositeVariationPlacement(oppositePlacement)];
}
function flip(_ref) {
  var state = _ref.state, options = _ref.options, name = _ref.name;
  if (state.modifiersData[name]._skip) {
    return;
  }
  var _options$mainAxis = options.mainAxis, checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis, _options$altAxis = options.altAxis, checkAltAxis = _options$altAxis === void 0 ? true : _options$altAxis, specifiedFallbackPlacements = options.fallbackPlacements, padding = options.padding, boundary = options.boundary, rootBoundary = options.rootBoundary, altBoundary = options.altBoundary, _options$flipVariatio = options.flipVariations, flipVariations = _options$flipVariatio === void 0 ? true : _options$flipVariatio, allowedAutoPlacements = options.allowedAutoPlacements;
  var preferredPlacement = state.options.placement;
  var basePlacement = getBasePlacement(preferredPlacement);
  var isBasePlacement = basePlacement === preferredPlacement;
  var fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipVariations ? [getOppositePlacement(preferredPlacement)] : getExpandedFallbackPlacements(preferredPlacement));
  var placements2 = [preferredPlacement].concat(fallbackPlacements).reduce(function(acc, placement2) {
    return acc.concat(getBasePlacement(placement2) === auto ? computeAutoPlacement(state, {
      placement: placement2,
      boundary,
      rootBoundary,
      padding,
      flipVariations,
      allowedAutoPlacements
    }) : placement2);
  }, []);
  var referenceRect = state.rects.reference;
  var popperRect = state.rects.popper;
  var checksMap = /* @__PURE__ */ new Map();
  var makeFallbackChecks = true;
  var firstFittingPlacement = placements2[0];
  for (var i = 0; i < placements2.length; i++) {
    var placement = placements2[i];
    var _basePlacement = getBasePlacement(placement);
    var isStartVariation = getVariation(placement) === start;
    var isVertical = [top, bottom].indexOf(_basePlacement) >= 0;
    var len = isVertical ? "width" : "height";
    var overflow = detectOverflow(state, {
      placement,
      boundary,
      rootBoundary,
      altBoundary,
      padding
    });
    var mainVariationSide = isVertical ? isStartVariation ? right : left : isStartVariation ? bottom : top;
    if (referenceRect[len] > popperRect[len]) {
      mainVariationSide = getOppositePlacement(mainVariationSide);
    }
    var altVariationSide = getOppositePlacement(mainVariationSide);
    var checks = [];
    if (checkMainAxis) {
      checks.push(overflow[_basePlacement] <= 0);
    }
    if (checkAltAxis) {
      checks.push(overflow[mainVariationSide] <= 0, overflow[altVariationSide] <= 0);
    }
    if (checks.every(function(check) {
      return check;
    })) {
      firstFittingPlacement = placement;
      makeFallbackChecks = false;
      break;
    }
    checksMap.set(placement, checks);
  }
  if (makeFallbackChecks) {
    var numberOfChecks = flipVariations ? 3 : 1;
    var _loop = function _loop2(_i2) {
      var fittingPlacement = placements2.find(function(placement2) {
        var checks2 = checksMap.get(placement2);
        if (checks2) {
          return checks2.slice(0, _i2).every(function(check) {
            return check;
          });
        }
      });
      if (fittingPlacement) {
        firstFittingPlacement = fittingPlacement;
        return "break";
      }
    };
    for (var _i = numberOfChecks; _i > 0; _i--) {
      var _ret = _loop(_i);
      if (_ret === "break")
        break;
    }
  }
  if (state.placement !== firstFittingPlacement) {
    state.modifiersData[name]._skip = true;
    state.placement = firstFittingPlacement;
    state.reset = true;
  }
}
var flip_default = {
  name: "flip",
  enabled: true,
  phase: "main",
  fn: flip,
  requiresIfExists: ["offset"],
  data: {
    _skip: false
  }
};

// node_modules/@popperjs/core/lib/modifiers/hide.js
function getSideOffsets(overflow, rect, preventedOffsets) {
  if (preventedOffsets === void 0) {
    preventedOffsets = {
      x: 0,
      y: 0
    };
  }
  return {
    top: overflow.top - rect.height - preventedOffsets.y,
    right: overflow.right - rect.width + preventedOffsets.x,
    bottom: overflow.bottom - rect.height + preventedOffsets.y,
    left: overflow.left - rect.width - preventedOffsets.x
  };
}
function isAnySideFullyClipped(overflow) {
  return [top, right, bottom, left].some(function(side) {
    return overflow[side] >= 0;
  });
}
function hide(_ref) {
  var state = _ref.state, name = _ref.name;
  var referenceRect = state.rects.reference;
  var popperRect = state.rects.popper;
  var preventedOffsets = state.modifiersData.preventOverflow;
  var referenceOverflow = detectOverflow(state, {
    elementContext: "reference"
  });
  var popperAltOverflow = detectOverflow(state, {
    altBoundary: true
  });
  var referenceClippingOffsets = getSideOffsets(referenceOverflow, referenceRect);
  var popperEscapeOffsets = getSideOffsets(popperAltOverflow, popperRect, preventedOffsets);
  var isReferenceHidden = isAnySideFullyClipped(referenceClippingOffsets);
  var hasPopperEscaped = isAnySideFullyClipped(popperEscapeOffsets);
  state.modifiersData[name] = {
    referenceClippingOffsets,
    popperEscapeOffsets,
    isReferenceHidden,
    hasPopperEscaped
  };
  state.attributes.popper = Object.assign({}, state.attributes.popper, {
    "data-popper-reference-hidden": isReferenceHidden,
    "data-popper-escaped": hasPopperEscaped
  });
}
var hide_default = {
  name: "hide",
  enabled: true,
  phase: "main",
  requiresIfExists: ["preventOverflow"],
  fn: hide
};

// node_modules/@popperjs/core/lib/modifiers/offset.js
function distanceAndSkiddingToXY(placement, rects, offset2) {
  var basePlacement = getBasePlacement(placement);
  var invertDistance = [left, top].indexOf(basePlacement) >= 0 ? -1 : 1;
  var _ref = typeof offset2 === "function" ? offset2(Object.assign({}, rects, {
    placement
  })) : offset2, skidding = _ref[0], distance = _ref[1];
  skidding = skidding || 0;
  distance = (distance || 0) * invertDistance;
  return [left, right].indexOf(basePlacement) >= 0 ? {
    x: distance,
    y: skidding
  } : {
    x: skidding,
    y: distance
  };
}
function offset(_ref2) {
  var state = _ref2.state, options = _ref2.options, name = _ref2.name;
  var _options$offset = options.offset, offset2 = _options$offset === void 0 ? [0, 0] : _options$offset;
  var data = placements.reduce(function(acc, placement) {
    acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset2);
    return acc;
  }, {});
  var _data$state$placement = data[state.placement], x = _data$state$placement.x, y = _data$state$placement.y;
  if (state.modifiersData.popperOffsets != null) {
    state.modifiersData.popperOffsets.x += x;
    state.modifiersData.popperOffsets.y += y;
  }
  state.modifiersData[name] = data;
}
var offset_default = {
  name: "offset",
  enabled: true,
  phase: "main",
  requires: ["popperOffsets"],
  fn: offset
};

// node_modules/@popperjs/core/lib/modifiers/popperOffsets.js
function popperOffsets(_ref) {
  var state = _ref.state, name = _ref.name;
  state.modifiersData[name] = computeOffsets({
    reference: state.rects.reference,
    element: state.rects.popper,
    strategy: "absolute",
    placement: state.placement
  });
}
var popperOffsets_default = {
  name: "popperOffsets",
  enabled: true,
  phase: "read",
  fn: popperOffsets,
  data: {}
};

// node_modules/@popperjs/core/lib/utils/getAltAxis.js
function getAltAxis(axis) {
  return axis === "x" ? "y" : "x";
}

// node_modules/@popperjs/core/lib/modifiers/preventOverflow.js
function preventOverflow(_ref) {
  var state = _ref.state, options = _ref.options, name = _ref.name;
  var _options$mainAxis = options.mainAxis, checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis, _options$altAxis = options.altAxis, checkAltAxis = _options$altAxis === void 0 ? false : _options$altAxis, boundary = options.boundary, rootBoundary = options.rootBoundary, altBoundary = options.altBoundary, padding = options.padding, _options$tether = options.tether, tether = _options$tether === void 0 ? true : _options$tether, _options$tetherOffset = options.tetherOffset, tetherOffset = _options$tetherOffset === void 0 ? 0 : _options$tetherOffset;
  var overflow = detectOverflow(state, {
    boundary,
    rootBoundary,
    padding,
    altBoundary
  });
  var basePlacement = getBasePlacement(state.placement);
  var variation = getVariation(state.placement);
  var isBasePlacement = !variation;
  var mainAxis = getMainAxisFromPlacement(basePlacement);
  var altAxis = getAltAxis(mainAxis);
  var popperOffsets2 = state.modifiersData.popperOffsets;
  var referenceRect = state.rects.reference;
  var popperRect = state.rects.popper;
  var tetherOffsetValue = typeof tetherOffset === "function" ? tetherOffset(Object.assign({}, state.rects, {
    placement: state.placement
  })) : tetherOffset;
  var normalizedTetherOffsetValue = typeof tetherOffsetValue === "number" ? {
    mainAxis: tetherOffsetValue,
    altAxis: tetherOffsetValue
  } : Object.assign({
    mainAxis: 0,
    altAxis: 0
  }, tetherOffsetValue);
  var offsetModifierState = state.modifiersData.offset ? state.modifiersData.offset[state.placement] : null;
  var data = {
    x: 0,
    y: 0
  };
  if (!popperOffsets2) {
    return;
  }
  if (checkMainAxis) {
    var _offsetModifierState$;
    var mainSide = mainAxis === "y" ? top : left;
    var altSide = mainAxis === "y" ? bottom : right;
    var len = mainAxis === "y" ? "height" : "width";
    var offset2 = popperOffsets2[mainAxis];
    var min2 = offset2 + overflow[mainSide];
    var max2 = offset2 - overflow[altSide];
    var additive = tether ? -popperRect[len] / 2 : 0;
    var minLen = variation === start ? referenceRect[len] : popperRect[len];
    var maxLen = variation === start ? -popperRect[len] : -referenceRect[len];
    var arrowElement = state.elements.arrow;
    var arrowRect = tether && arrowElement ? getLayoutRect(arrowElement) : {
      width: 0,
      height: 0
    };
    var arrowPaddingObject = state.modifiersData["arrow#persistent"] ? state.modifiersData["arrow#persistent"].padding : getFreshSideObject();
    var arrowPaddingMin = arrowPaddingObject[mainSide];
    var arrowPaddingMax = arrowPaddingObject[altSide];
    var arrowLen = within(0, referenceRect[len], arrowRect[len]);
    var minOffset = isBasePlacement ? referenceRect[len] / 2 - additive - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis : minLen - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis;
    var maxOffset = isBasePlacement ? -referenceRect[len] / 2 + additive + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis : maxLen + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis;
    var arrowOffsetParent = state.elements.arrow && getOffsetParent(state.elements.arrow);
    var clientOffset = arrowOffsetParent ? mainAxis === "y" ? arrowOffsetParent.clientTop || 0 : arrowOffsetParent.clientLeft || 0 : 0;
    var offsetModifierValue = (_offsetModifierState$ = offsetModifierState == null ? void 0 : offsetModifierState[mainAxis]) != null ? _offsetModifierState$ : 0;
    var tetherMin = offset2 + minOffset - offsetModifierValue - clientOffset;
    var tetherMax = offset2 + maxOffset - offsetModifierValue;
    var preventedOffset = within(tether ? min(min2, tetherMin) : min2, offset2, tether ? max(max2, tetherMax) : max2);
    popperOffsets2[mainAxis] = preventedOffset;
    data[mainAxis] = preventedOffset - offset2;
  }
  if (checkAltAxis) {
    var _offsetModifierState$2;
    var _mainSide = mainAxis === "x" ? top : left;
    var _altSide = mainAxis === "x" ? bottom : right;
    var _offset = popperOffsets2[altAxis];
    var _len = altAxis === "y" ? "height" : "width";
    var _min = _offset + overflow[_mainSide];
    var _max = _offset - overflow[_altSide];
    var isOriginSide = [top, left].indexOf(basePlacement) !== -1;
    var _offsetModifierValue = (_offsetModifierState$2 = offsetModifierState == null ? void 0 : offsetModifierState[altAxis]) != null ? _offsetModifierState$2 : 0;
    var _tetherMin = isOriginSide ? _min : _offset - referenceRect[_len] - popperRect[_len] - _offsetModifierValue + normalizedTetherOffsetValue.altAxis;
    var _tetherMax = isOriginSide ? _offset + referenceRect[_len] + popperRect[_len] - _offsetModifierValue - normalizedTetherOffsetValue.altAxis : _max;
    var _preventedOffset = tether && isOriginSide ? withinMaxClamp(_tetherMin, _offset, _tetherMax) : within(tether ? _tetherMin : _min, _offset, tether ? _tetherMax : _max);
    popperOffsets2[altAxis] = _preventedOffset;
    data[altAxis] = _preventedOffset - _offset;
  }
  state.modifiersData[name] = data;
}
var preventOverflow_default = {
  name: "preventOverflow",
  enabled: true,
  phase: "main",
  fn: preventOverflow,
  requiresIfExists: ["offset"]
};

// node_modules/@popperjs/core/lib/dom-utils/getHTMLElementScroll.js
function getHTMLElementScroll(element2) {
  return {
    scrollLeft: element2.scrollLeft,
    scrollTop: element2.scrollTop
  };
}

// node_modules/@popperjs/core/lib/dom-utils/getNodeScroll.js
function getNodeScroll(node) {
  if (node === getWindow(node) || !isHTMLElement(node)) {
    return getWindowScroll(node);
  } else {
    return getHTMLElementScroll(node);
  }
}

// node_modules/@popperjs/core/lib/dom-utils/getCompositeRect.js
function isElementScaled(element2) {
  var rect = element2.getBoundingClientRect();
  var scaleX = round(rect.width) / element2.offsetWidth || 1;
  var scaleY = round(rect.height) / element2.offsetHeight || 1;
  return scaleX !== 1 || scaleY !== 1;
}
function getCompositeRect(elementOrVirtualElement, offsetParent, isFixed) {
  if (isFixed === void 0) {
    isFixed = false;
  }
  var isOffsetParentAnElement = isHTMLElement(offsetParent);
  var offsetParentIsScaled = isHTMLElement(offsetParent) && isElementScaled(offsetParent);
  var documentElement = getDocumentElement(offsetParent);
  var rect = getBoundingClientRect(elementOrVirtualElement, offsetParentIsScaled, isFixed);
  var scroll = {
    scrollLeft: 0,
    scrollTop: 0
  };
  var offsets = {
    x: 0,
    y: 0
  };
  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
    if (getNodeName(offsetParent) !== "body" || isScrollParent(documentElement)) {
      scroll = getNodeScroll(offsetParent);
    }
    if (isHTMLElement(offsetParent)) {
      offsets = getBoundingClientRect(offsetParent, true);
      offsets.x += offsetParent.clientLeft;
      offsets.y += offsetParent.clientTop;
    } else if (documentElement) {
      offsets.x = getWindowScrollBarX(documentElement);
    }
  }
  return {
    x: rect.left + scroll.scrollLeft - offsets.x,
    y: rect.top + scroll.scrollTop - offsets.y,
    width: rect.width,
    height: rect.height
  };
}

// node_modules/@popperjs/core/lib/utils/orderModifiers.js
function order(modifiers) {
  var map = /* @__PURE__ */ new Map();
  var visited = /* @__PURE__ */ new Set();
  var result = [];
  modifiers.forEach(function(modifier) {
    map.set(modifier.name, modifier);
  });
  function sort(modifier) {
    visited.add(modifier.name);
    var requires = [].concat(modifier.requires || [], modifier.requiresIfExists || []);
    requires.forEach(function(dep) {
      if (!visited.has(dep)) {
        var depModifier = map.get(dep);
        if (depModifier) {
          sort(depModifier);
        }
      }
    });
    result.push(modifier);
  }
  modifiers.forEach(function(modifier) {
    if (!visited.has(modifier.name)) {
      sort(modifier);
    }
  });
  return result;
}
function orderModifiers(modifiers) {
  var orderedModifiers = order(modifiers);
  return modifierPhases.reduce(function(acc, phase) {
    return acc.concat(orderedModifiers.filter(function(modifier) {
      return modifier.phase === phase;
    }));
  }, []);
}

// node_modules/@popperjs/core/lib/utils/debounce.js
function debounce(fn2) {
  var pending;
  return function() {
    if (!pending) {
      pending = new Promise(function(resolve) {
        Promise.resolve().then(function() {
          pending = void 0;
          resolve(fn2());
        });
      });
    }
    return pending;
  };
}

// node_modules/@popperjs/core/lib/utils/format.js
function format2(str) {
  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
    args[_key - 1] = arguments[_key];
  }
  return [].concat(args).reduce(function(p, c) {
    return p.replace(/%s/, c);
  }, str);
}

// node_modules/@popperjs/core/lib/utils/validateModifiers.js
var INVALID_MODIFIER_ERROR = 'Popper: modifier "%s" provided an invalid %s property, expected %s but got %s';
var MISSING_DEPENDENCY_ERROR = 'Popper: modifier "%s" requires "%s", but "%s" modifier is not available';
var VALID_PROPERTIES = ["name", "enabled", "phase", "fn", "effect", "requires", "options"];
function validateModifiers(modifiers) {
  modifiers.forEach(function(modifier) {
    [].concat(Object.keys(modifier), VALID_PROPERTIES).filter(function(value, index, self) {
      return self.indexOf(value) === index;
    }).forEach(function(key) {
      switch (key) {
        case "name":
          if (typeof modifier.name !== "string") {
            console.error(format2(INVALID_MODIFIER_ERROR, String(modifier.name), '"name"', '"string"', '"' + String(modifier.name) + '"'));
          }
          break;
        case "enabled":
          if (typeof modifier.enabled !== "boolean") {
            console.error(format2(INVALID_MODIFIER_ERROR, modifier.name, '"enabled"', '"boolean"', '"' + String(modifier.enabled) + '"'));
          }
          break;
        case "phase":
          if (modifierPhases.indexOf(modifier.phase) < 0) {
            console.error(format2(INVALID_MODIFIER_ERROR, modifier.name, '"phase"', "either " + modifierPhases.join(", "), '"' + String(modifier.phase) + '"'));
          }
          break;
        case "fn":
          if (typeof modifier.fn !== "function") {
            console.error(format2(INVALID_MODIFIER_ERROR, modifier.name, '"fn"', '"function"', '"' + String(modifier.fn) + '"'));
          }
          break;
        case "effect":
          if (modifier.effect != null && typeof modifier.effect !== "function") {
            console.error(format2(INVALID_MODIFIER_ERROR, modifier.name, '"effect"', '"function"', '"' + String(modifier.fn) + '"'));
          }
          break;
        case "requires":
          if (modifier.requires != null && !Array.isArray(modifier.requires)) {
            console.error(format2(INVALID_MODIFIER_ERROR, modifier.name, '"requires"', '"array"', '"' + String(modifier.requires) + '"'));
          }
          break;
        case "requiresIfExists":
          if (!Array.isArray(modifier.requiresIfExists)) {
            console.error(format2(INVALID_MODIFIER_ERROR, modifier.name, '"requiresIfExists"', '"array"', '"' + String(modifier.requiresIfExists) + '"'));
          }
          break;
        case "options":
        case "data":
          break;
        default:
          console.error('PopperJS: an invalid property has been provided to the "' + modifier.name + '" modifier, valid properties are ' + VALID_PROPERTIES.map(function(s) {
            return '"' + s + '"';
          }).join(", ") + '; but "' + key + '" was provided.');
      }
      modifier.requires && modifier.requires.forEach(function(requirement) {
        if (modifiers.find(function(mod) {
          return mod.name === requirement;
        }) == null) {
          console.error(format2(MISSING_DEPENDENCY_ERROR, String(modifier.name), requirement, requirement));
        }
      });
    });
  });
}

// node_modules/@popperjs/core/lib/utils/uniqueBy.js
function uniqueBy(arr, fn2) {
  var identifiers = /* @__PURE__ */ new Set();
  return arr.filter(function(item) {
    var identifier = fn2(item);
    if (!identifiers.has(identifier)) {
      identifiers.add(identifier);
      return true;
    }
  });
}

// node_modules/@popperjs/core/lib/utils/mergeByName.js
function mergeByName(modifiers) {
  var merged = modifiers.reduce(function(merged2, current) {
    var existing = merged2[current.name];
    merged2[current.name] = existing ? Object.assign({}, existing, current, {
      options: Object.assign({}, existing.options, current.options),
      data: Object.assign({}, existing.data, current.data)
    }) : current;
    return merged2;
  }, {});
  return Object.keys(merged).map(function(key) {
    return merged[key];
  });
}

// node_modules/@popperjs/core/lib/createPopper.js
var INVALID_ELEMENT_ERROR = "Popper: Invalid reference or popper argument provided. They must be either a DOM element or virtual element.";
var INFINITE_LOOP_ERROR = "Popper: An infinite loop in the modifiers cycle has been detected! The cycle has been interrupted to prevent a browser crash.";
var DEFAULT_OPTIONS = {
  placement: "bottom",
  modifiers: [],
  strategy: "absolute"
};
function areValidElements() {
  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
    args[_key] = arguments[_key];
  }
  return !args.some(function(element2) {
    return !(element2 && typeof element2.getBoundingClientRect === "function");
  });
}
function popperGenerator(generatorOptions) {
  if (generatorOptions === void 0) {
    generatorOptions = {};
  }
  var _generatorOptions = generatorOptions, _generatorOptions$def = _generatorOptions.defaultModifiers, defaultModifiers2 = _generatorOptions$def === void 0 ? [] : _generatorOptions$def, _generatorOptions$def2 = _generatorOptions.defaultOptions, defaultOptions = _generatorOptions$def2 === void 0 ? DEFAULT_OPTIONS : _generatorOptions$def2;
  return function createPopper2(reference2, popper2, options) {
    if (options === void 0) {
      options = defaultOptions;
    }
    var state = {
      placement: "bottom",
      orderedModifiers: [],
      options: Object.assign({}, DEFAULT_OPTIONS, defaultOptions),
      modifiersData: {},
      elements: {
        reference: reference2,
        popper: popper2
      },
      attributes: {},
      styles: {}
    };
    var effectCleanupFns = [];
    var isDestroyed = false;
    var instance27 = {
      state,
      setOptions: function setOptions(setOptionsAction) {
        var options2 = typeof setOptionsAction === "function" ? setOptionsAction(state.options) : setOptionsAction;
        cleanupModifierEffects();
        state.options = Object.assign({}, defaultOptions, state.options, options2);
        state.scrollParents = {
          reference: isElement(reference2) ? listScrollParents(reference2) : reference2.contextElement ? listScrollParents(reference2.contextElement) : [],
          popper: listScrollParents(popper2)
        };
        var orderedModifiers = orderModifiers(mergeByName([].concat(defaultModifiers2, state.options.modifiers)));
        state.orderedModifiers = orderedModifiers.filter(function(m) {
          return m.enabled;
        });
        if (true) {
          var modifiers = uniqueBy([].concat(orderedModifiers, state.options.modifiers), function(_ref) {
            var name = _ref.name;
            return name;
          });
          validateModifiers(modifiers);
          if (getBasePlacement(state.options.placement) === auto) {
            var flipModifier = state.orderedModifiers.find(function(_ref2) {
              var name = _ref2.name;
              return name === "flip";
            });
            if (!flipModifier) {
              console.error(['Popper: "auto" placements require the "flip" modifier be', "present and enabled to work."].join(" "));
            }
          }
          var _getComputedStyle = getComputedStyle2(popper2), marginTop = _getComputedStyle.marginTop, marginRight = _getComputedStyle.marginRight, marginBottom = _getComputedStyle.marginBottom, marginLeft = _getComputedStyle.marginLeft;
          if ([marginTop, marginRight, marginBottom, marginLeft].some(function(margin) {
            return parseFloat(margin);
          })) {
            console.warn(['Popper: CSS "margin" styles cannot be used to apply padding', "between the popper and its reference element or boundary.", "To replicate margin, use the `offset` modifier, as well as", "the `padding` option in the `preventOverflow` and `flip`", "modifiers."].join(" "));
          }
        }
        runModifierEffects();
        return instance27.update();
      },
      forceUpdate: function forceUpdate() {
        if (isDestroyed) {
          return;
        }
        var _state$elements = state.elements, reference3 = _state$elements.reference, popper3 = _state$elements.popper;
        if (!areValidElements(reference3, popper3)) {
          if (true) {
            console.error(INVALID_ELEMENT_ERROR);
          }
          return;
        }
        state.rects = {
          reference: getCompositeRect(reference3, getOffsetParent(popper3), state.options.strategy === "fixed"),
          popper: getLayoutRect(popper3)
        };
        state.reset = false;
        state.placement = state.options.placement;
        state.orderedModifiers.forEach(function(modifier) {
          return state.modifiersData[modifier.name] = Object.assign({}, modifier.data);
        });
        var __debug_loops__ = 0;
        for (var index = 0; index < state.orderedModifiers.length; index++) {
          if (true) {
            __debug_loops__ += 1;
            if (__debug_loops__ > 100) {
              console.error(INFINITE_LOOP_ERROR);
              break;
            }
          }
          if (state.reset === true) {
            state.reset = false;
            index = -1;
            continue;
          }
          var _state$orderedModifie = state.orderedModifiers[index], fn2 = _state$orderedModifie.fn, _state$orderedModifie2 = _state$orderedModifie.options, _options = _state$orderedModifie2 === void 0 ? {} : _state$orderedModifie2, name = _state$orderedModifie.name;
          if (typeof fn2 === "function") {
            state = fn2({
              state,
              options: _options,
              name,
              instance: instance27
            }) || state;
          }
        }
      },
      update: debounce(function() {
        return new Promise(function(resolve) {
          instance27.forceUpdate();
          resolve(state);
        });
      }),
      destroy: function destroy() {
        cleanupModifierEffects();
        isDestroyed = true;
      }
    };
    if (!areValidElements(reference2, popper2)) {
      if (true) {
        console.error(INVALID_ELEMENT_ERROR);
      }
      return instance27;
    }
    instance27.setOptions(options).then(function(state2) {
      if (!isDestroyed && options.onFirstUpdate) {
        options.onFirstUpdate(state2);
      }
    });
    function runModifierEffects() {
      state.orderedModifiers.forEach(function(_ref3) {
        var name = _ref3.name, _ref3$options = _ref3.options, options2 = _ref3$options === void 0 ? {} : _ref3$options, effect4 = _ref3.effect;
        if (typeof effect4 === "function") {
          var cleanupFn = effect4({
            state,
            name,
            instance: instance27,
            options: options2
          });
          var noopFn = function noopFn2() {
          };
          effectCleanupFns.push(cleanupFn || noopFn);
        }
      });
    }
    function cleanupModifierEffects() {
      effectCleanupFns.forEach(function(fn2) {
        return fn2();
      });
      effectCleanupFns = [];
    }
    return instance27;
  };
}

// node_modules/@popperjs/core/lib/popper.js
var defaultModifiers = [eventListeners_default, popperOffsets_default, computeStyles_default, applyStyles_default, offset_default, flip_default, preventOverflow_default, arrow_default, hide_default];
var createPopper = /* @__PURE__ */ popperGenerator({
  defaultModifiers
});

// src/suggester/suggester.ts
var Suggester = class {
  constructor(ISuggester, scope) {
    this.ISuggester = ISuggester;
    this.suggestionsStore = writable();
    this.selectedItemIndexStore = writable();
    this.suggestionsContainer = writable();
    this.selectedItemIndexStore.subscribe((value) => this.selectedItemIndex = value);
    this.suggestionsStore.subscribe((value) => this.suggestions = value);
    this.setSuggestions([]);
    this.setSelectedItemIndex(0);
    scope.register([], "ArrowUp", (e) => {
      e.preventDefault();
      this.setSelectedItemIndex(this.selectedItemIndex - 1);
      this.ISuggester.scrollSelectedItemIntoView();
    });
    scope.register([], "ArrowDown", (e) => {
      e.preventDefault();
      this.setSelectedItemIndex(this.selectedItemIndex + 1);
      this.ISuggester.scrollSelectedItemIntoView();
    });
    scope.register([], "Enter", (e) => {
      e.preventDefault();
      this.ISuggester.useSelectedItem(this.getSelectedItem());
    });
  }
  setSuggestions(suggestions) {
    this.selectedItemIndexStore.set(0);
    this.suggestionsStore.set(suggestions);
  }
  getSuggestions() {
    return this.suggestions;
  }
  getSelectedItem() {
    return this.suggestions[this.selectedItemIndex];
  }
  getSelectedItemIndex() {
    return this.selectedItemIndex;
  }
  getSuggestionByIndex(index) {
    return this.suggestions[index];
  }
  setSelectedItemIndex(newIndex) {
    if (newIndex >= this.suggestions.length) {
      this.selectedItemIndexStore.set(0);
    } else if (newIndex < 0) {
      this.selectedItemIndexStore.set(this.suggestions.length - 1);
    } else {
      this.selectedItemIndexStore.set(newIndex);
    }
  }
};
var TextInputSuggester = class {
  additionalCleaning() {
  }
  onOpen() {
  }
  onClose() {
  }
  constructor(app2, inputEl, suggestionParentContainer, viewOptions, searchDelay) {
    this.app = app2;
    this.inputEl = inputEl;
    this.scope = new import_obsidian2.Scope(this.app.scope);
    this.suggester = new Suggester(this, this.scope);
    this.inputListener = searchDelay ? (0, import_obsidian2.debounce)(async () => await this.onInput(), searchDelay, false) : this.onInput.bind(this);
    this.inputEl.addEventListener("input", this.inputListener);
    this.inputEl.addEventListener("focus", this.inputListener);
    this.inputEl.addEventListener("blur", this.close.bind(this));
    this.scope.register([], "escape", this.close.bind(this));
    this.viewOptions = viewOptions != null ? viewOptions : {};
    this.suggestionParentContainer = suggestionParentContainer;
    this.closingAnimationRunning = false;
  }
  async onInput() {
    const input = this.inputEl.value;
    const suggestions = await this.getSuggestions(input);
    if (suggestions.length > 0) {
      this.suggester.setSuggestions(suggestions);
      this.open();
    } else if (suggestions.length === 0) {
      this.onNoSuggestion();
    }
  }
  onNoSuggestion() {
    this.close();
  }
  getContainerEl() {
    return this.suggestionParentContainer;
  }
  open() {
    if (this.closingAnimationRunning)
      this.abortClosingAnimation();
    if (this.suggesterView)
      return;
    this.suggestionContainer = this.getContainerEl();
    this.app.keymap.pushScope(this.scope);
    this.suggesterView = new suggesterView_default({
      target: this.suggestionContainer,
      props: {
        textInputSuggester: this,
        options: this.viewOptions
      },
      intro: true
    });
    this.onOpen();
  }
  close() {
    this.app.keymap.popScope(this.scope);
    this.suggester.setSuggestions([]);
    if (this.suggesterView) {
      this.closingAnimationRunning = true;
      this.closingAnimationTimeout = setTimeout(() => {
        var _a;
        (_a = this.suggesterView) == null ? void 0 : _a.$destroy();
        this.suggesterView = void 0;
        this.closingAnimationRunning = false;
      }, 200);
    }
    this.additionalCleaning();
    this.onClose();
  }
  abortClosingAnimation() {
    var _a;
    clearTimeout(this.closingAnimationTimeout);
    (_a = this.suggesterView) == null ? void 0 : _a.$destroy();
    this.suggesterView = void 0;
    this.closingAnimationRunning = false;
  }
  destroy() {
    this.close();
    this.inputEl.removeEventListener("input", this.inputListener);
    this.inputEl.removeEventListener("focus", this.inputListener);
  }
  scrollSelectedItemIntoView() {
    var _a;
    (_a = get_store_value(this.suggester.suggestionsContainer).children[this.suggester.getSelectedItemIndex()]) == null ? void 0 : _a.scrollIntoView({ behavior: "auto", block: "nearest", inline: "nearest" });
  }
  getSuggester() {
    return this.suggester;
  }
  setInput(input) {
    this.inputEl.value = input;
    this.inputEl.dispatchEvent(new Event("input"));
  }
};
var PopoverTextInputSuggester = class extends TextInputSuggester {
  constructor(app2, inputEl, viewOptions) {
    super(app2, inputEl, app2.dom.appContainerEl, viewOptions);
  }
  getContainerEl() {
    if (document.contains(this.popperWrapper))
      return this.popperWrapper;
    this.popperWrapper = this.suggestionParentContainer.createDiv("popper-wrapper");
    this.popperWrapper.style.zIndex = "var(--layer-menu)";
    const isPhone = import_obsidian2.Platform.isPhone;
    const popperReference = isPhone ? document.body : this.inputEl;
    if (isPhone) {
      this.popperWrapper.style.width = "100%";
    }
    this.popperInstance = createPopper(popperReference, this.popperWrapper, {
      placement: "bottom-start",
      modifiers: [{
        name: "offset",
        options: {
          offset: [0, 5]
        }
      }]
    });
    return this.popperWrapper;
  }
  additionalCleaning() {
    if (this.popperInstance) {
      this.popperInstance.destroy();
    }
    if (document.body.contains(this.popperWrapper)) {
      this.popperWrapper.detach();
    }
  }
};

// src/utils/lucideIcons.ts
var lucideIcons = [
  "accessibility",
  "activity",
  "air-vent",
  "airplay",
  "alarm-check",
  "alarm-clock-off",
  "alarm-clock",
  "alarm-minus",
  "alarm-plus",
  "album",
  "alert-circle",
  "alert-octagon",
  "alert-triangle",
  "align-center-horizontal",
  "align-center-vertical",
  "align-center",
  "align-end-horizontal",
  "align-end-vertical",
  "align-horizontal-distribute-center",
  "align-horizontal-distribute-end",
  "align-horizontal-distribute-start",
  "align-horizontal-justify-center",
  "align-horizontal-justify-end",
  "align-horizontal-justify-start",
  "align-horizontal-space-around",
  "align-horizontal-space-between",
  "align-justify",
  "align-left",
  "align-right",
  "align-start-horizontal",
  "align-start-vertical",
  "align-vertical-distribute-center",
  "align-vertical-distribute-end",
  "align-vertical-distribute-start",
  "align-vertical-justify-center",
  "align-vertical-justify-end",
  "align-vertical-justify-start",
  "align-vertical-space-around",
  "align-vertical-space-between",
  "anchor",
  "angry",
  "annoyed",
  "aperture",
  "apple",
  "archive-restore",
  "archive",
  "armchair",
  "arrow-big-down",
  "arrow-big-left",
  "arrow-big-right",
  "arrow-big-up",
  "arrow-down-circle",
  "arrow-down-left",
  "arrow-down-right",
  "arrow-down",
  "arrow-left-circle",
  "arrow-left-right",
  "arrow-left",
  "arrow-right-circle",
  "arrow-right",
  "arrow-up-circle",
  "arrow-up-down",
  "arrow-up-left",
  "arrow-up-right",
  "arrow-up",
  "asterisk",
  "at-sign",
  "award",
  "axe",
  "axis-3d",
  "baby",
  "backpack",
  "baggage-claim",
  "banana",
  "banknote",
  "bar-chart-2",
  "bar-chart-3",
  "bar-chart-4",
  "bar-chart-horizontal",
  "bar-chart",
  "baseline",
  "bath",
  "battery-charging",
  "battery-full",
  "battery-low",
  "battery-medium",
  "battery",
  "beaker",
  "bed-double",
  "bed-single",
  "bed",
  "beer",
  "bell-minus",
  "bell-off",
  "bell-plus",
  "bell-ring",
  "bell",
  "bike",
  "binary",
  "bitcoin",
  "bluetooth-connected",
  "bluetooth-off",
  "bluetooth-searching",
  "bluetooth",
  "bold",
  "bomb",
  "bone",
  "book-open-check",
  "book-open",
  "book",
  "bookmark-minus",
  "bookmark-plus",
  "bookmark",
  "bot",
  "box-select",
  "box",
  "boxes",
  "briefcase",
  "brush",
  "bug",
  "building-2",
  "building",
  "bus",
  "cake",
  "calculator",
  "calendar-check-2",
  "calendar-check",
  "calendar-clock",
  "calendar-days",
  "calendar-heart",
  "calendar-minus",
  "calendar-off",
  "calendar-plus",
  "calendar-range",
  "calendar-search",
  "calendar-x",
  "calendar",
  "camera-off",
  "camera",
  "car",
  "carrot",
  "cast",
  "check-circle-2",
  "check-circle",
  "check-square",
  "check",
  "chef-hat",
  "cherry",
  "chevron-down",
  "chevron-first",
  "chevron-last",
  "chevron-left",
  "chevron-right",
  "chevron-up",
  "chevrons-down-up",
  "chevrons-down",
  "chevrons-left-right",
  "chevrons-left",
  "chevrons-right-left",
  "chevrons-right",
  "chevrons-up-down",
  "chevrons-up",
  "chrome",
  "cigarette-off",
  "cigarette",
  "circle-dot",
  "circle-ellipsis",
  "circle-slashed",
  "circle",
  "citrus",
  "clapperboard",
  "clipboard-check",
  "clipboard-copy",
  "clipboard-edit",
  "clipboard-list",
  "clipboard-signature",
  "clipboard-type",
  "clipboard-x",
  "clipboard",
  "clock-1",
  "clock-10",
  "clock-11",
  "clock-12",
  "clock-2",
  "clock-3",
  "clock-4",
  "clock-5",
  "clock-6",
  "clock-7",
  "clock-8",
  "clock-9",
  "clock",
  "cloud-cog",
  "cloud-drizzle",
  "cloud-fog",
  "cloud-hail",
  "cloud-lightning",
  "cloud-moon-rain",
  "cloud-moon",
  "cloud-off",
  "cloud-rain-wind",
  "cloud-rain",
  "cloud-snow",
  "cloud-sun-rain",
  "cloud-sun",
  "cloud",
  "cloudy",
  "clover",
  "code-2",
  "code",
  "codepen",
  "codesandbox",
  "coffee",
  "cog",
  "coins",
  "columns",
  "command",
  "compass",
  "component",
  "concierge-bell",
  "contact",
  "contrast",
  "cookie",
  "copy",
  "copyleft",
  "copyright",
  "corner-down-left",
  "corner-down-right",
  "corner-left-down",
  "corner-left-up",
  "corner-right-down",
  "corner-right-up",
  "corner-up-left",
  "corner-up-right",
  "cpu",
  "credit-card",
  "croissant",
  "crop",
  "cross",
  "crosshair",
  "crown",
  "cup-soda",
  "curly-braces",
  "currency",
  "database",
  "delete",
  "diamond",
  "dice-1",
  "dice-2",
  "dice-3",
  "dice-4",
  "dice-5",
  "dice-6",
  "dices",
  "diff",
  "disc",
  "divide-circle",
  "divide-square",
  "divide",
  "dollar-sign",
  "download-cloud",
  "download",
  "dribbble",
  "droplet",
  "droplets",
  "drumstick",
  "edit-2",
  "edit-3",
  "edit",
  "egg-fried",
  "egg",
  "equal-not",
  "equal",
  "eraser",
  "euro",
  "expand",
  "external-link",
  "eye-off",
  "eye",
  "facebook",
  "factory",
  "fan",
  "fast-forward",
  "feather",
  "figma",
  "file-archive",
  "file-audio-2",
  "file-audio",
  "file-axis-3d",
  "file-badge-2",
  "file-badge",
  "file-bar-chart-2",
  "file-bar-chart",
  "file-box",
  "file-check-2",
  "file-check",
  "file-clock",
  "file-code",
  "file-cog-2",
  "file-cog",
  "file-diff",
  "file-digit",
  "file-down",
  "file-edit",
  "file-heart",
  "file-image",
  "file-input",
  "file-json-2",
  "file-json",
  "file-key-2",
  "file-key",
  "file-line-chart",
  "file-lock-2",
  "file-lock",
  "file-minus-2",
  "file-minus",
  "file-output",
  "file-pie-chart",
  "file-plus-2",
  "file-plus",
  "file-question",
  "file-scan",
  "file-search-2",
  "file-search",
  "file-signature",
  "file-spreadsheet",
  "file-symlink",
  "file-terminal",
  "file-text",
  "file-type-2",
  "file-type",
  "file-up",
  "file-video-2",
  "file-video",
  "file-volume-2",
  "file-volume",
  "file-warning",
  "file-x-2",
  "file-x",
  "file",
  "files",
  "film",
  "filter",
  "fingerprint",
  "flag-off",
  "flag-triangle-left",
  "flag-triangle-right",
  "flag",
  "flame",
  "flashlight-off",
  "flashlight",
  "flask-conical",
  "flask-round",
  "flip-horizontal-2",
  "flip-horizontal",
  "flip-vertical-2",
  "flip-vertical",
  "flower-2",
  "flower",
  "focus",
  "folder-archive",
  "folder-check",
  "folder-clock",
  "folder-closed",
  "folder-cog-2",
  "folder-cog",
  "folder-down",
  "folder-edit",
  "folder-heart",
  "folder-input",
  "folder-key",
  "folder-lock",
  "folder-minus",
  "folder-open",
  "folder-output",
  "folder-plus",
  "folder-search-2",
  "folder-search",
  "folder-symlink",
  "folder-tree",
  "folder-up",
  "folder-x",
  "folder",
  "folders",
  "form-input",
  "forward",
  "frame",
  "framer",
  "frown",
  "fuel",
  "function-square",
  "gamepad-2",
  "gamepad",
  "gauge",
  "gavel",
  "gem",
  "ghost",
  "gift",
  "git-branch-plus",
  "git-branch",
  "git-commit",
  "git-compare",
  "git-fork",
  "git-merge",
  "git-pull-request-closed",
  "git-pull-request-draft",
  "git-pull-request",
  "github",
  "gitlab",
  "glass-water",
  "glasses",
  "globe-2",
  "globe",
  "grab",
  "graduation-cap",
  "grape",
  "grid",
  "grip-horizontal",
  "grip-vertical",
  "hammer",
  "hand-metal",
  "hand",
  "hard-drive",
  "hard-hat",
  "hash",
  "haze",
  "headphones",
  "heart-crack",
  "heart-handshake",
  "heart-off",
  "heart-pulse",
  "heart",
  "help-circle",
  "hexagon",
  "highlighter",
  "history",
  "home",
  "hourglass",
  "ice-cream",
  "image-minus",
  "image-off",
  "image-plus",
  "image",
  "import",
  "inbox",
  "indent",
  "indian-rupee",
  "infinity",
  "info",
  "inspect",
  "instagram",
  "italic",
  "japanese-yen",
  "joystick",
  "key",
  "keyboard",
  "lamp-ceiling",
  "lamp-desk",
  "lamp-floor",
  "lamp-wall-down",
  "lamp-wall-up",
  "lamp",
  "landmark",
  "languages",
  "laptop-2",
  "laptop",
  "lasso-select",
  "lasso",
  "laugh",
  "layers",
  "layout-dashboard",
  "layout-grid",
  "layout-list",
  "layout-template",
  "layout",
  "leaf",
  "library",
  "life-buoy",
  "lightbulb-off",
  "lightbulb",
  "line-chart",
  "link-2-off",
  "link-2",
  "link",
  "linkedin",
  "list-checks",
  "list-end",
  "list-minus",
  "list-music",
  "list-ordered",
  "list-plus",
  "list-start",
  "list-video",
  "list-x",
  "list",
  "loader-2",
  "loader",
  "locate-fixed",
  "locate-off",
  "locate",
  "lock",
  "log-in",
  "log-out",
  "luggage",
  "magnet",
  "mail-check",
  "mail-minus",
  "mail-open",
  "mail-plus",
  "mail-question",
  "mail-search",
  "mail-warning",
  "mail-x",
  "mail",
  "mails",
  "map-pin-off",
  "map-pin",
  "map",
  "martini",
  "maximize-2",
  "maximize",
  "medal",
  "megaphone-off",
  "megaphone",
  "meh",
  "menu",
  "message-circle",
  "message-square",
  "mic-2",
  "mic-off",
  "mic",
  "microscope",
  "microwave",
  "milestone",
  "minimize-2",
  "minimize",
  "minus-circle",
  "minus-square",
  "minus",
  "monitor-off",
  "monitor-speaker",
  "monitor",
  "moon",
  "more-horizontal",
  "more-vertical",
  "mountain-snow",
  "mountain",
  "mouse-pointer-2",
  "mouse-pointer-click",
  "mouse-pointer",
  "mouse",
  "move-3d",
  "move-diagonal-2",
  "move-diagonal",
  "move-horizontal",
  "move-vertical",
  "move",
  "music-2",
  "music-3",
  "music-4",
  "music",
  "navigation-2-off",
  "navigation-2",
  "navigation-off",
  "navigation",
  "network",
  "newspaper",
  "octagon",
  "option",
  "outdent",
  "package-2",
  "package-check",
  "package-minus",
  "package-open",
  "package-plus",
  "package-search",
  "package-x",
  "package",
  "paint-bucket",
  "paintbrush-2",
  "paintbrush",
  "palette",
  "palmtree",
  "paperclip",
  "party-popper",
  "pause-circle",
  "pause-octagon",
  "pause",
  "pen-tool",
  "pencil",
  "percent",
  "person-standing",
  "phone-call",
  "phone-forwarded",
  "phone-incoming",
  "phone-missed",
  "phone-off",
  "phone-outgoing",
  "phone",
  "pie-chart",
  "piggy-bank",
  "pin-off",
  "pin",
  "pipette",
  "pizza",
  "plane",
  "play-circle",
  "play",
  "plug-2",
  "plug-zap",
  "plug",
  "plus-circle",
  "plus-square",
  "plus",
  "pocket",
  "podcast",
  "pointer",
  "pound-sterling",
  "power-off",
  "power",
  "printer",
  "puzzle",
  "qr-code",
  "quote",
  "radio-receiver",
  "radio",
  "rectangle-horizontal",
  "rectangle-vertical",
  "recycle",
  "redo-2",
  "redo",
  "refresh-ccw",
  "refresh-cw",
  "refrigerator",
  "regex",
  "repeat-1",
  "repeat",
  "reply-all",
  "reply",
  "rewind",
  "rocket",
  "rocking-chair",
  "rotate-3d",
  "rotate-ccw",
  "rotate-cw",
  "rss",
  "ruler",
  "russian-ruble",
  "sailboat",
  "save",
  "scale-3d",
  "scale",
  "scaling",
  "scan-face",
  "scan-line",
  "scan",
  "scissors",
  "screen-share-off",
  "screen-share",
  "scroll",
  "search",
  "send",
  "separator-horizontal",
  "separator-vertical",
  "server-cog",
  "server-crash",
  "server-off",
  "server",
  "settings-2",
  "settings",
  "share-2",
  "share",
  "sheet",
  "shield-alert",
  "shield-check",
  "shield-close",
  "shield-off",
  "shield",
  "shirt",
  "shopping-bag",
  "shopping-cart",
  "shovel",
  "shower-head",
  "shrink",
  "shrub",
  "shuffle",
  "sidebar-close",
  "sidebar-open",
  "sidebar",
  "sigma",
  "signal-high",
  "signal-low",
  "signal-medium",
  "signal-zero",
  "signal",
  "siren",
  "skip-back",
  "skip-forward",
  "skull",
  "slack",
  "slash",
  "slice",
  "sliders-horizontal",
  "sliders",
  "smartphone-charging",
  "smartphone",
  "smile-plus",
  "smile",
  "snowflake",
  "sofa",
  "sort-asc",
  "sort-desc",
  "speaker",
  "sprout",
  "square",
  "star-half",
  "star-off",
  "star",
  "stethoscope",
  "sticker",
  "sticky-note",
  "stop-circle",
  "stretch-horizontal",
  "stretch-vertical",
  "strikethrough",
  "subscript",
  "sun-dim",
  "sun-medium",
  "sun-moon",
  "sun-snow",
  "sun",
  "sunrise",
  "sunset",
  "superscript",
  "swiss-franc",
  "switch-camera",
  "sword",
  "swords",
  "syringe",
  "table-2",
  "table",
  "tablet",
  "tag",
  "tags",
  "target",
  "tent",
  "terminal-square",
  "terminal",
  "text-cursor-input",
  "text-cursor",
  "thermometer-snowflake",
  "thermometer-sun",
  "thermometer",
  "thumbs-down",
  "thumbs-up",
  "ticket",
  "timer-off",
  "timer-reset",
  "timer",
  "toggle-left",
  "toggle-right",
  "tornado",
  "toy-brick",
  "train",
  "trash-2",
  "trash",
  "tree-deciduous",
  "tree-pine",
  "trees",
  "trello",
  "trending-down",
  "trending-up",
  "triangle",
  "trophy",
  "truck",
  "tv-2",
  "tv",
  "twitch",
  "twitter",
  "type",
  "umbrella",
  "underline",
  "undo-2",
  "undo",
  "unlink-2",
  "unlink",
  "unlock",
  "upload-cloud",
  "upload",
  "usb",
  "user-check",
  "user-cog",
  "user-minus",
  "user-plus",
  "user-x",
  "user",
  "users",
  "utensils-crossed",
  "utensils",
  "venetian-mask",
  "verified",
  "vibrate-off",
  "vibrate",
  "video-off",
  "video",
  "view",
  "voicemail",
  "volume-1",
  "volume-2",
  "volume-x",
  "volume",
  "wallet",
  "wand-2",
  "wand",
  "watch",
  "waves",
  "webcam",
  "webhook",
  "wifi-off",
  "wifi",
  "wind",
  "wine",
  "wrap-text",
  "wrench",
  "x-circle",
  "x-octagon",
  "x-square",
  "x",
  "youtube",
  "zap-off",
  "zap",
  "zoom-in",
  "zoom-out"
];

// src/utils/htmlUtils.ts
var import_obsidian3 = require("obsidian");
function generateHotkeySuggestion(hotkeySuggestions, containerClass) {
  const hotkeySuggestionElement = createDiv(containerClass);
  hotkeySuggestions.forEach((hotkeySuggestion) => {
    const suggestionElement = hotkeySuggestionElement.createDiv("prompt-instruction");
    suggestionElement.createEl("span", { text: hotkeySuggestion.hotkey }).addClass("prompt-instruction-command");
    suggestionElement.createEl("span", { text: hotkeySuggestion.action });
  });
  return hotkeySuggestionElement;
}

// node_modules/lucide-svelte/dist/esm/defaultAttributes.js
var defaultAttributes = {
  xmlns: "http://www.w3.org/2000/svg",
  width: 24,
  height: 24,
  viewBox: "0 0 24 24",
  fill: "none",
  stroke: "currentColor",
  "stroke-width": 2,
  "stroke-linecap": "round",
  "stroke-linejoin": "round"
};
var defaultAttributes_default = defaultAttributes;

// node_modules/lucide-svelte/dist/esm/Icon.svelte
function create_fragment2(ctx) {
  var _a;
  let svg;
  let svg_class_value;
  let current;
  const default_slot_template = ctx[7].default;
  const default_slot = create_slot(default_slot_template, ctx, ctx[6], null);
  let svg_levels = [
    defaultAttributes_default,
    ctx[4],
    { width: ctx[2] },
    { height: ctx[2] },
    { stroke: ctx[1] },
    { "stroke-width": ctx[3] },
    {
      class: svg_class_value = `lucide-icon lucide lucide-${ctx[0]} ${(_a = ctx[5].class) != null ? _a : ""}`
    }
  ];
  let svg_data = {};
  for (let i = 0; i < svg_levels.length; i += 1) {
    svg_data = assign(svg_data, svg_levels[i]);
  }
  return {
    c() {
      svg = svg_element("svg");
      if (default_slot)
        default_slot.c();
      set_svg_attributes(svg, svg_data);
    },
    m(target, anchor) {
      insert(target, svg, anchor);
      if (default_slot) {
        default_slot.m(svg, null);
      }
      current = true;
    },
    p(ctx2, [dirty]) {
      var _a2;
      if (default_slot) {
        if (default_slot.p && (!current || dirty & 64)) {
          update_slot_base(default_slot, default_slot_template, ctx2, ctx2[6], !current ? get_all_dirty_from_scope(ctx2[6]) : get_slot_changes(default_slot_template, ctx2[6], dirty, null), null);
        }
      }
      set_svg_attributes(svg, svg_data = get_spread_update(svg_levels, [
        defaultAttributes_default,
        dirty & 16 && ctx2[4],
        (!current || dirty & 4) && { width: ctx2[2] },
        (!current || dirty & 4) && { height: ctx2[2] },
        (!current || dirty & 2) && { stroke: ctx2[1] },
        (!current || dirty & 8) && { "stroke-width": ctx2[3] },
        (!current || dirty & 33 && svg_class_value !== (svg_class_value = `lucide-icon lucide lucide-${ctx2[0]} ${(_a2 = ctx2[5].class) != null ? _a2 : ""}`)) && { class: svg_class_value }
      ]));
    },
    i(local) {
      if (current)
        return;
      transition_in(default_slot, local);
      current = true;
    },
    o(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d(detaching) {
      if (detaching)
        detach(svg);
      if (default_slot)
        default_slot.d(detaching);
    }
  };
}
function instance2($$self, $$props, $$invalidate) {
  const omit_props_names = ["name", "color", "size", "strokeWidth"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let { $$slots: slots = {}, $$scope } = $$props;
  let { name } = $$props;
  let { color = "currentColor" } = $$props;
  let { size = 24 } = $$props;
  let { strokeWidth = 2 } = $$props;
  $$self.$$set = ($$new_props) => {
    $$invalidate(5, $$props = assign(assign({}, $$props), exclude_internal_props($$new_props)));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("name" in $$new_props)
      $$invalidate(0, name = $$new_props.name);
    if ("color" in $$new_props)
      $$invalidate(1, color = $$new_props.color);
    if ("size" in $$new_props)
      $$invalidate(2, size = $$new_props.size);
    if ("strokeWidth" in $$new_props)
      $$invalidate(3, strokeWidth = $$new_props.strokeWidth);
    if ("$$scope" in $$new_props)
      $$invalidate(6, $$scope = $$new_props.$$scope);
  };
  $$props = exclude_internal_props($$props);
  return [name, color, size, strokeWidth, $$restProps, $$props, $$scope, slots];
}
var Icon = class extends SvelteComponent {
  constructor(options) {
    super();
    init(this, options, instance2, create_fragment2, safe_not_equal, {
      name: 0,
      color: 1,
      size: 2,
      strokeWidth: 3
    });
  }
};
var Icon_default = Icon;

// node_modules/lucide-svelte/dist/esm/icons/file-audio.svelte
function create_default_slot(ctx) {
  let path0;
  let t0;
  let polyline;
  let t1;
  let path1;
  let t2;
  let path2;
  let t3;
  let path3;
  let t4;
  let current;
  const default_slot_template = ctx[1].default;
  const default_slot = create_slot(default_slot_template, ctx, ctx[2], null);
  return {
    c() {
      path0 = svg_element("path");
      t0 = space();
      polyline = svg_element("polyline");
      t1 = space();
      path1 = svg_element("path");
      t2 = space();
      path2 = svg_element("path");
      t3 = space();
      path3 = svg_element("path");
      t4 = space();
      if (default_slot)
        default_slot.c();
      attr(path0, "d", "M17.5 22h.5c.5 0 1-.2 1.4-.6.4-.4.6-.9.6-1.4V7.5L14.5 2H6c-.5 0-1 .2-1.4.6C4.2 3 4 3.5 4 4v3");
      attr(polyline, "points", "14 2 14 8 20 8");
      attr(path1, "d", "M10 20v-1a2 2 0 1 1 4 0v1a2 2 0 1 1-4 0Z");
      attr(path2, "d", "M6 20v-1a2 2 0 1 0-4 0v1a2 2 0 1 0 4 0Z");
      attr(path3, "d", "M2 19v-3a6 6 0 0 1 12 0v3");
    },
    m(target, anchor) {
      insert(target, path0, anchor);
      insert(target, t0, anchor);
      insert(target, polyline, anchor);
      insert(target, t1, anchor);
      insert(target, path1, anchor);
      insert(target, t2, anchor);
      insert(target, path2, anchor);
      insert(target, t3, anchor);
      insert(target, path3, anchor);
      insert(target, t4, anchor);
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & 4)) {
          update_slot_base(default_slot, default_slot_template, ctx2, ctx2[2], !current ? get_all_dirty_from_scope(ctx2[2]) : get_slot_changes(default_slot_template, ctx2[2], dirty, null), null);
        }
      }
    },
    i(local) {
      if (current)
        return;
      transition_in(default_slot, local);
      current = true;
    },
    o(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d(detaching) {
      if (detaching)
        detach(path0);
      if (detaching)
        detach(t0);
      if (detaching)
        detach(polyline);
      if (detaching)
        detach(t1);
      if (detaching)
        detach(path1);
      if (detaching)
        detach(t2);
      if (detaching)
        detach(path2);
      if (detaching)
        detach(t3);
      if (detaching)
        detach(path3);
      if (detaching)
        detach(t4);
      if (default_slot)
        default_slot.d(detaching);
    }
  };
}
function create_fragment3(ctx) {
  let icon;
  let current;
  const icon_spread_levels = [{ name: "file-audio" }, ctx[0]];
  let icon_props = {
    $$slots: { default: [create_default_slot] },
    $$scope: { ctx }
  };
  for (let i = 0; i < icon_spread_levels.length; i += 1) {
    icon_props = assign(icon_props, icon_spread_levels[i]);
  }
  icon = new Icon_default({ props: icon_props });
  return {
    c() {
      create_component(icon.$$.fragment);
    },
    m(target, anchor) {
      mount_component(icon, target, anchor);
      current = true;
    },
    p(ctx2, [dirty]) {
      const icon_changes = dirty & 1 ? get_spread_update(icon_spread_levels, [icon_spread_levels[0], get_spread_object(ctx2[0])]) : {};
      if (dirty & 4) {
        icon_changes.$$scope = { dirty, ctx: ctx2 };
      }
      icon.$set(icon_changes);
    },
    i(local) {
      if (current)
        return;
      transition_in(icon.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(icon.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      destroy_component(icon, detaching);
    }
  };
}
function instance3($$self, $$props, $$invalidate) {
  let { $$slots: slots = {}, $$scope } = $$props;
  $$self.$$set = ($$new_props) => {
    $$invalidate(0, $$props = assign(assign({}, $$props), exclude_internal_props($$new_props)));
    if ("$$scope" in $$new_props)
      $$invalidate(2, $$scope = $$new_props.$$scope);
  };
  $$props = exclude_internal_props($$props);
  return [$$props, slots, $$scope];
}
var File_audio = class extends SvelteComponent {
  constructor(options) {
    super();
    init(this, options, instance3, create_fragment3, safe_not_equal, {});
  }
};
var file_audio_default = File_audio;

// node_modules/lucide-svelte/dist/esm/icons/file-image.svelte
function create_default_slot2(ctx) {
  let path0;
  let t0;
  let polyline;
  let t1;
  let circle;
  let t2;
  let path1;
  let t3;
  let current;
  const default_slot_template = ctx[1].default;
  const default_slot = create_slot(default_slot_template, ctx, ctx[2], null);
  return {
    c() {
      path0 = svg_element("path");
      t0 = space();
      polyline = svg_element("polyline");
      t1 = space();
      circle = svg_element("circle");
      t2 = space();
      path1 = svg_element("path");
      t3 = space();
      if (default_slot)
        default_slot.c();
      attr(path0, "d", "M14.5 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7.5L14.5 2z");
      attr(polyline, "points", "14 2 14 8 20 8");
      attr(circle, "cx", "10");
      attr(circle, "cy", "13");
      attr(circle, "r", "2");
      attr(path1, "d", "m20 17-1.09-1.09a2 2 0 0 0-2.82 0L10 22");
    },
    m(target, anchor) {
      insert(target, path0, anchor);
      insert(target, t0, anchor);
      insert(target, polyline, anchor);
      insert(target, t1, anchor);
      insert(target, circle, anchor);
      insert(target, t2, anchor);
      insert(target, path1, anchor);
      insert(target, t3, anchor);
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & 4)) {
          update_slot_base(default_slot, default_slot_template, ctx2, ctx2[2], !current ? get_all_dirty_from_scope(ctx2[2]) : get_slot_changes(default_slot_template, ctx2[2], dirty, null), null);
        }
      }
    },
    i(local) {
      if (current)
        return;
      transition_in(default_slot, local);
      current = true;
    },
    o(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d(detaching) {
      if (detaching)
        detach(path0);
      if (detaching)
        detach(t0);
      if (detaching)
        detach(polyline);
      if (detaching)
        detach(t1);
      if (detaching)
        detach(circle);
      if (detaching)
        detach(t2);
      if (detaching)
        detach(path1);
      if (detaching)
        detach(t3);
      if (default_slot)
        default_slot.d(detaching);
    }
  };
}
function create_fragment4(ctx) {
  let icon;
  let current;
  const icon_spread_levels = [{ name: "file-image" }, ctx[0]];
  let icon_props = {
    $$slots: { default: [create_default_slot2] },
    $$scope: { ctx }
  };
  for (let i = 0; i < icon_spread_levels.length; i += 1) {
    icon_props = assign(icon_props, icon_spread_levels[i]);
  }
  icon = new Icon_default({ props: icon_props });
  return {
    c() {
      create_component(icon.$$.fragment);
    },
    m(target, anchor) {
      mount_component(icon, target, anchor);
      current = true;
    },
    p(ctx2, [dirty]) {
      const icon_changes = dirty & 1 ? get_spread_update(icon_spread_levels, [icon_spread_levels[0], get_spread_object(ctx2[0])]) : {};
      if (dirty & 4) {
        icon_changes.$$scope = { dirty, ctx: ctx2 };
      }
      icon.$set(icon_changes);
    },
    i(local) {
      if (current)
        return;
      transition_in(icon.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(icon.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      destroy_component(icon, detaching);
    }
  };
}
function instance4($$self, $$props, $$invalidate) {
  let { $$slots: slots = {}, $$scope } = $$props;
  $$self.$$set = ($$new_props) => {
    $$invalidate(0, $$props = assign(assign({}, $$props), exclude_internal_props($$new_props)));
    if ("$$scope" in $$new_props)
      $$invalidate(2, $$scope = $$new_props.$$scope);
  };
  $$props = exclude_internal_props($$props);
  return [$$props, slots, $$scope];
}
var File_image = class extends SvelteComponent {
  constructor(options) {
    super();
    init(this, options, instance4, create_fragment4, safe_not_equal, {});
  }
};
var file_image_default = File_image;

// node_modules/lucide-svelte/dist/esm/icons/file-pie-chart.svelte
function create_default_slot3(ctx) {
  let path0;
  let t0;
  let polyline;
  let t1;
  let path1;
  let t2;
  let path2;
  let t3;
  let current;
  const default_slot_template = ctx[1].default;
  const default_slot = create_slot(default_slot_template, ctx, ctx[2], null);
  return {
    c() {
      path0 = svg_element("path");
      t0 = space();
      polyline = svg_element("polyline");
      t1 = space();
      path1 = svg_element("path");
      t2 = space();
      path2 = svg_element("path");
      t3 = space();
      if (default_slot)
        default_slot.c();
      attr(path0, "d", "M16 22h2a2 2 0 0 0 2-2V7.5L14.5 2H6a2 2 0 0 0-2 2v3");
      attr(polyline, "points", "14 2 14 8 20 8");
      attr(path1, "d", "M4.04 11.71a5.84 5.84 0 1 0 8.2 8.29");
      attr(path2, "d", "M13.83 16A5.83 5.83 0 0 0 8 10.17V16h5.83Z");
    },
    m(target, anchor) {
      insert(target, path0, anchor);
      insert(target, t0, anchor);
      insert(target, polyline, anchor);
      insert(target, t1, anchor);
      insert(target, path1, anchor);
      insert(target, t2, anchor);
      insert(target, path2, anchor);
      insert(target, t3, anchor);
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & 4)) {
          update_slot_base(default_slot, default_slot_template, ctx2, ctx2[2], !current ? get_all_dirty_from_scope(ctx2[2]) : get_slot_changes(default_slot_template, ctx2[2], dirty, null), null);
        }
      }
    },
    i(local) {
      if (current)
        return;
      transition_in(default_slot, local);
      current = true;
    },
    o(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d(detaching) {
      if (detaching)
        detach(path0);
      if (detaching)
        detach(t0);
      if (detaching)
        detach(polyline);
      if (detaching)
        detach(t1);
      if (detaching)
        detach(path1);
      if (detaching)
        detach(t2);
      if (detaching)
        detach(path2);
      if (detaching)
        detach(t3);
      if (default_slot)
        default_slot.d(detaching);
    }
  };
}
function create_fragment5(ctx) {
  let icon;
  let current;
  const icon_spread_levels = [{ name: "file-pie-chart" }, ctx[0]];
  let icon_props = {
    $$slots: { default: [create_default_slot3] },
    $$scope: { ctx }
  };
  for (let i = 0; i < icon_spread_levels.length; i += 1) {
    icon_props = assign(icon_props, icon_spread_levels[i]);
  }
  icon = new Icon_default({ props: icon_props });
  return {
    c() {
      create_component(icon.$$.fragment);
    },
    m(target, anchor) {
      mount_component(icon, target, anchor);
      current = true;
    },
    p(ctx2, [dirty]) {
      const icon_changes = dirty & 1 ? get_spread_update(icon_spread_levels, [icon_spread_levels[0], get_spread_object(ctx2[0])]) : {};
      if (dirty & 4) {
        icon_changes.$$scope = { dirty, ctx: ctx2 };
      }
      icon.$set(icon_changes);
    },
    i(local) {
      if (current)
        return;
      transition_in(icon.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(icon.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      destroy_component(icon, detaching);
    }
  };
}
function instance5($$self, $$props, $$invalidate) {
  let { $$slots: slots = {}, $$scope } = $$props;
  $$self.$$set = ($$new_props) => {
    $$invalidate(0, $$props = assign(assign({}, $$props), exclude_internal_props($$new_props)));
    if ("$$scope" in $$new_props)
      $$invalidate(2, $$scope = $$new_props.$$scope);
  };
  $$props = exclude_internal_props($$props);
  return [$$props, slots, $$scope];
}
var File_pie_chart = class extends SvelteComponent {
  constructor(options) {
    super();
    init(this, options, instance5, create_fragment5, safe_not_equal, {});
  }
};
var file_pie_chart_default = File_pie_chart;

// node_modules/lucide-svelte/dist/esm/icons/file-plus.svelte
function create_default_slot4(ctx) {
  let path;
  let t0;
  let polyline;
  let t1;
  let line0;
  let t2;
  let line1;
  let t3;
  let current;
  const default_slot_template = ctx[1].default;
  const default_slot = create_slot(default_slot_template, ctx, ctx[2], null);
  return {
    c() {
      path = svg_element("path");
      t0 = space();
      polyline = svg_element("polyline");
      t1 = space();
      line0 = svg_element("line");
      t2 = space();
      line1 = svg_element("line");
      t3 = space();
      if (default_slot)
        default_slot.c();
      attr(path, "d", "M14.5 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7.5L14.5 2z");
      attr(polyline, "points", "14 2 14 8 20 8");
      attr(line0, "x1", "12");
      attr(line0, "y1", "18");
      attr(line0, "x2", "12");
      attr(line0, "y2", "12");
      attr(line1, "x1", "9");
      attr(line1, "y1", "15");
      attr(line1, "x2", "15");
      attr(line1, "y2", "15");
    },
    m(target, anchor) {
      insert(target, path, anchor);
      insert(target, t0, anchor);
      insert(target, polyline, anchor);
      insert(target, t1, anchor);
      insert(target, line0, anchor);
      insert(target, t2, anchor);
      insert(target, line1, anchor);
      insert(target, t3, anchor);
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & 4)) {
          update_slot_base(default_slot, default_slot_template, ctx2, ctx2[2], !current ? get_all_dirty_from_scope(ctx2[2]) : get_slot_changes(default_slot_template, ctx2[2], dirty, null), null);
        }
      }
    },
    i(local) {
      if (current)
        return;
      transition_in(default_slot, local);
      current = true;
    },
    o(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d(detaching) {
      if (detaching)
        detach(path);
      if (detaching)
        detach(t0);
      if (detaching)
        detach(polyline);
      if (detaching)
        detach(t1);
      if (detaching)
        detach(line0);
      if (detaching)
        detach(t2);
      if (detaching)
        detach(line1);
      if (detaching)
        detach(t3);
      if (default_slot)
        default_slot.d(detaching);
    }
  };
}
function create_fragment6(ctx) {
  let icon;
  let current;
  const icon_spread_levels = [{ name: "file-plus" }, ctx[0]];
  let icon_props = {
    $$slots: { default: [create_default_slot4] },
    $$scope: { ctx }
  };
  for (let i = 0; i < icon_spread_levels.length; i += 1) {
    icon_props = assign(icon_props, icon_spread_levels[i]);
  }
  icon = new Icon_default({ props: icon_props });
  return {
    c() {
      create_component(icon.$$.fragment);
    },
    m(target, anchor) {
      mount_component(icon, target, anchor);
      current = true;
    },
    p(ctx2, [dirty]) {
      const icon_changes = dirty & 1 ? get_spread_update(icon_spread_levels, [icon_spread_levels[0], get_spread_object(ctx2[0])]) : {};
      if (dirty & 4) {
        icon_changes.$$scope = { dirty, ctx: ctx2 };
      }
      icon.$set(icon_changes);
    },
    i(local) {
      if (current)
        return;
      transition_in(icon.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(icon.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      destroy_component(icon, detaching);
    }
  };
}
function instance6($$self, $$props, $$invalidate) {
  let { $$slots: slots = {}, $$scope } = $$props;
  $$self.$$set = ($$new_props) => {
    $$invalidate(0, $$props = assign(assign({}, $$props), exclude_internal_props($$new_props)));
    if ("$$scope" in $$new_props)
      $$invalidate(2, $$scope = $$new_props.$$scope);
  };
  $$props = exclude_internal_props($$props);
  return [$$props, slots, $$scope];
}
var File_plus = class extends SvelteComponent {
  constructor(options) {
    super();
    init(this, options, instance6, create_fragment6, safe_not_equal, {});
  }
};
var file_plus_default = File_plus;

// node_modules/lucide-svelte/dist/esm/icons/file-question.svelte
function create_default_slot5(ctx) {
  let path0;
  let t0;
  let path1;
  let t1;
  let path2;
  let t2;
  let current;
  const default_slot_template = ctx[1].default;
  const default_slot = create_slot(default_slot_template, ctx, ctx[2], null);
  return {
    c() {
      path0 = svg_element("path");
      t0 = space();
      path1 = svg_element("path");
      t1 = space();
      path2 = svg_element("path");
      t2 = space();
      if (default_slot)
        default_slot.c();
      attr(path0, "d", "M14.5 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7.5L14.5 2z");
      attr(path1, "d", "M10 10.3c.2-.4.5-.8.9-1a2.1 2.1 0 0 1 2.6.4c.3.4.5.8.5 1.3 0 1.3-2 2-2 2");
      attr(path2, "d", "M12 17h.01");
    },
    m(target, anchor) {
      insert(target, path0, anchor);
      insert(target, t0, anchor);
      insert(target, path1, anchor);
      insert(target, t1, anchor);
      insert(target, path2, anchor);
      insert(target, t2, anchor);
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & 4)) {
          update_slot_base(default_slot, default_slot_template, ctx2, ctx2[2], !current ? get_all_dirty_from_scope(ctx2[2]) : get_slot_changes(default_slot_template, ctx2[2], dirty, null), null);
        }
      }
    },
    i(local) {
      if (current)
        return;
      transition_in(default_slot, local);
      current = true;
    },
    o(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d(detaching) {
      if (detaching)
        detach(path0);
      if (detaching)
        detach(t0);
      if (detaching)
        detach(path1);
      if (detaching)
        detach(t1);
      if (detaching)
        detach(path2);
      if (detaching)
        detach(t2);
      if (default_slot)
        default_slot.d(detaching);
    }
  };
}
function create_fragment7(ctx) {
  let icon;
  let current;
  const icon_spread_levels = [{ name: "file-question" }, ctx[0]];
  let icon_props = {
    $$slots: { default: [create_default_slot5] },
    $$scope: { ctx }
  };
  for (let i = 0; i < icon_spread_levels.length; i += 1) {
    icon_props = assign(icon_props, icon_spread_levels[i]);
  }
  icon = new Icon_default({ props: icon_props });
  return {
    c() {
      create_component(icon.$$.fragment);
    },
    m(target, anchor) {
      mount_component(icon, target, anchor);
      current = true;
    },
    p(ctx2, [dirty]) {
      const icon_changes = dirty & 1 ? get_spread_update(icon_spread_levels, [icon_spread_levels[0], get_spread_object(ctx2[0])]) : {};
      if (dirty & 4) {
        icon_changes.$$scope = { dirty, ctx: ctx2 };
      }
      icon.$set(icon_changes);
    },
    i(local) {
      if (current)
        return;
      transition_in(icon.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(icon.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      destroy_component(icon, detaching);
    }
  };
}
function instance7($$self, $$props, $$invalidate) {
  let { $$slots: slots = {}, $$scope } = $$props;
  $$self.$$set = ($$new_props) => {
    $$invalidate(0, $$props = assign(assign({}, $$props), exclude_internal_props($$new_props)));
    if ("$$scope" in $$new_props)
      $$invalidate(2, $$scope = $$new_props.$$scope);
  };
  $$props = exclude_internal_props($$props);
  return [$$props, slots, $$scope];
}
var File_question = class extends SvelteComponent {
  constructor(options) {
    super();
    init(this, options, instance7, create_fragment7, safe_not_equal, {});
  }
};
var file_question_default = File_question;

// node_modules/lucide-svelte/dist/esm/icons/file-text.svelte
function create_default_slot6(ctx) {
  let path;
  let t0;
  let polyline;
  let t1;
  let line0;
  let t2;
  let line1;
  let t3;
  let line2;
  let t4;
  let current;
  const default_slot_template = ctx[1].default;
  const default_slot = create_slot(default_slot_template, ctx, ctx[2], null);
  return {
    c() {
      path = svg_element("path");
      t0 = space();
      polyline = svg_element("polyline");
      t1 = space();
      line0 = svg_element("line");
      t2 = space();
      line1 = svg_element("line");
      t3 = space();
      line2 = svg_element("line");
      t4 = space();
      if (default_slot)
        default_slot.c();
      attr(path, "d", "M14.5 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7.5L14.5 2z");
      attr(polyline, "points", "14 2 14 8 20 8");
      attr(line0, "x1", "16");
      attr(line0, "y1", "13");
      attr(line0, "x2", "8");
      attr(line0, "y2", "13");
      attr(line1, "x1", "16");
      attr(line1, "y1", "17");
      attr(line1, "x2", "8");
      attr(line1, "y2", "17");
      attr(line2, "x1", "10");
      attr(line2, "y1", "9");
      attr(line2, "x2", "8");
      attr(line2, "y2", "9");
    },
    m(target, anchor) {
      insert(target, path, anchor);
      insert(target, t0, anchor);
      insert(target, polyline, anchor);
      insert(target, t1, anchor);
      insert(target, line0, anchor);
      insert(target, t2, anchor);
      insert(target, line1, anchor);
      insert(target, t3, anchor);
      insert(target, line2, anchor);
      insert(target, t4, anchor);
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & 4)) {
          update_slot_base(default_slot, default_slot_template, ctx2, ctx2[2], !current ? get_all_dirty_from_scope(ctx2[2]) : get_slot_changes(default_slot_template, ctx2[2], dirty, null), null);
        }
      }
    },
    i(local) {
      if (current)
        return;
      transition_in(default_slot, local);
      current = true;
    },
    o(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d(detaching) {
      if (detaching)
        detach(path);
      if (detaching)
        detach(t0);
      if (detaching)
        detach(polyline);
      if (detaching)
        detach(t1);
      if (detaching)
        detach(line0);
      if (detaching)
        detach(t2);
      if (detaching)
        detach(line1);
      if (detaching)
        detach(t3);
      if (detaching)
        detach(line2);
      if (detaching)
        detach(t4);
      if (default_slot)
        default_slot.d(detaching);
    }
  };
}
function create_fragment8(ctx) {
  let icon;
  let current;
  const icon_spread_levels = [{ name: "file-text" }, ctx[0]];
  let icon_props = {
    $$slots: { default: [create_default_slot6] },
    $$scope: { ctx }
  };
  for (let i = 0; i < icon_spread_levels.length; i += 1) {
    icon_props = assign(icon_props, icon_spread_levels[i]);
  }
  icon = new Icon_default({ props: icon_props });
  return {
    c() {
      create_component(icon.$$.fragment);
    },
    m(target, anchor) {
      mount_component(icon, target, anchor);
      current = true;
    },
    p(ctx2, [dirty]) {
      const icon_changes = dirty & 1 ? get_spread_update(icon_spread_levels, [icon_spread_levels[0], get_spread_object(ctx2[0])]) : {};
      if (dirty & 4) {
        icon_changes.$$scope = { dirty, ctx: ctx2 };
      }
      icon.$set(icon_changes);
    },
    i(local) {
      if (current)
        return;
      transition_in(icon.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(icon.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      destroy_component(icon, detaching);
    }
  };
}
function instance8($$self, $$props, $$invalidate) {
  let { $$slots: slots = {}, $$scope } = $$props;
  $$self.$$set = ($$new_props) => {
    $$invalidate(0, $$props = assign(assign({}, $$props), exclude_internal_props($$new_props)));
    if ("$$scope" in $$new_props)
      $$invalidate(2, $$scope = $$new_props.$$scope);
  };
  $$props = exclude_internal_props($$props);
  return [$$props, slots, $$scope];
}
var File_text = class extends SvelteComponent {
  constructor(options) {
    super();
    init(this, options, instance8, create_fragment8, safe_not_equal, {});
  }
};
var file_text_default = File_text;

// node_modules/lucide-svelte/dist/esm/icons/file-video.svelte
function create_default_slot7(ctx) {
  let path0;
  let t0;
  let polyline;
  let t1;
  let path1;
  let t2;
  let current;
  const default_slot_template = ctx[1].default;
  const default_slot = create_slot(default_slot_template, ctx, ctx[2], null);
  return {
    c() {
      path0 = svg_element("path");
      t0 = space();
      polyline = svg_element("polyline");
      t1 = space();
      path1 = svg_element("path");
      t2 = space();
      if (default_slot)
        default_slot.c();
      attr(path0, "d", "M14.5 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7.5L14.5 2z");
      attr(polyline, "points", "14 2 14 8 20 8");
      attr(path1, "d", "m10 11 5 3-5 3v-6Z");
    },
    m(target, anchor) {
      insert(target, path0, anchor);
      insert(target, t0, anchor);
      insert(target, polyline, anchor);
      insert(target, t1, anchor);
      insert(target, path1, anchor);
      insert(target, t2, anchor);
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & 4)) {
          update_slot_base(default_slot, default_slot_template, ctx2, ctx2[2], !current ? get_all_dirty_from_scope(ctx2[2]) : get_slot_changes(default_slot_template, ctx2[2], dirty, null), null);
        }
      }
    },
    i(local) {
      if (current)
        return;
      transition_in(default_slot, local);
      current = true;
    },
    o(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d(detaching) {
      if (detaching)
        detach(path0);
      if (detaching)
        detach(t0);
      if (detaching)
        detach(polyline);
      if (detaching)
        detach(t1);
      if (detaching)
        detach(path1);
      if (detaching)
        detach(t2);
      if (default_slot)
        default_slot.d(detaching);
    }
  };
}
function create_fragment9(ctx) {
  let icon;
  let current;
  const icon_spread_levels = [{ name: "file-video" }, ctx[0]];
  let icon_props = {
    $$slots: { default: [create_default_slot7] },
    $$scope: { ctx }
  };
  for (let i = 0; i < icon_spread_levels.length; i += 1) {
    icon_props = assign(icon_props, icon_spread_levels[i]);
  }
  icon = new Icon_default({ props: icon_props });
  return {
    c() {
      create_component(icon.$$.fragment);
    },
    m(target, anchor) {
      mount_component(icon, target, anchor);
      current = true;
    },
    p(ctx2, [dirty]) {
      const icon_changes = dirty & 1 ? get_spread_update(icon_spread_levels, [icon_spread_levels[0], get_spread_object(ctx2[0])]) : {};
      if (dirty & 4) {
        icon_changes.$$scope = { dirty, ctx: ctx2 };
      }
      icon.$set(icon_changes);
    },
    i(local) {
      if (current)
        return;
      transition_in(icon.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(icon.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      destroy_component(icon, detaching);
    }
  };
}
function instance9($$self, $$props, $$invalidate) {
  let { $$slots: slots = {}, $$scope } = $$props;
  $$self.$$set = ($$new_props) => {
    $$invalidate(0, $$props = assign(assign({}, $$props), exclude_internal_props($$new_props)));
    if ("$$scope" in $$new_props)
      $$invalidate(2, $$scope = $$new_props.$$scope);
  };
  $$props = exclude_internal_props($$props);
  return [$$props, slots, $$scope];
}
var File_video = class extends SvelteComponent {
  constructor(options) {
    super();
    init(this, options, instance9, create_fragment9, safe_not_equal, {});
  }
};
var file_video_default = File_video;

// node_modules/lucide-svelte/dist/esm/icons/file.svelte
function create_default_slot8(ctx) {
  let path;
  let t0;
  let polyline;
  let t1;
  let current;
  const default_slot_template = ctx[1].default;
  const default_slot = create_slot(default_slot_template, ctx, ctx[2], null);
  return {
    c() {
      path = svg_element("path");
      t0 = space();
      polyline = svg_element("polyline");
      t1 = space();
      if (default_slot)
        default_slot.c();
      attr(path, "d", "M14.5 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7.5L14.5 2z");
      attr(polyline, "points", "14 2 14 8 20 8");
    },
    m(target, anchor) {
      insert(target, path, anchor);
      insert(target, t0, anchor);
      insert(target, polyline, anchor);
      insert(target, t1, anchor);
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & 4)) {
          update_slot_base(default_slot, default_slot_template, ctx2, ctx2[2], !current ? get_all_dirty_from_scope(ctx2[2]) : get_slot_changes(default_slot_template, ctx2[2], dirty, null), null);
        }
      }
    },
    i(local) {
      if (current)
        return;
      transition_in(default_slot, local);
      current = true;
    },
    o(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d(detaching) {
      if (detaching)
        detach(path);
      if (detaching)
        detach(t0);
      if (detaching)
        detach(polyline);
      if (detaching)
        detach(t1);
      if (default_slot)
        default_slot.d(detaching);
    }
  };
}
function create_fragment10(ctx) {
  let icon;
  let current;
  const icon_spread_levels = [{ name: "file" }, ctx[0]];
  let icon_props = {
    $$slots: { default: [create_default_slot8] },
    $$scope: { ctx }
  };
  for (let i = 0; i < icon_spread_levels.length; i += 1) {
    icon_props = assign(icon_props, icon_spread_levels[i]);
  }
  icon = new Icon_default({ props: icon_props });
  return {
    c() {
      create_component(icon.$$.fragment);
    },
    m(target, anchor) {
      mount_component(icon, target, anchor);
      current = true;
    },
    p(ctx2, [dirty]) {
      const icon_changes = dirty & 1 ? get_spread_update(icon_spread_levels, [icon_spread_levels[0], get_spread_object(ctx2[0])]) : {};
      if (dirty & 4) {
        icon_changes.$$scope = { dirty, ctx: ctx2 };
      }
      icon.$set(icon_changes);
    },
    i(local) {
      if (current)
        return;
      transition_in(icon.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(icon.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      destroy_component(icon, detaching);
    }
  };
}
function instance10($$self, $$props, $$invalidate) {
  let { $$slots: slots = {}, $$scope } = $$props;
  $$self.$$set = ($$new_props) => {
    $$invalidate(0, $$props = assign(assign({}, $$props), exclude_internal_props($$new_props)));
    if ("$$scope" in $$new_props)
      $$invalidate(2, $$scope = $$new_props.$$scope);
  };
  $$props = exclude_internal_props($$props);
  return [$$props, slots, $$scope];
}
var File = class extends SvelteComponent {
  constructor(options) {
    super();
    init(this, options, instance10, create_fragment10, safe_not_equal, {});
  }
};
var file_default = File;

// node_modules/lucide-svelte/dist/esm/icons/folder-open.svelte
function create_default_slot9(ctx) {
  let path;
  let t;
  let current;
  const default_slot_template = ctx[1].default;
  const default_slot = create_slot(default_slot_template, ctx, ctx[2], null);
  return {
    c() {
      path = svg_element("path");
      t = space();
      if (default_slot)
        default_slot.c();
      attr(path, "d", "m6 14 1.45-2.9A2 2 0 0 1 9.24 10H20a2 2 0 0 1 1.94 2.5l-1.55 6a2 2 0 0 1-1.94 1.5H4a2 2 0 0 1-2-2V5c0-1.1.9-2 2-2h3.93a2 2 0 0 1 1.66.9l.82 1.2a2 2 0 0 0 1.66.9H18a2 2 0 0 1 2 2v2");
    },
    m(target, anchor) {
      insert(target, path, anchor);
      insert(target, t, anchor);
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & 4)) {
          update_slot_base(default_slot, default_slot_template, ctx2, ctx2[2], !current ? get_all_dirty_from_scope(ctx2[2]) : get_slot_changes(default_slot_template, ctx2[2], dirty, null), null);
        }
      }
    },
    i(local) {
      if (current)
        return;
      transition_in(default_slot, local);
      current = true;
    },
    o(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d(detaching) {
      if (detaching)
        detach(path);
      if (detaching)
        detach(t);
      if (default_slot)
        default_slot.d(detaching);
    }
  };
}
function create_fragment11(ctx) {
  let icon;
  let current;
  const icon_spread_levels = [{ name: "folder-open" }, ctx[0]];
  let icon_props = {
    $$slots: { default: [create_default_slot9] },
    $$scope: { ctx }
  };
  for (let i = 0; i < icon_spread_levels.length; i += 1) {
    icon_props = assign(icon_props, icon_spread_levels[i]);
  }
  icon = new Icon_default({ props: icon_props });
  return {
    c() {
      create_component(icon.$$.fragment);
    },
    m(target, anchor) {
      mount_component(icon, target, anchor);
      current = true;
    },
    p(ctx2, [dirty]) {
      const icon_changes = dirty & 1 ? get_spread_update(icon_spread_levels, [icon_spread_levels[0], get_spread_object(ctx2[0])]) : {};
      if (dirty & 4) {
        icon_changes.$$scope = { dirty, ctx: ctx2 };
      }
      icon.$set(icon_changes);
    },
    i(local) {
      if (current)
        return;
      transition_in(icon.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(icon.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      destroy_component(icon, detaching);
    }
  };
}
function instance11($$self, $$props, $$invalidate) {
  let { $$slots: slots = {}, $$scope } = $$props;
  $$self.$$set = ($$new_props) => {
    $$invalidate(0, $$props = assign(assign({}, $$props), exclude_internal_props($$new_props)));
    if ("$$scope" in $$new_props)
      $$invalidate(2, $$scope = $$new_props.$$scope);
  };
  $$props = exclude_internal_props($$props);
  return [$$props, slots, $$scope];
}
var Folder_open = class extends SvelteComponent {
  constructor(options) {
    super();
    init(this, options, instance11, create_fragment11, safe_not_equal, {});
  }
};
var folder_open_default = Folder_open;

// node_modules/lucide-svelte/dist/esm/icons/folder.svelte
function create_default_slot10(ctx) {
  let path;
  let t;
  let current;
  const default_slot_template = ctx[1].default;
  const default_slot = create_slot(default_slot_template, ctx, ctx[2], null);
  return {
    c() {
      path = svg_element("path");
      t = space();
      if (default_slot)
        default_slot.c();
      attr(path, "d", "M4 20h16a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.93a2 2 0 0 1-1.66-.9l-.82-1.2A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13c0 1.1.9 2 2 2Z");
    },
    m(target, anchor) {
      insert(target, path, anchor);
      insert(target, t, anchor);
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & 4)) {
          update_slot_base(default_slot, default_slot_template, ctx2, ctx2[2], !current ? get_all_dirty_from_scope(ctx2[2]) : get_slot_changes(default_slot_template, ctx2[2], dirty, null), null);
        }
      }
    },
    i(local) {
      if (current)
        return;
      transition_in(default_slot, local);
      current = true;
    },
    o(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d(detaching) {
      if (detaching)
        detach(path);
      if (detaching)
        detach(t);
      if (default_slot)
        default_slot.d(detaching);
    }
  };
}
function create_fragment12(ctx) {
  let icon;
  let current;
  const icon_spread_levels = [{ name: "folder" }, ctx[0]];
  let icon_props = {
    $$slots: { default: [create_default_slot10] },
    $$scope: { ctx }
  };
  for (let i = 0; i < icon_spread_levels.length; i += 1) {
    icon_props = assign(icon_props, icon_spread_levels[i]);
  }
  icon = new Icon_default({ props: icon_props });
  return {
    c() {
      create_component(icon.$$.fragment);
    },
    m(target, anchor) {
      mount_component(icon, target, anchor);
      current = true;
    },
    p(ctx2, [dirty]) {
      const icon_changes = dirty & 1 ? get_spread_update(icon_spread_levels, [icon_spread_levels[0], get_spread_object(ctx2[0])]) : {};
      if (dirty & 4) {
        icon_changes.$$scope = { dirty, ctx: ctx2 };
      }
      icon.$set(icon_changes);
    },
    i(local) {
      if (current)
        return;
      transition_in(icon.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(icon.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      destroy_component(icon, detaching);
    }
  };
}
function instance12($$self, $$props, $$invalidate) {
  let { $$slots: slots = {}, $$scope } = $$props;
  $$self.$$set = ($$new_props) => {
    $$invalidate(0, $$props = assign(assign({}, $$props), exclude_internal_props($$new_props)));
    if ("$$scope" in $$new_props)
      $$invalidate(2, $$scope = $$new_props.$$scope);
  };
  $$props = exclude_internal_props($$props);
  return [$$props, slots, $$scope];
}
var Folder = class extends SvelteComponent {
  constructor(options) {
    super();
    init(this, options, instance12, create_fragment12, safe_not_equal, {});
  }
};
var folder_default = Folder;

// node_modules/lucide-svelte/dist/esm/icons/forward.svelte
function create_default_slot11(ctx) {
  let polyline;
  let t0;
  let path;
  let t1;
  let current;
  const default_slot_template = ctx[1].default;
  const default_slot = create_slot(default_slot_template, ctx, ctx[2], null);
  return {
    c() {
      polyline = svg_element("polyline");
      t0 = space();
      path = svg_element("path");
      t1 = space();
      if (default_slot)
        default_slot.c();
      attr(polyline, "points", "15 17 20 12 15 7");
      attr(path, "d", "M4 18v-2a4 4 0 0 1 4-4h12");
    },
    m(target, anchor) {
      insert(target, polyline, anchor);
      insert(target, t0, anchor);
      insert(target, path, anchor);
      insert(target, t1, anchor);
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & 4)) {
          update_slot_base(default_slot, default_slot_template, ctx2, ctx2[2], !current ? get_all_dirty_from_scope(ctx2[2]) : get_slot_changes(default_slot_template, ctx2[2], dirty, null), null);
        }
      }
    },
    i(local) {
      if (current)
        return;
      transition_in(default_slot, local);
      current = true;
    },
    o(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d(detaching) {
      if (detaching)
        detach(polyline);
      if (detaching)
        detach(t0);
      if (detaching)
        detach(path);
      if (detaching)
        detach(t1);
      if (default_slot)
        default_slot.d(detaching);
    }
  };
}
function create_fragment13(ctx) {
  let icon;
  let current;
  const icon_spread_levels = [{ name: "forward" }, ctx[0]];
  let icon_props = {
    $$slots: { default: [create_default_slot11] },
    $$scope: { ctx }
  };
  for (let i = 0; i < icon_spread_levels.length; i += 1) {
    icon_props = assign(icon_props, icon_spread_levels[i]);
  }
  icon = new Icon_default({ props: icon_props });
  return {
    c() {
      create_component(icon.$$.fragment);
    },
    m(target, anchor) {
      mount_component(icon, target, anchor);
      current = true;
    },
    p(ctx2, [dirty]) {
      const icon_changes = dirty & 1 ? get_spread_update(icon_spread_levels, [icon_spread_levels[0], get_spread_object(ctx2[0])]) : {};
      if (dirty & 4) {
        icon_changes.$$scope = { dirty, ctx: ctx2 };
      }
      icon.$set(icon_changes);
    },
    i(local) {
      if (current)
        return;
      transition_in(icon.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(icon.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      destroy_component(icon, detaching);
    }
  };
}
function instance13($$self, $$props, $$invalidate) {
  let { $$slots: slots = {}, $$scope } = $$props;
  $$self.$$set = ($$new_props) => {
    $$invalidate(0, $$props = assign(assign({}, $$props), exclude_internal_props($$new_props)));
    if ("$$scope" in $$new_props)
      $$invalidate(2, $$scope = $$new_props.$$scope);
  };
  $$props = exclude_internal_props($$props);
  return [$$props, slots, $$scope];
}
var Forward = class extends SvelteComponent {
  constructor(options) {
    super();
    init(this, options, instance13, create_fragment13, safe_not_equal, {});
  }
};
var forward_default = Forward;

// node_modules/lucide-svelte/dist/esm/icons/more-horizontal.svelte
function create_default_slot12(ctx) {
  let circle0;
  let t0;
  let circle1;
  let t1;
  let circle2;
  let t2;
  let current;
  const default_slot_template = ctx[1].default;
  const default_slot = create_slot(default_slot_template, ctx, ctx[2], null);
  return {
    c() {
      circle0 = svg_element("circle");
      t0 = space();
      circle1 = svg_element("circle");
      t1 = space();
      circle2 = svg_element("circle");
      t2 = space();
      if (default_slot)
        default_slot.c();
      attr(circle0, "cx", "12");
      attr(circle0, "cy", "12");
      attr(circle0, "r", "1");
      attr(circle1, "cx", "19");
      attr(circle1, "cy", "12");
      attr(circle1, "r", "1");
      attr(circle2, "cx", "5");
      attr(circle2, "cy", "12");
      attr(circle2, "r", "1");
    },
    m(target, anchor) {
      insert(target, circle0, anchor);
      insert(target, t0, anchor);
      insert(target, circle1, anchor);
      insert(target, t1, anchor);
      insert(target, circle2, anchor);
      insert(target, t2, anchor);
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & 4)) {
          update_slot_base(default_slot, default_slot_template, ctx2, ctx2[2], !current ? get_all_dirty_from_scope(ctx2[2]) : get_slot_changes(default_slot_template, ctx2[2], dirty, null), null);
        }
      }
    },
    i(local) {
      if (current)
        return;
      transition_in(default_slot, local);
      current = true;
    },
    o(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d(detaching) {
      if (detaching)
        detach(circle0);
      if (detaching)
        detach(t0);
      if (detaching)
        detach(circle1);
      if (detaching)
        detach(t1);
      if (detaching)
        detach(circle2);
      if (detaching)
        detach(t2);
      if (default_slot)
        default_slot.d(detaching);
    }
  };
}
function create_fragment14(ctx) {
  let icon;
  let current;
  const icon_spread_levels = [{ name: "more-horizontal" }, ctx[0]];
  let icon_props = {
    $$slots: { default: [create_default_slot12] },
    $$scope: { ctx }
  };
  for (let i = 0; i < icon_spread_levels.length; i += 1) {
    icon_props = assign(icon_props, icon_spread_levels[i]);
  }
  icon = new Icon_default({ props: icon_props });
  return {
    c() {
      create_component(icon.$$.fragment);
    },
    m(target, anchor) {
      mount_component(icon, target, anchor);
      current = true;
    },
    p(ctx2, [dirty]) {
      const icon_changes = dirty & 1 ? get_spread_update(icon_spread_levels, [icon_spread_levels[0], get_spread_object(ctx2[0])]) : {};
      if (dirty & 4) {
        icon_changes.$$scope = { dirty, ctx: ctx2 };
      }
      icon.$set(icon_changes);
    },
    i(local) {
      if (current)
        return;
      transition_in(icon.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(icon.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      destroy_component(icon, detaching);
    }
  };
}
function instance14($$self, $$props, $$invalidate) {
  let { $$slots: slots = {}, $$scope } = $$props;
  $$self.$$set = ($$new_props) => {
    $$invalidate(0, $$props = assign(assign({}, $$props), exclude_internal_props($$new_props)));
    if ("$$scope" in $$new_props)
      $$invalidate(2, $$scope = $$new_props.$$scope);
  };
  $$props = exclude_internal_props($$props);
  return [$$props, slots, $$scope];
}
var More_horizontal = class extends SvelteComponent {
  constructor(options) {
    super();
    init(this, options, instance14, create_fragment14, safe_not_equal, {});
  }
};
var more_horizontal_default = More_horizontal;

// src/ui/svelteComponents/suggestion.svelte
var get_suggestion_aux_slot_changes = (dirty) => ({});
var get_suggestion_aux_slot_context = (ctx) => ({});
var get_suggestion_extra_content_slot_changes = (dirty) => ({});
var get_suggestion_extra_content_slot_context = (ctx) => ({});
var get_suggestion_title_slot_changes = (dirty) => ({});
var get_suggestion_title_slot_context = (ctx) => ({});
function create_fragment15(ctx) {
  let div3;
  let div1;
  let div0;
  let div0_class_value;
  let t0;
  let div1_class_value;
  let t1;
  let div2;
  let div2_class_value;
  let div3_class_value;
  let current;
  let mounted;
  let dispose;
  const suggestion_title_slot_template = ctx[9]["suggestion-title"];
  const suggestion_title_slot = create_slot(suggestion_title_slot_template, ctx, ctx[8], get_suggestion_title_slot_context);
  const suggestion_extra_content_slot_template = ctx[9]["suggestion-extra-content"];
  const suggestion_extra_content_slot = create_slot(suggestion_extra_content_slot_template, ctx, ctx[8], get_suggestion_extra_content_slot_context);
  const suggestion_aux_slot_template = ctx[9]["suggestion-aux"];
  const suggestion_aux_slot = create_slot(suggestion_aux_slot_template, ctx, ctx[8], get_suggestion_aux_slot_context);
  return {
    c() {
      var _a, _b, _c, _d;
      div3 = element("div");
      div1 = element("div");
      div0 = element("div");
      if (suggestion_title_slot)
        suggestion_title_slot.c();
      t0 = space();
      if (suggestion_extra_content_slot)
        suggestion_extra_content_slot.c();
      t1 = space();
      div2 = element("div");
      if (suggestion_aux_slot)
        suggestion_aux_slot.c();
      attr(div0, "class", div0_class_value = (_a = ctx[5]) != null ? _a : "suggestion-title");
      attr(div1, "class", div1_class_value = (_b = ctx[4]) != null ? _b : "suggestion-content");
      attr(div2, "class", div2_class_value = (_c = ctx[6]) != null ? _c : "suggestion-aux");
      attr(div3, "class", div3_class_value = (_d = ctx[3]) != null ? _d : "suggestion-item mod-complex");
      toggle_class(div3, "is-selected", ctx[2] === ctx[0]);
    },
    m(target, anchor) {
      insert(target, div3, anchor);
      append(div3, div1);
      append(div1, div0);
      if (suggestion_title_slot) {
        suggestion_title_slot.m(div0, null);
      }
      append(div1, t0);
      if (suggestion_extra_content_slot) {
        suggestion_extra_content_slot.m(div1, null);
      }
      append(div3, t1);
      append(div3, div2);
      if (suggestion_aux_slot) {
        suggestion_aux_slot.m(div2, null);
      }
      current = true;
      if (!mounted) {
        dispose = [
          listen(div3, "mousemove", ctx[10]),
          listen(div3, "click", ctx[11]),
          listen(div3, "auxclick", ctx[12])
        ];
        mounted = true;
      }
    },
    p(ctx2, [dirty]) {
      var _a, _b, _c, _d;
      if (suggestion_title_slot) {
        if (suggestion_title_slot.p && (!current || dirty & 256)) {
          update_slot_base(suggestion_title_slot, suggestion_title_slot_template, ctx2, ctx2[8], !current ? get_all_dirty_from_scope(ctx2[8]) : get_slot_changes(suggestion_title_slot_template, ctx2[8], dirty, get_suggestion_title_slot_changes), get_suggestion_title_slot_context);
        }
      }
      if (!current || dirty & 32 && div0_class_value !== (div0_class_value = (_a = ctx2[5]) != null ? _a : "suggestion-title")) {
        attr(div0, "class", div0_class_value);
      }
      if (suggestion_extra_content_slot) {
        if (suggestion_extra_content_slot.p && (!current || dirty & 256)) {
          update_slot_base(suggestion_extra_content_slot, suggestion_extra_content_slot_template, ctx2, ctx2[8], !current ? get_all_dirty_from_scope(ctx2[8]) : get_slot_changes(suggestion_extra_content_slot_template, ctx2[8], dirty, get_suggestion_extra_content_slot_changes), get_suggestion_extra_content_slot_context);
        }
      }
      if (!current || dirty & 16 && div1_class_value !== (div1_class_value = (_b = ctx2[4]) != null ? _b : "suggestion-content")) {
        attr(div1, "class", div1_class_value);
      }
      if (suggestion_aux_slot) {
        if (suggestion_aux_slot.p && (!current || dirty & 256)) {
          update_slot_base(suggestion_aux_slot, suggestion_aux_slot_template, ctx2, ctx2[8], !current ? get_all_dirty_from_scope(ctx2[8]) : get_slot_changes(suggestion_aux_slot_template, ctx2[8], dirty, get_suggestion_aux_slot_changes), get_suggestion_aux_slot_context);
        }
      }
      if (!current || dirty & 64 && div2_class_value !== (div2_class_value = (_c = ctx2[6]) != null ? _c : "suggestion-aux")) {
        attr(div2, "class", div2_class_value);
      }
      if (!current || dirty & 8 && div3_class_value !== (div3_class_value = (_d = ctx2[3]) != null ? _d : "suggestion-item mod-complex")) {
        attr(div3, "class", div3_class_value);
      }
      if (!current || dirty & 13) {
        toggle_class(div3, "is-selected", ctx2[2] === ctx2[0]);
      }
    },
    i(local) {
      if (current)
        return;
      transition_in(suggestion_title_slot, local);
      transition_in(suggestion_extra_content_slot, local);
      transition_in(suggestion_aux_slot, local);
      current = true;
    },
    o(local) {
      transition_out(suggestion_title_slot, local);
      transition_out(suggestion_extra_content_slot, local);
      transition_out(suggestion_aux_slot, local);
      current = false;
    },
    d(detaching) {
      if (detaching)
        detach(div3);
      if (suggestion_title_slot)
        suggestion_title_slot.d(detaching);
      if (suggestion_extra_content_slot)
        suggestion_extra_content_slot.d(detaching);
      if (suggestion_aux_slot)
        suggestion_aux_slot.d(detaching);
      mounted = false;
      run_all(dispose);
    }
  };
}
function instance15($$self, $$props, $$invalidate) {
  let { $$slots: slots = {}, $$scope } = $$props;
  let { index } = $$props;
  let { textInputSuggester } = $$props;
  let { selectedItemIndex } = $$props;
  let suggester = textInputSuggester.getSuggester();
  let { suggestionItemClass = void 0 } = $$props;
  let { suggestionContentClass = void 0 } = $$props;
  let { suggestionTitleClass = void 0 } = $$props;
  let { suggestionAuxClass = void 0 } = $$props;
  const mousemove_handler = () => suggester.setSelectedItemIndex(index);
  const click_handler = () => textInputSuggester.useSelectedItem(suggester.getSelectedItem());
  const auxclick_handler = (e) => {
    if (e.button === 1) {
      textInputSuggester.useSelectedItem(suggester.getSelectedItem(), true);
    }
  };
  $$self.$$set = ($$props2) => {
    if ("index" in $$props2)
      $$invalidate(0, index = $$props2.index);
    if ("textInputSuggester" in $$props2)
      $$invalidate(1, textInputSuggester = $$props2.textInputSuggester);
    if ("selectedItemIndex" in $$props2)
      $$invalidate(2, selectedItemIndex = $$props2.selectedItemIndex);
    if ("suggestionItemClass" in $$props2)
      $$invalidate(3, suggestionItemClass = $$props2.suggestionItemClass);
    if ("suggestionContentClass" in $$props2)
      $$invalidate(4, suggestionContentClass = $$props2.suggestionContentClass);
    if ("suggestionTitleClass" in $$props2)
      $$invalidate(5, suggestionTitleClass = $$props2.suggestionTitleClass);
    if ("suggestionAuxClass" in $$props2)
      $$invalidate(6, suggestionAuxClass = $$props2.suggestionAuxClass);
    if ("$$scope" in $$props2)
      $$invalidate(8, $$scope = $$props2.$$scope);
  };
  return [
    index,
    textInputSuggester,
    selectedItemIndex,
    suggestionItemClass,
    suggestionContentClass,
    suggestionTitleClass,
    suggestionAuxClass,
    suggester,
    $$scope,
    slots,
    mousemove_handler,
    click_handler,
    auxclick_handler
  ];
}
var Suggestion = class extends SvelteComponent {
  constructor(options) {
    super();
    init(this, options, instance15, create_fragment15, safe_not_equal, {
      index: 0,
      textInputSuggester: 1,
      selectedItemIndex: 2,
      suggestionItemClass: 3,
      suggestionContentClass: 4,
      suggestionTitleClass: 5,
      suggestionAuxClass: 6
    });
  }
};
var suggestion_default = Suggestion;

// src/ui/svelteComponents/homeTabFileSuggestion.svelte
function create_if_block_5(ctx) {
  let div;
  return {
    c() {
      div = element("div");
      div.textContent = `${ctx[5].extension}`;
      attr(div, "class", "nav-file-tag home-tab-suggestion-file-tag");
    },
    m(target, anchor) {
      insert(target, div, anchor);
    },
    p: noop,
    d(detaching) {
      if (detaching)
        detach(div);
    }
  };
}
function create_suggestion_title_slot(ctx) {
  let span;
  let t0;
  let t1;
  let if_block_anchor;
  let if_block = ctx[5].fileType != "markdown" && create_if_block_5(ctx);
  return {
    c() {
      span = element("span");
      t0 = text(ctx[3]);
      t1 = space();
      if (if_block)
        if_block.c();
      if_block_anchor = empty();
    },
    m(target, anchor) {
      insert(target, span, anchor);
      append(span, t0);
      insert(target, t1, anchor);
      if (if_block)
        if_block.m(target, anchor);
      insert(target, if_block_anchor, anchor);
    },
    p(ctx2, dirty) {
      if (dirty & 8)
        set_data(t0, ctx2[3]);
      if (ctx2[5].fileType != "markdown")
        if_block.p(ctx2, dirty);
    },
    d(detaching) {
      if (detaching)
        detach(span);
      if (detaching)
        detach(t1);
      if (if_block)
        if_block.d(detaching);
      if (detaching)
        detach(if_block_anchor);
    }
  };
}
function create_if_block_3(ctx) {
  var _a;
  let show_if = ctx[5].aliases && ((_a = ctx[5].aliases) == null ? void 0 : _a.includes(ctx[3]));
  let if_block_anchor;
  let current;
  let if_block = show_if && create_if_block_4(ctx);
  return {
    c() {
      if (if_block)
        if_block.c();
      if_block_anchor = empty();
    },
    m(target, anchor) {
      if (if_block)
        if_block.m(target, anchor);
      insert(target, if_block_anchor, anchor);
      current = true;
    },
    p(ctx2, dirty) {
      var _a2;
      if (dirty & 8)
        show_if = ctx2[5].aliases && ((_a2 = ctx2[5].aliases) == null ? void 0 : _a2.includes(ctx2[3]));
      if (show_if) {
        if (if_block) {
          if_block.p(ctx2, dirty);
          if (dirty & 8) {
            transition_in(if_block, 1);
          }
        } else {
          if_block = create_if_block_4(ctx2);
          if_block.c();
          transition_in(if_block, 1);
          if_block.m(if_block_anchor.parentNode, if_block_anchor);
        }
      } else if (if_block) {
        group_outros();
        transition_out(if_block, 1, 1, () => {
          if_block = null;
        });
        check_outros();
      }
    },
    i(local) {
      if (current)
        return;
      transition_in(if_block);
      current = true;
    },
    o(local) {
      transition_out(if_block);
      current = false;
    },
    d(detaching) {
      if (if_block)
        if_block.d(detaching);
      if (detaching)
        detach(if_block_anchor);
    }
  };
}
function create_if_block_4(ctx) {
  let div;
  let forward;
  let t0;
  let span;
  let current;
  forward = new forward_default({
    props: { size: 15, "aria-label": "Alias of" }
  });
  return {
    c() {
      div = element("div");
      create_component(forward.$$.fragment);
      t0 = space();
      span = element("span");
      span.textContent = `${ctx[5].basename}`;
      attr(div, "class", "home-tab-suggestion-description");
    },
    m(target, anchor) {
      insert(target, div, anchor);
      mount_component(forward, div, null);
      append(div, t0);
      append(div, span);
      current = true;
    },
    p: noop,
    i(local) {
      if (current)
        return;
      transition_in(forward.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(forward.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      if (detaching)
        detach(div);
      destroy_component(forward);
    }
  };
}
function create_suggestion_extra_content_slot(ctx) {
  let if_block_anchor;
  let current;
  let if_block = ctx[5].isCreated && create_if_block_3(ctx);
  return {
    c() {
      if (if_block)
        if_block.c();
      if_block_anchor = empty();
    },
    m(target, anchor) {
      if (if_block)
        if_block.m(target, anchor);
      insert(target, if_block_anchor, anchor);
      current = true;
    },
    p(ctx2, dirty) {
      if (ctx2[5].isCreated)
        if_block.p(ctx2, dirty);
    },
    i(local) {
      if (current)
        return;
      transition_in(if_block);
      current = true;
    },
    o(local) {
      transition_out(if_block);
      current = false;
    },
    d(detaching) {
      if (if_block)
        if_block.d(detaching);
      if (detaching)
        detach(if_block_anchor);
    }
  };
}
function create_if_block_12(ctx) {
  let div;
  let current_block_type_index;
  let if_block;
  let current;
  const if_block_creators = [create_if_block_2, create_else_block];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (ctx2[5].isUnresolved)
      return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  return {
    c() {
      div = element("div");
      if_block.c();
      attr(div, "class", "home-tab-suggestion-tip");
    },
    m(target, anchor) {
      insert(target, div, anchor);
      if_blocks[current_block_type_index].m(div, null);
      current = true;
    },
    p: noop,
    i(local) {
      if (current)
        return;
      transition_in(if_block);
      current = true;
    },
    o(local) {
      transition_out(if_block);
      current = false;
    },
    d(detaching) {
      if (detaching)
        detach(div);
      if_blocks[current_block_type_index].d();
    }
  };
}
function create_else_block(ctx) {
  let filequestion;
  let t0;
  let div;
  let current;
  filequestion = new file_question_default({
    props: {
      size: 15,
      "aria-label": "Non exists yet, select to create"
    }
  });
  return {
    c() {
      create_component(filequestion.$$.fragment);
      t0 = space();
      div = element("div");
      div.innerHTML = `<span>Enter to create</span>`;
      attr(div, "class", "suggestion-hotkey");
    },
    m(target, anchor) {
      mount_component(filequestion, target, anchor);
      insert(target, t0, anchor);
      insert(target, div, anchor);
      current = true;
    },
    i(local) {
      if (current)
        return;
      transition_in(filequestion.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(filequestion.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      destroy_component(filequestion, detaching);
      if (detaching)
        detach(t0);
      if (detaching)
        detach(div);
    }
  };
}
function create_if_block_2(ctx) {
  let fileplus;
  let current;
  fileplus = new file_plus_default({
    props: {
      size: 15,
      "aria-label": "Not created yet, select to create"
    }
  });
  return {
    c() {
      create_component(fileplus.$$.fragment);
    },
    m(target, anchor) {
      mount_component(fileplus, target, anchor);
      current = true;
    },
    i(local) {
      if (current)
        return;
      transition_in(fileplus.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(fileplus.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      destroy_component(fileplus, detaching);
    }
  };
}
function create_if_block2(ctx) {
  let div;
  let folder;
  let t0;
  let span;
  let t1;
  let current;
  folder = new folder_default({ props: { size: 15 } });
  return {
    c() {
      div = element("div");
      create_component(folder.$$.fragment);
      t0 = space();
      span = element("span");
      t1 = text(ctx[4]);
      attr(span, "class", "home-tab-file-path");
      attr(div, "class", "home-tab-suggestion-filepath");
      attr(div, "aria-label", "File path");
    },
    m(target, anchor) {
      insert(target, div, anchor);
      mount_component(folder, div, null);
      append(div, t0);
      append(div, span);
      append(span, t1);
      current = true;
    },
    p(ctx2, dirty) {
      if (!current || dirty & 16)
        set_data(t1, ctx2[4]);
    },
    i(local) {
      if (current)
        return;
      transition_in(folder.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(folder.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      if (detaching)
        detach(div);
      destroy_component(folder);
    }
  };
}
function create_suggestion_aux_slot(ctx) {
  let t;
  let if_block1_anchor;
  let current;
  let if_block0 = !ctx[5].isCreated && create_if_block_12(ctx);
  let if_block1 = (ctx[5].isCreated || ctx[5].isUnresolved) && ctx[4] && create_if_block2(ctx);
  return {
    c() {
      if (if_block0)
        if_block0.c();
      t = space();
      if (if_block1)
        if_block1.c();
      if_block1_anchor = empty();
    },
    m(target, anchor) {
      if (if_block0)
        if_block0.m(target, anchor);
      insert(target, t, anchor);
      if (if_block1)
        if_block1.m(target, anchor);
      insert(target, if_block1_anchor, anchor);
      current = true;
    },
    p(ctx2, dirty) {
      if (!ctx2[5].isCreated)
        if_block0.p(ctx2, dirty);
      if ((ctx2[5].isCreated || ctx2[5].isUnresolved) && ctx2[4]) {
        if (if_block1) {
          if_block1.p(ctx2, dirty);
          if (dirty & 16) {
            transition_in(if_block1, 1);
          }
        } else {
          if_block1 = create_if_block2(ctx2);
          if_block1.c();
          transition_in(if_block1, 1);
          if_block1.m(if_block1_anchor.parentNode, if_block1_anchor);
        }
      } else if (if_block1) {
        group_outros();
        transition_out(if_block1, 1, 1, () => {
          if_block1 = null;
        });
        check_outros();
      }
    },
    i(local) {
      if (current)
        return;
      transition_in(if_block0);
      transition_in(if_block1);
      current = true;
    },
    o(local) {
      transition_out(if_block0);
      transition_out(if_block1);
      current = false;
    },
    d(detaching) {
      if (if_block0)
        if_block0.d(detaching);
      if (detaching)
        detach(t);
      if (if_block1)
        if_block1.d(detaching);
      if (detaching)
        detach(if_block1_anchor);
    }
  };
}
function create_fragment16(ctx) {
  let suggestion_1;
  let current;
  suggestion_1 = new suggestion_default({
    props: {
      index: ctx[0],
      textInputSuggester: ctx[1],
      selectedItemIndex: ctx[2],
      suggestionTitleClass: `suggestion-title home-tab-suggestion-title ${ctx[5].isUnresolved ? "is-unresolved" : ""}`,
      $$slots: {
        "suggestion-aux": [create_suggestion_aux_slot],
        "suggestion-extra-content": [create_suggestion_extra_content_slot],
        "suggestion-title": [create_suggestion_title_slot]
      },
      $$scope: { ctx }
    }
  });
  return {
    c() {
      create_component(suggestion_1.$$.fragment);
    },
    m(target, anchor) {
      mount_component(suggestion_1, target, anchor);
      current = true;
    },
    p(ctx2, [dirty]) {
      const suggestion_1_changes = {};
      if (dirty & 1)
        suggestion_1_changes.index = ctx2[0];
      if (dirty & 2)
        suggestion_1_changes.textInputSuggester = ctx2[1];
      if (dirty & 4)
        suggestion_1_changes.selectedItemIndex = ctx2[2];
      if (dirty & 152) {
        suggestion_1_changes.$$scope = { dirty, ctx: ctx2 };
      }
      suggestion_1.$set(suggestion_1_changes);
    },
    i(local) {
      if (current)
        return;
      transition_in(suggestion_1.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(suggestion_1.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      destroy_component(suggestion_1, detaching);
    }
  };
}
function instance16($$self, $$props, $$invalidate) {
  let { index } = $$props;
  let { textInputSuggester } = $$props;
  let { selectedItemIndex } = $$props;
  let { suggestion } = $$props;
  let { nameToDisplay } = $$props;
  let { filePath = void 0 } = $$props;
  let suggestionItem = suggestion.item;
  $$self.$$set = ($$props2) => {
    if ("index" in $$props2)
      $$invalidate(0, index = $$props2.index);
    if ("textInputSuggester" in $$props2)
      $$invalidate(1, textInputSuggester = $$props2.textInputSuggester);
    if ("selectedItemIndex" in $$props2)
      $$invalidate(2, selectedItemIndex = $$props2.selectedItemIndex);
    if ("suggestion" in $$props2)
      $$invalidate(6, suggestion = $$props2.suggestion);
    if ("nameToDisplay" in $$props2)
      $$invalidate(3, nameToDisplay = $$props2.nameToDisplay);
    if ("filePath" in $$props2)
      $$invalidate(4, filePath = $$props2.filePath);
  };
  return [
    index,
    textInputSuggester,
    selectedItemIndex,
    nameToDisplay,
    filePath,
    suggestionItem,
    suggestion
  ];
}
var HomeTabFileSuggestion = class extends SvelteComponent {
  constructor(options) {
    super();
    init(this, options, instance16, create_fragment16, safe_not_equal, {
      index: 0,
      textInputSuggester: 1,
      selectedItemIndex: 2,
      suggestion: 6,
      nameToDisplay: 3,
      filePath: 4
    });
  }
};
var homeTabFileSuggestion_default = HomeTabFileSuggestion;

// src/suggester/homeTabSuggester.ts
var HomeTabFileSuggester = class extends TextInputSuggester {
  constructor(app2, plugin, view, searchBar) {
    super(app2, get_store_value(searchBar.searchBarEl), get_store_value(searchBar.suggestionContainerEl), {
      containerClass: `home-tab-suggestion-container ${import_obsidian4.Platform.isPhone ? "is-phone" : ""}`,
      additionalClasses: `${plugin.settings.selectionHighlight === "accentColor" ? "use-accent-color" : ""}`,
      additionalModalInfo: plugin.settings.showShortcuts ? generateHotkeySuggestion([
        { hotkey: "\u2191\u2193", action: "to navigate" },
        { hotkey: "\u21B5", action: "to open" },
        { hotkey: "shift \u21B5", action: "to create" },
        { hotkey: "ctrl \u21B5", action: "to open in new tab" },
        { hotkey: "esc", action: "to dismiss" }
      ], "home-tab-hotkey-suggestions") : void 0
    }, plugin.settings.searchDelay);
    this.plugin = plugin;
    this.view = view;
    this.searchBar = searchBar;
    this.app.metadataCache.onCleanCache(() => {
      this.plugin.settings.markdownOnly ? this.files = this.filterSearchFileArray("markdown", getSearchFiles(this.plugin.settings.unresolvedLinks)) : this.files = getSearchFiles(this.plugin.settings.unresolvedLinks);
      this.fuzzySearch = new FileFuzzySearch(this.files, { ...DEFAULT_FUSE_OPTIONS, ignoreLocation: true, fieldNormWeight: 1.65, keys: [{ name: "basename", weight: 1.5 }, { name: "aliases", weight: 0.1 }] });
    });
    this.scope.register(["Mod"], "Enter", (e) => {
      e.preventDefault();
      this.useSelectedItem(this.suggester.getSelectedItem(), true);
    });
    this.scope.register(["Shift"], "Enter", async (e) => {
      e.preventDefault();
      await this.handleFileCreation();
    });
    this.scope.register(["Shift", "Mod"], "Enter", async (e) => {
      e.preventDefault();
      await this.handleFileCreation(void 0, true);
    });
    this.view.registerEvent(this.app.vault.on("create", (file) => {
      if (file instanceof import_obsidian4.TFile) {
        this.updateSearchfilesList(file);
      }
    }));
    this.view.registerEvent(this.app.vault.on("delete", (file) => {
      if (file instanceof import_obsidian4.TFile) {
        this.updateSearchfilesList(file);
      }
    }));
    this.view.registerEvent(this.app.vault.on("rename", (file, oldPath) => {
      if (file instanceof import_obsidian4.TFile) {
        this.updateSearchfilesList(file, oldPath);
      }
    }));
    this.view.registerEvent(this.app.metadataCache.on("resolved", () => this.updateUnresolvedFiles()));
  }
  updateSearchBarContainerElState(isActive) {
    var _a;
    (_a = this.inputEl.parentElement) == null ? void 0 : _a.toggleClass("is-active", isActive);
  }
  onOpen() {
    this.updateSearchBarContainerElState(this.suggester.getSuggestions().length > 0 ? true : false);
  }
  onClose() {
    this.updateSearchBarContainerElState(false);
  }
  filterSearchFileArray(filterKey, fileArray) {
    const arrayToFilter = fileArray;
    return arrayToFilter.filter((file) => isValidExtension(filterKey) ? file.extension === filterKey : file.fileType === filterKey);
  }
  updateUnresolvedFiles() {
    const unresolvedFiles = getUnresolvedMarkdownFiles();
    let newFiles = false;
    if (this.files) {
      unresolvedFiles.forEach((unresolvedFile) => {
        if (!this.files.includes(unresolvedFile)) {
          this.files.push(unresolvedFile);
          newFiles = true;
        }
      });
      if (newFiles)
        this.fuzzySearch.updateSearchArray(this.files);
    }
  }
  updateSearchfilesList(file, oldPath) {
    this.app.metadataCache.onCleanCache(() => {
      if (oldPath) {
        this.files.splice(this.files.findIndex((f) => f.path === oldPath), 1);
        this.files.push(generateSearchFile(file));
      }
      if (file.deleted) {
        this.files.splice(this.files.findIndex((f) => f.path === file.path), 1);
      } else {
        const fileIndex = this.files.findIndex((f) => f.path === file.path);
        if (fileIndex === -1) {
          this.files.push(generateSearchFile(file));
        } else if (this.files[fileIndex].isUnresolved) {
          this.files[fileIndex] = generateSearchFile(file);
        }
      }
      this.fuzzySearch.updateSearchArray(this.files);
    });
  }
  onNoSuggestion() {
    if (!this.activeFilter || this.activeFilter === "markdown" || this.activeFilter === "md") {
      const input = this.inputEl.value;
      if (!!input) {
        this.suggester.setSuggestions([{
          item: {
            name: `${input}.md`,
            path: `${input}.md`,
            basename: input,
            isCreated: false,
            fileType: "markdown",
            extension: "md"
          },
          refIndex: 0,
          score: 0
        }]);
        this.open();
      } else {
        this.close();
      }
    } else {
      this.close();
    }
  }
  getSuggestions(input) {
    return this.fuzzySearch.rawSearch(input, this.plugin.settings.maxResults);
  }
  useSelectedItem(selectedItem, newTab) {
    if (selectedItem.item.isCreated && selectedItem.item.file) {
      this.openFile(selectedItem.item.file, newTab);
    } else {
      this.handleFileCreation(selectedItem.item, newTab);
    }
  }
  getDisplayElementProps(suggestion) {
    const nameToDisplay = this.fuzzySearch.getBestMatch(suggestion, this.inputEl.value);
    let filePath = void 0;
    if (this.plugin.settings.showPath) {
      filePath = suggestion.item.file ? suggestion.item.file.parent.name : getParentFolderFromPath(suggestion.item.path);
    }
    return {
      nameToDisplay,
      filePath
    };
  }
  getDisplayElementComponentType() {
    return homeTabFileSuggestion_default;
  }
  async handleFileCreation(selectedFile, newTab) {
    var _a;
    let newFile;
    if (selectedFile == null ? void 0 : selectedFile.isUnresolved) {
      const folderPath = selectedFile.path.replace(selectedFile.name, "");
      if (!await this.app.vault.adapter.exists(folderPath)) {
        await this.app.vault.createFolder(folderPath);
      }
      newFile = await this.app.vault.create(selectedFile.path, "");
    } else {
      const input = this.inputEl.value;
      const files = this.files.filter((file) => file.fileType === "markdown");
      if (files.map((file) => file.basename).includes(input)) {
        const fileToOpen = (_a = files.find((f) => f.basename === input)) == null ? void 0 : _a.file;
        if (fileToOpen) {
          return this.openFile(fileToOpen, newTab);
        }
      }
      newFile = await this.app.vault.create((0, import_obsidian4.normalizePath)(`${this.app.fileManager.getNewFileParent("").path}/${input}.md`), "");
    }
    this.openFile(newFile, newTab);
  }
  openFile(file, newTab) {
    if (newTab) {
      this.app.workspace.createLeafInTabGroup().openFile(file);
    } else {
      this.view.leaf.openFile(file);
    }
  }
  setFileFilter(filterKey) {
    this.activeFilter = filterKey;
    this.app.metadataCache.onCleanCache(() => {
      this.fuzzySearch.updateSearchArray(this.filterSearchFileArray(filterKey, this.plugin.settings.markdownOnly ? getSearchFiles(this.plugin.settings.unresolvedLinks) : this.files));
    });
    this.suggester.setSuggestions([]);
    this.close();
  }
};

// src/suggester/omnisearchSuggester.ts
var import_obsidian5 = require("obsidian");

// src/ui/svelteComponents/omnisearchSuggestion.svelte
function create_if_block_13(ctx) {
  let span;
  let t_value = `${ctx[3].matches.length} match${ctx[3].matches.length > 1 ? "es" : ""}`;
  let t;
  return {
    c() {
      span = element("span");
      t = text(t_value);
      attr(span, "class", "omnisearch-result__counter");
    },
    m(target, anchor) {
      insert(target, span, anchor);
      append(span, t);
    },
    p(ctx2, dirty) {
      if (dirty & 8 && t_value !== (t_value = `${ctx2[3].matches.length} match${ctx2[3].matches.length > 1 ? "es" : ""}`))
        set_data(t, t_value);
    },
    d(detaching) {
      if (detaching)
        detach(span);
    }
  };
}
function create_suggestion_title_slot2(ctx) {
  let span3;
  let span0;
  let file;
  let t0;
  let span1;
  let t1;
  let span2;
  let t3;
  let current;
  file = new file_default({ props: { size: 15 } });
  let if_block = ctx[3].matches.length > 0 && create_if_block_13(ctx);
  return {
    c() {
      span3 = element("span");
      span0 = element("span");
      create_component(file.$$.fragment);
      t0 = space();
      span1 = element("span");
      t1 = space();
      span2 = element("span");
      span2.textContent = `${`.${ctx[6]}`}`;
      t3 = space();
      if (if_block)
        if_block.c();
      attr(span2, "class", "omnisearch-result__extension");
      attr(span3, "class", "omnisearch-result__title");
    },
    m(target, anchor) {
      insert(target, span3, anchor);
      append(span3, span0);
      mount_component(file, span0, null);
      append(span3, t0);
      append(span3, span1);
      span1.innerHTML = ctx[4];
      append(span3, t1);
      append(span3, span2);
      append(span3, t3);
      if (if_block)
        if_block.m(span3, null);
      current = true;
    },
    p(ctx2, dirty) {
      if (!current || dirty & 16)
        span1.innerHTML = ctx2[4];
      ;
      if (ctx2[3].matches.length > 0) {
        if (if_block) {
          if_block.p(ctx2, dirty);
        } else {
          if_block = create_if_block_13(ctx2);
          if_block.c();
          if_block.m(span3, null);
        }
      } else if (if_block) {
        if_block.d(1);
        if_block = null;
      }
    },
    i(local) {
      if (current)
        return;
      transition_in(file.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(file.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      if (detaching)
        detach(span3);
      destroy_component(file);
      if (if_block)
        if_block.d();
    }
  };
}
function create_if_block3(ctx) {
  let div;
  let folderopen;
  let t0;
  let span;
  let current;
  folderopen = new folder_open_default({ props: { size: 15 } });
  return {
    c() {
      div = element("div");
      create_component(folderopen.$$.fragment);
      t0 = space();
      span = element("span");
      span.textContent = `${ctx[7]}`;
      attr(div, "class", "omnisearch-result__folder-path");
    },
    m(target, anchor) {
      insert(target, div, anchor);
      mount_component(folderopen, div, null);
      append(div, t0);
      append(div, span);
      current = true;
    },
    p: noop,
    i(local) {
      if (current)
        return;
      transition_in(folderopen.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(folderopen.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      if (detaching)
        detach(div);
      destroy_component(folderopen);
    }
  };
}
function create_suggestion_extra_content_slot2(ctx) {
  let t;
  let div;
  let current;
  let if_block = ctx[7].length > 0 && create_if_block3(ctx);
  return {
    c() {
      if (if_block)
        if_block.c();
      t = space();
      div = element("div");
      attr(div, "class", "omnisearch-result__body");
    },
    m(target, anchor) {
      if (if_block)
        if_block.m(target, anchor);
      insert(target, t, anchor);
      insert(target, div, anchor);
      div.innerHTML = ctx[5];
      current = true;
    },
    p(ctx2, dirty) {
      if (ctx2[7].length > 0)
        if_block.p(ctx2, dirty);
      if (!current || dirty & 32)
        div.innerHTML = ctx2[5];
      ;
    },
    i(local) {
      if (current)
        return;
      transition_in(if_block);
      current = true;
    },
    o(local) {
      transition_out(if_block);
      current = false;
    },
    d(detaching) {
      if (if_block)
        if_block.d(detaching);
      if (detaching)
        detach(t);
      if (detaching)
        detach(div);
    }
  };
}
function create_fragment17(ctx) {
  let suggestion_1;
  let current;
  suggestion_1 = new suggestion_default({
    props: {
      index: ctx[0],
      textInputSuggester: ctx[1],
      selectedItemIndex: ctx[2],
      suggestionItemClass: "suggestion-item omnisearch-result",
      suggestionContentClass: "",
      suggestionTitleClass: "omnisearch-result__title-container",
      $$slots: {
        "suggestion-extra-content": [create_suggestion_extra_content_slot2],
        "suggestion-title": [create_suggestion_title_slot2]
      },
      $$scope: { ctx }
    }
  });
  return {
    c() {
      create_component(suggestion_1.$$.fragment);
    },
    m(target, anchor) {
      mount_component(suggestion_1, target, anchor);
      current = true;
    },
    p(ctx2, [dirty]) {
      const suggestion_1_changes = {};
      if (dirty & 1)
        suggestion_1_changes.index = ctx2[0];
      if (dirty & 2)
        suggestion_1_changes.textInputSuggester = ctx2[1];
      if (dirty & 4)
        suggestion_1_changes.selectedItemIndex = ctx2[2];
      if (dirty & 312) {
        suggestion_1_changes.$$scope = { dirty, ctx: ctx2 };
      }
      suggestion_1.$set(suggestion_1_changes);
    },
    i(local) {
      if (current)
        return;
      transition_in(suggestion_1.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(suggestion_1.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      destroy_component(suggestion_1, detaching);
    }
  };
}
function instance17($$self, $$props, $$invalidate) {
  let { index } = $$props;
  let { textInputSuggester } = $$props;
  let { selectedItemIndex } = $$props;
  let { suggestion } = $$props;
  let { basename } = $$props;
  let { excerpt } = $$props;
  let fileExtension = getExtensionFromFilename(suggestion.path);
  let folderPath = suggestion.path.replace(`${suggestion.basename}.${fileExtension}`, "").slice(0, -1);
  $$self.$$set = ($$props2) => {
    if ("index" in $$props2)
      $$invalidate(0, index = $$props2.index);
    if ("textInputSuggester" in $$props2)
      $$invalidate(1, textInputSuggester = $$props2.textInputSuggester);
    if ("selectedItemIndex" in $$props2)
      $$invalidate(2, selectedItemIndex = $$props2.selectedItemIndex);
    if ("suggestion" in $$props2)
      $$invalidate(3, suggestion = $$props2.suggestion);
    if ("basename" in $$props2)
      $$invalidate(4, basename = $$props2.basename);
    if ("excerpt" in $$props2)
      $$invalidate(5, excerpt = $$props2.excerpt);
  };
  return [
    index,
    textInputSuggester,
    selectedItemIndex,
    suggestion,
    basename,
    excerpt,
    fileExtension,
    folderPath
  ];
}
var OmnisearchSuggestion = class extends SvelteComponent {
  constructor(options) {
    super();
    init(this, options, instance17, create_fragment17, safe_not_equal, {
      index: 0,
      textInputSuggester: 1,
      selectedItemIndex: 2,
      suggestion: 3,
      basename: 4,
      excerpt: 5
    });
  }
};
var omnisearchSuggestion_default = OmnisearchSuggestion;

// src/utils/regexUtils.ts
function escapeStringForRegExp(string) {
  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
}
function concatenateStringsToRegex(strings, modifier) {
  return new RegExp(strings.join("|"), modifier != null ? modifier : "g");
}

// src/suggester/omnisearchSuggester.ts
var OmnisearchSuggester = class extends TextInputSuggester {
  constructor(app2, plugin, view, searchBar) {
    super(app2, get_store_value(searchBar.searchBarEl), get_store_value(searchBar.suggestionContainerEl), {
      containerClass: `home-tab-suggestion-container ${import_obsidian5.Platform.isPhone ? "is-phone" : ""}`,
      additionalClasses: `${plugin.settings.selectionHighlight === "accentColor" ? "use-accent-color" : ""}`,
      additionalModalInfo: plugin.settings.showShortcuts ? generateHotkeySuggestion([
        { hotkey: "\u2191\u2193", action: "to navigate" },
        { hotkey: "\u21B5", action: "to open" },
        { hotkey: "ctrl \u21B5", action: "to open in new tab" },
        { hotkey: "esc", action: "to dismiss" }
      ], "home-tab-hotkey-suggestions") : void 0
    }, plugin.settings.searchDelay);
    this.plugin = plugin;
    this.view = view;
    this.searchBar = searchBar;
    this.omnisearch = omnisearch;
    this.scope.register(["Mod"], "Enter", (e) => {
      e.preventDefault();
      this.useSelectedItem(this.suggester.getSelectedItem(), true);
    });
  }
  updateSearchBarContainerEl(isActive) {
    var _a;
    (_a = this.inputEl.parentElement) == null ? void 0 : _a.toggleClass("is-active", isActive);
  }
  onOpen() {
    this.updateSearchBarContainerEl(this.suggester.getSuggestions().length > 0 ? true : false);
  }
  onClose() {
    this.updateSearchBarContainerEl(false);
  }
  async getSuggestions(input) {
    const suggestions = (await this.omnisearch.search(input)).splice(0, this.plugin.settings.maxResults);
    return suggestions;
  }
  useSelectedItem(selectedItem, newTab) {
    const file = this.app.vault.getAbstractFileByPath(selectedItem.path);
    if (file && file instanceof import_obsidian5.TFile) {
      this.openFile(file, newTab);
    }
  }
  getDisplayElementProps(suggestion) {
    const escapedWords = suggestion.foundWords.map((word) => escapeStringForRegExp(word));
    const regex = concatenateStringsToRegex(escapedWords, "gi");
    let content = this.plugin.settings.showOmnisearchExcerpt ? this.highlightMatches(suggestion.excerpt, regex) : "";
    let basename = this.highlightMatches(suggestion.basename, regex);
    return { basename, excerpt: content };
  }
  getDisplayElementComponentType() {
    return omnisearchSuggestion_default;
  }
  openFile(file, newTab) {
    if (newTab) {
      this.app.workspace.createLeafInTabGroup().openFile(file);
    } else {
      this.view.leaf.openFile(file);
    }
  }
  highlightMatches(content, regexMatches) {
    return content.replaceAll(regexMatches, (value) => `<span class="suggestion-highlight omnisearch-highlight omnisearch-default-highlight">${value}</span>`);
  }
};

// src/suggester/surfingSuggester.ts
var import_obsidian6 = require("obsidian");

// src/ui/svelteComponents/surfingSuggestion.svelte
function create_suggestion_title_slot3(ctx) {
  let span;
  return {
    c() {
      span = element("span");
      span.textContent = `${ctx[4].name}`;
    },
    m(target, anchor) {
      insert(target, span, anchor);
    },
    p: noop,
    d(detaching) {
      if (detaching)
        detach(span);
    }
  };
}
function create_suggestion_aux_slot2(ctx) {
  let span;
  let t;
  return {
    c() {
      span = element("span");
      t = text(ctx[3]);
      attr(span, "class", "home-tab-suggestion-tip");
    },
    m(target, anchor) {
      insert(target, span, anchor);
      append(span, t);
    },
    p(ctx2, dirty) {
      if (dirty & 8)
        set_data(t, ctx2[3]);
    },
    d(detaching) {
      if (detaching)
        detach(span);
    }
  };
}
function create_if_block4(ctx) {
  let span;
  return {
    c() {
      span = element("span");
      span.textContent = `${ctx[4].url}`;
    },
    m(target, anchor) {
      insert(target, span, anchor);
    },
    p: noop,
    d(detaching) {
      if (detaching)
        detach(span);
    }
  };
}
function create_suggestion_extra_content_slot3(ctx) {
  let if_block_anchor;
  let if_block = ctx[4].type != "newUrl" && create_if_block4(ctx);
  return {
    c() {
      if (if_block)
        if_block.c();
      if_block_anchor = empty();
    },
    m(target, anchor) {
      if (if_block)
        if_block.m(target, anchor);
      insert(target, if_block_anchor, anchor);
    },
    p(ctx2, dirty) {
      if (ctx2[4].type != "newUrl")
        if_block.p(ctx2, dirty);
    },
    d(detaching) {
      if (if_block)
        if_block.d(detaching);
      if (detaching)
        detach(if_block_anchor);
    }
  };
}
function create_fragment18(ctx) {
  let suggestion_1;
  let current;
  suggestion_1 = new suggestion_default({
    props: {
      index: ctx[0],
      textInputSuggester: ctx[1],
      selectedItemIndex: ctx[2],
      suggestionTitleClass: `suggestion-title home-tab-suggestion-title}`,
      $$slots: {
        "suggestion-extra-content": [create_suggestion_extra_content_slot3],
        "suggestion-aux": [create_suggestion_aux_slot2],
        "suggestion-title": [create_suggestion_title_slot3]
      },
      $$scope: { ctx }
    }
  });
  return {
    c() {
      create_component(suggestion_1.$$.fragment);
    },
    m(target, anchor) {
      mount_component(suggestion_1, target, anchor);
      current = true;
    },
    p(ctx2, [dirty]) {
      const suggestion_1_changes = {};
      if (dirty & 1)
        suggestion_1_changes.index = ctx2[0];
      if (dirty & 2)
        suggestion_1_changes.textInputSuggester = ctx2[1];
      if (dirty & 4)
        suggestion_1_changes.selectedItemIndex = ctx2[2];
      if (dirty & 72) {
        suggestion_1_changes.$$scope = { dirty, ctx: ctx2 };
      }
      suggestion_1.$set(suggestion_1_changes);
    },
    i(local) {
      if (current)
        return;
      transition_in(suggestion_1.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(suggestion_1.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      destroy_component(suggestion_1, detaching);
    }
  };
}
function instance18($$self, $$props, $$invalidate) {
  let { index } = $$props;
  let { textInputSuggester } = $$props;
  let { selectedItemIndex } = $$props;
  let { suggestion } = $$props;
  let { info } = $$props;
  let suggestionItem = suggestion.item;
  $$self.$$set = ($$props2) => {
    if ("index" in $$props2)
      $$invalidate(0, index = $$props2.index);
    if ("textInputSuggester" in $$props2)
      $$invalidate(1, textInputSuggester = $$props2.textInputSuggester);
    if ("selectedItemIndex" in $$props2)
      $$invalidate(2, selectedItemIndex = $$props2.selectedItemIndex);
    if ("suggestion" in $$props2)
      $$invalidate(5, suggestion = $$props2.suggestion);
    if ("info" in $$props2)
      $$invalidate(3, info = $$props2.info);
  };
  return [index, textInputSuggester, selectedItemIndex, info, suggestionItem, suggestion];
}
var SurfingSuggestion = class extends SvelteComponent {
  constructor(options) {
    super();
    init(this, options, instance18, create_fragment18, safe_not_equal, {
      index: 0,
      textInputSuggester: 1,
      selectedItemIndex: 2,
      suggestion: 5,
      info: 3
    });
  }
};
var surfingSuggestion_default = SurfingSuggestion;

// src/suggester/surfingSuggester.ts
var SurfingSuggester = class extends TextInputSuggester {
  constructor(app2, plugin, view, searchBar) {
    super(app2, get_store_value(searchBar.searchBarEl), get_store_value(searchBar.suggestionContainerEl), {
      containerClass: `home-tab-suggestion-container ${import_obsidian6.Platform.isPhone ? "is-phone" : ""}`,
      additionalClasses: `${plugin.settings.selectionHighlight === "accentColor" ? "use-accent-color" : ""}`,
      additionalModalInfo: plugin.settings.showShortcuts ? generateHotkeySuggestion([
        { hotkey: "\u2191\u2193", action: "to navigate" },
        { hotkey: "\u21B5", action: "to open" },
        { hotkey: "ctrl \u21B5", action: "to open in new tab" },
        { hotkey: "esc", action: "to dismiss" }
      ], "home-tab-hotkey-suggestions") : void 0
    }, plugin.settings.searchDelay);
    this.surfingJSONfile = "surfing-bookmark.json";
    this.plugin = plugin;
    this.view = view;
    this.searchBar = searchBar;
    this.surfingPlugin = this.app.plugins.getPlugin("surfing");
    this.fuzzySearch = new SurfingItemFuzzySearch(this.getSurfingItems());
    this.scope.register(["Mod"], "Enter", (e) => {
      e.preventDefault();
      this.useSelectedItem(this.suggester.getSelectedItem(), true);
    });
  }
  updateSearchBarContainerEl(isActive) {
    var _a;
    (_a = this.inputEl.parentElement) == null ? void 0 : _a.toggleClass("is-active", isActive);
  }
  onOpen() {
    this.updateSearchBarContainerEl(this.suggester.getSuggestions().length > 0 ? true : false);
  }
  onClose() {
    this.updateSearchBarContainerEl(false);
  }
  onNoSuggestion() {
    const input = this.inputEl.value;
    if (!!input) {
      this.suggester.setSuggestions([{
        item: {
          type: "newUrl",
          name: input,
          url: input
        },
        refIndex: 0,
        score: 0
      }]);
      this.open();
    } else {
      this.close();
    }
  }
  async getSuggestions(input) {
    return this.fuzzySearch.rawSearch(input, this.plugin.settings.maxResults);
  }
  async useSelectedItem(selectedItem, newTab) {
    const leaf = this.app.workspace.getMostRecentLeaf();
    if (leaf) {
      await this.patchLeaf(leaf, selectedItem.item.url);
    }
  }
  async patchLeaf(leaf, url) {
    const state = {
      url,
      active: true
    };
    await leaf.setViewState({
      type: "surfing-view",
      state
    });
    return leaf.view;
  }
  getDisplayElementProps(suggestion) {
    let info = "";
    if (suggestion.item.type === "newUrl") {
      info = `Search with ${this.surfingPlugin.settings.defaultSearchEngine}`;
    }
    return { info };
  }
  getDisplayElementComponentType() {
    return surfingSuggestion_default;
  }
  getSurfingItems() {
    const items = [];
    return items;
  }
  getHistory() {
    return [];
  }
  getOpenitems() {
    return [];
  }
  async getBookmarks() {
    return JSON.parse(await this.app.vault.adapter.read(`${this.app.vault.configDir}/${this.surfingJSONfile}`));
  }
  async getBookmarkedItems() {
    const items = [];
    (await this.getBookmarks()).bookmarks.forEach((bookmark) => items.push({
      type: "bookmark",
      name: bookmark.name,
      url: bookmark.url,
      description: bookmark.description
    }));
    return items;
  }
};

// src/homeTabSearchbar.ts
var omnisearchKeys = ["omnisearch", "omni"];
var webSearchKeys = ["surfing", "web", "internet"];
var filterKeysLookupTable = {
  default: [],
  omnisearch: [...omnisearchKeys],
  webSearch: [...webSearchKeys],
  fileType: [...fileTypes],
  fileExtension: [...fileExtensions]
};
var filterKeys = [
  ...filterKeysLookupTable.omnisearch,
  ...filterKeysLookupTable.webSearch,
  ...filterKeysLookupTable.fileType,
  ...filterKeysLookupTable.fileExtension
];
var HomeTabSearchBar = class {
  constructor(plugin, view, onLoad) {
    this.app = view.app;
    this.view = view;
    this.plugin = plugin;
    this.searchBarEl = writable();
    this.activeExtEl = writable();
    this.suggestionContainerEl = writable();
    this.onLoad = onLoad;
  }
  focusSearchbar() {
    if (this.searchBarEl)
      get_store_value(this.searchBarEl).focus();
  }
  load() {
    if (this.plugin.settings.omnisearch && this.plugin.app.plugins.getPlugin("omnisearch")) {
      this.fileSuggester = new OmnisearchSuggester(this.plugin.app, this.plugin, this.view, this);
    } else {
      this.fileSuggester = new HomeTabFileSuggester(this.plugin.app, this.plugin, this.view, this);
    }
    this.onLoad ? this.onLoad() : null;
  }
  updateActiveSuggester(filterKey) {
    this.fileSuggester.destroy();
    const filterEl = get_store_value(this.activeExtEl);
    let filter = "default";
    for (const filterType of Object.keys(filterKeysLookupTable)) {
      if (filterKeysLookupTable[filterType].includes(filterKey)) {
        filter = filterType;
      }
    }
    filterEl.setText(filter);
    this.activeFilter = filter;
    switch (filter) {
      case "default":
        filterEl.toggleClass("hide", true);
        if (this.plugin.settings.omnisearch && this.plugin.app.plugins.getPlugin("omnisearch")) {
          this.fileSuggester = new OmnisearchSuggester(this.plugin.app, this.plugin, this.view, this);
        } else {
          this.fileSuggester = new HomeTabFileSuggester(this.plugin.app, this.plugin, this.view, this);
        }
        this.fileSuggester.setInput("");
        break;
      case "omnisearch":
        if (this.app.plugins.getPlugin("omnisearch")) {
          filterEl.toggleClass("hide", false);
          this.fileSuggester = new OmnisearchSuggester(this.plugin.app, this.plugin, this.view, this);
          this.fileSuggester.setInput("");
        } else {
          new import_obsidian7.Notice("Omnisearch plugins is not enabled.");
          this.updateActiveSuggester("default");
        }
        break;
      case "webSearch":
        if (this.app.plugins.getPlugin("surfing")) {
          filterEl.toggleClass("hide", false);
          this.fileSuggester = new SurfingSuggester(this.plugin.app, this.plugin, this.view, this);
          this.fileSuggester.setInput("");
        } else {
          new import_obsidian7.Notice("Surfing plugin is not enabled.");
          this.updateActiveSuggester("default");
        }
        break;
      case "fileExtension":
      case "fileType":
        this.fileSuggester = new HomeTabFileSuggester(this.plugin.app, this.plugin, this.view, this);
        this.fileSuggester.setFileFilter(filterKey);
        filterEl.toggleClass("hide", false);
        filterEl.setText(filterKey);
        this.fileSuggester.setInput("");
        break;
      default:
        break;
    }
  }
};

// src/ui/searchBar.svelte
function add_css2(target) {
  append_styles(target, "svelte-1v6c0q", ".home-tab-searchbar-container.svelte-1v6c0q.svelte-1v6c0q{display:flex;align-items:center;flex-direction:column}.home-tab-searchbar.svelte-1v6c0q.svelte-1v6c0q{display:flex;min-width:250px;max-width:700px;margin:0 auto;height:calc(var(--input-height)*1.25);background-color:var(--background-modifier-form-field);border:var(--input-border-width) solid var(--background-modifier-border);padding:var(--size-2-3);border-radius:var(--input-radius);outline:none}.home-tab-searchbar.svelte-1v6c0q input.svelte-1v6c0q{width:100%;height:100%;box-shadow:none;font-size:var(--font-ui-medium);background:none;border:none;padding-left:12px}.home-tab-searchbar.svelte-1v6c0q input.svelte-1v6c0q:hover{background:none;border:none}.home-tab-suggestion-file-tag.hide.svelte-1v6c0q.svelte-1v6c0q{display:none}");
}
function create_fragment19(ctx) {
  let div2;
  let div1;
  let div0;
  let t;
  let input;
  let mounted;
  let dispose;
  return {
    c() {
      div2 = element("div");
      div1 = element("div");
      div0 = element("div");
      t = space();
      input = element("input");
      attr(div0, "class", "nav-file-tag home-tab-suggestion-file-tag hide svelte-1v6c0q");
      attr(input, "type", "search");
      attr(input, "spellcheck", "false");
      attr(input, "placeholder", "Type to start search...");
      attr(input, "class", "svelte-1v6c0q");
      attr(div1, "class", "home-tab-searchbar svelte-1v6c0q");
      toggle_class(div1, "embedded", ctx[0]);
      set_style(div1, "width", ctx[0] || ctx[8] ? "90%" : "50%", false);
      attr(div2, "class", "home-tab-searchbar-container svelte-1v6c0q");
    },
    m(target, anchor) {
      insert(target, div2, anchor);
      append(div2, div1);
      append(div1, div0);
      ctx[11](div0);
      append(div1, t);
      append(div1, input);
      set_input_value(input, ctx[1]);
      ctx[13](input);
      ctx[15](div2);
      if (!mounted) {
        dispose = [
          listen(input, "input", ctx[12]),
          listen(input, "keydown", ctx[14])
        ];
        mounted = true;
      }
    },
    p(ctx2, [dirty]) {
      if (dirty & 2) {
        set_input_value(input, ctx2[1]);
      }
      if (dirty & 1) {
        toggle_class(div1, "embedded", ctx2[0]);
      }
      if (dirty & 1) {
        set_style(div1, "width", ctx2[0] || ctx2[8] ? "90%" : "50%", false);
      }
    },
    i: noop,
    o: noop,
    d(detaching) {
      if (detaching)
        detach(div2);
      ctx[11](null);
      ctx[13](null);
      ctx[15](null);
      mounted = false;
      run_all(dispose);
    }
  };
}
function instance19($$self, $$props, $$invalidate) {
  let $container;
  let $activeExtEl;
  let $searchBarEl;
  let { HomeTabSearchBar: HomeTabSearchBar2 } = $$props;
  let { embedded = false } = $$props;
  const searchBarEl = HomeTabSearchBar2.searchBarEl;
  component_subscribe($$self, searchBarEl, (value) => $$invalidate(4, $searchBarEl = value));
  const activeExtEl = HomeTabSearchBar2.activeExtEl;
  component_subscribe($$self, activeExtEl, (value) => $$invalidate(3, $activeExtEl = value));
  const container = HomeTabSearchBar2.suggestionContainerEl;
  component_subscribe($$self, container, (value) => $$invalidate(2, $container = value));
  const isPhone = import_obsidian8.Platform.isPhone;
  let inputValue = "";
  function handleKeydown(e) {
    if (e.key === "Backspace") {
      if (inputValue != "")
        return;
      if (HomeTabSearchBar2.activeFilter) {
        HomeTabSearchBar2.updateActiveSuggester("default");
      }
    }
    if (e.key === "Tab") {
      e.preventDefault();
      const key = inputValue.toLowerCase();
      if (filterKeys.find((item) => item === key)) {
        HomeTabSearchBar2.updateActiveSuggester(key);
      }
    }
  }
  function div0_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      $activeExtEl = $$value;
      activeExtEl.set($activeExtEl);
    });
  }
  function input_input_handler() {
    inputValue = this.value;
    $$invalidate(1, inputValue);
  }
  function input_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      $searchBarEl = $$value;
      searchBarEl.set($searchBarEl);
    });
  }
  const keydown_handler = (e) => handleKeydown(e);
  function div2_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      $container = $$value;
      container.set($container);
    });
  }
  $$self.$$set = ($$props2) => {
    if ("HomeTabSearchBar" in $$props2)
      $$invalidate(10, HomeTabSearchBar2 = $$props2.HomeTabSearchBar);
    if ("embedded" in $$props2)
      $$invalidate(0, embedded = $$props2.embedded);
  };
  return [
    embedded,
    inputValue,
    $container,
    $activeExtEl,
    $searchBarEl,
    searchBarEl,
    activeExtEl,
    container,
    isPhone,
    handleKeydown,
    HomeTabSearchBar2,
    div0_binding,
    input_input_handler,
    input_binding,
    keydown_handler,
    div2_binding
  ];
}
var SearchBar = class extends SvelteComponent {
  constructor(options) {
    super();
    init(this, options, instance19, create_fragment19, safe_not_equal, { HomeTabSearchBar: 10, embedded: 0 }, add_css2);
  }
};
var searchBar_default = SearchBar;

// src/store.ts
var pluginSettingsStore = writable();
var bookmarkedFiles = writable();
var recentFiles = writable([]);

// src/ui/homepage.svelte
var import_obsidian14 = require("obsidian");

// src/ui/bookmarkedFiles.svelte
var import_obsidian12 = require("obsidian");

// src/iconSelectionModal.ts
var import_obsidian10 = require("obsidian");

// src/ui/svelteComponents/iconSuggestion.svelte
var import_obsidian9 = require("obsidian");
function create_suggestion_title_slot4(ctx) {
  let t_value = ctx[3].item + "";
  let t;
  return {
    c() {
      t = text(t_value);
    },
    m(target, anchor) {
      insert(target, t, anchor);
    },
    p(ctx2, dirty) {
      if (dirty & 8 && t_value !== (t_value = ctx2[3].item + ""))
        set_data(t, t_value);
    },
    d(detaching) {
      if (detaching)
        detach(t);
    }
  };
}
function create_if_block5(ctx) {
  var _a;
  let span;
  let raw_value = ((_a = (0, import_obsidian9.getIcon)(ctx[3].item)) == null ? void 0 : _a.outerHTML) + "";
  return {
    c() {
      span = element("span");
      attr(span, "class", "suggestion-flair");
    },
    m(target, anchor) {
      insert(target, span, anchor);
      span.innerHTML = raw_value;
    },
    p(ctx2, dirty) {
      var _a2;
      if (dirty & 8 && raw_value !== (raw_value = ((_a2 = (0, import_obsidian9.getIcon)(ctx2[3].item)) == null ? void 0 : _a2.outerHTML) + ""))
        span.innerHTML = raw_value;
      ;
    },
    d(detaching) {
      if (detaching)
        detach(span);
    }
  };
}
function create_suggestion_aux_slot3(ctx) {
  let if_block_anchor;
  let if_block = ctx[4] && create_if_block5(ctx);
  return {
    c() {
      if (if_block)
        if_block.c();
      if_block_anchor = empty();
    },
    m(target, anchor) {
      if (if_block)
        if_block.m(target, anchor);
      insert(target, if_block_anchor, anchor);
    },
    p(ctx2, dirty) {
      if (ctx2[4]) {
        if (if_block) {
          if_block.p(ctx2, dirty);
        } else {
          if_block = create_if_block5(ctx2);
          if_block.c();
          if_block.m(if_block_anchor.parentNode, if_block_anchor);
        }
      } else if (if_block) {
        if_block.d(1);
        if_block = null;
      }
    },
    d(detaching) {
      if (if_block)
        if_block.d(detaching);
      if (detaching)
        detach(if_block_anchor);
    }
  };
}
function create_fragment20(ctx) {
  let suggestion_1;
  let current;
  suggestion_1 = new suggestion_default({
    props: {
      index: ctx[0],
      textInputSuggester: ctx[1],
      selectedItemIndex: ctx[2],
      $$slots: {
        "suggestion-aux": [create_suggestion_aux_slot3],
        "suggestion-title": [create_suggestion_title_slot4]
      },
      $$scope: { ctx }
    }
  });
  return {
    c() {
      create_component(suggestion_1.$$.fragment);
    },
    m(target, anchor) {
      mount_component(suggestion_1, target, anchor);
      current = true;
    },
    p(ctx2, [dirty]) {
      const suggestion_1_changes = {};
      if (dirty & 1)
        suggestion_1_changes.index = ctx2[0];
      if (dirty & 2)
        suggestion_1_changes.textInputSuggester = ctx2[1];
      if (dirty & 4)
        suggestion_1_changes.selectedItemIndex = ctx2[2];
      if (dirty & 56) {
        suggestion_1_changes.$$scope = { dirty, ctx: ctx2 };
      }
      suggestion_1.$set(suggestion_1_changes);
    },
    i(local) {
      if (current)
        return;
      transition_in(suggestion_1.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(suggestion_1.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      destroy_component(suggestion_1, detaching);
    }
  };
}
function instance20($$self, $$props, $$invalidate) {
  let { index } = $$props;
  let { textInputSuggester } = $$props;
  let { selectedItemIndex } = $$props;
  let { suggestion } = $$props;
  let { displayIcon } = $$props;
  $$self.$$set = ($$props2) => {
    if ("index" in $$props2)
      $$invalidate(0, index = $$props2.index);
    if ("textInputSuggester" in $$props2)
      $$invalidate(1, textInputSuggester = $$props2.textInputSuggester);
    if ("selectedItemIndex" in $$props2)
      $$invalidate(2, selectedItemIndex = $$props2.selectedItemIndex);
    if ("suggestion" in $$props2)
      $$invalidate(3, suggestion = $$props2.suggestion);
    if ("displayIcon" in $$props2)
      $$invalidate(4, displayIcon = $$props2.displayIcon);
  };
  return [index, textInputSuggester, selectedItemIndex, suggestion, displayIcon];
}
var IconSuggestion = class extends SvelteComponent {
  constructor(options) {
    super();
    init(this, options, instance20, create_fragment20, safe_not_equal, {
      index: 0,
      textInputSuggester: 1,
      selectedItemIndex: 2,
      suggestion: 3,
      displayIcon: 4
    });
  }
};
var iconSuggestion_default = IconSuggestion;

// src/suggester/iconSuggester.ts
var iconSuggester = class extends PopoverTextInputSuggester {
  constructor(app2, inputEl, viewOptions, displayIcon) {
    super(app2, inputEl, viewOptions);
    this.iconList = [...lucideIcons];
    this.fuzzySearch = new ArrayFuzzySearch(this.iconList);
    this.displayIcon = displayIcon != null ? displayIcon : false;
  }
  getSuggestions(input) {
    return this.fuzzySearch.filteredSearch(input, 0.25, 15);
  }
  useSelectedItem(selectedItem) {
    this.inputEl.value = selectedItem.item;
    this.inputEl.trigger("input");
    this.onInput().then(() => this.close());
  }
  getDisplayElementComponentType() {
    return iconSuggestion_default;
  }
  getDisplayElementProps() {
    return {
      displayIcon: this.displayIcon
    };
  }
};

// src/iconSelectionModal.ts
var IconSelectionModal = class extends import_obsidian10.Modal {
  constructor(app2, defaultIcon, onSubmit) {
    super(app2);
    this.icon = defaultIcon;
    this.onSubmit = onSubmit;
  }
  onOpen() {
    const { contentEl } = this;
    contentEl.createEl("h1", { text: "Set a custom icon" });
    const iconSetting = new import_obsidian10.Setting(contentEl).setName("Choose an icon").setDesc("Accepts any lucide icon id.");
    let invalidInputIcon;
    iconSetting.addExtraButton((button) => {
      button.setIcon("alert-circle").setTooltip("The icon id is not valid.");
      invalidInputIcon = button.extraSettingsEl;
      invalidInputIcon.toggleVisibility(false);
      invalidInputIcon.addClass("mod-warning");
    });
    iconSetting.addSearch((text2) => {
      var _a, _b;
      new iconSuggester(this.app, text2.inputEl, {
        isScrollable: true,
        style: `max-height: 200px`
      }, true);
      (_b = text2.setPlaceholder("Type to start search...").setValue((_a = this.icon) != null ? _a : "").onChange((value) => {
        if (lucideIcons.includes(value)) {
          this.icon = value;
          invalidInputIcon.toggleVisibility(false);
        } else {
          invalidInputIcon.toggleVisibility(true);
        }
      }).inputEl.parentElement) == null ? void 0 : _b.addClass("wide-input-container");
    });
    new import_obsidian10.Setting(contentEl).addButton((btn) => btn.setButtonText("Close modal").onClick(() => {
      this.close();
    })).addButton((btn) => btn.setButtonText("Set icon").setCta().onClick(() => {
      this.icon ? this.onSubmit(this.icon) : null;
      this.close();
    }));
  }
  onClose() {
    this.icon = void 0;
    let { contentEl } = this;
    contentEl.empty();
  }
};

// src/ui/svelteComponents/fileDisplayItem.svelte
var import_obsidian11 = require("obsidian");
function add_css3(target) {
  append_styles(target, "svelte-1gyh8cg", ".home-tab-file-item.svelte-1gyh8cg{margin:5px;padding:5px;border-radius:var(--radius-m);min-width:75px;max-width:125px;position:relative}.home-tab-file-item.svelte-1gyh8cg:hover{background-color:var(--background-modifier-hover)}.home-tab-file-item.use-accent-color.svelte-1gyh8cg:hover{color:white;background:var(--interactive-accent)}.home-tab-file-item-preview-icon.svelte-1gyh8cg{display:flex;align-items:center;justify-content:center;padding:var(--size-2-3)}.home-tab-file-item-name.svelte-1gyh8cg{text-align:center;font-size:var(--font-ui-small);display:-webkit-box;overflow:hidden;text-overflow:ellipsis;-webkit-line-clamp:3;-webkit-box-orient:vertical}.home-tab-file-item-remove_btn.svelte-1gyh8cg{opacity:0;position:absolute;top:4px;right:4px}.home-tab-file-item-remove_btn.svelte-1gyh8cg:hover{opacity:1}");
}
function create_else_block2(ctx) {
  let file_1;
  let current;
  file_1 = new file_default({ props: { strokeWidth: 1 } });
  return {
    c() {
      create_component(file_1.$$.fragment);
    },
    m(target, anchor) {
      mount_component(file_1, target, anchor);
      current = true;
    },
    p: noop,
    i(local) {
      if (current)
        return;
      transition_in(file_1.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(file_1.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      destroy_component(file_1, detaching);
    }
  };
}
function create_if_block_52(ctx) {
  let filepiechart;
  let current;
  filepiechart = new file_pie_chart_default({ props: { strokeWidth: 1 } });
  return {
    c() {
      create_component(filepiechart.$$.fragment);
    },
    m(target, anchor) {
      mount_component(filepiechart, target, anchor);
      current = true;
    },
    p: noop,
    i(local) {
      if (current)
        return;
      transition_in(filepiechart.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(filepiechart.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      destroy_component(filepiechart, detaching);
    }
  };
}
function create_if_block_42(ctx) {
  let fileaudio;
  let current;
  fileaudio = new file_audio_default({ props: { strokeWidth: 1 } });
  return {
    c() {
      create_component(fileaudio.$$.fragment);
    },
    m(target, anchor) {
      mount_component(fileaudio, target, anchor);
      current = true;
    },
    p: noop,
    i(local) {
      if (current)
        return;
      transition_in(fileaudio.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(fileaudio.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      destroy_component(fileaudio, detaching);
    }
  };
}
function create_if_block_32(ctx) {
  let filevideo;
  let current;
  filevideo = new file_video_default({ props: { strokeWidth: 1 } });
  return {
    c() {
      create_component(filevideo.$$.fragment);
    },
    m(target, anchor) {
      mount_component(filevideo, target, anchor);
      current = true;
    },
    p: noop,
    i(local) {
      if (current)
        return;
      transition_in(filevideo.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(filevideo.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      destroy_component(filevideo, detaching);
    }
  };
}
function create_if_block_22(ctx) {
  let fileimage;
  let current;
  fileimage = new file_image_default({ props: { strokeWidth: 1 } });
  return {
    c() {
      create_component(fileimage.$$.fragment);
    },
    m(target, anchor) {
      mount_component(fileimage, target, anchor);
      current = true;
    },
    p: noop,
    i(local) {
      if (current)
        return;
      transition_in(fileimage.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(fileimage.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      destroy_component(fileimage, detaching);
    }
  };
}
function create_if_block_14(ctx) {
  let filetext;
  let current;
  filetext = new file_text_default({ props: { strokeWidth: 1 } });
  return {
    c() {
      create_component(filetext.$$.fragment);
    },
    m(target, anchor) {
      mount_component(filetext, target, anchor);
      current = true;
    },
    p: noop,
    i(local) {
      if (current)
        return;
      transition_in(filetext.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(filetext.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      destroy_component(filetext, detaching);
    }
  };
}
function create_if_block6(ctx) {
  var _a;
  let svg;
  let raw_value = ((_a = (0, import_obsidian11.getIcon)(ctx[3])) == null ? void 0 : _a.innerHTML) + "";
  let svg_class_value;
  return {
    c() {
      svg = svg_element("svg");
      attr(svg, "xmlns", "http://www.w3.org/2000/svg");
      attr(svg, "width", "24");
      attr(svg, "height", "24");
      attr(svg, "viewBox", "0 0 24 24");
      attr(svg, "fill", "none");
      attr(svg, "stroke", "currentColor");
      attr(svg, "stroke-width", "1");
      attr(svg, "stroke-linecap", "round");
      attr(svg, "stroke-linejoin", "round");
      attr(svg, "class", svg_class_value = "lucide-icon lucide lucide-" + ctx[3] + " svelte-1gyh8cg");
    },
    m(target, anchor) {
      insert(target, svg, anchor);
      svg.innerHTML = raw_value;
    },
    p(ctx2, dirty) {
      var _a2;
      if (dirty & 8 && raw_value !== (raw_value = ((_a2 = (0, import_obsidian11.getIcon)(ctx2[3])) == null ? void 0 : _a2.innerHTML) + ""))
        svg.innerHTML = raw_value;
      ;
      if (dirty & 8 && svg_class_value !== (svg_class_value = "lucide-icon lucide lucide-" + ctx2[3] + " svelte-1gyh8cg")) {
        attr(svg, "class", svg_class_value);
      }
    },
    i: noop,
    o: noop,
    d(detaching) {
      if (detaching)
        detach(svg);
    }
  };
}
function create_fragment21(ctx) {
  let div3;
  let div0;
  let morehorizontal;
  let t0;
  let div1;
  let current_block_type_index;
  let if_block;
  let t1;
  let div2;
  let current;
  let mounted;
  let dispose;
  morehorizontal = new more_horizontal_default({
    props: {
      strokeWidth: 1,
      width: 24,
      height: 24,
      class: "svg-icon lucide-x"
    }
  });
  const if_block_creators = [
    create_if_block6,
    create_if_block_14,
    create_if_block_22,
    create_if_block_32,
    create_if_block_42,
    create_if_block_52,
    create_else_block2
  ];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (ctx2[3])
      return 0;
    if (ctx2[5] === "markdown")
      return 1;
    if (ctx2[5] === "image")
      return 2;
    if (ctx2[5] === "video")
      return 3;
    if (ctx2[5] === "audio")
      return 4;
    if (ctx2[5] === "pdf")
      return 5;
    return 6;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  return {
    c() {
      div3 = element("div");
      div0 = element("div");
      create_component(morehorizontal.$$.fragment);
      t0 = space();
      div1 = element("div");
      if_block.c();
      t1 = space();
      div2 = element("div");
      div2.textContent = `${ctx[4]}`;
      attr(div0, "class", "home-tab-file-item-remove_btn svelte-1gyh8cg");
      attr(div0, "aria-label", "File options");
      attr(div1, "class", "home-tab-file-item-preview-icon svelte-1gyh8cg");
      attr(div2, "class", "home-tab-file-item-name svelte-1gyh8cg");
      attr(div3, "class", "home-tab-file-item svelte-1gyh8cg");
      toggle_class(div3, "use-accent-color", ctx[1].selectionHighlight === "accentColor");
    },
    m(target, anchor) {
      insert(target, div3, anchor);
      append(div3, div0);
      mount_component(morehorizontal, div0, null);
      append(div3, t0);
      append(div3, div1);
      if_blocks[current_block_type_index].m(div1, null);
      append(div3, t1);
      append(div3, div2);
      current = true;
      if (!mounted) {
        dispose = [
          listen(div0, "click", ctx[9]),
          listen(div3, "mousedown", prevent_default(ctx[10]))
        ];
        mounted = true;
      }
    },
    p(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(div1, null);
      }
      if (!current || dirty & 2) {
        toggle_class(div3, "use-accent-color", ctx2[1].selectionHighlight === "accentColor");
      }
    },
    i(local) {
      if (current)
        return;
      transition_in(morehorizontal.$$.fragment, local);
      transition_in(if_block);
      current = true;
    },
    o(local) {
      transition_out(morehorizontal.$$.fragment, local);
      transition_out(if_block);
      current = false;
    },
    d(detaching) {
      if (detaching)
        detach(div3);
      destroy_component(morehorizontal);
      if_blocks[current_block_type_index].d();
      mounted = false;
      run_all(dispose);
    }
  };
}
function instance21($$self, $$props, $$invalidate) {
  let { app: app2 } = $$props;
  let { file } = $$props;
  let { pluginSettings } = $$props;
  let { contextualMenu } = $$props;
  let { customIcon = void 0 } = $$props;
  const filename = file.basename;
  const fileType = getFileTypeFromExtension(file.extension);
  const dispatch2 = createEventDispatcher();
  function handleFileOpening(file2, newTab) {
    const leaf = app2.workspace.getLeaf(newTab);
    leaf.openFile(file2);
  }
  function handleMouseClick(e, file2) {
    if (e.target.classList.contains("home-tab-file-item-remove_btn"))
      return;
    else if (e.button != 2) {
      handleFileOpening(file2, import_obsidian11.Keymap.isModEvent(e));
    }
  }
  const click_handler = (e) => {
    contextualMenu.showAtMouseEvent(e);
    dispatch2("itemMenu", { file });
  };
  const mousedown_handler2 = (e) => handleMouseClick(e, file);
  $$self.$$set = ($$props2) => {
    if ("app" in $$props2)
      $$invalidate(8, app2 = $$props2.app);
    if ("file" in $$props2)
      $$invalidate(0, file = $$props2.file);
    if ("pluginSettings" in $$props2)
      $$invalidate(1, pluginSettings = $$props2.pluginSettings);
    if ("contextualMenu" in $$props2)
      $$invalidate(2, contextualMenu = $$props2.contextualMenu);
    if ("customIcon" in $$props2)
      $$invalidate(3, customIcon = $$props2.customIcon);
  };
  return [
    file,
    pluginSettings,
    contextualMenu,
    customIcon,
    filename,
    fileType,
    dispatch2,
    handleMouseClick,
    app2,
    click_handler,
    mousedown_handler2
  ];
}
var FileDisplayItem = class extends SvelteComponent {
  constructor(options) {
    super();
    init(this, options, instance21, create_fragment21, safe_not_equal, {
      app: 8,
      file: 0,
      pluginSettings: 1,
      contextualMenu: 2,
      customIcon: 3
    }, add_css3);
  }
};
var fileDisplayItem_default = FileDisplayItem;

// src/ui/bookmarkedFiles.svelte
function add_css4(target) {
  append_styles(target, "svelte-vhq7y8", ".home-tab-bookmarked-files-container.svelte-vhq7y8{display:flex;align-items:baseline;justify-content:center;flex-wrap:wrap;width:65%;max-width:900px;padding-top:30px;margin:auto}");
}
function get_each_context2(ctx, list, i) {
  const child_ctx = ctx.slice();
  child_ctx[9] = list[i];
  return child_ctx;
}
function create_each_block2(key_1, ctx) {
  let first;
  let filedisplayitem;
  let current;
  filedisplayitem = new fileDisplayItem_default({
    props: {
      file: ctx[9].file,
      customIcon: ctx[9].iconId,
      app: ctx[3],
      pluginSettings: ctx[1],
      contextualMenu: ctx[4]
    }
  });
  filedisplayitem.$on("itemMenu", ctx[7]);
  return {
    key: key_1,
    first: null,
    c() {
      first = empty();
      create_component(filedisplayitem.$$.fragment);
      this.first = first;
    },
    m(target, anchor) {
      insert(target, first, anchor);
      mount_component(filedisplayitem, target, anchor);
      current = true;
    },
    p(new_ctx, dirty) {
      ctx = new_ctx;
      const filedisplayitem_changes = {};
      if (dirty & 1)
        filedisplayitem_changes.file = ctx[9].file;
      if (dirty & 1)
        filedisplayitem_changes.customIcon = ctx[9].iconId;
      if (dirty & 2)
        filedisplayitem_changes.pluginSettings = ctx[1];
      filedisplayitem.$set(filedisplayitem_changes);
    },
    i(local) {
      if (current)
        return;
      transition_in(filedisplayitem.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(filedisplayitem.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      if (detaching)
        detach(first);
      destroy_component(filedisplayitem, detaching);
    }
  };
}
function create_fragment22(ctx) {
  let div;
  let each_blocks = [];
  let each_1_lookup = /* @__PURE__ */ new Map();
  let current;
  let each_value = ctx[0];
  const get_key = (ctx2) => ctx2[9].file.path;
  for (let i = 0; i < each_value.length; i += 1) {
    let child_ctx = get_each_context2(ctx, each_value, i);
    let key = get_key(child_ctx);
    each_1_lookup.set(key, each_blocks[i] = create_each_block2(key, child_ctx));
  }
  return {
    c() {
      div = element("div");
      for (let i = 0; i < each_blocks.length; i += 1) {
        each_blocks[i].c();
      }
      attr(div, "class", "home-tab-bookmarked-files-container svelte-vhq7y8");
    },
    m(target, anchor) {
      insert(target, div, anchor);
      for (let i = 0; i < each_blocks.length; i += 1) {
        each_blocks[i].m(div, null);
      }
      current = true;
    },
    p(ctx2, [dirty]) {
      if (dirty & 31) {
        each_value = ctx2[0];
        group_outros();
        each_blocks = update_keyed_each(each_blocks, dirty, get_key, 1, ctx2, each_value, each_1_lookup, div, outro_and_destroy_block, create_each_block2, null, get_each_context2);
        check_outros();
      }
    },
    i(local) {
      if (current)
        return;
      for (let i = 0; i < each_value.length; i += 1) {
        transition_in(each_blocks[i]);
      }
      current = true;
    },
    o(local) {
      for (let i = 0; i < each_blocks.length; i += 1) {
        transition_out(each_blocks[i]);
      }
      current = false;
    },
    d(detaching) {
      if (detaching)
        detach(div);
      for (let i = 0; i < each_blocks.length; i += 1) {
        each_blocks[i].d();
      }
    }
  };
}
function instance22($$self, $$props, $$invalidate) {
  let { view } = $$props;
  let { bookmarkedFiles: bookmarkedFiles2 } = $$props;
  let { pluginSettings } = $$props;
  let { bookmarkedFileManager } = $$props;
  const app2 = view.leaf.app;
  let selectedFile;
  const selectIconModal = new IconSelectionModal(app2, void 0, (icon) => bookmarkedFileManager.updateFileIcon(selectedFile, icon));
  const contextualMenu = new import_obsidian12.Menu().addItem((item) => item.setTitle("Remove bookmark").setIcon("trash-2").onClick(() => bookmarkedFileManager.removeBookmark(selectedFile))).addSeparator().addItem((item) => item.setTitle("Set custom icon").setIcon("plus").onClick(() => selectIconModal.open())).setUseNativeMenu(app2.vault.config.nativeMenus);
  const itemMenu_handler = (e) => $$invalidate(2, selectedFile = e.detail.file);
  $$self.$$set = ($$props2) => {
    if ("view" in $$props2)
      $$invalidate(5, view = $$props2.view);
    if ("bookmarkedFiles" in $$props2)
      $$invalidate(0, bookmarkedFiles2 = $$props2.bookmarkedFiles);
    if ("pluginSettings" in $$props2)
      $$invalidate(1, pluginSettings = $$props2.pluginSettings);
    if ("bookmarkedFileManager" in $$props2)
      $$invalidate(6, bookmarkedFileManager = $$props2.bookmarkedFileManager);
  };
  return [
    bookmarkedFiles2,
    pluginSettings,
    selectedFile,
    app2,
    contextualMenu,
    view,
    bookmarkedFileManager,
    itemMenu_handler
  ];
}
var BookmarkedFiles = class extends SvelteComponent {
  constructor(options) {
    super();
    init(this, options, instance22, create_fragment22, safe_not_equal, {
      view: 5,
      bookmarkedFiles: 0,
      pluginSettings: 1,
      bookmarkedFileManager: 6
    }, add_css4);
  }
};
var bookmarkedFiles_default = BookmarkedFiles;

// src/ui/recentFiles.svelte
var import_obsidian13 = require("obsidian");
function add_css5(target) {
  append_styles(target, "svelte-1xy0abl", ".home-tab-recent-files-container.svelte-1xy0abl{width:65%;display:flex;flex-direction:column;padding-top:20px;margin:auto}.home-tab-recent-files-title.svelte-1xy0abl{text-align:center;font-weight:600;font-size:var(--font-ui-large);padding-bottom:5px}.home-tab-recent-files-wrapper.svelte-1xy0abl{display:flex;max-width:900px;align-items:center;justify-content:center;flex-wrap:wrap;margin:auto}@media(max-width: 600px){.home-tab-recent-files-container.svelte-1xy0abl{padding-bottom:75px}}");
}
function get_each_context3(ctx, list, i) {
  const child_ctx = ctx.slice();
  child_ctx[8] = list[i];
  return child_ctx;
}
function create_each_block3(key_1, ctx) {
  let first;
  let filedisplayitem;
  let current;
  filedisplayitem = new fileDisplayItem_default({
    props: {
      file: ctx[8].file,
      app: ctx[3],
      pluginSettings: ctx[1],
      contextualMenu: ctx[4]
    }
  });
  filedisplayitem.$on("itemMenu", ctx[7]);
  return {
    key: key_1,
    first: null,
    c() {
      first = empty();
      create_component(filedisplayitem.$$.fragment);
      this.first = first;
    },
    m(target, anchor) {
      insert(target, first, anchor);
      mount_component(filedisplayitem, target, anchor);
      current = true;
    },
    p(new_ctx, dirty) {
      ctx = new_ctx;
      const filedisplayitem_changes = {};
      if (dirty & 1)
        filedisplayitem_changes.file = ctx[8].file;
      if (dirty & 2)
        filedisplayitem_changes.pluginSettings = ctx[1];
      filedisplayitem.$set(filedisplayitem_changes);
    },
    i(local) {
      if (current)
        return;
      transition_in(filedisplayitem.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(filedisplayitem.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      if (detaching)
        detach(first);
      destroy_component(filedisplayitem, detaching);
    }
  };
}
function create_fragment23(ctx) {
  let div2;
  let div0;
  let t1;
  let div1;
  let each_blocks = [];
  let each_1_lookup = /* @__PURE__ */ new Map();
  let current;
  let each_value = ctx[0];
  const get_key = (ctx2) => ctx2[8].file.path;
  for (let i = 0; i < each_value.length; i += 1) {
    let child_ctx = get_each_context3(ctx, each_value, i);
    let key = get_key(child_ctx);
    each_1_lookup.set(key, each_blocks[i] = create_each_block3(key, child_ctx));
  }
  return {
    c() {
      div2 = element("div");
      div0 = element("div");
      div0.textContent = "Recent files";
      t1 = space();
      div1 = element("div");
      for (let i = 0; i < each_blocks.length; i += 1) {
        each_blocks[i].c();
      }
      attr(div0, "class", "home-tab-recent-files-title svelte-1xy0abl");
      attr(div1, "class", "home-tab-recent-files-wrapper svelte-1xy0abl");
      attr(div2, "class", "home-tab-recent-files-container svelte-1xy0abl");
    },
    m(target, anchor) {
      insert(target, div2, anchor);
      append(div2, div0);
      append(div2, t1);
      append(div2, div1);
      for (let i = 0; i < each_blocks.length; i += 1) {
        each_blocks[i].m(div1, null);
      }
      current = true;
    },
    p(ctx2, [dirty]) {
      if (dirty & 31) {
        each_value = ctx2[0];
        group_outros();
        each_blocks = update_keyed_each(each_blocks, dirty, get_key, 1, ctx2, each_value, each_1_lookup, div1, outro_and_destroy_block, create_each_block3, null, get_each_context3);
        check_outros();
      }
    },
    i(local) {
      if (current)
        return;
      for (let i = 0; i < each_value.length; i += 1) {
        transition_in(each_blocks[i]);
      }
      current = true;
    },
    o(local) {
      for (let i = 0; i < each_blocks.length; i += 1) {
        transition_out(each_blocks[i]);
      }
      current = false;
    },
    d(detaching) {
      if (detaching)
        detach(div2);
      for (let i = 0; i < each_blocks.length; i += 1) {
        each_blocks[i].d();
      }
    }
  };
}
function instance23($$self, $$props, $$invalidate) {
  let { view } = $$props;
  let { recentFileList } = $$props;
  let { pluginSettings } = $$props;
  let { recentFileManager } = $$props;
  const app2 = view.leaf.app;
  let selectedFile;
  let contextualMenu = new import_obsidian13.Menu().addItem((item) => item.setTitle("Hide file").setIcon("eye-off").onClick(() => recentFileManager.removeRecentFile(selectedFile))).setUseNativeMenu(app2.vault.config.nativeMenus);
  const itemMenu_handler = (e) => $$invalidate(2, selectedFile = e.detail.file);
  $$self.$$set = ($$props2) => {
    if ("view" in $$props2)
      $$invalidate(5, view = $$props2.view);
    if ("recentFileList" in $$props2)
      $$invalidate(0, recentFileList = $$props2.recentFileList);
    if ("pluginSettings" in $$props2)
      $$invalidate(1, pluginSettings = $$props2.pluginSettings);
    if ("recentFileManager" in $$props2)
      $$invalidate(6, recentFileManager = $$props2.recentFileManager);
  };
  return [
    recentFileList,
    pluginSettings,
    selectedFile,
    app2,
    contextualMenu,
    view,
    recentFileManager,
    itemMenu_handler
  ];
}
var RecentFiles = class extends SvelteComponent {
  constructor(options) {
    super();
    init(this, options, instance23, create_fragment23, safe_not_equal, {
      view: 5,
      recentFileList: 0,
      pluginSettings: 1,
      recentFileManager: 6
    }, add_css5);
  }
};
var recentFiles_default = RecentFiles;

// src/ui/homepage.svelte
function add_css6(target) {
  append_styles(target, "svelte-1yjwmjb", ".home-tab-logo.svelte-1yjwmjb svg.svelte-1yjwmjb{height:unset;width:unset}.home-tab-wordmark-container.svelte-1yjwmjb.svelte-1yjwmjb{display:flex;align-items:center;justify-content:center;margin-bottom:50px}.home-tab.svelte-1yjwmjb:not(.embedded) .home-tab-wordmark-container.svelte-1yjwmjb{padding-top:100px}.home-tab-wordmark.svelte-1yjwmjb h1.svelte-1yjwmjb{margin:unset}@media(max-width: 600px){.home-tab-wordmark-container.svelte-1yjwmjb.svelte-1yjwmjb{display:flex;flex-direction:column;justify-content:center}.home-tab-wordmark.svelte-1yjwmjb.svelte-1yjwmjb{text-align:center}}@media(max-height: 1000px){.home-tab.svelte-1yjwmjb:not(.embedded) .home-tab-wordmark-container.svelte-1yjwmjb{padding-top:10px}}");
}
function create_if_block_23(ctx) {
  let div1;
  let t0;
  let div0;
  let h1;
  let t1_value = ctx[5].wordmark + "";
  let t1;
  let if_block = !(ctx[5].logoType === "none") && create_if_block_33(ctx);
  return {
    c() {
      div1 = element("div");
      if (if_block)
        if_block.c();
      t0 = space();
      div0 = element("div");
      h1 = element("h1");
      t1 = text(t1_value);
      set_style(h1, "font-family", ctx[5].customFont === "interfaceFont" ? "var(--interface-font)" : ctx[5].customFont === "textFont" ? "var(--font-text)" : ctx[5].customFont === "monospaceFont" ? "var(--font-monospace)" : ctx[5].font);
      set_style(h1, "font-size", ctx[5].fontSize);
      set_style(h1, "font-weight", ctx[5].fontWeight.toString());
      set_style(h1, "color", ctx[5].fontColorType === "default" ? "" : ctx[5].fontColorType === "accentColor" ? "var(--interactive-accent)" : ctx[5].fontColor);
      attr(h1, "class", "svelte-1yjwmjb");
      attr(div0, "class", "home-tab-wordmark svelte-1yjwmjb");
      attr(div1, "class", "home-tab-wordmark-container svelte-1yjwmjb");
    },
    m(target, anchor) {
      insert(target, div1, anchor);
      if (if_block)
        if_block.m(div1, null);
      append(div1, t0);
      append(div1, div0);
      append(div0, h1);
      append(h1, t1);
    },
    p(ctx2, dirty) {
      if (!(ctx2[5].logoType === "none")) {
        if (if_block) {
          if_block.p(ctx2, dirty);
        } else {
          if_block = create_if_block_33(ctx2);
          if_block.c();
          if_block.m(div1, t0);
        }
      } else if (if_block) {
        if_block.d(1);
        if_block = null;
      }
      if (dirty & 32 && t1_value !== (t1_value = ctx2[5].wordmark + ""))
        set_data(t1, t1_value);
      if (dirty & 32) {
        set_style(h1, "font-family", ctx2[5].customFont === "interfaceFont" ? "var(--interface-font)" : ctx2[5].customFont === "textFont" ? "var(--font-text)" : ctx2[5].customFont === "monospaceFont" ? "var(--font-monospace)" : ctx2[5].font);
      }
      if (dirty & 32) {
        set_style(h1, "font-size", ctx2[5].fontSize);
      }
      if (dirty & 32) {
        set_style(h1, "font-weight", ctx2[5].fontWeight.toString());
      }
      if (dirty & 32) {
        set_style(h1, "color", ctx2[5].fontColorType === "default" ? "" : ctx2[5].fontColorType === "accentColor" ? "var(--interactive-accent)" : ctx2[5].fontColor);
      }
    },
    d(detaching) {
      if (detaching)
        detach(div1);
      if (if_block)
        if_block.d();
    }
  };
}
function create_if_block_33(ctx) {
  let div;
  function select_block_type(ctx2, dirty) {
    if (ctx2[5].logoType === "default")
      return create_if_block_43;
    if (ctx2[5].logoType === "oldLogo")
      return create_if_block_53;
    if (ctx2[5].logoType === "lucideIcon" && !!ctx2[5].logo.lucideIcon)
      return create_if_block_6;
    if (ctx2[5].logoType === "imagePath" && !!ctx2[5].logo.imagePath)
      return create_if_block_7;
    if (ctx2[5].logoType === "imageLink" && !!ctx2[5].logo.imageLink)
      return create_if_block_8;
  }
  let current_block_type = select_block_type(ctx, -1);
  let if_block = current_block_type && current_block_type(ctx);
  return {
    c() {
      div = element("div");
      if (if_block)
        if_block.c();
      attr(div, "class", "home-tab-logo svelte-1yjwmjb");
      set_style(div, "margin-right", "calc(" + ctx[5].fontSize + "/5)");
    },
    m(target, anchor) {
      insert(target, div, anchor);
      if (if_block)
        if_block.m(div, null);
    },
    p(ctx2, dirty) {
      if (current_block_type === (current_block_type = select_block_type(ctx2, dirty)) && if_block) {
        if_block.p(ctx2, dirty);
      } else {
        if (if_block)
          if_block.d(1);
        if_block = current_block_type && current_block_type(ctx2);
        if (if_block) {
          if_block.c();
          if_block.m(div, null);
        }
      }
      if (dirty & 32) {
        set_style(div, "margin-right", "calc(" + ctx2[5].fontSize + "/5)");
      }
    },
    d(detaching) {
      if (detaching)
        detach(div);
      if (if_block) {
        if_block.d();
      }
    }
  };
}
function create_if_block_8(ctx) {
  let img;
  let img_src_value;
  return {
    c() {
      img = element("img");
      if (!src_url_equal(img.src, img_src_value = ctx[5].logo.imageLink))
        attr(img, "src", img_src_value);
      attr(img, "alt", "home-tab-logo");
      set_style(img, "max-width", "calc(" + ctx[5].fontSize + "*" + ctx[5].logoScale + ")");
      set_style(img, "max-height", "calc(" + ctx[5].fontSize + "*" + ctx[5].logoScale + ")");
    },
    m(target, anchor) {
      insert(target, img, anchor);
    },
    p(ctx2, dirty) {
      if (dirty & 32 && !src_url_equal(img.src, img_src_value = ctx2[5].logo.imageLink)) {
        attr(img, "src", img_src_value);
      }
      if (dirty & 32) {
        set_style(img, "max-width", "calc(" + ctx2[5].fontSize + "*" + ctx2[5].logoScale + ")");
      }
      if (dirty & 32) {
        set_style(img, "max-height", "calc(" + ctx2[5].fontSize + "*" + ctx2[5].logoScale + ")");
      }
    },
    d(detaching) {
      if (detaching)
        detach(img);
    }
  };
}
function create_if_block_7(ctx) {
  let img;
  let img_src_value;
  return {
    c() {
      img = element("img");
      if (!src_url_equal(img.src, img_src_value = ctx[7].getResourcePath(ctx[5].logo.imagePath)))
        attr(img, "src", img_src_value);
      attr(img, "alt", "home-tab-logo");
      set_style(img, "max-width", "calc(" + ctx[5].fontSize + "*" + ctx[5].logoScale + ")");
      set_style(img, "max-height", "calc(" + ctx[5].fontSize + "*" + ctx[5].logoScale + ")");
    },
    m(target, anchor) {
      insert(target, img, anchor);
    },
    p(ctx2, dirty) {
      if (dirty & 32 && !src_url_equal(img.src, img_src_value = ctx2[7].getResourcePath(ctx2[5].logo.imagePath))) {
        attr(img, "src", img_src_value);
      }
      if (dirty & 32) {
        set_style(img, "max-width", "calc(" + ctx2[5].fontSize + "*" + ctx2[5].logoScale + ")");
      }
      if (dirty & 32) {
        set_style(img, "max-height", "calc(" + ctx2[5].fontSize + "*" + ctx2[5].logoScale + ")");
      }
    },
    d(detaching) {
      if (detaching)
        detach(img);
    }
  };
}
function create_if_block_6(ctx) {
  var _a;
  let svg;
  let raw_value = ((_a = (0, import_obsidian14.getIcon)(ctx[5].logo.lucideIcon)) == null ? void 0 : _a.innerHTML) + "";
  let svg_width_value;
  let svg_height_value;
  let svg_stroke_value;
  let svg_class_value;
  return {
    c() {
      svg = svg_element("svg");
      attr(svg, "xmlns", "http://www.w3.org/2000/svg");
      attr(svg, "width", svg_width_value = "calc(" + ctx[5].fontSize + "*" + ctx[5].logoScale + ")");
      attr(svg, "height", svg_height_value = "calc(" + ctx[5].fontSize + "*" + ctx[5].logoScale + ")");
      attr(svg, "viewBox", "0 0 24 24");
      attr(svg, "fill", "none");
      attr(svg, "stroke", svg_stroke_value = ctx[5].iconColorType === "default" ? "currentColor" : ctx[5].iconColorType === "accentColor" ? "var(--interactive-accent)" : ctx[5].iconColor);
      attr(svg, "stroke-width", "2");
      attr(svg, "stroke-linecap", "round");
      attr(svg, "stroke-linejoin", "round");
      attr(svg, "class", svg_class_value = "svg-icon lucide-" + ctx[5].logo.lucideIcon + " svelte-1yjwmjb");
    },
    m(target, anchor) {
      insert(target, svg, anchor);
      svg.innerHTML = raw_value;
    },
    p(ctx2, dirty) {
      var _a2;
      if (dirty & 32 && raw_value !== (raw_value = ((_a2 = (0, import_obsidian14.getIcon)(ctx2[5].logo.lucideIcon)) == null ? void 0 : _a2.innerHTML) + ""))
        svg.innerHTML = raw_value;
      ;
      if (dirty & 32 && svg_width_value !== (svg_width_value = "calc(" + ctx2[5].fontSize + "*" + ctx2[5].logoScale + ")")) {
        attr(svg, "width", svg_width_value);
      }
      if (dirty & 32 && svg_height_value !== (svg_height_value = "calc(" + ctx2[5].fontSize + "*" + ctx2[5].logoScale + ")")) {
        attr(svg, "height", svg_height_value);
      }
      if (dirty & 32 && svg_stroke_value !== (svg_stroke_value = ctx2[5].iconColorType === "default" ? "currentColor" : ctx2[5].iconColorType === "accentColor" ? "var(--interactive-accent)" : ctx2[5].iconColor)) {
        attr(svg, "stroke", svg_stroke_value);
      }
      if (dirty & 32 && svg_class_value !== (svg_class_value = "svg-icon lucide-" + ctx2[5].logo.lucideIcon + " svelte-1yjwmjb")) {
        attr(svg, "class", svg_class_value);
      }
    },
    d(detaching) {
      if (detaching)
        detach(svg);
    }
  };
}
function create_if_block_53(ctx) {
  let svg;
  let defs;
  let linearGradient;
  let stop0;
  let stop1;
  let linearGradient_id_value;
  let polygon0;
  let polygon1;
  let polygon1_fill_value;
  let polygon2;
  let polygon3;
  let polygon4;
  let svg_width_value;
  let svg_height_value;
  return {
    c() {
      svg = svg_element("svg");
      defs = svg_element("defs");
      linearGradient = svg_element("linearGradient");
      stop0 = svg_element("stop");
      stop1 = svg_element("stop");
      polygon0 = svg_element("polygon");
      polygon1 = svg_element("polygon");
      polygon2 = svg_element("polygon");
      polygon3 = svg_element("polygon");
      polygon4 = svg_element("polygon");
      attr(stop0, "offset", "0");
      attr(stop0, "stop-color", "#6c56cc");
      attr(stop1, "offset", "1");
      attr(stop1, "stop-color", "#9785e5");
      attr(linearGradient, "id", linearGradient_id_value = ctx[8].toString());
      attr(linearGradient, "x1", "82.85");
      attr(linearGradient, "y1", "30.41");
      attr(linearGradient, "x2", "51.26");
      attr(linearGradient, "y2", "105.9");
      attr(linearGradient, "gradientTransform", "matrix(1, 0, 0, -1, -22.41, 110.97)");
      attr(linearGradient, "gradientUnits", "userSpaceOnUse");
      attr(polygon0, "points", "44.61 0 12.91 17.52 0 45.45 19.57 90.47 47.35 100 52.44 89.8 63 26.39 44.61 0");
      attr(polygon0, "fill", "#34208c");
      attr(polygon1, "points", "63 26.39 43.44 14.41 16.43 35.7 47.35 100 52.44 89.8 63 26.39");
      attr(polygon1, "fill", polygon1_fill_value = "url(#" + ctx[8] + ")");
      attr(polygon2, "points", "63 26.39 63 26.39 44.61 0 43.44 14.41 63 26.39");
      attr(polygon2, "fill", "#af9ff4");
      attr(polygon3, "points", "43.44 14.41 44.61 0 12.91 17.52 16.43 35.7 43.44 14.41");
      attr(polygon3, "fill", "#4a37a0");
      attr(polygon4, "points", "16.43 35.7 19.57 90.47 47.35 100 16.43 35.7");
      attr(polygon4, "fill", "#4a37a0");
      attr(svg, "viewBox", "0 0 65 100");
      attr(svg, "width", svg_width_value = "calc(" + ctx[5].fontSize + "*" + ctx[5].logoScale + ")");
      attr(svg, "height", svg_height_value = "calc(" + ctx[5].fontSize + "*" + ctx[5].logoScale + ")");
      attr(svg, "class", "svelte-1yjwmjb");
    },
    m(target, anchor) {
      insert(target, svg, anchor);
      append(svg, defs);
      append(defs, linearGradient);
      append(linearGradient, stop0);
      append(linearGradient, stop1);
      append(svg, polygon0);
      append(svg, polygon1);
      append(svg, polygon2);
      append(svg, polygon3);
      append(svg, polygon4);
    },
    p(ctx2, dirty) {
      if (dirty & 32 && svg_width_value !== (svg_width_value = "calc(" + ctx2[5].fontSize + "*" + ctx2[5].logoScale + ")")) {
        attr(svg, "width", svg_width_value);
      }
      if (dirty & 32 && svg_height_value !== (svg_height_value = "calc(" + ctx2[5].fontSize + "*" + ctx2[5].logoScale + ")")) {
        attr(svg, "height", svg_height_value);
      }
    },
    d(detaching) {
      if (detaching)
        detach(svg);
    }
  };
}
function create_if_block_43(ctx) {
  let svg;
  let defs;
  let radialGradient0;
  let stop0;
  let stop1;
  let radialGradient1;
  let stop2;
  let stop3;
  let radialGradient2;
  let stop4;
  let stop5;
  let radialGradient3;
  let stop6;
  let stop7;
  let radialGradient4;
  let stop8;
  let stop9;
  let radialGradient5;
  let stop10;
  let stop11;
  let radialGradient6;
  let stop12;
  let stop13;
  let radialGradient7;
  let stop14;
  let stop15;
  let stop16;
  let filter;
  let feFlood;
  let feBlend;
  let feGaussianBlur;
  let g;
  let path0;
  let path1;
  let path2;
  let path3;
  let path4;
  let path5;
  let path6;
  let path7;
  let path8;
  let path9;
  let svg_width_value;
  let svg_height_value;
  return {
    c() {
      svg = svg_element("svg");
      defs = svg_element("defs");
      radialGradient0 = svg_element("radialGradient");
      stop0 = svg_element("stop");
      stop1 = svg_element("stop");
      radialGradient1 = svg_element("radialGradient");
      stop2 = svg_element("stop");
      stop3 = svg_element("stop");
      radialGradient2 = svg_element("radialGradient");
      stop4 = svg_element("stop");
      stop5 = svg_element("stop");
      radialGradient3 = svg_element("radialGradient");
      stop6 = svg_element("stop");
      stop7 = svg_element("stop");
      radialGradient4 = svg_element("radialGradient");
      stop8 = svg_element("stop");
      stop9 = svg_element("stop");
      radialGradient5 = svg_element("radialGradient");
      stop10 = svg_element("stop");
      stop11 = svg_element("stop");
      radialGradient6 = svg_element("radialGradient");
      stop12 = svg_element("stop");
      stop13 = svg_element("stop");
      radialGradient7 = svg_element("radialGradient");
      stop14 = svg_element("stop");
      stop15 = svg_element("stop");
      stop16 = svg_element("stop");
      filter = svg_element("filter");
      feFlood = svg_element("feFlood");
      feBlend = svg_element("feBlend");
      feGaussianBlur = svg_element("feGaussianBlur");
      g = svg_element("g");
      path0 = svg_element("path");
      path1 = svg_element("path");
      path2 = svg_element("path");
      path3 = svg_element("path");
      path4 = svg_element("path");
      path5 = svg_element("path");
      path6 = svg_element("path");
      path7 = svg_element("path");
      path8 = svg_element("path");
      path9 = svg_element("path");
      attr(stop0, "stop-color", "#fff");
      attr(stop0, "stop-opacity", ".4");
      attr(stop1, "offset", "1");
      attr(stop1, "stop-opacity", ".1");
      attr(radialGradient0, "id", "b");
      attr(radialGradient0, "cx", "0");
      attr(radialGradient0, "cy", "0");
      attr(radialGradient0, "r", "1");
      attr(radialGradient0, "gradientUnits", "userSpaceOnUse");
      attr(radialGradient0, "gradientTransform", "matrix(-48 -185 123 -32 179 429.7)");
      attr(stop2, "stop-color", "#fff");
      attr(stop2, "stop-opacity", ".6");
      attr(stop3, "offset", "1");
      attr(stop3, "stop-color", "#fff");
      attr(stop3, "stop-opacity", ".1");
      attr(radialGradient1, "id", "c");
      attr(radialGradient1, "cx", "0");
      attr(radialGradient1, "cy", "0");
      attr(radialGradient1, "r", "1");
      attr(radialGradient1, "gradientUnits", "userSpaceOnUse");
      attr(radialGradient1, "gradientTransform", "matrix(41 -310 229 30 341.6 351.3)");
      attr(stop4, "stop-color", "#fff");
      attr(stop4, "stop-opacity", ".8");
      attr(stop5, "offset", "1");
      attr(stop5, "stop-color", "#fff");
      attr(stop5, "stop-opacity", ".4");
      attr(radialGradient2, "id", "d");
      attr(radialGradient2, "cx", "0");
      attr(radialGradient2, "cy", "0");
      attr(radialGradient2, "r", "1");
      attr(radialGradient2, "gradientUnits", "userSpaceOnUse");
      attr(radialGradient2, "gradientTransform", "matrix(57 -261 178 39 190.5 296.3)");
      attr(stop6, "stop-color", "#fff");
      attr(stop6, "stop-opacity", ".3");
      attr(stop7, "offset", "1");
      attr(stop7, "stop-opacity", ".3");
      attr(radialGradient3, "id", "e");
      attr(radialGradient3, "cx", "0");
      attr(radialGradient3, "cy", "0");
      attr(radialGradient3, "r", "1");
      attr(radialGradient3, "gradientUnits", "userSpaceOnUse");
      attr(radialGradient3, "gradientTransform", "matrix(-79 -133 153 -90 321.4 464.2)");
      attr(stop8, "stop-color", "#fff");
      attr(stop8, "stop-opacity", "0");
      attr(stop9, "offset", "1");
      attr(stop9, "stop-color", "#fff");
      attr(stop9, "stop-opacity", ".2");
      attr(radialGradient4, "id", "f");
      attr(radialGradient4, "cx", "0");
      attr(radialGradient4, "cy", "0");
      attr(radialGradient4, "r", "1");
      attr(radialGradient4, "gradientUnits", "userSpaceOnUse");
      attr(radialGradient4, "gradientTransform", "matrix(-29 136 -92 -20 300.7 149.9)");
      attr(stop10, "stop-color", "#fff");
      attr(stop10, "stop-opacity", ".2");
      attr(stop11, "offset", "1");
      attr(stop11, "stop-color", "#fff");
      attr(stop11, "stop-opacity", ".4");
      attr(radialGradient5, "id", "g");
      attr(radialGradient5, "cx", "0");
      attr(radialGradient5, "cy", "0");
      attr(radialGradient5, "r", "1");
      attr(radialGradient5, "gradientUnits", "userSpaceOnUse");
      attr(radialGradient5, "gradientTransform", "matrix(72 73 -155 153 137.8 225.2)");
      attr(stop12, "stop-color", "#fff");
      attr(stop12, "stop-opacity", ".1");
      attr(stop13, "offset", "1");
      attr(stop13, "stop-color", "#fff");
      attr(stop13, "stop-opacity", ".3");
      attr(radialGradient6, "id", "h");
      attr(radialGradient6, "cx", "0");
      attr(radialGradient6, "cy", "0");
      attr(radialGradient6, "r", "1");
      attr(radialGradient6, "gradientUnits", "userSpaceOnUse");
      attr(radialGradient6, "gradientTransform", "matrix(20 118 -251 43 215.1 273.7)");
      attr(stop14, "stop-color", "#fff");
      attr(stop14, "stop-opacity", ".2");
      attr(stop15, "offset", ".5");
      attr(stop15, "stop-color", "#fff");
      attr(stop15, "stop-opacity", ".2");
      attr(stop16, "offset", "1");
      attr(stop16, "stop-color", "#fff");
      attr(stop16, "stop-opacity", ".3");
      attr(radialGradient7, "id", "i");
      attr(radialGradient7, "cx", "0");
      attr(radialGradient7, "cy", "0");
      attr(radialGradient7, "r", "1");
      attr(radialGradient7, "gradientUnits", "userSpaceOnUse");
      attr(radialGradient7, "gradientTransform", "matrix(-162 -85 268 -510 374.4 371.7)");
      attr(feFlood, "flood-opacity", "0");
      attr(feFlood, "result", "BackgroundImageFix");
      attr(feBlend, "in", "SourceGraphic");
      attr(feBlend, "in2", "BackgroundImageFix");
      attr(feBlend, "result", "shape");
      attr(feGaussianBlur, "stdDeviation", "6.5");
      attr(feGaussianBlur, "result", "effect1_foregroundBlur_744_9191");
      attr(filter, "id", "a");
      attr(filter, "x", "80.1");
      attr(filter, "y", "37");
      attr(filter, "width", "351.1");
      attr(filter, "height", "443.2");
      attr(filter, "filterUnits", "userSpaceOnUse");
      attr(filter, "color-interpolation-filters", "sRGB");
      attr(path0, "d", "M359.2 437.5c-2.6 19-21.3 33.9-40 28.7-26.5-7.2-57.2-18.6-84.8-20.7l-42.4-3.2a28 28 0 0 1-18-8.3l-73-74.8a27.7 27.7 0 0 1-5.4-30.7s45-98.6 46.8-103.7c1.6-5.1 7.8-49.9 11.4-73.9a28 28 0 0 1 9-16.5L249 57.2a28 28 0 0 1 40.6 3.4l72.6 91.6a29.5 29.5 0 0 1 6.2 18.3c0 17.3 1.5 53 11.2 76a301.3 301.3 0 0 0 35.6 58.2 14 14 0 0 1 1 15.6c-6.3 10.7-18.9 31.3-36.6 57.6a142.2 142.2 0 0 0-20.5 59.6Z");
      attr(path0, "fill", "#000");
      attr(path0, "fill-opacity", ".3");
      attr(g, "filter", "url(#a)");
      attr(path1, "id", "arrow");
      attr(path1, "d", "M359.9 434.3c-2.6 19.1-21.3 34-40 28.9-26.4-7.3-57-18.7-84.7-20.8l-42.3-3.2a27.9 27.9 0 0 1-18-8.4l-73-75a27.9 27.9 0 0 1-5.4-31s45.1-99 46.8-104.2c1.7-5.1 7.8-50 11.4-74.2a28 28 0 0 1 9-16.6l86.2-77.5a28 28 0 0 1 40.6 3.5l72.5 92a29.7 29.7 0 0 1 6.2 18.3c0 17.4 1.5 53.2 11.1 76.3a303 303 0 0 0 35.6 58.5 14 14 0 0 1 1.1 15.7c-6.4 10.8-18.9 31.4-36.7 57.9a143.3 143.3 0 0 0-20.4 59.8Z");
      attr(path1, "fill", "#6C31E3");
      attr(path2, "d", "M182.7 436.4c33.9-68.7 33-118 18.5-153-13.2-32.4-37.9-52.8-57.3-65.5-.4 1.9-1 3.7-1.8 5.4L96.5 324.8a27.9 27.9 0 0 0 5.5 31l72.9 75c2.3 2.3 5 4.2 7.8 5.6Z");
      attr(path2, "fill", "url(#b)");
      attr(path3, "d", "M274.9 297c9.1.9 18 2.9 26.8 6.1 27.8 10.4 53.1 33.8 74 78.9 1.5-2.6 3-5.1 4.6-7.5a1222 1222 0 0 0 36.7-57.9 14 14 0 0 0-1-15.7 303 303 0 0 1-35.7-58.5c-9.6-23-11-58.9-11.1-76.3 0-6.6-2.1-13.1-6.2-18.3l-72.5-92-1.2-1.5c5.3 17.5 5 31.5 1.7 44.2-3 11.8-8.6 22.5-14.5 33.8-2 3.8-4 7.7-5.9 11.7a140 140 0 0 0-15.8 58c-1 24.2 3.9 54.5 20 95Z");
      attr(path3, "fill", "url(#c)");
      attr(path4, "d", "M274.8 297c-16.1-40.5-21-70.8-20-95 1-24 8-42 15.8-58l6-11.7c5.8-11.3 11.3-22 14.4-33.8a78.5 78.5 0 0 0-1.7-44.2 28 28 0 0 0-39.4-2l-86.2 77.5a28 28 0 0 0-9 16.6L144.2 216c0 .7-.2 1.3-.3 2 19.4 12.6 44 33 57.3 65.3 2.6 6.4 4.8 13.1 6.4 20.4a200 200 0 0 1 67.2-6.8Z");
      attr(path4, "fill", "url(#d)");
      attr(path5, "d", "M320 463.2c18.6 5.1 37.3-9.8 39.9-29a153 153 0 0 1 15.9-52.2c-21-45.1-46.3-68.5-74-78.9-29.5-11-61.6-7.3-94.2.6 7.3 33.1 3 76.4-24.8 132.7 3.1 1.6 6.6 2.5 10.1 2.8l43.9 3.3c23.8 1.7 59.3 14 83.2 20.7Z");
      attr(path5, "fill", "url(#e)");
      attr(path6, "fill-rule", "evenodd");
      attr(path6, "clip-rule", "evenodd");
      attr(path6, "d", "M255 200.5c-1.1 24 1.9 51.4 18 91.8l-5-.5c-14.5-42.1-17.7-63.7-16.6-88 1-24.3 8.9-43 16.7-59 2-4 6.6-11.5 8.6-15.3 5.8-11.3 9.7-17.2 13-27.5 4.8-14.4 3.8-21.2 3.2-28 3.7 24.5-10.4 45.8-21 67.5a145 145 0 0 0-17 59Z");
      attr(path6, "fill", "url(#f)");
      attr(path7, "fill-rule", "evenodd");
      attr(path7, "clip-rule", "evenodd");
      attr(path7, "d", "M206 285.1c2 4.4 3.7 8 4.9 13.5l-4.3 1c-1.7-6.4-3-11-5.5-16.5-14.6-34.3-38-52-57-65 23 12.4 46.7 31.9 61.9 67Z");
      attr(path7, "fill", "url(#g)");
      attr(path8, "fill-rule", "evenodd");
      attr(path8, "clip-rule", "evenodd");
      attr(path8, "d", "M211.1 303c8 37.5-1 85.2-27.5 131.6 22.2-46 33-90.1 24-131l3.5-.7Z");
      attr(path8, "fill", "url(#h)");
      attr(path9, "fill-rule", "evenodd");
      attr(path9, "clip-rule", "evenodd");
      attr(path9, "d", "M302.7 299.5c43.5 16.3 60.3 52 72.8 81.9-15.5-31.2-37-65.7-74.4-78.5-28.4-9.8-52.4-8.6-93.5.7l-.9-4c43.6-10 66.4-11.2 96 0Z");
      attr(path9, "fill", "url(#i)");
      attr(svg, "width", svg_width_value = "calc(" + ctx[5].fontSize + "*" + ctx[5].logoScale + ")");
      attr(svg, "height", svg_height_value = "calc(" + ctx[5].fontSize + "*" + ctx[5].logoScale + ")");
      attr(svg, "viewBox", "0 0 512 512");
      attr(svg, "fill", "none");
      attr(svg, "xmlns", "http://www.w3.org/2000/svg");
      attr(svg, "class", "svelte-1yjwmjb");
    },
    m(target, anchor) {
      insert(target, svg, anchor);
      append(svg, defs);
      append(defs, radialGradient0);
      append(radialGradient0, stop0);
      append(radialGradient0, stop1);
      append(defs, radialGradient1);
      append(radialGradient1, stop2);
      append(radialGradient1, stop3);
      append(defs, radialGradient2);
      append(radialGradient2, stop4);
      append(radialGradient2, stop5);
      append(defs, radialGradient3);
      append(radialGradient3, stop6);
      append(radialGradient3, stop7);
      append(defs, radialGradient4);
      append(radialGradient4, stop8);
      append(radialGradient4, stop9);
      append(defs, radialGradient5);
      append(radialGradient5, stop10);
      append(radialGradient5, stop11);
      append(defs, radialGradient6);
      append(radialGradient6, stop12);
      append(radialGradient6, stop13);
      append(defs, radialGradient7);
      append(radialGradient7, stop14);
      append(radialGradient7, stop15);
      append(radialGradient7, stop16);
      append(defs, filter);
      append(filter, feFlood);
      append(filter, feBlend);
      append(filter, feGaussianBlur);
      append(svg, g);
      append(g, path0);
      append(svg, path1);
      append(svg, path2);
      append(svg, path3);
      append(svg, path4);
      append(svg, path5);
      append(svg, path6);
      append(svg, path7);
      append(svg, path8);
      append(svg, path9);
    },
    p(ctx2, dirty) {
      if (dirty & 32 && svg_width_value !== (svg_width_value = "calc(" + ctx2[5].fontSize + "*" + ctx2[5].logoScale + ")")) {
        attr(svg, "width", svg_width_value);
      }
      if (dirty & 32 && svg_height_value !== (svg_height_value = "calc(" + ctx2[5].fontSize + "*" + ctx2[5].logoScale + ")")) {
        attr(svg, "height", svg_height_value);
      }
    },
    d(detaching) {
      if (detaching)
        detach(svg);
    }
  };
}
function create_if_block_15(ctx) {
  let bookmarkedfiles;
  let current;
  bookmarkedfiles = new bookmarkedFiles_default({
    props: {
      bookmarkedFiles: ctx[4],
      view: ctx[0],
      pluginSettings: ctx[5],
      bookmarkedFileManager: ctx[2].bookmarkedFileManager
    }
  });
  return {
    c() {
      create_component(bookmarkedfiles.$$.fragment);
    },
    m(target, anchor) {
      mount_component(bookmarkedfiles, target, anchor);
      current = true;
    },
    p(ctx2, dirty) {
      const bookmarkedfiles_changes = {};
      if (dirty & 16)
        bookmarkedfiles_changes.bookmarkedFiles = ctx2[4];
      if (dirty & 1)
        bookmarkedfiles_changes.view = ctx2[0];
      if (dirty & 32)
        bookmarkedfiles_changes.pluginSettings = ctx2[5];
      if (dirty & 4)
        bookmarkedfiles_changes.bookmarkedFileManager = ctx2[2].bookmarkedFileManager;
      bookmarkedfiles.$set(bookmarkedfiles_changes);
    },
    i(local) {
      if (current)
        return;
      transition_in(bookmarkedfiles.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(bookmarkedfiles.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      destroy_component(bookmarkedfiles, detaching);
    }
  };
}
function create_if_block7(ctx) {
  let recentfiles;
  let current;
  recentfiles = new recentFiles_default({
    props: {
      recentFileList: ctx[6],
      view: ctx[0],
      pluginSettings: ctx[5],
      recentFileManager: ctx[2].recentFileManager
    }
  });
  return {
    c() {
      create_component(recentfiles.$$.fragment);
    },
    m(target, anchor) {
      mount_component(recentfiles, target, anchor);
      current = true;
    },
    p(ctx2, dirty) {
      const recentfiles_changes = {};
      if (dirty & 64)
        recentfiles_changes.recentFileList = ctx2[6];
      if (dirty & 1)
        recentfiles_changes.view = ctx2[0];
      if (dirty & 32)
        recentfiles_changes.pluginSettings = ctx2[5];
      if (dirty & 4)
        recentfiles_changes.recentFileManager = ctx2[2].recentFileManager;
      recentfiles.$set(recentfiles_changes);
    },
    i(local) {
      if (current)
        return;
      transition_in(recentfiles.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(recentfiles.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      destroy_component(recentfiles, detaching);
    }
  };
}
function create_fragment24(ctx) {
  var _a;
  let main2;
  let t0;
  let searchbar;
  let t1;
  let t2;
  let current;
  let if_block0 = !((_a = ctx[3]) == null ? void 0 : _a.searchbarOnly) && create_if_block_23(ctx);
  searchbar = new searchBar_default({
    props: {
      HomeTabSearchBar: ctx[1],
      embedded: ctx[3] ? true : false
    }
  });
  let if_block1 = ctx[9] && ctx[4] && ctx[11] && create_if_block_15(ctx);
  let if_block2 = ctx[2].recentFileManager && ctx[6].length > 0 && ctx[10] && create_if_block7(ctx);
  return {
    c() {
      main2 = element("main");
      if (if_block0)
        if_block0.c();
      t0 = space();
      create_component(searchbar.$$.fragment);
      t1 = space();
      if (if_block1)
        if_block1.c();
      t2 = space();
      if (if_block2)
        if_block2.c();
      attr(main2, "class", "home-tab svelte-1yjwmjb");
      toggle_class(main2, "embedded", ctx[3]);
    },
    m(target, anchor) {
      insert(target, main2, anchor);
      if (if_block0)
        if_block0.m(main2, null);
      append(main2, t0);
      mount_component(searchbar, main2, null);
      append(main2, t1);
      if (if_block1)
        if_block1.m(main2, null);
      append(main2, t2);
      if (if_block2)
        if_block2.m(main2, null);
      current = true;
    },
    p(ctx2, [dirty]) {
      var _a2;
      if (!((_a2 = ctx2[3]) == null ? void 0 : _a2.searchbarOnly)) {
        if (if_block0) {
          if_block0.p(ctx2, dirty);
        } else {
          if_block0 = create_if_block_23(ctx2);
          if_block0.c();
          if_block0.m(main2, t0);
        }
      } else if (if_block0) {
        if_block0.d(1);
        if_block0 = null;
      }
      const searchbar_changes = {};
      if (dirty & 2)
        searchbar_changes.HomeTabSearchBar = ctx2[1];
      if (dirty & 8)
        searchbar_changes.embedded = ctx2[3] ? true : false;
      searchbar.$set(searchbar_changes);
      if (ctx2[9] && ctx2[4] && ctx2[11]) {
        if (if_block1) {
          if_block1.p(ctx2, dirty);
          if (dirty & 16) {
            transition_in(if_block1, 1);
          }
        } else {
          if_block1 = create_if_block_15(ctx2);
          if_block1.c();
          transition_in(if_block1, 1);
          if_block1.m(main2, t2);
        }
      } else if (if_block1) {
        group_outros();
        transition_out(if_block1, 1, 1, () => {
          if_block1 = null;
        });
        check_outros();
      }
      if (ctx2[2].recentFileManager && ctx2[6].length > 0 && ctx2[10]) {
        if (if_block2) {
          if_block2.p(ctx2, dirty);
          if (dirty & 68) {
            transition_in(if_block2, 1);
          }
        } else {
          if_block2 = create_if_block7(ctx2);
          if_block2.c();
          transition_in(if_block2, 1);
          if_block2.m(main2, null);
        }
      } else if (if_block2) {
        group_outros();
        transition_out(if_block2, 1, 1, () => {
          if_block2 = null;
        });
        check_outros();
      }
      if (!current || dirty & 8) {
        toggle_class(main2, "embedded", ctx2[3]);
      }
    },
    i(local) {
      if (current)
        return;
      transition_in(searchbar.$$.fragment, local);
      transition_in(if_block1);
      transition_in(if_block2);
      current = true;
    },
    o(local) {
      transition_out(searchbar.$$.fragment, local);
      transition_out(if_block1);
      transition_out(if_block2);
      current = false;
    },
    d(detaching) {
      if (detaching)
        detach(main2);
      if (if_block0)
        if_block0.d();
      destroy_component(searchbar);
      if (if_block1)
        if_block1.d();
      if (if_block2)
        if_block2.d();
    }
  };
}
function instance24($$self, $$props, $$invalidate) {
  let { view } = $$props;
  let { HomeTabSearchBar: HomeTabSearchBar2 } = $$props;
  let { plugin } = $$props;
  let { embeddedView = void 0 } = $$props;
  let bookmarkedFileList = [];
  let pluginSettings;
  let recentFileList = [];
  pluginSettingsStore.subscribe((settings) => {
    $$invalidate(5, pluginSettings = settings);
    if (pluginSettings.showbookmarkedFiles) {
      bookmarkedFiles.subscribe((files) => $$invalidate(4, bookmarkedFileList = files));
    }
    if (pluginSettings.showRecentFiles) {
      recentFiles.subscribe((files) => $$invalidate(6, recentFileList = files));
    }
  });
  const vaultAdapter = app.vault.adapter;
  const gradientUniqueId = Math.random();
  const isbookmarkedPluginEnabled = app.internalPlugins.getPluginById("bookmarks") ? true : false;
  const renderRecentFiles = embeddedView ? embeddedView.recentFiles : pluginSettings.showRecentFiles;
  const renderbookmarkedFiles = embeddedView ? embeddedView.bookmarkedFiles : pluginSettings.showbookmarkedFiles;
  $$self.$$set = ($$props2) => {
    if ("view" in $$props2)
      $$invalidate(0, view = $$props2.view);
    if ("HomeTabSearchBar" in $$props2)
      $$invalidate(1, HomeTabSearchBar2 = $$props2.HomeTabSearchBar);
    if ("plugin" in $$props2)
      $$invalidate(2, plugin = $$props2.plugin);
    if ("embeddedView" in $$props2)
      $$invalidate(3, embeddedView = $$props2.embeddedView);
  };
  return [
    view,
    HomeTabSearchBar2,
    plugin,
    embeddedView,
    bookmarkedFileList,
    pluginSettings,
    recentFileList,
    vaultAdapter,
    gradientUniqueId,
    isbookmarkedPluginEnabled,
    renderRecentFiles,
    renderbookmarkedFiles
  ];
}
var Homepage = class extends SvelteComponent {
  constructor(options) {
    super();
    init(this, options, instance24, create_fragment24, safe_not_equal, {
      view: 0,
      HomeTabSearchBar: 1,
      plugin: 2,
      embeddedView: 3
    }, add_css6);
  }
};
var homepage_default = Homepage;

// src/homeView.ts
var VIEW_TYPE = "home-tab-view";
var EmbeddedHomeTab = class extends import_obsidian15.MarkdownRenderChild {
  constructor(containerEl, view, plugin, codeBlockContent) {
    super(containerEl);
    this.view = view;
    this.plugin = plugin;
    this.parseCodeBlockContent(codeBlockContent);
    this.searchBar = new HomeTabSearchBar(plugin, view);
  }
  onload() {
    this.homepage = new homepage_default({
      target: this.containerEl,
      props: {
        plugin: this.plugin,
        view: this.view,
        HomeTabSearchBar: this.searchBar,
        embeddedView: this
      }
    });
    this.searchBar.load();
  }
  onunload() {
    this.plugin.activeEmbeddedHomeTabViews.splice(this.plugin.activeEmbeddedHomeTabViews.findIndex((item) => item.view == this.view), 1);
    this.searchBar.fileSuggester.close();
    this.homepage.$destroy();
  }
  parseCodeBlockContent(codeBlockContent) {
    codeBlockContent.split("\n").map((line) => line.trim()).forEach((line) => {
      switch (true) {
        case line === "":
          break;
        case line === "only search bar":
          this.searchbarOnly = true;
          break;
        case line === "show recent files":
          this.recentFiles = true;
          break;
        case line === "show bookmarked files":
          this.bookmarkedFiles = true;
          break;
      }
    });
  }
};
var HomeTabView = class extends import_obsidian15.FileView {
  constructor(leaf, plugin) {
    super(leaf);
    this.leaf = leaf;
    this.plugin = plugin;
    this.navigation = true;
    this.allowNoFile = true;
    this.icon = "search";
    this.searchBar = new HomeTabSearchBar(this.plugin, this);
  }
  getViewType() {
    return VIEW_TYPE;
  }
  getDisplayText() {
    return "Home tab";
  }
  async onOpen() {
    this.homepage = new homepage_default({
      target: this.contentEl,
      props: {
        plugin: this.plugin,
        view: this,
        HomeTabSearchBar: this.searchBar
      }
    });
    this.searchBar.load();
    this.searchBar.focusSearchbar();
  }
  async onClose() {
    this.searchBar.fileSuggester.close();
    this.homepage.$destroy();
  }
};

// src/settings.ts
var import_obsidian16 = require("obsidian");

// src/ui/svelteComponents/fileSuggestion.svelte
function create_suggestion_title_slot5(ctx) {
  var _a;
  let t_value = ((_a = ctx[4]) != null ? _a : ctx[3].item.basename) + "";
  let t;
  return {
    c() {
      t = text(t_value);
    },
    m(target, anchor) {
      insert(target, t, anchor);
    },
    p(ctx2, dirty) {
      var _a2;
      if (dirty & 24 && t_value !== (t_value = ((_a2 = ctx2[4]) != null ? _a2 : ctx2[3].item.basename) + ""))
        set_data(t, t_value);
    },
    d(detaching) {
      if (detaching)
        detach(t);
    }
  };
}
function create_fragment25(ctx) {
  let suggestion_1;
  let current;
  suggestion_1 = new suggestion_default({
    props: {
      index: ctx[0],
      textInputSuggester: ctx[1],
      selectedItemIndex: ctx[2],
      $$slots: {
        "suggestion-title": [create_suggestion_title_slot5]
      },
      $$scope: { ctx }
    }
  });
  return {
    c() {
      create_component(suggestion_1.$$.fragment);
    },
    m(target, anchor) {
      mount_component(suggestion_1, target, anchor);
      current = true;
    },
    p(ctx2, [dirty]) {
      const suggestion_1_changes = {};
      if (dirty & 1)
        suggestion_1_changes.index = ctx2[0];
      if (dirty & 2)
        suggestion_1_changes.textInputSuggester = ctx2[1];
      if (dirty & 4)
        suggestion_1_changes.selectedItemIndex = ctx2[2];
      if (dirty & 56) {
        suggestion_1_changes.$$scope = { dirty, ctx: ctx2 };
      }
      suggestion_1.$set(suggestion_1_changes);
    },
    i(local) {
      if (current)
        return;
      transition_in(suggestion_1.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(suggestion_1.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      destroy_component(suggestion_1, detaching);
    }
  };
}
function instance25($$self, $$props, $$invalidate) {
  let { index } = $$props;
  let { textInputSuggester } = $$props;
  let { selectedItemIndex } = $$props;
  let { suggestion } = $$props;
  let { displayName = void 0 } = $$props;
  $$self.$$set = ($$props2) => {
    if ("index" in $$props2)
      $$invalidate(0, index = $$props2.index);
    if ("textInputSuggester" in $$props2)
      $$invalidate(1, textInputSuggester = $$props2.textInputSuggester);
    if ("selectedItemIndex" in $$props2)
      $$invalidate(2, selectedItemIndex = $$props2.selectedItemIndex);
    if ("suggestion" in $$props2)
      $$invalidate(3, suggestion = $$props2.suggestion);
    if ("displayName" in $$props2)
      $$invalidate(4, displayName = $$props2.displayName);
  };
  return [index, textInputSuggester, selectedItemIndex, suggestion, displayName];
}
var FileSuggestion = class extends SvelteComponent {
  constructor(options) {
    super();
    init(this, options, instance25, create_fragment25, safe_not_equal, {
      index: 0,
      textInputSuggester: 1,
      selectedItemIndex: 2,
      suggestion: 3,
      displayName: 4
    });
  }
};
var fileSuggestion_default = FileSuggestion;

// src/suggester/imageSuggester.ts
var ImageFileSuggester = class extends PopoverTextInputSuggester {
  constructor(app2, inputEl, viewOptions) {
    super(app2, inputEl, viewOptions);
    this.fuzzySearch = new ImageFileFuzzySearch(void 0, { ...DEFAULT_FUSE_OPTIONS, ignoreLocation: true, keys: ["name"] });
  }
  getSuggestions(input) {
    return this.fuzzySearch.filteredSearch(input, 0.25, 15);
  }
  useSelectedItem(selectedItem) {
    this.inputEl.value = selectedItem.item.path;
    this.inputEl.trigger("input");
    this.onInput().then(() => this.close());
  }
  getDisplayElementComponentType() {
    return fileSuggestion_default;
  }
  getDisplayElementProps(suggestion) {
    return { displayName: suggestion.item.name };
  }
};

// src/utils/cssUnitValidator.ts
function cssUnitValidator(inputString) {
  const regex = /\d+(?:cm|mm|in|px|pt|pc|em|ex|ch|rem|vw|vh|vmin|vmax|%)(?!.)/g;
  if (regex.test(inputString)) {
    return true;
  }
  return false;
}

// src/utils/isLink.ts
function isLink(string) {
  const urlPattern = /(?:https?):\/\/(\w+:?\w*)?(\S+)(:\d+)?(\/|\/([\w#!:.?+=&%!\-\/]))?/;
  return !!urlPattern.test(string);
}

// src/suggester/fontSuggester.ts
var import_font_list = __toESM(require_font_list());

// src/ui/svelteComponents/fontSuggestion.svelte
function create_suggestion_title_slot6(ctx) {
  let span;
  let t;
  let span_style_value;
  return {
    c() {
      span = element("span");
      t = text(ctx[5]);
      attr(span, "style", span_style_value = ctx[4] ? `font-family: ${ctx[3].item}` : "");
    },
    m(target, anchor) {
      insert(target, span, anchor);
      append(span, t);
    },
    p(ctx2, dirty) {
      if (dirty & 32)
        set_data(t, ctx2[5]);
      if (dirty & 24 && span_style_value !== (span_style_value = ctx2[4] ? `font-family: ${ctx2[3].item}` : "")) {
        attr(span, "style", span_style_value);
      }
    },
    d(detaching) {
      if (detaching)
        detach(span);
    }
  };
}
function create_fragment26(ctx) {
  let suggestion_1;
  let current;
  suggestion_1 = new suggestion_default({
    props: {
      index: ctx[0],
      textInputSuggester: ctx[1],
      selectedItemIndex: ctx[2],
      $$slots: {
        "suggestion-title": [create_suggestion_title_slot6]
      },
      $$scope: { ctx }
    }
  });
  return {
    c() {
      create_component(suggestion_1.$$.fragment);
    },
    m(target, anchor) {
      mount_component(suggestion_1, target, anchor);
      current = true;
    },
    p(ctx2, [dirty]) {
      const suggestion_1_changes = {};
      if (dirty & 1)
        suggestion_1_changes.index = ctx2[0];
      if (dirty & 2)
        suggestion_1_changes.textInputSuggester = ctx2[1];
      if (dirty & 4)
        suggestion_1_changes.selectedItemIndex = ctx2[2];
      if (dirty & 120) {
        suggestion_1_changes.$$scope = { dirty, ctx: ctx2 };
      }
      suggestion_1.$set(suggestion_1_changes);
    },
    i(local) {
      if (current)
        return;
      transition_in(suggestion_1.$$.fragment, local);
      current = true;
    },
    o(local) {
      transition_out(suggestion_1.$$.fragment, local);
      current = false;
    },
    d(detaching) {
      destroy_component(suggestion_1, detaching);
    }
  };
}
function instance26($$self, $$props, $$invalidate) {
  let { index } = $$props;
  let { textInputSuggester } = $$props;
  let { selectedItemIndex } = $$props;
  let { suggestion } = $$props;
  let { renderFont } = $$props;
  let { suggestionTitle } = $$props;
  $$self.$$set = ($$props2) => {
    if ("index" in $$props2)
      $$invalidate(0, index = $$props2.index);
    if ("textInputSuggester" in $$props2)
      $$invalidate(1, textInputSuggester = $$props2.textInputSuggester);
    if ("selectedItemIndex" in $$props2)
      $$invalidate(2, selectedItemIndex = $$props2.selectedItemIndex);
    if ("suggestion" in $$props2)
      $$invalidate(3, suggestion = $$props2.suggestion);
    if ("renderFont" in $$props2)
      $$invalidate(4, renderFont = $$props2.renderFont);
    if ("suggestionTitle" in $$props2)
      $$invalidate(5, suggestionTitle = $$props2.suggestionTitle);
  };
  return [
    index,
    textInputSuggester,
    selectedItemIndex,
    suggestion,
    renderFont,
    suggestionTitle
  ];
}
var FontSuggestion = class extends SvelteComponent {
  constructor(options) {
    super();
    init(this, options, instance26, create_fragment26, safe_not_equal, {
      index: 0,
      textInputSuggester: 1,
      selectedItemIndex: 2,
      suggestion: 3,
      renderFont: 4,
      suggestionTitle: 5
    });
  }
};
var fontSuggestion_default = FontSuggestion;

// src/suggester/fontSuggester.ts
var fontSuggester = class extends PopoverTextInputSuggester {
  constructor(app2, inputEl, viewOptions, renderFont) {
    super(app2, inputEl, viewOptions);
    this.renderFont = renderFont;
    this.getInstalledFonts().then((fontList) => this.fuzzySearch = new ArrayFuzzySearch(fontList));
  }
  async getInstalledFonts() {
    if (!this.fontList) {
      this.fontList = await (0, import_font_list.getFonts)();
    }
    return this.fontList;
  }
  getSuggestions(input) {
    return this.fuzzySearch.filteredSearch(input, 0.25, 15);
  }
  useSelectedItem(selectedItem) {
    this.inputEl.value = selectedItem.item.replace(/"/g, ``);
    this.inputEl.trigger("input");
    this.onInput().then(() => this.close());
  }
  getDisplayElementComponentType() {
    return fontSuggestion_default;
  }
  getDisplayElementProps(suggestion) {
    var _a;
    return {
      renderFont: (_a = this.renderFont) != null ? _a : false,
      suggestionTitle: suggestion.item.replace(/"/g, ``)
    };
  }
  onNoSuggestion() {
    const input = this.inputEl.value;
    if (!input) {
      const suggestions = [];
      this.fontList.forEach((font) => {
        suggestions.push({
          item: font,
          refIndex: 0,
          score: 0
        });
      });
      this.suggester.setSuggestions(suggestions);
      this.open();
    } else {
      this.close();
    }
  }
};

// src/utils/fontValidator.ts
function checkFont(font, size) {
  if (font.trim().length == 0)
    return false;
  return document.fonts.check(`${size != null ? size : 18}px ${font}`);
}

// src/settings.ts
var DEFAULT_SETTINGS = {
  logoType: "default",
  logo: {
    lucideIcon: "",
    imagePath: "",
    imageLink: ""
  },
  logoScale: 1.2,
  iconColorType: "default",
  wordmark: "Obsidian",
  customFont: "interfaceFont",
  fontSize: "4em",
  fontColorType: "default",
  fontWeight: 600,
  maxResults: 5,
  showbookmarkedFiles: app.internalPlugins.getPluginById("bookmarks") ? true : false,
  showRecentFiles: false,
  maxRecentFiles: 5,
  storeRecentFile: true,
  showPath: true,
  selectionHighlight: "default",
  showShortcuts: true,
  markdownOnly: false,
  unresolvedLinks: false,
  recentFilesStore: [],
  bookmarkedFileStore: [],
  searchDelay: 0,
  replaceNewTabs: true,
  newTabOnStart: false,
  closePreviousSessionTabs: false,
  omnisearch: false,
  showOmnisearchExcerpt: true
};
var HomeTabSettingTab = class extends import_obsidian16.PluginSettingTab {
  constructor(app2, plugin) {
    super(app2, plugin);
    this.plugin = plugin;
  }
  display() {
    var _a, _b;
    const { containerEl } = this;
    containerEl.empty();
    containerEl.createEl("h3", { text: "Home tab settings" });
    containerEl.createEl("h2", { text: "General settings" });
    new import_obsidian16.Setting(containerEl).setName("Replace new tabs with Home tab").addToggle((toggle) => toggle.setValue(this.plugin.settings.replaceNewTabs).onChange((value) => {
      this.plugin.settings.replaceNewTabs = value;
      this.plugin.saveSettings();
    }));
    new import_obsidian16.Setting(containerEl).setName("Open new Home tab on Obsidian start").setDesc("If a Home tab is already open it'll focus it instead of opening a new one.").addToggle((toggle) => toggle.setValue(this.plugin.settings.newTabOnStart).onChange((value) => {
      this.plugin.settings.newTabOnStart = value;
      this.plugin.saveSettings();
      this.display();
    }));
    if (this.plugin.settings.newTabOnStart) {
      new import_obsidian16.Setting(containerEl).setName("Close previous session tabs on start").setDesc("Enable this to close all the tabs and leave only one Home tab on Obsidian opening.").addToggle((toggle) => toggle.setValue(this.plugin.settings.closePreviousSessionTabs).onChange((value) => {
        this.plugin.settings.closePreviousSessionTabs = value;
        this.plugin.saveSettings();
      }));
    }
    containerEl.createEl("h2", { text: "Search settings" });
    if (this.plugin.app.plugins.getPlugin("omnisearch")) {
      new import_obsidian16.Setting(containerEl).setName("Use Omnisearch").setDesc("Set Omnisearch as the default search engine.").addToggle((toggle) => toggle.setValue(this.plugin.settings.omnisearch).onChange((value) => {
        this.plugin.settings.omnisearch = value;
        this.plugin.saveSettings();
        this.display();
        this.plugin.refreshOpenViews();
      }));
    }
    if (!this.plugin.settings.omnisearch) {
      new import_obsidian16.Setting(containerEl).setName("Search only markdown files").addToggle((toggle) => toggle.setValue(this.plugin.settings.markdownOnly).onChange((value) => {
        this.plugin.settings.markdownOnly = value;
        this.plugin.saveSettings();
        this.plugin.refreshOpenViews();
      }));
      new import_obsidian16.Setting(containerEl).setName("Show uncreated files").addToggle((toggle) => toggle.setValue(this.plugin.settings.unresolvedLinks).onChange((value) => {
        this.plugin.settings.unresolvedLinks = value;
        this.plugin.saveSettings();
        this.plugin.refreshOpenViews();
      }));
      new import_obsidian16.Setting(containerEl).setName("Show file path").setDesc("Displays file path at the right of the filename.").addToggle((toggle) => toggle.setValue(this.plugin.settings.showPath).onChange((value) => {
        this.plugin.settings.showPath = value;
        this.plugin.saveSettings();
      }));
    }
    new import_obsidian16.Setting(containerEl).setName("Show shorcuts").setDesc("Displays shortcuts under the search results.").addToggle((toggle) => toggle.setValue(this.plugin.settings.showShortcuts).onChange((value) => {
      this.plugin.settings.showShortcuts = value;
      this.plugin.refreshOpenViews();
      this.plugin.saveSettings();
    }));
    new import_obsidian16.Setting(containerEl).setName("Search results").setDesc("Set how many results display.").addSlider((slider) => slider.setLimits(1, 25, 1).setValue(this.plugin.settings.maxResults).setDynamicTooltip().onChange((value) => {
      this.plugin.settings.maxResults = value;
      this.plugin.saveSettings();
    })).then((settingEl) => this.addResetButton(settingEl, "maxResults"));
    new import_obsidian16.Setting(containerEl).setName("Search delay").setDesc("The value is in milliseconds.").addSlider((slider) => slider.setLimits(0, 500, 10).setValue(this.plugin.settings.searchDelay).setDynamicTooltip().onChange((value) => {
      this.plugin.settings.searchDelay = value;
      this.plugin.saveSettings();
      this.plugin.refreshOpenViews();
    })).then((settingEl) => this.addResetButton(settingEl, "searchDelay"));
    if (this.plugin.app.plugins.getPlugin("omnisearch")) {
      new import_obsidian16.Setting(containerEl).setName("Show excerpt (Omnisearch)").setDesc("Shows the contextual part of the note that matches the search.").addToggle((toggle) => toggle.setValue(this.plugin.settings.showOmnisearchExcerpt).onChange((value) => {
        this.plugin.settings.showOmnisearchExcerpt = value;
        this.plugin.saveSettings();
      }));
    }
    containerEl.createEl("h2", { text: "Files display" });
    if (app.internalPlugins.getPluginById("bookmarks")) {
      new import_obsidian16.Setting(containerEl).setName("Show bookmarked files").setDesc("Shows bookmarked files under the search bar.").addToggle((toggle) => toggle.setValue(this.plugin.settings.showbookmarkedFiles).onChange((value) => {
        this.plugin.settings.showbookmarkedFiles = value;
        this.plugin.saveSettings();
        this.plugin.refreshOpenViews();
      }));
    }
    new import_obsidian16.Setting(containerEl).setName("Show recent files").setDesc("Displays recent files under the search bar.").addToggle((toggle) => toggle.setValue(this.plugin.settings.showRecentFiles).onChange((value) => {
      this.plugin.settings.showRecentFiles = value;
      this.plugin.saveSettings();
      this.display();
      this.plugin.refreshOpenViews();
    }));
    if (this.plugin.settings.showRecentFiles) {
      new import_obsidian16.Setting(containerEl).setName("Store last recent files").setDesc("Remembers the recent files of the previous session.").addToggle((toggle) => toggle.setValue(this.plugin.settings.storeRecentFile).onChange((value) => {
        this.plugin.settings.storeRecentFile = value;
        this.plugin.saveSettings();
      }));
      new import_obsidian16.Setting(containerEl).setName("Recent files").setDesc("Set how many recent files display.").addSlider((slider) => slider.setValue(this.plugin.settings.maxRecentFiles).setLimits(1, 25, 1).setDynamicTooltip().onChange((value) => {
        this.plugin.recentFileManager.onNewMaxListLenght(value);
        this.plugin.settings.maxRecentFiles = value;
        this.plugin.saveSettings();
      })).then((settingEl) => this.addResetButton(settingEl, "maxRecentFiles"));
    }
    containerEl.createEl("h2", { text: "Appearance" });
    const logoTypeSetting = new import_obsidian16.Setting(containerEl).setName("Logo").setDesc("Remove or set a custom logo. Accepts local files, links to images or lucide icon ids.");
    (_a = logoTypeSetting.descEl.parentElement) == null ? void 0 : _a.addClass("ultra-compressed");
    let invalidInputIcon;
    logoTypeSetting.addExtraButton((button) => {
      button.setIcon("alert-circle").setTooltip("The path/link/icon is not valid.");
      invalidInputIcon = button.extraSettingsEl;
      invalidInputIcon.toggleVisibility(false);
      invalidInputIcon.addClass("mod-warning");
    });
    if (this.plugin.settings.logoType === "imagePath" || this.plugin.settings.logoType === "imageLink" || this.plugin.settings.logoType === "lucideIcon") {
      logoTypeSetting.addSearch((text2) => {
        var _a2;
        if (this.plugin.settings.logoType === "imagePath") {
          new ImageFileSuggester(this.app, text2.inputEl, {
            isScrollable: true,
            style: `max-height: 200px`
          });
        } else if (this.plugin.settings.logoType === "lucideIcon") {
          new iconSuggester(this.app, text2.inputEl, {
            isScrollable: true,
            style: `max-height: 200px`
          }, true);
        }
        (_a2 = text2.setPlaceholder("Type anything ... ").setValue(this.plugin.settings.logo[this.plugin.settings.logoType] != "" ? this.plugin.settings.logo[this.plugin.settings.logoType] : "").onChange(async (value) => {
          if (value === "" || value == "/") {
            invalidInputIcon.toggleVisibility(false);
            return;
          }
          if (this.plugin.settings.logoType === "imagePath") {
            const normalizedPath = (0, import_obsidian16.normalizePath)(value);
            if (await app.vault.adapter.exists(normalizedPath)) {
              invalidInputIcon.toggleVisibility(false);
              this.plugin.settings.logo["imagePath"] = normalizedPath;
              this.plugin.saveSettings();
            } else {
              invalidInputIcon.toggleVisibility(true);
            }
          } else if (this.plugin.settings.logoType === "imageLink") {
            if (isLink(value)) {
              invalidInputIcon.toggleVisibility(false);
              this.plugin.settings.logo["imageLink"] = value;
              this.plugin.saveSettings();
            } else {
              invalidInputIcon.toggleVisibility(true);
            }
          } else if (this.plugin.settings.logoType === "lucideIcon") {
            if (lucideIcons.includes(value)) {
              this.plugin.settings.logo["lucideIcon"] = value;
              this.plugin.saveSettings();
              invalidInputIcon.toggleVisibility(false);
            } else {
              invalidInputIcon.toggleVisibility(true);
            }
          }
        }).inputEl.parentElement) == null ? void 0 : _a2.addClass("wide-input-container");
      });
    }
    logoTypeSetting.addDropdown((dropdown) => dropdown.addOption("default", "Obsidian logo").addOption("oldLogo", "Obsidian old logo").addOption("imagePath", "Local image").addOption("imageLink", "Link").addOption("lucideIcon", "Lucide icon").addOption("none", "Empty").setValue(this.plugin.settings.logoType).onChange((value) => {
      this.plugin.settings.logoType = value;
      this.plugin.saveSettings();
      this.display();
    })).then((settingEl) => this.addResetButton(settingEl, "logoType"));
    if (this.plugin.settings.logoType === "lucideIcon") {
      const iconColorSetting = new import_obsidian16.Setting(containerEl).setName("Logo icon color").setDesc("Set the icon color");
      if (this.plugin.settings.iconColorType === "custom") {
        iconColorSetting.addColorPicker((colorPicker) => colorPicker.setValue(this.plugin.settings.iconColor ? this.plugin.settings.iconColor : "#000000").onChange((value) => {
          this.plugin.settings.iconColor = value;
          this.plugin.saveSettings();
        }));
      }
      iconColorSetting.addDropdown((dropdown) => dropdown.addOption("default", "Theme default").addOption("accentColor", "Accent color").addOption("custom", "Custom").setValue(this.plugin.settings.iconColorType).onChange((value) => {
        this.plugin.settings.iconColorType = value;
        this.plugin.saveSettings();
        this.display();
      })).then((settingEl) => this.addResetButton(settingEl, "iconColorType"));
    }
    new import_obsidian16.Setting(containerEl).setName("Logo scale").setDesc("Set the logo dimensions relative to the title font size.").addSlider((slider) => slider.setDynamicTooltip().setLimits(0.3, 3, 0.1).setValue(this.plugin.settings.logoScale).onChange((value) => {
      this.plugin.settings.logoScale = value;
      this.plugin.saveSettings();
    })).then((settingEl) => this.addResetButton(settingEl, "logoScale"));
    new import_obsidian16.Setting(containerEl).setName("Title").addText((text2) => text2.setValue(this.plugin.settings.wordmark).onChange((value) => {
      this.plugin.settings.wordmark = value;
      this.plugin.saveSettings();
    })).then((settingEl) => this.addResetButton(settingEl, "wordmark"));
    const titleFontSettings = new import_obsidian16.Setting(containerEl).setName("Title font").setDesc("Interface font, text font, and monospace font options match the fonts set in the Appearance setting tab.");
    (_b = titleFontSettings.descEl.parentElement) == null ? void 0 : _b.addClass("compressed");
    if (this.plugin.settings.customFont === "custom") {
      let invalidFontIcon;
      titleFontSettings.addExtraButton((button) => {
        button.setIcon("alert-circle").setTooltip("The font is not valid.");
        invalidFontIcon = button.extraSettingsEl;
        invalidFontIcon.toggleVisibility(false);
        invalidFontIcon.addClass("mod-warning");
      });
      titleFontSettings.addSearch((text2) => {
        var _a2;
        text2.setValue(this.plugin.settings.font ? this.plugin.settings.font.replace(/"/g, "") : "");
        text2.setPlaceholder("Type anything ... ");
        const suggester = import_obsidian16.Platform.isMobile || import_obsidian16.Platform.isMacOS ? void 0 : new fontSuggester(this.app, text2.inputEl, {
          isScrollable: true,
          style: `max-height: 200px;
                    width: fit-content;
                    min-width: 200px;`
        }, true);
        (_a2 = text2.onChange(async (value) => {
          value = value.indexOf(" ") >= 0 ? `"${value}"` : value;
          if (suggester && (await suggester.getInstalledFonts()).includes(value) || checkFont(value)) {
            this.plugin.settings.font = value;
            this.plugin.saveSettings();
            invalidFontIcon.toggleVisibility(false);
          } else {
            invalidFontIcon.toggleVisibility(true);
          }
        }).inputEl.parentElement) == null ? void 0 : _a2.addClass("wide-input-container");
      });
    }
    titleFontSettings.addDropdown((dropdown) => dropdown.addOption("interfaceFont", "Interface font").addOption("textFont", "Text font").addOption("monospaceFont", "Monospace font").addOption("custom", "Custom font").setValue(this.plugin.settings.customFont).onChange((value) => {
      this.plugin.settings.customFont = value;
      this.plugin.saveSettings();
      this.display();
    }));
    this.addResetButton(titleFontSettings, "customFont");
    let invalidFontSizeIcon;
    new import_obsidian16.Setting(containerEl).setName("Title font size").setDesc("Accepts any CSS font-size value.").addExtraButton((button) => {
      button.setIcon("alert-circle").setTooltip("The CSS unit is not valid.");
      invalidFontSizeIcon = button.extraSettingsEl;
      invalidFontSizeIcon.addClass("mod-warning");
      invalidFontSizeIcon.toggleVisibility(false);
    }).addText((text2) => text2.setValue(this.plugin.settings.fontSize).onChange((value) => {
      if (cssUnitValidator(value)) {
        this.plugin.settings.fontSize = value;
        this.plugin.saveSettings();
        invalidFontSizeIcon.toggleVisibility(false);
      } else {
        invalidFontSizeIcon.toggleVisibility(true);
      }
    })).then((settingEl) => this.addResetButton(settingEl, "fontSize"));
    new import_obsidian16.Setting(containerEl).setName("Title font weight").addSlider((slider) => slider.setLimits(100, 900, 100).setDynamicTooltip().setValue(this.plugin.settings.fontWeight).onChange((value) => {
      this.plugin.settings.fontWeight = value;
      this.plugin.saveSettings();
    })).then((settingEl) => this.addResetButton(settingEl, "fontWeight"));
    const titleColorSetting = new import_obsidian16.Setting(containerEl).setName("Title color");
    if (this.plugin.settings.fontColorType === "custom") {
      titleColorSetting.addColorPicker((colorPicker) => colorPicker.setValue(this.plugin.settings.fontColor ? this.plugin.settings.fontColor : "#000000").onChange((value) => {
        this.plugin.settings.fontColor = value;
        this.plugin.saveSettings();
      }));
    }
    titleColorSetting.addDropdown((dropdown) => dropdown.addOption("default", "Theme default").addOption("accentColor", "Accent color").addOption("custom", "Custom").setValue(this.plugin.settings.fontColorType).onChange((value) => {
      this.plugin.settings.fontColorType = value;
      this.plugin.saveSettings();
      this.display();
    })).then((settingEl) => this.addResetButton(settingEl, "fontColorType"));
    new import_obsidian16.Setting(containerEl).setName("Selection highlight").setDesc("Set the color of the selected item.").addDropdown((dropdown) => dropdown.addOption("default", "Theme default").addOption("accentColor", "Accent color").setValue(this.plugin.settings.selectionHighlight).onChange((value) => {
      this.plugin.settings.selectionHighlight = value;
      this.plugin.saveSettings();
      this.plugin.refreshOpenViews();
    })).then((settingEl) => this.addResetButton(settingEl, "selectionHighlight"));
  }
  addResetButton(settingElement, settingKey, refreshView = true) {
    settingElement.addExtraButton((button) => button.setIcon("reset").setTooltip("Reset to default").onClick(() => {
      this.plugin.settings[settingKey] = DEFAULT_SETTINGS[settingKey];
      this.plugin.saveSettings();
      if (refreshView) {
        this.display();
      }
    }));
  }
};

// src/recentFiles.ts
var import_obsidian17 = require("obsidian");
var RecentFileManager = class extends import_obsidian17.Component {
  constructor(app2, plugin) {
    super();
    this.app = app2;
    this.plugin = plugin;
    this.pluginSettings = plugin.settings;
  }
  onload() {
    this.registerEvent(this.app.workspace.on("file-open", async (file) => {
      this.updateRecentFiles(file);
      await this.storeRecentFiles();
    }));
    this.registerEvent(this.app.vault.on("delete", async (file) => {
      file instanceof import_obsidian17.TFile ? this.removeRecentFile(file) : null;
      await this.storeRecentFiles();
    }));
    this.registerEvent(this.app.vault.on("rename", (file) => file instanceof import_obsidian17.TFile ? this.onFileRename() : null));
    this.loadStoredRecentFiles();
  }
  updateRecentFiles(openedFile) {
    if (openedFile) {
      recentFiles.update((filesArray) => {
        if (filesArray.some((item) => item.file === openedFile)) {
          const itemIndex = filesArray.findIndex((item) => item.file === openedFile);
          filesArray[itemIndex].timestamp = Date.now();
        } else if (filesArray.length >= this.pluginSettings.maxRecentFiles) {
          filesArray[filesArray.length - 1] = {
            file: openedFile,
            timestamp: Date.now()
          };
        } else {
          filesArray.push({
            file: openedFile,
            timestamp: Date.now()
          });
        }
        return filesArray.sort((a, b) => b.timestamp - a.timestamp);
      });
    }
  }
  removeRecentFile(file) {
    recentFiles.update((filesArray) => {
      filesArray.splice(filesArray.findIndex((recentFile) => recentFile.file == file), 1);
      return filesArray;
    });
    this.storeRecentFiles();
  }
  onNewMaxListLenght(newValue) {
    const currentLenght = get_store_value(recentFiles).length;
    if (newValue < currentLenght) {
      this.removeRecentFiles(currentLenght - newValue);
    }
  }
  removeRecentFiles(number) {
    recentFiles.update((filesArray) => {
      filesArray.splice(filesArray.length - number, number);
      return filesArray;
    });
    this.storeRecentFiles();
  }
  onFileRename() {
    recentFiles.update((filesArray) => filesArray);
  }
  async storeRecentFiles() {
    if (this.plugin.settings.storeRecentFile) {
      let storeObj = [];
      get_store_value(recentFiles).forEach((item) => storeObj.push({
        filepath: item.file.path,
        timestamp: item.timestamp
      }));
      this.plugin.settings.recentFilesStore = storeObj;
      await this.plugin.saveData(this.plugin.settings);
    }
  }
  loadStoredRecentFiles() {
    if (this.plugin.settings.storeRecentFile) {
      let filesToLoad = [];
      this.app.workspace.onLayoutReady(() => {
        this.plugin.settings.recentFilesStore.forEach((item) => {
          let file = this.app.vault.getAbstractFileByPath(item.filepath);
          if (file && file instanceof import_obsidian17.TFile) {
            filesToLoad.push({
              file,
              timestamp: item.timestamp
            });
          }
        });
        recentFiles.set(filesToLoad);
      });
    }
  }
};

// src/bookmarkedFiles.ts
var import_obsidian18 = require("obsidian");
var bookmarkedFilesManager = class extends import_obsidian18.Component {
  constructor(app2, plugin, bookmarkedFilesStore) {
    super();
    this.removeBookmark = (file) => {
      const bookmarksPlugin = this.app.internalPlugins.getPluginById("bookmarks");
      if (bookmarksPlugin) {
        const item = bookmarksPlugin.instance.getBookmarks().find((item2) => item2.path === file.path);
        if (item)
          this.app.internalPlugins.plugins.bookmarks.instance.removeItem(item);
      } else {
        new import_obsidian18.Notice("Bookmarks plugin is not enabled");
      }
    };
    this.app = app2;
    this.plugin = plugin;
    this.bookmarkedFilesStore = bookmarkedFilesStore;
  }
  onload() {
    this.loadStoredBookmarkedFiles();
    this.updateBookmarkedFiles();
    this.registerEvent(this.app.internalPlugins.getPluginById("bookmarks").instance.on("changed", () => this.updateBookmarkedFiles()));
  }
  updateBookmarkedFiles() {
    const bookmarkedFiles2 = this.getBookmarkedFiles();
    this.bookmarkedFilesStore.update((filesArray) => {
      const updatedArray = [];
      bookmarkedFiles2.forEach((bookmarkedFile) => {
        var _a, _b;
        updatedArray.push({
          file: bookmarkedFile,
          iconId: (_b = (_a = filesArray.find((item) => item.file === bookmarkedFile)) == null ? void 0 : _a.iconId) != null ? _b : void 0
        });
      });
      return updatedArray;
    });
    this.storeBookmarkedFiles();
  }
  updateFileIcon(file, iconId) {
    this.bookmarkedFilesStore.update((filesArray) => {
      const itemIndex = filesArray.findIndex((item) => item.file === file);
      filesArray[itemIndex].iconId = iconId;
      return filesArray;
    });
    this.storeBookmarkedFiles();
  }
  getBookmarkedFiles() {
    if (this.app.internalPlugins.getPluginById("bookmarks")) {
      const bookmarkedItems = app.internalPlugins.plugins.bookmarks.instance.getBookmarks();
      const bookmarkedFiles2 = [];
      bookmarkedItems.forEach((item) => {
        if (item.type === "file") {
          const file = app.vault.getAbstractFileByPath(item.path);
          if (file instanceof import_obsidian18.TFile) {
            bookmarkedFiles2.push(file);
          }
        }
      });
      return bookmarkedFiles2;
    }
    return [];
  }
  async storeBookmarkedFiles() {
    if (this.app.internalPlugins.getPluginById("bookmarks")) {
      let storeObj = [];
      get_store_value(this.bookmarkedFilesStore).forEach((item) => storeObj.push({
        filepath: item.file.path,
        iconId: item.iconId
      }));
      this.plugin.settings.bookmarkedFileStore = storeObj;
      await this.plugin.saveData(this.plugin.settings);
    }
  }
  loadStoredBookmarkedFiles() {
    if (this.app.internalPlugins.getPluginById("bookmarks")) {
      let filesToLoad = [];
      this.app.workspace.onLayoutReady(() => {
        this.plugin.settings.bookmarkedFileStore.forEach((item) => {
          let file = this.app.vault.getAbstractFileByPath(item.filepath);
          if (file && file instanceof import_obsidian18.TFile) {
            filesToLoad.push({
              file,
              iconId: item.iconId
            });
          }
        });
        this.bookmarkedFilesStore.set(filesToLoad);
      });
    }
  }
};

// src/main.ts
var HomeTab = class extends import_obsidian19.Plugin {
  async onload() {
    console.log("Loading home-tab plugin");
    await this.loadSettings();
    this.addSettingTab(new HomeTabSettingTab(this.app, this));
    this.registerView(VIEW_TYPE, (leaf) => new HomeTabView(leaf, this));
    this.registerEvent(this.app.workspace.on("layout-change", () => this.onLayoutChange()));
    this.registerEvent(this.app.workspace.on("active-leaf-change", (leaf) => {
      if (leaf.view instanceof HomeTabView) {
        leaf.view.searchBar.focusSearchbar();
      }
    }));
    pluginSettingsStore.set(this.settings);
    this.activeEmbeddedHomeTabViews = [];
    this.recentFileManager = new RecentFileManager(app, this);
    this.recentFileManager.load();
    this.addCommand({
      id: "open-new-home-tab",
      name: "Open new Home tab",
      callback: () => this.activateView(false, true)
    });
    this.addCommand({
      id: "open-home-tab",
      name: "Replace current tab",
      callback: () => this.activateView(true)
    });
    this.app.workspace.onLayoutReady(() => {
      if (this.app.internalPlugins.getPluginById("bookmarks")) {
        this.bookmarkedFileManager = new bookmarkedFilesManager(app, this, bookmarkedFiles);
        this.bookmarkedFileManager.load();
      }
      this.registerMarkdownCodeBlockProcessor("search-bar", (source, el, ctx) => {
        const view = this.app.workspace.getActiveViewOfType(import_obsidian19.MarkdownView);
        if (view) {
          let embeddedHomeTab = new EmbeddedHomeTab(el, view, this, source);
          this.activeEmbeddedHomeTabViews.push(embeddedHomeTab);
          ctx.addChild(embeddedHomeTab);
        }
      });
      if (this.settings.newTabOnStart) {
        const leaves = app.workspace.getLeavesOfType(VIEW_TYPE);
        if (leaves.length > 0) {
          app.workspace.revealLeaf(leaves[0]);
          leaves.forEach((leaf, index) => {
            if (index < 1)
              return;
            leaf.detach();
          });
        } else {
          this.activateView(false, true);
        }
        if (this.settings.closePreviousSessionTabs) {
          const leafTypes = [];
          app.workspace.iterateRootLeaves((leaf) => {
            const leafType = leaf.view.getViewType();
            if (leafTypes.indexOf(leafType) === -1 && leafType != VIEW_TYPE) {
              leafTypes.push(leafType);
            }
          });
          leafTypes.forEach((type) => app.workspace.detachLeavesOfType(type));
        }
      }
    });
  }
  onunload() {
    this.app.workspace.detachLeavesOfType(VIEW_TYPE);
    this.activeEmbeddedHomeTabViews.forEach((view) => view.unload());
    this.recentFileManager.unload();
    this.bookmarkedFileManager.unload();
  }
  async loadSettings() {
    this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());
  }
  async saveSettings() {
    await this.saveData(this.settings);
    pluginSettingsStore.update(() => this.settings);
  }
  onLayoutChange() {
    if (this.settings.replaceNewTabs) {
      this.activateView();
    }
  }
  activateView(overrideView, openNewTab) {
    const leaf = openNewTab ? app.workspace.getLeaf("tab") : app.workspace.getMostRecentLeaf();
    if (leaf && (overrideView || leaf.getViewState().type === "empty")) {
      leaf.setViewState({
        type: VIEW_TYPE
      });
      if (openNewTab) {
        app.workspace.revealLeaf(leaf);
      }
    }
  }
  refreshOpenViews() {
    this.app.workspace.getLeavesOfType(VIEW_TYPE).forEach((leaf) => leaf.rebuildView());
  }
};
/*! *****************************************************************************
Copyright (c) Microsoft Corporation.

Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */