@oscarpalmer/atoms 0.196.0 → 0.197.0

package/dist/internal/math/aggregate.d.mts

@@ -49,7 +49,7 @@ declare function max<Item>(items: Item[], callback: (item: Item, index: number,
  * @param first Return only the first item with the maximum value
  * @returns Item with the maximum value, or `undefined` if no maximum can be found
  */
-declare function max<Item extends PlainObject, ItemKey extends keyof NumericalValues<Item>>(items: Item[], key: ItemKey, first: true): Item | undefined;
+declare function max<Item extends PlainObject>(items: Item[], key: keyof NumericalValues<Item>, first: true): Item | undefined;
 /**
  * Get the maximum value from a list of items
  *
@@ -85,7 +85,7 @@ declare function max<Item>(items: Item[], callback: (item: Item, index: number,
  * @param key Key to use for value
  * @returns Items with the maximum value
  */
-declare function max<Item extends PlainObject, ItemKey extends keyof NumericalValues<Item>>(items: Item[], key: ItemKey): Item[];
+declare function max<Item extends PlainObject>(items: Item[], key: keyof NumericalValues<Item>): Item[];
 /**
  * Get the maximum value from a list of numbers
  *

package/dist/internal/sized/map.mjs

@@ -33,11 +33,12 @@ var SizedMap = class extends Map {
 	* @inheritdoc
 	*/
 	get(key) {
+		let value;
 		if (super.has(key)) {
-			const value = super.get(key);
+			value = super.get(key);
 			this.#setValue(key, value, true);
-			return value;
 		}
+		return value;
 	}
 	/**
 	* @inheritdoc

package/dist/internal/value/compare.d.mts

@@ -10,12 +10,12 @@ type Comparator<Value = any> = (first: Value, second: Value) => number;
  */
 declare function compare(first: unknown, second: unknown): number;
 declare namespace compare {
+  var deregister: typeof deregisterComparator;
   var handlers: {
     deregister(constructor: Constructor): void;
     handle(first: unknown, second: unknown, ...parameters: unknown[]): number;
     register(constructor: Constructor, handler?: string | GenericCallback): void;
   };
-  var deregister: typeof deregisterComparator;
   var register: typeof registerComparator;
 }
 /**

package/dist/internal/value/compare.mjs

@@ -32,14 +32,6 @@ function compare(first, second) {
 	}
 	return 0;
 }
-compare.handlers = getCompareHandlers(compare, {
-	callback: (first, second, compareStrings) => {
-		if (compareStrings) return getString(first).localeCompare(getString(second));
-	},
-	method: COMPARE_NAME
-});
-compare.deregister = deregisterComparator;
-compare.register = registerComparator;
 function compareNumbers(first, second) {
 	if (Object.is(first, second)) return 0;
 	if (Number.isNaN(first)) return -1;
@@ -86,5 +78,17 @@ const comparators = {
 	number: compareNumbers,
 	symbol: compareSymbols
 };
+const compareHandlers = getCompareHandlers(compare, {
+	callback: (first, second, compareStrings) => compareStrings ? getString(first).localeCompare(getString(second)) : void 0,
+	method: COMPARE_NAME
+});
+compare.deregister = deregisterComparator;
+compare.handlers = compareHandlers;
+compare.register = registerComparator;
+Object.defineProperties(compare, {
+	deregister: { value: deregisterComparator },
+	handlers: { value: compareHandlers },
+	register: { value: registerComparator }
+});
 //#endregion
 export { compare, deregisterComparator, registerComparator };

package/dist/internal/value/handlers.d.mts

@@ -11,7 +11,7 @@ declare function getCompareHandlers<Value>(owner: GenericCallback, options: Opti
 };
 declare function getSelfHandlers(owner: GenericCallback, options: Options): {
   deregister(constructor: Constructor): void;
-  handle(value: unknown, ...parameters: unknown[]): any;
+  handle(value: unknown, ...parameters: unknown[]): unknown;
   register(constructor: Constructor, handler?: string | GenericCallback): void;
 };
 //#endregion

package/dist/internal/value/has.mjs

@@ -3,9 +3,10 @@ import { getNestedValue } from "./misc.mjs";
 function hasValue(data, path, ignoreCase) {
 	return getNestedValue(data, path, ignoreCase === true).ok;
 }
-hasValue.get = hasValueResult;
 function hasValueResult(data, path, ignoreCase) {
 	return getNestedValue(data, path, ignoreCase === true);
 }
+hasValue.get = hasValueResult;
+Object.defineProperty(hasValue, "get", { value: hasValueResult });
 //#endregion
 export { hasValue, hasValueResult };

package/dist/math.d.mts

@@ -95,18 +95,18 @@ declare function median(array: number[]): number;
  * @param items List of items
  * @param callback Callback to get an item's value
  * @param first Return only the first item with the minimum value
- * @returns Items with the minimum value
+ * @returns First item with the minimum value, or `undefined` if no minimum can be found
  */
-declare function min<Item>(items: Item[], callback: (item: Item, index: number, array: Item[]) => number, first: true): Item[];
+declare function min<Item>(items: Item[], callback: (item: Item, index: number, array: Item[]) => number, first: true): Item | undefined;
 /**
  * Get the minimum value from a list of items
  *
  * @param items List of items
  * @param key Key to use for value
  * @param first Return only the first item with the minimum value
- * @returns Items with the minimum value
+ * @returns First item with the minimum value, or `undefined` if no minimum can be found
  */
-declare function min<Item extends PlainObject>(items: Item[], key: keyof NumericalValues<Item>, first: true): Item[];
+declare function min<Item extends PlainObject>(items: Item[], key: keyof NumericalValues<Item>, first: true): Item | undefined;
 /**
  * Get the minimum value from a list of items
  *

package/dist/promise/index.mjs

@@ -66,9 +66,10 @@ async function promises(items, options) {
 		}));
 	});
 }
-promises.result = resultPromises;
 async function resultPromises(items, signal) {
 	return promises(items, signal).then(getResultsFromPromises);
 }
+promises.result = resultPromises;
+Object.defineProperty(promises, "result", { value: resultPromises });
 //#endregion
 export { attemptPromise, promises, resultPromises };

package/dist/queue.mjs

@@ -241,7 +241,6 @@ function keyedQueue(callback, options) {
 function queue(callback, options) {
 	return createQueue(callback, options);
 }
-queue.keyed = keyedQueue;
 function removeQueue(state, key, id) {
 	if (key == null) {
 		handleQueues(state, QUEUE_HANDLE_CLEAR);
@@ -317,5 +316,7 @@ const QUEUE_STATUS_ACTIVE = "active";
 const QUEUE_STATUS_EMPTY = "empty";
 const QUEUE_STATUS_FULL = "full";
 const QUEUE_STATUS_PAUSED = "paused";
+queue.keyed = keyedQueue;
+Object.defineProperty(queue, "keyed", { value: keyedQueue });
 //#endregion
 export { QueueError, isKeyedQueue, isQueue, isQueueInstance, keyedQueue, queue };

package/dist/sized/set.mjs

@@ -45,13 +45,12 @@ var SizedSet = class extends Set {
 	* @returns Found value if it exists, otherwise `undefined`
 	*/
 	get(value, update) {
-		if (super.has(value)) {
-			if (update ?? false) {
-				super.delete(value);
-				this.add(value);
-			}
-			return value;
+		if (!super.has(value)) return;
+		if (update ?? false) {
+			super.delete(value);
+			this.add(value);
 		}
+		return value;
 	}
 };
 //#endregion

package/dist/string/fuzzy.mjs

@@ -56,7 +56,6 @@ function fuzzy(items, configuration) {
 	});
 	return Object.freeze(instance);
 }
-fuzzy.match = fuzzyMatch;
 /**
 * Does the needle match the haystack in a fuzzy way?
 *
@@ -163,5 +162,7 @@ const FUZZY_LENGTH_DIVISOR = 3;
 const FUZZY_MESSAGE_ARRAY = "Fuzzy requires an array of items";
 const FUZZY_MESSAGE_HANDLER = "Fuzzy requires a key or function to stringify items";
 const FUZZY_PROXIMITY_THRESHOLD = 5;
+fuzzy.match = fuzzyMatch;
+Object.defineProperty(fuzzy, "match", { value: fuzzyMatch });
 //#endregion
 export { fuzzy, fuzzyMatch };

package/dist/string/normalize.mjs

@@ -51,7 +51,6 @@ function initializeNormalizer(options) {
 function normalize(value, options) {
 	return normalizeString(value, getNormalizeOptions(options));
 }
-normalize.initialize = initializeNormalizer;
 function normalizeString(value, options) {
 	if (typeof value !== "string") return "";
 	let result = value;
@@ -103,5 +102,7 @@ const NORMALIZE_SPECIAL_REPLACEMENT = "";
 const NORMALIZE_WHITESPACE_PATTERN = /\s+/g;
 const NORMALIZE_WHITESPACE_REPLACEMENT = " ";
 let deburrMemoizer;
+normalize.initialize = initializeNormalizer;
+Object.defineProperty(normalize, "initialize", { value: initializeNormalizer });
 //#endregion
 export { deburr, initializeNormalizer, normalize };

package/dist/string/template.mjs

@@ -45,7 +45,8 @@ function template(value, ...parameters) {
 	const { ignoreCase, pattern } = getTemplateOptions(parameters[1]);
 	return handleTemplate(value, pattern, ignoreCase, parameters[0]);
 }
-template.initialize = initializeTemplater;
 const TEMPLATE_EXPRESSION_VARIABLE = /{{([\s\S]+?)}}/g;
+template.initialize = initializeTemplater;
+Object.defineProperty(template, "initialize", { value: initializeTemplater });
 //#endregion
 export { initializeTemplater, template };

package/dist/value/clone.d.mts

@@ -1,5 +1,19 @@
 import { Constructor, GenericCallback } from "../models.mjs";
 //#region src/value/clone.d.ts
+type CloneOptions = {
+  /**
+   * Copy functions instead of returning `undefined`? _(defaults to `false`)_
+   */
+  copyFunctions?: boolean;
+  /**
+   * Copy symbols instead of returning `Symbol(description)`? _(defaults to `false`)_
+   */
+  copySymbols?: boolean;
+  /**
+   * Clone only the value itself, without cloning nested values? _(defaults to `false`)_
+   */
+  flat?: boolean;
+};
 /**
  * Clone any kind of value _(shallowly)_
  *
@@ -12,13 +26,14 @@ declare function clone<Value>(value: Value, flat: true): Value;
  * Clone any kind of value _(deeply, if needed)_
  *
  * @param value Value to clone
+ * @param options Clone options
  * @returns Cloned value
  */
-declare function clone<Value>(value: Value): Value;
+declare function clone<Value>(value: Value, options?: CloneOptions): Value;
 declare namespace clone {
   var handlers: {
     deregister(constructor: Constructor): void;
-    handle(value: unknown, ...parameters: unknown[]): any;
+    handle(value: unknown, ...parameters: unknown[]): unknown;
     register(constructor: Constructor, handler?: string | GenericCallback): void;
   };
   var deregister: typeof deregisterCloner;
@@ -52,4 +67,4 @@ declare function deregisterCloner<Instance>(constructor: Constructor<Instance>):
  */
 declare function registerCloner<Instance>(constructor: Constructor<Instance>, handler?: string | ((value: Instance) => Instance)): void;
 //#endregion
-export { clone, copy, deregisterCloner, registerCloner };
+export { CloneOptions, clone, copy, deregisterCloner, registerCloner };

package/dist/value/clone.mjs

@@ -2,8 +2,17 @@ import { isArrayOrPlainObject, isTypedArray } from "../internal/is.mjs";
 import { getSelfHandlers } from "../internal/value/handlers.mjs";
 //#region src/value/clone.ts
 const CLONE_NAME = "clone";
-function clone(value, flat) {
-	return flat === true ? copy(value) : cloneValue(value, 0, /* @__PURE__ */ new WeakMap(), false);
+function clone(value, options) {
+	switch (true) {
+		case value === null:
+		case value === void 0:
+		case typeof value === "bigint":
+		case typeof value === "boolean":
+		case typeof value === "number":
+		case typeof value === "string": return value;
+		case value instanceof Date: return new Date(value.getTime());
+		default: return cloneAny(value, getCloneParameters(options), 0);
+	}
 }
 clone.handlers = getSelfHandlers(clone, {
 	callback: tryStructuredClone,
@@ -11,90 +20,92 @@ clone.handlers = getSelfHandlers(clone, {
 });
 clone.deregister = deregisterCloner;
 clone.register = registerCloner;
-function cloneArrayBuffer(value, depth, references) {
-	if (typeof depth === "number" && depth >= CLONE_MAX_DEPTH) return value;
+function cloneAny(value, parameters, depth) {
+	switch (true) {
+		case value == null:
+		case typeof value === "bigint":
+		case typeof value === "boolean":
+		case typeof value === "number":
+		case typeof value === "string": return value;
+		case value instanceof Date: return new Date(value.getTime());
+		case typeof value === "function": return parameters.options?.copyFunctions ? value : void 0;
+		case typeof value === "symbol": return parameters.options?.copySymbols ? value : Symbol(value.description);
+		case parameters.references.has(value): return parameters.references.get(value);
+		case value instanceof ArrayBuffer: return cloneArrayBuffer(value, parameters, depth);
+		case value instanceof DataView: return cloneDataView(value, parameters, depth);
+		case value instanceof RegExp: return cloneRegularExpression(value, parameters, depth);
+		case value instanceof Map: return cloneMap(value, parameters, depth);
+		case typeof Node !== "undefined" && value instanceof Node: return cloneNode(value, parameters, depth);
+		case value instanceof Set: return cloneSet(value, parameters, depth);
+		case isArrayOrPlainObject(value): return cloneObject(value, parameters, depth);
+		case isTypedArray(value): return cloneTypedArray(value, parameters, depth);
+		default: return clone.handlers.handle(value, parameters, depth);
+	}
+}
+function cloneArrayBuffer(value, parameters, depth) {
+	if (depth >= CLONE_MAX_DEPTH) return value;
 	const cloned = new ArrayBuffer(value.byteLength);
 	new Uint8Array(cloned).set(new Uint8Array(value));
-	references?.set(value, cloned);
+	parameters.references.set(value, cloned);
 	return cloned;
 }
-function cloneDataView(value, depth, references) {
+function cloneDataView(value, parameters, depth) {
 	if (depth >= CLONE_MAX_DEPTH) return value;
-	const buffer = cloneArrayBuffer(value.buffer);
+	const buffer = cloneArrayBuffer(value.buffer, parameters, depth);
 	const cloned = new DataView(buffer, value.byteOffset, value.byteLength);
-	references.set(value, cloned);
+	parameters.references.set(value, cloned);
 	return cloned;
 }
-function cloneMap(map, depth, references, flat) {
+function cloneMap(map, parameters, depth) {
 	if (depth >= CLONE_MAX_DEPTH) return map;
+	const flat = parameters.options?.flat;
 	const cloned = /* @__PURE__ */ new Map();
 	const entries = map.entries();
-	for (const entry of entries) cloned.set(flat ? entry[0] : cloneValue(entry[0], depth + 1, references, false), flat ? entry[1] : cloneValue(entry[1], depth + 1, references, false));
-	references.set(map, cloned);
+	for (const entry of entries) cloned.set(flat ? entry[0] : cloneAny(entry[0], parameters, depth + 1), flat ? entry[1] : cloneAny(entry[1], parameters, depth + 1));
+	parameters.references.set(map, cloned);
 	return cloned;
 }
-function cloneNode(node, depth, references) {
+function cloneNode(node, parameters, depth) {
 	if (depth >= CLONE_MAX_DEPTH) return node;
 	const cloned = node.cloneNode(true);
-	references.set(node, cloned);
+	parameters.references.set(node, cloned);
 	return cloned;
 }
-function cloneObject(value, depth, references, flat) {
-	if (flat || depth >= CLONE_MAX_DEPTH) return Array.isArray(value) ? value.slice() : { ...value };
-	const cloned = Array.isArray(value) ? [] : {};
-	const keys = [...Object.keys(value), ...Object.getOwnPropertySymbols(value)];
-	const { length } = keys;
+function cloneObject(value, parameters, depth) {
+	const isArray = Array.isArray(value);
+	if (parameters.options?.flat || depth >= CLONE_MAX_DEPTH) return isArray ? value.slice() : { ...value };
+	const cloned = isArray ? [] : {};
+	const keys = isArray ? void 0 : Object.keys(value);
+	const { length } = keys ?? value;
 	for (let index = 0; index < length; index += 1) {
-		const key = keys[index];
-		cloned[key] = cloneValue(value[key], depth + 1, references, false);
+		const key = keys?.[index] ?? index;
+		cloned[key] = cloneAny(value[key], parameters, depth + 1);
 	}
-	references.set(value, cloned);
+	parameters.references.set(value, cloned);
 	return cloned;
 }
-function cloneRegularExpression(value, depth, references) {
+function cloneRegularExpression(value, parameters, depth) {
 	if (depth >= CLONE_MAX_DEPTH) return value;
 	const cloned = new RegExp(value.source, value.flags);
 	cloned.lastIndex = value.lastIndex;
-	references.set(value, cloned);
+	parameters.references.set(value, cloned);
 	return cloned;
 }
-function cloneSet(set, depth, references, flat) {
+function cloneSet(set, parameters, depth) {
 	if (depth >= CLONE_MAX_DEPTH) return set;
 	const cloned = /* @__PURE__ */ new Set();
 	const values = [...set.values()];
 	const { length } = values;
-	for (let index = 0; index < length; index += 1) cloned.add(flat ? values[index] : cloneValue(values[index], depth + 1, references, false));
-	references.set(set, cloned);
+	for (let index = 0; index < length; index += 1) cloned.add(parameters.options?.flat ? values[index] : cloneAny(values[index], parameters, depth + 1));
+	parameters.references.set(set, cloned);
 	return cloned;
 }
-function cloneTypedArray(value, depth, references) {
+function cloneTypedArray(value, parameters, depth) {
 	if (depth >= CLONE_MAX_DEPTH) return value;
 	const cloned = new value.constructor(value);
-	references.set(value, cloned);
+	parameters.references.set(value, cloned);
 	return cloned;
 }
-function cloneValue(value, depth, references, flat) {
-	switch (true) {
-		case value == null:
-		case typeof value === "bigint":
-		case typeof value === "boolean":
-		case typeof value === "number":
-		case typeof value === "string": return value;
-		case typeof value === "function": return;
-		case typeof value === "symbol": return Symbol(value.description);
-		case references.has(value): return references.get(value);
-		case value instanceof ArrayBuffer: return cloneArrayBuffer(value, depth, references);
-		case value instanceof DataView: return cloneDataView(value, depth, references);
-		case value instanceof Date: return new Date(value.getTime());
-		case value instanceof RegExp: return cloneRegularExpression(value, depth, references);
-		case value instanceof Map: return cloneMap(value, depth, references, flat);
-		case typeof Node !== "undefined" && value instanceof Node: return cloneNode(value, depth, references);
-		case value instanceof Set: return cloneSet(value, depth, references, flat);
-		case isArrayOrPlainObject(value): return cloneObject(value, depth, references, flat);
-		case isTypedArray(value): return cloneTypedArray(value, depth, references);
-		default: return clone.handlers.handle(value, depth, references);
-	}
-}
 /**
 * Copy any kind of value
 *
@@ -105,7 +116,7 @@ function cloneValue(value, depth, references, flat) {
 * @returns Copied value
 */
 function copy(value) {
-	return cloneValue(value, 0, /* @__PURE__ */ new WeakMap(), true);
+	return clone(value, CLONE_COPY_OPTIONS);
 }
 /**
 * Deregister a clone handler for a specific class
@@ -117,6 +128,25 @@ function copy(value) {
 function deregisterCloner(constructor) {
 	clone.handlers.deregister(constructor);
 }
+function getCloneOptions(input) {
+	if (typeof input === "boolean") return {
+		copyFunctions: false,
+		copySymbols: false,
+		flat: input === true
+	};
+	if (typeof input !== "object" || input === null) return CLONE_DEFAULT_OPTIONS;
+	return {
+		copyFunctions: input.copyFunctions === true,
+		copySymbols: input.copySymbols === true,
+		flat: input.flat === true
+	};
+}
+function getCloneParameters(input) {
+	return {
+		options: getCloneOptions(input),
+		references: /* @__PURE__ */ new WeakMap()
+	};
+}
 /**
 * Register a clone handler for a specific class
 *
@@ -128,17 +158,27 @@ function deregisterCloner(constructor) {
 function registerCloner(constructor, handler) {
 	clone.handlers.register(constructor, handler);
 }
-function tryStructuredClone(value, depth, references) {
+function tryStructuredClone(value, parameters, depth) {
 	if (depth >= CLONE_MAX_DEPTH) return value;
 	try {
 		const cloned = structuredClone(value);
-		references.set(value, cloned);
+		parameters.references?.set(value, cloned);
 		return cloned;
 	} catch {
-		references.set(value, value);
+		parameters.references?.set(value, value);
 		return value;
 	}
 }
+const CLONE_COPY_OPTIONS = {
+	copyFunctions: true,
+	copySymbols: true,
+	flat: true
+};
+const CLONE_DEFAULT_OPTIONS = {
+	copyFunctions: false,
+	copySymbols: false,
+	flat: false
+};
 const CLONE_MAX_DEPTH = 100;
 //#endregion
 export { clone, copy, deregisterCloner, registerCloner };

package/dist/value/collection.mjs

@@ -4,7 +4,9 @@ function inMap(map, value, key) {
 	const getKey = key === true;
 	if (!(map instanceof Map)) return getKey ? void 0 : false;
 	if (!getKey) return inSet(new Set(map.values()), value);
-	for (const [key, item] of map) if (equal(item, value)) return key;
+	let found;
+	for (const [key, item] of map) if (equal(item, value)) found = key;
+	return found;
 }
 /**
 * Does the value exist in a _Set_?

package/dist/value/freeze.mjs

@@ -10,8 +10,6 @@ function flatFreeze(value) {
 function freeze(value, flat) {
 	return freezeValue(value, /* @__PURE__ */ new WeakSet(), flat === true);
 }
-freeze.flat = flatFreeze;
-freeze.is = isFrozen;
 function freezeArray(array, references, flat) {
 	if (flat) return Object.freeze(array);
 	references.add(array);
@@ -76,5 +74,11 @@ function isFrozen(value) {
 	return typeof value === "object" && value !== null && Object.isFrozen(value);
 }
 const frozenValues = /* @__PURE__ */ new WeakSet();
+freeze.flat = flatFreeze;
+freeze.is = isFrozen;
+Object.defineProperties(freeze, {
+	flat: { value: flatFreeze },
+	is: { value: isFrozen }
+});
 //#endregion
 export { flatFreeze, freeze, isFrozen };

package/dist/value/merge.mjs

@@ -13,7 +13,6 @@ function assign(to, from, options) {
 	actual.assignValues = true;
 	return mergeValues([to, ...from], actual);
 }
-assign.initialize = initializeAssigner;
 function getMergeOptions(options) {
 	const actual = {
 		assignValues: false,
@@ -67,7 +66,6 @@ function initializeMerger(options) {
 function merge(values, options) {
 	return mergeValues(values, getMergeOptions(options));
 }
-merge.initialize = initializeMerger;
 function mergeObjects(values, options, destination, prefix) {
 	const { length } = values;
 	const isArray = Array.isArray(destination ?? values[0]);
@@ -97,5 +95,9 @@ function mergeValues(values, options, prefix) {
 	if (actual.length > 1) return mergeObjects(actual, options, options.assignValues ? actual[0] : void 0, prefix);
 	return options.assignValues ? actual[0] : Array.isArray(actual[0]) ? actual[0].slice() : { ...actual[0] };
 }
+assign.initialize = initializeAssigner;
+merge.initialize = initializeMerger;
+Object.defineProperty(assign, "initialize", { value: initializeAssigner });
+Object.defineProperty(merge, "initialize", { value: initializeMerger });
 //#endregion
 export { assign, initializeAssigner, initializeMerger, merge };

package/dist/value/transform.mjs

@@ -20,7 +20,6 @@ function initializeTransformer(transform) {
 function transform(value, transform) {
 	return transformValue(value, getTransformer(transform));
 }
-transform.initialize = initializeTransformer;
 function transformValue(value, transformer) {
 	if (isNonPlainObject(value)) return {};
 	if (transformer == null) return value;
@@ -34,5 +33,7 @@ function transformValue(value, transformer) {
 	}
 	return value;
 }
+transform.initialize = initializeTransformer;
+Object.defineProperty(transform, "initialize", { value: initializeTransformer });
 //#endregion
 export { initializeTransformer, transform };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/atoms",
-	"version": "0.196.0",
+	"version": "0.197.0",
 	"description": "Atomic utilities for making your JavaScript better.",
 	"keywords": [
 		"array",
@@ -277,7 +277,7 @@
 		"watch": "npx vite build --watch"
 	},
 	"devDependencies": {
-		"@oxlint/plugins": "^1.80",
+		"@oxlint/plugins": "^1.81",
 		"@types/node": "^26.4",
 		"@vitest/coverage-istanbul": "^4.1",
 		"eslint": "^10.9",