jai shree ram

node_modules/es-abstract/helpers/DefineOwnProperty.js

@@ -0,0 +1,55 @@
+'use strict';
+
+var hasPropertyDescriptors = require('has-property-descriptors');
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $defineProperty = hasPropertyDescriptors() && GetIntrinsic('%Object.defineProperty%', true);
+
+var hasArrayLengthDefineBug = hasPropertyDescriptors.hasArrayLengthDefineBug();
+
+// eslint-disable-next-line global-require
+var isArray = hasArrayLengthDefineBug && require('../helpers/IsArray');
+
+var callBound = require('call-bind/callBound');
+
+var $isEnumerable = callBound('Object.prototype.propertyIsEnumerable');
+
+// eslint-disable-next-line max-params
+module.exports = function DefineOwnProperty(IsDataDescriptor, SameValue, FromPropertyDescriptor, O, P, desc) {
+	if (!$defineProperty) {
+		if (!IsDataDescriptor(desc)) {
+			// ES3 does not support getters/setters
+			return false;
+		}
+		if (!desc['[[Configurable]]'] || !desc['[[Writable]]']) {
+			return false;
+		}
+
+		// fallback for ES3
+		if (P in O && $isEnumerable(O, P) !== !!desc['[[Enumerable]]']) {
+			// a non-enumerable existing property
+			return false;
+		}
+
+		// property does not exist at all, or exists but is enumerable
+		var V = desc['[[Value]]'];
+		// eslint-disable-next-line no-param-reassign
+		O[P] = V; // will use [[Define]]
+		return SameValue(O[P], V);
+	}
+	if (
+		hasArrayLengthDefineBug
+		&& P === 'length'
+		&& '[[Value]]' in desc
+		&& isArray(O)
+		&& O.length !== desc['[[Value]]']
+	) {
+		// eslint-disable-next-line no-param-reassign
+		O.length = desc['[[Value]]'];
+		return O.length === desc['[[Value]]'];
+	}
+
+	$defineProperty(O, P, FromPropertyDescriptor(desc));
+	return true;
+};

node_modules/es-abstract/helpers/IsArray.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $Array = GetIntrinsic('%Array%');
+
+// eslint-disable-next-line global-require
+var toStr = !$Array.isArray && require('call-bind/callBound')('Object.prototype.toString');
+
+module.exports = $Array.isArray || function IsArray(argument) {
+	return toStr(argument) === '[object Array]';
+};

node_modules/es-abstract/helpers/OwnPropertyKeys.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var callBind = require('call-bind');
+var callBound = require('call-bind/callBound');
+
+var $ownKeys = GetIntrinsic('%Reflect.ownKeys%', true);
+var $pushApply = callBind.apply(GetIntrinsic('%Array.prototype.push%'));
+var $SymbolValueOf = callBound('Symbol.prototype.valueOf', true);
+var $gOPN = GetIntrinsic('%Object.getOwnPropertyNames%', true);
+var $gOPS = $SymbolValueOf ? GetIntrinsic('%Object.getOwnPropertySymbols%') : null;
+
+var keys = require('object-keys');
+
+module.exports = $ownKeys || function OwnPropertyKeys(source) {
+	var ownKeys = ($gOPN || keys)(source);
+	if ($gOPS) {
+		$pushApply(ownKeys, $gOPS(source));
+	}
+	return ownKeys;
+};

node_modules/es-abstract/helpers/assertRecord.js

@@ -0,0 +1,71 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+var $SyntaxError = GetIntrinsic('%SyntaxError%');
+
+var has = require('has');
+
+var isMatchRecord = require('./isMatchRecord');
+
+var predicates = {
+	// https://262.ecma-international.org/6.0/#sec-property-descriptor-specification-type
+	'Property Descriptor': function isPropertyDescriptor(Desc) {
+		var allowed = {
+			'[[Configurable]]': true,
+			'[[Enumerable]]': true,
+			'[[Get]]': true,
+			'[[Set]]': true,
+			'[[Value]]': true,
+			'[[Writable]]': true
+		};
+
+		if (!Desc) {
+			return false;
+		}
+		for (var key in Desc) { // eslint-disable-line
+			if (has(Desc, key) && !allowed[key]) {
+				return false;
+			}
+		}
+
+		var isData = has(Desc, '[[Value]]');
+		var IsAccessor = has(Desc, '[[Get]]') || has(Desc, '[[Set]]');
+		if (isData && IsAccessor) {
+			throw new $TypeError('Property Descriptors may not be both accessor and data descriptors');
+		}
+		return true;
+	},
+	// https://262.ecma-international.org/13.0/#sec-match-records
+	'Match Record': isMatchRecord,
+	'Iterator Record': function isIteratorRecord(value) {
+		return has(value, '[[Iterator]]') && has(value, '[[NextMethod]]') && has(value, '[[Done]]');
+	},
+	'PromiseCapability Record': function isPromiseCapabilityRecord(value) {
+		return !!value
+			&& has(value, '[[Resolve]]')
+			&& typeof value['[[Resolve]]'] === 'function'
+			&& has(value, '[[Reject]]')
+			&& typeof value['[[Reject]]'] === 'function'
+			&& has(value, '[[Promise]]')
+			&& value['[[Promise]]']
+			&& typeof value['[[Promise]]'].then === 'function';
+	},
+	'AsyncGeneratorRequest Record': function isAsyncGeneratorRequestRecord(value) {
+		return !!value
+			&& has(value, '[[Completion]]') // TODO: confirm is a completion record
+			&& has(value, '[[Capability]]')
+			&& predicates['PromiseCapability Record'](value['[[Capability]]']);
+	}
+};
+
+module.exports = function assertRecord(Type, recordType, argumentName, value) {
+	var predicate = predicates[recordType];
+	if (typeof predicate !== 'function') {
+		throw new $SyntaxError('unknown record type: ' + recordType);
+	}
+	if (Type(value) !== 'Object' || !predicate(value)) {
+		throw new $TypeError(argumentName + ' must be a ' + recordType);
+	}
+};

node_modules/es-abstract/helpers/assign.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var has = require('has');
+
+var $assign = GetIntrinsic('%Object.assign%', true);
+
+module.exports = function assign(target, source) {
+	if ($assign) {
+		return $assign(target, source);
+	}
+
+	// eslint-disable-next-line no-restricted-syntax
+	for (var key in source) {
+		if (has(source, key)) {
+			// eslint-disable-next-line no-param-reassign
+			target[key] = source[key];
+		}
+	}
+	return target;
+};

node_modules/es-abstract/helpers/callBind.js

@@ -0,0 +1,5 @@
+'use strict';
+
+// TODO; semver-major: remove
+
+module.exports = require('call-bind');

node_modules/es-abstract/helpers/callBound.js

@@ -0,0 +1,5 @@
+'use strict';
+
+// TODO; semver-major: remove
+
+module.exports = require('call-bind/callBound');

node_modules/es-abstract/helpers/every.js

@@ -0,0 +1,10 @@
+'use strict';
+
+module.exports = function every(array, predicate) {
+	for (var i = 0; i < array.length; i += 1) {
+		if (!predicate(array[i], i, array)) {
+			return false;
+		}
+	}
+	return true;
+};

node_modules/es-abstract/helpers/forEach.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports = function forEach(array, callback) {
+	for (var i = 0; i < array.length; i += 1) {
+		callback(array[i], i, array); // eslint-disable-line callback-return
+	}
+};

node_modules/es-abstract/helpers/fromPropertyDescriptor.js

@@ -0,0 +1,27 @@
+'use strict';
+
+module.exports = function fromPropertyDescriptor(Desc) {
+	if (typeof Desc === 'undefined') {
+		return Desc;
+	}
+	var obj = {};
+	if ('[[Value]]' in Desc) {
+		obj.value = Desc['[[Value]]'];
+	}
+	if ('[[Writable]]' in Desc) {
+		obj.writable = !!Desc['[[Writable]]'];
+	}
+	if ('[[Get]]' in Desc) {
+		obj.get = Desc['[[Get]]'];
+	}
+	if ('[[Set]]' in Desc) {
+		obj.set = Desc['[[Set]]'];
+	}
+	if ('[[Enumerable]]' in Desc) {
+		obj.enumerable = !!Desc['[[Enumerable]]'];
+	}
+	if ('[[Configurable]]' in Desc) {
+		obj.configurable = !!Desc['[[Configurable]]'];
+	}
+	return obj;
+};

node_modules/es-abstract/helpers/getInferredName.js

@@ -0,0 +1,4 @@
+'use strict';
+
+// TODO: remove, semver-major
+module.exports = require('get-symbol-description/getInferredName');

node_modules/es-abstract/helpers/getIteratorMethod.js

@@ -0,0 +1,47 @@
+'use strict';
+
+var hasSymbols = require('has-symbols')();
+var GetIntrinsic = require('get-intrinsic');
+var callBound = require('call-bind/callBound');
+var isString = require('is-string');
+
+var $iterator = GetIntrinsic('%Symbol.iterator%', true);
+var $stringSlice = callBound('String.prototype.slice');
+var $String = GetIntrinsic('%String%');
+
+module.exports = function getIteratorMethod(ES, iterable) {
+	var usingIterator;
+	if (hasSymbols) {
+		usingIterator = ES.GetMethod(iterable, $iterator);
+	} else if (ES.IsArray(iterable)) {
+		usingIterator = function () {
+			var i = -1;
+			var arr = this; // eslint-disable-line no-invalid-this
+			return {
+				next: function () {
+					i += 1;
+					return {
+						done: i >= arr.length,
+						value: arr[i]
+					};
+				}
+			};
+		};
+	} else if (isString(iterable)) {
+		usingIterator = function () {
+			var i = 0;
+			return {
+				next: function () {
+					var nextIndex = ES.AdvanceStringIndex($String(iterable), i, true);
+					var value = $stringSlice(iterable, i, nextIndex);
+					i = nextIndex;
+					return {
+						done: nextIndex > iterable.length,
+						value: value
+					};
+				}
+			};
+		};
+	}
+	return usingIterator;
+};

node_modules/es-abstract/helpers/getOwnPropertyDescriptor.js

@@ -0,0 +1,5 @@
+'use strict';
+
+// TODO: remove, semver-major
+
+module.exports = require('gopd');

node_modules/es-abstract/helpers/getProto.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var originalGetProto = GetIntrinsic('%Object.getPrototypeOf%', true);
+
+var hasProto = require('has-proto')();
+
+module.exports = originalGetProto || (
+	hasProto
+		? function (O) {
+			return O.__proto__; // eslint-disable-line no-proto
+		}
+		: null
+);

node_modules/es-abstract/helpers/getSymbolDescription.js

@@ -0,0 +1,4 @@
+'use strict';
+
+// TODO: remove, semver-major
+module.exports = require('get-symbol-description');

node_modules/es-abstract/helpers/isAbstractClosure.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var functionName = require('function.prototype.name');
+
+var anon = functionName(function () {});
+
+module.exports = function isAbstractClosure(x) {
+	return typeof x === 'function' && (!x.prototype || functionName(x) === anon);
+};

node_modules/es-abstract/helpers/isByteValue.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = function isByteValue(value) {
+	return typeof value === 'number' && value >= 0 && value <= 255 && (value | 0) === value;
+};

node_modules/es-abstract/helpers/isCodePoint.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = function isCodePoint(cp) {
+	return typeof cp === 'number' && cp >= 0 && cp <= 0x10FFFF && (cp | 0) === cp;
+};

node_modules/es-abstract/helpers/isFinite.js

@@ -0,0 +1,5 @@
+'use strict';
+
+var $isNaN = require('./isNaN');
+
+module.exports = function (x) { return (typeof x === 'number' || typeof x === 'bigint') && !$isNaN(x) && x !== Infinity && x !== -Infinity; };

node_modules/es-abstract/helpers/isFullyPopulatedPropertyDescriptor.js

@@ -0,0 +1,9 @@
+'use strict';
+
+module.exports = function isFullyPopulatedPropertyDescriptor(ES, Desc) {
+	return !!Desc
+		&& typeof Desc === 'object'
+		&& '[[Enumerable]]' in Desc
+		&& '[[Configurable]]' in Desc
+		&& (ES.IsAccessorDescriptor(Desc) || ES.IsDataDescriptor(Desc));
+};

node_modules/es-abstract/helpers/isLeadingSurrogate.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = function isLeadingSurrogate(charCode) {
+	return typeof charCode === 'number' && charCode >= 0xD800 && charCode <= 0xDBFF;
+};

node_modules/es-abstract/helpers/isMatchRecord.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var has = require('has');
+
+// https://262.ecma-international.org/13.0/#sec-match-records
+
+module.exports = function isMatchRecord(record) {
+	return (
+		has(record, '[[StartIndex]]')
+        && has(record, '[[EndIndex]]')
+        && record['[[StartIndex]]'] >= 0
+        && record['[[EndIndex]]'] >= record['[[StartIndex]]']
+        && String(parseInt(record['[[StartIndex]]'], 10)) === String(record['[[StartIndex]]'])
+        && String(parseInt(record['[[EndIndex]]'], 10)) === String(record['[[EndIndex]]'])
+	);
+};

node_modules/es-abstract/helpers/isNaN.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = Number.isNaN || function isNaN(a) {
+	return a !== a;
+};

node_modules/es-abstract/helpers/isPrefixOf.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var $strSlice = require('call-bind/callBound')('String.prototype.slice');
+
+module.exports = function isPrefixOf(prefix, string) {
+	if (prefix === string) {
+		return true;
+	}
+	if (prefix.length > string.length) {
+		return false;
+	}
+	return $strSlice(string, 0, prefix.length) === prefix;
+};

node_modules/es-abstract/helpers/isPrimitive.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = function isPrimitive(value) {
+	return value === null || (typeof value !== 'function' && typeof value !== 'object');
+};

node_modules/es-abstract/helpers/isPropertyDescriptor.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var has = require('has');
+var $TypeError = GetIntrinsic('%TypeError%');
+
+module.exports = function IsPropertyDescriptor(ES, Desc) {
+	if (ES.Type(Desc) !== 'Object') {
+		return false;
+	}
+	var allowed = {
+		'[[Configurable]]': true,
+		'[[Enumerable]]': true,
+		'[[Get]]': true,
+		'[[Set]]': true,
+		'[[Value]]': true,
+		'[[Writable]]': true
+	};
+
+	for (var key in Desc) { // eslint-disable-line no-restricted-syntax
+		if (has(Desc, key) && !allowed[key]) {
+			return false;
+		}
+	}
+
+	if (ES.IsDataDescriptor(Desc) && ES.IsAccessorDescriptor(Desc)) {
+		throw new $TypeError('Property Descriptors may not be both accessor and data descriptors');
+	}
+	return true;
+};

node_modules/es-abstract/helpers/isSamePropertyDescriptor.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var every = require('./every');
+
+module.exports = function isSamePropertyDescriptor(ES, D1, D2) {
+	var fields = [
+		'[[Configurable]]',
+		'[[Enumerable]]',
+		'[[Get]]',
+		'[[Set]]',
+		'[[Value]]',
+		'[[Writable]]'
+	];
+	return every(fields, function (field) {
+		if ((field in D1) !== (field in D2)) {
+			return false;
+		}
+		return ES.SameValue(D1[field], D2[field]);
+	});
+};

node_modules/es-abstract/helpers/isTrailingSurrogate.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = function isTrailingSurrogate(charCode) {
+	return typeof charCode === 'number' && charCode >= 0xDC00 && charCode <= 0xDFFF;
+};

node_modules/es-abstract/helpers/maxSafeInteger.js

@@ -0,0 +1,8 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $Math = GetIntrinsic('%Math%');
+var $Number = GetIntrinsic('%Number%');
+
+module.exports = $Number.MAX_SAFE_INTEGER || $Math.pow(2, 53) - 1;

node_modules/es-abstract/helpers/mod.js

@@ -0,0 +1,8 @@
+'use strict';
+
+var $floor = Math.floor;
+
+module.exports = function mod(number, modulo) {
+	var remain = number % modulo;
+	return $floor(remain >= 0 ? remain : remain + modulo);
+};

node_modules/es-abstract/helpers/modBigInt.js

@@ -0,0 +1,6 @@
+'use strict';
+
+module.exports = function bigIntMod(BigIntRemainder, bigint, modulo) {
+	var remain = BigIntRemainder(bigint, modulo);
+	return remain >= 0 ? remain : remain + modulo;
+};

node_modules/es-abstract/helpers/padTimeComponent.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var callBound = require('call-bind/callBound');
+
+var $strSlice = callBound('String.prototype.slice');
+
+module.exports = function padTimeComponent(c, count) {
+	return $strSlice('00' + c, -(count || 2));
+};

node_modules/es-abstract/helpers/reduce.js

@@ -0,0 +1,9 @@
+'use strict';
+
+module.exports = function reduce(arr, fn, init) {
+	var acc = init;
+	for (var i = 0; i < arr.length; i += 1) {
+		acc = fn(acc, arr[i], i);
+	}
+	return acc;
+};

node_modules/es-abstract/helpers/regexTester.js

@@ -0,0 +1,5 @@
+'use strict';
+
+// TODO: remove, semver-major
+
+module.exports = require('safe-regex-test');

node_modules/es-abstract/helpers/setProto.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var originalSetProto = GetIntrinsic('%Object.setPrototypeOf%', true);
+
+var hasProto = require('has-proto')();
+
+module.exports = originalSetProto || (
+
+	hasProto
+		? function (O, proto) {
+			O.__proto__ = proto; // eslint-disable-line no-proto, no-param-reassign
+			return O;
+		}
+		: null
+);

node_modules/es-abstract/helpers/sign.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = function sign(number) {
+	return number >= 0 ? 1 : -1;
+};

node_modules/es-abstract/helpers/some.js

@@ -0,0 +1,10 @@
+'use strict';
+
+module.exports = function some(array, predicate) {
+	for (var i = 0; i < array.length; i += 1) {
+		if (predicate(array[i], i, array)) {
+			return true;
+		}
+	}
+	return false;
+};

node_modules/es-abstract/helpers/timeConstants.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var HoursPerDay = 24;
+var MinutesPerHour = 60;
+var SecondsPerMinute = 60;
+var msPerSecond = 1e3;
+var msPerMinute = msPerSecond * SecondsPerMinute;
+var msPerHour = msPerMinute * MinutesPerHour;
+var msPerDay = 86400000;
+
+module.exports = {
+	HoursPerDay: HoursPerDay,
+	MinutesPerHour: MinutesPerHour,
+	SecondsPerMinute: SecondsPerMinute,
+	msPerSecond: msPerSecond,
+	msPerMinute: msPerMinute,
+	msPerHour: msPerHour,
+	msPerDay: msPerDay
+};