@flourish/sdk 4.2.2 → 5.0.0

package/my_template/node_modules/is-what/test/ava.ts

@@ -1,376 +0,0 @@
-import test from 'ava'
-import {
-  isError,
-  isEmptyArray,
-  isObject,
-  isPlainObject,
-  isAnyObject,
-  isUndefined,
-  isNull,
-  isNullOrUndefined,
-  isFunction,
-  isArray,
-  isString,
-  isEmptyString,
-  isFullString,
-  isBoolean,
-  isRegExp,
-  isNumber,
-  isDate,
-  isSymbol,
-  isPrimitive,
-  isType,
-  isMap,
-  isWeakMap,
-  isSet,
-  isWeakSet,
-  isFullArray,
-  // isBlob,
-  // isFile,
-  isPromise,
-  isNaNValue,
-  isEmptyObject,
-  isOneOf,
-  isFullObject,
-} from '../src/index'
-
-// const blob = Buffer.from([])
-
-test('Basic true tests', t => {
-  t.is(isError(new Error('')), true)
-  t.is(isUndefined(undefined), true)
-  t.is(isNull(null), true)
-  t.is(isNullOrUndefined(null), true)
-  t.is(isNullOrUndefined(undefined), true)
-  t.is(isObject({}), true)
-  t.is(isEmptyObject({}), true)
-  t.is(isFullObject({0: ''}), true)
-  t.is(isFullObject({'': ''}), true)
-  t.is(isObject(new Object()), true)
-  t.is(isArray([]), true)
-  t.is(isEmptyArray([]), true)
-  t.is(isFullArray(['']), true)
-  t.is(isArray(new Array()), true)
-  t.is(isString(''), true)
-  t.is(isString('_'), true)
-  t.is(isEmptyString(''), true)
-  t.is(isFullString(' '), true)
-  t.is(isBoolean(true), true)
-  t.is(isBoolean(false), true)
-  t.is(isRegExp(/./), true)
-  t.is(isRegExp(/./gi), true)
-  t.is(isNumber(0), true)
-  t.is(isNumber(1), true)
-  t.is(isDate(new Date()), true)
-  t.is(isSymbol(Symbol()), true)
-  t.is(isMap(new Map()), true)
-  t.is(isWeakMap(new WeakMap()), true)
-  t.is(isSet(new Set()), true)
-  t.is(isWeakSet(new WeakSet()), true)
-  // t.is(isBlob(blob), true)
-  // t.is(isFile(new File([''], '', { type: 'text/html' })), true)
-  t.is(isPromise(new Promise((resolve, reject) => {})), true)
-})
-
-test('Basic false tests', t => {
-  t.is(isError({}), false)
-  t.is(isNumber(NaN), false)
-  t.is(isDate(new Date('_')), false)
-  t.is(isDate(NaN), false)
-  t.is(isUndefined(NaN), false)
-  t.is(isNull(NaN), false)
-  t.is(isObject(NaN), false)
-  t.is(isArray(NaN), false)
-  t.is(isString(NaN), false)
-  t.is(isEmptyString(' '), false)
-  t.is(isFullString(''), false)
-  t.is(isBoolean(NaN), false)
-  t.is(isRegExp(NaN), false)
-  t.is(isSymbol(NaN), false)
-  t.is(isMap(new WeakMap()), false)
-  t.is(isWeakMap(new Map()), false)
-  t.is(isSet(new WeakSet()), false)
-  t.is(isWeakSet(new Set()), false)
-  t.is(isNullOrUndefined(NaN), false)
-})
-
-test('isFunction', t => {
-  t.is(isFunction(NaN), false)
-  t.is(isFunction(() => {}), true)
-  t.is(isFunction(function () {}), true)
-  t.is(isFunction(async () => {}), true)
-  t.is(isFunction(async function () {}), true)
-  t.is(isFunction(function * () {}), true)
-  t.is(isFunction(async function * () {}), true)
-  const _ = { fn: () => {}, method () {} }
-  t.is(isFunction(_.fn), true)
-  t.is(isFunction(_.method), true)
-})
-
-test('isEmptyObject', t => {
-  t.is(isEmptyObject({}), true)
-  t.is(isEmptyObject(new Object()), true)
-
-  t.is(isEmptyObject('{}'), false)
-  t.is(isEmptyObject('{}'), false)
-  t.is(isEmptyObject(null), false)
-  t.is(isEmptyObject(new Date()), false)
-  t.is(isEmptyObject(new Error('')), false)
-  t.is(isEmptyObject(new Date()), false)
-  t.is(isEmptyObject(Symbol()), false)
-  t.is(isEmptyObject(new Map()), false)
-  t.is(isEmptyObject(new WeakMap()), false)
-  t.is(isEmptyObject(new Set()), false)
-  t.is(isEmptyObject(new WeakSet()), false)
-})
-
-test('isEmptyArray', t => {
-  t.is(isEmptyArray([]), true)
-  t.is(isEmptyArray(new Array()), true)
-  t.is(isEmptyArray(new Array(0)), true)
-
-  t.is(isEmptyArray(new Array(1)), false)
-  t.is(isEmptyArray([undefined]), false)
-  t.is(isEmptyArray(null), false)
-  t.is(isEmptyArray(new Date()), false)
-  t.is(isEmptyArray(new Error('')), false)
-  t.is(isEmptyArray(new Date()), false)
-  t.is(isEmptyArray(Symbol()), false)
-  t.is(isEmptyArray(new Map()), false)
-  t.is(isEmptyArray(new WeakMap()), false)
-  t.is(isEmptyArray(new Set()), false)
-  t.is(isEmptyArray(new WeakSet()), false)
-})
-
-test('isFullArray', t => {
-  t.is(isFullArray(new Array(1)), true)
-  t.is(isFullArray([undefined]), true)
-  t.is(isFullArray([null]), true)
-  t.is(isFullArray(['']), true)
-
-  t.is(isFullArray([]), false)
-  t.is(isFullArray(new Array()), false)
-  t.is(isFullArray(new Array(0)), false)
-
-  t.is(isFullArray(null), false)
-  t.is(isFullArray(new Date()), false)
-  t.is(isFullArray(new Error('')), false)
-  t.is(isFullArray(new Date()), false)
-  t.is(isFullArray(Symbol()), false)
-  t.is(isFullArray(new Map()), false)
-  t.is(isFullArray(new WeakMap()), false)
-  t.is(isFullArray(new Set()), false)
-  t.is(isFullArray(new WeakSet()), false)
-})
-
-test('NaN tests', t => {
-  t.is(isNaNValue(NaN), true)
-  t.is(isNaNValue(new Error('')), false)
-  t.is(isNaNValue(undefined), false)
-  t.is(isNaNValue(null), false)
-  t.is(isNaNValue(undefined), false)
-  t.is(isNaNValue({}), false)
-  t.is(isNaNValue(new Object()), false)
-  t.is(
-    isNaNValue(() => {}),
-    false
-  )
-  t.is(isNaNValue([]), false)
-  t.is(isNaNValue(new Array()), false)
-  t.is(isNaNValue(''), false)
-  t.is(isNaNValue('_'), false)
-  t.is(isNaNValue(''), false)
-  t.is(isNaNValue(' '), false)
-  t.is(isNaNValue(true), false)
-  t.is(isNaNValue(false), false)
-  t.is(isNaNValue(/./), false)
-  t.is(isNaNValue(/./gi), false)
-  t.is(isNaNValue(0), false)
-  t.is(isNaNValue(1), false)
-  t.is(isNaNValue(new Date()), false)
-  t.is(isNaNValue(Symbol()), false)
-  t.is(isNaNValue(new Map()), false)
-  t.is(isNaNValue(new WeakMap()), false)
-  t.is(isNaNValue(new Set()), false)
-  t.is(isNaNValue(new WeakSet()), false)
-  t.is(isNaNValue(new Promise((resolve, reject) => {})), false)
-})
-
-test('Primitive tests', t => {
-  // true
-  t.is(isPrimitive(0), true)
-  t.is(isPrimitive(''), true)
-  t.is(isPrimitive('str'), true)
-  t.is(isPrimitive(Symbol()), true)
-  t.is(isPrimitive(true), true)
-  t.is(isPrimitive(false), true)
-  t.is(isPrimitive(null), true)
-  t.is(isPrimitive(undefined), true)
-  // false
-  t.is(isPrimitive(NaN), false)
-  t.is(isPrimitive([]), false)
-  t.is(isPrimitive(new Array()), false)
-  t.is(isPrimitive({}), false)
-  t.is(isPrimitive(new Object()), false)
-  t.is(isPrimitive(new Date()), false)
-  t.is(
-    isPrimitive(() => {}),
-    false
-  )
-})
-
-test('Date exception', t => {
-  t.is(isDate(new Date('_')), false)
-})
-
-test('Generic isType', t => {
-  // -----------------------------
-  // This is correct old fashion syntax for classes, if this is missing
-  function MyClass () {}
-  MyClass.prototype.constructor = MyClass
-  // @ts-ignore
-  const myClass = new MyClass()
-  // -----------------------------
-  class MyOtherClass { constructor() {} }
-  // this is expected behaviour
-  t.is(isType('', String), true)
-  t.is(isType('_', String), true)
-  t.is(isType('Hello World', String), true)
-  t.is(isType(NaN, Number), true)
-  t.is(isType(0, Number), true)
-  t.is(isType(1, Number), true)
-  t.is(isType({}, Object), true)
-  t.is(isType(new Object(), Object), true)
-  t.is(isType([], Array), true)
-  t.is(isType(new Array(), Array), true)
-  t.is(
-    isType(() => {}, Function),
-    true
-  )
-  t.is(isType(true, Boolean), true)
-  t.is(isType(false, Boolean), true)
-  t.is(isType(new Date('_'), Date), true)
-  t.is(isType(new Date(), Date), true)
-  t.is(isType(/./, RegExp), true)
-  t.is(isType(/./gi, RegExp), true)
-  t.is(isType(myClass, MyClass), true)
-  t.is(isType(new MyOtherClass(), MyOtherClass), true)
-  t.is(isType(myClass, MyOtherClass), false)
-  t.is(isType(Symbol(), Symbol), true)
-  // t.is(isType(null, Null), true)
-  // t.is(isType(undefined, Undefined), true)
-  // It SHOULD fail
-  t.is(isType(5, String), false)
-  t.is(isType(null, Object), false)
-  // Not sure if this would be the expected behaviour but everything is an object
-  // so I would say so
-  t.is(isType(myClass, Object), true)
-})
-
-test('isObject vs isAnyObject', t => {
-  // -----------------------------
-  // This is correct old fashion syntax for classes, if this is missing
-  function MyClass () {}
-  MyClass.prototype.constructor = MyClass
-  // @ts-ignore
-  const myClass = new MyClass()
-  // -----------------------------
-  class MyClass2 { constructor() {} }
-  const myClass2 = new MyClass2()
-  const mySpecialObject = {}
-  Object.setPrototypeOf(mySpecialObject, {
-    toDate: function () {
-      return new Date()
-    },
-  })
-  // IS OBJECT
-  // plain object
-  t.is(isObject({}), true)
-  t.is(isObject(new Object()), true)
-  t.is(isPlainObject({}), true)
-  t.is(isPlainObject(new Object()), true)
-  // classes & prototypes
-  t.is(isObject(myClass), false)
-  t.is(isObject(myClass2), false)
-  t.is(isObject(mySpecialObject), false)
-  t.is(isPlainObject(myClass), false)
-  t.is(isPlainObject(myClass2), false)
-  t.is(isPlainObject(mySpecialObject), false)
-  // arrays and dates
-  t.is(isObject([]), false)
-  t.is(isObject(new Array()), false)
-  t.is(isObject(new Date('_')), false)
-  t.is(isObject(new Date()), false)
-  t.is(isPlainObject([]), false)
-  t.is(isPlainObject(new Array()), false)
-  t.is(isPlainObject(new Date('_')), false)
-  t.is(isPlainObject(new Date()), false)
-  // IS ANY OBJECT
-  // plain object
-  t.is(isAnyObject({}), true)
-  t.is(isAnyObject(new Object()), true)
-  // classes & prototypes
-  t.is(isAnyObject(myClass), true)
-  t.is(isAnyObject(myClass2), true)
-  t.is(isAnyObject(mySpecialObject), true)
-  // arrays and dates
-  t.is(isAnyObject([]), false)
-  t.is(isAnyObject(new Array()), false)
-  t.is(isAnyObject(new Date('_')), false)
-  t.is(isAnyObject(new Date()), false)
-})
-
-test('isOneOf', t => {
-  t.is(isOneOf(isString, isNumber)('_'), true)
-  t.is(isOneOf(isString, isNumber)(1), true)
-  t.is(isOneOf(isString, isNumber)(undefined), false)
-
-  t.is(isOneOf(isString, isNumber, isBoolean)('_'), true)
-  t.is(isOneOf(isString, isNumber, isBoolean)(1), true)
-  t.is(isOneOf(isString, isNumber, isBoolean)(true), true)
-  t.is(isOneOf(isString, isNumber, isBoolean)(undefined), false)
-
-  t.is(isOneOf(isString, isNumber, isBoolean, isArray)('_'), true)
-  t.is(isOneOf(isString, isNumber, isBoolean, isArray)(1), true)
-  t.is(isOneOf(isString, isNumber, isBoolean, isArray)(true), true)
-  t.is(isOneOf(isString, isNumber, isBoolean, isArray)([]), true)
-  t.is(isOneOf(isString, isNumber, isBoolean, isArray)(undefined), false)
-
-  t.is(isOneOf(isString, isNumber, isBoolean, isArray, isPlainObject)('_'), true)
-  t.is(isOneOf(isString, isNumber, isBoolean, isArray, isPlainObject)(1), true)
-  t.is(isOneOf(isString, isNumber, isBoolean, isArray, isPlainObject)(true), true)
-  t.is(isOneOf(isString, isNumber, isBoolean, isArray, isPlainObject)([]), true)
-  t.is(isOneOf(isString, isNumber, isBoolean, isArray, isPlainObject)({}), true)
-  t.is(isOneOf(isString, isNumber, isBoolean, isArray, isPlainObject)(undefined), false)
-})
-
-test('type related tests', t => {
-  t.pass()
-  // const fn: string | ((k: number) => string) = (p) => 'a'
-  // if (!isFunction(fn)) {
-  //   fn
-  // }
-
-  // const a: Record<string, number> = {}
-
-  // a[fn(1)] = fn(2)
-
-  // const myArray: string | string[] = ['a', 'b']
-  // if (!isArray(myArray)) {
-  //   myArray
-  // }
-
-  // const a: Record<string, number> = {}
-
-  // a[myArray[1]] = myArray[0]
-
-  // const myArray: string | any[] = [1, 2, 'a', 'b']
-  // if (!isArray(myArray)) {
-  //   myArray
-  // }
-
-  // const a: Record<string, number> = {}
-
-  // a[myArray[1]] = myArray[0]
-
-})

package/my_template/node_modules/is-what/test/index.test.js

@@ -1,15 +0,0 @@
-// @ts-check
-import {
-  isBlob,
-  isFile,
-} from '../dist/index.cjs'
-
-test('isBlob', () => {
-  expect(isBlob(Blob)).toBe(false)
-  expect(isBlob(new Blob())).toBe(true)
-})
-
-test('isFile', () => {
-  expect(isFile(File)).toBe(false)
-  expect(isFile(new File([''], '', { type: 'text/html' }))).toBe(true)
-})

package/my_template/node_modules/is-what/tsconfig.json

@@ -1,11 +0,0 @@
-{
-  "compilerOptions": {
-    "baseUrl": ".",
-    "strict": true,
-    "isolatedModules": true,
-    "esModuleInterop": true,
-    "declaration": true,
-    "declarationDir": "./types/"
-  },
-  "include": ["src/**/*", "test/**/*"]
-}

package/my_template/node_modules/is-what/types/index.d.ts

@@ -1,253 +0,0 @@
-export declare type AnyFunction = (...args: any[]) => any;
-export declare type AnyAsyncFunction = (...args: any[]) => Promise<any>;
-export declare type AnyClass = new (...args: any[]) => any;
-export declare type PlainObject = Record<string | number | symbol, any>;
-declare type TypeGuard<A, B extends A> = (payload: A) => payload is B;
-/**
- * Returns the object type of the given payload
- *
- * @param {*} payload
- * @returns {string}
- */
-export declare function getType(payload: any): string;
-/**
- * Returns whether the payload is undefined
- *
- * @param {*} payload
- * @returns {payload is undefined}
- */
-export declare function isUndefined(payload: any): payload is undefined;
-/**
- * Returns whether the payload is null
- *
- * @param {*} payload
- * @returns {payload is null}
- */
-export declare function isNull(payload: any): payload is null;
-/**
- * Returns whether the payload is a plain JavaScript object (excluding special classes or objects with other prototypes)
- *
- * @param {*} payload
- * @returns {payload is PlainObject}
- */
-export declare function isPlainObject(payload: any): payload is PlainObject;
-/**
- * Returns whether the payload is a plain JavaScript object (excluding special classes or objects with other prototypes)
- *
- * @param {*} payload
- * @returns {payload is PlainObject}
- */
-export declare function isObject(payload: any): payload is PlainObject;
-/**
- * Returns whether the payload is a an empty object (excluding special classes or objects with other prototypes)
- *
- * @param {*} payload
- * @returns {payload is { [K in any]: never }}
- */
-export declare function isEmptyObject(payload: any): payload is {
-    [K in any]: never;
-};
-/**
- * Returns whether the payload is a an empty object (excluding special classes or objects with other prototypes)
- *
- * @param {*} payload
- * @returns {payload is PlainObject}
- */
-export declare function isFullObject(payload: any): payload is PlainObject;
-/**
- * Returns whether the payload is an any kind of object (including special classes or objects with different prototypes)
- *
- * @param {*} payload
- * @returns {payload is PlainObject}
- */
-export declare function isAnyObject(payload: any): payload is PlainObject;
-/**
- * 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 < >
- * @param {*} payload
- * @returns {payload is T}
- */
-export declare function isObjectLike<T extends PlainObject>(payload: any): payload is T;
-/**
- * Returns whether the payload is a function (regular or async)
- *
- * @param {*} payload
- * @returns {payload is AnyFunction}
- */
-export declare function isFunction(payload: any): payload is AnyFunction;
-/**
- * Returns whether the payload is an array
- *
- * @param {any} payload
- * @returns {payload is any[]}
- */
-export declare function isArray(payload: any): payload is any[];
-/**
- * Returns whether the payload is a an array with at least 1 item
- *
- * @param {*} payload
- * @returns {payload is any[]}
- */
-export declare function isFullArray(payload: any): payload is any[];
-/**
- * Returns whether the payload is a an empty array
- *
- * @param {*} payload
- * @returns {payload is []}
- */
-export declare function isEmptyArray(payload: any): payload is [];
-/**
- * Returns whether the payload is a string
- *
- * @param {*} payload
- * @returns {payload is string}
- */
-export declare function isString(payload: any): payload is string;
-/**
- * Returns whether the payload is a string, BUT returns false for ''
- *
- * @param {*} payload
- * @returns {payload is string}
- */
-export declare function isFullString(payload: any): payload is string;
-/**
- * Returns whether the payload is ''
- *
- * @param {*} payload
- * @returns {payload is string}
- */
-export declare function isEmptyString(payload: any): payload is string;
-/**
- * Returns whether the payload is a number (but not NaN)
- *
- * This will return `false` for `NaN`!!
- *
- * @param {*} payload
- * @returns {payload is number}
- */
-export declare function isNumber(payload: any): payload is number;
-/**
- * Returns whether the payload is a boolean
- *
- * @param {*} payload
- * @returns {payload is boolean}
- */
-export declare function isBoolean(payload: any): payload is boolean;
-/**
- * Returns whether the payload is a regular expression (RegExp)
- *
- * @param {*} payload
- * @returns {payload is RegExp}
- */
-export declare function isRegExp(payload: any): payload is RegExp;
-/**
- * Returns whether the payload is a Map
- *
- * @param {*} payload
- * @returns {payload is Map<any, any>}
- */
-export declare function isMap(payload: any): payload is Map<any, any>;
-/**
- * Returns whether the payload is a WeakMap
- *
- * @param {*} payload
- * @returns {payload is WeakMap<any, any>}
- */
-export declare function isWeakMap(payload: any): payload is WeakMap<any, any>;
-/**
- * Returns whether the payload is a Set
- *
- * @param {*} payload
- * @returns {payload is Set<any>}
- */
-export declare function isSet(payload: any): payload is Set<any>;
-/**
- * Returns whether the payload is a WeakSet
- *
- * @param {*} payload
- * @returns {payload is WeakSet<any>}
- */
-export declare function isWeakSet(payload: any): payload is WeakSet<any>;
-/**
- * Returns whether the payload is a Symbol
- *
- * @param {*} payload
- * @returns {payload is symbol}
- */
-export declare function isSymbol(payload: any): payload is symbol;
-/**
- * Returns whether the payload is a Date, and that the date is valid
- *
- * @param {*} payload
- * @returns {payload is Date}
- */
-export declare function isDate(payload: any): payload is Date;
-/**
- * Returns whether the payload is a Blob
- *
- * @param {*} payload
- * @returns {payload is Blob}
- */
-export declare function isBlob(payload: any): payload is Blob;
-/**
- * Returns whether the payload is a File
- *
- * @param {*} payload
- * @returns {payload is File}
- */
-export declare function isFile(payload: any): payload is File;
-/**
- * Returns whether the payload is a Promise
- *
- * @param {*} payload
- * @returns {payload is Promise<any>}
- */
-export declare function isPromise(payload: any): payload is Promise<any>;
-/**
- * Returns whether the payload is an Error
- *
- * @param {*} payload
- * @returns {payload is Error}
- */
-export declare function isError(payload: any): payload is Error;
-/**
- * Returns whether the payload is literally the value `NaN` (it's `NaN` and also a `number`)
- *
- * @param {*} payload
- * @returns {payload is typeof NaN}
- */
-export declare function isNaNValue(payload: any): payload is typeof NaN;
-/**
- * Returns whether the payload is a primitive type (eg. Boolean | Null | Undefined | Number | String | Symbol)
- *
- * @param {*} payload
- * @returns {(payload is boolean | null | undefined | number | string | symbol)}
- */
-export declare function isPrimitive(payload: any): payload is boolean | null | undefined | number | string | symbol;
-/**
- * Returns true whether the payload is null or undefined
- *
- * @param {*} payload
- * @returns {(payload is null | undefined)}
- */
-export declare const isNullOrUndefined: TypeGuard<any, null | undefined>;
-export declare function isOneOf<A, B extends A, C extends A>(a: TypeGuard<A, B>, b: TypeGuard<A, C>): TypeGuard<A, B | C>;
-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>;
-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>;
-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>;
-/**
- * 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
- *
- * @template T
- * @param {*} payload
- * @param {T} type
- * @throws {TypeError} Will throw type error if type is an invalid type
- * @returns {payload is T}
- */
-export declare function isType<T extends AnyFunction | AnyClass>(payload: any, type: T): payload is T;
-export {};

package/my_template/node_modules/jest-worker/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) Facebook, Inc. and its affiliates.
-
-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.