@ditojs/utils 2.0.1 → 2.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ditojs/utils",
-  "version": "2.0.1",
+  "version": "2.1.1",
   "type": "module",
   "description": "Dito.js Utility Functions – Dito.js is a declarative and modern web framework, based on Objection.js, Koa.js and Vue.js",
   "repository": "https://github.com/ditojs/dito/tree/master/packages/utils",
@@ -29,10 +29,10 @@
     "punycode": "^2.3.0"
   },
   "devDependencies": {
-    "typescript": "^5.0.3"
+    "typescript": "^5.0.4"
   },
   "types": "types",
-  "gitHead": "80c209774fe4ee5243eb25d77ac9a97bfb694d8c",
+  "gitHead": "b4ff87b7ffa812092a27b6c28a8ab3c5d7d7094d",
   "scripts": {
     "types": "tsc --noEmit types/index.d.ts"
   },

package/src/array/shuffle.js

@@ -1,7 +1,7 @@
 export function shuffle(array) {
   // Do the Fisher-Yates (aka Knuth) Shuffle:
   const res = array.slice()
-  for (let i = array.length; i;) {
+  for (let i = array.length; i; ) {
     const r = Math.floor(Math.random() * i)
     const t = res[--i]
     res[i] = res[r]

package/src/array/shuffle.test.js

@@ -17,7 +17,9 @@ describe('shuffle()', () => {
       const res = shuffle([1, 2])
       results[res] = res
     }
-    const sorted = Object.entries(results).sort().map(([, value]) => value)
+    const sorted = Object.entries(results)
+      .sort()
+      .map(([, value]) => value)
     expect(sorted).toStrictEqual([[1, 2], [2, 1]])
   })
 })

package/src/base/base.js

@@ -1,11 +1,12 @@
 export const { isArray } = Array
 const { toString } = Object.prototype
 
-export const is = Object.is || (
+export const is = (
+  Object.is ||
   // SameValue algorithm:
   // istanbul ignore next
   // eslint-disable-next-line no-self-compare
-  (x, y) => x === y ? x !== 0 || 1 / x === 1 / y : x !== x && y !== y
+  ((x, y) => (x === y ? x !== 0 || 1 / x === 1 / y : x !== x && y !== y))
 )
 
 export function isPlainObject(arg) {
@@ -13,11 +14,14 @@ export function isPlainObject(arg) {
   // We also need to check for ctor.name === 'Object', in case this is an object
   // from another global scope (e.g. another vm context in Node.js).
   // When an value has no constructor, it was created with `Object.create(null)`
-  return !!arg && (
-    ctor && (
-      ctor === Object ||
-      ctor.name === 'Object'
-    ) || !ctor && !isModule(arg)
+  return (
+    !!arg && (
+      ctor && (
+        ctor === Object ||
+        ctor.name === 'Object'
+      ) ||
+      !ctor && !isModule(arg)
+    )
   )
 }
 
@@ -35,7 +39,7 @@ function getPrimitiveCheck(name) {
   // here because `new Date().valueOf()` also returns a number.
   const typeName = name.toLowerCase()
   const toStringName = `[object ${name}]`
-  return function(arg) {
+  return function (arg) {
     const type = typeof arg
     return (
       type === typeName ||
@@ -64,13 +68,16 @@ export function isPromise(arg) {
   return !!arg && isFunction(arg.then) && isFunction(arg.catch)
 }
 
-export const isInteger = Number.isInteger || function isInteger(arg) {
-  return (
-    isNumber(arg) &&
-    isFinite(arg) &&
-    Math.floor(arg) === arg
-  )
-}
+export const isInteger = (
+  Number.isInteger ||
+  function isInteger(arg) {
+    return (
+      isNumber(arg) &&
+      isFinite(arg) &&
+      Math.floor(arg) === arg
+    )
+  }
+)
 
 export function isAsync(arg) {
   return arg?.[Symbol.toStringTag] === 'AsyncFunction'
@@ -88,9 +95,11 @@ export function isArrayLike(arg) {
 }
 
 export function isEmpty(arg) {
-  return arg == null ||
+  return (
+    arg == null ||
     isArrayLike(arg) && arg.length === 0 ||
     isObject(arg) && Object.keys(arg).length === 0
+  )
 }
 
 export function asObject(arg) {

package/src/base/base.test.js

@@ -1,7 +1,22 @@
 import {
-  isPlainObject, isObject, isArray, isModule, isFunction, isString, isBoolean,
-  isNumber, isDate, isRegExp, isPromise, isAsync, isInteger, isArrayLike,
-  isEmpty, asObject, asArray, asFunction
+  isPlainObject,
+  isObject,
+  isArray,
+  isModule,
+  isFunction,
+  isString,
+  isBoolean,
+  isNumber,
+  isDate,
+  isRegExp,
+  isPromise,
+  isAsync,
+  isInteger,
+  isArrayLike,
+  isEmpty,
+  asObject,
+  asArray,
+  asFunction
 } from './base.js'
 
 import * as module from './index.js'
@@ -14,12 +29,12 @@ const boolean = true
 const date = new Date()
 const regexp = /x/
 const symbol = Symbol('a')
-const instance = new class {}()
+const instance = new (class {})()
 const promise = new Promise(() => {})
-const func = function() {}
+const func = function () {}
 const lambda = () => {}
-const asyncFunc = async function() {}
-const asyncLambda = async function() {}
+const asyncFunc = async function () {}
+const asyncLambda = async function () {}
 
 describe('isPlainObject()', () => {
   describe.each([

package/src/class/mixin.js

@@ -3,7 +3,7 @@
 const mixinsMap = new WeakMap()
 
 export function mixin(mixinFunction) {
-  return function(targetClass) {
+  return function (targetClass) {
     // Prevent multiple application of the same mixins in nested inheritance
     // through keeping track of what was already applied in weak-maps:
     if (targetClass && !hasMixin(targetClass, mixinFunction)) {

package/src/class/mixin.test.js

@@ -5,13 +5,19 @@ describe('mixin()', () => {
     function() {}
   }
 
-  const SomeMixin1 = mixin(Class => class extends Class {
-    function1() {}
-  })
+  const SomeMixin1 = mixin(
+    Class =>
+      class extends Class {
+        function1() {}
+      }
+  )
 
-  const SomeMixin2 = mixin(Class => class extends Class {
-    function2() {}
-  })
+  const SomeMixin2 = mixin(
+    Class =>
+      class extends Class {
+        function2() {}
+      }
+  )
 
   it('should apply mixin to class', () => {
     const NewClass = SomeMixin1(SomeClass)
@@ -57,8 +63,7 @@ describe('mixin()', () => {
 
   it(`should not apply mixin more than once, even if it was applied higher up`, () => {
     const NewClass1 = SomeMixin1(SomeClass)
-    class NewClass2 extends NewClass1 {
-    }
+    class NewClass2 extends NewClass1 {}
     const NewClass3 = SomeMixin1(NewClass2)
     expect(NewClass3).toBe(NewClass2)
   })

package/src/dataPath/getEntriesAtDataPath.js

@@ -6,7 +6,9 @@ const NOT_FOUND = Symbol('NOT_FOUND')
 export function getEntriesAtDataPath(
   obj,
   path,
-  handleError = () => { throw new Error(`Invalid path: ${path}`) }
+  handleError = () => {
+    throw new Error(`Invalid path: ${path}`)
+  }
 ) {
   const parsedPath = parseDataPath(path)
 

package/src/dataPath/getValueAtDataPath.js

@@ -6,7 +6,9 @@ const NOT_FOUND = Symbol('NOT_FOUND')
 export function getValueAtDataPath(
   obj,
   path,
-  handleError = () => { throw new Error(`Invalid path: ${path}`) }
+  handleError = () => {
+    throw new Error(`Invalid path: ${path}`)
+  }
 ) {
   const parsedPath = parseDataPath(path)
   let index = 0
@@ -20,18 +22,21 @@ export function getValueAtDataPath(
         // Support wildcards on arrays and objects
         const pathNested = parsedPath.slice(index + 1)
         const values = isArray(obj) ? obj : Object.values(obj)
-        return values.map(
-          value => getValueAtDataPath(value, pathNested, handleError)
-        ).flat(1)
+        return values
+          .map(value => getValueAtDataPath(value, pathNested, handleError))
+          .flat(1)
       } else if (part === '**') {
         // Support deep wildcards on arrays and objects
         const pathNested = parsedPath.slice(index + 1)
         const pathSelf = parsedPath.slice(index)
         const values = isArray(obj) ? obj : Object.values(obj)
-        return values.map(value => [
-          ...asArray(getValueAtDataPath(value, pathNested, () => NOT_FOUND)),
-          ...asArray(getValueAtDataPath(value, pathSelf, () => NOT_FOUND))
-        ]).flat(1).filter(value => value !== NOT_FOUND)
+        return values
+          .map(value => [
+            ...asArray(getValueAtDataPath(value, pathNested, () => NOT_FOUND)),
+            ...asArray(getValueAtDataPath(value, pathSelf, () => NOT_FOUND))
+          ])
+          .flat(1)
+          .filter(value => value !== NOT_FOUND)
       }
     }
     return handleError?.(obj, part, index)

package/src/dataPath/setDataPathEntries.test.js

@@ -13,10 +13,12 @@ describe('setDataPathEntries()', () => {
   const add = { prop: 'new' }
 
   it('should add data at a path to a given object and array', () => {
-    expect(() => setDataPathEntries(data, {
-      'object.array[0].added': add,
-      'object.array[1]': add
-    }))
+    expect(() =>
+      setDataPathEntries(data, {
+        'object.array[0].added': add,
+        'object.array[1]': add
+      })
+    )
       .not.toThrow()
     expect(data.object.array[0].added).toStrictEqual(add)
     expect(data.object.array[1]).toStrictEqual(add)

package/src/function/toAsync.test.js

@@ -3,7 +3,7 @@ import { toAsync } from './toAsync.js'
 describe('toAsync()', () => {
   it('should convert callback functions to async', async () => {
     expect.assertions(1)
-    const asyncFunc = toAsync(function(toResolve, callback) {
+    const asyncFunc = toAsync(function (toResolve, callback) {
       process.nextTick(() => {
         callback(null, toResolve)
       })
@@ -16,7 +16,7 @@ describe('toAsync()', () => {
   it('should convert callback errors to exceptions', async () => {
     expect.assertions(1)
     const error = new Error('This error is intentional')
-    const throwError = toAsync(function(toReject, callback) {
+    const throwError = toAsync(function (toReject, callback) {
       process.nextTick(() => {
         callback(toReject)
       })

package/src/html/escapeHtml.js

@@ -1,6 +1,11 @@
 export function escapeHtml(html) {
   return html != null
-    ? html.toString().replace(/["&<>]/g,
-      chr => ({ '"': '&quot;', '&': '&amp;', '<': '&lt;', '>': '&gt;' })[chr])
+    ? html
+        .toString()
+        .replace(
+          /["&<>]/g,
+          chr =>
+            ({ '"': '&quot;', '&': '&amp;', '<': '&lt;', '>': '&gt;' }[chr])
+        )
     : ''
 }

package/src/object/clone.js

@@ -1,5 +1,10 @@
 import {
-  isArray, isObject, isDate, isRegExp, isFunction, isPromise
+  isArray,
+  isObject,
+  isDate,
+  isRegExp,
+  isFunction,
+  isPromise
 } from '../base/index.js'
 import { pick } from './pick.js'
 
@@ -21,11 +26,12 @@ export function clone(value, options) {
     return copy
   }
 
-  const handleValue = value => {
-    return shallow || transferables?.includes(value) ? value
-      : clones.has(value) ? clones.get(value)
-      : cloneValue(value)
-  }
+  const handleValue = value =>
+    shallow || transferables?.includes(value)
+      ? value
+      : clones.has(value)
+        ? clones.get(value)
+        : cloneValue(value)
 
   const cloneValue = value => {
     let copy = value
@@ -39,15 +45,15 @@ export function clone(value, options) {
         copy[i] = handleValue(value[i])
       }
     } else if (isObject(value)) {
-    // Rely on arg.clone() if it exists and assume it creates an actual clone.
+      // Rely on arg.clone() if it exists and assume it creates an actual clone.
       if (isFunction(value.clone)) {
         copy = storeClone(value, value.clone(options))
       } else if (isPromise(value)) {
-      // https://stackoverflow.com/questions/37063293/can-i-clone-a-promise
+        // https://stackoverflow.com/questions/37063293/can-i-clone-a-promise
         copy = storeClone(value, value.then())
       } else {
-      // Prevent calling the actual constructor since it is not guaranteed to
-      // work as intended here, and only clone the non-inherited own properties.
+        // Prevent calling the actual constructor since it is not guaranteed to
+        // work as intended here, and only clone non-inherited own properties.
         copy = storeClone(value, Object.create(Object.getPrototypeOf(value)))
         clones.set(value, copy)
         const keys = enumerable ? Object.keys(value) : Reflect.ownKeys(value)

package/src/object/equals.test.js

@@ -4,27 +4,52 @@ describe('equals()', () => {
   const symbol1 = Symbol('a')
   const symbol2 = Symbol('b')
   describe.each([
-    [1, 1, true], [1, Object(1), true], [1, '1', false], [1, 2, false],
-    [-0, -0, true], [0, 0, true], [0, Object(0), true],
-    [Object(0), Object(0), true], [-0, 0, true], [0, '0', false],
+    [1, 1, true],
+    [1, Object(1), true],
+    [1, '1', false],
+    [1, 2, false],
+    [-0, -0, true],
+    [0, 0, true],
+    [0, Object(0), true],
+    [Object(0), Object(0), true],
+    [-0, 0, true],
+    [0, '0', false],
     [0, null, false],
 
-    [NaN, NaN, true], [NaN, Object(NaN), true],
-    [Object(NaN), Object(NaN), true], [NaN, 'a', false], [NaN, Infinity, false],
-
-    ['a', 'a', true], ['a', Object('a'), true],
-    [Object('a'), Object('a'), true], ['a', 'b', false], ['a', ['a'], false],
-
-    [true, true, true], [true, Object(true), true],
-    [Object(true), Object(true), true], [true, 1, false], [true, 'a', false],
-    [false, false, true], [false, Object(false), true],
-    [Object(false), Object(false), true], [false, 0, false], [false, '', false],
-
-    [symbol1, symbol1, true], [symbol1, Object(symbol1), true],
-    [Object(symbol1), Object(symbol1), true], [symbol1, symbol2, false],
-
-    [null, null, true], [null, undefined, false], [null, {}, false],
-    [null, '', false], [undefined, undefined, true], [undefined, null, false],
+    [NaN, NaN, true],
+    [NaN, Object(NaN), true],
+    [Object(NaN), Object(NaN), true],
+    [NaN, 'a', false],
+    [NaN, Infinity, false],
+
+    ['a', 'a', true],
+    ['a', Object('a'), true],
+    [Object('a'), Object('a'), true],
+    ['a', 'b', false],
+    ['a', ['a'], false],
+
+    [true, true, true],
+    [true, Object(true), true],
+    [Object(true), Object(true), true],
+    [true, 1, false],
+    [true, 'a', false],
+    [false, false, true],
+    [false, Object(false), true],
+    [Object(false), Object(false), true],
+    [false, 0, false],
+    [false, '', false],
+
+    [symbol1, symbol1, true],
+    [symbol1, Object(symbol1), true],
+    [Object(symbol1), Object(symbol1), true],
+    [symbol1, symbol2, false],
+
+    [null, null, true],
+    [null, undefined, false],
+    [null, {}, false],
+    [null, '', false],
+    [undefined, undefined, true],
+    [undefined, null, false],
     [undefined, '', false]
   ])(
     'equals(%o, %o) (should compare primitives)',
@@ -91,13 +116,27 @@ describe('equals()', () => {
     let array1 = [1, 2, 3]
     let array2 = [1, 2, 3]
 
-    array1.every = array1.filter = array1.forEach =
-    array1.indexOf = array1.lastIndexOf = array1.map =
-    array1.some = array1.reduce = array1.reduceRight = null
-
-    array2.concat = array2.join = array2.pop =
-    array2.reverse = array2.shift = array2.slice =
-    array2.sort = array2.splice = array2.unshift = null
+    array1.every =
+      array1.filter =
+      array1.forEach =
+      array1.indexOf =
+      array1.lastIndexOf =
+      array1.map =
+      array1.some =
+      array1.reduce =
+      array1.reduceRight =
+        null
+
+    array2.concat =
+      array2.join =
+      array2.pop =
+      array2.reverse =
+      array2.shift =
+      array2.slice =
+      array2.sort =
+      array2.splice =
+      array2.unshift =
+        null
 
     expect(equals(array1, array2)).toBe(true)
 
@@ -217,8 +256,12 @@ describe('equals()', () => {
   })
 
   it('should compare functions', () => {
-    function a() { return 1 + 2 }
-    function b() { return 1 + 2 }
+    function a() {
+      return 1 + 2
+    }
+    function b() {
+      return 1 + 2
+    }
 
     expect(equals(a, a)).toBe(true)
     expect(equals(a, b)).toBe(false)

package/src/object/groupBy.test.js

@@ -17,12 +17,14 @@ describe('groupBy()', () => {
       [2, 'a'],
       [2, 'b']
     ]
-    expect(groupBy(array, value => value[0])).toStrictEqual(
-      { 1: [[1, 'a']], 2: [[2, 'a'], [2, 'b']] }
-    )
-    expect(groupBy(array, value => value[1])).toStrictEqual(
-      { a: [[1, 'a'], [2, 'a']], b: [[2, 'b']] }
-    )
+    expect(groupBy(array, value => value[0])).toStrictEqual({
+      1: [[1, 'a']],
+      2: [[2, 'a'], [2, 'b']]
+    })
+    expect(groupBy(array, value => value[1])).toStrictEqual({
+      a: [[1, 'a'], [2, 'a']],
+      b: [[2, 'b']]
+    })
   })
 
   it('should work with an object for `collection`', () => {

package/src/object/mapKeys.js

@@ -1,4 +1,3 @@
-
 export function mapKeys(object, callback) {
   return Object.keys(object).reduce((mapped, key) => {
     const value = object[key]

package/src/object/mapValues.js

@@ -1,4 +1,3 @@
-
 export function mapValues(object, callback) {
   return Object.keys(object).reduce((mapped, key) => {
     mapped[key] = callback(object[key], key, object)

package/src/object/merge.js

@@ -3,10 +3,14 @@ import { clone } from './clone.js'
 
 export function merge(target, ...sources) {
   const _merge = (target, source, cloneTarget) => {
-    if (target && source && target !== source && (
-      isArray(target) && isArray(source) ||
-      isPlainObject(target) && isPlainObject(source)
-    )) {
+    if (
+      target &&
+      source &&
+      target !== source && (
+        isArray(target) && isArray(source) ||
+        isPlainObject(target) && isPlainObject(source)
+      )
+    ) {
       const result = cloneTarget
         ? clone(target)
         : target

package/src/string/camelize.js

@@ -1,13 +1,14 @@
 export function camelize(str, pascalCase = false) {
   return str
     ? str
-      // Trim beginnings and ends
-      .replace(/^[-_\s]+|[-_\s]+$/g, '')
-      .replace(
-        /(^|[-_\s]+)(\w)([A-Z]*)([a-z]*)/g,
-        (all, sep, first, upperRest, lowerRest) => `${
-          pascalCase || sep ? first.toUpperCase() : first.toLowerCase()
-        }${upperRest.toLowerCase()}${lowerRest}`
-      )
+        // Trim beginnings and ends
+        .replace(/^[-_\s]+|[-_\s]+$/g, '')
+        .replace(
+          /(^|[-_\s]+)(\w)([A-Z]*)([a-z]*)/g,
+          (all, sep, first, upperRest, lowerRest) =>
+            `${
+              pascalCase || sep ? first.toUpperCase() : first.toLowerCase()
+            }${upperRest.toLowerCase()}${lowerRest}`
+        )
     : ''
 }

package/src/string/camelize.test.js

@@ -14,7 +14,10 @@ describe('camelize()', () => {
     (pascalCase, expected) => {
       describe.each([
         ...strings,
-        'foo-bar', 'foo_bar', '--foo-bar--', '__foo_bar__'
+        'foo-bar',
+        'foo_bar',
+        '--foo-bar--',
+        '__foo_bar__'
       ])(
         `camelize(%o, ${pascalCase})`,
         value => {

package/src/string/capitalize.js

@@ -1,6 +1,7 @@
 export function capitalize(str) {
   return str
-    ? str.replace(/(^|[^a-zA-Z\u00C0-\u017F'])([a-zA-Z\u00C0-\u017F])/g,
-      chr => chr.toUpperCase())
+    ? str.replace(/(^|[^a-zA-Z\u00C0-\u017F'])([a-zA-Z\u00C0-\u017F])/g, chr =>
+        chr.toUpperCase()
+      )
     : ''
 }

package/src/string/decamelize.js

@@ -1,16 +1,18 @@
 export function decamelize(str, sep = ' ') {
   return str
     ? str
-      .replace(
-        // TODO: Once JavaScript supports Unicode properties in regexps, switch
-        // to better parsing that matches non-ASCII uppercase letters:
-        // /([\p{Ll}\d])(\p{Lu})/gu
-        /([a-z\d])([A-Z])|(\S)(?:\s+)(\S)/g,
-        (all, lower, upper, beforeSpace, afterSpace) => upper
-          ? `${lower}${sep}${upper}`
-          : `${beforeSpace}${sep}${afterSpace}`
-      )
-      .toLowerCase()
+        .replace(
+          // TODO: Once JavaScript supports Unicode property escapes in regexps,
+          // switch to better parsing that matches non-ASCII uppercase letters:
+          // /([\p{Ll}\d])(\p{Lu})/gu
+          // See: https://caniuse.com/?search=Unicode%20property%20escape
+          /([a-z\d])([A-Z])|(\S)(?:\s+)(\S)/g,
+          (all, lower, upper, beforeSpace, afterSpace) =>
+            upper
+              ? `${lower}${sep}${upper}`
+              : `${beforeSpace}${sep}${afterSpace}`
+        )
+        .toLowerCase()
     : ''
 }
 

package/src/string/deindent.js

@@ -11,11 +11,13 @@ export function deindent(strings, ...values) {
   // First, perform interpolation
   let parts = []
   for (let i = 0; i < strings.length; i++) {
-    parts.push(strings[i]
-      // Join lines when there is a line-break suppressed by a preceding '\\'
-      .replace(/\\\n\s*/g, '')
-      // Handle escaped back-ticks
-      .replace(/\\`/g, '`'))
+    parts.push(
+      strings[i]
+        // Join lines when there is a line-break suppressed by a preceding '\\'
+        .replace(/\\\n\s*/g, '')
+        // Handle escaped back-ticks
+        .replace(/\\`/g, '`')
+    )
     if (i < values.length) {
       // See if the value itself contains multiple lines, and if so, indent
       // each of them by the whitespace that precedes it except the first.
@@ -32,7 +34,9 @@ export function deindent(strings, ...values) {
         //                      # line, by making sure no line breaks follow
         //                      # until the end.
         const str = parts.join('')
-        const match = str.match(/((?:^[\n\r]*|[\n\r])(?:[\n\r]*))(\s+)(?:[^\n\r]*)$/)
+        const match = str.match(
+          /((?:^[\n\r]*|[\n\r])(?:[\n\r]*))(\s+)(?:[^\n\r]*)$/
+        )
         const [, lineBreaks = '', indent = ''] = match || []
         parts = [str]
         parts.push(lines.join(`${getLineBreak(lineBreaks)}${indent}`))

package/src/string/deindent.test.js

@@ -8,7 +8,7 @@ describe('deindent()', () => {
           indented
             text`
     ).toBe(
-`some
+      `some
   indented
     text`
     )
@@ -22,7 +22,7 @@ describe('deindent()', () => {
             text
       `
     ).toBe(
-`some
+      `some
   indented
     text
 `
@@ -39,7 +39,7 @@ describe('deindent()', () => {
             text
       `
     ).toBe(
-`
+      `
 
 some
   indented
@@ -58,7 +58,7 @@ some
 
       `
     ).toBe(
-`some
+      `some
   indented
     text
 
@@ -76,7 +76,7 @@ some
   indented
     text`
     ).toBe(
-`some
+      `some
   indented
     text
 some
@@ -91,7 +91,7 @@ some
     indented
       text`
     ).toBe(
-`some
+      `some
   indented
     text`
     )
@@ -106,7 +106,7 @@ some
             ${singleLineText}
       `
     ).toBe(
-`some
+      `some
   indented
     single-line text
 `
@@ -122,7 +122,7 @@ indented
 ${multiLineText}
 `
     ).toBe(
-`some
+      `some
 indented
 multi-
 line
@@ -140,7 +140,7 @@ text
             ${multiLineText}
       `
     ).toBe(
-`some
+      `some
   indented
     multi-
     line
@@ -158,7 +158,7 @@ text
             content: ${multiLineText}
       `
     ).toBe(
-`some
+      `some
   indented
     content: multi-
     line
@@ -173,7 +173,7 @@ text
         indented
           text`
     ).toBe(
-`some
+      `some
         indented
           text`
     )

package/src/string/format.js

@@ -32,14 +32,14 @@ export function format(value, {
       ? defaultOption
       : isObject(option)
         ? Object.entries({
-          ...defaultOption,
-          ...option
-        }).reduce((opt, [key, value]) => {
-          if (value !== false) {
-            opt[key] = value
-          }
-          return opt
-        }, {})
+            ...defaultOption,
+            ...option
+          }).reduce((opt, [key, value]) => {
+            if (value !== false) {
+              opt[key] = value
+            }
+            return opt
+          }, {})
         : {}
   }
 
@@ -62,9 +62,11 @@ export function format(value, {
         // e.g. to replace decimals and such:
         const parts = new Intl.NumberFormat(locale, options)
           .formatToParts(value)
-        return parts.map(({ type, value }) =>
-          options.format(value, type, options) ?? value
-        ).join('')
+        return parts
+          .map(
+            ({ type, value }) => options.format(value, type, options) ?? value
+          )
+          .join('')
       }
     }
   } else if (isDate(value)) {
@@ -86,16 +88,18 @@ export function format(value, {
         const parts = new Intl.DateTimeFormat(locale, options)
           .formatToParts(value)
         let modeOpts = null
-        return parts.map(({ type, value }) => {
-          if (type !== 'literal') {
-            // Switch mode between date & time to pick the right format methdod:
-            const mode = ['weekday', 'day', 'month', 'year'].includes(type)
-              ? 'date'
-              : 'time'
-            modeOpts = opts[mode]
-          }
-          return modeOpts?.format?.(value, type, modeOpts) ?? value
-        }).join('')
+        return parts
+          .map(({ type, value }) => {
+            if (type !== 'literal') {
+              // Switch mode between date/time to pick the right format method:
+              const mode = ['weekday', 'day', 'month', 'year'].includes(type)
+                ? 'date'
+                : 'time'
+              modeOpts = opts[mode]
+            }
+            return modeOpts?.format?.(value, type, modeOpts) ?? value
+          })
+          .join('')
       }
     }
   }

package/src/string/format.test.js

@@ -148,11 +148,12 @@ describe('format()', () => {
         number: {
           style: 'currency',
           currency: 'GBP',
-          format: (value, type) => type === 'group'
-            ? `’`
-            : type === 'decimal'
-              ? ','
-              : undefined
+          format: (value, type) =>
+            type === 'group'
+              ? `’`
+              : type === 'decimal'
+                ? ','
+                : undefined
         }
       })
     ).toBe(`£123’456’789,00`)
@@ -166,11 +167,10 @@ describe('format()', () => {
           day: 'numeric',
           month: 'numeric',
           year: 'numeric',
-          format: (value, type, options) => (
+          format: (value, type, options) =>
             type === 'literal' && options.month === 'numeric'
               ? value.replace(/\//, '.').replace(/,/, '')
               : undefined
-          )
         },
         time: {
           hour: '2-digit',

package/src/string/isCreditCard.js

@@ -1,4 +1,5 @@
-const creditCardRegExp = /^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|(222[1-9]|22[3-9][0-9]|2[3-6][0-9]{2}|27[01][0-9]|2720)[0-9]{12}|6(?:011|5[0-9][0-9])[0-9]{12}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11}|(?:2131|1800|35\d{3})\d{11})|62[0-9]{14}$/
+const creditCardRegExp =
+  /^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|(222[1-9]|22[3-9][0-9]|2[3-6][0-9]{2}|27[01][0-9]|2720)[0-9]{12}|6(?:011|5[0-9][0-9])[0-9]{12}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11}|(?:2131|1800|35\d{3})\d{11})|62[0-9]{14}$/
 
 export function isCreditCard(str) {
   str = str && str.replace(/[\s-]+/g, '')

package/src/string/isDomain.js

@@ -2,7 +2,8 @@
 import punycode from 'punycode'
 
 // Best effort approach, allowing Internationalized domain name (with punycode)
-const domainRegExp = /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9][a-z0-9-]{0,61}[a-z0-9]$/i
+const domainRegExp =
+  /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9][a-z0-9-]{0,61}[a-z0-9]$/i
 
 export function isDomain(str) {
   return !!(str && domainRegExp.test(punycode.toASCII(str)))

package/src/string/isEmail.js

@@ -1,4 +1,5 @@
-const emailRegExp = /^(([^<>()[\].,;:\s@"]+(\.[^<>()[\].,;:\s@"]+)*)|(".+"))@(([^<>()[\].,;:\s@"]+\.)+[^<>()[\].,;:\s@"]{2,})$/i
+const emailRegExp =
+  /^(([^<>()[\].,;:\s@"]+(\.[^<>()[\].,;:\s@"]+)*)|(".+"))@(([^<>()[\].,;:\s@"]+\.)+[^<>()[\].,;:\s@"]{2,})$/i
 
 export function isEmail(str) {
   return !!(str && emailRegExp.test(str))

package/src/string/isHostname.js

@@ -1,6 +1,7 @@
 // https://tools.ietf.org/html/rfc1034#section-3.5
 // https://tools.ietf.org/html/rfc1123#section-2
-const hostnameRegExp = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*$/i
+const hostnameRegExp =
+  /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*$/i
 
 export function isHostname(str) {
   return !!(str && hostnameRegExp.test(str))

package/src/string/isUrl.js

@@ -2,19 +2,19 @@
 // isUrl() returns `true` for 'google.com', and isAbsoluteUrl() returns `false`!
 
 const isUrlRegExp = new RegExp(
-  '^((https?|ftps?|mailto|rtsp|mms)?://)?' +
-  '(([0-9a-z_!~*\'().&=+$%-]+:)?[0-9a-z_!~*\'().&=+$%-]*@)?' + // user:pass@
+  '^((https?|ftps?|mailto|rtsp|mms)?://)?' + // user:pass@
+  "(([0-9a-z_!~*'().&=+$%-]+:)?[0-9a-z_!~*'().&=+$%-]*@)?" +
   '(' +
-    '(\\d{1,3}\\.){3}\\d{1,3}' + // ip
-    '|' +
-    '([0-9a-z_-]+\\.)*' + // sub-domain: www.
-    '[0-9a-z][0-9a-z_-]{0,61}[0-9a-z]\\.' + // domain-name
-    // tld - https://tools.ietf.org/id/draft-liman-tld-names-00.html#rfc.section.2
-    '([a-z]{2,61}|xn--[0-9a-z][0-9a-z-]{0,61}[0-9a-z])' +
+  '(\\d{1,3}\\.){3}\\d{1,3}' + // ip
+  '|' +
+  '([0-9a-z_-]+\\.)*' + // sub-domain: www.
+  '[0-9a-z][0-9a-z_-]{0,61}[0-9a-z]\\.' + // domain-name
+  // tld - https://tools.ietf.org/id/draft-liman-tld-names-00.html#rfc.section.2
+  '([a-z]{2,61}|xn--[0-9a-z][0-9a-z-]{0,61}[0-9a-z])' +
   ')' + // top level domain.
   '(:[0-9]{1,5})?' + // port
   '((/?)|' + // allow ending in a slash
-  '([/?#][0-9a-z_!~*\'().;:@&=+$,%/?#-]+)+/?)$', // path
+  "([/?#][0-9a-z_!~*'().;:@&=+$,%/?#-]+)+/?)$", // path
   'i'
 )
 

package/src/string/isUrl.test.js

@@ -24,7 +24,7 @@ describe('isUrl()', () => {
     'http://10.0.0.0/',
     'http://189.123.14.13/',
     'http://duckduckgo.com/?q=%2F',
-    'http://foobar.com/t$-_.+!*\'(),',
+    "http://foobar.com/t$-_.+!*'(),",
     'http://foobar.com/?foo=bar#baz=qux',
     'http://foobar.com?foo=bar',
     'http://foobar.com#baz=qux',
@@ -76,7 +76,7 @@ describe('isUrl()', () => {
     'http://localhost:61500this is an invalid url!!!!',
     '////foobar.com',
     'http:////foobar.com',
-    'https://example.com/foo/<script>alert(\'XSS\')</script>/'
+    "https://example.com/foo/<script>alert('XSS')</script>/"
     // TODO: block this: 'mailto:foo@bar.com'
   ])(
     'isUrl(%o)',

package/src/string/labelize.js

@@ -2,13 +2,15 @@ export function labelize(str) {
   // Handle hyphenated, underscored and camel-cased property names and
   // expand them to title cased labels.
   return str
-    ? str.replace(/([-_ ]|^)(\w)|([a-z])(?=[A-Z0-9])|(\d)([a-zA-Z])/g,
-      function(all, hyphen, hyphenated, camel, decimal, decimalNext) {
-        return hyphenated
-          ? `${hyphen ? ' ' : ''}${hyphenated.toUpperCase()}`
-          : camel
-            ? `${camel} `
-            : `${decimal} ${decimalNext.toUpperCase()}`
-      })
+    ? str.replace(
+        /([-_ ]|^)(\w)|([a-z])(?=[A-Z0-9])|(\d)([a-zA-Z])/g,
+        function (all, hyphen, hyphenated, camel, decimal, decimalNext) {
+          return hyphenated
+            ? `${hyphen ? ' ' : ''}${hyphenated.toUpperCase()}`
+            : camel
+              ? `${camel} `
+              : `${decimal} ${decimalNext.toUpperCase()}`
+        }
+      )
     : ''
 }

package/src/timer/debounce.js

@@ -6,7 +6,7 @@ export function debounce(func, options) {
   let timer = null
   let result
 
-  const debounced = function(...args) {
+  const debounced = function (...args) {
     const callNow = immediate && !timer
     clearTimeout(timer)
     timer = setTimeout(async () => {
@@ -21,7 +21,7 @@ export function debounce(func, options) {
     return result
   }
 
-  debounced.cancel = function() {
+  debounced.cancel = function () {
     const pending = timer !== null
     if (pending) {
       clearTimeout(timer)

package/src/timer/debounceAsync.js

@@ -26,7 +26,7 @@ export function debounceAsync(func, options) {
     callbacks = []
   }
 
-  const debounced = function(...args) {
+  const debounced = function (...args) {
     return new Promise((resolve, reject) => {
       const callNow = immediate && !timer
       clearTimeout(timer)
@@ -45,7 +45,7 @@ export function debounceAsync(func, options) {
     })
   }
 
-  debounced.cancel = function() {
+  debounced.cancel = function () {
     const pending = timer !== null
     if (pending) {
       resolve(undefined)

package/src/timer/debounceAsync.test.js

@@ -53,7 +53,9 @@ describe('debounceAsync()', () => {
 
   it('should pass through `this`', async () => {
     expect.assertions(2)
-    const func = vi.fn(async function() { return this })
+    const func = vi.fn(async function () {
+      return this
+    })
     const debounced = debounceAsync(func, 1000)
     const obj = {}
     const promises = []
@@ -82,69 +84,60 @@ describe('debounceAsync()', () => {
     expect(func).toBeCalledTimes(1)
   })
 
-  it(
-    'should execute once immediately if intervals are less than wait',
-    async () => {
-      expect.assertions(2)
-      const func = vi.fn()
-      const debounced = debounceAsync(func, { delay: 1000, immediate: true })
-      const promises = []
+  it('should execute once immediately if intervals are less than wait', async () => {
+    expect.assertions(2)
+    const func = vi.fn()
+    const debounced = debounceAsync(func, { delay: 1000, immediate: true })
+    const promises = []
+    promises.push(debounced())
+    expect(func).toBeCalledTimes(1)
+    for (let i = 0; i < 10; i++) {
+      vi.advanceTimersByTime(500)
       promises.push(debounced())
-      expect(func).toBeCalledTimes(1)
-      for (let i = 0; i < 10; i++) {
-        vi.advanceTimersByTime(500)
-        promises.push(debounced())
-      }
-      await Promise.all(promises)
-      expect(func).toBeCalledTimes(1)
     }
-  )
+    await Promise.all(promises)
+    expect(func).toBeCalledTimes(1)
+  })
 
-  it(
-    'should execute twice immediately with long enough intervals',
-    async () => {
-      expect.assertions(3)
-      const func = vi.fn()
-      const debounced = debounceAsync(func, { delay: 1000, immediate: true })
-      const promises = []
-      promises.push(debounced())
-      expect(func).toBeCalledTimes(1)
-      for (let i = 0; i < 10; i++) {
-        vi.advanceTimersByTime(500)
-        promises.push(debounced())
-      }
-      expect(func).toBeCalledTimes(1)
-      vi.advanceTimersByTime(1000)
+  it('should execute twice immediately with long enough intervals', async () => {
+    expect.assertions(3)
+    const func = vi.fn()
+    const debounced = debounceAsync(func, { delay: 1000, immediate: true })
+    const promises = []
+    promises.push(debounced())
+    expect(func).toBeCalledTimes(1)
+    for (let i = 0; i < 10; i++) {
+      vi.advanceTimersByTime(500)
       promises.push(debounced())
-      await Promise.all(promises)
-      expect(func).toBeCalledTimes(2)
     }
-  )
+    expect(func).toBeCalledTimes(1)
+    vi.advanceTimersByTime(1000)
+    promises.push(debounced())
+    await Promise.all(promises)
+    expect(func).toBeCalledTimes(2)
+  })
 
-  it(
-    'should only reject the last waiting promise',
-    async () => {
-      expect.assertions(5)
-      let count = 0
-      const func = vi.fn(() => {
-        if (++count > 1) {
-          throw new Error('boom')
-        }
-      })
-      const debounced = debounceAsync(func, { delay: 1000, immediate: true })
-      const promises = []
-      promises.push(debounced())
-      expect(func).toBeCalledTimes(1)
-      for (let i = 0; i < 10; i++) {
-        vi.advanceTimersByTime(500)
-        promises.push(debounced())
+  it('should only reject the last waiting promise', async () => {
+    expect.assertions(5)
+    let count = 0
+    const func = vi.fn(() => {
+      if (++count > 1) {
+        throw new Error('boom')
       }
-      expect(func).toBeCalledTimes(1)
-      vi.advanceTimersByTime(1000)
-      await expect(debounced()).rejects.toThrow('boom')
-      const results = await Promise.all(promises)
-      expect(results).toStrictEqual(new Array(11).fill(undefined))
-      expect(func).toBeCalledTimes(2)
+    })
+    const debounced = debounceAsync(func, { delay: 1000, immediate: true })
+    const promises = []
+    promises.push(debounced())
+    expect(func).toBeCalledTimes(1)
+    for (let i = 0; i < 10; i++) {
+      vi.advanceTimersByTime(500)
+      promises.push(debounced())
     }
-  )
+    expect(func).toBeCalledTimes(1)
+    vi.advanceTimersByTime(1000)
+    await expect(debounced()).rejects.toThrow('boom')
+    const results = await Promise.all(promises)
+    expect(results).toStrictEqual(new Array(11).fill(undefined))
+    expect(func).toBeCalledTimes(2)
+  })
 })

package/types/index.d.ts

@@ -116,23 +116,23 @@ export function clone<T>(value: T, options?: {
    *
    * @default false
    */
-  shallow?: boolean,
+  shallow?: boolean
   /**
    * Whether to clone all object properties, or only those that are defined
    * directly on that object, and are not inherited from the object's prototype.
    *
    * @default true
    */
-  enumerable?: boolean,
+  enumerable?: boolean
   /**
    * @default `true` if `options.enumerable` is true, `false` otherwise
    */
-  descriptors?: boolean,
-  transferables?: any[],
+  descriptors?: boolean
+  transferables?: any[]
   /**
    * Optional callback to process the cloned value.
    */
-  processValue?: <S>(value: T) => S,
+  processValue?: <S>(value: T) => S
 }): T
 
 /**
@@ -220,14 +220,14 @@ export function mapConcurrently<T, R>(
   input: Promise<T[]> | T[],
   callback: (value: T, index: number, array: T[]) => Promise<R> | R,
   options?: {
-    concurrency?: number;
+    concurrency?: number
   }
-): Promise<R[]>;
+): Promise<R[]>
 
 export function mapSequentially<T, R>(
   input: Promise<T[]> | T[],
   callback: (value: T, index: number) => Promise<R> | R
-): Promise<R[]>;
+): Promise<R[]>
 
 /* --------------------------------- string --------------------------------- */
 
@@ -458,8 +458,7 @@ export function debounceAsync<T extends (...args: any[]) => Promise<any>>(
 // overloaded node function types), excluding the custom promisified function
 // functionality, which toAsync does not support:
 // https://github.com/DefinitelyTyped/DefinitelyTyped/blob/fa723dee727e433add7e700420523f0f90e87a01/types/node/util.d.ts#L86
-interface CustomPromisifyLegacy<TCustom extends Function>
-  extends Function {
+interface CustomPromisifyLegacy<TCustom extends Function> extends Function {
   __promisify__: TCustom
 }
 type CustomToAsync<TCustom extends Function> = CustomPromisifyLegacy<TCustom>