immosquare-cleaner 0.1.35 → 0.1.36

data/node_modules/es-abstract/2024/OrdinaryGetPrototypeOf.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var $getProto = require('../helpers/getProto');
+
+var Type = require('./Type');
+
+// https://262.ecma-international.org/7.0/#sec-ordinarygetprototypeof
+
+module.exports = function OrdinaryGetPrototypeOf(O) {
+	if (Type(O) !== 'Object') {
+		throw new $TypeError('Assertion failed: O must be an Object');
+	}
+	if (!$getProto) {
+		throw new $TypeError('This environment does not support fetching prototypes.');
+	}
+	return $getProto(O);
+};

data/node_modules/es-abstract/2024/OrdinaryHasInstance.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var Get = require('./Get');
+var IsCallable = require('./IsCallable');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-ordinaryhasinstance
+
+module.exports = function OrdinaryHasInstance(C, O) {
+	if (!IsCallable(C)) {
+		return false;
+	}
+	if (Type(O) !== 'Object') {
+		return false;
+	}
+	var P = Get(C, 'prototype');
+	if (Type(P) !== 'Object') {
+		throw new $TypeError('OrdinaryHasInstance called on an object with an invalid prototype property.');
+	}
+	return O instanceof C;
+};

data/node_modules/es-abstract/2024/OrdinaryHasProperty.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var IsPropertyKey = require('./IsPropertyKey');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-ordinaryhasproperty
+
+module.exports = function OrdinaryHasProperty(O, P) {
+	if (Type(O) !== 'Object') {
+		throw new $TypeError('Assertion failed: Type(O) is not Object');
+	}
+	if (!IsPropertyKey(P)) {
+		throw new $TypeError('Assertion failed: P must be a Property Key');
+	}
+	return P in O;
+};

data/node_modules/es-abstract/2024/OrdinaryObjectCreate.js

@@ -0,0 +1,56 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $ObjectCreate = GetIntrinsic('%Object.create%', true);
+var $TypeError = require('es-errors/type');
+var $SyntaxError = require('es-errors/syntax');
+
+var IsArray = require('./IsArray');
+var Type = require('./Type');
+
+var forEach = require('../helpers/forEach');
+
+var SLOT = require('internal-slot');
+
+var hasProto = require('has-proto')();
+
+// https://262.ecma-international.org/11.0/#sec-objectcreate
+
+module.exports = function OrdinaryObjectCreate(proto) {
+	if (proto !== null && Type(proto) !== 'Object') {
+		throw new $TypeError('Assertion failed: `proto` must be null or an object');
+	}
+	var additionalInternalSlotsList = arguments.length < 2 ? [] : arguments[1];
+	if (!IsArray(additionalInternalSlotsList)) {
+		throw new $TypeError('Assertion failed: `additionalInternalSlotsList` must be an Array');
+	}
+
+	// var internalSlotsList = ['[[Prototype]]', '[[Extensible]]']; // step 1
+	// internalSlotsList.push(...additionalInternalSlotsList); // step 2
+	// var O = MakeBasicObject(internalSlotsList); // step 3
+	// setProto(O, proto); // step 4
+	// return O; // step 5
+
+	var O;
+	if ($ObjectCreate) {
+		O = $ObjectCreate(proto);
+	} else if (hasProto) {
+		O = { __proto__: proto };
+	} else {
+		if (proto === null) {
+			throw new $SyntaxError('native Object.create support is required to create null objects');
+		}
+		var T = function T() {};
+		T.prototype = proto;
+		O = new T();
+	}
+
+	if (additionalInternalSlotsList.length > 0) {
+		forEach(additionalInternalSlotsList, function (slot) {
+			SLOT.set(O, slot, void undefined);
+		});
+	}
+
+	return O;
+};

data/node_modules/es-abstract/2024/OrdinarySetPrototypeOf.js

@@ -0,0 +1,50 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var $setProto = require('../helpers/setProto');
+
+var OrdinaryGetPrototypeOf = require('./OrdinaryGetPrototypeOf');
+
+// https://262.ecma-international.org/7.0/#sec-ordinarysetprototypeof
+
+module.exports = function OrdinarySetPrototypeOf(O, V) {
+	if (typeof V !== 'object') {
+		throw new $TypeError('Assertion failed: V must be Object or Null');
+	}
+	/*
+	var extensible = IsExtensible(O);
+	var current = OrdinaryGetPrototypeOf(O);
+	if (SameValue(V, current)) {
+		return true;
+	}
+	if (!extensible) {
+		return false;
+	}
+	*/
+	try {
+		$setProto(O, V);
+	} catch (e) {
+		return false;
+	}
+	return OrdinaryGetPrototypeOf(O) === V;
+	/*
+	var p = V;
+	var done = false;
+	while (!done) {
+		if (p === null) {
+			done = true;
+		} else if (SameValue(p, O)) {
+			return false;
+		} else {
+			if (wat) {
+				done = true;
+			} else {
+				p = p.[[Prototype]];
+			}
+		}
+	}
+	O.[[Prototype]] = V;
+	return true;
+	*/
+};

data/node_modules/es-abstract/2024/OrdinaryToPrimitive.js

@@ -0,0 +1,36 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var Call = require('./Call');
+var Get = require('./Get');
+var IsCallable = require('./IsCallable');
+var Type = require('./Type');
+
+var inspect = require('object-inspect');
+
+// https://262.ecma-international.org/8.0/#sec-ordinarytoprimitive
+
+module.exports = function OrdinaryToPrimitive(O, hint) {
+	if (Type(O) !== 'Object') {
+		throw new $TypeError('Assertion failed: Type(O) is not Object');
+	}
+	if (/* typeof hint !== 'string' || */ hint !== 'string' && hint !== 'number') {
+		throw new $TypeError('Assertion failed: `hint` must be "string" or "number"');
+	}
+
+	var methodNames = hint === 'string' ? ['toString', 'valueOf'] : ['valueOf', 'toString'];
+
+	for (var i = 0; i < methodNames.length; i += 1) {
+		var name = methodNames[i];
+		var method = Get(O, name);
+		if (IsCallable(method)) {
+			var result = Call(method, O);
+			if (Type(result) !== 'Object') {
+				return result;
+			}
+		}
+	}
+
+	throw new $TypeError('No primitive value for ' + inspect(O));
+};

data/node_modules/es-abstract/2024/ParseHexOctet.js

@@ -0,0 +1,43 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $Number = GetIntrinsic('%Number%');
+var $SyntaxError = require('es-errors/syntax');
+var $TypeError = require('es-errors/type');
+
+var IsIntegralNumber = require('./IsIntegralNumber');
+var substring = require('./substring');
+
+var isNaN = require('../helpers/isNaN');
+
+// https://262.ecma-international.org/14.0/#sec-parsehexoctet
+
+module.exports = function ParseHexOctet(string, position) {
+	if (typeof string !== 'string') {
+		throw new $TypeError('Assertion failed: `string` must be a String');
+	}
+	if (!IsIntegralNumber(position) || position < 0) {
+		throw new $TypeError('Assertion failed: `position` must be a nonnegative integer');
+	}
+
+	var len = string.length; // step 1
+	if ((position + 2) > len) { // step 2
+		var error = new $SyntaxError('requested a position on a string that does not contain 2 characters at that position'); // step 2.a
+		return [error]; // step 2.b
+	}
+	var hexDigits = substring(string, position, position + 2); // step 3
+
+	var n = $Number('0x' + hexDigits);
+	if (isNaN(n)) {
+		return [new $SyntaxError('Invalid hexadecimal characters')];
+	}
+	return n;
+
+	/*
+	4. Let _parseResult_ be ParseText(StringToCodePoints(_hexDigits_), |HexDigits[~Sep]|).
+    5. If _parseResult_ is not a Parse Node, return _parseResult_.
+    6. Let _n_ be the unsigned 8-bit value corresponding with the MV of _parseResult_.
+    7. Return _n_.
+    */
+};

data/node_modules/es-abstract/2024/PromiseResolve.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+var callBind = require('call-bind');
+var $SyntaxError = require('es-errors/syntax');
+
+var $resolve = GetIntrinsic('%Promise.resolve%', true);
+var $PromiseResolve = $resolve && callBind($resolve);
+
+// https://262.ecma-international.org/9.0/#sec-promise-resolve
+
+module.exports = function PromiseResolve(C, x) {
+	if (!$PromiseResolve) {
+		throw new $SyntaxError('This environment does not support Promises.');
+	}
+	return $PromiseResolve(C, x);
+};
+

data/node_modules/es-abstract/2024/QuoteJSONString.js

@@ -0,0 +1,51 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var callBound = require('call-bind/callBound');
+var forEach = require('../helpers/forEach');
+var isLeadingSurrogate = require('../helpers/isLeadingSurrogate');
+var isTrailingSurrogate = require('../helpers/isTrailingSurrogate');
+
+var $charCodeAt = callBound('String.prototype.charCodeAt');
+
+var StringToCodePoints = require('./StringToCodePoints');
+var UnicodeEscape = require('./UnicodeEscape');
+var UTF16EncodeCodePoint = require('./UTF16EncodeCodePoint');
+
+var hasOwn = require('hasown');
+
+// https://262.ecma-international.org/12.0/#sec-quotejsonstring
+
+var escapes = {
+	'\u0008': '\\b',
+	'\u0009': '\\t',
+	'\u000A': '\\n',
+	'\u000C': '\\f',
+	'\u000D': '\\r',
+	'\u0022': '\\"',
+	'\u005c': '\\\\'
+};
+
+module.exports = function QuoteJSONString(value) {
+	if (typeof value !== 'string') {
+		throw new $TypeError('Assertion failed: `value` must be a String');
+	}
+	var product = '"';
+	if (value) {
+		forEach(StringToCodePoints(value), function (C) {
+			if (hasOwn(escapes, C)) {
+				product += escapes[C];
+			} else {
+				var cCharCode = $charCodeAt(C, 0);
+				if (cCharCode < 0x20 || isLeadingSurrogate(C) || isTrailingSurrogate(C)) {
+					product += UnicodeEscape(C);
+				} else {
+					product += UTF16EncodeCodePoint(cCharCode);
+				}
+			}
+		});
+	}
+	product += '"';
+	return product;
+};

data/node_modules/es-abstract/2024/RawBytesToNumeric.js

@@ -0,0 +1,83 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+var callBound = require('call-bind/callBound');
+
+var $RangeError = require('es-errors/range');
+var $SyntaxError = require('es-errors/syntax');
+var $TypeError = require('es-errors/type');
+var $BigInt = GetIntrinsic('%BigInt%', true);
+
+var hasOwnProperty = require('./HasOwnProperty');
+var IsArray = require('./IsArray');
+var IsBigIntElementType = require('./IsBigIntElementType');
+var IsUnsignedElementType = require('./IsUnsignedElementType');
+
+var bytesAsFloat32 = require('../helpers/bytesAsFloat32');
+var bytesAsFloat64 = require('../helpers/bytesAsFloat64');
+var bytesAsInteger = require('../helpers/bytesAsInteger');
+var every = require('../helpers/every');
+var isByteValue = require('../helpers/isByteValue');
+
+var $reverse = callBound('Array.prototype.reverse');
+var $slice = callBound('Array.prototype.slice');
+
+var keys = require('object-keys');
+
+// https://262.ecma-international.org/15.0/#table-the-typedarray-constructors
+var TypeToSizes = {
+	__proto__: null,
+	INT8: 1,
+	UINT8: 1,
+	UINT8C: 1,
+	INT16: 2,
+	UINT16: 2,
+	INT32: 4,
+	UINT32: 4,
+	BIGINT64: 8,
+	BIGUINT64: 8,
+	FLOAT32: 4,
+	FLOAT64: 8
+};
+
+// https://262.ecma-international.org/15.0/#sec-rawbytestonumeric
+
+module.exports = function RawBytesToNumeric(type, rawBytes, isLittleEndian) {
+	if (!hasOwnProperty(TypeToSizes, type)) {
+		throw new $TypeError('Assertion failed: `type` must be a TypedArray element type: ' + keys(TypeToSizes));
+	}
+	if (!IsArray(rawBytes) || !every(rawBytes, isByteValue)) {
+		throw new $TypeError('Assertion failed: `rawBytes` must be an Array of bytes');
+	}
+	if (typeof isLittleEndian !== 'boolean') {
+		throw new $TypeError('Assertion failed: `isLittleEndian` must be a Boolean');
+	}
+
+	var elementSize = TypeToSizes[type]; // step 1
+
+	if (rawBytes.length !== elementSize) {
+		// this assertion is not in the spec, but it'd be an editorial error if it were ever violated
+		throw new $RangeError('Assertion failed: `rawBytes` must have a length of ' + elementSize + ' for type ' + type);
+	}
+
+	var isBigInt = IsBigIntElementType(type);
+	if (isBigInt && !$BigInt) {
+		throw new $SyntaxError('this environment does not support BigInts');
+	}
+
+	// eslint-disable-next-line no-param-reassign
+	rawBytes = $slice(rawBytes, 0, elementSize);
+	if (!isLittleEndian) {
+		$reverse(rawBytes); // step 2
+	}
+
+	if (type === 'FLOAT32') { // step 3
+		return bytesAsFloat32(rawBytes);
+	}
+
+	if (type === 'FLOAT64') { // step 4
+		return bytesAsFloat64(rawBytes);
+	}
+
+	return bytesAsInteger(rawBytes, elementSize, IsUnsignedElementType(type), isBigInt);
+};

data/node_modules/es-abstract/2024/RegExpCreate.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $RegExp = GetIntrinsic('%RegExp%');
+
+// var RegExpAlloc = require('./RegExpAlloc');
+// var RegExpInitialize = require('./RegExpInitialize');
+var ToString = require('./ToString');
+
+// https://262.ecma-international.org/6.0/#sec-regexpcreate
+
+module.exports = function RegExpCreate(P, F) {
+	// var obj = RegExpAlloc($RegExp);
+	// return RegExpInitialize(obj, P, F);
+
+	// covers spec mechanics; bypass regex brand checking
+	var pattern = typeof P === 'undefined' ? '' : ToString(P);
+	var flags = typeof F === 'undefined' ? '' : ToString(F);
+	return new $RegExp(pattern, flags);
+};

data/node_modules/es-abstract/2024/RegExpExec.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var regexExec = require('call-bind/callBound')('RegExp.prototype.exec');
+
+var Call = require('./Call');
+var Get = require('./Get');
+var IsCallable = require('./IsCallable');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-regexpexec
+
+module.exports = function RegExpExec(R, S) {
+	if (Type(R) !== 'Object') {
+		throw new $TypeError('Assertion failed: `R` must be an Object');
+	}
+	if (typeof S !== 'string') {
+		throw new $TypeError('Assertion failed: `S` must be a String');
+	}
+	var exec = Get(R, 'exec');
+	if (IsCallable(exec)) {
+		var result = Call(exec, R, [S]);
+		if (typeof result === 'object') {
+			return result;
+		}
+		throw new $TypeError('"exec" method must return `null` or an Object');
+	}
+	return regexExec(R, S);
+};

data/node_modules/es-abstract/2024/RegExpHasFlag.js

@@ -0,0 +1,38 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+var callBound = require('call-bind/callBound');
+
+var $TypeError = require('es-errors/type');
+var $RegExpPrototype = GetIntrinsic('%RegExp.prototype%');
+
+var SameValue = require('./SameValue');
+var Type = require('./Type');
+
+var $indexOf = callBound('String.prototype.indexOf');
+
+var hasRegExpMatcher = require('is-regex');
+var getFlags = require('regexp.prototype.flags');
+
+// https://262.ecma-international.org/13.0/#sec-regexphasflag
+
+module.exports = function RegExpHasFlag(R, codeUnit) {
+	if (typeof codeUnit !== 'string' || codeUnit.length !== 1) {
+		throw new $TypeError('Assertion failed: `string` must be a code unit - a String of length 1');
+	}
+
+	if (Type(R) !== 'Object') {
+		throw new $TypeError('Assertion failed: Type(R) is not Object');
+	}
+
+	if (!hasRegExpMatcher(R)) { // step 2
+		if (SameValue(R, $RegExpPrototype)) {
+			return void undefined; // step 2.a
+		}
+		throw new $TypeError('`R` must be a RegExp object'); // step 2.b
+	}
+
+	var flags = getFlags(R); // step 3
+
+	return $indexOf(flags, codeUnit) > -1; // steps 4-5
+};

data/node_modules/es-abstract/2024/RequireObjectCoercible.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('es-object-atoms/RequireObjectCoercible');

data/node_modules/es-abstract/2024/SameValue.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var $isNaN = require('../helpers/isNaN');
+
+// http://262.ecma-international.org/5.1/#sec-9.12
+
+module.exports = function SameValue(x, y) {
+	if (x === y) { // 0 === -0, but they are not identical.
+		if (x === 0) { return 1 / x === 1 / y; }
+		return true;
+	}
+	return $isNaN(x) && $isNaN(y);
+};

data/node_modules/es-abstract/2024/SameValueNonNumber.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var SameValue = require('./SameValue');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/14.0/#sec-samevaluenonnumeric
+
+module.exports = function SameValueNonNumber(x, y) {
+	var xType = Type(x);
+	if (xType === 'Number') {
+		throw new $TypeError('Assertion failed: SameValueNonNumber does not accept Number values');
+	}
+	if (xType !== Type(y)) {
+		throw new $TypeError('SameValueNonNumber requires two non-Number values of the same type.');
+	}
+	return SameValue(x, y);
+};

data/node_modules/es-abstract/2024/SameValueZero.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var $isNaN = require('../helpers/isNaN');
+
+// https://262.ecma-international.org/6.0/#sec-samevaluezero
+
+module.exports = function SameValueZero(x, y) {
+	return (x === y) || ($isNaN(x) && $isNaN(y));
+};

data/node_modules/es-abstract/2024/SecFromTime.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var floor = require('./floor');
+var modulo = require('./modulo');
+
+var timeConstants = require('../helpers/timeConstants');
+var msPerSecond = timeConstants.msPerSecond;
+var SecondsPerMinute = timeConstants.SecondsPerMinute;
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.10
+
+module.exports = function SecFromTime(t) {
+	return modulo(floor(t / msPerSecond), SecondsPerMinute);
+};

data/node_modules/es-abstract/2024/Set.js

@@ -0,0 +1,45 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var IsPropertyKey = require('./IsPropertyKey');
+var SameValue = require('./SameValue');
+var Type = require('./Type');
+
+// IE 9 does not throw in strict mode when writability/configurability/extensibility is violated
+var noThrowOnStrictViolation = (function () {
+	try {
+		delete [].length;
+		return true;
+	} catch (e) {
+		return false;
+	}
+}());
+
+// https://262.ecma-international.org/6.0/#sec-set-o-p-v-throw
+
+module.exports = function Set(O, P, V, Throw) {
+	if (Type(O) !== 'Object') {
+		throw new $TypeError('Assertion failed: `O` must be an Object');
+	}
+	if (!IsPropertyKey(P)) {
+		throw new $TypeError('Assertion failed: `P` must be a Property Key');
+	}
+	if (typeof Throw !== 'boolean') {
+		throw new $TypeError('Assertion failed: `Throw` must be a Boolean');
+	}
+	if (Throw) {
+		O[P] = V; // eslint-disable-line no-param-reassign
+		if (noThrowOnStrictViolation && !SameValue(O[P], V)) {
+			throw new $TypeError('Attempted to assign to readonly property.');
+		}
+		return true;
+	}
+	try {
+		O[P] = V; // eslint-disable-line no-param-reassign
+		return noThrowOnStrictViolation ? SameValue(O[P], V) : true;
+	} catch (e) {
+		return false;
+	}
+
+};

data/node_modules/es-abstract/2024/SetFunctionLength.js

@@ -0,0 +1,29 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var DefinePropertyOrThrow = require('./DefinePropertyOrThrow');
+var HasOwnProperty = require('./HasOwnProperty');
+var IsExtensible = require('./IsExtensible');
+
+var isInteger = require('../helpers/isInteger');
+
+// https://262.ecma-international.org/12.0/#sec-setfunctionlength
+
+module.exports = function SetFunctionLength(F, length) {
+	if (typeof F !== 'function' || !IsExtensible(F) || HasOwnProperty(F, 'length')) {
+		throw new $TypeError('Assertion failed: `F` must be an extensible function and lack an own `length` property');
+	}
+	if (typeof length !== 'number') {
+		throw new $TypeError('Assertion failed: `length` must be a Number');
+	}
+	if (length !== Infinity && (!isInteger(length) || length < 0)) {
+		throw new $TypeError('Assertion failed: `length` must be ∞, or an integer >= 0');
+	}
+	return DefinePropertyOrThrow(F, 'length', {
+		'[[Configurable]]': true,
+		'[[Enumerable]]': false,
+		'[[Value]]': length,
+		'[[Writable]]': false
+	});
+};