Criada a API do site

node_modules/is-what/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Luca Ban - Mesqueeb
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/is-what/README.md

@@ -0,0 +1,305 @@
+# is What? 🙉
+
+<a href="https://www.npmjs.com/package/is-what"><img src="https://img.shields.io/npm/v/is-what.svg" alt="Total Downloads"></a>
+<a href="https://www.npmjs.com/package/is-what"><img src="https://img.shields.io/npm/dw/is-what.svg" alt="Latest Stable Version"></a>
+
+Very simple & small JS type check functions. It's fully TypeScript supported!
+
+```
+npm i is-what
+```
+
+Or for deno available at: `"deno.land/x/is_what"`
+
+> Also check out [is-where 🙈](https://github.com/mesqueeb/is-where)
+
+## Motivation
+
+I built is-what because the existing solutions were all too complex or too poorly built.
+
+I was looking for:
+
+- A simple way to check any kind of type (including non-primitives)
+- Be able to check if an object is a plain object `{}` or a special object (like a class instance) ‼️
+- Let TypeScript automatically know what type a value is when checking
+
+And that's exactly what `is-what` is! (what a great wordplay 😃)
+
+## Usage
+
+is-what is really easy to use, and most functions work just like you'd expect.
+
+```js
+// import functions you want to use like so:
+import { isString, isDate, isPlainObject } from 'is-what'
+```
+
+1. First I'll go over the simple functions available. Only `isNumber` and `isDate` have special treatment.
+2. After that I'll talk about working with Objects (plain objects vs class instances etc.).
+3. Lastly I'll talk about TypeScript implementation
+
+### Simple type check functions
+
+```js
+// basics
+isBoolean(true) // true
+isBoolean(false) // true
+isUndefined(undefined) // true
+isNull(null) // true
+
+// strings
+isString('') // true
+isEmptyString('') // true
+isFullString('') // false
+isHexDecimal('60adf084f0fbdcab42de841e') // true
+isHexDecimal('60adf084f0fbdcab42de841e', 24) // check specific length of 24 (eg. MongoDB ObjectId)
+
+// numbers
+isNumber(0) // true
+isNumber('0') // false
+isNumber(NaN) // false *
+isPositiveNumber(1) // true
+isNegativeNumber(-1) // true
+// * see below for special NaN use cases!
+
+// arrays
+isArray([]) // true
+isEmptyArray([]) // true
+isFullArray([1]) // true
+
+// objects
+isPlainObject({}) // true *
+isEmptyObject({}) // true
+isFullObject({ a: 1 }) // true
+// * see below for special object (& class instance) use cases!
+
+// functions
+isFunction(function () {}) // true
+isFunction(() => {}) // true
+
+// dates
+isDate(new Date()) // true
+isDate(new Date('invalid date')) // false
+
+// maps & sets
+isMap(new Map()) // true
+isSet(new Set()) // true
+isWeakMap(new WeakMap()) // true
+isWeakSet(new WeakSet()) // true
+
+// others
+isRegExp(/\s/gi) // true
+isSymbol(Symbol()) // true
+isBlob(new Blob()) // true
+isFile(new File([''], '', { type: 'text/html' })) // true
+isError(new Error('')) // true
+isPromise(new Promise((resolve) => {})) // true
+
+// primitives
+isPrimitive('') // true
+//     true for any of: boolean, null, undefined, number, string, symbol
+
+// iterables
+isIterable([1, 2, 3]) // true
+isIterable('hello') // true
+isIterable(new Map()) // true
+isIterable(new Set()) // true
+isIterable(function* generator() {
+  yield 1
+}) // true
+```
+
+### Let's talk about NaN
+
+`isNaN` is a built-in JS Function but it really makes no sense:
+
+```js
+// 1)
+typeof NaN === 'number' // true
+// 🤔 ("not a number" is a "number"...)
+
+// 2)
+isNaN('1') // false
+// 🤔 the string '1' is not-"not a number"... so it's a number??
+
+// 3)
+isNaN('one') // true
+// 🤔 'one' is NaN but `NaN === 'one'` is false...
+```
+
+With is-what the way we treat NaN makes a little bit more sense:
+
+```js
+import { isNumber, isNaNValue } from 'is-what'
+
+// 1)
+isNumber(NaN) // false!
+// let's not treat NaN as a number
+
+// 2)
+isNaNValue('1') // false
+// if it's not NaN, it's not NaN!!
+
+// 3)
+isNaNValue('one') // false
+// if it's not NaN, it's not NaN!!
+
+isNaNValue(NaN) // true
+```
+
+### isPlainObject vs isAnyObject
+
+Checking for a JavaScript object can be really difficult. In JavaScript you can create classes that will behave just like JavaScript objects but might have completely different prototypes. With is-what I went for this classification:
+
+- `isPlainObject` will only return `true` on plain JavaScript objects and not on classes or others
+- `isAnyObject` will be more loose and return `true` on regular objects, classes, etc.
+
+```js
+// define a plain object
+const plainObject = { hello: 'I am a good old object.' }
+
+// define a special object
+class SpecialObject {
+  constructor(somethingSpecial) {
+    this.speciality = somethingSpecial
+  }
+}
+const specialObject = new SpecialObject('I am a special object! I am a class instance!!!')
+
+// check the plain object
+isPlainObject(plainObject) // returns true
+isAnyObject(plainObject) // returns true
+getType(plainObject) // returns 'Object'
+
+// check the special object
+isPlainObject(specialObject) // returns false !!!!!!!!!
+isAnyObject(specialObject) // returns true
+getType(specialObject) // returns 'Object'
+```
+
+> Please note that `isPlainObject` will only return `true` for normal plain JavaScript objects.
+
+### Getting and checking for specific types
+
+You can check for specific types with `getType` and `isType`:
+
+```js
+import { getType, isType } from 'is-what'
+
+getType('') // returns 'String'
+// pass a Type as second param:
+isType('', String) // returns true
+```
+
+If you just want to make sure your object _inherits_ from a particular class or
+`toStringTag` value, you can use `isInstanceOf()` like this:
+
+```js
+import { isInstanceOf } from 'is-what'
+
+isInstanceOf(new XMLHttpRequest(), 'EventTarget')
+// returns true
+isInstanceOf(globalThis, ReadableStream)
+// returns false
+```
+
+## TypeScript
+
+is-what makes TypeScript know the type during if statements. This means that a check returns the type of the payload for TypeScript users.
+
+```ts
+function isNumber(payload: unknown): payload is number {
+  // return boolean
+}
+// As you can see above, all functions return a boolean for JavaScript, but pass the payload type to TypeScript.
+
+// usage example:
+function fn(payload: string | number): number {
+  if (isNumber(payload)) {
+    // ↑ TypeScript already knows payload is a number here!
+    return payload
+  }
+  return 0
+}
+```
+
+`isPlainObject` and `isAnyObject` with TypeScript will declare the payload to be an object type with any props:
+
+```ts
+function isPlainObject(payload: unknown): payload is { [key: string]: unknown }
+function isAnyObject(payload: unknown): payload is { [key: string]: unknown }
+// The reason to return `{[key: string]: unknown}` is to be able to do
+if (isPlainObject(payload) && payload.id) return payload.id
+// if isPlainObject() would return `payload is object` then it would give an error at `payload.id`
+```
+
+### isObjectLike
+
+If you want more control over what kind of interface/type is casted when checking for objects.
+
+To cast to a specific type while checking for `isAnyObject`, can use `isObjectLike<T>`:
+
+```ts
+import { isObjectLike } from 'is-what'
+
+const payload = { name: 'Mesqueeb' } // current type: `{ name: string }`
+
+// Without casting:
+if (isAnyObject(payload)) {
+  // in here `payload` is casted to: `Record<string | number | symbol, unknown>`
+  // WE LOOSE THE TYPE!
+}
+
+// With casting:
+// you can pass a specific type for TS that will be casted when the function returns
+if (isObjectLike<{ name: string }>(payload)) {
+  // in here `payload` is casted to: `{ name: string }`
+}
+```
+
+Please note: this library will not actually check the shape of the object, you need to do that yourself.
+
+`isObjectLike<T>` works like this under the hood:
+
+```ts
+function isObjectLike<T extends object>(payload: unknown): payload is T {
+  return isAnyObject(payload)
+}
+```
+
+## Meet the family (more tiny utils with TS support)
+
+- [is-what 🙉](https://github.com/mesqueeb/is-what)
+- [is-where 🙈](https://github.com/mesqueeb/is-where)
+- [merge-anything 🥡](https://github.com/mesqueeb/merge-anything)
+- [check-anything 👁](https://github.com/mesqueeb/check-anything)
+- [remove-anything ✂️](https://github.com/mesqueeb/remove-anything)
+- [getorset-anything 🐊](https://github.com/mesqueeb/getorset-anything)
+- [map-anything 🗺](https://github.com/mesqueeb/map-anything)
+- [filter-anything ⚔️](https://github.com/mesqueeb/filter-anything)
+- [copy-anything 🎭](https://github.com/mesqueeb/copy-anything)
+- [case-anything 🐫](https://github.com/mesqueeb/case-anything)
+- [flatten-anything 🏏](https://github.com/mesqueeb/flatten-anything)
+- [nestify-anything 🧅](https://github.com/mesqueeb/nestify-anything)
+
+## Source code
+
+It's litterally just these functions:
+
+```js
+function getType(payload) {
+  return Object.prototype.toString.call(payload).slice(8, -1)
+}
+function isUndefined(payload) {
+  return getType(payload) === 'Undefined'
+}
+function isString(payload) {
+  return getType(payload) === 'String'
+}
+function isAnyObject(payload) {
+  return getType(payload) === 'Object'
+}
+// etc...
+```
+
+See the full source code [here](https://github.com/mesqueeb/is-what/blob/main/src/index.ts).

node_modules/is-what/dist/getType.d.ts

@@ -0,0 +1,2 @@
+/** Returns the object type of the given payload */
+export declare function getType(payload: unknown): string;

node_modules/is-what/dist/getType.js

@@ -0,0 +1,4 @@
+/** Returns the object type of the given payload */
+export function getType(payload) {
+    return Object.prototype.toString.call(payload).slice(8, -1);
+}

node_modules/is-what/dist/index.d.ts

@@ -0,0 +1,47 @@
+export type AnyAsyncFunction = (...args: unknown[]) => Promise<unknown>;
+export { getType } from './getType.js';
+export { isAnyObject } from './isAnyObject.js';
+export { isArray } from './isArray.js';
+export { isBigInt } from './isBigInt.js';
+export { isBlob } from './isBlob.js';
+export { isBoolean } from './isBoolean.js';
+export { isDate } from './isDate.js';
+export { isEmptyArray } from './isEmptyArray.js';
+export { isEmptyObject } from './isEmptyObject.js';
+export { isEmptyString } from './isEmptyString.js';
+export { isError } from './isError.js';
+export { isFile } from './isFile.js';
+export { isFullArray } from './isFullArray.js';
+export { isFullObject } from './isFullObject.js';
+export { isFullString } from './isFullString.js';
+export { isFunction } from './isFunction.js';
+export type { AnyFunction } from './isFunction.js';
+export { isHexDecimal } from './isHexDecimal.js';
+export { isInstanceOf } from './isInstanceOf.js';
+export { isInteger } from './isInteger.js';
+export { isIterable } from './isIterable.js';
+export { isMap } from './isMap.js';
+export { isNaNValue } from './isNaNValue.js';
+export { isNegativeInteger } from './isNegativeInteger.js';
+export { isNegativeNumber } from './isNegativeNumber.js';
+export { isNull } from './isNull.js';
+export { isNullOrUndefined } from './isNullOrUndefined.js';
+export { isNumber } from './isNumber.js';
+export { isObject } from './isObject.js';
+export { isObjectLike } from './isObjectLike.js';
+export { isOneOf } from './isOneOf.js';
+export { isPlainObject } from './isPlainObject.js';
+export type { PlainObject } from './isPlainObject.js';
+export { isPositiveInteger } from './isPositiveInteger.js';
+export { isPositiveNumber } from './isPositiveNumber.js';
+export { isPrimitive } from './isPrimitive.js';
+export { isPromise } from './isPromise.js';
+export { isRegExp } from './isRegExp.js';
+export { isSet } from './isSet.js';
+export { isString } from './isString.js';
+export { isSymbol } from './isSymbol.js';
+export { isType } from './isType.js';
+export type { AnyClass } from './isType.js';
+export { isUndefined } from './isUndefined.js';
+export { isWeakMap } from './isWeakMap.js';
+export { isWeakSet } from './isWeakSet.js';

node_modules/is-what/dist/index.js

@@ -0,0 +1,43 @@
+export { getType } from './getType.js';
+export { isAnyObject } from './isAnyObject.js';
+export { isArray } from './isArray.js';
+export { isBigInt } from './isBigInt.js';
+export { isBlob } from './isBlob.js';
+export { isBoolean } from './isBoolean.js';
+export { isDate } from './isDate.js';
+export { isEmptyArray } from './isEmptyArray.js';
+export { isEmptyObject } from './isEmptyObject.js';
+export { isEmptyString } from './isEmptyString.js';
+export { isError } from './isError.js';
+export { isFile } from './isFile.js';
+export { isFullArray } from './isFullArray.js';
+export { isFullObject } from './isFullObject.js';
+export { isFullString } from './isFullString.js';
+export { isFunction } from './isFunction.js';
+export { isHexDecimal } from './isHexDecimal.js';
+export { isInstanceOf } from './isInstanceOf.js';
+export { isInteger } from './isInteger.js';
+export { isIterable } from './isIterable.js';
+export { isMap } from './isMap.js';
+export { isNaNValue } from './isNaNValue.js';
+export { isNegativeInteger } from './isNegativeInteger.js';
+export { isNegativeNumber } from './isNegativeNumber.js';
+export { isNull } from './isNull.js';
+export { isNullOrUndefined } from './isNullOrUndefined.js';
+export { isNumber } from './isNumber.js';
+export { isObject } from './isObject.js';
+export { isObjectLike } from './isObjectLike.js';
+export { isOneOf } from './isOneOf.js';
+export { isPlainObject } from './isPlainObject.js';
+export { isPositiveInteger } from './isPositiveInteger.js';
+export { isPositiveNumber } from './isPositiveNumber.js';
+export { isPrimitive } from './isPrimitive.js';
+export { isPromise } from './isPromise.js';
+export { isRegExp } from './isRegExp.js';
+export { isSet } from './isSet.js';
+export { isString } from './isString.js';
+export { isSymbol } from './isSymbol.js';
+export { isType } from './isType.js';
+export { isUndefined } from './isUndefined.js';
+export { isWeakMap } from './isWeakMap.js';
+export { isWeakSet } from './isWeakSet.js';

node_modules/is-what/dist/isAnyObject.d.ts

@@ -0,0 +1,6 @@
+import type { PlainObject } from './isPlainObject.js';
+/**
+ * Returns whether the payload is an any kind of object (including special classes or objects with
+ * different prototypes)
+ */
+export declare function isAnyObject(payload: unknown): payload is PlainObject;

node_modules/is-what/dist/isAnyObject.js

@@ -0,0 +1,8 @@
+import { getType } from './getType.js';
+/**
+ * Returns whether the payload is an any kind of object (including special classes or objects with
+ * different prototypes)
+ */
+export function isAnyObject(payload) {
+    return getType(payload) === 'Object';
+}

node_modules/is-what/dist/isArray.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is an array */
+export declare function isArray(payload: unknown): payload is unknown[];

node_modules/is-what/dist/isArray.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is an array */
+export function isArray(payload) {
+    return getType(payload) === 'Array';
+}

node_modules/is-what/dist/isBigInt.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a bigint */
+export declare function isBigInt(payload: unknown): payload is bigint;

node_modules/is-what/dist/isBigInt.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a bigint */
+export function isBigInt(payload) {
+    return getType(payload) === 'BigInt';
+}

node_modules/is-what/dist/isBlob.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a Blob */
+export declare function isBlob(payload: unknown): payload is Blob;

node_modules/is-what/dist/isBlob.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a Blob */
+export function isBlob(payload) {
+    return getType(payload) === 'Blob';
+}

node_modules/is-what/dist/isBoolean.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a boolean */
+export declare function isBoolean(payload: unknown): payload is boolean;

node_modules/is-what/dist/isBoolean.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a boolean */
+export function isBoolean(payload) {
+    return getType(payload) === 'Boolean';
+}

node_modules/is-what/dist/isDate.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a Date, and that the date is valid */
+export declare function isDate(payload: unknown): payload is Date;

node_modules/is-what/dist/isDate.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a Date, and that the date is valid */
+export function isDate(payload) {
+    return getType(payload) === 'Date' && !Number.isNaN(payload.valueOf());
+}

node_modules/is-what/dist/isEmptyArray.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a an empty array */
+export declare function isEmptyArray(payload: unknown): payload is [];

node_modules/is-what/dist/isEmptyArray.js

@@ -0,0 +1,5 @@
+import { isArray } from './isArray.js';
+/** Returns whether the payload is a an empty array */
+export function isEmptyArray(payload) {
+    return isArray(payload) && payload.length === 0;
+}

node_modules/is-what/dist/isEmptyObject.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns whether the payload is a an empty object (excluding special classes or objects with other
+ * prototypes)
+ */
+export declare function isEmptyObject(payload: unknown): payload is {
+    [K in string | symbol | number]: never;
+};

node_modules/is-what/dist/isEmptyObject.js

@@ -0,0 +1,8 @@
+import { isPlainObject } from './isPlainObject.js';
+/**
+ * Returns whether the payload is a an empty object (excluding special classes or objects with other
+ * prototypes)
+ */
+export function isEmptyObject(payload) {
+    return isPlainObject(payload) && Object.keys(payload).length === 0;
+}

node_modules/is-what/dist/isEmptyString.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is '' */
+export declare function isEmptyString(payload: unknown): payload is string;

node_modules/is-what/dist/isEmptyString.js

@@ -0,0 +1,4 @@
+/** Returns whether the payload is '' */
+export function isEmptyString(payload) {
+    return payload === '';
+}

node_modules/is-what/dist/isError.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is an Error */
+export declare function isError(payload: unknown): payload is Error;

node_modules/is-what/dist/isError.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is an Error */
+export function isError(payload) {
+    return getType(payload) === 'Error' || payload instanceof Error;
+}

node_modules/is-what/dist/isFile.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a File */
+export declare function isFile(payload: unknown): payload is File;

node_modules/is-what/dist/isFile.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a File */
+export function isFile(payload) {
+    return getType(payload) === 'File';
+}

node_modules/is-what/dist/isFullArray.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a an array with at least 1 item */
+export declare function isFullArray(payload: unknown): payload is unknown[];

node_modules/is-what/dist/isFullArray.js

@@ -0,0 +1,5 @@
+import { isArray } from './isArray.js';
+/** Returns whether the payload is a an array with at least 1 item */
+export function isFullArray(payload) {
+    return isArray(payload) && payload.length > 0;
+}

node_modules/is-what/dist/isFullObject.d.ts

@@ -0,0 +1,6 @@
+import type { PlainObject } from './isPlainObject.js';
+/**
+ * Returns whether the payload is a an empty object (excluding special classes or objects with other
+ * prototypes)
+ */
+export declare function isFullObject(payload: unknown): payload is PlainObject;

node_modules/is-what/dist/isFullObject.js

@@ -0,0 +1,8 @@
+import { isPlainObject } from './isPlainObject.js';
+/**
+ * Returns whether the payload is a an empty object (excluding special classes or objects with other
+ * prototypes)
+ */
+export function isFullObject(payload) {
+    return isPlainObject(payload) && Object.keys(payload).length > 0;
+}

node_modules/is-what/dist/isFullString.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a string, BUT returns false for '' */
+export declare function isFullString(payload: unknown): payload is string;

node_modules/is-what/dist/isFullString.js

@@ -0,0 +1,5 @@
+import { isString } from './isString.js';
+/** Returns whether the payload is a string, BUT returns false for '' */
+export function isFullString(payload) {
+    return isString(payload) && payload !== '';
+}

node_modules/is-what/dist/isFunction.d.ts

@@ -0,0 +1,3 @@
+export type AnyFunction = (...args: any[]) => any;
+/** Returns whether the payload is a function (regular or async) */
+export declare function isFunction(payload: unknown): payload is AnyFunction;

node_modules/is-what/dist/isFunction.js

@@ -0,0 +1,4 @@
+/** Returns whether the payload is a function (regular or async) */
+export function isFunction(payload) {
+    return typeof payload === 'function';
+}

node_modules/is-what/dist/isHexDecimal.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Checks if a string is a valid hexadecimal string. If a length is provided, it also checks that
+ * the string has that length.
+ */
+export declare function isHexDecimal(payload: unknown, length?: number): payload is string;

node_modules/is-what/dist/isHexDecimal.js

@@ -0,0 +1,12 @@
+import { isString } from './isString.js';
+/**
+ * Checks if a string is a valid hexadecimal string. If a length is provided, it also checks that
+ * the string has that length.
+ */
+export function isHexDecimal(payload, length) {
+    if (!isString(payload))
+        return false;
+    if (!/^[0-9a-fA-F]+$/.test(payload))
+        return false;
+    return length === undefined || payload.length === length;
+}

node_modules/is-what/dist/isInstanceOf.d.ts

@@ -0,0 +1,23 @@
+import type { AnyClass } from './isType.js';
+type GlobalClassName = {
+    [K in keyof typeof globalThis]: (typeof globalThis)[K] extends AnyClass ? K : never;
+}[keyof typeof globalThis];
+/**
+ * Checks if a value is an instance of a class or a class name. Useful when you want to check if a
+ * value is an instance of a class that may not be defined in the current scope. For example, if you
+ * want to check if a value is an `OffscreenCanvas` instance, you might not want to do the song and
+ * dance of using `typeof OffscreenCanvas !== 'undefined'` and then shimming `OffscreenCanvas` if
+ * the types aren't around.
+ *
+ * @example
+ *   if (isInstanceOf(value, 'OffscreenCanvas')) {
+ *     // value is an OffscreenCanvas
+ *   }
+ *
+ * @param value The value to recursively check
+ * @param class_ A string or class that the value should be an instance of
+ */
+export declare function isInstanceOf<T extends AnyClass>(value: unknown, class_: T): value is T;
+export declare function isInstanceOf<K extends GlobalClassName>(value: unknown, className: K): value is (typeof globalThis)[K];
+export declare function isInstanceOf(value: unknown, className: string): value is object;
+export {};

node_modules/is-what/dist/isInstanceOf.js

@@ -0,0 +1,19 @@
+import { getType } from './getType.js';
+import { isType } from './isType.js';
+export function isInstanceOf(value, classOrClassName) {
+    if (typeof classOrClassName === 'function') {
+        for (let p = value; p; p = Object.getPrototypeOf(p)) {
+            if (isType(p, classOrClassName)) {
+                return true;
+            }
+        }
+    }
+    else {
+        for (let p = value; p; p = Object.getPrototypeOf(p)) {
+            if (getType(p) === classOrClassName) {
+                return true;
+            }
+        }
+    }
+    return false;
+}

node_modules/is-what/dist/isInteger.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is an integer number */
+export declare function isInteger(payload: unknown): payload is number;

node_modules/is-what/dist/isInteger.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is an integer number */
+export function isInteger(payload) {
+    return getType(payload) === 'Number' && Number.isInteger(payload);
+}

node_modules/is-what/dist/isIterable.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is an iterable (regular or async) */
+export declare function isIterable(payload: unknown): payload is Iterable<unknown>;

node_modules/is-what/dist/isIterable.js

@@ -0,0 +1,16 @@
+/** Returns whether the payload is an iterable (regular or async) */
+export function isIterable(payload) {
+    // oxlint-disable-next-line no-typeof-undefined
+    if (typeof Symbol === 'undefined' || typeof Symbol.iterator === 'undefined') {
+        return false;
+    }
+    // oxlint-disable-next-line no-null
+    if (payload === null || payload === undefined)
+        return false;
+    // Strings are iterable, even though they're primitives.
+    if (typeof payload === 'string')
+        return true;
+    // For objects, arrays and functions, check if Symbol.iterator is a function.
+    return ((typeof payload === 'object' || typeof payload === 'function') &&
+        typeof payload[Symbol.iterator] === 'function');
+}

node_modules/is-what/dist/isMap.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a Map */
+export declare function isMap(payload: unknown): payload is Map<unknown, unknown>;

node_modules/is-what/dist/isMap.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a Map */
+export function isMap(payload) {
+    return getType(payload) === 'Map';
+}

node_modules/is-what/dist/isNaNValue.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is literally the value `NaN` (it's `NaN` and also a `number`) */
+export declare function isNaNValue(payload: unknown): payload is typeof Number.NaN;

node_modules/is-what/dist/isNaNValue.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is literally the value `NaN` (it's `NaN` and also a `number`) */
+export function isNaNValue(payload) {
+    return getType(payload) === 'Number' && Number.isNaN(payload);
+}

node_modules/is-what/dist/isNegativeInteger.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a negative Integer (but not 0) */
+export declare function isNegativeInteger(payload: unknown): payload is number;

node_modules/is-what/dist/isNegativeInteger.js

@@ -0,0 +1,5 @@
+import { isInteger } from './isInteger.js';
+/** Returns whether the payload is a negative Integer (but not 0) */
+export function isNegativeInteger(payload) {
+    return isInteger(payload) && payload < 0;
+}

node_modules/is-what/dist/isNegativeNumber.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a negative number (but not 0) */
+export declare function isNegativeNumber(payload: unknown): payload is number;

node_modules/is-what/dist/isNegativeNumber.js

@@ -0,0 +1,5 @@
+import { isNumber } from './isNumber.js';
+/** Returns whether the payload is a negative number (but not 0) */
+export function isNegativeNumber(payload) {
+    return isNumber(payload) && payload < 0;
+}

node_modules/is-what/dist/isNull.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is null */
+export declare function isNull(payload: unknown): payload is null;

node_modules/is-what/dist/isNull.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is null */
+export function isNull(payload) {
+    return getType(payload) === 'Null';
+}

node_modules/is-what/dist/isNullOrUndefined.d.ts

@@ -0,0 +1,2 @@
+/** Returns true whether the payload is null or undefined */
+export declare const isNullOrUndefined: (payload: unknown) => payload is null | undefined;

node_modules/is-what/dist/isNullOrUndefined.js

@@ -0,0 +1,5 @@
+import { isNull } from './isNull.js';
+import { /* tree-shaking no-side-effects-when-called */ isOneOf } from './isOneOf.js';
+import { isUndefined } from './isUndefined.js';
+/** Returns true whether the payload is null or undefined */
+export const isNullOrUndefined = isOneOf(isNull, isUndefined);

node_modules/is-what/dist/isNumber.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns whether the payload is a number (but not NaN)
+ *
+ * This will return `false` for `NaN`!!
+ */
+export declare function isNumber(payload: unknown): payload is number;

node_modules/is-what/dist/isNumber.js

@@ -0,0 +1,9 @@
+import { getType } from './getType.js';
+/**
+ * Returns whether the payload is a number (but not NaN)
+ *
+ * This will return `false` for `NaN`!!
+ */
+export function isNumber(payload) {
+    return getType(payload) === 'Number' && !Number.isNaN(payload);
+}

node_modules/is-what/dist/isObject.d.ts

@@ -0,0 +1,6 @@
+import type { PlainObject } from './isPlainObject.js';
+/**
+ * Returns whether the payload is a plain JavaScript object (excluding special classes or objects
+ * with other prototypes)
+ */
+export declare function isObject(payload: unknown): payload is PlainObject;

node_modules/is-what/dist/isObject.js

@@ -0,0 +1,8 @@
+import { isPlainObject } from './isPlainObject.js';
+/**
+ * Returns whether the payload is a plain JavaScript object (excluding special classes or objects
+ * with other prototypes)
+ */
+export function isObject(payload) {
+    return isPlainObject(payload);
+}

node_modules/is-what/dist/isObjectLike.d.ts

@@ -0,0 +1,9 @@
+import type { PlainObject } from './isPlainObject.js';
+/**
+ * Returns whether the payload is an object like a type passed in < >
+ *
+ * Usage: isObjectLike<{id: any}>(payload) // will make sure it's an object and has an `id` prop.
+ *
+ * @template T This must be passed in < >
+ */
+export declare function isObjectLike<T extends PlainObject>(payload: unknown): payload is T;

node_modules/is-what/dist/isObjectLike.js

@@ -0,0 +1,11 @@
+import { isAnyObject } from './isAnyObject.js';
+/**
+ * Returns whether the payload is an object like a type passed in < >
+ *
+ * Usage: isObjectLike<{id: any}>(payload) // will make sure it's an object and has an `id` prop.
+ *
+ * @template T This must be passed in < >
+ */
+export function isObjectLike(payload) {
+    return isAnyObject(payload);
+}

node_modules/is-what/dist/isOneOf.d.ts

@@ -0,0 +1,54 @@
+type TypeGuard<A, B extends A> = (payload: A) => payload is B;
+/**
+ * A factory function that creates a function to check if the payload is one of the given types.
+ *
+ * @example
+ *   import { isOneOf, isNull, isUndefined } from 'is-what'
+ *
+ *   const isNullOrUndefined = isOneOf(isNull, isUndefined)
+ *
+ *   isNullOrUndefined(null) // true
+ *   isNullOrUndefined(undefined) // true
+ *   isNullOrUndefined(123) // false
+ */
+export declare function isOneOf<A, B extends A, C extends A>(a: TypeGuard<A, B>, b: TypeGuard<A, C>): TypeGuard<A, B | C>;
+/**
+ * A factory function that creates a function to check if the payload is one of the given types.
+ *
+ * @example
+ *   import { isOneOf, isNull, isUndefined } from 'is-what'
+ *
+ *   const isNullOrUndefined = isOneOf(isNull, isUndefined)
+ *
+ *   isNullOrUndefined(null) // true
+ *   isNullOrUndefined(undefined) // true
+ *   isNullOrUndefined(123) // false
+ */
+export declare function isOneOf<A, B extends A, C extends A, D extends A>(a: TypeGuard<A, B>, b: TypeGuard<A, C>, c: TypeGuard<A, D>): TypeGuard<A, B | C | D>;
+/**
+ * A factory function that creates a function to check if the payload is one of the given types.
+ *
+ * @example
+ *   import { isOneOf, isNull, isUndefined } from 'is-what'
+ *
+ *   const isNullOrUndefined = isOneOf(isNull, isUndefined)
+ *
+ *   isNullOrUndefined(null) // true
+ *   isNullOrUndefined(undefined) // true
+ *   isNullOrUndefined(123) // false
+ */
+export declare function isOneOf<A, B extends A, C extends A, D extends A, E extends A>(a: TypeGuard<A, B>, b: TypeGuard<A, C>, c: TypeGuard<A, D>, d: TypeGuard<A, E>): TypeGuard<A, B | C | D | E>;
+/**
+ * A factory function that creates a function to check if the payload is one of the given types.
+ *
+ * @example
+ *   import { isOneOf, isNull, isUndefined } from 'is-what'
+ *
+ *   const isNullOrUndefined = isOneOf(isNull, isUndefined)
+ *
+ *   isNullOrUndefined(null) // true
+ *   isNullOrUndefined(undefined) // true
+ *   isNullOrUndefined(123) // false
+ */
+export declare function isOneOf<A, B extends A, C extends A, D extends A, E extends A, F extends A>(a: TypeGuard<A, B>, b: TypeGuard<A, C>, c: TypeGuard<A, D>, d: TypeGuard<A, E>, e: TypeGuard<A, F>): TypeGuard<A, B | C | D | E | F>;
+export {};

node_modules/is-what/dist/isOneOf.js

@@ -0,0 +1,15 @@
+/**
+ * A factory function that creates a function to check if the payload is one of the given types.
+ *
+ * @example
+ *   import { isOneOf, isNull, isUndefined } from 'is-what'
+ *
+ *   const isNullOrUndefined = isOneOf(isNull, isUndefined)
+ *
+ *   isNullOrUndefined(null) // true
+ *   isNullOrUndefined(undefined) // true
+ *   isNullOrUndefined(123) // false
+ */
+export function isOneOf(a, b, c, d, e) {
+    return (value) => a(value) || b(value) || (!!c && c(value)) || (!!d && d(value)) || (!!e && e(value));
+}

node_modules/is-what/dist/isPlainObject.d.ts

@@ -0,0 +1,8 @@
+export type PlainObject = {
+    [key in string | number | symbol]: unknown;
+};
+/**
+ * Returns whether the payload is a plain JavaScript object (excluding special classes or objects
+ * with other prototypes)
+ */
+export declare function isPlainObject(payload: unknown): payload is PlainObject;

node_modules/is-what/dist/isPlainObject.js

@@ -0,0 +1,11 @@
+import { getType } from './getType.js';
+/**
+ * Returns whether the payload is a plain JavaScript object (excluding special classes or objects
+ * with other prototypes)
+ */
+export function isPlainObject(payload) {
+    if (getType(payload) !== 'Object')
+        return false;
+    const prototype = Object.getPrototypeOf(payload);
+    return !!prototype && prototype.constructor === Object && prototype === Object.prototype;
+}

node_modules/is-what/dist/isPositiveInteger.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a positive Integer (but not 0) */
+export declare function isPositiveInteger(payload: unknown): payload is number;

node_modules/is-what/dist/isPositiveInteger.js

@@ -0,0 +1,5 @@
+import { isInteger } from './isInteger.js';
+/** Returns whether the payload is a positive Integer (but not 0) */
+export function isPositiveInteger(payload) {
+    return isInteger(payload) && payload > 0;
+}

node_modules/is-what/dist/isPositiveNumber.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a positive number (but not 0) */
+export declare function isPositiveNumber(payload: unknown): payload is number;

node_modules/is-what/dist/isPositiveNumber.js

@@ -0,0 +1,5 @@
+import { isNumber } from './isNumber.js';
+/** Returns whether the payload is a positive number (but not 0) */
+export function isPositiveNumber(payload) {
+    return isNumber(payload) && payload > 0;
+}

node_modules/is-what/dist/isPrimitive.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns whether the payload is a primitive type (eg. Boolean | Null | Undefined | Number | String
+ *
+ * | Symbol)
+ */
+export declare function isPrimitive(payload: unknown): payload is boolean | null | undefined | number | string | symbol | bigint;

node_modules/is-what/dist/isPrimitive.js

@@ -0,0 +1,21 @@
+import { isBigInt } from './isBigInt.js';
+import { isBoolean } from './isBoolean.js';
+import { isNull } from './isNull.js';
+import { isNumber } from './isNumber.js';
+import { isString } from './isString.js';
+import { isSymbol } from './isSymbol.js';
+import { isUndefined } from './isUndefined.js';
+/**
+ * Returns whether the payload is a primitive type (eg. Boolean | Null | Undefined | Number | String
+ *
+ * | Symbol)
+ */
+export function isPrimitive(payload) {
+    return (isBoolean(payload) ||
+        isNull(payload) ||
+        isUndefined(payload) ||
+        isNumber(payload) ||
+        isString(payload) ||
+        isSymbol(payload) ||
+        isBigInt(payload));
+}

node_modules/is-what/dist/isPromise.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a Promise */
+export declare function isPromise(payload: unknown): payload is Promise<unknown>;

node_modules/is-what/dist/isPromise.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a Promise */
+export function isPromise(payload) {
+    return getType(payload) === 'Promise';
+}

node_modules/is-what/dist/isRegExp.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a regular expression (RegExp) */
+export declare function isRegExp(payload: unknown): payload is RegExp;

node_modules/is-what/dist/isRegExp.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a regular expression (RegExp) */
+export function isRegExp(payload) {
+    return getType(payload) === 'RegExp';
+}

node_modules/is-what/dist/isSet.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a Set */
+export declare function isSet(payload: unknown): payload is Set<unknown>;

node_modules/is-what/dist/isSet.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a Set */
+export function isSet(payload) {
+    return getType(payload) === 'Set';
+}

node_modules/is-what/dist/isString.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a string */
+export declare function isString(payload: unknown): payload is string;

node_modules/is-what/dist/isString.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a string */
+export function isString(payload) {
+    return getType(payload) === 'String';
+}

node_modules/is-what/dist/isSymbol.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a Symbol */
+export declare function isSymbol(payload: unknown): payload is symbol;

node_modules/is-what/dist/isSymbol.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a Symbol */
+export function isSymbol(payload) {
+    return getType(payload) === 'Symbol';
+}

node_modules/is-what/dist/isType.d.ts

@@ -0,0 +1,10 @@
+import type { AnyFunction } from './isFunction.js';
+export type AnyClass = new (...args: unknown[]) => unknown;
+/**
+ * Does a generic check to check that the given payload is of a given type. In cases like Number, it
+ * will return true for NaN as NaN is a Number (thanks javascript!); It will, however, differentiate
+ * between object and null
+ *
+ * @throws {TypeError} Will throw type error if type is an invalid type
+ */
+export declare function isType<T extends AnyFunction | AnyClass>(payload: unknown, type: T): payload is T;

node_modules/is-what/dist/isType.js

@@ -0,0 +1,20 @@
+import { getType } from './getType.js';
+import { isFunction } from './isFunction.js';
+/**
+ * Does a generic check to check that the given payload is of a given type. In cases like Number, it
+ * will return true for NaN as NaN is a Number (thanks javascript!); It will, however, differentiate
+ * between object and null
+ *
+ * @throws {TypeError} Will throw type error if type is an invalid type
+ */
+export function isType(payload, type) {
+    if (!isFunction(type)) {
+        throw new TypeError('Type must be a function');
+    }
+    if (!Object.hasOwn(type, 'prototype')) {
+        throw new TypeError('Type is not a class');
+    }
+    // Classes usually have names (as functions usually have names)
+    const { name } = type;
+    return getType(payload) === name || Boolean(payload && payload.constructor === type);
+}

node_modules/is-what/dist/isUndefined.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is undefined */
+export declare function isUndefined(payload: unknown): payload is undefined;

node_modules/is-what/dist/isUndefined.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is undefined */
+export function isUndefined(payload) {
+    return getType(payload) === 'Undefined';
+}

node_modules/is-what/dist/isWeakMap.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a WeakMap */
+export declare function isWeakMap(payload: unknown): payload is WeakMap<WeakKey, unknown>;

node_modules/is-what/dist/isWeakMap.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a WeakMap */
+export function isWeakMap(payload) {
+    return getType(payload) === 'WeakMap';
+}

node_modules/is-what/dist/isWeakSet.d.ts

@@ -0,0 +1,2 @@
+/** Returns whether the payload is a WeakSet */
+export declare function isWeakSet(payload: unknown): payload is WeakSet<WeakKey>;

node_modules/is-what/dist/isWeakSet.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a WeakSet */
+export function isWeakSet(payload) {
+    return getType(payload) === 'WeakSet';
+}

node_modules/is-what/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "is-what",
+  "version": "5.5.0",
+  "description": "JS type check (TypeScript supported) functions like `isPlainObject() isArray()` etc. A simple & small integration.",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": "./dist/index.js",
+    "./*": "./dist/*"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "lint": "tsc --noEmit && oxlint",
+    "build": "del-cli dist && tsc",
+    "build:docs": "typedoc",
+    "release": "npm run lint && npm run build && np --no-publish"
+  },
+  "devDependencies": {
+    "@cycraft/eslint": "^0.4.4",
+    "@cycraft/tsconfig": "^0.1.2",
+    "del-cli": "^7.0.0",
+    "np": "^10.2.0",
+    "oxlint": "^1.16.0",
+    "typedoc": "^0.28.13",
+    "vitest": "^3.2.4"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "javascript",
+    "typescript",
+    "typechecker",
+    "check-type",
+    "javascript-type",
+    "primitive-types",
+    "plain-object",
+    "plain-objects",
+    "class-instance",
+    "class-identifier",
+    "type-checking",
+    "type-checker",
+    "type-check",
+    "define-type",
+    "get-type",
+    "what-type",
+    "is-object",
+    "is-plain-obj",
+    "is-plain-object"
+  ],
+  "author": "Luca Ban - Mesqueeb (https://cycraft.co)",
+  "funding": "https://github.com/sponsors/mesqueeb",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mesqueeb/is-what.git"
+  },
+  "homepage": "https://github.com/mesqueeb/is-what#readme",
+  "bugs": "https://github.com/mesqueeb/is-what/issues"
+}