@ls-stack/utils 1.13.2 → 2.0.1

package/dist/arrayUtils.cjs

@@ -0,0 +1,91 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/arrayUtils.ts
+var arrayUtils_exports = {};
+__export(arrayUtils_exports, {
+  arrayWithPrev: () => arrayWithPrev,
+  arrayWithPrevAndIndex: () => arrayWithPrevAndIndex,
+  filterAndMap: () => filterAndMap,
+  isInArray: () => isInArray,
+  sortBy: () => sortBy
+});
+module.exports = __toCommonJS(arrayUtils_exports);
+function filterAndMap(array, mapFilter) {
+  const result = [];
+  let i = -1;
+  for (const item of array) {
+    i += 1;
+    const filterResult = mapFilter(item, i);
+    if (filterResult !== false) {
+      result.push(filterResult);
+    }
+  }
+  return result;
+}
+function sortBy(arr, sortByValue, props = "asc") {
+  const order = Array.isArray(props) || typeof props === "string" ? props : props.order ?? "asc";
+  return [...arr].sort((a, b) => {
+    const _aPriority = sortByValue(a);
+    const _bPriority = sortByValue(b);
+    const aPriority = Array.isArray(_aPriority) ? _aPriority : [_aPriority];
+    const bPriority = Array.isArray(_bPriority) ? _bPriority : [_bPriority];
+    for (let i = 0; i < aPriority.length; i++) {
+      const levelOrder = typeof order === "string" ? order : order[i] ?? "asc";
+      const aP = aPriority[i] ?? 0;
+      const bP = bPriority[i] ?? 0;
+      if (aP === bP) {
+        continue;
+      }
+      if (bP === Infinity || aP === -Infinity || aP < bP) {
+        return levelOrder === "asc" ? -1 : 1;
+      }
+      if (aP === Infinity || bP === -Infinity || aP > bP) {
+        return levelOrder === "asc" ? 1 : -1;
+      }
+    }
+    return 0;
+  });
+}
+function arrayWithPrev(array) {
+  return array.map((item, i) => [item, array[i - 1] ?? null]);
+}
+function arrayWithPrevAndIndex(array) {
+  return array.map((item, i) => ({
+    item,
+    prev: array[i - 1] ?? null,
+    index: i
+  }));
+}
+function isInArray(value, oneOf) {
+  for (let i = 0; i < oneOf.length; i++) {
+    if (oneOf[i] === value) {
+      return true;
+    }
+  }
+  return false;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  arrayWithPrev,
+  arrayWithPrevAndIndex,
+  filterAndMap,
+  isInArray,
+  sortBy
+});

package/dist/arrayUtils.d.cts

@@ -0,0 +1,51 @@
+/**
+ * allow to filter and map with better typing ergonomics
+ *
+ * In the `mapFilter` function return `false` to reject the item, or any other
+ * value to map it.
+ *
+ * @example
+ * // Filter reject and turn value into `value mapped`
+ * const items = ['value', 'value', 'reject', 'reject'];
+ *
+ * const mappedItems = filterAndMap(items, (item) =>
+ *   item === 'reject'
+ *     ? false
+ *     : `${item} mapped`,
+ * );
+ *
+ * mappedItems; // ['value mapped', 'value mapped']
+ */
+declare function filterAndMap<T, R>(array: IterableIterator<T> | readonly T[], mapFilter: (item: T, index: number) => false | R): R[];
+type FilterAndMapReturn<T> = false | T;
+type SortOrder = 'desc' | 'asc';
+/**
+ * Sort an array based on a value
+ *
+ * Sort by `ascending` order by default
+ *
+ * Use `Infinity` as as wildcard to absolute max and min values
+ *
+ * @example
+ * const items = [1, 3, 2, 4];
+ *
+ * const sortedItems = sortBy(items, (item) => item);
+ * // [1, 2, 3, 4]
+ *
+ * const items2 = [{ a: 1, b: 2 }, { a: 2, b: 1 }, { a: 1, b: 1}]
+ *
+ * // return a array to sort by multiple values
+ * const sortedItems = sortBy(items, (item) => [item.a, item.b]);
+ **/
+declare function sortBy<T>(arr: T[], sortByValue: (item: T) => (number | string)[] | number | string, props?: {
+    order?: SortOrder | SortOrder[];
+} | SortOrder | SortOrder[]): T[];
+declare function arrayWithPrev<T>(array: T[]): [current: T, prev: T | null][];
+declare function arrayWithPrevAndIndex<T>(array: T[]): {
+    item: T;
+    prev: T | null;
+    index: number;
+}[];
+declare function isInArray<T, const U extends T>(value: T, oneOf: readonly U[]): value is U;
+
+export { type FilterAndMapReturn, arrayWithPrev, arrayWithPrevAndIndex, filterAndMap, isInArray, sortBy };

package/dist/arrayUtils.js

@@ -4,7 +4,7 @@ import {
   filterAndMap,
   isInArray,
   sortBy
-} from "./chunk-W7X6NSGR.js";
+} from "./chunk-AZBBTE33.js";
 export {
   arrayWithPrev,
   arrayWithPrevAndIndex,
@@ -12,4 +12,3 @@ export {
   isInArray,
   sortBy
 };
-//# sourceMappingURL=arrayUtils.js.map

package/dist/assertions.cjs

@@ -0,0 +1,99 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/assertions.ts
+var assertions_exports = {};
+__export(assertions_exports, {
+  assertIsNotNullish: () => assertIsNotNullish,
+  assertIsNotUndefined: () => assertIsNotUndefined,
+  exhaustiveCheck: () => exhaustiveCheck,
+  invariant: () => invariant,
+  isFunction: () => isFunction,
+  isObject: () => isObject,
+  isPlainObject: () => isPlainObject,
+  isPromise: () => isPromise,
+  notNullish: () => notNullish,
+  notUndefined: () => notUndefined
+});
+module.exports = __toCommonJS(assertions_exports);
+var undefErrMsg = "not undefined assertion failed";
+var nullishErrMsg = "not nullish assertion failed";
+function notUndefined(value) {
+  if (value === void 0) {
+    throw new Error(undefErrMsg);
+  }
+  return value;
+}
+function notNullish(value) {
+  if (value === void 0 || value === null) {
+    throw new Error(nullishErrMsg);
+  }
+  return value;
+}
+function assertIsNotNullish(value, errorMsg = nullishErrMsg) {
+  if (value === void 0 || value === null) {
+    throw new Error(errorMsg);
+  }
+}
+function assertIsNotUndefined(value, errorMsg = undefErrMsg) {
+  if (value === void 0) {
+    throw new Error(errorMsg);
+  }
+}
+function invariant(condition, errorMsg = "Invariant violation") {
+  if (!condition) {
+    throw new Error(`Invariant violation: ${errorMsg}`);
+  }
+}
+function exhaustiveCheck(narrowedType) {
+  return new Error("This should never happen");
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isPromise(value) {
+  return isObject(value) && "then" in value;
+}
+function isPlainObject(value) {
+  if (!value || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  if (proto === null) {
+    return true;
+  }
+  const Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor;
+  if (Ctor === Object) return true;
+  const objectCtorString = Object.prototype.constructor.toString();
+  return typeof Ctor == "function" && Function.toString.call(Ctor) === objectCtorString;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assertIsNotNullish,
+  assertIsNotUndefined,
+  exhaustiveCheck,
+  invariant,
+  isFunction,
+  isObject,
+  isPlainObject,
+  isPromise,
+  notNullish,
+  notUndefined
+});

package/dist/assertions.d.cts

@@ -0,0 +1,17 @@
+type NotUndefined<T> = T extends undefined ? never : T;
+type StrictNonUndefined<T, N = unknown> = undefined extends T ? NotUndefined<T> : N;
+declare function notUndefined<T>(value: T): StrictNonUndefined<T>;
+type StrictNonNullable<T, N = unknown> = undefined extends T ? NonNullable<T> : null extends T ? NonNullable<T> : N;
+declare function notNullish<T>(value: T): StrictNonNullable<T>;
+declare function assertIsNotNullish<T>(value: T, errorMsg?: string): asserts value is StrictNonNullable<T, never>;
+declare function assertIsNotUndefined<T>(value: T, errorMsg?: string): asserts value is StrictNonUndefined<T, never>;
+/** Use this function to assert that a certain condition is always true. */
+declare function invariant(condition: any, errorMsg?: string): asserts condition;
+/** ensures all type possibilities are being handled */
+declare function exhaustiveCheck<Except = never>(narrowedType: NoInfer<Except>): Error;
+declare function isObject(value: unknown): value is Record<string, unknown>;
+declare function isFunction(value: unknown): value is (...args: any[]) => any;
+declare function isPromise(value: unknown): value is Promise<unknown>;
+declare function isPlainObject(value: any): value is Record<string, unknown>;
+
+export { assertIsNotNullish, assertIsNotUndefined, exhaustiveCheck, invariant, isFunction, isObject, isPlainObject, isPromise, notNullish, notUndefined };

package/dist/assertions.js

@@ -9,7 +9,7 @@ import {
   isPromise,
   notNullish,
   notUndefined
-} from "./chunk-FYMTZQ42.js";
+} from "./chunk-4UGSP3L3.js";
 export {
   assertIsNotNullish,
   assertIsNotUndefined,
@@ -22,4 +22,3 @@ export {
   notNullish,
   notUndefined
 };
-//# sourceMappingURL=assertions.js.map

package/dist/castValues.cjs

@@ -0,0 +1,41 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/castValues.ts
+var castValues_exports = {};
+__export(castValues_exports, {
+  castToNumber: () => castToNumber,
+  castToString: () => castToString
+});
+module.exports = __toCommonJS(castValues_exports);
+function castToString(value) {
+  return value !== null && value !== void 0 ? String(value) : null;
+}
+function castToNumber(value) {
+  return isNumeric(value) ? Number(value) : null;
+}
+function isNumeric(num) {
+  const str = String(num);
+  return !isNaN(str) && !isNaN(parseFloat(str));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  castToNumber,
+  castToString
+});

package/dist/castValues.d.cts

@@ -0,0 +1,4 @@
+declare function castToString(value: unknown): string | null;
+declare function castToNumber(value: unknown): number | null;
+
+export { castToNumber, castToString };

package/dist/castValues.js

@@ -13,4 +13,3 @@ export {
   castToNumber,
   castToString
 };
-//# sourceMappingURL=castValues.js.map

package/dist/chunk-3PXKYWJF.js

@@ -0,0 +1,148 @@
+import {
+  isObject
+} from "./chunk-4UGSP3L3.js";
+
+// src/rsResult.ts
+function okUnwrapOr() {
+  return this.value;
+}
+function okMap(mapFn) {
+  return this.ok ? ok(mapFn(this.value)) : this;
+}
+function errMap(mapFn) {
+  return this.ok ? this : err(mapFn(this.error));
+}
+function mapOkAndErr({
+  ok: mapFn,
+  err: mapErrFn
+}) {
+  return this.ok ? ok(mapFn(this.value)) : err(mapErrFn(this.error));
+}
+function returnResult() {
+  return this;
+}
+function ok(value = void 0) {
+  return {
+    ok: true,
+    error: false,
+    value,
+    unwrapOrNull: okUnwrapOr,
+    unwrapOr: okUnwrapOr,
+    unwrap: okUnwrapOr,
+    mapOk: okMap,
+    mapErr: returnResult,
+    mapOkAndErr
+  };
+}
+function err(error) {
+  return {
+    ok: false,
+    error,
+    unwrapOrNull: () => null,
+    unwrapOr: (defaultValue) => defaultValue,
+    errorResult() {
+      return err(error);
+    },
+    unwrap: () => {
+      if (error instanceof Error) {
+        throw error;
+      }
+      throw normalizeError(error);
+    },
+    mapOk: returnResult,
+    mapErr: errMap,
+    mapOkAndErr
+  };
+}
+function unknownToError(error) {
+  return err(normalizeError(error));
+}
+async function asyncUnwrap(result) {
+  const unwrapped = await result;
+  if (unwrapped.ok) {
+    return unwrapped.value;
+  }
+  if (unwrapped.error instanceof Error) {
+    throw unwrapped.error;
+  }
+  throw normalizeError(unwrapped.error);
+}
+function asyncMap(resultPromise) {
+  return {
+    err: async (mapFn) => {
+      const result = await resultPromise;
+      return result.ok ? ok(result.value) : err(mapFn(result.error));
+    },
+    ok: async (mapFn) => {
+      const result = await resultPromise;
+      return result.ok ? ok(mapFn(result.value)) : err(result.error);
+    },
+    okAndErr: async ({
+      ok: mapFn,
+      err: mapErrFn
+    }) => {
+      const result = await resultPromise;
+      return result.ok ? ok(mapFn(result.value)) : err(mapErrFn(result.error));
+    }
+  };
+}
+var Result = {
+  ok,
+  err,
+  unknownToError,
+  asyncUnwrap,
+  asyncMap
+};
+function resultify(fn, errorNormalizer) {
+  try {
+    return ok(fn());
+  } catch (error) {
+    return err(
+      errorNormalizer ? errorNormalizer(error) : normalizeError(error)
+    );
+  }
+}
+async function asyncResultify(fn, errorNormalizer) {
+  try {
+    return ok(await fn());
+  } catch (error) {
+    return err(
+      errorNormalizer ? errorNormalizer(error) : normalizeError(error)
+    );
+  }
+}
+function normalizeError(error) {
+  if (error instanceof Error) return error;
+  if (typeof error === "string") {
+    return new Error(error);
+  }
+  if (isObject(error)) {
+    return new Error(
+      "message" in error && error.message && typeof error.message === "string" ? error.message : safeJsonStringify(error) ?? "unknown",
+      { cause: error }
+    );
+  }
+  return new Error(safeJsonStringify(error) ?? "unknown", { cause: error });
+}
+function safeJsonStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch (_) {
+    return null;
+  }
+}
+function createTypedResult() {
+  return {
+    ok,
+    err
+  };
+}
+
+export {
+  Result,
+  resultify,
+  asyncResultify,
+  normalizeError,
+  safeJsonStringify,
+  createTypedResult
+};

package/dist/{chunk-FYMTZQ42.js → chunk-4UGSP3L3.js}

@@ -64,4 +64,3 @@ export {
   isPromise,
   isPlainObject
 };
-//# sourceMappingURL=chunk-FYMTZQ42.js.map

package/dist/{chunk-HLFWWIDK.js → chunk-5DZT3Z5Z.js}

@@ -6,4 +6,3 @@ function sleep(ms) {
 export {
   sleep
 };
-//# sourceMappingURL=chunk-HLFWWIDK.js.map

package/dist/{chunk-W7X6NSGR.js → chunk-AZBBTE33.js}

@@ -61,4 +61,3 @@ export {
   arrayWithPrevAndIndex,
   isInArray
 };
-//# sourceMappingURL=chunk-W7X6NSGR.js.map

package/dist/{chunk-MMKMF4GG.js → chunk-IATIXMCE.js}

@@ -18,4 +18,3 @@ function bytesToHumanReadable(bytes) {
 export {
   bytesToHumanReadable
 };
-//# sourceMappingURL=chunk-MMKMF4GG.js.map

package/dist/{chunk-M74KKYE4.js → chunk-KCOXGSRA.js}

@@ -62,4 +62,3 @@ function deepEqual(foo, bar) {
 export {
   deepEqual
 };
-//# sourceMappingURL=chunk-M74KKYE4.js.map

package/dist/{chunk-NKCC3375.js → chunk-NWXBMMHO.js}

@@ -21,4 +21,3 @@ export {
   clampRange,
   clamp
 };
-//# sourceMappingURL=chunk-NKCC3375.js.map

package/dist/{chunk-SNAAKCTH.js → chunk-RVVH3MDA.js}

@@ -37,4 +37,3 @@ export {
   mapObjectToObject,
   omit
 };
-//# sourceMappingURL=chunk-SNAAKCTH.js.map

package/dist/{chunk-4QK76IRX.js → chunk-T5WDDPFI.js}

@@ -1,6 +1,6 @@
 import {
   isFunction
-} from "./chunk-FYMTZQ42.js";
+} from "./chunk-4UGSP3L3.js";
 
 // src/enhancedMap.ts
 var enhancedMapReject = Symbol();
@@ -73,10 +73,6 @@ var EnhancedMap = class _EnhancedMap extends Map {
   toKeys() {
     return [...this.keys()];
   }
-  /** @deprecated, will be removed in v5 use `from` method instead */
-  static fromIterMap(array, mapFunction) {
-    return this.from(array, mapFunction);
-  }
   static from(array, mapFunction) {
     const map = new _EnhancedMap();
     if (!array) return map;
@@ -102,4 +98,3 @@ export {
   enhancedMapReject,
   EnhancedMap
 };
-//# sourceMappingURL=chunk-4QK76IRX.js.map

package/dist/{chunk-GLZ5MZC5.js → chunk-V2L472LS.js}

@@ -12,34 +12,6 @@ function joinStrings(...args) {
   }
   return strings.join("");
 }
-function dedent(strings, ...values) {
-  const raw = typeof strings === "string" ? [strings] : strings.raw;
-  let result = "";
-  for (let i = 0; i < raw.length; i++) {
-    result += raw[i].replace(/\\\n[ \t]*/g, "").replace(/\\`/g, "`");
-    if (i < values.length) {
-      result += values[i];
-    }
-  }
-  const lines = result.split("\n");
-  let mindent = null;
-  lines.forEach((l) => {
-    const m = l.match(/^(\s+)\S+/);
-    if (m) {
-      const indent = m[1].length;
-      if (!mindent) {
-        mindent = indent;
-      } else {
-        mindent = Math.min(mindent, indent);
-      }
-    }
-  });
-  if (mindent !== null) {
-    const m = mindent;
-    result = lines.map((l) => l.startsWith(" ") ? l.slice(m) : l).join("\n");
-  }
-  return result.trim().replace(/\\n/g, "\n");
-}
 function formatNum(num) {
   return num.toLocaleString("en-US", {
     minimumFractionDigits: 2,
@@ -59,10 +31,8 @@ function truncateString(str, length, ellipsis = "\u2026") {
 
 export {
   joinStrings,
-  dedent,
   formatNum,
   isSnakeCase,
   convertToSnakeCase,
   truncateString
 };
-//# sourceMappingURL=chunk-GLZ5MZC5.js.map

package/dist/consoleFmt.cjs

@@ -0,0 +1,84 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/consoleFmt.ts
+var consoleFmt_exports = {};
+__export(consoleFmt_exports, {
+  consoleFmt: () => consoleFmt
+});
+module.exports = __toCommonJS(consoleFmt_exports);
+var colorToCodeASCII = {
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  black: "\x1B[30m",
+  gray: "\x1B[90m",
+  brightRed: "\x1B[91m",
+  brightGreen: "\x1B[92m",
+  brightYellow: "\x1B[93m",
+  brightBlue: "\x1B[94m",
+  brightMagenta: "\x1B[95m",
+  brightCyan: "\x1B[96m",
+  brightWhite: "\x1B[97m"
+};
+function consoleColors(color, text) {
+  return `${colorToCodeASCII[color]}${text}\x1B[0m`;
+}
+function bold(text) {
+  return `\x1B[1m${text}\x1B[0m`;
+}
+function underline(text) {
+  return `\x1B[4m${text}\x1B[0m`;
+}
+var bgColorToCodeASCII = {
+  red: "\x1B[41m",
+  green: "\x1B[42m",
+  yellow: "\x1B[43m",
+  blue: "\x1B[44m",
+  magenta: "\x1B[45m",
+  cyan: "\x1B[46m",
+  white: "\x1B[47m",
+  black: "\x1B[40m",
+  gray: "\x1B[100m",
+  brightRed: "\x1B[101m",
+  brightGreen: "\x1B[102m",
+  brightYellow: "\x1B[103m",
+  brightBlue: "\x1B[104m",
+  brightMagenta: "\x1B[105m",
+  brightCyan: "\x1B[106m",
+  brightWhite: "\x1B[107m"
+};
+function bgColor(color, text) {
+  const resetBgColor = "\x1B[49m";
+  return `${bgColorToCodeASCII[color]}${text}${resetBgColor}\x1B[0m`;
+}
+var consoleFmt = {
+  color: consoleColors,
+  bold,
+  underline,
+  bgColor
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  consoleFmt
+});