@fragno-dev/workflows 0.0.1 → 0.0.3

package/dist/node/node_modules/.pnpm/@sindresorhus_is@7.1.1/node_modules/@sindresorhus/is/distribution/index.js

@@ -1,605 +0,0 @@
-import { keysOf } from "./utilities.js";
-
-//#region ../../node_modules/.pnpm/@sindresorhus+is@7.1.1/node_modules/@sindresorhus/is/distribution/index.js
-const typedArrayTypeNames = [
-	"Int8Array",
-	"Uint8Array",
-	"Uint8ClampedArray",
-	"Int16Array",
-	"Uint16Array",
-	"Int32Array",
-	"Uint32Array",
-	"Float32Array",
-	"Float64Array",
-	"BigInt64Array",
-	"BigUint64Array"
-];
-function isTypedArrayName(name) {
-	return typedArrayTypeNames.includes(name);
-}
-const objectTypeNames = [
-	"Function",
-	"Generator",
-	"AsyncGenerator",
-	"GeneratorFunction",
-	"AsyncGeneratorFunction",
-	"AsyncFunction",
-	"Observable",
-	"Array",
-	"Buffer",
-	"Blob",
-	"Object",
-	"RegExp",
-	"Date",
-	"Error",
-	"Map",
-	"Set",
-	"WeakMap",
-	"WeakSet",
-	"WeakRef",
-	"ArrayBuffer",
-	"SharedArrayBuffer",
-	"DataView",
-	"Promise",
-	"URL",
-	"FormData",
-	"URLSearchParams",
-	"HTMLElement",
-	"NaN",
-	...typedArrayTypeNames
-];
-function isObjectTypeName(name) {
-	return objectTypeNames.includes(name);
-}
-const primitiveTypeNames = [
-	"null",
-	"undefined",
-	"string",
-	"number",
-	"bigint",
-	"boolean",
-	"symbol"
-];
-function isPrimitiveTypeName(name) {
-	return primitiveTypeNames.includes(name);
-}
-[...objectTypeNames, ...primitiveTypeNames];
-const getObjectType = (value) => {
-	const objectTypeName = Object.prototype.toString.call(value).slice(8, -1);
-	if (/HTML\w+Element/.test(objectTypeName) && isHtmlElement(value)) return "HTMLElement";
-	if (isObjectTypeName(objectTypeName)) return objectTypeName;
-};
-function detect(value) {
-	if (value === null) return "null";
-	switch (typeof value) {
-		case "undefined": return "undefined";
-		case "string": return "string";
-		case "number": return Number.isNaN(value) ? "NaN" : "number";
-		case "boolean": return "boolean";
-		case "function": return "Function";
-		case "bigint": return "bigint";
-		case "symbol": return "symbol";
-		default:
-	}
-	if (isObservable(value)) return "Observable";
-	if (isArray(value)) return "Array";
-	if (isBuffer(value)) return "Buffer";
-	const tagType = getObjectType(value);
-	if (tagType && tagType !== "Object") return tagType;
-	if (hasPromiseApi(value)) return "Promise";
-	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 hasPromiseApi(value) {
-	return isFunction(value?.then) && isFunction(value?.catch);
-}
-const is = Object.assign(detect, {
-	all: isAll,
-	any: isAny,
-	array: isArray,
-	arrayBuffer: isArrayBuffer,
-	arrayLike: isArrayLike,
-	asyncFunction: isAsyncFunction,
-	asyncGenerator: isAsyncGenerator,
-	asyncGeneratorFunction: isAsyncGeneratorFunction,
-	asyncIterable: isAsyncIterable,
-	bigint: isBigint,
-	bigInt64Array: isBigInt64Array,
-	bigUint64Array: isBigUint64Array,
-	blob: isBlob,
-	boolean: isBoolean,
-	boundFunction: isBoundFunction,
-	buffer: isBuffer,
-	class: isClass,
-	dataView: isDataView,
-	date: isDate,
-	detect,
-	directInstanceOf: isDirectInstanceOf,
-	emptyArray: isEmptyArray,
-	emptyMap: isEmptyMap,
-	emptyObject: isEmptyObject,
-	emptySet: isEmptySet,
-	emptyString: isEmptyString,
-	emptyStringOrWhitespace: isEmptyStringOrWhitespace,
-	enumCase: isEnumCase,
-	error: isError,
-	evenInteger: isEvenInteger,
-	falsy: isFalsy,
-	float32Array: isFloat32Array,
-	float64Array: isFloat64Array,
-	formData: isFormData,
-	function: isFunction,
-	generator: isGenerator,
-	generatorFunction: isGeneratorFunction,
-	htmlElement: isHtmlElement,
-	infinite: isInfinite,
-	inRange: isInRange,
-	int16Array: isInt16Array,
-	int32Array: isInt32Array,
-	int8Array: isInt8Array,
-	integer: isInteger,
-	iterable: isIterable,
-	map: isMap,
-	nan: isNan,
-	nativePromise: isNativePromise,
-	negativeNumber: isNegativeNumber,
-	nodeStream: isNodeStream,
-	nonEmptyArray: isNonEmptyArray,
-	nonEmptyMap: isNonEmptyMap,
-	nonEmptyObject: isNonEmptyObject,
-	nonEmptySet: isNonEmptySet,
-	nonEmptyString: isNonEmptyString,
-	nonEmptyStringAndNotWhitespace: isNonEmptyStringAndNotWhitespace,
-	null: isNull,
-	nullOrUndefined: isNullOrUndefined,
-	number: isNumber,
-	numericString: isNumericString,
-	object: isObject,
-	observable: isObservable,
-	oddInteger: isOddInteger,
-	plainObject: isPlainObject,
-	positiveNumber: isPositiveNumber,
-	primitive: isPrimitive,
-	promise: isPromise,
-	propertyKey: isPropertyKey,
-	regExp: isRegExp,
-	safeInteger: isSafeInteger,
-	set: isSet,
-	sharedArrayBuffer: isSharedArrayBuffer,
-	string: isString,
-	symbol: isSymbol,
-	truthy: isTruthy,
-	tupleLike: isTupleLike,
-	typedArray: isTypedArray,
-	uint16Array: isUint16Array,
-	uint32Array: isUint32Array,
-	uint8Array: isUint8Array,
-	uint8ClampedArray: isUint8ClampedArray,
-	undefined: isUndefined,
-	urlInstance: isUrlInstance,
-	urlSearchParams: isUrlSearchParams,
-	urlString: isUrlString,
-	optional: isOptional,
-	validDate: isValidDate,
-	validLength: isValidLength,
-	weakMap: isWeakMap,
-	weakRef: isWeakRef,
-	weakSet: isWeakSet,
-	whitespaceString: isWhitespaceString
-});
-function isAbsoluteModule2(remainder) {
-	return (value) => isInteger(value) && Math.abs(value % 2) === remainder;
-}
-function isAll(predicate, ...values) {
-	return predicateOnArray(Array.prototype.every, predicate, values);
-}
-function isAny(predicate, ...values) {
-	return (isArray(predicate) ? predicate : [predicate]).some((singlePredicate) => predicateOnArray(Array.prototype.some, singlePredicate, values));
-}
-function isOptional(value, predicate) {
-	return isUndefined(value) || predicate(value);
-}
-function isArray(value, assertion) {
-	if (!Array.isArray(value)) return false;
-	if (!isFunction(assertion)) return true;
-	return value.every((element) => assertion(element));
-}
-function isArrayBuffer(value) {
-	return getObjectType(value) === "ArrayBuffer";
-}
-function isArrayLike(value) {
-	return !isNullOrUndefined(value) && !isFunction(value) && isValidLength(value.length);
-}
-function isAsyncFunction(value) {
-	return getObjectType(value) === "AsyncFunction";
-}
-function isAsyncGenerator(value) {
-	return isAsyncIterable(value) && isFunction(value.next) && isFunction(value.throw);
-}
-function isAsyncGeneratorFunction(value) {
-	return getObjectType(value) === "AsyncGeneratorFunction";
-}
-function isAsyncIterable(value) {
-	return isFunction(value?.[Symbol.asyncIterator]);
-}
-function isBigint(value) {
-	return typeof value === "bigint";
-}
-function isBigInt64Array(value) {
-	return getObjectType(value) === "BigInt64Array";
-}
-function isBigUint64Array(value) {
-	return getObjectType(value) === "BigUint64Array";
-}
-function isBlob(value) {
-	return getObjectType(value) === "Blob";
-}
-function isBoolean(value) {
-	return value === true || value === false;
-}
-function isBoundFunction(value) {
-	return isFunction(value) && !Object.hasOwn(value, "prototype");
-}
-/**
-Note: [Prefer using `Uint8Array` instead of `Buffer`.](https://sindresorhus.com/blog/goodbye-nodejs-buffer)
-*/
-function isBuffer(value) {
-	return value?.constructor?.isBuffer?.(value) ?? false;
-}
-function isClass(value) {
-	return isFunction(value) && /^class(\s+|{)/.test(value.toString());
-}
-function isDataView(value) {
-	return getObjectType(value) === "DataView";
-}
-function isDate(value) {
-	return getObjectType(value) === "Date";
-}
-function isDirectInstanceOf(instance, class_) {
-	if (instance === void 0 || instance === null) return false;
-	return Object.getPrototypeOf(instance) === class_.prototype;
-}
-function isEmptyArray(value) {
-	return isArray(value) && value.length === 0;
-}
-function isEmptyMap(value) {
-	return isMap(value) && value.size === 0;
-}
-function isEmptyObject(value) {
-	return isObject(value) && !isMap(value) && !isSet(value) && Object.keys(value).length === 0;
-}
-function isEmptySet(value) {
-	return isSet(value) && value.size === 0;
-}
-function isEmptyString(value) {
-	return isString(value) && value.length === 0;
-}
-function isEmptyStringOrWhitespace(value) {
-	return isEmptyString(value) || isWhitespaceString(value);
-}
-function isEnumCase(value, targetEnum) {
-	return Object.values(targetEnum).includes(value);
-}
-function isError(value) {
-	return getObjectType(value) === "Error";
-}
-function isEvenInteger(value) {
-	return isAbsoluteModule2(0)(value);
-}
-function isFalsy(value) {
-	return !value;
-}
-function isFloat32Array(value) {
-	return getObjectType(value) === "Float32Array";
-}
-function isFloat64Array(value) {
-	return getObjectType(value) === "Float64Array";
-}
-function isFormData(value) {
-	return getObjectType(value) === "FormData";
-}
-function isFunction(value) {
-	return typeof value === "function";
-}
-function isGenerator(value) {
-	return isIterable(value) && isFunction(value?.next) && isFunction(value?.throw);
-}
-function isGeneratorFunction(value) {
-	return getObjectType(value) === "GeneratorFunction";
-}
-const NODE_TYPE_ELEMENT = 1;
-const DOM_PROPERTIES_TO_CHECK = [
-	"innerHTML",
-	"ownerDocument",
-	"style",
-	"attributes",
-	"nodeValue"
-];
-function isHtmlElement(value) {
-	return isObject(value) && value.nodeType === NODE_TYPE_ELEMENT && isString(value.nodeName) && !isPlainObject(value) && DOM_PROPERTIES_TO_CHECK.every((property) => property in value);
-}
-function isInfinite(value) {
-	return value === Number.POSITIVE_INFINITY || value === Number.NEGATIVE_INFINITY;
-}
-function isInRange(value, range) {
-	if (isNumber(range)) return value >= Math.min(0, range) && value <= Math.max(range, 0);
-	if (isArray(range) && range.length === 2) return value >= Math.min(...range) && value <= Math.max(...range);
-	throw new TypeError(`Invalid range: ${JSON.stringify(range)}`);
-}
-function isInt16Array(value) {
-	return getObjectType(value) === "Int16Array";
-}
-function isInt32Array(value) {
-	return getObjectType(value) === "Int32Array";
-}
-function isInt8Array(value) {
-	return getObjectType(value) === "Int8Array";
-}
-function isInteger(value) {
-	return Number.isInteger(value);
-}
-function isIterable(value) {
-	return isFunction(value?.[Symbol.iterator]);
-}
-function isMap(value) {
-	return getObjectType(value) === "Map";
-}
-function isNan(value) {
-	return Number.isNaN(value);
-}
-function isNativePromise(value) {
-	return getObjectType(value) === "Promise";
-}
-function isNegativeNumber(value) {
-	return isNumber(value) && value < 0;
-}
-function isNodeStream(value) {
-	return isObject(value) && isFunction(value.pipe) && !isObservable(value);
-}
-function isNonEmptyArray(value) {
-	return isArray(value) && value.length > 0;
-}
-function isNonEmptyMap(value) {
-	return isMap(value) && value.size > 0;
-}
-function isNonEmptyObject(value) {
-	return isObject(value) && !isMap(value) && !isSet(value) && Object.keys(value).length > 0;
-}
-function isNonEmptySet(value) {
-	return isSet(value) && value.size > 0;
-}
-function isNonEmptyString(value) {
-	return isString(value) && value.length > 0;
-}
-function isNonEmptyStringAndNotWhitespace(value) {
-	return isString(value) && !isEmptyStringOrWhitespace(value);
-}
-function isNull(value) {
-	return value === null;
-}
-function isNullOrUndefined(value) {
-	return isNull(value) || isUndefined(value);
-}
-function isNumber(value) {
-	return typeof value === "number" && !Number.isNaN(value);
-}
-function isNumericString(value) {
-	return isString(value) && !isEmptyStringOrWhitespace(value) && !Number.isNaN(Number(value));
-}
-function isObject(value) {
-	return !isNull(value) && (typeof value === "object" || isFunction(value));
-}
-function isObservable(value) {
-	if (!value) return false;
-	if (Symbol.observable !== void 0 && value === value[Symbol.observable]?.()) return true;
-	if (value === value["@@observable"]?.()) return true;
-	return false;
-}
-function isOddInteger(value) {
-	return isAbsoluteModule2(1)(value);
-}
-function isPlainObject(value) {
-	if (typeof value !== "object" || value === null) return false;
-	const prototype = Object.getPrototypeOf(value);
-	return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
-}
-function isPositiveNumber(value) {
-	return isNumber(value) && value > 0;
-}
-function isPrimitive(value) {
-	return isNull(value) || isPrimitiveTypeName(typeof value);
-}
-function isPromise(value) {
-	return isNativePromise(value) || hasPromiseApi(value);
-}
-function isPropertyKey(value) {
-	return isAny([
-		isString,
-		isNumber,
-		isSymbol
-	], value);
-}
-function isRegExp(value) {
-	return getObjectType(value) === "RegExp";
-}
-function isSafeInteger(value) {
-	return Number.isSafeInteger(value);
-}
-function isSet(value) {
-	return getObjectType(value) === "Set";
-}
-function isSharedArrayBuffer(value) {
-	return getObjectType(value) === "SharedArrayBuffer";
-}
-function isString(value) {
-	return typeof value === "string";
-}
-function isSymbol(value) {
-	return typeof value === "symbol";
-}
-function isTruthy(value) {
-	return Boolean(value);
-}
-function isTupleLike(value, guards) {
-	if (isArray(guards) && isArray(value) && guards.length === value.length) return guards.every((guard, index) => guard(value[index]));
-	return false;
-}
-function isTypedArray(value) {
-	return isTypedArrayName(getObjectType(value));
-}
-function isUint16Array(value) {
-	return getObjectType(value) === "Uint16Array";
-}
-function isUint32Array(value) {
-	return getObjectType(value) === "Uint32Array";
-}
-function isUint8Array(value) {
-	return getObjectType(value) === "Uint8Array";
-}
-function isUint8ClampedArray(value) {
-	return getObjectType(value) === "Uint8ClampedArray";
-}
-function isUndefined(value) {
-	return value === void 0;
-}
-function isUrlInstance(value) {
-	return getObjectType(value) === "URL";
-}
-function isUrlSearchParams(value) {
-	return getObjectType(value) === "URLSearchParams";
-}
-function isUrlString(value) {
-	if (!isString(value)) return false;
-	try {
-		new URL(value);
-		return true;
-	} catch {
-		return false;
-	}
-}
-function isValidDate(value) {
-	return isDate(value) && !isNan(Number(value));
-}
-function isValidLength(value) {
-	return isSafeInteger(value) && value >= 0;
-}
-function isWeakMap(value) {
-	return getObjectType(value) === "WeakMap";
-}
-function isWeakRef(value) {
-	return getObjectType(value) === "WeakRef";
-}
-function isWeakSet(value) {
-	return getObjectType(value) === "WeakSet";
-}
-function isWhitespaceString(value) {
-	return isString(value) && /^\s+$/.test(value);
-}
-function predicateOnArray(method, predicate, values) {
-	if (!isFunction(predicate)) throw new TypeError(`Invalid predicate: ${JSON.stringify(predicate)}`);
-	if (values.length === 0) throw new TypeError("Invalid number of values");
-	return method.call(values, predicate);
-}
-const andFormatter = new Intl.ListFormat("en", {
-	style: "long",
-	type: "conjunction"
-});
-const orFormatter = new Intl.ListFormat("en", {
-	style: "long",
-	type: "disjunction"
-});
-const methodTypeMap = {
-	isArray: "Array",
-	isArrayBuffer: "ArrayBuffer",
-	isArrayLike: "array-like",
-	isAsyncFunction: "AsyncFunction",
-	isAsyncGenerator: "AsyncGenerator",
-	isAsyncGeneratorFunction: "AsyncGeneratorFunction",
-	isAsyncIterable: "AsyncIterable",
-	isBigint: "bigint",
-	isBigInt64Array: "BigInt64Array",
-	isBigUint64Array: "BigUint64Array",
-	isBlob: "Blob",
-	isBoolean: "boolean",
-	isBoundFunction: "Function",
-	isBuffer: "Buffer",
-	isClass: "Class",
-	isDataView: "DataView",
-	isDate: "Date",
-	isDirectInstanceOf: "T",
-	isEmptyArray: "empty array",
-	isEmptyMap: "empty map",
-	isEmptyObject: "empty object",
-	isEmptySet: "empty set",
-	isEmptyString: "empty string",
-	isEmptyStringOrWhitespace: "empty string or whitespace",
-	isEnumCase: "EnumCase",
-	isError: "Error",
-	isEvenInteger: "even integer",
-	isFalsy: "falsy",
-	isFloat32Array: "Float32Array",
-	isFloat64Array: "Float64Array",
-	isFormData: "FormData",
-	isFunction: "Function",
-	isGenerator: "Generator",
-	isGeneratorFunction: "GeneratorFunction",
-	isHtmlElement: "HTMLElement",
-	isInfinite: "infinite number",
-	isInRange: "in range",
-	isInt16Array: "Int16Array",
-	isInt32Array: "Int32Array",
-	isInt8Array: "Int8Array",
-	isInteger: "integer",
-	isIterable: "Iterable",
-	isMap: "Map",
-	isNan: "NaN",
-	isNativePromise: "native Promise",
-	isNegativeNumber: "negative number",
-	isNodeStream: "Node.js Stream",
-	isNonEmptyArray: "non-empty array",
-	isNonEmptyMap: "non-empty map",
-	isNonEmptyObject: "non-empty object",
-	isNonEmptySet: "non-empty set",
-	isNonEmptyString: "non-empty string",
-	isNonEmptyStringAndNotWhitespace: "non-empty string and not whitespace",
-	isNull: "null",
-	isNullOrUndefined: "null or undefined",
-	isNumber: "number",
-	isNumericString: "string with a number",
-	isObject: "Object",
-	isObservable: "Observable",
-	isOddInteger: "odd integer",
-	isPlainObject: "plain object",
-	isPositiveNumber: "positive number",
-	isPrimitive: "primitive",
-	isPromise: "Promise",
-	isPropertyKey: "PropertyKey",
-	isRegExp: "RegExp",
-	isSafeInteger: "integer",
-	isSet: "Set",
-	isSharedArrayBuffer: "SharedArrayBuffer",
-	isString: "string",
-	isSymbol: "symbol",
-	isTruthy: "truthy",
-	isTupleLike: "tuple-like",
-	isTypedArray: "TypedArray",
-	isUint16Array: "Uint16Array",
-	isUint32Array: "Uint32Array",
-	isUint8Array: "Uint8Array",
-	isUint8ClampedArray: "Uint8ClampedArray",
-	isUndefined: "undefined",
-	isUrlInstance: "URL",
-	isUrlSearchParams: "URLSearchParams",
-	isUrlString: "string with a URL",
-	isValidDate: "valid Date",
-	isValidLength: "valid length",
-	isWeakMap: "WeakMap",
-	isWeakRef: "WeakRef",
-	isWeakSet: "WeakSet",
-	isWhitespaceString: "whitespace string"
-};
-const isMethodNames = keysOf(methodTypeMap);
-
-//#endregion
-export { isObject, isString };
-//# sourceMappingURL=index.js.map