Data

Tools

Indexes

Applications

Experiments

Awesome

An open API service indexing awesome lists of open source software.

https://github.com/xan105/node-is

Collection of various checks for asserting types and values at runtime
https://github.com/xan105/node-is

as assert check is nodejs should types

Last synced: 2 months ago
JSON representation

Collection of various checks for asserting types and values at runtime

Awesome Lists containing this project

README 

          
About

=====



Collection of various checks for asserting types and values at runtime.



📦 Scoped `@xan105` packages are for my own personal use but feel free to use them.



Example

=======



Check Windows/Linux 64-bit/32-bit executable

```js

import { is64bit, is32bit } from "@xan105/is";

const is64 = await is64bit("path/to/executable");

const is32 = await is32bit("path/to/executable");

```



Check is PNG file

```js

import { isPNG } from "@xan105/is";

const is = await isPNG("path/to/img");

```



Check winver

```js

import * as check from "@xan105/is";

check.isWin10orGreater();

check.isWin11();

check.isWindows();

check.isWin64(); //64-bits

//etc...

```



Check Linux

```js

import * as check from "@xan105/is";

check.isDebian();

check.isDebianLike(); //Debian + derivatives (eg: Ubuntu)

check.isGnome();

check.isWayland();

```



Check type

```js

import * as check from "@xan105/is";



check.isStringNotEmpty("hello world");

check.isIntegerWithinRange(1,0,2);

check.isArrayOfString(["a","b"]);

//etc...

```



Check Object like

```js

import { isObjLike, isString, isNumber } from "@xan105/is";



const family = {

  name: "Xan",

  age: 26,

  child: {

    name: "Xanette",

    age: 15

  }

};



isObjLike(family,{

  name: isString,

  age: isNumber,

  child: {

    name: isString,

    age: isNumber

  }

});

```



### Assertion

_Perform the same check but throw an error instead._



```js

import { shouldWin10orGreater } from "@xan105/is/assert";

shouldWin10orGreater();

```



```js

import { assert } from "@xan105/is";



assert.shouldStringNotEmpty("hello world");

assert.shouldIntegerWithinRange(1,0,2, "Custom error message");

assert.shouldArrayOfString(["a","b"], new Error("custom error", { cause: err }));

//etc...

```



### Opt

_Return the given value when the condition is true otherwise null._



```js

import { asString, asInteger } from "@xan105/is/opt";



function(option = {}){

  const options = {

    param1: asString(option.param1) || "hello world",

    param2: asInteger(option.param2) ?? 0

  };

}

```



Install / Runtime

=================



### 📦 Package manager



```

npm install @xan105/is

```



Compatibility



- Node ✔️



### 🌐 CDN / HTTPS Bundle



```

import ... from "https://esm.sh/@xan105/is"

```



Please see https://esm.sh/ for more details.



API

===



⚠️ This module is only available as an ECMAScript module (ESM)



💡 `assert` and `opt` are under their respective namespace.

```js

import { assert } from "@xan105/is";

assert.shouldWin10orGreater();



import { shouldWin10orGreater } from "@xan105/is/assert";

shouldWin10orGreater();

```



## Named export



binary

  

#### `is64bit(filePath: string): Promise`



Check if it's a 64-bits (x86_64) Windows or Linux binary.



#### `is32bit(filePath: string): Promise`



Same as above but for a 32-bits (x86) Windows or Linux binary.



#### `isPNG(filePath: string): Promise`

#### `isJPG(filePath: string): Promise`

#### `isICO(filePath: string): Promise`

#### `isGIF(filePath: string): Promise`

#### `isWEBP(filePath: string): Promise`

#### `isQOI(filePath: string): Promise`

  



type: array



#### `isArray(value: unknown): boolean`

#### `isArrayNotEmpty(value: unknown): boolean`

#### `isArrayOfString(value: unknown): boolean`

#### `isSizeArrayOfString(value: unknown, length: number): boolean`

#### `isArrayOfStringNotEmpty(value: unknown): boolean`

#### `isSizeArrayOfStringNotEmpty(value: unknown, length: number): boolean`

#### `isArrayOfNumber(value: unknown): boolean`

#### `isArrayOfStringLike(value: unknown, pattern: RegExp | string): boolean`

#### `isSizeArrayOfStringLike(value: unknown, length: number, pattern: RegExp | string): boolean`

#### `isSizeArrayOfNumber(value: unknown, length: number): boolean`

#### `isArrayOfNumberWithinRange(value: unknown, min: number, max: number): boolean`

#### `isSizeArrayOfNumberWithinRange(value: unknown, length: number, min: number, max: number): boolean`

#### `isArrayOfInteger(value: unknown): boolean`

#### `isSizeArrayOfInteger(value: unknown, length: number): boolean`

#### `isArrayOfIntegerPositive(value: unknown): boolean`

#### `isSizeArrayOfIntegerPositive(value: unknown, length: number): boolean`

#### `isArrayOfIntegerPositiveOrZero(value: unknown): boolean`

#### `isSizeArrayOfIntegerPositiveOrZero(value: unknown, length: number): boolean`

#### `isArrayOfIntegerWithinRange(value: unknown, min: number, max: number): boolean`

#### `isSizeArrayOfIntegerWithinRange(value: unknown, length: number, min: number, max: number): boolean`

#### `isArrayOfObj(value: unknown): boolean`

#### `isSizeArrayOfObj(value: unknown, length: number): boolean`

#### `isArrayOfObjWithProperties(value: unknown, prop: string[]): boolean`

#### `isSizeArrayOfObjWithProperties(value: unknown, length: number, prop: string[]): boolean`

#### `isArrayOfObjLike(value: unknown, schema: object): boolean`

#### `isArrayOfSomeObjLike(value: unknown, schema: object): boolean`



Same as `isArrayOfObjLike()` but at least **one element** in the array must pass the test instead of **all**



#### `isSizeArrayOfObjLike(value: unknown, length: number, schema: object): boolean`

#### `isArrayOfUint8Array(value: unknown): boolean`



alias: `isArrayOfBuffer(value: unknown): boolean`



#### `isSizeArrayOfUint8Array(value: unknown, length: number): boolean`



alias: `isSizeArrayOfBuffer`



  



type: number

  

#### `isBigInt(value: unknown): boolean`

#### `isBigIntPositive(value: unknown): boolean`

#### `isBigIntPositiveOrZero(value: unknown): boolean`

#### `isBigIntWithinRange(value: unknown, min: bigint, max: bigint): boolean`

#### `isInteger(value: unknown): boolean`

#### `isIntegerPositive(value: unknown): boolean`

#### `isIntegerPositiveOrZero(value: unknown): boolean`

#### `isIntegerWithinRange(value: unknown, min: number, max: number): boolean`

#### `isNumber(value: unknown): boolean`

#### `isNumberWithinRange(value: unknown, min: number, max: number): boolean`

  



type: object



#### `isObj(value: unknown): boolean`



as in a "plain obj" and not a JS obj so {}, new Object() and Object.create(null).



#### `isObjNotEmpty(value: unknown): boolean`

#### `isObjWithProperties(value: unknown, prop: string[]): boolean`

#### `isObjLike(value: unknown, schema: object): boolean`



Check if an obj is like the specified schema.


Where schema is an obj containing a set of required property name and its corresponding _check_ function.


If the obj has these properties and they are validated by said corresponding function then this will return true otherwise false. 



Example:



```js

const family = {

  name: "Xan",

  age: 26,

  child: {

    name: "Xanette",

    age: 15,

    height: 164,

    weight: 42

  }

};



isObjLike(family,{

  name: isString,

  age: isNumber,

  child: {

    name: isStringNotEmpty,

    age: [ isIntegerWithinRange, [0,100] ],

    height: isNumber,

    weight: [ isNumber, [] ]

  }

});

```



The check funtion should only return a **boolean**.


**Otherwise** or if the function throws then **false** will be assumed.


_NB: Function that use [@xan105/error](https://github.com/xan105/node-error) will bypass this and still throw (this is by design)._



The check funtion should be defined as follow: `something: [function, [args,...] ]`


If you don't have any args then an empty array: `something: [function, [] ]`


Or you can pass the function as is (shortcut): `something: function`


Note that `something: [function]` is invalid !



💡 You can flag a property to be _optional_ by using `{optional: true}`.


If the property is missing it will be skipped.


eg: `something: [function, [], {optional: true}]`



#### `isObjWithinObj(value: unknown): boolean`



Plain object assigned as property within another:



```js

{

  foo: {

    bar: "foo"

  },

  bar: {

    foo: "bar"

  }

}

```

  



type: string

  

#### `isString(value: unknown): boolean`

#### `isStringNotEmpty(value: unknown): boolean`

#### `isStringLike(value: unknown, pattern: RegExp | string): boolean`



If pattern is a string, this function will look for a corresponding known regex pattern.



As of this writing, these are:



  - `hex`: Hexadecimal

  - `SRI`: [Subresource Integrity](https://developer.mozilla.org/en-US/docs/Web/Security/Subresource_Integrity)



#### `isHexString(value: unknown): boolean`

  



type: other

  

#### `isBoolean(value: unknown): boolean`  

#### `isUint8Array(value: unknown): boolean`



alias: `isBuffer(value: unknown): boolean`



#### `isError(value: unknown): boolean`

#### `isRegExp(value: unknown): boolean`

#### `isPromise(value: unknown): boolean`

#### `isFunction(value: unknown): boolean`

  



os: Windows



#### `isWindows(): boolean`

#### `isWindowsX86(): boolean`



alias: `isWin32(): boolean`



#### `isWindowsX64(): boolean`



alias: `isWin64(): boolean`



#### `isWin11orGreater(): boolean`

#### `isWin10orGreater(): boolean`

#### `isWin8orGreater(): boolean`

#### `isWin7orGreater(): boolean`

#### `isWin11orLesser(): boolean`

#### `isWin10orLesser(): boolean`

#### `isWin8orLesser(): boolean`

#### `isWin7orLesser(): boolean`

#### `isWin11(): boolean`

#### `isWin10(): boolean`

#### `isWin8(): boolean`

#### `isWin7(): boolean`

  



  

os: Linux

  

#### `isLinux(): boolean`

#### `isArch(): Promise`

#### `isArchLike(): Promise`

#### `isManjaro(): Promise`

#### `isDebian(): Promise`

#### `isDebianLike(): Promise`

#### `isUbuntu(): Promise`

#### `isUbuntuLike(): Promise`

#### `isMint(): Promise`

#### `isPopOS(): Promise`

#### `isElementaryOS(): Promise`

#### `isDeepin(): Promise`

#### `isRaspberryPiOS(): Promise`



alias: `isRaspbian(): Promise`



#### `isFedora(): Promise`

#### `isFedoraLike(): Promise`

#### `isOpenSUSE(): Promise`

#### `isSlackware(): Promise`

#### `isGentoo(): Promise`



#### `isGnome(): boolean`

#### `isKDE(): boolean`

#### `isXFCE(): boolean`

#### `isMate(): boolean`

#### `isCinnamon(): boolean`



#### `isWayland(): boolean`

  



misc

  

#### `isIP(value: string): boolean`

#### `isIPv4(value: string): boolean`

#### `isIPv6(value: string): boolean`

#### `isDeno(): boolean`

#### `isNode(): boolean`

#### `isBrowser(): boolean`

  



  

### assert



_Perform the same checks as above but throw an error instead._


_This replace the cumbersome and often repetitive "if(unexpected) throw Error" pattern_.



💡 Every assertion has an optional `error` parameter to override the default Error.


You can either use

  

- an instance of/inherit from the `Error` class 

- or a string to just change the default message.



eg: 

  

```js

assert.shouldIntegerWithinRange(1,0,2, "Custom error message");

assert.shouldArrayOfString(["a","b"], new Error("custom error", { cause: err }));

```

  

binary

  

#### `should64bit (filePath: string, error?: Error | string): Promise`

#### `should32bit (filePath: string, error?: Error | string): Promise`

#### `shouldPNG(filePath: string, error?: Error | string): Promise`

#### `shouldJPG(filePath: string, error?: Error | string): Promise`

#### `shouldICO(filePath: string, error?: Error | string): Promise`

#### `shouldGIF(filePath: string, error?: Error | string): Promise`

#### `shouldWEBP(filePath: string, error?: Error | string): Promise`

#### `shouldQOI(filePath: string, error?: Error | string): Promise`

  



type: array

  

#### `shouldArray(value: unknown, error?: Error | string): void`

#### `shouldArrayNotEmpty(value: unknown, error?: Error | string): void`

#### `shouldArrayOfString(value: unknown, error?: Error | string): void`

#### `shouldSizeArrayOfString(value: unknown, length: number, error?: Error | string): void`

#### `shouldArrayOfStringNotEmpty(value: unknown, error?: Error | string): void`

#### `shouldSizeArrayOfStringNotEmpty(value: unknown, length: number, error?: Error | string): void`

#### `shouldArrayOfStringLike(value: unknown, pattern: RegExp | string, error?: Error | string | null): void`

#### `shouldSizeArrayOfStringLike(value: unknown, length: number, pattern: RegExp | string, error?: Error | string | null): void`

#### `shouldArrayOfNumber(value: unknown, error?: Error | string): void`

#### `shouldSizeArrayOfNumber(value: unknown, length: number, error?: Error | string): void`

#### `shouldArrayOfNumberWithinRange(value: unknown, min: number, max: number, error?: Error | string): void`

#### `shouldSizeArrayOfNumberWithinRange(value: unknown, length: number, min: number, max: number, error?: Error | string): void`

#### `shouldArrayOfInteger(value: unknown, error?: Error | string): void`

#### `shouldSizeArrayOfInteger(value: unknown, length: number, error?: Error | string): void`

#### `shouldArrayOfIntegerPositive(value: unknown, error?: Error | string): void`

#### `shouldSizeArrayOfIntegerPositive(value: unknown, length: number, error?: Error | string): void`

#### `shouldArrayOfIntegerPositiveOrZero(value: unknown, error?: Error | string): void`

#### `shouldSizeArrayOfIntegerPositiveOrZero(value: unknown, length: number, error?: Error | string): void`

#### `shouldArrayOfIntegerWithinRange(value: unknown, min: number, max: number, error?: Error | string): void`

#### `shouldSizeArrayOfIntegerWithinRange(value: unknown, length: number, min: number, max: number, error?: Error | string): void`

#### `shouldArrayOfObj(value: unknown, error?: Error | string): void`

#### `shouldSizeArrayOfObj(value: unknown, length: number, error?: Error | string): void`

#### `shouldArrayOfObjWithProperties(value: unknown, prop: string[], error?: Error | string): void`

#### `shouldSizeArrayOfObjWithProperties(value: unknown, length: number, prop: string[], error?: Error | string): void`

#### `shouldArrayOfObjLike(value: unknown, schema: object, error?: Error | string): void`

#### `shouldArrayOfSomeObjLike(value: unknown, schema: object, error?: Error | string): void`

#### `shouldSizeArrayOfObjLike(value: unknown, length: number, schema: object, error?: Error | string): void`



#### `shouldArrayOfUint8Array(value: unknown, error?: Error | string): void`



alias: `shouldArrayOfBuffer(value: unknown, error?: Error | string): void`



#### `shouldSizeArrayOfUint8Array(value: unknown, length: number, error?: Error | string): void`



alias: `shouldSizeArrayOfBuffer(value: unknown, length: number, error?: Error | string): void`

  



 

type: number



#### `shouldBigInt(value: unknown, error?: Error | string): void`

#### `shouldBigIntPositive(value: unknown, error?: Error | string): void`

#### `shouldBigIntPositiveOrZero(value: unknown, error?: Error | string): void`

#### `shouldBigIntWithinRange(value: unknown, min: bigint, max: bigint, error?: Error | string): void`

#### `shouldInteger(value: unknown, error?: Error | string): void`

#### `shouldIntegerPositive(value: unknown, error?: Error | string): void`

#### `shouldIntegerPositiveOrZero(value: unknown, error?: Error | string): void`

#### `shouldIntegerWithinRange(value: unknown, min: number, max: number, error?: Error | string): void`

#### `shouldNumber(value: unknown, error?: Error | string): void`

#### `shouldNumberWithinRange(value: unknown, min: number, max: number, error?: Error | string): void`

  



type: object



#### `shouldObj(value: unknown, error?: Error | string): void`

#### `shouldObjNotEmpty(value: unknown, error?: Error | string): void`

#### `shouldObjWithProperties(value: unknown, prop: string[], error?: Error | string): void`

#### `shouldObjLike(value: unknown, schema: object, error?: Error | string): void`

#### `shouldObjWithinObj(value: unknown, error?: Error | string | null): void`

  



type: string



#### `shouldString(value: unknown, error?: Error | string): void`

#### `shouldStringNotEmpty(value: unknown, error?: Error | string): void`

#### `shouldStringLike(value: unknown, pattern: RegExp | string, error?: Error | string | null): void`

#### `shouldHexString(value: unknown, error?: Error | string): void`

  



type: other

  

#### `shouldBoolean(value: unknown, error?: Error | string): void`

#### `shouldUint8Array(value: unknown, error?: Error | string): void`



alias: #### `shouldBuffer(value: unknown, error?: Error | string): void`



#### `shouldError(value: unknown, error?: Error | string): void`

#### `shouldRegExp(value: unknown, error?: Error | string): void`

#### `shouldPromise(value: unknown, error?: Error | string | null): void`

#### `shouldFunction(value: unknown, error?: Error | string | null): void`

  



os: Windows

  

#### `shouldWindows(error?: Error | string): void`

#### `shouldWindowsX86(error?: Error | string): void`



alias: `shouldWin32(error?: Error | string): void`



#### `shouldWindowsX64(error?: Error | string): void`



alias: `shouldWin64(error?: Error | string): void`



#### `shouldWin11orGreater(error?: Error | string): void`

#### `shouldWin10orGreater(error?: Error | string): void`

#### `shouldWin8orGreater(error?: Error | string): void`

#### `shouldWin7orGreater(error?: Error | string): void`

#### `shouldWin11orLesser(error?: Error | string): void`

#### `shouldWin10orLesser(error?: Error | string): void`

#### `shouldWin8orLesser(error?: Error | string): void`

#### `shouldWin7orLesser(error?: Error | string): void`

#### `shouldWin11(error?: Error | string): void`

#### `shouldWin10(error?: Error | string): void`

#### `shouldWin8(error?: Error | string): void`

#### `shouldWin7(error?: Error | string): void`

  



os: Linux



#### `shouldLinux(error?: Error | string): void`

#### `shouldArch(error?: Error | string): Promise`

#### `shouldArchLike(error?: Error | string): Promise`

#### `shouldManjaro(error?: Error | string): Promise`

#### `shouldDebian(error?: Error | string): Promise`

#### `shouldDebianLike(error?: Error | string): Promise`

#### `shouldUbuntu(error?: Error | string): Promise`

#### `shouldUbuntuLike(error?: Error | string): Promise`

#### `shouldMint(error?: Error | string): Promise`

#### `shouldPopOS(error?: Error | string): Promise`

#### `shouldElementaryOS(error?: Error | string): Promise`

#### `shouldDeepin(error?: Error | string): Promise`

#### `shouldRaspberryPiOS(error?: Error | string): Promise`



alias: `shouldRaspbian(error?: Error | string): Promise`



#### `shouldFedora(error?: Error | string): Promise`

#### `shouldFedoraLike(error?: Error | string): Promise`

#### `shouldOpenSUSE(error?: Error | string): Promise`

#### `shouldSlackware(error?: Error | string): Promise`

#### `shouldGentoo(error?: Error | string): Promise`



#### `shouldGnome(error?: Error | string): void`

#### `shouldKDE(error?: Error | string): void`

#### `shouldXFCE(error?: Error | string): void`

#### `shouldMate(error?: Error | string): void`

#### `shouldCinnamon(error?: Error | string): void`



#### `shouldWayland(error?: Error | string): void`

  



  

misc



#### `shouldIP(value: string, error?: Error | string): void`

#### `shouldIPv4(value: string, error?: Error | string): void`

#### `shouldIPv6(value: string, error?: Error | string): void`

#### `shouldDeno(error?: Error | string): boolean`

#### `shouldNode(error?: Error | string): boolean`

#### `shouldBrowser(error?: Error | string): boolean`

  



  

### opt



_Return the given value when the condition is true otherwise null._


_Works great with operator such as `||` and `??`_



eg:

```js

function(option = {}){

  const options = {

    param1: asString(option.param1) || "hello world",

    param2: asInteger(option.param2) ?? 0

  };

}

```

  

type: array

  

#### `asArray(value: unknown): [] | null`

#### `asArrayNotEmpty(value: unknown): [] | null`

#### `asArrayOfString(value: unknown): string[] | null`

#### `asSizeArrayOfString(value: unknown, length: number): string[] | null`

#### `asArrayOfStringNotEmpty(value: unknown): string[] | null`

#### `asSizeArrayOfStringNotEmpty(value: unknown, length: number): string[] | null`

#### `asArrayOfStringLike(value: unknown, pattern: RegExp | string): string[] | null;

#### `asSizeArrayOfStringLike(value: unknown, length: number, pattern: RegExp | string): string[] | null;

#### `asArrayOfNumber(value: unknown): number[] | null`

#### `asSizeArrayOfNumber(value: unknown, length: number): number[] | null`

#### `asArrayOfNumberWithinRange(value: unknown, min: number, max: number): number[] | null`

#### `asSizeArrayOfNumberWithinRange(value: unknown, length: number, min: number, max: number): number[] | null`

#### `asArrayOfInteger(value: unknown): number[] | null`

#### `asSizeArrayOfInteger(value: unknown, length: number): number[] | null`

#### `asArrayOfIntegerPositive(value: unknown): number[] | null`

#### `asSizeArrayOfIntegerPositive(value: unknown, length: number): number[] | null`

#### `asArrayOfIntegerPositiveOrZero(value: unknown): number[] | null`

#### `asSizeArrayOfIntegerPositiveOrZero(value: unknown, length: number): number[] | null`

#### `asArrayOfIntegerWithinRange(value: unknown, min: number, max: number): number[] | null`

#### `asSizeArrayOfIntegerWithinRange(value: unknown, length: number, min: number, max: number): number[] | null`

#### `asArrayOfObj(value: unknown): object[] | null`

#### `asSizeArrayOfObj(value: unknown, length: number): object[] | null`

#### `asArrayOfObjWithProperties(value: unknown, prop: string[]): object[] | null`

#### `asSizeArrayOfObjWithProperties(value: unknown, length: number, prop: string[]): object[] | null`

#### `asArrayOfObjLike(value: unknown, schema: object): object[] | null`

#### `asArrayOfSomeObjLike(value: unknown, schema: object): object[] | null`



This will return every element matching the given schema.


Unlike `asArrayOfObjLike` which return the array only if all elements pass the test.



#### `asSizeArrayOfObjLike(value: unknown, length: number, schema: object): object[] | null`

#### `asArrayOfUint8Array(value: unknown): Uint8Array[] | Buffer[] | null`



alias: `asArrayOfBuffer(value: unknown): Uint8Array[] | Buffer[] | null`



#### `asSizeArrayOfUint8Array(value: unknown, length: number): Uint8Array[] | Buffer[] | null`



alias: `asSizeArrayOfBuffer(value: unknown, length: number): Uint8Array[] | Buffer[] | null`

  



type: number

  

#### `asBigInt(value: unknown): bigint | null`

#### `asBigIntPositive(value: unknown): bigint | null`

#### `asBigIntPositiveOrZero(value: unknown): bigint | null`

#### `asBigIntWithinRange(value: unknown, min: bigint, max: bigint): bigint | null`

#### `asInteger(value: unknown): number | null`

#### `asIntegerPositive(value: unknown): number | null`

#### `asIntegerPositiveOrZero(value: unknown): number | null`

#### `asIntegerWithinRange(value: unknown, min: number, max: number): number | null`

#### `asNumber(value: unknown): number | null`

#### `asNumberWithinRange(value: unknown, min: number, max: number): number | null`

  



  

type: object

  

#### `asObj(value: unknown): object | null`

#### `asObjNotEmpty(value: unknown): object | null`

#### `asObjWithProperties(value: unknown, prop: string[]): object | null`

#### `asObjLike(value: unknown, schema: object): object | null`

#### `asObjWithinObj(value: unknown): object | null`

  



type: string

  

#### `asString(value: unknown): string | null`

#### `asStringNotEmpty(value: unknown): string | null`

#### `asStringLike(value: unknown, pattern: RegExp | string): string | null`

#### `asHexString(value: unknown): string | null`

  



  

type: other



#### `asBoolean(value: unknown): boolean | null`

#### `asUint8Array(value: unknown): Uint8Array | Buffer | null`



alias: `asBuffer(value: unknown): Uint8Array | Buffer | null`



#### `asError(value: unknown): Error | null`

#### `asRegExp(value: unknown): RegExp | null`

#### `asPromise(value: unknown): Promise | null`

#### `asFunction(value: unknown): any`