471 lines
20 KiB
JavaScript
471 lines
20 KiB
JavaScript
import "./chunk-FOSKEDPS.js";
|
|
|
|
// src/lib/mind-elixir/node_modules/@viselect/vanilla/dist/viselect.mjs
|
|
var X = class {
|
|
constructor() {
|
|
this._listeners = /* @__PURE__ */ new Map(), this.on = this.addEventListener, this.off = this.removeEventListener, this.emit = this.dispatchEvent;
|
|
}
|
|
addEventListener(e, t) {
|
|
const s = this._listeners.get(e) ?? /* @__PURE__ */ new Set();
|
|
return this._listeners.set(e, s), s.add(t), this;
|
|
}
|
|
removeEventListener(e, t) {
|
|
var s;
|
|
return (s = this._listeners.get(e)) == null || s.delete(t), this;
|
|
}
|
|
dispatchEvent(e, ...t) {
|
|
let s = true;
|
|
for (const i of this._listeners.get(e) ?? [])
|
|
s = i(...t) !== false && s;
|
|
return s;
|
|
}
|
|
unbindAllListeners() {
|
|
this._listeners.clear();
|
|
}
|
|
};
|
|
var L = (l, e = "px") => typeof l == "number" ? l + e : l;
|
|
var y = ({ style: l }, e, t) => {
|
|
if (typeof e == "object")
|
|
for (const [s, i] of Object.entries(e))
|
|
i !== void 0 && (l[s] = L(i));
|
|
else
|
|
t !== void 0 && (l[e] = L(t));
|
|
};
|
|
var M = (l = 0, e = 0, t = 0, s = 0) => {
|
|
const i = { x: l, y: e, width: t, height: s, top: e, left: l, right: l + t, bottom: e + s };
|
|
return { ...i, toJSON: () => JSON.stringify(i) };
|
|
};
|
|
var Y = (l) => {
|
|
let e, t = -1, s = false;
|
|
return {
|
|
next: (...i) => {
|
|
e = i, s || (s = true, t = requestAnimationFrame(() => {
|
|
l(...e), s = false;
|
|
}));
|
|
},
|
|
cancel: () => {
|
|
cancelAnimationFrame(t), s = false;
|
|
}
|
|
};
|
|
};
|
|
var k = (l, e, t = "touch") => {
|
|
switch (t) {
|
|
case "center": {
|
|
const s = e.left + e.width / 2, i = e.top + e.height / 2;
|
|
return s >= l.left && s <= l.right && i >= l.top && i <= l.bottom;
|
|
}
|
|
case "cover":
|
|
return e.left >= l.left && e.top >= l.top && e.right <= l.right && e.bottom <= l.bottom;
|
|
case "touch":
|
|
return l.right >= e.left && l.left <= e.right && l.bottom >= e.top && l.top <= e.bottom;
|
|
}
|
|
};
|
|
var H = () => matchMedia("(hover: none), (pointer: coarse)").matches;
|
|
var N = () => "safari" in window;
|
|
var A = (l) => Array.isArray(l) ? l : [l];
|
|
var O = (l) => (e, t, s, i = {}) => {
|
|
(e instanceof HTMLCollection || e instanceof NodeList) && (e = Array.from(e)), t = A(t), e = A(e);
|
|
for (const o of e)
|
|
if (o)
|
|
for (const n of t)
|
|
o[l](n, s, { capture: false, ...i });
|
|
};
|
|
var S = O("addEventListener");
|
|
var g = O("removeEventListener");
|
|
var x = (l) => {
|
|
var i;
|
|
const { clientX: e, clientY: t, target: s } = ((i = l.touches) == null ? void 0 : i[0]) ?? l;
|
|
return { x: e, y: t, target: s };
|
|
};
|
|
var E = (l, e = document) => A(l).map(
|
|
(t) => typeof t == "string" ? Array.from(e.querySelectorAll(t)) : t instanceof Element ? t : null
|
|
).flat().filter(Boolean);
|
|
var q = (l, e) => e.some((t) => typeof t == "number" ? l.button === t : typeof t == "object" ? t.button !== l.button ? false : t.modifiers.every((s) => {
|
|
switch (s) {
|
|
case "alt":
|
|
return l.altKey;
|
|
case "ctrl":
|
|
return l.ctrlKey || l.metaKey;
|
|
case "shift":
|
|
return l.shiftKey;
|
|
}
|
|
}) : false);
|
|
var { abs: b, max: C, min: B, ceil: R } = Math;
|
|
var D = (l = []) => ({
|
|
stored: l,
|
|
selected: [],
|
|
touched: [],
|
|
changed: { added: [], removed: [] }
|
|
});
|
|
var T = class T2 extends X {
|
|
constructor(e) {
|
|
var o, n, r, a, u;
|
|
super(), this._selection = D(), this._targetBoundaryScrolled = true, this._selectables = [], this._areaLocation = { y1: 0, x2: 0, y2: 0, x1: 0 }, this._areaRect = M(), this._singleClick = true, this._scrollAvailable = true, this._scrollingActive = false, this._scrollSpeed = { x: 0, y: 0 }, this._scrollDelta = { x: 0, y: 0 }, this._lastMousePosition = { x: 0, y: 0 }, this.enable = this._toggleStartEvents, this.disable = this._toggleStartEvents.bind(this, false), this._options = {
|
|
selectionAreaClass: "selection-area",
|
|
selectionContainerClass: void 0,
|
|
selectables: [],
|
|
document: window.document,
|
|
startAreas: ["html"],
|
|
boundaries: ["html"],
|
|
container: "body",
|
|
...e,
|
|
behaviour: {
|
|
overlap: "invert",
|
|
intersect: "touch",
|
|
triggers: [0],
|
|
...e.behaviour,
|
|
startThreshold: (o = e.behaviour) != null && o.startThreshold ? typeof e.behaviour.startThreshold == "number" ? e.behaviour.startThreshold : { x: 10, y: 10, ...e.behaviour.startThreshold } : { x: 10, y: 10 },
|
|
scrolling: {
|
|
speedDivider: 10,
|
|
manualSpeed: 750,
|
|
...(n = e.behaviour) == null ? void 0 : n.scrolling,
|
|
startScrollMargins: {
|
|
x: 0,
|
|
y: 0,
|
|
...(a = (r = e.behaviour) == null ? void 0 : r.scrolling) == null ? void 0 : a.startScrollMargins
|
|
}
|
|
}
|
|
},
|
|
features: {
|
|
range: true,
|
|
touch: true,
|
|
deselectOnBlur: false,
|
|
...e.features,
|
|
singleTap: {
|
|
allow: true,
|
|
intersect: "native",
|
|
...(u = e.features) == null ? void 0 : u.singleTap
|
|
}
|
|
}
|
|
};
|
|
for (const _ of Object.getOwnPropertyNames(Object.getPrototypeOf(this)))
|
|
typeof this[_] == "function" && (this[_] = this[_].bind(this));
|
|
const { document: t, selectionAreaClass: s, selectionContainerClass: i } = this._options;
|
|
this._area = t.createElement("div"), this._clippingElement = t.createElement("div"), this._clippingElement.appendChild(this._area), this._area.classList.add(s), i && this._clippingElement.classList.add(i), y(this._area, {
|
|
willChange: "top, left, bottom, right, width, height",
|
|
top: 0,
|
|
left: 0,
|
|
position: "fixed"
|
|
}), y(this._clippingElement, {
|
|
overflow: "hidden",
|
|
position: "fixed",
|
|
transform: "translate3d(0, 0, 0)",
|
|
// https://stackoverflow.com/a/38268846
|
|
pointerEvents: "none",
|
|
zIndex: "1"
|
|
}), this._frame = Y((_) => {
|
|
this._recalculateSelectionAreaRect(), this._updateElementSelection(), this._emitEvent("move", _), this._redrawSelectionArea();
|
|
}), this.enable();
|
|
}
|
|
_toggleStartEvents(e = true) {
|
|
const { document: t, features: s } = this._options, i = e ? S : g;
|
|
i(t, "mousedown", this._onTapStart), s.touch && i(t, "touchstart", this._onTapStart, { passive: false });
|
|
}
|
|
_onTapStart(e, t = false) {
|
|
const { x: s, y: i, target: o } = x(e), { document: n, startAreas: r, boundaries: a, features: u, behaviour: _ } = this._options, c = o.getBoundingClientRect();
|
|
if (e instanceof MouseEvent && !q(e, _.triggers))
|
|
return;
|
|
const p = E(r, n), m = E(a, n);
|
|
this._targetElement = m.find(
|
|
(v) => k(v.getBoundingClientRect(), c)
|
|
);
|
|
const f = e.composedPath(), d = p.find((v) => f.includes(v));
|
|
if (this._targetBoundary = m.find((v) => f.includes(v)), !this._targetElement || !d || !this._targetBoundary || !t && this._emitEvent("beforestart", e) === false)
|
|
return;
|
|
this._areaLocation = { x1: s, y1: i, x2: 0, y2: 0 };
|
|
const h = n.scrollingElement ?? n.body;
|
|
this._scrollDelta = { x: h.scrollLeft, y: h.scrollTop }, this._singleClick = true, this.clearSelection(false, true), S(n, ["touchmove", "mousemove"], this._delayedTapMove, { passive: false }), S(n, ["mouseup", "touchcancel", "touchend"], this._onTapStop), S(n, "scroll", this._onScroll), u.deselectOnBlur && (this._targetBoundaryScrolled = false, S(this._targetBoundary, "scroll", this._onStartAreaScroll));
|
|
}
|
|
_onSingleTap(e) {
|
|
const { singleTap: { intersect: t }, range: s } = this._options.features, i = x(e);
|
|
let o;
|
|
if (t === "native")
|
|
o = i.target;
|
|
else if (t === "touch") {
|
|
this.resolveSelectables();
|
|
const { x: r, y: a } = i;
|
|
o = this._selectables.find((u) => {
|
|
const { right: _, left: c, top: p, bottom: m } = u.getBoundingClientRect();
|
|
return r < _ && r > c && a < m && a > p;
|
|
});
|
|
}
|
|
if (!o)
|
|
return;
|
|
for (this.resolveSelectables(); !this._selectables.includes(o); )
|
|
if (o.parentElement)
|
|
o = o.parentElement;
|
|
else {
|
|
this._targetBoundaryScrolled || this.clearSelection();
|
|
return;
|
|
}
|
|
const { stored: n } = this._selection;
|
|
if (this._emitEvent("start", e), e.shiftKey && s && this._latestElement) {
|
|
const r = this._latestElement, [a, u] = r.compareDocumentPosition(o) & 4 ? [o, r] : [r, o], _ = [...this._selectables.filter(
|
|
(c) => c.compareDocumentPosition(a) & 4 && c.compareDocumentPosition(u) & 2
|
|
), a, u];
|
|
this.select(_), this._latestElement = r;
|
|
} else
|
|
n.includes(o) && (n.length === 1 || e.ctrlKey || n.every((r) => this._selection.stored.includes(r))) ? this.deselect(o) : (this.select(o), this._latestElement = o);
|
|
}
|
|
_delayedTapMove(e) {
|
|
const { container: t, document: s, behaviour: { startThreshold: i } } = this._options, { x1: o, y1: n } = this._areaLocation, { x: r, y: a } = x(e);
|
|
if (
|
|
// Single number for both coordinates
|
|
typeof i == "number" && b(r + a - (o + n)) >= i || // Different x and y threshold
|
|
typeof i == "object" && b(r - o) >= i.x || b(a - n) >= i.y
|
|
) {
|
|
if (g(s, ["mousemove", "touchmove"], this._delayedTapMove, { passive: false }), this._emitEvent("beforedrag", e) === false) {
|
|
g(s, ["mouseup", "touchcancel", "touchend"], this._onTapStop);
|
|
return;
|
|
}
|
|
S(s, ["mousemove", "touchmove"], this._onTapMove, { passive: false }), y(this._area, "display", "block"), E(t, s)[0].appendChild(this._clippingElement), this.resolveSelectables(), this._singleClick = false, this._targetRect = this._targetElement.getBoundingClientRect(), this._scrollAvailable = this._targetElement.scrollHeight !== this._targetElement.clientHeight || this._targetElement.scrollWidth !== this._targetElement.clientWidth, this._scrollAvailable && (S(this._targetElement, "wheel", this._wheelScroll, { passive: false }), S(this._options.document, "keydown", this._keyboardScroll, { passive: false }), this._selectables = this._selectables.filter((u) => this._targetElement.contains(u))), this._setupSelectionArea(), this._emitEvent("start", e), this._onTapMove(e);
|
|
}
|
|
this._handleMoveEvent(e);
|
|
}
|
|
_setupSelectionArea() {
|
|
const { _clippingElement: e, _targetElement: t, _area: s } = this, i = this._targetRect = t.getBoundingClientRect();
|
|
this._scrollAvailable ? (y(e, {
|
|
top: i.top,
|
|
left: i.left,
|
|
width: i.width,
|
|
height: i.height
|
|
}), y(s, {
|
|
marginTop: -i.top,
|
|
marginLeft: -i.left
|
|
})) : (y(e, {
|
|
top: 0,
|
|
left: 0,
|
|
width: "100%",
|
|
height: "100%"
|
|
}), y(s, {
|
|
marginTop: 0,
|
|
marginLeft: 0
|
|
}));
|
|
}
|
|
_onTapMove(e) {
|
|
const { _scrollSpeed: t, _areaLocation: s, _options: i, _frame: o } = this, { speedDivider: n } = i.behaviour.scrolling, r = this._targetElement, { x: a, y: u } = x(e);
|
|
if (s.x2 = a, s.y2 = u, this._lastMousePosition.x = a, this._lastMousePosition.y = u, this._scrollAvailable && !this._scrollingActive && (t.y || t.x)) {
|
|
this._scrollingActive = true;
|
|
const _ = () => {
|
|
if (!t.x && !t.y) {
|
|
this._scrollingActive = false;
|
|
return;
|
|
}
|
|
const { scrollTop: c, scrollLeft: p } = r;
|
|
t.y && (r.scrollTop += R(t.y / n), s.y1 -= r.scrollTop - c), t.x && (r.scrollLeft += R(t.x / n), s.x1 -= r.scrollLeft - p), o.next(e), requestAnimationFrame(_);
|
|
};
|
|
requestAnimationFrame(_);
|
|
} else
|
|
o.next(e);
|
|
this._handleMoveEvent(e);
|
|
}
|
|
_handleMoveEvent(e) {
|
|
const { features: t } = this._options;
|
|
(t.touch && H() || this._scrollAvailable && N()) && e.preventDefault();
|
|
}
|
|
_onScroll() {
|
|
const { _scrollDelta: e, _options: { document: t } } = this, { scrollTop: s, scrollLeft: i } = t.scrollingElement ?? t.body;
|
|
this._areaLocation.x1 += e.x - i, this._areaLocation.y1 += e.y - s, e.x = i, e.y = s, this._setupSelectionArea(), this._frame.next(null);
|
|
}
|
|
_onStartAreaScroll() {
|
|
this._targetBoundaryScrolled = true, g(this._targetElement, "scroll", this._onStartAreaScroll);
|
|
}
|
|
_wheelScroll(e) {
|
|
const { manualSpeed: t } = this._options.behaviour.scrolling, s = e.deltaY ? e.deltaY > 0 ? 1 : -1 : 0, i = e.deltaX ? e.deltaX > 0 ? 1 : -1 : 0;
|
|
this._scrollSpeed.y += s * t, this._scrollSpeed.x += i * t, this._onTapMove(e), e.preventDefault();
|
|
}
|
|
_keyboardScroll(e) {
|
|
const { manualSpeed: t } = this._options.behaviour.scrolling, s = e.key === "ArrowLeft" ? -1 : e.key === "ArrowRight" ? 1 : 0, i = e.key === "ArrowUp" ? -1 : e.key === "ArrowDown" ? 1 : 0;
|
|
this._scrollSpeed.x += Math.sign(s) * t, this._scrollSpeed.y += Math.sign(i) * t, e.preventDefault(), this._onTapMove({
|
|
clientX: this._lastMousePosition.x,
|
|
clientY: this._lastMousePosition.y,
|
|
preventDefault: () => {
|
|
}
|
|
});
|
|
}
|
|
_recalculateSelectionAreaRect() {
|
|
const { _scrollSpeed: e, _areaLocation: t, _targetElement: s, _options: i } = this, { scrollTop: o, scrollHeight: n, clientHeight: r, scrollLeft: a, scrollWidth: u, clientWidth: _ } = s, c = this._targetRect, { x1: p, y1: m } = t;
|
|
let { x2: f, y2: d } = t;
|
|
const { behaviour: { scrolling: { startScrollMargins: h } } } = i;
|
|
f < c.left + h.x ? (e.x = a ? -b(c.left - f + h.x) : 0, f = f < c.left ? c.left : f) : f > c.right - h.x ? (e.x = u - a - _ ? b(c.left + c.width - f - h.x) : 0, f = f > c.right ? c.right : f) : e.x = 0, d < c.top + h.y ? (e.y = o ? -b(c.top - d + h.y) : 0, d = d < c.top ? c.top : d) : d > c.bottom - h.y ? (e.y = n - o - r ? b(c.top + c.height - d - h.y) : 0, d = d > c.bottom ? c.bottom : d) : e.y = 0;
|
|
const v = B(p, f), w = B(m, d), j = C(p, f), K = C(m, d);
|
|
this._areaRect = M(v, w, j - v, K - w);
|
|
}
|
|
_redrawSelectionArea() {
|
|
const { x: e, y: t, width: s, height: i } = this._areaRect, { style: o } = this._area;
|
|
o.left = `${e}px`, o.top = `${t}px`, o.width = `${s}px`, o.height = `${i}px`;
|
|
}
|
|
_onTapStop(e, t) {
|
|
var n;
|
|
const { document: s, features: i } = this._options, { _singleClick: o } = this;
|
|
g(this._targetElement, "scroll", this._onStartAreaScroll), g(s, ["mousemove", "touchmove"], this._delayedTapMove), g(s, ["touchmove", "mousemove"], this._onTapMove), g(s, ["mouseup", "touchcancel", "touchend"], this._onTapStop), g(s, "scroll", this._onScroll), this._keepSelection(), e && o && i.singleTap.allow ? this._onSingleTap(e) : !o && !t && (this._updateElementSelection(), this._emitEvent("stop", e)), this._scrollSpeed.x = 0, this._scrollSpeed.y = 0, g(this._targetElement, "wheel", this._wheelScroll, { passive: true }), g(this._options.document, "keydown", this._keyboardScroll, { passive: true }), this._clippingElement.remove(), (n = this._frame) == null || n.cancel(), y(this._area, "display", "none");
|
|
}
|
|
_updateElementSelection() {
|
|
const { _selectables: e, _options: t, _selection: s, _areaRect: i } = this, { stored: o, selected: n, touched: r } = s, { intersect: a, overlap: u } = t.behaviour, _ = u === "invert", c = [], p = [], m = [];
|
|
for (let d = 0; d < e.length; d++) {
|
|
const h = e[d];
|
|
if (k(i, h.getBoundingClientRect(), a)) {
|
|
if (n.includes(h))
|
|
o.includes(h) && !r.includes(h) && r.push(h);
|
|
else if (_ && o.includes(h)) {
|
|
m.push(h);
|
|
continue;
|
|
} else
|
|
p.push(h);
|
|
c.push(h);
|
|
}
|
|
}
|
|
_ && p.push(...o.filter((d) => !n.includes(d)));
|
|
const f = u === "keep";
|
|
for (let d = 0; d < n.length; d++) {
|
|
const h = n[d];
|
|
!c.includes(h) && !// Check if the user wants to keep previously selected elements, e.g.,
|
|
// not make them part of the current selection as soon as they're touched.
|
|
(f && o.includes(h)) && m.push(h);
|
|
}
|
|
s.selected = c, s.changed = { added: p, removed: m }, this._latestElement = void 0;
|
|
}
|
|
_emitEvent(e, t) {
|
|
return this.emit(e, {
|
|
event: t,
|
|
store: this._selection,
|
|
selection: this
|
|
});
|
|
}
|
|
_keepSelection() {
|
|
const { _options: e, _selection: t } = this, { selected: s, changed: i, touched: o, stored: n } = t, r = s.filter((a) => !n.includes(a));
|
|
switch (e.behaviour.overlap) {
|
|
case "drop": {
|
|
t.stored = [
|
|
...r,
|
|
...n.filter((a) => !o.includes(a))
|
|
// Elements not touched
|
|
];
|
|
break;
|
|
}
|
|
case "invert": {
|
|
t.stored = [
|
|
...r,
|
|
...n.filter((a) => !i.removed.includes(a))
|
|
// Elements not removed from selection
|
|
];
|
|
break;
|
|
}
|
|
case "keep": {
|
|
t.stored = [
|
|
...n,
|
|
...s.filter((a) => !n.includes(a))
|
|
// Newly added
|
|
];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Manually triggers the start of a selection
|
|
* @param evt A MouseEvent / TouchEvent-like object
|
|
* @param silent If beforestart should be fired
|
|
*/
|
|
trigger(e, t = true) {
|
|
this._onTapStart(e, t);
|
|
}
|
|
/**
|
|
* Can be used if during a selection elements have been added
|
|
* Will update everything that can be selected
|
|
*/
|
|
resolveSelectables() {
|
|
this._selectables = E(this._options.selectables, this._options.document);
|
|
}
|
|
/**
|
|
* Same as deselecting, but for all elements currently selected
|
|
* @param includeStored If the store should also get cleared
|
|
* @param quiet If move / stop events should be fired
|
|
*/
|
|
clearSelection(e = true, t = false) {
|
|
const { selected: s, stored: i, changed: o } = this._selection;
|
|
o.added = [], o.removed.push(
|
|
...s,
|
|
...e ? i : []
|
|
), t || (this._emitEvent("move", null), this._emitEvent("stop", null)), this._selection = D(e ? [] : i);
|
|
}
|
|
/**
|
|
* @returns {Array} Selected elements
|
|
*/
|
|
getSelection() {
|
|
return this._selection.stored;
|
|
}
|
|
/**
|
|
* @returns {HTMLElement} The selection area element
|
|
*/
|
|
getSelectionArea() {
|
|
return this._area;
|
|
}
|
|
/**
|
|
* @returns {Element[]} Available selectable elements for current selection
|
|
*/
|
|
getSelectables() {
|
|
return this._selectables;
|
|
}
|
|
/**
|
|
* Set the location of the selection area
|
|
* @param location A partial AreaLocation object
|
|
*/
|
|
setAreaLocation(e) {
|
|
Object.assign(this._areaLocation, e), this._redrawSelectionArea();
|
|
}
|
|
/**
|
|
* @returns {AreaLocation} The current location of the selection area
|
|
*/
|
|
getAreaLocation() {
|
|
return this._areaLocation;
|
|
}
|
|
/**
|
|
* Cancel the current selection process, pass true to fire a stop event after cancel
|
|
* @param keepEvent If a stop event should be fired
|
|
*/
|
|
cancel(e = false) {
|
|
this._onTapStop(null, !e);
|
|
}
|
|
/**
|
|
* Unbinds all events and removes the area-element.
|
|
*/
|
|
destroy() {
|
|
this.cancel(), this.disable(), this._clippingElement.remove(), super.unbindAllListeners();
|
|
}
|
|
/**
|
|
* Adds elements to the selection
|
|
* @param query CSS Query, can be an array of queries
|
|
* @param quiet If this should not trigger the move event
|
|
*/
|
|
select(e, t = false) {
|
|
const { changed: s, selected: i, stored: o } = this._selection, n = E(e, this._options.document).filter(
|
|
(r) => !i.includes(r) && !o.includes(r)
|
|
);
|
|
return o.push(...n), i.push(...n), s.added.push(...n), s.removed = [], this._latestElement = void 0, t || (this._emitEvent("move", null), this._emitEvent("stop", null)), n;
|
|
}
|
|
/**
|
|
* Removes a particular element from the selection
|
|
* @param query CSS Query, can be an array of queries
|
|
* @param quiet If this should not trigger the move event
|
|
*/
|
|
deselect(e, t = false) {
|
|
const { selected: s, stored: i, changed: o } = this._selection, n = E(e, this._options.document).filter(
|
|
(r) => s.includes(r) || i.includes(r)
|
|
);
|
|
this._selection.stored = i.filter((r) => !n.includes(r)), this._selection.selected = s.filter((r) => !n.includes(r)), this._selection.changed.added = [], this._selection.changed.removed.push(
|
|
...n.filter((r) => !o.removed.includes(r))
|
|
), this._latestElement = void 0, t || (this._emitEvent("move", null), this._emitEvent("stop", null));
|
|
}
|
|
};
|
|
T.version = "3.9.0";
|
|
var P = T;
|
|
export {
|
|
P as default
|
|
};
|
|
/*! Bundled license information:
|
|
|
|
@viselect/vanilla/dist/viselect.mjs:
|
|
(*! @viselect/vanilla v3.9.0 MIT | https://github.com/Simonwep/selection/tree/master/packages/vanilla *)
|
|
*/
|
|
//# sourceMappingURL=@viselect_vanilla.js.map
|