JasTobi/WeihnachtsKalenderMelly
3
0
Fork 0
Code Issues 3 Pull Requests Releases 4 Activity

Galerie und tage

Browse Source
This commit is contained in:
Jason
2021-11-23 17:56:26 +01:00
parent ff35366279
commit 5f873bee89
4693 changed files with 149659 additions and 301447 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
node_modules/@sindresorhus/is/dist/example.d.ts generated vendored
View File

3
node_modules/@sindresorhus/is/dist/example.js generated vendored
View File

@@ -1,3 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
//# sourceMappingURL=example.js.map

1
node_modules/@sindresorhus/is/dist/example.js.map generated vendored
View File

@@ -1 +0,0 @@
{"version":3,"file":"example.js","sourceRoot":"","sources":["../example.ts"],"names":[],"mappings":""}

95
node_modules/@sindresorhus/is/dist/index.d.ts generated vendored
View File

@@ -1,95 +0,0 @@
/// <reference types="node" />
export declare const enum TypeName {
null = "null",
boolean = "boolean",
undefined = "undefined",
string = "string",
number = "number",
symbol = "symbol",
Function = "Function",
Array = "Array",
Buffer = "Buffer",
Object = "Object",
RegExp = "RegExp",
Date = "Date",
Error = "Error",
Map = "Map",
Set = "Set",
WeakMap = "WeakMap",
WeakSet = "WeakSet",
Int8Array = "Int8Array",
Uint8Array = "Uint8Array",
Uint8ClampedArray = "Uint8ClampedArray",
Int16Array = "Int16Array",
Uint16Array = "Uint16Array",
Int32Array = "Int32Array",
Uint32Array = "Uint32Array",
Float32Array = "Float32Array",
Float64Array = "Float64Array",
ArrayBuffer = "ArrayBuffer",
SharedArrayBuffer = "SharedArrayBuffer",
DataView = "DataView",
Promise = "Promise",
}
declare function is(value: any): TypeName;
declare namespace is {
const undefined: (value: any) => boolean;
const string: (value: any) => boolean;
const number: (value: any) => boolean;
const function_: (value: any) => boolean;
const null_: (value: any) => boolean;
const class_: (value: any) => any;
const boolean: (value: any) => boolean;
const symbol: (value: any) => boolean;
const array: (arg: any) => arg is any[];
const buffer: (obj: any) => obj is Buffer;
const nullOrUndefined: (value: any) => boolean;
const object: (value: any) => boolean;
const iterable: (value: any) => boolean;
const generator: (value: any) => boolean;
const nativePromise: (value: any) => boolean;
const promise: (value: any) => boolean;
const generatorFunction: (value: any) => boolean;
const asyncFunction: (value: any) => boolean;
const boundFunction: (value: any) => boolean;
const regExp: (value: any) => boolean;
const date: (value: any) => boolean;
const error: (value: any) => boolean;
const map: (value: any) => boolean;
const set: (value: any) => boolean;
const weakMap: (value: any) => boolean;
const weakSet: (value: any) => boolean;
const int8Array: (value: any) => boolean;
const uint8Array: (value: any) => boolean;
const uint8ClampedArray: (value: any) => boolean;
const int16Array: (value: any) => boolean;
const uint16Array: (value: any) => boolean;
const int32Array: (value: any) => boolean;
const uint32Array: (value: any) => boolean;
const float32Array: (value: any) => boolean;
const float64Array: (value: any) => boolean;
const arrayBuffer: (value: any) => boolean;
const sharedArrayBuffer: (value: any) => boolean;
const dataView: (value: any) => boolean;
const directInstanceOf: (instance: any, klass: any) => boolean;
const truthy: (value: any) => boolean;
const falsy: (value: any) => boolean;
const nan: (value: any) => boolean;
const primitive: (value: any) => boolean;
const integer: (value: any) => boolean;
const safeInteger: (value: any) => boolean;
const plainObject: (value: any) => boolean;
const typedArray: (value: any) => boolean;
const arrayLike: (value: any) => boolean;
const inRange: (value: number, range: number | number[]) => boolean;
const domElement: (value: any) => boolean;
const nodeStream: (value: any) => boolean;
const infinite: (value: any) => boolean;
const even: (rem: number) => boolean;
const odd: (rem: number) => boolean;
const empty: (value: any) => boolean;
const emptyOrWhitespace: (value: any) => boolean;
function any(...predicate: any[]): any;
function all(...predicate: any[]): any;
}
export default is;

215
node_modules/@sindresorhus/is/dist/index.js generated vendored
View File

@@ -1,215 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const util = require("util");
const toString = Object.prototype.toString;
const isOfType = (type) => (value) => typeof value === type; // tslint:disable-line:strict-type-predicates
const getObjectType = (value) => {
const objectName = toString.call(value).slice(8, -1);
if (objectName) {
return objectName;
}
return null;
};
const isObjectOfType = (typeName) => (value) => {
return getObjectType(value) === typeName;
};
function is(value) {
if (value === null) {
return "null" /* null */;
}
if (value === true || value === false) {
return "boolean" /* boolean */;
}
const type = typeof value;
if (type === 'undefined') {
return "undefined" /* undefined */;
}
if (type === 'string') {
return "string" /* string */;
}
if (type === 'number') {
return "number" /* number */;
}
if (type === 'symbol') {
return "symbol" /* symbol */;
}
if (is.function_(value)) {
return "Function" /* Function */;
}
if (Array.isArray(value)) {
return "Array" /* Array */;
}
if (Buffer.isBuffer(value)) {
return "Buffer" /* Buffer */;
}
const tagType = getObjectType(value);
if (tagType) {
return tagType;
}
if (value instanceof String || value instanceof Boolean || value instanceof Number) {
throw new TypeError('Please don\'t use object wrappers for primitive types');
}
return "Object" /* Object */;
}
(function (is) {
const isObject = (value) => typeof value === 'object';
// tslint:disable:variable-name
is.undefined = isOfType('undefined');
is.string = isOfType('string');
is.number = isOfType('number');
is.function_ = isOfType('function');
is.null_ = (value) => value === null;
is.class_ = (value) => is.function_(value) && value.toString().startsWith('class ');
is.boolean = (value) => value === true || value === false;
// tslint:enable:variable-name
is.symbol = isOfType('symbol');
is.array = Array.isArray;
is.buffer = Buffer.isBuffer;
is.nullOrUndefined = (value) => is.null_(value) || is.undefined(value);
is.object = (value) => !is.nullOrUndefined(value) && (is.function_(value) || isObject(value));
is.iterable = (value) => !is.nullOrUndefined(value) && is.function_(value[Symbol.iterator]);
is.generator = (value) => is.iterable(value) && is.function_(value.next) && is.function_(value.throw);
is.nativePromise = isObjectOfType("Promise" /* Promise */);
const hasPromiseAPI = (value) => !is.null_(value) &&
isObject(value) &&
is.function_(value.then) &&
is.function_(value.catch);
is.promise = (value) => is.nativePromise(value) || hasPromiseAPI(value);
// TODO: Change to use `isObjectOfType` once Node.js 6 or higher is targeted
const isFunctionOfType = (type) => (value) => is.function_(value) && is.function_(value.constructor) && value.constructor.name === type;
is.generatorFunction = isFunctionOfType('GeneratorFunction');
is.asyncFunction = isFunctionOfType('AsyncFunction');
is.boundFunction = (value) => is.function_(value) && !value.hasOwnProperty('prototype');
is.regExp = isObjectOfType("RegExp" /* RegExp */);
is.date = isObjectOfType("Date" /* Date */);
is.error = isObjectOfType("Error" /* Error */);
is.map = isObjectOfType("Map" /* Map */);
is.set = isObjectOfType("Set" /* Set */);
is.weakMap = isObjectOfType("WeakMap" /* WeakMap */);
is.weakSet = isObjectOfType("WeakSet" /* WeakSet */);
is.int8Array = isObjectOfType("Int8Array" /* Int8Array */);
is.uint8Array = isObjectOfType("Uint8Array" /* Uint8Array */);
is.uint8ClampedArray = isObjectOfType("Uint8ClampedArray" /* Uint8ClampedArray */);
is.int16Array = isObjectOfType("Int16Array" /* Int16Array */);
is.uint16Array = isObjectOfType("Uint16Array" /* Uint16Array */);
is.int32Array = isObjectOfType("Int32Array" /* Int32Array */);
is.uint32Array = isObjectOfType("Uint32Array" /* Uint32Array */);
is.float32Array = isObjectOfType("Float32Array" /* Float32Array */);
is.float64Array = isObjectOfType("Float64Array" /* Float64Array */);
is.arrayBuffer = isObjectOfType("ArrayBuffer" /* ArrayBuffer */);
is.sharedArrayBuffer = isObjectOfType("SharedArrayBuffer" /* SharedArrayBuffer */);
is.dataView = isObjectOfType("DataView" /* DataView */);
// TODO: Remove `object` checks when targeting ES2015 or higher
// See `Notes`: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getPrototypeOf
is.directInstanceOf = (instance, klass) => is.object(instance) && is.object(klass) && Object.getPrototypeOf(instance) === klass.prototype;
is.truthy = (value) => Boolean(value);
is.falsy = (value) => !value;
is.nan = (value) => Number.isNaN(value);
const primitiveTypes = new Set([
'undefined',
'string',
'number',
'boolean',
'symbol'
]);
is.primitive = (value) => is.null_(value) || primitiveTypes.has(typeof value);
is.integer = (value) => Number.isInteger(value);
is.safeInteger = (value) => Number.isSafeInteger(value);
is.plainObject = (value) => {
// From: https://github.com/sindresorhus/is-plain-obj/blob/master/index.js
let prototype;
return getObjectType(value) === "Object" /* Object */ &&
(prototype = Object.getPrototypeOf(value), prototype === null || // tslint:disable-line:ban-comma-operator
prototype === Object.getPrototypeOf({}));
};
const typedArrayTypes = new Set([
"Int8Array" /* Int8Array */,
"Uint8Array" /* Uint8Array */,
"Uint8ClampedArray" /* Uint8ClampedArray */,
"Int16Array" /* Int16Array */,
"Uint16Array" /* Uint16Array */,
"Int32Array" /* Int32Array */,
"Uint32Array" /* Uint32Array */,
"Float32Array" /* Float32Array */,
"Float64Array" /* Float64Array */
]);
is.typedArray = (value) => {
const objectType = getObjectType(value);
if (objectType === null) {
return false;
}
return typedArrayTypes.has(objectType);
};
const isValidLength = (value) => is.safeInteger(value) && value > -1;
is.arrayLike = (value) => !is.nullOrUndefined(value) && !is.function_(value) && isValidLength(value.length);
is.inRange = (value, range) => {
if (is.number(range)) {
return value >= Math.min(0, range) && value <= Math.max(range, 0);
}
if (is.array(range) && range.length === 2) {
// TODO: Use spread operator here when targeting Node.js 6 or higher
return value >= Math.min.apply(null, range) && value <= Math.max.apply(null, range);
}
throw new TypeError(`Invalid range: ${util.inspect(range)}`);
};
const NODE_TYPE_ELEMENT = 1;
const DOM_PROPERTIES_TO_CHECK = [
'innerHTML',
'ownerDocument',
'style',
'attributes',
'nodeValue'
];
is.domElement = (value) => is.object(value) && value.nodeType === NODE_TYPE_ELEMENT && is.string(value.nodeName) &&
!is.plainObject(value) && DOM_PROPERTIES_TO_CHECK.every(property => property in value);
is.nodeStream = (value) => !is.nullOrUndefined(value) && isObject(value) && is.function_(value.pipe);
is.infinite = (value) => value === Infinity || value === -Infinity;
const isAbsoluteMod2 = (value) => (rem) => is.integer(rem) && Math.abs(rem % 2) === value;
is.even = isAbsoluteMod2(0);
is.odd = isAbsoluteMod2(1);
const isWhiteSpaceString = (value) => is.string(value) && /\S/.test(value) === false;
const isEmptyStringOrArray = (value) => (is.string(value) || is.array(value)) && value.length === 0;
const isEmptyObject = (value) => !is.map(value) && !is.set(value) && is.object(value) && Object.keys(value).length === 0;
const isEmptyMapOrSet = (value) => (is.map(value) || is.set(value)) && value.size === 0;
is.empty = (value) => is.falsy(value) || isEmptyStringOrArray(value) || isEmptyObject(value) || isEmptyMapOrSet(value);
is.emptyOrWhitespace = (value) => is.empty(value) || isWhiteSpaceString(value);
const predicateOnArray = (method, predicate, args) => {
// `args` is the calling function's "arguments object".
// We have to do it this way to keep node v4 support.
// So here we convert it to an array and slice off the first item.
const values = Array.prototype.slice.call(args, 1);
if (is.function_(predicate) === false) {
throw new TypeError(`Invalid predicate: ${util.inspect(predicate)}`);
}
if (values.length === 0) {
throw new TypeError('Invalid number of values');
}
return method.call(values, predicate);
};
function any(predicate) {
return predicateOnArray(Array.prototype.some, predicate, arguments);
}
is.any = any;
function all(predicate) {
return predicateOnArray(Array.prototype.every, predicate, arguments);
}
is.all = all;
// tslint:enable:only-arrow-functions no-function-expression
})(is || (is = {}));
// Some few keywords are reserved, but we'll populate them for Node.js users
// See https://github.com/Microsoft/TypeScript/issues/2536
Object.defineProperties(is, {
class: {
value: is.class_
},
function: {
value: is.function_
},
null: {
value: is.null_
}
});
exports.default = is;
// For CommonJS default export support
module.exports = is;
module.exports.default = is;

1
node_modules/@sindresorhus/is/dist/index.js.map generated vendored
View File

File diff suppressed because one or more lines are too long

59
node_modules/@sindresorhus/is/dist/source/index.d.ts generated vendored
View File

@@ -1,59 +0,0 @@
/// <reference types="node" />
declare function is(value: any): string;
declare namespace is {
const undefined: (value: any) => boolean;
const string: (value: any) => boolean;
const number: (value: any) => boolean;
const function_: (value: any) => boolean;
const null_: (value: any) => boolean;
const class_: (value: any) => any;
const boolean: (value: any) => boolean;
const symbol: (value: any) => boolean;
const array: (arg: any) => arg is any[];
const buffer: (obj: any) => obj is Buffer;
const nullOrUndefined: (value: any) => boolean;
const object: (value: any) => boolean;
const iterable: (value: any) => boolean;
const generator: (value: any) => boolean;
const nativePromise: (value: any) => boolean;
const promise: (value: any) => boolean;
const generatorFunction: (value: any) => boolean;
const asyncFunction: (value: any) => boolean;
const regExp: (value: any) => boolean;
const date: (value: any) => boolean;
const error: (value: any) => boolean;
const map: (value: any) => boolean;
const set: (value: any) => boolean;
const weakMap: (value: any) => boolean;
const weakSet: (value: any) => boolean;
const int8Array: (value: any) => boolean;
const uint8Array: (value: any) => boolean;
const uint8ClampedArray: (value: any) => boolean;
const int16Array: (value: any) => boolean;
const uint16Array: (value: any) => boolean;
const int32Array: (value: any) => boolean;
const uint32Array: (value: any) => boolean;
const float32Array: (value: any) => boolean;
const float64Array: (value: any) => boolean;
const arrayBuffer: (value: any) => boolean;
const sharedArrayBuffer: (value: any) => boolean;
const truthy: (value: any) => boolean;
const falsy: (value: any) => boolean;
const nan: (value: any) => boolean;
const primitive: (value: any) => boolean;
const integer: (value: any) => boolean;
const safeInteger: (value: any) => boolean;
const plainObject: (value: any) => boolean;
const typedArray: (value: any) => boolean;
const arrayLike: (value: any) => boolean;
const inRange: (value: number, range: number | number[]) => boolean;
const domElement: (value: any) => boolean;
const infinite: (value: any) => boolean;
const even: (rem: number) => boolean;
const odd: (rem: number) => boolean;
const empty: (value: any) => boolean;
const emptyOrWhitespace: (value: any) => boolean;
function any(...predicate: any[]): any;
function all(...predicate: any[]): any;
}
export default is;

182
node_modules/@sindresorhus/is/dist/source/index.js generated vendored
View File

@@ -1,182 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const util = require("util");
const toString = Object.prototype.toString;
const getObjectType = (value) => toString.call(value).slice(8, -1);
const isOfType = (type) => (value) => typeof value === type;
const isObjectOfType = (type) => (value) => getObjectType(value) === type;
function is(value) {
if (value === null) {
return 'null';
}
if (value === true || value === false) {
return 'boolean';
}
const type = typeof value;
if (type === 'undefined') {
return 'undefined';
}
if (type === 'string') {
return 'string';
}
if (type === 'number') {
return 'number';
}
if (type === 'symbol') {
return 'symbol';
}
if (is.function_(value)) {
return 'Function';
}
if (Array.isArray(value)) {
return 'Array';
}
if (Buffer.isBuffer(value)) {
return 'Buffer';
}
const tagType = getObjectType(value);
if (tagType) {
return tagType;
}
if (value instanceof String || value instanceof Boolean || value instanceof Number) {
throw new TypeError('Please don\'t use object wrappers for primitive types');
}
return 'Object';
}
(function (is) {
const isObject = (value) => typeof value === 'object';
is.undefined = isOfType('undefined');
is.string = isOfType('string');
is.number = isOfType('number');
is.function_ = isOfType('function');
is.null_ = (value) => value === null;
is.class_ = (value) => is.function_(value) && value.toString().startsWith('class ');
is.boolean = (value) => value === true || value === false;
is.symbol = isOfType('symbol');
is.array = Array.isArray;
is.buffer = Buffer.isBuffer;
is.nullOrUndefined = (value) => is.null_(value) || is.undefined(value);
is.object = (value) => !is.nullOrUndefined(value) && (is.function_(value) || isObject(value));
is.iterable = (value) => !is.nullOrUndefined(value) && is.function_(value[Symbol.iterator]);
is.generator = (value) => is.iterable(value) && is.function_(value.next) && is.function_(value.throw);
is.nativePromise = isObjectOfType('Promise');
const hasPromiseAPI = (value) => !is.null_(value) &&
isObject(value) &&
is.function_(value.then) &&
is.function_(value.catch);
is.promise = (value) => is.nativePromise(value) || hasPromiseAPI(value);
const isFunctionOfType = (type) => (value) => is.function_(value) && is.function_(value.constructor) && value.constructor.name === type;
is.generatorFunction = isFunctionOfType('GeneratorFunction');
is.asyncFunction = isFunctionOfType('AsyncFunction');
is.regExp = isObjectOfType('RegExp');
is.date = isObjectOfType('Date');
is.error = isObjectOfType('Error');
is.map = isObjectOfType('Map');
is.set = isObjectOfType('Set');
is.weakMap = isObjectOfType('WeakMap');
is.weakSet = isObjectOfType('WeakSet');
is.int8Array = isObjectOfType('Int8Array');
is.uint8Array = isObjectOfType('Uint8Array');
is.uint8ClampedArray = isObjectOfType('Uint8ClampedArray');
is.int16Array = isObjectOfType('Int16Array');
is.uint16Array = isObjectOfType('Uint16Array');
is.int32Array = isObjectOfType('Int32Array');
is.uint32Array = isObjectOfType('Uint32Array');
is.float32Array = isObjectOfType('Float32Array');
is.float64Array = isObjectOfType('Float64Array');
is.arrayBuffer = isObjectOfType('ArrayBuffer');
is.sharedArrayBuffer = isObjectOfType('SharedArrayBuffer');
is.truthy = (value) => Boolean(value);
is.falsy = (value) => !value;
is.nan = (value) => Number.isNaN(value);
const primitiveTypes = new Set([
'undefined',
'string',
'number',
'boolean',
'symbol'
]);
is.primitive = (value) => is.null_(value) || primitiveTypes.has(typeof value);
is.integer = (value) => Number.isInteger(value);
is.safeInteger = (value) => Number.isSafeInteger(value);
is.plainObject = (value) => {
let prototype;
return getObjectType(value) === 'Object' &&
(prototype = Object.getPrototypeOf(value), prototype === null ||
prototype === Object.getPrototypeOf({}));
};
const typedArrayTypes = new Set([
'Int8Array',
'Uint8Array',
'Uint8ClampedArray',
'Int16Array',
'Uint16Array',
'Int32Array',
'Uint32Array',
'Float32Array',
'Float64Array'
]);
is.typedArray = (value) => typedArrayTypes.has(getObjectType(value));
const isValidLength = (value) => is.safeInteger(value) && value > -1;
is.arrayLike = (value) => !is.nullOrUndefined(value) && !is.function_(value) && isValidLength(value.length);
is.inRange = (value, range) => {
if (is.number(range)) {
return value >= Math.min(0, range) && value <= Math.max(range, 0);
}
if (is.array(range) && range.length === 2) {
return value >= Math.min.apply(null, range) && value <= Math.max.apply(null, range);
}
throw new TypeError(`Invalid range: ${util.inspect(range)}`);
};
const NODE_TYPE_ELEMENT = 1;
const DOM_PROPERTIES_TO_CHECK = [
'innerHTML',
'ownerDocument',
'style',
'attributes',
'nodeValue'
];
is.domElement = (value) => is.object(value) && value.nodeType === NODE_TYPE_ELEMENT && is.string(value.nodeName) &&
!is.plainObject(value) && DOM_PROPERTIES_TO_CHECK.every(property => property in value);
is.infinite = (value) => value === Infinity || value === -Infinity;
const isAbsoluteMod2 = (value) => (rem) => is.integer(rem) && Math.abs(rem % 2) === value;
is.even = isAbsoluteMod2(0);
is.odd = isAbsoluteMod2(1);
const isWhiteSpaceString = (value) => is.string(value) && /\S/.test(value) === false;
const isEmptyStringOrArray = (value) => (is.string(value) || is.array(value)) && value.length === 0;
const isEmptyObject = (value) => !is.map(value) && !is.set(value) && is.object(value) && Object.keys(value).length === 0;
const isEmptyMapOrSet = (value) => (is.map(value) || is.set(value)) && value.size === 0;
is.empty = (value) => is.falsy(value) || isEmptyStringOrArray(value) || isEmptyObject(value) || isEmptyMapOrSet(value);
is.emptyOrWhitespace = (value) => is.empty(value) || isWhiteSpaceString(value);
const predicateOnArray = (method, predicate, args) => {
const values = Array.prototype.slice.call(args, 1);
if (is.function_(predicate) === false) {
throw new TypeError(`Invalid predicate: ${util.inspect(predicate)}`);
}
if (values.length === 0) {
throw new TypeError('Invalid number of values');
}
return method.call(values, predicate);
};
function any(predicate) {
return predicateOnArray(Array.prototype.some, predicate, arguments);
}
is.any = any;
function all(predicate) {
return predicateOnArray(Array.prototype.every, predicate, arguments);
}
is.all = all;
})(is || (is = {}));
Object.defineProperties(is, {
class: {
value: is.class_
},
function: {
value: is.function_
},
null: {
value: is.null_
}
});
exports.default = is;
//# sourceMappingURL=index.js.map

1
node_modules/@sindresorhus/is/dist/source/index.js.map generated vendored
View File

File diff suppressed because one or more lines are too long

0
node_modules/@sindresorhus/is/dist/source/tests/test.d.ts generated vendored
View File

622
node_modules/@sindresorhus/is/dist/source/tests/test.js generated vendored
View File

@@ -1,622 +0,0 @@
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
const util = require("util");
const ava_1 = require("ava");
const jsdom_1 = require("jsdom");
const __1 = require("..");
const isNode8orHigher = Number(process.versions.node.split('.')[0]) >= 8;
class ErrorSubclassFixture extends Error {
}
const document = jsdom_1.jsdom();
const createDomElement = (el) => document.createElement(el);
const types = new Map([
['undefined', {
is: __1.default.undefined,
fixtures: [
undefined
]
}],
['null', {
is: __1.default.null_,
fixtures: [
null
]
}],
['string', {
is: __1.default.string,
fixtures: [
'🦄',
'hello world',
''
]
}],
['number', {
is: __1.default.number,
fixtures: [
6,
1.4,
0,
-0,
Infinity,
-Infinity
]
}],
['boolean', {
is: __1.default.boolean,
fixtures: [
true, false
]
}],
['symbol', {
is: __1.default.symbol,
fixtures: [
Symbol('🦄')
]
}],
['array', {
is: __1.default.array,
fixtures: [
[1, 2],
new Array(2)
]
}],
['function', {
is: __1.default.function_,
fixtures: [
function foo() { },
function () { },
() => { },
function () {
return __awaiter(this, void 0, void 0, function* () { });
},
function* () { }
]
}],
['buffer', {
is: __1.default.buffer,
fixtures: [
Buffer.from('🦄')
]
}],
['object', {
is: __1.default.object,
fixtures: [
{ x: 1 },
Object.create({ x: 1 })
]
}],
['regExp', {
is: __1.default.regExp,
fixtures: [
/\w/,
new RegExp('\\w')
]
}],
['date', {
is: __1.default.date,
fixtures: [
new Date()
]
}],
['error', {
is: __1.default.error,
fixtures: [
new Error('🦄'),
new ErrorSubclassFixture()
]
}],
['nativePromise', {
is: __1.default.nativePromise,
fixtures: [
Promise.resolve(),
]
}],
['promise', {
is: __1.default.promise,
fixtures: [
{ then() { }, catch() { } }
]
}],
['generator', {
is: __1.default.generator,
fixtures: [
(function* () { yield 4; })()
]
}],
['generatorFunction', {
is: __1.default.generatorFunction,
fixtures: [
function* () { yield 4; }
]
}],
['asyncFunction', {
is: __1.default.asyncFunction,
fixtures: [
function () {
return __awaiter(this, void 0, void 0, function* () { });
},
() => __awaiter(this, void 0, void 0, function* () { })
]
}],
['map', {
is: __1.default.map,
fixtures: [
new Map()
]
}],
['set', {
is: __1.default.set,
fixtures: [
new Set()
]
}],
['weakSet', {
is: __1.default.weakSet,
fixtures: [
new WeakSet()
]
}],
['weakMap', {
is: __1.default.weakMap,
fixtures: [
new WeakMap()
]
}],
['int8Array', {
is: __1.default.int8Array,
fixtures: [
new Int8Array(0)
]
}],
['uint8Array', {
is: __1.default.uint8Array,
fixtures: [
new Uint8Array(0)
]
}],
['uint8ClampedArray', {
is: __1.default.uint8ClampedArray,
fixtures: [
new Uint8ClampedArray(0)
]
}],
['int16Array', {
is: __1.default.int16Array,
fixtures: [
new Int16Array(0)
]
}],
['uint16Array', {
is: __1.default.uint16Array,
fixtures: [
new Uint16Array(0)
]
}],
['int32Array', {
is: __1.default.int32Array,
fixtures: [
new Int32Array(0)
]
}],
['uint32Array', {
is: __1.default.uint32Array,
fixtures: [
new Uint32Array(0)
]
}],
['float32Array', {
is: __1.default.float32Array,
fixtures: [
new Float32Array(0)
]
}],
['float64Array', {
is: __1.default.float64Array,
fixtures: [
new Float64Array(0)
]
}],
['arrayBuffer', {
is: __1.default.arrayBuffer,
fixtures: [
new ArrayBuffer(10)
]
}],
['nan', {
is: __1.default.nan,
fixtures: [
NaN,
Number.NaN
]
}],
['nullOrUndefined', {
is: __1.default.nullOrUndefined,
fixtures: [
null,
undefined
]
}],
['plainObject', {
is: __1.default.plainObject,
fixtures: [
{ x: 1 },
Object.create(null),
new Object()
]
}],
['integer', {
is: __1.default.integer,
fixtures: [
6
]
}],
['safeInteger', {
is: __1.default.safeInteger,
fixtures: [
Math.pow(2, 53) - 1,
-Math.pow(2, 53) + 1
]
}],
['domElement', {
is: __1.default.domElement,
fixtures: [
'div',
'input',
'span',
'img',
'canvas',
'script'
].map(createDomElement)
}
], ['non-domElements', {
is: value => !__1.default.domElement(value),
fixtures: [
document.createTextNode('data'),
document.createProcessingInstruction('xml-stylesheet', 'href="mycss.css" type="text/css"'),
document.createComment('This is a comment'),
document,
document.implementation.createDocumentType('svg:svg', '-//W3C//DTD SVG 1.1//EN', 'http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd'),
document.createDocumentFragment()
]
}],
['infinite', {
is: __1.default.infinite,
fixtures: [
Infinity,
-Infinity
]
}]
]);
const testType = (t, type, exclude) => {
const testData = types.get(type);
if (testData === undefined) {
t.fail(`is.${type} not defined`);
return;
}
const { is } = testData;
for (const [key, { fixtures }] of types) {
if (exclude && exclude.indexOf(key) !== -1) {
continue;
}
const assert = key === type ? t.true.bind(t) : t.false.bind(t);
for (const fixture of fixtures) {
assert(is(fixture), `Value: ${util.inspect(fixture)}`);
}
}
};
ava_1.default('is', t => {
t.is(__1.default(null), 'null');
t.is(__1.default(undefined), 'undefined');
});
ava_1.default('is.undefined', t => {
testType(t, 'undefined', ['nullOrUndefined']);
});
ava_1.default('is.null', t => {
testType(t, 'null', ['nullOrUndefined']);
});
ava_1.default('is.string', t => {
testType(t, 'string');
});
ava_1.default('is.number', t => {
testType(t, 'number', ['nan', 'integer', 'safeInteger', 'infinite']);
});
ava_1.default('is.boolean', t => {
testType(t, 'boolean');
});
ava_1.default('is.symbol', t => {
testType(t, 'symbol');
});
ava_1.default('is.array', t => {
testType(t, 'array');
});
ava_1.default('is.function', t => {
testType(t, 'function', ['generatorFunction', 'asyncFunction']);
});
ava_1.default('is.buffer', t => {
testType(t, 'buffer');
});
ava_1.default('is.object', t => {
const testData = types.get('object');
if (testData === undefined) {
t.fail('is.object not defined');
return;
}
for (const el of testData.fixtures) {
t.true(__1.default.object(el));
}
});
ava_1.default('is.regExp', t => {
testType(t, 'regExp');
});
ava_1.default('is.date', t => {
testType(t, 'date');
});
ava_1.default('is.error', t => {
testType(t, 'error');
});
if (isNode8orHigher) {
ava_1.default('is.nativePromise', t => {
testType(t, 'nativePromise');
});
ava_1.default('is.promise', t => {
testType(t, 'promise', ['nativePromise']);
});
}
ava_1.default('is.generator', t => {
testType(t, 'generator');
});
ava_1.default('is.generatorFunction', t => {
testType(t, 'generatorFunction', ['function']);
});
ava_1.default('is.map', t => {
testType(t, 'map');
});
ava_1.default('is.set', t => {
testType(t, 'set');
});
ava_1.default('is.weakMap', t => {
testType(t, 'weakMap');
});
ava_1.default('is.weakSet', t => {
testType(t, 'weakSet');
});
ava_1.default('is.int8Array', t => {
testType(t, 'int8Array');
});
ava_1.default('is.uint8Array', t => {
testType(t, 'uint8Array', ['buffer']);
});
ava_1.default('is.uint8ClampedArray', t => {
testType(t, 'uint8ClampedArray');
});
ava_1.default('is.int16Array', t => {
testType(t, 'int16Array');
});
ava_1.default('is.uint16Array', t => {
testType(t, 'uint16Array');
});
ava_1.default('is.int32Array', t => {
testType(t, 'int32Array');
});
ava_1.default('is.uint32Array', t => {
testType(t, 'uint32Array');
});
ava_1.default('is.float32Array', t => {
testType(t, 'float32Array');
});
ava_1.default('is.float64Array', t => {
testType(t, 'float64Array');
});
ava_1.default('is.arrayBuffer', t => {
testType(t, 'arrayBuffer');
});
ava_1.default('is.dataView', t => {
testType(t, 'arrayBuffer');
});
ava_1.default('is.truthy', t => {
t.true(__1.default.truthy('unicorn'));
t.true(__1.default.truthy('🦄'));
t.true(__1.default.truthy(new Set()));
t.true(__1.default.truthy(Symbol('🦄')));
t.true(__1.default.truthy(true));
});
ava_1.default('is.falsy', t => {
t.true(__1.default.falsy(false));
t.true(__1.default.falsy(0));
t.true(__1.default.falsy(''));
t.true(__1.default.falsy(null));
t.true(__1.default.falsy(undefined));
t.true(__1.default.falsy(NaN));
});
ava_1.default('is.nan', t => {
testType(t, 'nan');
});
ava_1.default('is.nullOrUndefined', t => {
testType(t, 'nullOrUndefined', ['undefined', 'null']);
});
ava_1.default('is.primitive', t => {
const primitives = [
undefined,
null,
'🦄',
6,
Infinity,
-Infinity,
true,
false,
Symbol('🦄')
];
for (const el of primitives) {
t.true(__1.default.primitive(el));
}
});
ava_1.default('is.integer', t => {
testType(t, 'integer', ['number', 'safeInteger']);
t.false(__1.default.integer(1.4));
});
ava_1.default('is.safeInteger', t => {
testType(t, 'safeInteger', ['number', 'integer']);
t.false(__1.default.safeInteger(Math.pow(2, 53)));
t.false(__1.default.safeInteger(-Math.pow(2, 53)));
});
ava_1.default('is.plainObject', t => {
testType(t, 'plainObject', ['object', 'promise']);
});
ava_1.default('is.iterable', t => {
t.true(__1.default.iterable(''));
t.true(__1.default.iterable([]));
t.true(__1.default.iterable(new Map()));
t.false(__1.default.iterable(null));
t.false(__1.default.iterable(undefined));
t.false(__1.default.iterable(0));
t.false(__1.default.iterable(NaN));
t.false(__1.default.iterable(Infinity));
t.false(__1.default.iterable({}));
});
ava_1.default('is.class', t => {
class Foo {
}
const classDeclarations = [
Foo,
class Bar extends Foo {
}
];
for (const x of classDeclarations) {
t.true(__1.default.class_(x));
}
});
ava_1.default('is.typedArray', t => {
const typedArrays = [
new Int8Array(0),
new Uint8Array(0),
new Uint8ClampedArray(0),
new Uint16Array(0),
new Int32Array(0),
new Uint32Array(0),
new Float32Array(0),
new Float64Array(0)
];
for (const el of typedArrays) {
t.true(__1.default.typedArray(el));
}
t.false(__1.default.typedArray(new ArrayBuffer(1)));
t.false(__1.default.typedArray([]));
t.false(__1.default.typedArray({}));
});
ava_1.default('is.arrayLike', t => {
(() => {
t.true(__1.default.arrayLike(arguments));
})();
t.true(__1.default.arrayLike([]));
t.true(__1.default.arrayLike('unicorn'));
t.false(__1.default.arrayLike({}));
t.false(__1.default.arrayLike(() => { }));
t.false(__1.default.arrayLike(new Map()));
});
ava_1.default('is.inRange', t => {
const x = 3;
t.true(__1.default.inRange(x, [0, 5]));
t.true(__1.default.inRange(x, [5, 0]));
t.true(__1.default.inRange(x, [-5, 5]));
t.true(__1.default.inRange(x, [5, -5]));
t.false(__1.default.inRange(x, [4, 8]));
t.true(__1.default.inRange(-7, [-5, -10]));
t.true(__1.default.inRange(-5, [-5, -10]));
t.true(__1.default.inRange(-10, [-5, -10]));
t.true(__1.default.inRange(x, 10));
t.true(__1.default.inRange(0, 0));
t.true(__1.default.inRange(-2, -3));
t.false(__1.default.inRange(x, 2));
t.false(__1.default.inRange(-3, -2));
t.throws(() => {
__1.default.inRange(0, []);
});
t.throws(() => {
__1.default.inRange(0, [5]);
});
t.throws(() => {
__1.default.inRange(0, [1, 2, 3]);
});
});
ava_1.default('is.domElement', t => {
testType(t, 'domElement');
t.false(__1.default.domElement({ nodeType: 1, nodeName: 'div' }));
});
ava_1.default('is.infinite', t => {
testType(t, 'infinite', ['number']);
});
ava_1.default('is.even', t => {
for (const el of [-6, 2, 4]) {
t.true(__1.default.even(el));
}
for (const el of [-3, 1, 5]) {
t.false(__1.default.even(el));
}
});
ava_1.default('is.odd', t => {
for (const el of [-5, 7, 13]) {
t.true(__1.default.odd(el));
}
for (const el of [-8, 8, 10]) {
t.false(__1.default.odd(el));
}
});
ava_1.default('is.empty', t => {
t.true(__1.default.empty(null));
t.true(__1.default.empty(undefined));
t.true(__1.default.empty(false));
t.false(__1.default.empty(true));
t.true(__1.default.empty(''));
t.false(__1.default.empty('🦄'));
t.true(__1.default.empty([]));
t.false(__1.default.empty(['🦄']));
t.true(__1.default.empty({}));
t.false(__1.default.empty({ unicorn: '🦄' }));
const tempMap = new Map();
t.true(__1.default.empty(tempMap));
tempMap.set('unicorn', '🦄');
t.false(__1.default.empty(tempMap));
const tempSet = new Set();
t.true(__1.default.empty(tempSet));
tempSet.add(1);
t.false(__1.default.empty(tempSet));
});
ava_1.default('is.emptyOrWhitespace', t => {
t.true(__1.default.emptyOrWhitespace(''));
t.true(__1.default.emptyOrWhitespace(' '));
t.false(__1.default.emptyOrWhitespace('🦄'));
t.false(__1.default.emptyOrWhitespace('unicorn'));
});
ava_1.default('is.any', t => {
t.true(__1.default.any(__1.default.string, {}, true, '🦄'));
t.true(__1.default.any(__1.default.object, false, {}, 'unicorns'));
t.false(__1.default.any(__1.default.boolean, '🦄', [], 3));
t.false(__1.default.any(__1.default.integer, true, 'lol', {}));
t.throws(() => {
__1.default.any(null, true);
});
t.throws(() => {
__1.default.any(__1.default.string);
});
});
ava_1.default('is.all', t => {
t.true(__1.default.all(__1.default.object, {}, new Set(), new Map()));
t.true(__1.default.all(__1.default.boolean, true, false));
t.false(__1.default.all(__1.default.string, '🦄', []));
t.false(__1.default.all(__1.default.set, new Map(), {}));
t.throws(() => {
__1.default.all(null, true);
});
t.throws(() => {
__1.default.all(__1.default.string);
});
});
//# sourceMappingURL=test.js.map

1
node_modules/@sindresorhus/is/dist/source/tests/test.js.map generated vendored
View File

File diff suppressed because one or more lines are too long

9
node_modules/@sindresorhus/is/license generated vendored
View File

@@ -1,9 +0,0 @@
MIT License
Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
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.

95
node_modules/@sindresorhus/is/package.json generated vendored
View File

@@ -1,95 +0,0 @@
{
"_from": "@sindresorhus/is@^0.7.0",
"_id": "@sindresorhus/is@0.7.0",
"_inBundle": false,
"_integrity": "sha512-ONhaKPIufzzrlNbqtWFFd+jlnemX6lJAgq9ZeiZtS7I1PIf/la7CW4m83rTXRnVnsMbW2k56pGYu7AUFJD9Pow==",
"_location": "/@sindresorhus/is",
"_phantomChildren": {},
"_requested": {
"type": "range",
"registry": true,
"raw": "@sindresorhus/is@^0.7.0",
"name": "@sindresorhus/is",
"escapedName": "@sindresorhus%2fis",
"scope": "@sindresorhus",
"rawSpec": "^0.7.0",
"saveSpec": null,
"fetchSpec": "^0.7.0"
},
"_requiredBy": [
"/bin-wrapper/got"
],
"_resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-0.7.0.tgz",
"_shasum": "9a06f4f137ee84d7df0460c1fdb1135ffa6c50fd",
"_spec": "@sindresorhus/is@^0.7.0",
"_where": "/var/www/html/jason/WeihnachtenMelly/node_modules/bin-wrapper/node_modules/got",
"author": {
"name": "Sindre Sorhus",
"email": "sindresorhus@gmail.com",
"url": "sindresorhus.com"
},
"bugs": {
"url": "https://github.com/sindresorhus/is/issues"
},
"bundleDependencies": false,
"deprecated": false,
"description": "Type check values: `is.string('🦄') //=> true`",
"devDependencies": {
"@types/jsdom": "^2.0.31",
"@types/node": "^8.0.47",
"@types/tempy": "^0.1.0",
"ava": "*",
"del-cli": "^1.1.0",
"jsdom": "^9.12.0",
"tempy": "^0.2.1",
"tslint": "^5.8.0",
"tslint-xo": "^0.3.0",
"typescript": "^2.6.1"
},
"engines": {
"node": ">=4"
},
"files": [
"dist"
],
"homepage": "https://github.com/sindresorhus/is#readme",
"keywords": [
"type",
"types",
"is",
"check",
"checking",
"validate",
"validation",
"utility",
"util",
"typeof",
"instanceof",
"object",
"assert",
"assertion",
"test",
"kind",
"primitive",
"verify",
"compare"
],
"license": "MIT",
"main": "dist/index.js",
"name": "@sindresorhus/is",
"publishConfig": {
"access": "public"
},
"repository": {
"type": "git",
"url": "git+https://github.com/sindresorhus/is.git"
},
"scripts": {
"build": "tsc",
"lint": "tslint --format stylish --project .",
"prepublish": "npm run build && del dist/tests",
"test": "npm run lint && npm run build && ava dist/tests"
},
"types": "dist/index.d.ts",
"version": "0.7.0"
}

323
node_modules/@sindresorhus/is/readme.md generated vendored
View File

@@ -1,323 +0,0 @@
# is [![Build Status](https://travis-ci.org/sindresorhus/is.svg?branch=master)](https://travis-ci.org/sindresorhus/is)
> Type check values: `is.string('🦄') //=> true`
<img src="header.gif" width="182" align="right">
## Install
```
$ npm install @sindresorhus/is
```
## Usage
```js
const is = require('@sindresorhus/is');
is('🦄');
//=> 'string'
is(new Map());
//=> 'Map'
is.number(6);
//=> true
```
## API
### is(value)
Returns the type of `value`.
Primitives are lowercase and object types are camelcase.
Example:
- `'undefined'`
- `'null'`
- `'string'`
- `'symbol'`
- `'Array'`
- `'Function'`
- `'Object'`
Note: It will throw if you try to feed it object-wrapped primitives, as that's a bad practice. For example `new String('foo')`.
### is.{method}
All the below methods accept a value and returns a boolean for whether the value is of the desired type.
#### Primitives
##### .undefined(value)
##### .null(value)
##### .string(value)
##### .number(value)
##### .boolean(value)
##### .symbol(value)
#### Built-in types
##### .array(value)
##### .function(value)
##### .buffer(value)
##### .object(value)
Keep in mind that [functions are objects too](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions).
##### .regExp(value)
##### .date(value)
##### .error(value)
##### .nativePromise(value)
##### .promise(value)
Returns `true` for any object with a `.then()` and `.catch()` method. Prefer this one over `.nativePromise()` as you usually want to allow userland promise implementations too.
##### .generator(value)
Returns `true` for any object that implements its own `.next()` and `.throw()` methods and has a function definition for `Symbol.iterator`.
##### .generatorFunction(value)
##### .asyncFunction(value)
Returns `true` for any `async` function that can be called with the `await` operator.
```js
is.asyncFunction(async () => {});
// => true
is.asyncFunction(() => {});
// => false
```
##### .boundFunction(value)
Returns `true` for any `bound` function.
```js
is.boundFunction(() => {});
// => true
is.boundFunction(function () {}.bind(null));
// => true
is.boundFunction(function () {});
// => false
```
##### .map(value)
##### .set(value)
##### .weakMap(value)
##### .weakSet(value)
#### Typed arrays
##### .int8Array(value)
##### .uint8Array(value)
##### .uint8ClampedArray(value)
##### .int16Array(value)
##### .uint16Array(value)
##### .int32Array(value)
##### .uint32Array(value)
##### .float32Array(value)
##### .float64Array(value)
#### Structured data
##### .arrayBuffer(value)
##### .sharedArrayBuffer(value)
##### .dataView(value)
#### Miscellaneous
##### .directInstanceOf(value, class)
Returns `true` if `value` is a direct instance of `class`.
```js
is.directInstanceOf(new Error(), Error);
//=> true
class UnicornError extends Error {};
is.directInstanceOf(new UnicornError(), Error);
//=> false
```
##### .truthy(value)
Returns `true` for all values that evaluate to true in a boolean context:
```js
is.truthy('🦄');
//=> true
is.truthy(undefined);
//=> false
```
##### .falsy(value)
Returns `true` if `value` is one of: `false`, `0`, `''`, `null`, `undefined`, `NaN`.
##### .nan(value)
##### .nullOrUndefined(value)
##### .primitive(value)
JavaScript primitives are as follows: `null`, `undefined`, `string`, `number`, `boolean`, `symbol`.
##### .integer(value)
##### .safeInteger(value)
Returns `true` if `value` is a [safe integer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger).
##### .plainObject(value)
An object is plain if it's created by either `{}`, `new Object()`, or `Object.create(null)`.
##### .iterable(value)
##### .class(value)
Returns `true` for instances created by a ES2015 class.
##### .typedArray(value)
##### .arrayLike(value)
A `value` is array-like if it is not a function and has a `value.length` that is a safe integer greater than or equal to 0.
```js
is.arrayLike(document.forms);
//=> true
function () {
is.arrayLike(arguments);
//=> true
}
```
##### .inRange(value, range)
Check if `value` (number) is in the given `range`. The range is an array of two values, lower bound and upper bound, in no specific order.
```js
is.inRange(3, [0, 5]);
is.inRange(3, [5, 0]);
is.inRange(0, [-2, 2]);
```
##### .inRange(value, upperBound)
Check if `value` (number) is in the range of `0` to `upperBound`.
```js
is.inRange(3, 10);
```
##### .domElement(value)
Returns `true` if `value` is a DOM Element.
##### .nodeStream(value)
Returns `true` if `value` is a Node.js [stream](https://nodejs.org/api/stream.html).
```js
const fs = require('fs');
is.nodeStream(fs.createReadStream('unicorn.png'));
//=> true
```
##### .infinite(value)
Check if `value` is `Infinity` or `-Infinity`.
##### .even(value)
Returns `true` if `value` is an even integer.
##### .odd(value)
Returns `true` if `value` is an odd integer.
##### .empty(value)
Returns `true` if `value` is falsy or an empty string, array, object, map, or set.
##### .emptyOrWhitespace(value)
Returns `true` if `is.empty(value)` or a string that is all whitespace.
##### .any(predicate, ...values)
Returns `true` if **any** of the input `values` returns true in the `predicate`:
```js
is.any(is.string, {}, true, '🦄');
//=> true
is.any(is.boolean, 'unicorns', [], new Map());
//=> false
```
##### .all(predicate, ...values)
Returns `true` if **all** of the input `values` returns true in the `predicate`:
```js
is.all(is.object, {}, new Map(), new Set());
//=> true
is.all(is.string, '🦄', [], 'unicorns');
//=> false
```
## FAQ
### Why yet another type checking module?
There are hundreds of type checking modules on npm, unfortunately, I couldn't find any that fit my needs:
- Includes both type methods and ability to get the type
- Types of primitives returned as lowercase and object types as camelcase
- Covers all built-ins
- Unsurprising behavior
- Well-maintained
- Comprehensive test suite
For the ones I found, pick 3 of these.
The most common mistakes I noticed in these modules was using `instanceof` for type checking, forgetting that functions are objects, and omitting `symbol` as a primitive.
## Related
- [is-stream](https://github.com/sindresorhus/is-stream) - Check if something is a Node.js stream
- [is-observable](https://github.com/sindresorhus/is-observable) - Check if a value is an Observable
- [file-type](https://github.com/sindresorhus/file-type) - Detect the file type of a Buffer/Uint8Array
- [is-ip](https://github.com/sindresorhus/is-ip) - Check if a string is an IP address
- [is-array-sorted](https://github.com/sindresorhus/is-array-sorted) - Check if an Array is sorted
- [is-error-constructor](https://github.com/sindresorhus/is-error-constructor) - Check if a value is an error constructor
- [is-empty-iterable](https://github.com/sindresorhus/is-empty-iterable) - Check if an Iterable is empty
- [is-blob](https://github.com/sindresorhus/is-blob) - Check if a value is a Blob - File-like object of immutable, raw data
- [has-emoji](https://github.com/sindresorhus/has-emoji) - Check whether a string has any emoji
## Created by
- [Sindre Sorhus](https://github.com/sindresorhus)
- [Giora Guttsait](https://github.com/gioragutt)
- [Brandon Smith](https://github.com/brandon93s)
## License
MIT