decocms 2.371.3 → 2.372.1

package/dist/server/node_modules/is-what/LICENSE

@@ -1,21 +0,0 @@
-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.

package/dist/server/node_modules/is-what/README.md

@@ -1,294 +0,0 @@
-# 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
-
-// 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
-```
-
-### 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: any): 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: any): payload is { [key: string]: any }
-function isAnyObject(payload: any): payload is { [key: string]: any }
-// The reason to return `{[key: string]: any}` 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, any>`
-  // 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: any): 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/production/src/index.ts).

package/dist/server/node_modules/is-what/dist/cjs/index.cjs

@@ -1,209 +0,0 @@
-'use strict';
-
-function getType(payload) {
-  return Object.prototype.toString.call(payload).slice(8, -1);
-}
-
-function isAnyObject(payload) {
-  return getType(payload) === "Object";
-}
-
-function isArray(payload) {
-  return getType(payload) === "Array";
-}
-
-function isBlob(payload) {
-  return getType(payload) === "Blob";
-}
-
-function isBoolean(payload) {
-  return getType(payload) === "Boolean";
-}
-
-function isDate(payload) {
-  return getType(payload) === "Date" && !isNaN(payload);
-}
-
-function isEmptyArray(payload) {
-  return isArray(payload) && payload.length === 0;
-}
-
-function isPlainObject(payload) {
-  if (getType(payload) !== "Object")
-    return false;
-  const prototype = Object.getPrototypeOf(payload);
-  return !!prototype && prototype.constructor === Object && prototype === Object.prototype;
-}
-
-function isEmptyObject(payload) {
-  return isPlainObject(payload) && Object.keys(payload).length === 0;
-}
-
-function isEmptyString(payload) {
-  return payload === "";
-}
-
-function isError(payload) {
-  return getType(payload) === "Error" || payload instanceof Error;
-}
-
-function isFile(payload) {
-  return getType(payload) === "File";
-}
-
-function isFullArray(payload) {
-  return isArray(payload) && payload.length > 0;
-}
-
-function isFullObject(payload) {
-  return isPlainObject(payload) && Object.keys(payload).length > 0;
-}
-
-function isString(payload) {
-  return getType(payload) === "String";
-}
-
-function isFullString(payload) {
-  return isString(payload) && payload !== "";
-}
-
-function isFunction(payload) {
-  return typeof payload === "function";
-}
-
-function isType(payload, type) {
-  if (!(type instanceof Function)) {
-    throw new TypeError("Type must be a function");
-  }
-  if (!Object.prototype.hasOwnProperty.call(type, "prototype")) {
-    throw new TypeError("Type is not a class");
-  }
-  const name = type.name;
-  return getType(payload) === name || Boolean(payload && payload.constructor === type);
-}
-
-function isInstanceOf(value, classOrClassName) {
-  if (typeof classOrClassName === "function") {
-    for (let p = value; p; p = Object.getPrototypeOf(p)) {
-      if (isType(p, classOrClassName)) {
-        return true;
-      }
-    }
-    return false;
-  } else {
-    for (let p = value; p; p = Object.getPrototypeOf(p)) {
-      if (getType(p) === classOrClassName) {
-        return true;
-      }
-    }
-    return false;
-  }
-}
-
-function isMap(payload) {
-  return getType(payload) === "Map";
-}
-
-function isNaNValue(payload) {
-  return getType(payload) === "Number" && isNaN(payload);
-}
-
-function isNumber(payload) {
-  return getType(payload) === "Number" && !isNaN(payload);
-}
-
-function isNegativeNumber(payload) {
-  return isNumber(payload) && payload < 0;
-}
-
-function isNull(payload) {
-  return getType(payload) === "Null";
-}
-
-function isOneOf(a, b, c, d, e) {
-  return (value) => a(value) || b(value) || !!c && c(value) || !!d && d(value) || !!e && e(value);
-}
-
-function isUndefined(payload) {
-  return getType(payload) === "Undefined";
-}
-
-const isNullOrUndefined = isOneOf(isNull, isUndefined);
-
-function isObject(payload) {
-  return isPlainObject(payload);
-}
-
-function isObjectLike(payload) {
-  return isAnyObject(payload);
-}
-
-function isPositiveNumber(payload) {
-  return isNumber(payload) && payload > 0;
-}
-
-function isSymbol(payload) {
-  return getType(payload) === "Symbol";
-}
-
-function isPrimitive(payload) {
-  return isBoolean(payload) || isNull(payload) || isUndefined(payload) || isNumber(payload) || isString(payload) || isSymbol(payload);
-}
-
-function isPromise(payload) {
-  return getType(payload) === "Promise";
-}
-
-function isRegExp(payload) {
-  return getType(payload) === "RegExp";
-}
-
-function isSet(payload) {
-  return getType(payload) === "Set";
-}
-
-function isWeakMap(payload) {
-  return getType(payload) === "WeakMap";
-}
-
-function isWeakSet(payload) {
-  return getType(payload) === "WeakSet";
-}
-
-exports.getType = getType;
-exports.isAnyObject = isAnyObject;
-exports.isArray = isArray;
-exports.isBlob = isBlob;
-exports.isBoolean = isBoolean;
-exports.isDate = isDate;
-exports.isEmptyArray = isEmptyArray;
-exports.isEmptyObject = isEmptyObject;
-exports.isEmptyString = isEmptyString;
-exports.isError = isError;
-exports.isFile = isFile;
-exports.isFullArray = isFullArray;
-exports.isFullObject = isFullObject;
-exports.isFullString = isFullString;
-exports.isFunction = isFunction;
-exports.isInstanceOf = isInstanceOf;
-exports.isMap = isMap;
-exports.isNaNValue = isNaNValue;
-exports.isNegativeNumber = isNegativeNumber;
-exports.isNull = isNull;
-exports.isNullOrUndefined = isNullOrUndefined;
-exports.isNumber = isNumber;
-exports.isObject = isObject;
-exports.isObjectLike = isObjectLike;
-exports.isOneOf = isOneOf;
-exports.isPlainObject = isPlainObject;
-exports.isPositiveNumber = isPositiveNumber;
-exports.isPrimitive = isPrimitive;
-exports.isPromise = isPromise;
-exports.isRegExp = isRegExp;
-exports.isSet = isSet;
-exports.isString = isString;
-exports.isSymbol = isSymbol;
-exports.isType = isType;
-exports.isUndefined = isUndefined;
-exports.isWeakMap = isWeakMap;
-exports.isWeakSet = isWeakSet;