toolbox-x 1.0.0

package/dist/converter.mjs

@@ -0,0 +1,771 @@
+/**
+ * Copyright 2026 - present Nazmul Hassan
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { i as Y_TO_IES, n as IRREGULAR_PLURALS, r as UNITS, t as INVARIANT_UNITS } from "./constants-eNd-iYsV.mjs";
+
+//#region src/converter/base.ts
+/**
+* @description Base class providing common mathematical and formatting utilities
+* for all unit converters (time, length, data, temperature, etc.).
+*/
+var $BaseConverter = class {
+	value;
+	unit;
+	/**
+	* Convert value to other units
+	* @param value Number or numeric string value to convert.
+	* @param unit Optional base unit for the provided value.
+	*/
+	constructor(value, unit) {
+		this.value = Number(value);
+		this.unit = unit ?? "";
+	}
+	/** @protected Returns a grammatically correct unit string, prefixed with the number value. */
+	$withPluralUnit(value, unit) {
+		const abs = Math.abs(value ?? this.value);
+		const u = unit ?? this.unit;
+		if (!u) return String(abs);
+		let pluralized;
+		if (abs === 1) pluralized = u;
+		else if (IRREGULAR_PLURALS?.[u]) pluralized = IRREGULAR_PLURALS[u];
+		else if (INVARIANT_UNITS.has(u)) pluralized = u;
+		else if (u.endsWith("foot")) pluralized = u.replace(/foot$/, "feet");
+		else if (u.endsWith("inch")) pluralized = u.replace(/inch$/, "inches");
+		else pluralized = Y_TO_IES.has(u) ? u.replace(/y$/, "ies") : `${u}s`;
+		return `${abs} ${pluralized}`;
+	}
+	/** @protected Rounds a numeric value to given decimal places. */
+	$round(value, decimals = 2) {
+		const factor = 10 ** decimals;
+		return Math.round(value * factor) / factor;
+	}
+	/**
+	* @protected Shared formatter for all converters.
+	* @param value Converted value (already computed via `.to(target)`).
+	* @param target Target unit name.
+	* @param shortLabels Record of compact unit labels.
+	* @param options Formatting options.
+	* @returns Formatted string according to style (compact, plural, scientific).
+	*/
+	$formatTo(value, target, shortLabels, options) {
+		const { style = "plural", decimals = 2 } = options ?? {};
+		const rounded = this.$round(value, decimals);
+		switch (style) {
+			case "compact": return `${rounded}${shortLabels[target]}`;
+			case "scientific": return `${value.toExponential(decimals)} ${target}`;
+			default: return this.$withPluralUnit(rounded, target);
+		}
+	}
+	/**
+	* @instance Returns the numeric value.
+	* @returns The raw numeric value without unit.
+	*/
+	valueOf() {
+		return this.value;
+	}
+	/**
+	* @instance Returns the numeric value.
+	* @returns The raw numeric value without unit.
+	*/
+	getValue() {
+		return this.value;
+	}
+	/**
+	* @instance Returns the unit name.
+	* @returns The current unit.
+	*/
+	getUnit() {
+		return this.unit || "unknown";
+	}
+	/**
+	* @instance Returns the original value with formatted pluralized unit.
+	* @returns A string like `"3 hours"` or `"1 minute"` or `"3"` if no unit is provided.
+	*
+	* @remarks
+	* - This method is automatically called when the instance is used in a string context.
+	* - For complex and versatile pluralization, please refer to {@link https://toolbox.nazmul-nhb.dev/docs/utilities/string/pluralizer pluralizer} or {@link https://toolbox.nazmul-nhb.dev/docs/classes/Pluralizer Pluralizer Class} instead.
+	*/
+	toString() {
+		return this.$withPluralUnit();
+	}
+	/**
+	* @instance Returns a plain object representation.
+	* @returns An object with value and unit.
+	*/
+	toObject() {
+		return {
+			value: this.value,
+			unit: this.unit || "unknown"
+		};
+	}
+	/**
+	* @instance Converts to JSON representation.
+	* @returns JSON string of `{ value, unit }`.
+	*/
+	toJSON() {
+		return JSON.stringify(this.toObject());
+	}
+	/** @instance Returns a new instance with the absolute value. */
+	abs() {
+		return new this.constructor(Math.abs(this.value), this.unit);
+	}
+	/**
+	* @instance Adds a numeric value (same unit assumed).
+	* @returns A new instance with updated value.
+	*/
+	add(n) {
+		return new this.constructor(this.value + Number(n), this.unit);
+	}
+	/**
+	* @instance Subtracts a numeric value (same unit assumed).
+	* @returns A new instance with updated value.
+	*/
+	subtract(n) {
+		return new this.constructor(this.value - Number(n), this.unit);
+	}
+	/**
+	* @instance Multiplies the value.
+	* @returns A new instance with updated value.
+	*/
+	multiply(n) {
+		return new this.constructor(this.value * Number(n), this.unit);
+	}
+	/**
+	* @instance Divides the value.
+	* @returns A new instance with updated value.
+	*/
+	divide(n) {
+		return new this.constructor(this.value / Number(n), this.unit);
+	}
+	/**
+	* @instance Rounds to given decimal places.
+	* @param decimals Number of decimal places to round. Default is `0`.
+	* @returns A new instance with rounded value.
+	*/
+	round(decimals = 0) {
+		const rounded = this.$round(this.value, decimals);
+		return new this.constructor(rounded, this.unit);
+	}
+	/** @instance Returns whether this value is greater than another numeric value. */
+	gt(n) {
+		return this.value > Number(n);
+	}
+	/** @instance Returns whether this value is less than another numeric value. */
+	lt(n) {
+		return this.value < Number(n);
+	}
+	/** @instance Returns whether this value equals another numeric value. */
+	eq(n) {
+		return this.value === Number(n);
+	}
+	/**
+	* @instance Returns a human-friendly formatted string with fixed decimals (if the value is fraction).
+	* @param decimals Number of decimal places for fractional value.
+	* @returns Formatted string with proper unit pluralization.
+	*
+	* @remarks For complex and versatile pluralization, please refer to {@link https://toolbox.nazmul-nhb.dev/docs/utilities/string/pluralizer pluralizer} or {@link https://toolbox.nazmul-nhb.dev/docs/classes/Pluralizer Pluralizer Class} instead.
+	*/
+	format(decimals = 2) {
+		return this.$withPluralUnit(this.$round(this.value, decimals));
+	}
+	/**
+	* @instance Returns all supported units, optionally filtered by category.
+	* @param category Category to filter units by.
+	* @returns Array or tuple of supported unit strings.
+	*/
+	supportedUnits(category) {
+		if (category && category in UNITS) return [...UNITS[category]];
+		return Object.values(UNITS).flat();
+	}
+};
+
+//#endregion
+//#region src/converter/area.ts
+/**
+* @class AreaConverter
+* @description Handles conversions with smart `.to()`, `.toAll()`, and `.formatTo()`.
+*/
+var $Area = class $Area extends $BaseConverter {
+	/** * Conversion factors based on square-meters. */
+	static #factors = {
+		"square-millimeter": 1e-6,
+		"square-centimeter": 1e-4,
+		"square-meter": 1,
+		"square-kilometer": 1e6,
+		"square-millimetre": 1e-6,
+		"square-centimetre": 1e-4,
+		"square-metre": 1,
+		"square-kilometre": 1e6,
+		"square-inch": 64516e-8,
+		"square-foot": .09290304,
+		"square-yard": .83612736,
+		"square-mile": 2589988.110336,
+		hectare: 1e4,
+		acre: 4046.8564224
+	};
+	/**
+	* Convert area value to other area units
+	* @param value Number or numeric string value to convert.
+	* @param unit Base area unit for the provided value.
+	*/
+	constructor(value, unit) {
+		super(value, unit);
+	}
+	/** @instance Converts to base unit (square meters). */
+	#toSquareMeters() {
+		return this.value * $Area.#factors[this.unit];
+	}
+	/**
+	* @instance Converts to target area unit.
+	* @param target Target area unit.
+	*/
+	to(target) {
+		return this.#toSquareMeters() / $Area.#factors[target];
+	}
+	/**
+	* @instance Converts to all area units.
+	* @returns Object with all unit conversions.
+	*/
+	toAll() {
+		const base = this.#toSquareMeters();
+		const result = {};
+		for (const unit of UNITS.area) result[unit] = base / $Area.#factors[unit];
+		return result;
+	}
+	/**
+	* @instance Formats the converted value and unit.
+	* @param target Target unit to format to.
+	* @param options Formatting options.
+	* @returns Formatted string like "5km²", "5.02 square-miles", or "5e+3 meter".
+	*/
+	formatTo(target, options) {
+		const value = this.to(target);
+		return this.$formatTo(value, target, {
+			"square-millimeter": "mm²",
+			"square-centimeter": "cm²",
+			"square-meter": "m²",
+			"square-kilometer": "km²",
+			"square-millimetre": "mm²",
+			"square-centimetre": "cm²",
+			"square-metre": "m²",
+			"square-kilometre": "km²",
+			"square-inch": "in²",
+			"square-foot": "ft²",
+			"square-yard": "yd²",
+			"square-mile": "mi²",
+			hectare: "ha",
+			acre: "ac"
+		}, options);
+	}
+};
+
+//#endregion
+//#region src/converter/data.ts
+/**
+* @class DataConverter
+* @description Handles conversions with smart `.to()`, `.toAll()`, and `.formatTo()`.
+*/
+var $Data = class $Data extends $BaseConverter {
+	/** * Conversion factors based on bytes. */
+	static #factors = {
+		bit: 1 / 8,
+		byte: 1,
+		kilobit: 128,
+		kilobyte: 1024,
+		megabit: 131072,
+		megabyte: 1048576,
+		gigabit: 134217728,
+		gigabyte: 1073741824,
+		terabit: 137438953472,
+		terabyte: 1099511627776,
+		petabit: 0x800000000000,
+		petabyte: 0x4000000000000
+	};
+	/**
+	* Convert data value to other data units
+	* @param value Number or numeric string value to convert.
+	* @param unit Base data unit for the provided value.
+	*/
+	constructor(value, unit) {
+		super(value, unit);
+	}
+	/** @instance Converts to base unit (bytes). */
+	#toBytes() {
+		return this.value * $Data.#factors[this.unit];
+	}
+	/**
+	* @instance Converts to target data unit.
+	* @param target Target data unit.
+	*/
+	to(target) {
+		return this.#toBytes() / $Data.#factors[target];
+	}
+	/**
+	* @instance Converts to all data units.
+	* @returns Object with all unit conversions.
+	*/
+	toAll() {
+		const inBytes = this.#toBytes();
+		const result = {};
+		for (const unit of UNITS.data) result[unit] = inBytes / $Data.#factors[unit];
+		return result;
+	}
+	/**
+	* @instance Formats the converted value.
+	* @param target Target data unit.
+	* @param options Formatting options.
+	* @returns Formatted string like "256MB", "256 megabytes", or "2.56e+2 MB".
+	*/
+	formatTo(target, options) {
+		const value = this.to(target);
+		return this.$formatTo(value, target, {
+			bit: "b",
+			byte: "B",
+			kilobit: "Kb",
+			kilobyte: "KB",
+			megabit: "Mb",
+			megabyte: "MB",
+			gigabit: "Gb",
+			gigabyte: "GB",
+			terabit: "Tb",
+			terabyte: "TB",
+			petabit: "Pb",
+			petabyte: "PB"
+		}, options);
+	}
+};
+
+//#endregion
+//#region src/converter/length.ts
+/**
+* @class LengthConverter
+* @description Handles conversions with smart `.to()`, `.toAll()`, and `.formatTo()`.
+*/
+var $Length = class $Length extends $BaseConverter {
+	/** * Conversion factors based on meters. */
+	static #factors = {
+		millimeter: .001,
+		centimeter: .01,
+		meter: 1,
+		kilometer: 1e3,
+		millimetre: .001,
+		centimetre: .01,
+		metre: 1,
+		kilometre: 1e3,
+		inch: .0254,
+		foot: .3048,
+		yard: .9144,
+		mile: 1609.344,
+		"nautical-mile": 1852,
+		"light-year": 9460730472580800
+	};
+	/**
+	* Convert length/distance value to other length/distance units
+	* @param value Number or numeric string value to convert.
+	* @param unit Base length/distance unit for the provided value.
+	*/
+	constructor(value, unit) {
+		super(value, unit);
+	}
+	/** @instance Converts to base unit (meters). */
+	#toMeters() {
+		return this.value * $Length.#factors[this.unit];
+	}
+	/**
+	* @instance Converts to target length/distance unit.
+	* @param target Target length/distance unit.
+	*/
+	to(target) {
+		return this.#toMeters() / $Length.#factors[target];
+	}
+	/**
+	* @instance Converts to all data units.
+	* @returns Object with all unit conversions.
+	*/
+	toAll() {
+		const inMeters = this.#toMeters();
+		const result = {};
+		for (const unit of UNITS.length) result[unit] = inMeters / $Length.#factors[unit];
+		return result;
+	}
+	/**
+	* @instance Formats the converted value and unit.
+	* @param target Target unit to format to.
+	* @param options Formatting options.
+	* @returns Formatted string like "5km", "5.12 miles", or "5e+3 meter".
+	*/
+	formatTo(target, options) {
+		const value = this.to(target);
+		return this.$formatTo(value, target, {
+			millimeter: "mm",
+			centimeter: "cm",
+			meter: "m",
+			kilometer: "km",
+			millimetre: "mm",
+			centimetre: "cm",
+			metre: "m",
+			kilometre: "km",
+			inch: "in",
+			foot: "ft",
+			yard: "yd",
+			mile: "mi",
+			"nautical-mile": "nmi",
+			"light-year": "ly"
+		}, options);
+	}
+};
+
+//#endregion
+//#region src/converter/mass.ts
+/**
+* @class MassConverter
+* @description Handles conversions with smart `.to()`, `.toAll()`, and `.formatTo()`.
+*/
+var $Mass = class $Mass extends $BaseConverter {
+	/** * Common conversion factors relative to 1 kilogram. */
+	static #factors = {
+		microgram: 1e-9,
+		milligram: 1e-6,
+		gram: .001,
+		kilogram: 1,
+		tonne: 1e3,
+		ounce: .028349523125,
+		pound: .45359237,
+		stone: 6.35029318,
+		"short-ton": 907.18474,
+		"long-ton": 1016.0469088
+	};
+	/**
+	* Convert mass value to other mass units
+	* @param value Number or numeric string value to convert.
+	* @param unit Base mass unit for the provided value.
+	*/
+	constructor(value, unit) {
+		super(value, unit);
+	}
+	/** @instance Converts to base unit (kilograms). */
+	#toKilograms() {
+		return this.value * $Mass.#factors[this.unit];
+	}
+	/**
+	* @instance Converts to target mass unit.
+	* @param target Target mass unit.
+	*/
+	to(target) {
+		return this.#toKilograms() / $Mass.#factors[target];
+	}
+	/**
+	* @instance Converts to all mass units at once.
+	* @returns Object with all unit conversions.
+	*/
+	toAll() {
+		const base = this.#toKilograms();
+		const result = {};
+		for (const unit of UNITS.mass) result[unit] = base / $Mass.#factors[unit];
+		return result;
+	}
+	/**
+	* @instance Formats the converted value and unit.
+	* @param target Target unit to format to.
+	* @param options Formatting options.
+	* @returns Formatted string like "5kg", "5.25 kilograms", or "5e+3 gram".
+	*/
+	formatTo(target, options) {
+		const value = this.to(target);
+		return this.$formatTo(value, target, {
+			microgram: "µg",
+			milligram: "mg",
+			gram: "g",
+			kilogram: "kg",
+			tonne: "t",
+			ounce: "oz",
+			pound: "lb",
+			stone: "st",
+			"short-ton": "t (US)",
+			"long-ton": "t (UK)"
+		}, options);
+	}
+};
+
+//#endregion
+//#region src/converter/temp.ts
+/**
+* @class TemperatureConverter
+* @description Handles conversions with smart `.to()`, `.toAll()`, and `.formatTo()`.
+*/
+var $Temperature = class $Temperature extends $BaseConverter {
+	/**
+	* Convert temperature value to other temperature units
+	* @param value Number or numeric string value to convert.
+	* @param unit Base temperature unit for the provided value.
+	*/
+	constructor(value, unit) {
+		super(value, unit);
+	}
+	/**
+	* @private
+	* @description Conversion helper from Fahrenheit and Kelvin to Celsius.
+	*/
+	static #toCelsius(value, from) {
+		switch (from) {
+			case "fahrenheit": return (value - 32) * (5 / 9);
+			case "kelvin": return value - 273.15;
+			default: return value;
+		}
+	}
+	/**
+	* @private
+	* @description Conversion helper from Celsius to Fahrenheit and Kelvin.
+	*/
+	static #fromCelsius(value, to) {
+		switch (to) {
+			case "fahrenheit": return value * (9 / 5) + 32;
+			case "kelvin": return value + 273.15;
+			default: return value;
+		}
+	}
+	/**
+	* @instance Converts to target temperature unit.
+	* @param target Target temperature unit.
+	*/
+	to(target) {
+		const celsiusValue = $Temperature.#toCelsius(this.value, this.unit);
+		return $Temperature.#fromCelsius(celsiusValue, target);
+	}
+	/**
+	* @instance Converts to all temperature units at once.
+	* @returns Object with all unit conversions.
+	*/
+	toAll() {
+		const result = {};
+		for (const unit of UNITS.temp) result[unit] = this.to(unit);
+		return result;
+	}
+	/**
+	* @instance Formats the converted value and unit.
+	* @param target Target unit to format to.
+	* @param options Formatting options.
+	* @returns Formatted string like "95°F", "5.25 kelvins", or "5e+3 celsius".
+	*/
+	formatTo(target, options) {
+		const value = this.to(target);
+		return this.$formatTo(value, target, {
+			celsius: "°C",
+			fahrenheit: "°F",
+			kelvin: "K"
+		}, options);
+	}
+};
+
+//#endregion
+//#region src/converter/time.ts
+/**
+* @class TimeConverter
+* @description Handles conversions with smart `.to()`, `.toAll()`, and `.formatTo()`.
+*/
+var $Time = class $Time extends $BaseConverter {
+	/** * Common conversion factors based on seconds. */
+	static #factors = {
+		nanosecond: 1e-9,
+		microsecond: 1e-6,
+		millisecond: .001,
+		second: 1,
+		minute: 60,
+		hour: 3600,
+		day: 86400,
+		week: 604800,
+		month: 2629746,
+		year: 31556952,
+		decade: 315569520,
+		century: 3155695200,
+		millennium: 31556952e3
+	};
+	/**
+	* Convert time value to other time units
+	* @param value Number or numeric string value to convert.
+	* @param unit Base time unit for the provided value.
+	*/
+	constructor(value, unit) {
+		super(value, unit);
+	}
+	/** @instance Converts to base unit (seconds). */
+	#toSeconds() {
+		return this.value * $Time.#factors[this.unit];
+	}
+	/**
+	* @instance Converts to target time unit.
+	* @param target Target time unit.
+	*/
+	to(target) {
+		return this.#toSeconds() / $Time.#factors[target];
+	}
+	/**
+	* @instance Converts to all time units at once.
+	* @returns Object with all unit conversions.
+	*/
+	toAll() {
+		const inSeconds = this.#toSeconds();
+		const result = {};
+		for (const unit of UNITS.time) result[unit] = inSeconds / $Time.#factors[unit];
+		return result;
+	}
+	/**
+	* @instance Formats the converted value and unit.
+	* @param target Target unit to format to.
+	* @param options Formatting options.
+	* @returns Formatted string like "5h", "5.25 hours", or "5e+3 minute".
+	*/
+	formatTo(target, options) {
+		const value = this.to(target);
+		return this.$formatTo(value, target, {
+			nanosecond: "ns",
+			microsecond: "µs",
+			millisecond: "ms",
+			second: "s",
+			minute: "min",
+			hour: "h",
+			day: "d",
+			week: "wk",
+			month: "mo",
+			year: "yr",
+			decade: "dec",
+			century: "cen",
+			millennium: "mil"
+		}, options);
+	}
+};
+
+//#endregion
+//#region src/converter/volume.ts
+/**
+* @class VolumeConverter
+* @description Handles conversions with smart `.to()`, `.toAll()`, and `.formatTo()`.
+*/
+var $Volume = class $Volume extends $BaseConverter {
+	/** * Common conversion factors based on cubic-meters. */
+	static #factors = {
+		"cubic-millimeter": 1e-9,
+		"cubic-centimeter": 1e-6,
+		"cubic-meter": 1,
+		"cubic-kilometer": 1e9,
+		"cubic-millimetre": 1e-9,
+		"cubic-centimetre": 1e-6,
+		"cubic-metre": 1,
+		"cubic-kilometre": 1e9,
+		"cubic-inch": 16387064e-12,
+		"cubic-foot": .028316846592,
+		"cubic-yard": .764554857984,
+		liter: .001,
+		litre: .001,
+		milliliter: 1e-6,
+		millilitre: 1e-6,
+		gallon: .003785411784,
+		quart: .000946352946,
+		pint: .000473176473,
+		cup: .0002365882365,
+		tablespoon: 1478676478125e-17,
+		teaspoon: 492892159375e-17
+	};
+	/**
+	* Convert volume value to other volume units
+	* @param value Number or numeric string value to convert.
+	* @param unit Base volume unit for the provided value.
+	*/
+	constructor(value, unit) {
+		super(value, unit);
+	}
+	/** @instance Converts to base unit (cubic-meters). */
+	#toCubicMeters() {
+		return this.value * $Volume.#factors[this.unit];
+	}
+	/**
+	* @instance Converts to target volume unit.
+	* @param target Target volume unit.
+	*/
+	to(target) {
+		return this.#toCubicMeters() / $Volume.#factors[target];
+	}
+	/**
+	* @instance Converts to target volume unit.
+	* @param target Target volume unit.
+	*/
+	toAll() {
+		const base = this.#toCubicMeters();
+		const result = {};
+		for (const unit of UNITS.volume) result[unit] = base / $Volume.#factors[unit];
+		return result;
+	}
+	/**
+	* @instance Formats the converted value and unit.
+	* @param target Target unit to format to.
+	* @param options Formatting options.
+	* @returns Formatted string like "5m³", "5.25 cubic-meters", or "5e+3 meter".
+	*/
+	formatTo(target, options) {
+		const value = this.to(target);
+		return this.$formatTo(value, target, {
+			"cubic-millimeter": "mm³",
+			"cubic-centimeter": "cm³",
+			"cubic-meter": "m³",
+			"cubic-kilometer": "km³",
+			"cubic-millimetre": "mm³",
+			"cubic-centimetre": "cm³",
+			"cubic-metre": "m³",
+			"cubic-kilometre": "km³",
+			"cubic-inch": "in³",
+			"cubic-foot": "ft³",
+			"cubic-yard": "yd³",
+			liter: "L",
+			litre: "L",
+			milliliter: "mL",
+			millilitre: "mL",
+			gallon: "gal",
+			quart: "qt",
+			pint: "pt",
+			cup: "c",
+			tablespoon: "tbsp",
+			teaspoon: "tsp"
+		}, options);
+	}
+};
+
+//#endregion
+//#region src/converter/Converter.ts
+/**
+* @function `Converter` Creates instances of specific unit converter class based on the provided unit.
+*
+* @description Converts values between compatible units (time, length, data, temperature, mass, area, volume).
+* @remarks The returned instance exposes only methods relevant to the provided unit type.
+*/
+function Converter(value, unit) {
+	switch ((() => {
+		if (unit) {
+			for (const [category, values] of Object.entries(UNITS)) if ([...values].includes(unit)) return category;
+		}
+	})()) {
+		case "area": return new $Area(value, unit);
+		case "time": return new $Time(value, unit);
+		case "data": return new $Data(value, unit);
+		case "length": return new $Length(value, unit);
+		case "mass": return new $Mass(value, unit);
+		case "temp": return new $Temperature(value, unit);
+		case "volume": return new $Volume(value, unit);
+		default: return new $BaseConverter(value, unit);
+	}
+}
+
+//#endregion
+export { $Area as AreaConverter, Converter, Converter as converter, $Data as DataConverter, $Length as LengthConverter, $Mass as MassConverter, $Temperature as TemperatureConverter, $Time as TimeConverter, $Volume as VolumeConverter };