@oscarpalmer/tabela 0.8.0 → 0.9.0

package/dist/tabela.full.js

@@ -383,6 +383,8 @@ var ColumnManager = class {
 		this.set(columns);
 	}
 	destroy() {
+		const { length } = this.items;
+		for (let index = 0; index < length; index += 1) this.items[index].destroy();
 		this.items.length = 0;
 	}
 	remove(value) {
@@ -392,7 +394,10 @@ var ColumnManager = class {
 		if (length === 0) return;
 		for (let fieldIndex = 0; fieldIndex < length; fieldIndex += 1) {
 			const itemIndex = items.findIndex((component) => component.options.field === fields[fieldIndex]);
-			if (itemIndex > -1) items.splice(itemIndex, 1);
+			if (itemIndex > -1) {
+				items[itemIndex].destroy();
+				items.splice(itemIndex, 1);
+			}
 		}
 		components.header.update(items);
 		components.footer.update(items);
@@ -498,6 +503,90 @@ function isPlainObject(value) {
 	const prototype = Object.getPrototypeOf(value);
 	return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
 }
+/**
+* Is the value a typed array?
+* @param value Value to check
+* @returns `true` if the value is a typed array, otherwise `false`
+*/
+function isTypedArray(value) {
+	TYPED_ARRAYS ??= new Set([
+		Int8Array,
+		Uint8Array,
+		Uint8ClampedArray,
+		Int16Array,
+		Uint16Array,
+		Int32Array,
+		Uint32Array,
+		Float32Array,
+		Float64Array,
+		BigInt64Array,
+		BigUint64Array
+	]);
+	return TYPED_ARRAYS.has(value?.constructor);
+}
+var TYPED_ARRAYS;
+/**
+* Chunk an array into smaller arrays
+* @param array Array to chunk
+* @param size Size of each chunk _(minimum is `1`, maximum is `5000`; defaults to `5000`)_
+* @returns Array of arrays
+*/
+function chunk(array, size) {
+	if (!Array.isArray(array)) return [];
+	if (array.length === 0) return [];
+	const { length } = array;
+	const actualSize = typeof size === "number" && size > 0 && size <= MAX_SIZE ? size : MAX_SIZE;
+	if (length <= actualSize) return [array];
+	const chunks = [];
+	let index = 0;
+	while (index < length) {
+		chunks.push(array.slice(index, index + actualSize));
+		index += actualSize;
+	}
+	return chunks;
+}
+var MAX_SIZE = 5e3;
+function compact(array, strict) {
+	if (!Array.isArray(array)) return [];
+	if (strict === true) return array.filter(Boolean);
+	const { length } = array;
+	const compacted = [];
+	for (let index = 0; index < length; index += 1) {
+		const item = array[index];
+		if (item != null) compacted.push(item);
+	}
+	return compacted;
+}
+function insertChunkedValues(type, array, items, start, deleteCount) {
+	const actualDeleteCount = deleteCount < 0 ? 0 : deleteCount;
+	const actualStart = Math.min(Math.max(0, start), array.length);
+	const chunked = chunk(items);
+	const lastIndex = chunked.length - 1;
+	let index = Number(chunked.length);
+	let returned;
+	while (index > 0) {
+		index -= 1;
+		const spliced = array.splice(actualStart, index === lastIndex ? actualDeleteCount : 0, ...chunked[index]);
+		if (returned == null) returned = spliced;
+		else returned.push(...spliced);
+	}
+	if (type === "insert") return array;
+	return type === "splice" ? returned : array.length;
+}
+function insertValues(type, array, items, start, deleteCount) {
+	const spliceArray = type === "insert" || type === "splice";
+	if (!Array.isArray(array) || typeof start !== "number" || !Array.isArray(items) || items.length === 0) return spliceArray ? [] : 0;
+	return insertChunkedValues(type, array, items, start, spliceArray ? deleteCount : 0);
+}
+/**
+* Push items into an array _(at the end)_
+* @param array Original array
+* @param pushed Pushed items
+* @returns New length of the array
+*/
+function push(array, pushed) {
+	return insertValues("push", array, pushed, array.length, 0);
+}
 function aggregate(type, array, key) {
 	const length = Array.isArray(array) ? array.length : 0;
 	if (length === 0) return {
@@ -556,6 +645,15 @@ function getString(value) {
 	return asString.startsWith("[object ") ? JSON.stringify(value) : asString;
 }
 /**
+* Join an array of values into a string
+* @param value Array of values
+* @param delimiter Delimiter to use between values
+* @returns Joined string
+*/
+function join(value, delimiter) {
+	return compact(value).map(getString).join(typeof delimiter === "string" ? delimiter : "");
+}
+/**
 * Split a string into words _(and other readable parts)_
 * @param value Original string
 * @returns Array of words found in the string
@@ -659,7 +757,7 @@ function compareSymbols(first, second) {
 }
 function compareValue(first, second, compareStrings) {
 	const firstType = typeof first;
-	if (firstType === typeof second && firstType in comparators) return comparators[firstType](first, second);
+	if (firstType === typeof second && firstType in comparators$1) return comparators$1[firstType](first, second);
 	if (first instanceof Date && second instanceof Date) return compareNumbers(first.getTime(), second.getTime());
 	return compare.handlers.handle(first, second, compareStrings);
 }
@@ -667,7 +765,7 @@ function getComparisonParts(value) {
 	if (Array.isArray(value)) return value;
 	return typeof value === "object" ? [value] : words(getString(value));
 }
-var comparators = {
+var comparators$1 = {
 	bigint: compareNumbers,
 	boolean: compareNumbers,
 	number: compareNumbers,
@@ -780,7 +878,7 @@ var DataManager = class {
 	}
 	async add(data, render) {
 		const { field, values } = this;
-		values.objects.array.push(...data);
+		push(values.objects.array, data);
 		values.objects.mapped = toMap(values.objects.array, field);
 		if (render) this.render();
 	}
@@ -793,6 +891,7 @@ var DataManager = class {
 		values.keys.active = void 0;
 		values.keys.original.length = 0;
 		values.objects.array.length = 0;
+		this.handlers = void 0;
 	}
 	get(active) {
 		const { values } = this;
@@ -816,7 +915,8 @@ var DataManager = class {
 	render() {
 		const { field, managers, values } = this;
 		values.keys.original = sort(values.objects.array.map((item) => item[field]));
-		if (managers.sort.items.length > 0) managers.sort.sort();
+		if (Object.keys(managers.filter.items).length > 0) managers.filter.filter();
+		else if (managers.sort.items.length > 0) managers.sort.sort();
 		else managers.virtualization.update(true);
 	}
 	set(data) {
@@ -1158,7 +1258,7 @@ var EventManager = class {
 	listener;
 	constructor(managers, element) {
 		this.managers = managers;
-		on(element, "click", (event) => {
+		this.listener = on(element, "click", (event) => {
 			this.onClick(event);
 		}, { passive: false });
 	}
@@ -1181,6 +1281,489 @@ var EventManager = class {
 		if (field != null) managers.sort.toggle(event, field, direction);
 	}
 };
+/**
+* Clamp a number between a minimum and maximum value
+* @param value Value to clamp
+* @param minimum Minimum value
+* @param maximum Maximum value
+* @param loop If `true`, the value will loop around when smaller than the minimum or larger than the maximum _(defaults to `false`)_
+* @returns Clamped value
+*/
+function clamp(value, minimum, maximum, loop) {
+	if (![
+		value,
+		minimum,
+		maximum
+	].every(isNumber)) return NaN;
+	if (value < minimum) return loop === true ? maximum : minimum;
+	return value > maximum ? loop === true ? minimum : maximum : value;
+}
+/**
+* Get the number value from an unknown value _(based on Lodash)_
+* @param value Original value
+* @returns Original value as a number, or `NaN` if the value is unable to be parsed
+*/
+function getNumber(value) {
+	if (typeof value === "number") return value;
+	if (typeof value === "bigint" || typeof value === "boolean") return Number(value);
+	if (value == null || typeof value === "symbol") return NaN;
+	if (typeof value === "function") return getNumber(value());
+	let parsed = value.valueOf();
+	if (typeof parsed === "object") parsed = parsed.toString();
+	if (typeof parsed !== "string") return getNumber(parsed);
+	const trimmed = parsed.trim();
+	if (trimmed.length === 0) return NaN;
+	if (EXPRESSION_ZEROISH.test(parsed)) return 0;
+	const isBinary = EXPRESSION_BINARY.test(trimmed);
+	if (isBinary || EXPRESSION_OCTAL.test(trimmed)) return Number.parseInt(trimmed.slice(2), isBinary ? 2 : OCTAL_VALUE);
+	return Number(EXPRESSION_HEX.test(trimmed) ? trimmed : trimmed.replace(EXPRESSION_UNDERSCORE, ""));
+}
+var EXPRESSION_BINARY = /^0b[01]+$/i;
+var EXPRESSION_HEX = /^0x[0-9a-f]+$/i;
+var EXPRESSION_OCTAL = /^0o[0-7]+$/i;
+var EXPRESSION_UNDERSCORE = /_/g;
+var EXPRESSION_ZEROISH = /^\s*0+\s*$/;
+var OCTAL_VALUE = 8;
+function getSizedMaximum(first, second) {
+	let actual;
+	if (typeof first === "number") actual = first;
+	else actual = typeof second === "number" ? second : MAXIMUM_DEFAULT;
+	return clamp(actual, 1, MAXIMUM_ABSOLUTE);
+}
+var MAXIMUM_ABSOLUTE = 16777216;
+var MAXIMUM_DEFAULT = 1048576;
+/**
+* A Map with a maximum size
+*
+* Behavior is similar to a _LRU_-cache, where the least recently used entries are removed
+*/
+var SizedMap = class extends Map {
+	/**
+	* The maximum size of the Map
+	*/
+	#maximumSize;
+	/**
+	* Is the Map full?
+	*/
+	get full() {
+		return this.size >= this.#maximumSize;
+	}
+	get maximum() {
+		return this.#maximumSize;
+	}
+	constructor(first, second) {
+		const maximum = getSizedMaximum(first, second);
+		super();
+		this.#maximumSize = maximum;
+		if (Array.isArray(first)) {
+			const { length } = first;
+			if (length <= maximum) for (let index = 0; index < length; index += 1) this.set(...first[index]);
+			else for (let index = 0; index < maximum; index += 1) this.set(...first[length - maximum + index]);
+		}
+	}
+	/**
+	* @inheritdoc
+	*/
+	get(key) {
+		const value = super.get(key);
+		if (value !== void 0 || this.has(key)) this.set(key, value);
+		return value;
+	}
+	/**
+	* @inheritdoc
+	*/
+	set(key, value) {
+		if (this.has(key)) this.delete(key);
+		else if (this.size >= this.#maximumSize) this.delete(this.keys().next().value);
+		return super.set(key, value);
+	}
+};
+var Memoized = class {
+	#state;
+	/**
+	* Maximum cache size
+	*/
+	get maximum() {
+		return this.#state.cache?.maximum ?? NaN;
+	}
+	/**
+	* Current cache size
+	*/
+	get size() {
+		return this.#state.cache?.size ?? NaN;
+	}
+	constructor(callback, options) {
+		const cache = new SizedMap(options.cacheSize);
+		const getter = (...parameters) => {
+			const key = options.cacheKey?.(...parameters) ?? (parameters.length === 1 ? parameters[0] : join(parameters.map(getString), "_"));
+			if (cache.has(key)) return cache.get(key);
+			const value = callback(...parameters);
+			cache.set(key, value);
+			return value;
+		};
+		this.#state = {
+			cache,
+			getter
+		};
+	}
+	/**
+	* Clear the cache
+	*/
+	clear() {
+		this.#state.cache?.clear();
+	}
+	/**
+	* Delete a result from the cache
+	* @param key Key to delete
+	* @returns `true` if the key existed and was removed, otherwise `false`
+	*/
+	delete(key) {
+		return this.#state.cache?.delete(key) ?? false;
+	}
+	/**
+	* Destroy the instance _(clearing its cache and removing its callback)_
+	*/
+	destroy() {
+		this.#state.cache?.clear();
+		this.#state.cache = void 0;
+		this.#state.getter = void 0;
+	}
+	/**
+	* Get a result from the cache
+	* @param key Key to get
+	* @returns Cached result or `undefined` if it does not exist
+	*/
+	get(key) {
+		return this.#state.cache?.get(key);
+	}
+	/**
+	* Does the result exist?
+	* @param key Key to check
+	* @returns `true` if the result exists, otherwise `false`
+	*/
+	has(key) {
+		return this.#state.cache?.has(key) ?? false;
+	}
+	/**
+	* Run the callback with the provided parameters
+	* @param parameters Parameters to pass to the callback
+	* @returns Cached or computed _(then cached)_ result
+	*/
+	run(...parameters) {
+		if (this.#state.cache == null || this.#state.getter == null) throw new Error("The Memoized instance has been destroyed");
+		return this.#state.getter(...parameters);
+	}
+};
+function getMemoizationOptions(input) {
+	const { cacheKey, cacheSize } = isPlainObject(input) ? input : {};
+	return {
+		cacheKey: typeof cacheKey === "function" ? cacheKey : void 0,
+		cacheSize: typeof cacheSize === "number" && cacheSize > 0 ? cacheSize : DEFAULT_CACHE_SIZE
+	};
+}
+/**
+* Memoize a function, caching and retrieving results based on the first parameter
+* @param callback Callback to memoize
+* @param options Memoization options
+* @returns Memoized instance
+*/
+function memoize(callback, options) {
+	return new Memoized(callback, getMemoizationOptions(options));
+}
+var DEFAULT_CACHE_SIZE = 1024;
+/**
+* Check if a string ends with a specified substring
+* @param haystack String to look in
+* @param needle String to look for
+* @param ignoreCase Ignore case when matching? _(defaults to `false`)_
+* @returns `true` if the string ends with the given substring, otherwise `false`
+*/
+function endsWith(haystack, needle, ignoreCase) {
+	return match("endsWith", haystack, needle, ignoreCase === true);
+}
+/**
+* Check if a string includes a specified substring
+* @param haystack String to look in
+* @param needle String to look for
+* @param ignoreCase Ignore case when matching? _(defaults to `false`)_
+* @returns `true` if the string includes the given substring, otherwise `false`
+*/
+function includes(haystack, needle, ignoreCase) {
+	return match("includes", haystack, needle, ignoreCase === true);
+}
+function match(type, haystack, needle, ignoreCase) {
+	if (typeof haystack !== "string" || typeof needle !== "string") return false;
+	matchMemoizers[type] ??= memoize(matchCallback.bind(type));
+	return matchMemoizers[type].run(haystack, needle, ignoreCase);
+}
+function matchCallback(haystack, needle, ignoreCase) {
+	return (ignoreCase ? haystack.toLocaleLowerCase() : haystack)[this](ignoreCase ? needle.toLocaleLowerCase() : needle);
+}
+/**
+* Check if a string starts with a specified substring
+* @param haystack String to look in
+* @param needle String to look for
+* @param ignoreCase Ignore case when matching? _(defaults to `false`)_
+* @returns `true` if the string starts with the given substring, otherwise `false`
+*/
+function startsWith(haystack, needle, ignoreCase) {
+	return match("startsWith", haystack, needle, ignoreCase === true);
+}
+var matchMemoizers = {};
+function equal(first, second, options) {
+	return equalValue(first, second, getEqualOptions(options));
+}
+equal.handlers = getCompareHandlers(equal, { callback: Object.is });
+equal.initialize = initializeEqualizer;
+equal.register = registerEqualizer;
+equal.unregister = unregisterEqualizer;
+function equalArray(first, second, options) {
+	const { length } = first;
+	if (length !== second.length) return false;
+	let offset = 0;
+	if (length >= ARRAY_THRESHOLD) {
+		offset = Math.round(length / ARRAY_PEEK_PERCENTAGE);
+		offset = offset > ARRAY_THRESHOLD ? ARRAY_THRESHOLD : offset;
+		for (let index = 0; index < offset; index += 1) if (!(equalValue(first[index], second[index], options) && equalValue(first[length - index - 1], second[length - index - 1], options))) return false;
+	}
+	const firstChunks = chunk(first.slice(offset, length - offset), ARRAY_THRESHOLD);
+	const secondChunks = chunk(second.slice(offset, length - offset), ARRAY_THRESHOLD);
+	const chunksLength = firstChunks.length;
+	for (let chunkIndex = 0; chunkIndex < chunksLength; chunkIndex += 1) {
+		const firstChunk = firstChunks[chunkIndex];
+		const secondChunk = secondChunks[chunkIndex];
+		const chunkLength = firstChunk.length;
+		for (let index = 0; index < chunkLength; index += 1) if (!equalValue(firstChunk[index], secondChunk[index], options)) return false;
+	}
+	return true;
+}
+function equalArrayBuffer(first, second, options) {
+	return first.byteLength === second.byteLength ? equalArray(new Uint8Array(first), new Uint8Array(second), options) : false;
+}
+function equalDataView(first, second, options) {
+	return first.byteOffset === second.byteOffset ? equalArrayBuffer(first.buffer, second.buffer, options) : false;
+}
+function equalMap(first, second, options) {
+	const { size } = first;
+	if (size !== second.size) return false;
+	const firstKeys = [...first.keys()];
+	const secondKeys = [...second.keys()];
+	if (firstKeys.some((key) => !secondKeys.includes(key))) return false;
+	for (let index = 0; index < size; index += 1) {
+		const key = firstKeys[index];
+		if (!equalValue(first.get(key), second.get(key), options)) return false;
+	}
+	return true;
+}
+function equalPlainObject(first, second, options) {
+	let firstKeys = [...Object.keys(first), ...Object.getOwnPropertySymbols(first)];
+	let secondKeys = [...Object.keys(second), ...Object.getOwnPropertySymbols(second)];
+	if (options.ignoreKeys.enabled || options.ignoreExpressions.enabled) {
+		firstKeys = firstKeys.filter((key) => filterKey(key, options));
+		secondKeys = secondKeys.filter((key) => filterKey(key, options));
+	}
+	const { length } = firstKeys;
+	if (length !== secondKeys.length || firstKeys.some((key) => !secondKeys.includes(key))) return false;
+	for (let index = 0; index < length; index += 1) {
+		const key = firstKeys[index];
+		if (!equalValue(first[key], second[key], options)) return false;
+	}
+	return true;
+}
+function equalProperties(first, second, properties, options) {
+	const { length } = properties;
+	for (let index = 0; index < length; index += 1) {
+		const property = properties[index];
+		if (!equalValue(first[property], second[property], options)) return false;
+	}
+	return true;
+}
+function equalSet(first, second, options) {
+	const { size } = first;
+	if (size !== second.size) return false;
+	const firstValues = [...first];
+	const secondValues = [...second];
+	for (let index = 0; index < size; index += 1) {
+		const firstValue = firstValues[index];
+		if (!secondValues.some((secondValue) => equalValue(firstValue, secondValue, options))) return false;
+	}
+	return true;
+}
+function equalTypedArray(first, second) {
+	if (first.constructor !== second.constructor) return false;
+	if (first.byteLength !== second.byteLength) return false;
+	const { length } = first;
+	for (let index = 0; index < length; index += 1) if (first[index] !== second[index]) return false;
+	return true;
+}
+function equalValue(first, second, options) {
+	if (options.relaxedNullish && first == null && second == null) return true;
+	switch (true) {
+		case Object.is(first, second): return true;
+		case first == null || second == null: return first === second;
+		case typeof first !== typeof second: return false;
+		case typeof first === "string" && options.ignoreCase === true: return Object.is(first.toLocaleLowerCase(), second.toLocaleLowerCase());
+		case first instanceof ArrayBuffer && second instanceof ArrayBuffer: return equalArrayBuffer(first, second, options);
+		case first instanceof Date && second instanceof Date: return Object.is(Number(first), Number(second));
+		case first instanceof DataView && second instanceof DataView: return equalDataView(first, second, options);
+		case first instanceof Error && second instanceof Error: return equalProperties(first, second, ["name", "message"], options);
+		case first instanceof Map && second instanceof Map: return equalMap(first, second, options);
+		case first instanceof RegExp && second instanceof RegExp: return equalProperties(first, second, ["source", "flags"], options);
+		case first instanceof Set && second instanceof Set: return equalSet(first, second, options);
+		case Array.isArray(first) && Array.isArray(second): return equalArray(first, second, options);
+		case isPlainObject(first) && isPlainObject(second): return equalPlainObject(first, second, options);
+		case isTypedArray(first) && isTypedArray(second): return equalTypedArray(first, second);
+		default: return equal.handlers.handle(first, second, options);
+	}
+}
+/**
+* Create an equalizer with predefined options
+* @param options Comparison options
+* @returns Equalizer function
+*/
+function initializeEqualizer(options) {
+	const actual = getEqualOptions(options);
+	const equalizer = (first, second) => equalValue(first, second, actual);
+	equalizer.register = registerEqualizer;
+	equalizer.unregister = unregisterEqualizer;
+	return equalizer;
+}
+/**
+* Register a equality comparison function for a specific class
+* @param constructor Class constructor
+* @param fn Comparison function
+*/
+function registerEqualizer(constructor, handler) {
+	equal.handlers.register(constructor, handler);
+}
+/**
+* Unregister a equality comparison handler for a specific class
+* @param constructor Class constructor
+*/
+function unregisterEqualizer(constructor) {
+	equal.handlers.unregister(constructor);
+}
+function filterKey(key, options) {
+	if (typeof key !== "string") return true;
+	if (options.ignoreExpressions.enabled && options.ignoreExpressions.values.some((expression) => expression.test(key))) return false;
+	if (options.ignoreKeys.enabled && options.ignoreKeys.values.has(key)) return false;
+	return true;
+}
+function getEqualOptions(input) {
+	const options = {
+		ignoreCase: false,
+		ignoreExpressions: {
+			enabled: false,
+			values: []
+		},
+		ignoreKeys: {
+			enabled: false,
+			values: /* @__PURE__ */ new Set()
+		},
+		relaxedNullish: false
+	};
+	if (typeof input === "boolean") {
+		options.ignoreCase = input;
+		return options;
+	}
+	if (!isPlainObject(input)) return options;
+	options.ignoreCase = typeof input.ignoreCase === "boolean" ? input.ignoreCase : false;
+	options.ignoreExpressions.values = (Array.isArray(input.ignoreKeys) ? input.ignoreKeys : [input.ignoreKeys]).filter((key) => key instanceof RegExp);
+	options.ignoreKeys.values = new Set((Array.isArray(input.ignoreKeys) ? input.ignoreKeys : [input.ignoreKeys]).filter((key) => typeof key === "string"));
+	options.ignoreExpressions.enabled = options.ignoreExpressions.values.length > 0;
+	options.ignoreKeys.enabled = options.ignoreKeys.values.size > 0;
+	options.relaxedNullish = input.relaxedNullish === true;
+	return options;
+}
+var ARRAY_PEEK_PERCENTAGE = 10;
+var ARRAY_THRESHOLD = 100;
+var FilterManager = class {
+	handlers = Object.freeze({
+		add: (item) => this.add(item),
+		clear: () => this.clear(),
+		remove: (value) => this.remove(value),
+		set: (items) => this.set(items)
+	});
+	items = {};
+	constructor(managers) {
+		this.managers = managers;
+	}
+	add(item) {
+		if (this.items[item.field] == null) this.items[item.field] = [];
+		else if (this.items[item.field].findIndex((existing) => equal(existing, item)) !== -1) return;
+		this.items[item.field].push(item);
+		this.filter();
+	}
+	clear() {
+		if (Object.keys(this.items).length > 0) {
+			this.items = {};
+			this.filter();
+		}
+	}
+	destroy() {
+		this.handlers = void 0;
+		this.items = {};
+	}
+	filter() {
+		const { managers } = this;
+		const filtered = [];
+		const filters = Object.entries(this.items);
+		const keysLength = managers.data.values.keys.original.length;
+		rowLoop: for (let keyIndex = 0; keyIndex < keysLength; keyIndex += 1) {
+			const key = managers.data.values.keys.original[keyIndex];
+			const row = managers.data.values.objects.mapped.get(key);
+			if (row == null) continue;
+			filterLoop: for (let filterIndex = 0; filterIndex < filters.length; filterIndex += 1) {
+				const [field, items] = filters[filterIndex];
+				const value = row[field];
+				for (let itemIndex = 0; itemIndex < items.length; itemIndex += 1) {
+					const filter = items[itemIndex];
+					if (comparators[filter.comparison](value, filter.value)) continue filterLoop;
+				}
+				continue rowLoop;
+			}
+			filtered.push(key);
+		}
+		managers.data.values.keys.active = filtered;
+		if (managers.sort.items.length > 0) managers.sort.sort();
+		else managers.virtualization.update(true, true);
+	}
+	remove(value) {
+		if (typeof value === "string") {
+			if (this.items[value] == null) return;
+			this.items = {};
+		} else {
+			const { field } = value;
+			if (this.items[field] == null) return;
+			if (this.items[field].findIndex((item) => equal(item, value)) === -1) return;
+		}
+		this.filter();
+	}
+	set(items) {
+		const keyed = {};
+		const { length } = items;
+		for (let index = 0; index < length; index += 1) {
+			const item = items[index];
+			keyed[item.field] ??= [];
+			keyed[item.field].push(item);
+		}
+		this.items = keyed;
+		this.filter();
+	}
+};
+const comparators = {
+	contains: (row, filter) => includes(getString(row), getString(filter), true),
+	"ends-with": (row, filter) => endsWith(getString(row), getString(filter), true),
+	equals: (row, filter) => equalizer(row, filter),
+	"greater-than": (row, filter) => getNumber(row) > getNumber(filter),
+	"greater-than-or-equal": (row, filter) => getNumber(row) >= getNumber(filter),
+	"less-than": (row, filter) => getNumber(row) < getNumber(filter),
+	"less-than-or-equal": (row, filter) => getNumber(row) <= getNumber(filter),
+	"not-contains": (row, filter) => !includes(getString(row), getString(filter), true),
+	"not-equals": (row, filter) => !equalizer(row, filter),
+	"starts-with": (row, filter) => startsWith(getString(row), getString(filter), true)
+};
+const equalizer = equal.initialize({ ignoreCase: true });
 function removeRow(pool, row) {
 	if (row.element != null) {
 		row.element.innerHTML = "";
@@ -1223,6 +1806,9 @@ var RowManager = class {
 		this.height = rowHeight;
 	}
 	destroy() {
+		const components = [...this.components.values()];
+		const { length } = components;
+		for (let index = 0; index < length; index += 1) removeRow(this.managers.virtualization.pool, components[index]);
 		this.components.clear();
 	}
 	get(key) {
@@ -1237,7 +1823,11 @@ var RowManager = class {
 		return this.components.has(key);
 	}
 	remove(key) {
-		this.components.delete(key);
+		const row = this.components.get(key);
+		if (row != null) {
+			removeRow(this.managers.virtualization.pool, row);
+			this.components.delete(key);
+		}
 	}
 	update(key) {
 		const row = this.components.get(key);
@@ -1267,13 +1857,19 @@ var SortManager = class {
 	addOrSet(event, field) {
 		if (event.ctrlKey || event.metaKey) this.add(field);
 		else this.set([{
-			key: field,
+			field,
 			direction: "ascending"
 		}]);
 	}
 	clear() {
+		if (this.items.length > 0) {
+			this.items.length = 0;
+			this.sort();
+		}
+	}
+	destroy() {
+		this.handlers = void 0;
 		this.items.length = 0;
-		this.sort();
 	}
 	flip(field) {
 		const item = this.items.find((item) => item.key === field);
@@ -1293,14 +1889,17 @@ var SortManager = class {
 		else this.clear();
 	}
 	set(items) {
-		this.items.splice(0, this.items.length, ...items);
+		this.items.splice(0, this.items.length, ...items.map((item) => ({
+			key: item.field,
+			direction: item.direction
+		})));
 		this.sort();
 	}
 	sort() {
 		const { items, managers } = this;
-		managers.data.values.keys.active = items.length === 0 ? void 0 : sort(managers.data.values.objects.array, items).map((row) => row[managers.data.field]);
-		managers.virtualization.update(true, true);
-		for (const column of managers.column.items) {
+		const { length } = managers.column.items;
+		for (let index = 0; index < length; index += 1) {
+			const column = managers.column.items[index];
 			const sorterIndex = items.findIndex((item) => item.key === column.options.field);
 			const sorterItem = items[sorterIndex];
 			setAttributes(column.elements.wrapper, {
@@ -1309,6 +1908,8 @@ var SortManager = class {
 			});
 			setAttribute(column.elements.sorter, "data-sort-position", sorterIndex > -1 && items.length > 1 ? sorterIndex + 1 : void 0);
 		}
+		managers.data.values.keys.active = items.length === 0 ? void 0 : sort(managers.data.values.keys.active?.map((key) => managers.data.values.objects.mapped.get(key)) ?? managers.data.values.objects.array, items).map((row) => row[managers.data.field]);
+		managers.virtualization.update(true, true);
 	}
 	toggle(event, field, direction) {
 		switch (direction) {
@@ -1373,6 +1974,8 @@ var VirtualizationManager = class {
 		}
 		this.pool.cells = {};
 		this.pool.rows = [];
+		this.listener = void 0;
+		this.visible = void 0;
 	}
 	removeCells(fields) {
 		const { length } = fields;
@@ -1432,11 +2035,13 @@ var Tabela = class {
 		column: void 0,
 		data: void 0,
 		event: void 0,
+		filter: void 0,
 		row: void 0,
 		sort: void 0,
 		virtualization: void 0
 	};
 	data;
+	filter;
 	sort;
 	get key() {
 		return this.#key;
@@ -1454,12 +2059,14 @@ var Tabela = class {
 		this.#managers.column = new ColumnManager(this.#managers, this.#components, options.columns);
 		this.#managers.data = new DataManager(this.#managers, this.#components, options.key);
 		this.#managers.event = new EventManager(this.#managers, this.#element);
+		this.#managers.filter = new FilterManager(this.#managers);
 		this.#managers.row = new RowManager(this.#managers, options.rowHeight);
 		this.#managers.sort = new SortManager(this.#managers);
 		this.#managers.virtualization = new VirtualizationManager(this.#managers, this.#components);
 		element.append(this.#components.header.elements.group, this.#components.body.elements.group, this.#components.footer.elements.group);
 		this.#managers.data.set(options.data);
 		this.data = this.#managers.data.handlers;
+		this.filter = this.#managers.filter.handlers;
 		this.sort = this.#managers.sort.handlers;
 	}
 	destroy() {
@@ -1471,7 +2078,10 @@ var Tabela = class {
 		components.header.destroy();
 		managers.column.destroy();
 		managers.data.destroy();
+		managers.event.destroy();
+		managers.filter.destroy();
 		managers.row.destroy();
+		managers.sort.destroy();
 		managers.virtualization.destroy();
 		element.innerHTML = "";
 		element.role = "";