flow like the river

VISUALIZACION/node_modules/es-abstract/.editorconfig

@@ -0,0 +1,15 @@
+root = true
+
+[*]
+indent_style = tab;
+insert_final_newline = true;
+quote_type = auto;
+space_after_anonymous_functions = true;
+space_after_control_statements = true;
+spaces_around_operators = true;
+trim_trailing_whitespace = true;
+spaces_in_brackets = false;
+end_of_line = lf;
+
+[CHANGELOG.md]
+indent_style = space

VISUALIZACION/node_modules/es-abstract/.eslintrc

@@ -0,0 +1,88 @@
+{
+	"root": true,
+
+	"extends": "@ljharb",
+
+	"env": {
+		"es6": true,
+	},
+
+	"rules": {
+		"array-bracket-newline": 0,
+		"complexity": 0,
+		"eqeqeq": [2, "allow-null"],
+		"func-name-matching": 0,
+		"id-length": [2, { "min": 1, "max": 40 }],
+		"max-params": [2, 5],
+		"max-lines-per-function": 1,
+		"max-statements": 1,
+		"max-statements-per-line": [2, { "max": 2 }],
+		"multiline-comment-style": 0,
+		"no-magic-numbers": 0,
+		"new-cap": 0,
+		"no-extra-parens": 1,
+		"sort-keys": 0,
+	},
+
+	"overrides": [
+		{
+			"files": "GetIntrinsic.js",
+			"rules": {
+				"max-statements": 0,
+			}
+		},
+		{
+			"files": "operations/*",
+			"rules": {
+				"max-lines": 0,
+			},
+		},
+		{
+			"files": [
+				"operations/deltas.js",
+				"operations/getOps.js",
+				"operations/spackle.js",
+				"operations/years.js",
+			],
+			"extends": "@ljharb/eslint-config/node/latest",
+			"rules": {
+				"complexity": 0,
+				"func-style": 0,
+				"max-lines-per-function": 0,
+				"max-nested-callbacks": 0,
+				"max-statements": 0,
+				"no-magic-numbers": 0,
+				"no-throw-literal": 0,
+			},
+		},
+		{
+			"files": "test/**",
+			"extends": "@ljharb/eslint-config/tests",
+			"rules": {
+				"max-len": 0,
+				"max-lines-per-function": 0,
+				"no-implicit-coercion": 0,
+				"no-invalid-this": 1,
+				"prefer-promise-reject-errors": 0,
+			},
+		},
+		{
+			"files": [
+				"*/Num*ToRawBytes.js",
+				"*/RawBytesToNum*.js",
+				"helpers/bytesAs*.js",
+				"helpers/valueToFloat*.js",
+			],
+			"rules": {
+				"max-lines-per-function": "off",
+				"max-statements": "off",
+				"no-redeclare": "warn",
+				"operator-linebreak": [2, "before", {
+					"overrides": {
+						"=": "none"
+					}
+				}],
+			},
+		},
+	],
+}

VISUALIZACION/node_modules/es-abstract/.nycrc

@@ -0,0 +1,15 @@
+{
+	"all": true,
+	"check-coverage": false,
+	"reporter": ["text-summary", "text", "html", "json"],
+	"exclude": [
+		"coverage",
+		"operations",
+		"test",
+		"helpers/callBind.js",
+		"helpers/callBound.js",
+		"helpers/getOwnPropertyDescriptor.js",
+		"helpers/getSymbolDescription.js",
+		"helpers/regexTester.js"
+	]
+}

VISUALIZACION/node_modules/es-abstract/2015/AbstractEqualityComparison.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var ToNumber = require('./ToNumber');
+var ToPrimitive = require('./ToPrimitive');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-abstract-equality-comparison
+
+module.exports = function AbstractEqualityComparison(x, y) {
+	var xType = Type(x);
+	var yType = Type(y);
+	if (xType === yType) {
+		return x === y; // ES6+ specified this shortcut anyways.
+	}
+	if (x == null && y == null) {
+		return true;
+	}
+	if (xType === 'Number' && yType === 'String') {
+		return AbstractEqualityComparison(x, ToNumber(y));
+	}
+	if (xType === 'String' && yType === 'Number') {
+		return AbstractEqualityComparison(ToNumber(x), y);
+	}
+	if (xType === 'Boolean') {
+		return AbstractEqualityComparison(ToNumber(x), y);
+	}
+	if (yType === 'Boolean') {
+		return AbstractEqualityComparison(x, ToNumber(y));
+	}
+	if ((xType === 'String' || xType === 'Number' || xType === 'Symbol') && yType === 'Object') {
+		return AbstractEqualityComparison(x, ToPrimitive(y));
+	}
+	if (xType === 'Object' && (yType === 'String' || yType === 'Number' || yType === 'Symbol')) {
+		return AbstractEqualityComparison(ToPrimitive(x), y);
+	}
+	return false;
+};

VISUALIZACION/node_modules/es-abstract/2015/AbstractRelationalComparison.js

@@ -0,0 +1,63 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $Number = GetIntrinsic('%Number%');
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var $isNaN = require('../helpers/isNaN');
+var $isFinite = require('../helpers/isFinite');
+var isPrefixOf = require('../helpers/isPrefixOf');
+
+var ToNumber = require('./ToNumber');
+var ToPrimitive = require('./ToPrimitive');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/5.1/#sec-11.8.5
+
+// eslint-disable-next-line max-statements
+module.exports = function AbstractRelationalComparison(x, y, LeftFirst) {
+	if (Type(LeftFirst) !== 'Boolean') {
+		throw new $TypeError('Assertion failed: LeftFirst argument must be a Boolean');
+	}
+	var px;
+	var py;
+	if (LeftFirst) {
+		px = ToPrimitive(x, $Number);
+		py = ToPrimitive(y, $Number);
+	} else {
+		py = ToPrimitive(y, $Number);
+		px = ToPrimitive(x, $Number);
+	}
+	var bothStrings = Type(px) === 'String' && Type(py) === 'String';
+	if (!bothStrings) {
+		var nx = ToNumber(px);
+		var ny = ToNumber(py);
+		if ($isNaN(nx) || $isNaN(ny)) {
+			return undefined;
+		}
+		if ($isFinite(nx) && $isFinite(ny) && nx === ny) {
+			return false;
+		}
+		if (nx === Infinity) {
+			return false;
+		}
+		if (ny === Infinity) {
+			return true;
+		}
+		if (ny === -Infinity) {
+			return false;
+		}
+		if (nx === -Infinity) {
+			return true;
+		}
+		return nx < ny; // by now, these are both nonzero, finite, and not equal
+	}
+	if (isPrefixOf(py, px)) {
+		return false;
+	}
+	if (isPrefixOf(px, py)) {
+		return true;
+	}
+	return px < py; // both strings, neither a prefix of the other. shortcut for steps c-f
+};

VISUALIZACION/node_modules/es-abstract/2015/AdvanceStringIndex.js

@@ -0,0 +1,47 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var Type = require('./Type');
+
+var isInteger = require('../helpers/isInteger');
+var isLeadingSurrogate = require('../helpers/isLeadingSurrogate');
+var isTrailingSurrogate = require('../helpers/isTrailingSurrogate');
+var MAX_SAFE_INTEGER = require('../helpers/maxSafeInteger');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var $charCodeAt = require('call-bind/callBound')('String.prototype.charCodeAt');
+
+// https://262.ecma-international.org/6.0/#sec-advancestringindex
+
+module.exports = function AdvanceStringIndex(S, index, unicode) {
+	if (Type(S) !== 'String') {
+		throw new $TypeError('Assertion failed: `S` must be a String');
+	}
+	if (!isInteger(index) || index < 0 || index > MAX_SAFE_INTEGER) {
+		throw new $TypeError('Assertion failed: `length` must be an integer >= 0 and <= 2**53');
+	}
+	if (Type(unicode) !== 'Boolean') {
+		throw new $TypeError('Assertion failed: `unicode` must be a Boolean');
+	}
+	if (!unicode) {
+		return index + 1;
+	}
+	var length = S.length;
+	if ((index + 1) >= length) {
+		return index + 1;
+	}
+
+	var first = $charCodeAt(S, index);
+	if (!isLeadingSurrogate(first)) {
+		return index + 1;
+	}
+
+	var second = $charCodeAt(S, index + 1);
+	if (!isTrailingSurrogate(second)) {
+		return index + 1;
+	}
+
+	return index + 2;
+};

VISUALIZACION/node_modules/es-abstract/2015/ArrayCreate.js

@@ -0,0 +1,54 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $ArrayPrototype = GetIntrinsic('%Array.prototype%');
+var $RangeError = GetIntrinsic('%RangeError%');
+var $SyntaxError = GetIntrinsic('%SyntaxError%');
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var isInteger = require('../helpers/isInteger');
+
+var hasProto = require('has-proto')();
+
+var MAX_ARRAY_LENGTH = Math.pow(2, 32) - 1;
+
+var $setProto = GetIntrinsic('%Object.setPrototypeOf%', true) || (
+	hasProto
+		? function (O, proto) {
+			O.__proto__ = proto; // eslint-disable-line no-proto, no-param-reassign
+			return O;
+		}
+		: null
+);
+
+// https://262.ecma-international.org/6.0/#sec-arraycreate
+
+module.exports = function ArrayCreate(length) {
+	if (!isInteger(length) || length < 0) {
+		throw new $TypeError('Assertion failed: `length` must be an integer Number >= 0');
+	}
+	if (length > MAX_ARRAY_LENGTH) {
+		throw new $RangeError('length is greater than (2**32 - 1)');
+	}
+	var proto = arguments.length > 1 ? arguments[1] : $ArrayPrototype;
+	var A = []; // steps 5 - 7, and 9
+	if (proto !== $ArrayPrototype) { // step 8
+		if (!$setProto) {
+			throw new $SyntaxError('ArrayCreate: a `proto` argument that is not `Array.prototype` is not supported in an environment that does not support setting the [[Prototype]]');
+		}
+		$setProto(A, proto);
+	}
+	if (length !== 0) { // bypasses the need for step 2
+		A.length = length;
+	}
+	/* step 10, the above as a shortcut for the below
+	OrdinaryDefineOwnProperty(A, 'length', {
+		'[[Configurable]]': false,
+		'[[Enumerable]]': false,
+		'[[Value]]': length,
+		'[[Writable]]': true
+	});
+	*/
+	return A;
+};

VISUALIZACION/node_modules/es-abstract/2015/ArraySetLength.js

@@ -0,0 +1,85 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $RangeError = GetIntrinsic('%RangeError%');
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var assign = require('object.assign');
+
+var isPropertyDescriptor = require('../helpers/isPropertyDescriptor');
+
+var IsArray = require('./IsArray');
+var IsAccessorDescriptor = require('./IsAccessorDescriptor');
+var IsDataDescriptor = require('./IsDataDescriptor');
+var OrdinaryDefineOwnProperty = require('./OrdinaryDefineOwnProperty');
+var OrdinaryGetOwnProperty = require('./OrdinaryGetOwnProperty');
+var ToNumber = require('./ToNumber');
+var ToString = require('./ToString');
+var ToUint32 = require('./ToUint32');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-arraysetlength
+
+// eslint-disable-next-line max-statements, max-lines-per-function
+module.exports = function ArraySetLength(A, Desc) {
+	if (!IsArray(A)) {
+		throw new $TypeError('Assertion failed: A must be an Array');
+	}
+	if (!isPropertyDescriptor({
+		Type: Type,
+		IsDataDescriptor: IsDataDescriptor,
+		IsAccessorDescriptor: IsAccessorDescriptor
+	}, Desc)) {
+		throw new $TypeError('Assertion failed: Desc must be a Property Descriptor');
+	}
+	if (!('[[Value]]' in Desc)) {
+		return OrdinaryDefineOwnProperty(A, 'length', Desc);
+	}
+	var newLenDesc = assign({}, Desc);
+	var newLen = ToUint32(Desc['[[Value]]']);
+	var numberLen = ToNumber(Desc['[[Value]]']);
+	if (newLen !== numberLen) {
+		throw new $RangeError('Invalid array length');
+	}
+	newLenDesc['[[Value]]'] = newLen;
+	var oldLenDesc = OrdinaryGetOwnProperty(A, 'length');
+	if (!IsDataDescriptor(oldLenDesc)) {
+		throw new $TypeError('Assertion failed: an array had a non-data descriptor on `length`');
+	}
+	var oldLen = oldLenDesc['[[Value]]'];
+	if (newLen >= oldLen) {
+		return OrdinaryDefineOwnProperty(A, 'length', newLenDesc);
+	}
+	if (!oldLenDesc['[[Writable]]']) {
+		return false;
+	}
+	var newWritable;
+	if (!('[[Writable]]' in newLenDesc) || newLenDesc['[[Writable]]']) {
+		newWritable = true;
+	} else {
+		newWritable = false;
+		newLenDesc['[[Writable]]'] = true;
+	}
+	var succeeded = OrdinaryDefineOwnProperty(A, 'length', newLenDesc);
+	if (!succeeded) {
+		return false;
+	}
+	while (newLen < oldLen) {
+		oldLen -= 1;
+		// eslint-disable-next-line no-param-reassign
+		var deleteSucceeded = delete A[ToString(oldLen)];
+		if (!deleteSucceeded) {
+			newLenDesc['[[Value]]'] = oldLen + 1;
+			if (!newWritable) {
+				newLenDesc['[[Writable]]'] = false;
+				OrdinaryDefineOwnProperty(A, 'length', newLenDesc);
+				return false;
+			}
+		}
+	}
+	if (!newWritable) {
+		return OrdinaryDefineOwnProperty(A, 'length', { '[[Writable]]': false });
+	}
+	return true;
+};

VISUALIZACION/node_modules/es-abstract/2015/ArraySpeciesCreate.js

@@ -0,0 +1,47 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $Array = GetIntrinsic('%Array%');
+var $species = GetIntrinsic('%Symbol.species%', true);
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Get = require('./Get');
+var IsArray = require('./IsArray');
+var IsConstructor = require('./IsConstructor');
+var Type = require('./Type');
+
+var isInteger = require('../helpers/isInteger');
+
+// https://262.ecma-international.org/6.0/#sec-arrayspeciescreate
+
+module.exports = function ArraySpeciesCreate(originalArray, length) {
+	if (!isInteger(length) || length < 0) {
+		throw new $TypeError('Assertion failed: length must be an integer >= 0');
+	}
+	var len = length === 0 ? 0 : length;
+	var C;
+	var isArray = IsArray(originalArray);
+	if (isArray) {
+		C = Get(originalArray, 'constructor');
+		// TODO: figure out how to make a cross-realm normal Array, a same-realm Array
+		// if (IsConstructor(C)) {
+		// 	if C is another realm's Array, C = undefined
+		// 	Object.getPrototypeOf(Object.getPrototypeOf(Object.getPrototypeOf(Array))) === null ?
+		// }
+		if ($species && Type(C) === 'Object') {
+			C = Get(C, $species);
+			if (C === null) {
+				C = void 0;
+			}
+		}
+	}
+	if (typeof C === 'undefined') {
+		return $Array(len);
+	}
+	if (!IsConstructor(C)) {
+		throw new $TypeError('C must be a constructor');
+	}
+	return new C(len); // Construct(C, len);
+};
+

VISUALIZACION/node_modules/es-abstract/2015/Call.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+var callBound = require('call-bind/callBound');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var IsArray = require('./IsArray');
+
+var $apply = GetIntrinsic('%Reflect.apply%', true) || callBound('Function.prototype.apply');
+
+// https://262.ecma-international.org/6.0/#sec-call
+
+module.exports = function Call(F, V) {
+	var argumentsList = arguments.length > 2 ? arguments[2] : [];
+	if (!IsArray(argumentsList)) {
+		throw new $TypeError('Assertion failed: optional `argumentsList`, if provided, must be a List');
+	}
+	return $apply(F, V, argumentsList);
+};

VISUALIZACION/node_modules/es-abstract/2015/CanonicalNumericIndexString.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var SameValue = require('./SameValue');
+var ToNumber = require('./ToNumber');
+var ToString = require('./ToString');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-canonicalnumericindexstring
+
+module.exports = function CanonicalNumericIndexString(argument) {
+	if (Type(argument) !== 'String') {
+		throw new $TypeError('Assertion failed: `argument` must be a String');
+	}
+	if (argument === '-0') { return -0; }
+	var n = ToNumber(argument);
+	if (SameValue(ToString(n), argument)) { return n; }
+	return void 0;
+};

VISUALIZACION/node_modules/es-abstract/2015/Canonicalize.js

@@ -0,0 +1,55 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var callBound = require('call-bind/callBound');
+var has = require('has');
+
+var $charCodeAt = callBound('String.prototype.charCodeAt');
+var $toUpperCase = callBound('String.prototype.toUpperCase');
+
+var Type = require('./Type');
+
+var caseFolding = require('../helpers/caseFolding');
+
+// https://262.ecma-international.org/6.0/#sec-runtime-semantics-canonicalize-ch
+
+module.exports = function Canonicalize(ch, IgnoreCase, Unicode) {
+	if (Type(ch) !== 'String') {
+		throw new $TypeError('Assertion failed: `ch` must be a character');
+	}
+
+	if (Type(IgnoreCase) !== 'Boolean' || Type(Unicode) !== 'Boolean') {
+		throw new $TypeError('Assertion failed: `IgnoreCase` and `Unicode` must be Booleans');
+	}
+
+	if (!IgnoreCase) {
+		return ch; // step 1
+	}
+
+	if (Unicode) { // step 2
+		if (has(caseFolding.C, ch)) {
+			return caseFolding.C[ch];
+		}
+		if (has(caseFolding.S, ch)) {
+			return caseFolding.S[ch];
+		}
+		return ch; // step 2.b
+	}
+
+	var u = $toUpperCase(ch); // step 2
+
+	if (u.length !== 1) {
+		return ch; // step 3
+	}
+
+	var cu = u; // step 4
+
+	if ($charCodeAt(ch, 0) >= 128 && $charCodeAt(cu, 0) < 128) {
+		return ch; // step 5
+	}
+
+	return cu;
+};

VISUALIZACION/node_modules/es-abstract/2015/CharacterRange.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+var callBound = require('call-bind/callBound');
+
+var $fromCharCode = GetIntrinsic('%String.fromCharCode%');
+var $TypeError = GetIntrinsic('%TypeError%');
+var $charCodeAt = callBound('String.prototype.charCodeAt');
+var $push = callBound('Array.prototype.push');
+
+module.exports = function CharacterRange(A, B) {
+	if (A.length !== 1 || B.length !== 1) {
+		throw new $TypeError('Assertion failed: CharSets A and B contain exactly one character');
+	}
+
+	var a = A[0];
+	var b = B[0];
+
+	var i = $charCodeAt(a, 0);
+	var j = $charCodeAt(b, 0);
+
+	if (!(i <= j)) {
+		throw new $TypeError('Assertion failed: i is not <= j');
+	}
+
+	var arr = [];
+	for (var k = i; k <= j; k += 1) {
+		$push(arr, $fromCharCode(k));
+	}
+	return arr;
+};

VISUALIZACION/node_modules/es-abstract/2015/CompletePropertyDescriptor.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var has = require('has');
+
+var assertRecord = require('../helpers/assertRecord');
+
+var IsDataDescriptor = require('./IsDataDescriptor');
+var IsGenericDescriptor = require('./IsGenericDescriptor');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-completepropertydescriptor
+
+module.exports = function CompletePropertyDescriptor(Desc) {
+	/* eslint no-param-reassign: 0 */
+	assertRecord(Type, 'Property Descriptor', 'Desc', Desc);
+
+	if (IsGenericDescriptor(Desc) || IsDataDescriptor(Desc)) {
+		if (!has(Desc, '[[Value]]')) {
+			Desc['[[Value]]'] = void 0;
+		}
+		if (!has(Desc, '[[Writable]]')) {
+			Desc['[[Writable]]'] = false;
+		}
+	} else {
+		if (!has(Desc, '[[Get]]')) {
+			Desc['[[Get]]'] = void 0;
+		}
+		if (!has(Desc, '[[Set]]')) {
+			Desc['[[Set]]'] = void 0;
+		}
+	}
+	if (!has(Desc, '[[Enumerable]]')) {
+		Desc['[[Enumerable]]'] = false;
+	}
+	if (!has(Desc, '[[Configurable]]')) {
+		Desc['[[Configurable]]'] = false;
+	}
+	return Desc;
+};

VISUALIZACION/node_modules/es-abstract/2015/CompletionRecord.js

@@ -0,0 +1,53 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $SyntaxError = GetIntrinsic('%SyntaxError%');
+
+var SLOT = require('internal-slot');
+
+// https://262.ecma-international.org/6.0/#sec-completion-record-specification-type
+
+var CompletionRecord = function CompletionRecord(type, value) {
+	if (!(this instanceof CompletionRecord)) {
+		return new CompletionRecord(type, value);
+	}
+	if (type !== 'normal' && type !== 'break' && type !== 'continue' && type !== 'return' && type !== 'throw') {
+		throw new $SyntaxError('Assertion failed: `type` must be one of "normal", "break", "continue", "return", or "throw"');
+	}
+	SLOT.set(this, '[[type]]', type);
+	SLOT.set(this, '[[value]]', value);
+	// [[target]] slot?
+};
+
+CompletionRecord.prototype.type = function type() {
+	return SLOT.get(this, '[[type]]');
+};
+
+CompletionRecord.prototype.value = function value() {
+	return SLOT.get(this, '[[value]]');
+};
+
+CompletionRecord.prototype['?'] = function ReturnIfAbrupt() {
+	var type = SLOT.get(this, '[[type]]');
+	var value = SLOT.get(this, '[[value]]');
+
+	if (type === 'normal') {
+		return value;
+	}
+	if (type === 'throw') {
+		throw value;
+	}
+	throw new $SyntaxError('Completion Record is not of type "normal" or "throw": other types not supported');
+};
+
+CompletionRecord.prototype['!'] = function assert() {
+	var type = SLOT.get(this, '[[type]]');
+
+	if (type !== 'normal') {
+		throw new $SyntaxError('Assertion failed: Completion Record is not of type "normal"');
+	}
+	return SLOT.get(this, '[[value]]');
+};
+
+module.exports = CompletionRecord;

VISUALIZACION/node_modules/es-abstract/2015/CreateDataProperty.js

@@ -0,0 +1,27 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var IsPropertyKey = require('./IsPropertyKey');
+var OrdinaryDefineOwnProperty = require('./OrdinaryDefineOwnProperty');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-createdataproperty
+
+module.exports = function CreateDataProperty(O, P, V) {
+	if (Type(O) !== 'Object') {
+		throw new $TypeError('Assertion failed: Type(O) is not Object');
+	}
+	if (!IsPropertyKey(P)) {
+		throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true');
+	}
+	var newDesc = {
+		'[[Configurable]]': true,
+		'[[Enumerable]]': true,
+		'[[Value]]': V,
+		'[[Writable]]': true
+	};
+	return OrdinaryDefineOwnProperty(O, P, newDesc);
+};

VISUALIZACION/node_modules/es-abstract/2015/CreateDataPropertyOrThrow.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var CreateDataProperty = require('./CreateDataProperty');
+var IsPropertyKey = require('./IsPropertyKey');
+var Type = require('./Type');
+
+// // https://262.ecma-international.org/6.0/#sec-createdatapropertyorthrow
+
+module.exports = function CreateDataPropertyOrThrow(O, P, V) {
+	if (Type(O) !== 'Object') {
+		throw new $TypeError('Assertion failed: Type(O) is not Object');
+	}
+	if (!IsPropertyKey(P)) {
+		throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true');
+	}
+	var success = CreateDataProperty(O, P, V);
+	if (!success) {
+		throw new $TypeError('unable to create data property');
+	}
+	return success;
+};

VISUALIZACION/node_modules/es-abstract/2015/CreateHTML.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var callBound = require('call-bind/callBound');
+
+var $replace = callBound('String.prototype.replace');
+
+var RequireObjectCoercible = require('./RequireObjectCoercible');
+var ToString = require('./ToString');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-createhtml
+
+module.exports = function CreateHTML(string, tag, attribute, value) {
+	if (Type(tag) !== 'String' || Type(attribute) !== 'String') {
+		throw new $TypeError('Assertion failed: `tag` and `attribute` must be strings');
+	}
+	var str = RequireObjectCoercible(string);
+	var S = ToString(str);
+	var p1 = '<' + tag;
+	if (attribute !== '') {
+		var V = ToString(value);
+		var escapedV = $replace(V, /\x22/g, '&quot;');
+		p1 += '\x20' + attribute + '\x3D\x22' + escapedV + '\x22';
+	}
+	return p1 + '>' + S + '</' + tag + '>';
+};

VISUALIZACION/node_modules/es-abstract/2015/CreateIterResultObject.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-createiterresultobject
+
+module.exports = function CreateIterResultObject(value, done) {
+	if (Type(done) !== 'Boolean') {
+		throw new $TypeError('Assertion failed: Type(done) is not Boolean');
+	}
+	return {
+		value: value,
+		done: done
+	};
+};

VISUALIZACION/node_modules/es-abstract/2015/CreateListFromArrayLike.js

@@ -0,0 +1,45 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var callBound = require('call-bind/callBound');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+var $indexOf = callBound('Array.prototype.indexOf', true) || callBound('String.prototype.indexOf');
+var $push = callBound('Array.prototype.push');
+
+var Get = require('./Get');
+var IsArray = require('./IsArray');
+var ToLength = require('./ToLength');
+var ToString = require('./ToString');
+var Type = require('./Type');
+
+var defaultElementTypes = ['Undefined', 'Null', 'Boolean', 'String', 'Symbol', 'Number', 'Object'];
+
+// https://262.ecma-international.org/6.0/#sec-createlistfromarraylike
+module.exports = function CreateListFromArrayLike(obj) {
+	var elementTypes = arguments.length > 1
+		? arguments[1]
+		: defaultElementTypes;
+
+	if (Type(obj) !== 'Object') {
+		throw new $TypeError('Assertion failed: `obj` must be an Object');
+	}
+	if (!IsArray(elementTypes)) {
+		throw new $TypeError('Assertion failed: `elementTypes`, if provided, must be an array');
+	}
+	var len = ToLength(Get(obj, 'length'));
+	var list = [];
+	var index = 0;
+	while (index < len) {
+		var indexName = ToString(index);
+		var next = Get(obj, indexName);
+		var nextType = Type(next);
+		if ($indexOf(elementTypes, nextType) < 0) {
+			throw new $TypeError('item type ' + nextType + ' is not a valid elementType');
+		}
+		$push(list, next);
+		index += 1;
+	}
+	return list;
+};

VISUALIZACION/node_modules/es-abstract/2015/CreateMethodProperty.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var DefineOwnProperty = require('../helpers/DefineOwnProperty');
+
+var FromPropertyDescriptor = require('./FromPropertyDescriptor');
+var IsDataDescriptor = require('./IsDataDescriptor');
+var IsPropertyKey = require('./IsPropertyKey');
+var SameValue = require('./SameValue');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-createmethodproperty
+
+module.exports = function CreateMethodProperty(O, P, V) {
+	if (Type(O) !== 'Object') {
+		throw new $TypeError('Assertion failed: Type(O) is not Object');
+	}
+
+	if (!IsPropertyKey(P)) {
+		throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true');
+	}
+
+	var newDesc = {
+		'[[Configurable]]': true,
+		'[[Enumerable]]': false,
+		'[[Value]]': V,
+		'[[Writable]]': true
+	};
+	return DefineOwnProperty(
+		IsDataDescriptor,
+		SameValue,
+		FromPropertyDescriptor,
+		O,
+		P,
+		newDesc
+	);
+};

VISUALIZACION/node_modules/es-abstract/2015/DateFromTime.js

@@ -0,0 +1,54 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $EvalError = GetIntrinsic('%EvalError%');
+
+var DayWithinYear = require('./DayWithinYear');
+var InLeapYear = require('./InLeapYear');
+var MonthFromTime = require('./MonthFromTime');
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.5
+
+module.exports = function DateFromTime(t) {
+	var m = MonthFromTime(t);
+	var d = DayWithinYear(t);
+	if (m === 0) {
+		return d + 1;
+	}
+	if (m === 1) {
+		return d - 30;
+	}
+	var leap = InLeapYear(t);
+	if (m === 2) {
+		return d - 58 - leap;
+	}
+	if (m === 3) {
+		return d - 89 - leap;
+	}
+	if (m === 4) {
+		return d - 119 - leap;
+	}
+	if (m === 5) {
+		return d - 150 - leap;
+	}
+	if (m === 6) {
+		return d - 180 - leap;
+	}
+	if (m === 7) {
+		return d - 211 - leap;
+	}
+	if (m === 8) {
+		return d - 242 - leap;
+	}
+	if (m === 9) {
+		return d - 272 - leap;
+	}
+	if (m === 10) {
+		return d - 303 - leap;
+	}
+	if (m === 11) {
+		return d - 333 - leap;
+	}
+	throw new $EvalError('Assertion failed: MonthFromTime returned an impossible value: ' + m);
+};

VISUALIZACION/node_modules/es-abstract/2015/Day.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var floor = require('./floor');
+
+var msPerDay = require('../helpers/timeConstants').msPerDay;
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.2
+
+module.exports = function Day(t) {
+	return floor(t / msPerDay);
+};

VISUALIZACION/node_modules/es-abstract/2015/DayFromYear.js

@@ -0,0 +1,10 @@
+'use strict';
+
+var floor = require('./floor');
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.3
+
+module.exports = function DayFromYear(y) {
+	return (365 * (y - 1970)) + floor((y - 1969) / 4) - floor((y - 1901) / 100) + floor((y - 1601) / 400);
+};
+

VISUALIZACION/node_modules/es-abstract/2015/DayWithinYear.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var Day = require('./Day');
+var DayFromYear = require('./DayFromYear');
+var YearFromTime = require('./YearFromTime');
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.4
+
+module.exports = function DayWithinYear(t) {
+	return Day(t) - DayFromYear(YearFromTime(t));
+};

VISUALIZACION/node_modules/es-abstract/2015/DaysInYear.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var modulo = require('./modulo');
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.3
+
+module.exports = function DaysInYear(y) {
+	if (modulo(y, 4) !== 0) {
+		return 365;
+	}
+	if (modulo(y, 100) !== 0) {
+		return 366;
+	}
+	if (modulo(y, 400) !== 0) {
+		return 365;
+	}
+	return 366;
+};

VISUALIZACION/node_modules/es-abstract/2015/DefinePropertyOrThrow.js

@@ -0,0 +1,50 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var isPropertyDescriptor = require('../helpers/isPropertyDescriptor');
+var DefineOwnProperty = require('../helpers/DefineOwnProperty');
+
+var FromPropertyDescriptor = require('./FromPropertyDescriptor');
+var IsAccessorDescriptor = require('./IsAccessorDescriptor');
+var IsDataDescriptor = require('./IsDataDescriptor');
+var IsPropertyKey = require('./IsPropertyKey');
+var SameValue = require('./SameValue');
+var ToPropertyDescriptor = require('./ToPropertyDescriptor');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-definepropertyorthrow
+
+module.exports = function DefinePropertyOrThrow(O, P, desc) {
+	if (Type(O) !== 'Object') {
+		throw new $TypeError('Assertion failed: Type(O) is not Object');
+	}
+
+	if (!IsPropertyKey(P)) {
+		throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true');
+	}
+
+	var Desc = isPropertyDescriptor({
+		Type: Type,
+		IsDataDescriptor: IsDataDescriptor,
+		IsAccessorDescriptor: IsAccessorDescriptor
+	}, desc) ? desc : ToPropertyDescriptor(desc);
+	if (!isPropertyDescriptor({
+		Type: Type,
+		IsDataDescriptor: IsDataDescriptor,
+		IsAccessorDescriptor: IsAccessorDescriptor
+	}, Desc)) {
+		throw new $TypeError('Assertion failed: Desc is not a valid Property Descriptor');
+	}
+
+	return DefineOwnProperty(
+		IsDataDescriptor,
+		SameValue,
+		FromPropertyDescriptor,
+		O,
+		P,
+		Desc
+	);
+};

VISUALIZACION/node_modules/es-abstract/2015/DeletePropertyOrThrow.js

@@ -0,0 +1,27 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var IsPropertyKey = require('./IsPropertyKey');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-deletepropertyorthrow
+
+module.exports = function DeletePropertyOrThrow(O, P) {
+	if (Type(O) !== 'Object') {
+		throw new $TypeError('Assertion failed: Type(O) is not Object');
+	}
+
+	if (!IsPropertyKey(P)) {
+		throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true');
+	}
+
+	// eslint-disable-next-line no-param-reassign
+	var success = delete O[P];
+	if (!success) {
+		throw new $TypeError('Attempt to delete property failed.');
+	}
+	return success;
+};

VISUALIZACION/node_modules/es-abstract/2015/DetachArrayBuffer.js

@@ -0,0 +1,34 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $SyntaxError = GetIntrinsic('%SyntaxError%');
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var isArrayBuffer = require('is-array-buffer');
+
+var MessageChannel;
+try {
+	// eslint-disable-next-line global-require
+	MessageChannel = require('worker_threads').MessageChannel; // node 11.7+
+} catch (e) { /**/ }
+
+// https://262.ecma-international.org/6.0/#sec-detacharraybuffer
+
+/* globals postMessage */
+
+module.exports = function DetachArrayBuffer(arrayBuffer) {
+	if (!isArrayBuffer(arrayBuffer)) {
+		throw new $TypeError('Assertion failed: `arrayBuffer` must be an Object with an [[ArrayBufferData]] internal slot');
+	}
+	if (typeof structuredClone === 'function') {
+		structuredClone(arrayBuffer, { transfer: [arrayBuffer] });
+	} else if (typeof postMessage === 'function') {
+		postMessage('', '/', [arrayBuffer]); // TODO: see if this might trigger listeners
+	} else if (MessageChannel) {
+		(new MessageChannel()).port1.postMessage(null, [arrayBuffer]);
+	} else {
+		throw new $SyntaxError('DetachArrayBuffer is not supported in this environment');
+	}
+	return null;
+};

VISUALIZACION/node_modules/es-abstract/2015/EnumerableOwnNames.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var keys = require('object-keys');
+
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-enumerableownnames
+
+module.exports = function EnumerableOwnNames(O) {
+	if (Type(O) !== 'Object') {
+		throw new $TypeError('Assertion failed: Type(O) is not Object');
+	}
+
+	return keys(O);
+};

VISUALIZACION/node_modules/es-abstract/2015/FromPropertyDescriptor.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var assertRecord = require('../helpers/assertRecord');
+var fromPropertyDescriptor = require('../helpers/fromPropertyDescriptor');
+
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-frompropertydescriptor
+
+module.exports = function FromPropertyDescriptor(Desc) {
+	if (typeof Desc !== 'undefined') {
+		assertRecord(Type, 'Property Descriptor', 'Desc', Desc);
+	}
+
+	return fromPropertyDescriptor(Desc);
+};

VISUALIZACION/node_modules/es-abstract/2015/Get.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var inspect = require('object-inspect');
+
+var IsPropertyKey = require('./IsPropertyKey');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-get-o-p
+
+module.exports = function Get(O, P) {
+	// 7.3.1.1
+	if (Type(O) !== 'Object') {
+		throw new $TypeError('Assertion failed: Type(O) is not Object');
+	}
+	// 7.3.1.2
+	if (!IsPropertyKey(P)) {
+		throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true, got ' + inspect(P));
+	}
+	// 7.3.1.3
+	return O[P];
+};

VISUALIZACION/node_modules/es-abstract/2015/GetGlobalObject.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var getGlobal = require('globalthis/polyfill');
+
+// https://262.ecma-international.org/6.0/#sec-getglobalobject
+
+module.exports = function GetGlobalObject() {
+	return getGlobal();
+};

VISUALIZACION/node_modules/es-abstract/2015/GetIterator.js

@@ -0,0 +1,34 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var getIteratorMethod = require('../helpers/getIteratorMethod');
+var AdvanceStringIndex = require('./AdvanceStringIndex');
+var Call = require('./Call');
+var GetMethod = require('./GetMethod');
+var IsArray = require('./IsArray');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-getiterator
+
+module.exports = function GetIterator(obj, method) {
+	var actualMethod = method;
+	if (arguments.length < 2) {
+		actualMethod = getIteratorMethod(
+			{
+				AdvanceStringIndex: AdvanceStringIndex,
+				GetMethod: GetMethod,
+				IsArray: IsArray
+			},
+			obj
+		);
+	}
+	var iterator = Call(actualMethod, obj);
+	if (Type(iterator) !== 'Object') {
+		throw new $TypeError('iterator must return an object');
+	}
+
+	return iterator;
+};

VISUALIZACION/node_modules/es-abstract/2015/GetMethod.js

@@ -0,0 +1,36 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var GetV = require('./GetV');
+var IsCallable = require('./IsCallable');
+var IsPropertyKey = require('./IsPropertyKey');
+
+var inspect = require('object-inspect');
+
+// https://262.ecma-international.org/6.0/#sec-getmethod
+
+module.exports = function GetMethod(O, P) {
+	// 7.3.9.1
+	if (!IsPropertyKey(P)) {
+		throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true');
+	}
+
+	// 7.3.9.2
+	var func = GetV(O, P);
+
+	// 7.3.9.4
+	if (func == null) {
+		return void 0;
+	}
+
+	// 7.3.9.5
+	if (!IsCallable(func)) {
+		throw new $TypeError(inspect(P) + ' is not a function: ' + inspect(func));
+	}
+
+	// 7.3.9.6
+	return func;
+};

VISUALIZACION/node_modules/es-abstract/2015/GetOwnPropertyKeys.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var hasSymbols = require('has-symbols')();
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var $gOPN = GetIntrinsic('%Object.getOwnPropertyNames%', true);
+var $gOPS = hasSymbols && GetIntrinsic('%Object.getOwnPropertySymbols%', true);
+var keys = require('object-keys');
+
+var esType = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-getownpropertykeys
+
+module.exports = function GetOwnPropertyKeys(O, Type) {
+	if (esType(O) !== 'Object') {
+		throw new $TypeError('Assertion failed: Type(O) is not Object');
+	}
+	if (Type === 'Symbol') {
+		return $gOPS ? $gOPS(O) : [];
+	}
+	if (Type === 'String') {
+		if (!$gOPN) {
+			return keys(O);
+		}
+		return $gOPN(O);
+	}
+	throw new $TypeError('Assertion failed: `Type` must be `"String"` or `"Symbol"`');
+};

VISUALIZACION/node_modules/es-abstract/2015/GetPrototypeFromConstructor.js

@@ -0,0 +1,32 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $Function = GetIntrinsic('%Function%');
+var $TypeError = GetIntrinsic('%TypeError%');
+var $SyntaxError = GetIntrinsic('%SyntaxError%');
+
+var Get = require('./Get');
+var IsConstructor = require('./IsConstructor');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-getprototypefromconstructor
+
+module.exports = function GetPrototypeFromConstructor(constructor, intrinsicDefaultProto) {
+	var intrinsic = GetIntrinsic(intrinsicDefaultProto); // throws if not a valid intrinsic
+	if (Type(intrinsic) !== 'Object') {
+		throw new $TypeError('intrinsicDefaultProto must be an object');
+	}
+	if (!IsConstructor(constructor)) {
+		throw new $TypeError('Assertion failed: `constructor` must be a constructor');
+	}
+	var proto = Get(constructor, 'prototype');
+	if (Type(proto) !== 'Object') {
+		if (!(constructor instanceof $Function)) {
+			// ignore other realms, for now
+			throw new $SyntaxError('cross-realm constructors not currently supported');
+		}
+		proto = intrinsic;
+	}
+	return proto;
+};

VISUALIZACION/node_modules/es-abstract/2015/GetSubstitution.js

@@ -0,0 +1,100 @@
+
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+var $parseInt = GetIntrinsic('%parseInt%');
+
+var inspect = require('object-inspect');
+
+var regexTester = require('safe-regex-test');
+var callBound = require('call-bind/callBound');
+var every = require('../helpers/every');
+
+var isDigit = regexTester(/^[0-9]$/);
+
+var $charAt = callBound('String.prototype.charAt');
+var $strSlice = callBound('String.prototype.slice');
+
+var IsArray = require('./IsArray');
+var Type = require('./Type');
+
+var isInteger = require('../helpers/isInteger');
+var isStringOrHole = require('../helpers/isStringOrHole');
+
+// https://262.ecma-international.org/6.0/#sec-getsubstitution
+
+// eslint-disable-next-line max-statements, max-lines-per-function
+module.exports = function GetSubstitution(matched, str, position, captures, replacement) {
+	if (Type(matched) !== 'String') {
+		throw new $TypeError('Assertion failed: `matched` must be a String');
+	}
+	var matchLength = matched.length;
+
+	if (Type(str) !== 'String') {
+		throw new $TypeError('Assertion failed: `str` must be a String');
+	}
+	var stringLength = str.length;
+
+	if (!isInteger(position) || position < 0 || position > stringLength) {
+		throw new $TypeError('Assertion failed: `position` must be a nonnegative integer, and less than or equal to the length of `string`, got ' + inspect(position));
+	}
+
+	if (!IsArray(captures) || !every(captures, isStringOrHole)) {
+		throw new $TypeError('Assertion failed: `captures` must be a List of Strings, got ' + inspect(captures));
+	}
+
+	if (Type(replacement) !== 'String') {
+		throw new $TypeError('Assertion failed: `replacement` must be a String');
+	}
+
+	var tailPos = position + matchLength;
+	var m = captures.length;
+
+	var result = '';
+	for (var i = 0; i < replacement.length; i += 1) {
+		// if this is a $, and it's not the end of the replacement
+		var current = $charAt(replacement, i);
+		var isLast = (i + 1) >= replacement.length;
+		var nextIsLast = (i + 2) >= replacement.length;
+		if (current === '$' && !isLast) {
+			var next = $charAt(replacement, i + 1);
+			if (next === '$') {
+				result += '$';
+				i += 1;
+			} else if (next === '&') {
+				result += matched;
+				i += 1;
+			} else if (next === '`') {
+				result += position === 0 ? '' : $strSlice(str, 0, position - 1);
+				i += 1;
+			} else if (next === "'") {
+				result += tailPos >= stringLength ? '' : $strSlice(str, tailPos);
+				i += 1;
+			} else {
+				var nextNext = nextIsLast ? null : $charAt(replacement, i + 2);
+				if (isDigit(next) && next !== '0' && (nextIsLast || !isDigit(nextNext))) {
+					// $1 through $9, and not followed by a digit
+					var n = $parseInt(next, 10);
+					// if (n > m, impl-defined)
+					result += n <= m && Type(captures[n - 1]) === 'Undefined' ? '' : captures[n - 1];
+					i += 1;
+				} else if (isDigit(next) && (nextIsLast || isDigit(nextNext))) {
+					// $00 through $99
+					var nn = next + nextNext;
+					var nnI = $parseInt(nn, 10) - 1;
+					// if nn === '00' or nn > m, impl-defined
+					result += nn <= m && Type(captures[nnI]) === 'Undefined' ? '' : captures[nnI];
+					i += 2;
+				} else {
+					result += '$';
+				}
+			}
+		} else {
+			// the final $, or else not a $
+			result += $charAt(replacement, i);
+		}
+	}
+	return result;
+};

VISUALIZACION/node_modules/es-abstract/2015/GetV.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var inspect = require('object-inspect');
+
+var IsPropertyKey = require('./IsPropertyKey');
+// var ToObject = require('./ToObject');
+
+// https://262.ecma-international.org/6.0/#sec-getv
+
+module.exports = function GetV(V, P) {
+	// 7.3.2.1
+	if (!IsPropertyKey(P)) {
+		throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true, got ' + inspect(P));
+	}
+
+	// 7.3.2.2-3
+	// var O = ToObject(V);
+
+	// 7.3.2.4
+	return V[P];
+};

VISUALIZACION/node_modules/es-abstract/2015/GetValueFromBuffer.js

@@ -0,0 +1,97 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+var $Uint8Array = GetIntrinsic('%Uint8Array%', true);
+
+var callBound = require('call-bind/callBound');
+
+var $charAt = callBound('String.prototype.charAt');
+var $reverse = callBound('Array.prototype.reverse');
+var $slice = callBound('Array.prototype.slice');
+
+var bytesAsFloat32 = require('../helpers/bytesAsFloat32');
+var bytesAsFloat64 = require('../helpers/bytesAsFloat64');
+var bytesAsInteger = require('../helpers/bytesAsInteger');
+var defaultEndianness = require('../helpers/defaultEndianness');
+var isInteger = require('../helpers/isInteger');
+
+var IsDetachedBuffer = require('./IsDetachedBuffer');
+
+var isArrayBuffer = require('is-array-buffer');
+var safeConcat = require('safe-array-concat');
+
+var table49 = {
+	__proto__: null,
+	$Int8: 1,
+	$Uint8: 1,
+	$Uint8C: 1,
+	$Int16: 2,
+	$Uint16: 2,
+	$Int32: 4,
+	$Uint32: 4,
+	$Float32: 4,
+	$Float64: 8
+};
+
+var isUnsignedElementType = function isUnsignedElementType(type) { return $charAt(type, 0) === 'U'; };
+
+// https://262.ecma-international.org/6.0/#sec-getvaluefrombuffer
+
+module.exports = function GetValueFromBuffer(arrayBuffer, byteIndex, type) {
+	if (!isArrayBuffer(arrayBuffer)) {
+		throw new $TypeError('Assertion failed: `arrayBuffer` must be an ArrayBuffer');
+	}
+
+	if (!isInteger(byteIndex)) {
+		throw new $TypeError('Assertion failed: `byteIndex` must be an integer');
+	}
+
+	if (typeof type !== 'string') {
+		throw new $TypeError('Assertion failed: `type` must be a string');
+	}
+
+	if (arguments.length > 3 && typeof arguments[3] !== 'boolean') {
+		throw new $TypeError('Assertion failed: `isLittleEndian` must be a boolean, if present');
+	}
+
+	if (IsDetachedBuffer(arrayBuffer)) {
+		throw new $TypeError('Assertion failed: ArrayBuffer is detached'); // step 1
+	}
+
+	// 2. Assert: There are sufficient bytes in arrayBuffer starting at byteIndex to represent a value of type.
+
+	if (byteIndex < 0) {
+		throw new $TypeError('Assertion failed: `byteIndex` must be non-negative'); // step 3
+	}
+
+	// 4. Let block be arrayBuffer’s [[ArrayBufferData]] internal slot.
+
+	var elementSize = table49['$' + type]; // step 5
+	if (!elementSize) {
+		throw new $TypeError('Assertion failed: `type` must be one of "Int8", "Uint8", "Uint8C", "Int16", "Uint16", "Int32", "Uint32", "Float32", or "Float64"');
+	}
+
+	// 6. Let rawValue be a List of elementSize containing, in order, the elementSize sequence of bytes starting with block[byteIndex].
+	var rawValue = $slice(new $Uint8Array(arrayBuffer, byteIndex), 0, elementSize); // step 6
+
+	// 8. If isLittleEndian is not present, set isLittleEndian to either true or false. The choice is implementation dependent and should be the alternative that is most efficient for the implementation. An implementation must use the same value each time this step is executed and the same value must be used for the corresponding step in the SetValueInBuffer abstract operation.
+	var isLittleEndian = arguments.length > 3 ? arguments[3] : defaultEndianness === 'little'; // step 7
+
+	if (!isLittleEndian) {
+		$reverse(rawValue); // step 8
+	}
+
+	var bytes = $slice(safeConcat([0, 0, 0, 0, 0, 0, 0, 0], rawValue), -elementSize);
+
+	if (type === 'Float32') { // step 3
+		return bytesAsFloat32(bytes, true);
+	}
+
+	if (type === 'Float64') { // step 4
+		return bytesAsFloat64(bytes, true);
+	}
+
+	return bytesAsInteger(bytes, elementSize, isUnsignedElementType(type), false);
+};

VISUALIZACION/node_modules/es-abstract/2015/HasOwnProperty.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var has = require('has');
+
+var IsPropertyKey = require('./IsPropertyKey');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-hasownproperty
+
+module.exports = function HasOwnProperty(O, P) {
+	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');
+	}
+	return has(O, P);
+};

VISUALIZACION/node_modules/es-abstract/2015/HasProperty.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var IsPropertyKey = require('./IsPropertyKey');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-hasproperty
+
+module.exports = function HasProperty(O, P) {
+	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');
+	}
+	return P in O;
+};

VISUALIZACION/node_modules/es-abstract/2015/HourFromTime.js

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

VISUALIZACION/node_modules/es-abstract/2015/InLeapYear.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $EvalError = GetIntrinsic('%EvalError%');
+
+var DaysInYear = require('./DaysInYear');
+var YearFromTime = require('./YearFromTime');
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.3
+
+module.exports = function InLeapYear(t) {
+	var days = DaysInYear(YearFromTime(t));
+	if (days === 365) {
+		return 0;
+	}
+	if (days === 366) {
+		return 1;
+	}
+	throw new $EvalError('Assertion failed: there are not 365 or 366 days in a year, got: ' + days);
+};

VISUALIZACION/node_modules/es-abstract/2015/InstanceofOperator.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var $hasInstance = GetIntrinsic('Symbol.hasInstance', true);
+
+var Call = require('./Call');
+var GetMethod = require('./GetMethod');
+var IsCallable = require('./IsCallable');
+var OrdinaryHasInstance = require('./OrdinaryHasInstance');
+var ToBoolean = require('./ToBoolean');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-instanceofoperator
+
+module.exports = function InstanceofOperator(O, C) {
+	if (Type(O) !== 'Object') {
+		throw new $TypeError('Assertion failed: Type(O) is not Object');
+	}
+	var instOfHandler = $hasInstance ? GetMethod(C, $hasInstance) : void 0;
+	if (typeof instOfHandler !== 'undefined') {
+		return ToBoolean(Call(instOfHandler, C, [O]));
+	}
+	if (!IsCallable(C)) {
+		throw new $TypeError('`C` is not Callable');
+	}
+	return OrdinaryHasInstance(C, O);
+};

VISUALIZACION/node_modules/es-abstract/2015/Invoke.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Call = require('./Call');
+var IsArray = require('./IsArray');
+var GetV = require('./GetV');
+var IsPropertyKey = require('./IsPropertyKey');
+
+// https://262.ecma-international.org/6.0/#sec-invoke
+
+module.exports = function Invoke(O, P) {
+	if (!IsPropertyKey(P)) {
+		throw new $TypeError('Assertion failed: P must be a Property Key');
+	}
+	var argumentsList = arguments.length > 2 ? arguments[2] : [];
+	if (!IsArray(argumentsList)) {
+		throw new $TypeError('Assertion failed: optional `argumentsList`, if provided, must be a List');
+	}
+	var func = GetV(O, P);
+	return Call(func, O, argumentsList);
+};

VISUALIZACION/node_modules/es-abstract/2015/IsAccessorDescriptor.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var has = require('has');
+
+var Type = require('./Type');
+
+var assertRecord = require('../helpers/assertRecord');
+
+// https://262.ecma-international.org/5.1/#sec-8.10.1
+
+module.exports = function IsAccessorDescriptor(Desc) {
+	if (typeof Desc === 'undefined') {
+		return false;
+	}
+
+	assertRecord(Type, 'Property Descriptor', 'Desc', Desc);
+
+	if (!has(Desc, '[[Get]]') && !has(Desc, '[[Set]]')) {
+		return false;
+	}
+
+	return true;
+};

VISUALIZACION/node_modules/es-abstract/2015/IsArray.js

@@ -0,0 +1,4 @@
+'use strict';
+
+// https://262.ecma-international.org/6.0/#sec-isarray
+module.exports = require('../helpers/IsArray');

VISUALIZACION/node_modules/es-abstract/2015/IsCallable.js

@@ -0,0 +1,5 @@
+'use strict';
+
+// http://262.ecma-international.org/5.1/#sec-9.11
+
+module.exports = require('is-callable');

VISUALIZACION/node_modules/es-abstract/2015/IsCompatiblePropertyDescriptor.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var ValidateAndApplyPropertyDescriptor = require('./ValidateAndApplyPropertyDescriptor');
+
+// https://262.ecma-international.org/6.0/#sec-iscompatiblepropertydescriptor
+
+module.exports = function IsCompatiblePropertyDescriptor(Extensible, Desc, Current) {
+	return ValidateAndApplyPropertyDescriptor(undefined, undefined, Extensible, Desc, Current);
+};

VISUALIZACION/node_modules/es-abstract/2015/IsConcatSpreadable.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $isConcatSpreadable = GetIntrinsic('%Symbol.isConcatSpreadable%', true);
+
+var Get = require('./Get');
+var IsArray = require('./IsArray');
+var ToBoolean = require('./ToBoolean');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-isconcatspreadable
+
+module.exports = function IsConcatSpreadable(O) {
+	if (Type(O) !== 'Object') {
+		return false;
+	}
+	if ($isConcatSpreadable) {
+		var spreadable = Get(O, $isConcatSpreadable);
+		if (typeof spreadable !== 'undefined') {
+			return ToBoolean(spreadable);
+		}
+	}
+	return IsArray(O);
+};

VISUALIZACION/node_modules/es-abstract/2015/IsConstructor.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var GetIntrinsic = require('../GetIntrinsic.js');
+
+var $construct = GetIntrinsic('%Reflect.construct%', true);
+
+var DefinePropertyOrThrow = require('./DefinePropertyOrThrow');
+try {
+	DefinePropertyOrThrow({}, '', { '[[Get]]': function () {} });
+} catch (e) {
+	// Accessor properties aren't supported
+	DefinePropertyOrThrow = null;
+}
+
+// https://262.ecma-international.org/6.0/#sec-isconstructor
+
+if (DefinePropertyOrThrow && $construct) {
+	var isConstructorMarker = {};
+	var badArrayLike = {};
+	DefinePropertyOrThrow(badArrayLike, 'length', {
+		'[[Get]]': function () {
+			throw isConstructorMarker;
+		},
+		'[[Enumerable]]': true
+	});
+
+	module.exports = function IsConstructor(argument) {
+		try {
+			// `Reflect.construct` invokes `IsConstructor(target)` before `Get(args, 'length')`:
+			$construct(argument, badArrayLike);
+		} catch (err) {
+			return err === isConstructorMarker;
+		}
+	};
+} else {
+	module.exports = function IsConstructor(argument) {
+		// unfortunately there's no way to truly check this without try/catch `new argument` in old environments
+		return typeof argument === 'function' && !!argument.prototype;
+	};
+}

VISUALIZACION/node_modules/es-abstract/2015/IsDataDescriptor.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var has = require('has');
+
+var Type = require('./Type');
+
+var assertRecord = require('../helpers/assertRecord');
+
+// https://262.ecma-international.org/5.1/#sec-8.10.2
+
+module.exports = function IsDataDescriptor(Desc) {
+	if (typeof Desc === 'undefined') {
+		return false;
+	}
+
+	assertRecord(Type, 'Property Descriptor', 'Desc', Desc);
+
+	if (!has(Desc, '[[Value]]') && !has(Desc, '[[Writable]]')) {
+		return false;
+	}
+
+	return true;
+};

VISUALIZACION/node_modules/es-abstract/2015/IsDetachedBuffer.js

@@ -0,0 +1,27 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var $byteLength = require('array-buffer-byte-length');
+
+var isArrayBuffer = require('is-array-buffer');
+
+var availableTypedArrays = require('available-typed-arrays')();
+
+// https://262.ecma-international.org/6.0/#sec-isdetachedbuffer
+
+module.exports = function IsDetachedBuffer(arrayBuffer) {
+	if (!isArrayBuffer(arrayBuffer)) {
+		throw new $TypeError('Assertion failed: `arrayBuffer` must be an Object with an [[ArrayBufferData]] internal slot');
+	}
+	if ($byteLength(arrayBuffer) === 0) {
+		try {
+			new global[availableTypedArrays[0]](arrayBuffer); // eslint-disable-line no-new
+		} catch (error) {
+			return !!error && error.name === 'TypeError';
+		}
+	}
+	return false;
+};

VISUALIZACION/node_modules/es-abstract/2015/IsExtensible.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $preventExtensions = GetIntrinsic('%Object.preventExtensions%', true);
+var $isExtensible = GetIntrinsic('%Object.isExtensible%', true);
+
+var isPrimitive = require('../helpers/isPrimitive');
+
+// https://262.ecma-international.org/6.0/#sec-isextensible-o
+
+module.exports = $preventExtensions
+	? function IsExtensible(obj) {
+		return !isPrimitive(obj) && $isExtensible(obj);
+	}
+	: function IsExtensible(obj) {
+		return !isPrimitive(obj);
+	};

VISUALIZACION/node_modules/es-abstract/2015/IsGenericDescriptor.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var assertRecord = require('../helpers/assertRecord');
+
+var IsAccessorDescriptor = require('./IsAccessorDescriptor');
+var IsDataDescriptor = require('./IsDataDescriptor');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-isgenericdescriptor
+
+module.exports = function IsGenericDescriptor(Desc) {
+	if (typeof Desc === 'undefined') {
+		return false;
+	}
+
+	assertRecord(Type, 'Property Descriptor', 'Desc', Desc);
+
+	if (!IsAccessorDescriptor(Desc) && !IsDataDescriptor(Desc)) {
+		return true;
+	}
+
+	return false;
+};

VISUALIZACION/node_modules/es-abstract/2015/IsInteger.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var isInteger = require('../helpers/isInteger');
+
+// https://262.ecma-international.org/6.0/#sec-isinteger
+
+module.exports = function IsInteger(argument) {
+	return isInteger(argument);
+};

VISUALIZACION/node_modules/es-abstract/2015/IsPromise.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var callBound = require('call-bind/callBound');
+
+var $PromiseThen = callBound('Promise.prototype.then', true);
+
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-ispromise
+
+module.exports = function IsPromise(x) {
+	if (Type(x) !== 'Object') {
+		return false;
+	}
+	if (!$PromiseThen) { // Promises are not supported
+		return false;
+	}
+	try {
+		$PromiseThen(x); // throws if not a promise
+	} catch (e) {
+		return false;
+	}
+	return true;
+};

VISUALIZACION/node_modules/es-abstract/2015/IsPropertyDescriptor.js

@@ -0,0 +1,19 @@
+'use strict';
+
+// TODO, semver-major: delete this
+
+var isPropertyDescriptor = require('../helpers/isPropertyDescriptor');
+
+var Type = require('./Type');
+var IsDataDescriptor = require('./IsDataDescriptor');
+var IsAccessorDescriptor = require('./IsAccessorDescriptor');
+
+// https://262.ecma-international.org/6.0/#sec-property-descriptor-specification-type
+
+module.exports = function IsPropertyDescriptor(Desc) {
+	return isPropertyDescriptor({
+		IsDataDescriptor: IsDataDescriptor,
+		IsAccessorDescriptor: IsAccessorDescriptor,
+		Type: Type
+	}, Desc);
+};

VISUALIZACION/node_modules/es-abstract/2015/IsPropertyKey.js

@@ -0,0 +1,7 @@
+'use strict';
+
+// https://262.ecma-international.org/6.0/#sec-ispropertykey
+
+module.exports = function IsPropertyKey(argument) {
+	return typeof argument === 'string' || typeof argument === 'symbol';
+};

VISUALIZACION/node_modules/es-abstract/2015/IsRegExp.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $match = GetIntrinsic('%Symbol.match%', true);
+
+var hasRegExpMatcher = require('is-regex');
+
+var ToBoolean = require('./ToBoolean');
+
+// https://262.ecma-international.org/6.0/#sec-isregexp
+
+module.exports = function IsRegExp(argument) {
+	if (!argument || typeof argument !== 'object') {
+		return false;
+	}
+	if ($match) {
+		var isRegExp = argument[$match];
+		if (typeof isRegExp !== 'undefined') {
+			return ToBoolean(isRegExp);
+		}
+	}
+	return hasRegExpMatcher(argument);
+};

VISUALIZACION/node_modules/es-abstract/2015/IsWordChar.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var IsArray = require('./IsArray');
+var IsInteger = require('./IsInteger');
+
+var every = require('../helpers/every');
+var regexTester = require('safe-regex-test');
+
+var isChar = function isChar(c) {
+	return typeof c === 'string' && c.length === 1;
+};
+
+var isWordCharacter = regexTester(/^[a-zA-Z0-9_]$/);
+
+// https://262.ecma-international.org/6.0/#sec-runtime-semantics-iswordchar-abstract-operation
+
+// note: prior to ES2023, this AO erroneously omitted the latter of its arguments.
+module.exports = function IsWordChar(e, InputLength, Input) {
+	if (!IsInteger(e)) {
+		throw new $TypeError('Assertion failed: `e` must be an integer');
+	}
+	if (!IsInteger(InputLength)) {
+		throw new $TypeError('Assertion failed: `InputLength` must be an integer');
+	}
+	if (!IsArray(Input) || !every(Input, isChar)) {
+		throw new $TypeError('Assertion failed: `Input` must be a List of characters');
+	}
+	if (e === -1 || e === InputLength) {
+		return false; // step 1
+	}
+
+	var c = Input[e]; // step 2
+
+	return isWordCharacter(c); // steps 3-4
+};

VISUALIZACION/node_modules/es-abstract/2015/IteratorClose.js

@@ -0,0 +1,51 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Call = require('./Call');
+var CompletionRecord = require('./CompletionRecord');
+var GetMethod = require('./GetMethod');
+var IsCallable = require('./IsCallable');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-iteratorclose
+
+module.exports = function IteratorClose(iterator, completion) {
+	if (Type(iterator) !== 'Object') {
+		throw new $TypeError('Assertion failed: Type(iterator) is not Object');
+	}
+	if (!IsCallable(completion) && !(completion instanceof CompletionRecord)) {
+		throw new $TypeError('Assertion failed: completion is not a thunk representing a Completion Record, nor a Completion Record instance');
+	}
+	var completionThunk = completion instanceof CompletionRecord ? function () { return completion['?'](); } : completion;
+
+	var iteratorReturn = GetMethod(iterator, 'return');
+
+	if (typeof iteratorReturn === 'undefined') {
+		return completionThunk();
+	}
+
+	var completionRecord;
+	try {
+		var innerResult = Call(iteratorReturn, iterator, []);
+	} catch (e) {
+		// if we hit here, then "e" is the innerResult completion that needs re-throwing
+
+		// if the completion is of type "throw", this will throw.
+		completionThunk();
+		completionThunk = null; // ensure it's not called twice.
+
+		// if not, then return the innerResult completion
+		throw e;
+	}
+	completionRecord = completionThunk(); // if innerResult worked, then throw if the completion does
+	completionThunk = null; // ensure it's not called twice.
+
+	if (Type(innerResult) !== 'Object') {
+		throw new $TypeError('iterator .return must return an object');
+	}
+
+	return completionRecord;
+};

VISUALIZACION/node_modules/es-abstract/2015/IteratorComplete.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Get = require('./Get');
+var ToBoolean = require('./ToBoolean');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-iteratorcomplete
+
+module.exports = function IteratorComplete(iterResult) {
+	if (Type(iterResult) !== 'Object') {
+		throw new $TypeError('Assertion failed: Type(iterResult) is not Object');
+	}
+	return ToBoolean(Get(iterResult, 'done'));
+};

VISUALIZACION/node_modules/es-abstract/2015/IteratorNext.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Invoke = require('./Invoke');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-iteratornext
+
+module.exports = function IteratorNext(iterator, value) {
+	var result = Invoke(iterator, 'next', arguments.length < 2 ? [] : [value]);
+	if (Type(result) !== 'Object') {
+		throw new $TypeError('iterator next must return an object');
+	}
+	return result;
+};

VISUALIZACION/node_modules/es-abstract/2015/IteratorStep.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var IteratorComplete = require('./IteratorComplete');
+var IteratorNext = require('./IteratorNext');
+
+// https://262.ecma-international.org/6.0/#sec-iteratorstep
+
+module.exports = function IteratorStep(iterator) {
+	var result = IteratorNext(iterator);
+	var done = IteratorComplete(result);
+	return done === true ? false : result;
+};
+

VISUALIZACION/node_modules/es-abstract/2015/IteratorValue.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Get = require('./Get');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-iteratorvalue
+
+module.exports = function IteratorValue(iterResult) {
+	if (Type(iterResult) !== 'Object') {
+		throw new $TypeError('Assertion failed: Type(iterResult) is not Object');
+	}
+	return Get(iterResult, 'value');
+};
+

VISUALIZACION/node_modules/es-abstract/2015/MakeDate.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var $isFinite = require('../helpers/isFinite');
+var msPerDay = require('../helpers/timeConstants').msPerDay;
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.13
+
+module.exports = function MakeDate(day, time) {
+	if (!$isFinite(day) || !$isFinite(time)) {
+		return NaN;
+	}
+	return (day * msPerDay) + time;
+};

VISUALIZACION/node_modules/es-abstract/2015/MakeDay.js

@@ -0,0 +1,33 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $DateUTC = GetIntrinsic('%Date.UTC%');
+
+var $isFinite = require('../helpers/isFinite');
+
+var DateFromTime = require('./DateFromTime');
+var Day = require('./Day');
+var floor = require('./floor');
+var modulo = require('./modulo');
+var MonthFromTime = require('./MonthFromTime');
+var ToInteger = require('./ToInteger');
+var YearFromTime = require('./YearFromTime');
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.12
+
+module.exports = function MakeDay(year, month, date) {
+	if (!$isFinite(year) || !$isFinite(month) || !$isFinite(date)) {
+		return NaN;
+	}
+	var y = ToInteger(year);
+	var m = ToInteger(month);
+	var dt = ToInteger(date);
+	var ym = y + floor(m / 12);
+	var mn = modulo(m, 12);
+	var t = $DateUTC(ym, mn, 1);
+	if (YearFromTime(t) !== ym || MonthFromTime(t) !== mn || DateFromTime(t) !== 1) {
+		return NaN;
+	}
+	return Day(t) + dt - 1;
+};

VISUALIZACION/node_modules/es-abstract/2015/MakeTime.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var $isFinite = require('../helpers/isFinite');
+var timeConstants = require('../helpers/timeConstants');
+var msPerSecond = timeConstants.msPerSecond;
+var msPerMinute = timeConstants.msPerMinute;
+var msPerHour = timeConstants.msPerHour;
+
+var ToInteger = require('./ToInteger');
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.11
+
+module.exports = function MakeTime(hour, min, sec, ms) {
+	if (!$isFinite(hour) || !$isFinite(min) || !$isFinite(sec) || !$isFinite(ms)) {
+		return NaN;
+	}
+	var h = ToInteger(hour);
+	var m = ToInteger(min);
+	var s = ToInteger(sec);
+	var milli = ToInteger(ms);
+	var t = (h * msPerHour) + (m * msPerMinute) + (s * msPerSecond) + milli;
+	return t;
+};

VISUALIZACION/node_modules/es-abstract/2015/MinFromTime.js

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

VISUALIZACION/node_modules/es-abstract/2015/MonthFromTime.js

@@ -0,0 +1,47 @@
+'use strict';
+
+var DayWithinYear = require('./DayWithinYear');
+var InLeapYear = require('./InLeapYear');
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.4
+
+module.exports = function MonthFromTime(t) {
+	var day = DayWithinYear(t);
+	if (0 <= day && day < 31) {
+		return 0;
+	}
+	var leap = InLeapYear(t);
+	if (31 <= day && day < (59 + leap)) {
+		return 1;
+	}
+	if ((59 + leap) <= day && day < (90 + leap)) {
+		return 2;
+	}
+	if ((90 + leap) <= day && day < (120 + leap)) {
+		return 3;
+	}
+	if ((120 + leap) <= day && day < (151 + leap)) {
+		return 4;
+	}
+	if ((151 + leap) <= day && day < (181 + leap)) {
+		return 5;
+	}
+	if ((181 + leap) <= day && day < (212 + leap)) {
+		return 6;
+	}
+	if ((212 + leap) <= day && day < (243 + leap)) {
+		return 7;
+	}
+	if ((243 + leap) <= day && day < (273 + leap)) {
+		return 8;
+	}
+	if ((273 + leap) <= day && day < (304 + leap)) {
+		return 9;
+	}
+	if ((304 + leap) <= day && day < (334 + leap)) {
+		return 10;
+	}
+	if ((334 + leap) <= day && day < (365 + leap)) {
+		return 11;
+	}
+};

VISUALIZACION/node_modules/es-abstract/2015/NewPromiseCapability.js

@@ -0,0 +1,36 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var IsCallable = require('es-abstract/2022/IsCallable');
+var IsConstructor = require('es-abstract/2022/IsConstructor');
+
+// https://262.ecma-international.org/6.0/#sec-newpromisecapability
+
+module.exports = function NewPromiseCapability(C) {
+	if (!IsConstructor(C)) {
+		throw new $TypeError('C must be a constructor'); // step 1
+	}
+
+	var resolvingFunctions = { '[[Resolve]]': void undefined, '[[Reject]]': void undefined }; // step 3
+
+	var promise = new C(function (resolve, reject) { // steps 4-5
+		if (typeof resolvingFunctions['[[Resolve]]'] !== 'undefined' || typeof resolvingFunctions['[[Reject]]'] !== 'undefined') {
+			throw new $TypeError('executor has already been called'); // step 4.a, 4.b
+		}
+		resolvingFunctions['[[Resolve]]'] = resolve; // step 4.c
+		resolvingFunctions['[[Reject]]'] = reject; // step 4.d
+	}); // step 4-6
+
+	if (!IsCallable(resolvingFunctions['[[Resolve]]']) || !IsCallable(resolvingFunctions['[[Reject]]'])) {
+		throw new $TypeError('executor must provide valid resolve and reject functions'); // steps 7-8
+	}
+
+	return {
+		'[[Promise]]': promise,
+		'[[Resolve]]': resolvingFunctions['[[Resolve]]'],
+		'[[Reject]]': resolvingFunctions['[[Reject]]']
+	}; // step 9
+};

VISUALIZACION/node_modules/es-abstract/2015/NormalCompletion.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var CompletionRecord = require('./CompletionRecord');
+
+// https://262.ecma-international.org/6.0/#sec-normalcompletion
+
+module.exports = function NormalCompletion(value) {
+	return new CompletionRecord('normal', value);
+};

VISUALIZACION/node_modules/es-abstract/2015/ObjectCreate.js

@@ -0,0 +1,50 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $ObjectCreate = GetIntrinsic('%Object.create%', true);
+var $TypeError = GetIntrinsic('%TypeError%');
+var $SyntaxError = GetIntrinsic('%SyntaxError%');
+
+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/6.0/#sec-objectcreate
+
+module.exports = function ObjectCreate(proto, internalSlotsList) {
+	if (proto !== null && Type(proto) !== 'Object') {
+		throw new $TypeError('Assertion failed: `proto` must be null or an object');
+	}
+	var slots = arguments.length < 2 ? [] : internalSlotsList; // step 1
+	if (arguments.length >= 2 && !IsArray(slots)) {
+		throw new $TypeError('Assertion failed: `internalSlotsList` must be an Array');
+	}
+
+	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 (slots.length > 0) {
+		forEach(slots, function (slot) {
+			SLOT.set(O, slot, void undefined);
+		});
+	}
+
+	return O; // step 6
+};

VISUALIZACION/node_modules/es-abstract/2015/ObjectDefineProperties.js

@@ -0,0 +1,38 @@
+'use strict';
+
+var callBound = require('call-bind/callBound');
+
+var DefinePropertyOrThrow = require('./DefinePropertyOrThrow');
+var Get = require('./Get');
+var ToObject = require('./ToObject');
+var ToPropertyDescriptor = require('./ToPropertyDescriptor');
+
+var forEach = require('../helpers/forEach');
+var getOwnPropertyDescriptor = require('gopd');
+var OwnPropertyKeys = require('../helpers/OwnPropertyKeys');
+
+var $push = callBound('Array.prototype.push');
+
+// https://262.ecma-international.org/6.0/#sec-objectdefineproperties
+module.exports = function ObjectDefineProperties(O, Properties) {
+	var props = ToObject(Properties); // step 1
+	var keys = OwnPropertyKeys(props); // step 2
+	var descriptors = []; // step 3
+
+	forEach(keys, function (nextKey) { // step 4
+		var propDesc = ToPropertyDescriptor(getOwnPropertyDescriptor(props, nextKey)); // step 4.a
+		if (typeof propDesc !== 'undefined' && propDesc['[[Enumerable]]']) { // step 4.b
+			var descObj = Get(props, nextKey); // step 4.b.i
+			var desc = ToPropertyDescriptor(descObj); // step 4.b.ii
+			$push(descriptors, [nextKey, desc]); // step 4.b.iii
+		}
+	});
+
+	forEach(descriptors, function (pair) { // step 5
+		var P = pair[0]; // step 5.a
+		var desc = pair[1]; // step 5.b
+		DefinePropertyOrThrow(O, P, desc); // step 5.c
+	});
+
+	return O; // step 6
+};

VISUALIZACION/node_modules/es-abstract/2015/OrdinaryCreateFromConstructor.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var GetPrototypeFromConstructor = require('./GetPrototypeFromConstructor');
+var IsArray = require('./IsArray');
+var ObjectCreate = require('./ObjectCreate');
+
+// https://262.ecma-international.org/6.0/#sec-ordinarycreatefromconstructor
+
+module.exports = function OrdinaryCreateFromConstructor(constructor, intrinsicDefaultProto) {
+	GetIntrinsic(intrinsicDefaultProto); // throws if not a valid intrinsic
+	var proto = GetPrototypeFromConstructor(constructor, intrinsicDefaultProto);
+	var slots = arguments.length < 3 ? [] : arguments[2];
+	if (!IsArray(slots)) {
+		throw new $TypeError('Assertion failed: if provided, `internalSlotsList` must be a List');
+	}
+	return ObjectCreate(proto, slots);
+};

VISUALIZACION/node_modules/es-abstract/2015/OrdinaryDefineOwnProperty.js

@@ -0,0 +1,61 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $gOPD = require('gopd');
+var $SyntaxError = GetIntrinsic('%SyntaxError%');
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var isPropertyDescriptor = require('../helpers/isPropertyDescriptor');
+
+var IsAccessorDescriptor = require('./IsAccessorDescriptor');
+var IsDataDescriptor = require('./IsDataDescriptor');
+var IsExtensible = require('./IsExtensible');
+var IsPropertyKey = require('./IsPropertyKey');
+var ToPropertyDescriptor = require('./ToPropertyDescriptor');
+var SameValue = require('./SameValue');
+var Type = require('./Type');
+var ValidateAndApplyPropertyDescriptor = require('./ValidateAndApplyPropertyDescriptor');
+
+// https://262.ecma-international.org/6.0/#sec-ordinarydefineownproperty
+
+module.exports = function OrdinaryDefineOwnProperty(O, P, Desc) {
+	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 (!isPropertyDescriptor({
+		Type: Type,
+		IsDataDescriptor: IsDataDescriptor,
+		IsAccessorDescriptor: IsAccessorDescriptor
+	}, Desc)) {
+		throw new $TypeError('Assertion failed: Desc must be a Property Descriptor');
+	}
+	if (!$gOPD) {
+		// ES3/IE 8 fallback
+		if (IsAccessorDescriptor(Desc)) {
+			throw new $SyntaxError('This environment does not support accessor property descriptors.');
+		}
+		var creatingNormalDataProperty = !(P in O)
+			&& Desc['[[Writable]]']
+			&& Desc['[[Enumerable]]']
+			&& Desc['[[Configurable]]']
+			&& '[[Value]]' in Desc;
+		var settingExistingDataProperty = (P in O)
+			&& (!('[[Configurable]]' in Desc) || Desc['[[Configurable]]'])
+			&& (!('[[Enumerable]]' in Desc) || Desc['[[Enumerable]]'])
+			&& (!('[[Writable]]' in Desc) || Desc['[[Writable]]'])
+			&& '[[Value]]' in Desc;
+		if (creatingNormalDataProperty || settingExistingDataProperty) {
+			O[P] = Desc['[[Value]]']; // eslint-disable-line no-param-reassign
+			return SameValue(O[P], Desc['[[Value]]']);
+		}
+		throw new $SyntaxError('This environment does not support defining non-writable, non-enumerable, or non-configurable properties');
+	}
+	var desc = $gOPD(O, P);
+	var current = desc && ToPropertyDescriptor(desc);
+	var extensible = IsExtensible(O);
+	return ValidateAndApplyPropertyDescriptor(O, P, extensible, Desc, current);
+};

VISUALIZACION/node_modules/es-abstract/2015/OrdinaryGetOwnProperty.js

@@ -0,0 +1,44 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $gOPD = require('gopd');
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var callBound = require('call-bind/callBound');
+
+var $isEnumerable = callBound('Object.prototype.propertyIsEnumerable');
+
+var has = require('has');
+
+var IsArray = require('./IsArray');
+var IsPropertyKey = require('./IsPropertyKey');
+var IsRegExp = require('./IsRegExp');
+var ToPropertyDescriptor = require('./ToPropertyDescriptor');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-ordinarygetownproperty
+
+module.exports = function OrdinaryGetOwnProperty(O, P) {
+	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 (!has(O, P)) {
+		return void 0;
+	}
+	if (!$gOPD) {
+		// ES3 / IE 8 fallback
+		var arrayLength = IsArray(O) && P === 'length';
+		var regexLastIndex = IsRegExp(O) && P === 'lastIndex';
+		return {
+			'[[Configurable]]': !(arrayLength || regexLastIndex),
+			'[[Enumerable]]': $isEnumerable(O, P),
+			'[[Value]]': O[P],
+			'[[Writable]]': true
+		};
+	}
+	return ToPropertyDescriptor($gOPD(O, P));
+};

VISUALIZACION/node_modules/es-abstract/2015/OrdinaryHasInstance.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+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;
+};

VISUALIZACION/node_modules/es-abstract/2015/OrdinaryHasProperty.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+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;
+};

VISUALIZACION/node_modules/es-abstract/2015/QuoteJSONString.js

@@ -0,0 +1,52 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var callBound = require('call-bind/callBound');
+var forEach = require('../helpers/forEach');
+
+var $charCodeAt = callBound('String.prototype.charCodeAt');
+var $numberToString = callBound('Number.prototype.toString');
+var $toLowerCase = callBound('String.prototype.toLowerCase');
+var $strSlice = callBound('String.prototype.slice');
+var $strSplit = callBound('String.prototype.split');
+
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-quotejsonstring
+
+var escapes = {
+	'\u0008': 'b',
+	'\u000C': 'f',
+	'\u000A': 'n',
+	'\u000D': 'r',
+	'\u0009': 't'
+};
+
+module.exports = function QuoteJSONString(value) {
+	if (Type(value) !== 'String') {
+		throw new $TypeError('Assertion failed: `value` must be a String');
+	}
+	var product = '"';
+	if (value) {
+		forEach($strSplit(value), function (C) {
+			if (C === '"' || C === '\\') {
+				product += '\u005C' + C;
+			} else if (C === '\u0008' || C === '\u000C' || C === '\u000A' || C === '\u000D' || C === '\u0009') {
+				var abbrev = escapes[C];
+				product += '\u005C' + abbrev;
+			} else {
+				var cCharCode = $charCodeAt(C, 0);
+				if (cCharCode < 0x20) {
+					product += '\u005Cu' + $toLowerCase($strSlice('0000' + $numberToString(cCharCode, 16), -4));
+				} else {
+					product += C;
+				}
+			}
+		});
+	}
+	product += '"';
+	return product;
+};

VISUALIZACION/node_modules/es-abstract/2015/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);
+};

VISUALIZACION/node_modules/es-abstract/2015/RegExpExec.js

@@ -0,0 +1,32 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+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 (Type(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 (result === null || Type(result) === 'Object') {
+			return result;
+		}
+		throw new $TypeError('"exec" method must return `null` or an Object');
+	}
+	return regexExec(R, S);
+};

VISUALIZACION/node_modules/es-abstract/2015/RequireObjectCoercible.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('../5/CheckObjectCoercible');

VISUALIZACION/node_modules/es-abstract/2015/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);
+};

VISUALIZACION/node_modules/es-abstract/2015/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));
+};

VISUALIZACION/node_modules/es-abstract/2015/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);
+};

VISUALIZACION/node_modules/es-abstract/2015/Set.js

@@ -0,0 +1,47 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+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 (Type(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;
+	}
+
+};

VISUALIZACION/node_modules/es-abstract/2015/SetFunctionName.js

@@ -0,0 +1,44 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var has = require('has');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var getSymbolDescription = require('get-symbol-description');
+
+var DefinePropertyOrThrow = require('./DefinePropertyOrThrow');
+var IsExtensible = require('./IsExtensible');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-setfunctionname
+
+module.exports = function SetFunctionName(F, name) {
+	if (typeof F !== 'function') {
+		throw new $TypeError('Assertion failed: `F` must be a function');
+	}
+	if (!IsExtensible(F) || has(F, 'name')) {
+		throw new $TypeError('Assertion failed: `F` must be extensible, and must not have a `name` own property');
+	}
+	var nameType = Type(name);
+	if (nameType !== 'Symbol' && nameType !== 'String') {
+		throw new $TypeError('Assertion failed: `name` must be a Symbol or a String');
+	}
+	if (nameType === 'Symbol') {
+		var description = getSymbolDescription(name);
+		// eslint-disable-next-line no-param-reassign
+		name = typeof description === 'undefined' ? '' : '[' + description + ']';
+	}
+	if (arguments.length > 2) {
+		var prefix = arguments[2];
+		// eslint-disable-next-line no-param-reassign
+		name = prefix + ' ' + name;
+	}
+	return DefinePropertyOrThrow(F, 'name', {
+		'[[Value]]': name,
+		'[[Writable]]': false,
+		'[[Enumerable]]': false,
+		'[[Configurable]]': true
+	});
+};

VISUALIZACION/node_modules/es-abstract/2015/SetIntegrityLevel.js

@@ -0,0 +1,57 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $SyntaxError = GetIntrinsic('%SyntaxError%');
+var $TypeError = GetIntrinsic('%TypeError%');
+var $preventExtensions = GetIntrinsic('%Object.preventExtensions%', true);
+var $gOPD = require('gopd');
+var $gOPN = GetIntrinsic('%Object.getOwnPropertyNames%', true);
+
+var forEach = require('../helpers/forEach');
+
+var DefinePropertyOrThrow = require('./DefinePropertyOrThrow');
+var IsAccessorDescriptor = require('./IsAccessorDescriptor');
+var ToPropertyDescriptor = require('./ToPropertyDescriptor');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-setintegritylevel
+
+module.exports = function SetIntegrityLevel(O, level) {
+	if (Type(O) !== 'Object') {
+		throw new $TypeError('Assertion failed: Type(O) is not Object');
+	}
+	if (level !== 'sealed' && level !== 'frozen') {
+		throw new $TypeError('Assertion failed: `level` must be `"sealed"` or `"frozen"`');
+	}
+	if (!$preventExtensions) {
+		throw new $SyntaxError('SetIntegrityLevel requires native `Object.preventExtensions` support');
+	}
+	var status = $preventExtensions(O);
+	if (!status) {
+		return false;
+	}
+	if (!$gOPN) {
+		throw new $SyntaxError('SetIntegrityLevel requires native `Object.getOwnPropertyNames` support');
+	}
+	var theKeys = $gOPN(O);
+	if (level === 'sealed') {
+		forEach(theKeys, function (k) {
+			DefinePropertyOrThrow(O, k, { configurable: false });
+		});
+	} else if (level === 'frozen') {
+		forEach(theKeys, function (k) {
+			var currentDesc = $gOPD(O, k);
+			if (typeof currentDesc !== 'undefined') {
+				var desc;
+				if (IsAccessorDescriptor(ToPropertyDescriptor(currentDesc))) {
+					desc = { configurable: false };
+				} else {
+					desc = { configurable: false, writable: false };
+				}
+				DefinePropertyOrThrow(O, k, desc);
+			}
+		});
+	}
+	return true;
+};

VISUALIZACION/node_modules/es-abstract/2015/SetValueInBuffer.js

@@ -0,0 +1,120 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var isInteger = require('../helpers/isInteger');
+
+var IsDetachedBuffer = require('./IsDetachedBuffer');
+var ToInt16 = require('./ToInt16');
+var ToInt32 = require('./ToInt32');
+var ToInt8 = require('./ToInt8');
+var ToUint16 = require('./ToUint16');
+var ToUint32 = require('./ToUint32');
+var ToUint8 = require('./ToUint8');
+var ToUint8Clamp = require('./ToUint8Clamp');
+
+var isArrayBuffer = require('is-array-buffer');
+var has = require('has');
+
+var table49 = {
+	__proto__: null,
+	Int8: 1,
+	Uint8: 1,
+	Uint8C: 1,
+	Int16: 2,
+	Uint16: 2,
+	Int32: 4,
+	Uint32: 4,
+	Float32: 4,
+	Float64: 8
+};
+
+var TypeToAO = {
+	__proto__: null,
+	Int8: ToInt8,
+	Uint8: ToUint8,
+	Uint8C: ToUint8Clamp,
+	Int16: ToInt16,
+	Uint16: ToUint16,
+	Int32: ToInt32,
+	Uint32: ToUint32
+};
+
+var defaultEndianness = require('../helpers/defaultEndianness');
+var forEach = require('../helpers/forEach');
+var integerToNBytes = require('../helpers/integerToNBytes');
+var valueToFloat32Bytes = require('../helpers/valueToFloat32Bytes');
+var valueToFloat64Bytes = require('../helpers/valueToFloat64Bytes');
+
+// https://262.ecma-international.org/6.0/#sec-setvalueinbuffer
+
+module.exports = function SetValueInBuffer(arrayBuffer, byteIndex, type, value) {
+	if (!isArrayBuffer(arrayBuffer)) {
+		throw new $TypeError('Assertion failed: `arrayBuffer` must be an ArrayBuffer');
+	}
+
+	if (!isInteger(byteIndex)) {
+		throw new $TypeError('Assertion failed: `byteIndex` must be an integer');
+	}
+
+	if (typeof type !== 'string' || !has(table49, type)) {
+		throw new $TypeError('Assertion failed: `type` must be a Typed Array Element Type');
+	}
+
+	if (typeof value !== 'number') {
+		throw new $TypeError('Assertion failed: `value` must be a number');
+	}
+
+	if (arguments.length > 4 && typeof arguments[4] !== 'boolean') {
+		throw new $TypeError('Assertion failed: `isLittleEndian` must be a boolean, if present');
+	}
+
+	if (IsDetachedBuffer(arrayBuffer)) {
+		throw new $TypeError('Assertion failed: ArrayBuffer is detached'); // step 1
+	}
+
+	// 2. Assert: There are sufficient bytes in arrayBuffer starting at byteIndex to represent a value of type.
+
+	if (byteIndex < 0) {
+		throw new $TypeError('Assertion failed: `byteIndex` must be non-negative'); // step 3
+	}
+
+	// 4. Assert: Type(value) is Number.
+
+	// 5. Let block be arrayBuffer’s [[ArrayBufferData]] internal slot.
+
+	// 6. Assert: block is not undefined.
+
+	var elementSize = table49[type]; // step 7
+	if (!elementSize) {
+		throw new $TypeError('Assertion failed: `type` must be one of "Int8", "Uint8", "Uint8C", "Int16", "Uint16", "Int32", "Uint32", "Float32", or "Float64"');
+	}
+
+	// 8. If isLittleEndian is not present, set isLittleEndian to either true or false. The choice is implementation dependent and should be the alternative that is most efficient for the implementation. An implementation must use the same value each time this step is executed and the same value must be used for the corresponding step in the GetValueFromBuffer abstract operation.
+	var isLittleEndian = arguments.length > 4 ? arguments[4] : defaultEndianness === 'little'; // step 8
+
+	var rawBytes;
+	if (type === 'Float32') { // step 1
+		rawBytes = valueToFloat32Bytes(value, isLittleEndian);
+	} else if (type === 'Float64') { // step 2
+		rawBytes = valueToFloat64Bytes(value, isLittleEndian);
+	} else {
+		var n = table49[type]; // step 3.a
+
+		var convOp = TypeToAO[type]; // step 3.b
+
+		var intValue = convOp(value); // step 3.c
+
+		rawBytes = integerToNBytes(intValue, n, isLittleEndian); // step 3.d, 3.e, 4
+	}
+
+	// 12. Store the individual bytes of rawBytes into block, in order, starting at block[byteIndex].
+	var arr = new Uint8Array(arrayBuffer, byteIndex, elementSize);
+	forEach(rawBytes, function (rawByte, i) {
+		arr[i] = rawByte;
+	});
+
+	// 13. Return NormalCompletion(undefined).
+};

VISUALIZACION/node_modules/es-abstract/2015/SpeciesConstructor.js

@@ -0,0 +1,32 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $species = GetIntrinsic('%Symbol.species%', true);
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var IsConstructor = require('./IsConstructor');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-speciesconstructor
+
+module.exports = function SpeciesConstructor(O, defaultConstructor) {
+	if (Type(O) !== 'Object') {
+		throw new $TypeError('Assertion failed: Type(O) is not Object');
+	}
+	var C = O.constructor;
+	if (typeof C === 'undefined') {
+		return defaultConstructor;
+	}
+	if (Type(C) !== 'Object') {
+		throw new $TypeError('O.constructor is not an Object');
+	}
+	var S = $species ? C[$species] : void 0;
+	if (S == null) {
+		return defaultConstructor;
+	}
+	if (IsConstructor(S)) {
+		return S;
+	}
+	throw new $TypeError('no constructor found');
+};

VISUALIZACION/node_modules/es-abstract/2015/SplitMatch.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+var callBound = require('call-bind/callBound');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Type = require('./Type');
+
+var isInteger = require('../helpers/isInteger');
+
+var $charAt = callBound('String.prototype.charAt');
+
+// https://262.ecma-international.org/6.0/#sec-splitmatch
+
+module.exports = function SplitMatch(S, q, R) {
+	if (Type(S) !== 'String') {
+		throw new $TypeError('Assertion failed: `S` must be a String');
+	}
+	if (!isInteger(q)) {
+		throw new $TypeError('Assertion failed: `q` must be an integer');
+	}
+	if (Type(R) !== 'String') {
+		throw new $TypeError('Assertion failed: `R` must be a String');
+	}
+	var r = R.length;
+	var s = S.length;
+	if (q + r > s) {
+		return false;
+	}
+
+	for (var i = 0; i < r; i += 1) {
+		if ($charAt(S, q + i) !== $charAt(R, i)) {
+			return false;
+		}
+	}
+
+	return q + r;
+};

VISUALIZACION/node_modules/es-abstract/2015/StrictEqualityComparison.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var Type = require('./Type');
+
+// https://262.ecma-international.org/5.1/#sec-11.9.6
+
+module.exports = function StrictEqualityComparison(x, y) {
+	var xType = Type(x);
+	var yType = Type(y);
+	if (xType !== yType) {
+		return false;
+	}
+	if (xType === 'Undefined' || xType === 'Null') {
+		return true;
+	}
+	return x === y; // shortcut for steps 4-7
+};

VISUALIZACION/node_modules/es-abstract/2015/StringCreate.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $Object = GetIntrinsic('%Object%');
+var $StringPrototype = GetIntrinsic('%String.prototype%');
+var $SyntaxError = GetIntrinsic('%SyntaxError%');
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var DefinePropertyOrThrow = require('./DefinePropertyOrThrow');
+var Type = require('./Type');
+
+var setProto = require('../helpers/setProto');
+
+// https://262.ecma-international.org/6.0/#sec-stringcreate
+
+module.exports = function StringCreate(value, prototype) {
+	if (Type(value) !== 'String') {
+		throw new $TypeError('Assertion failed: `S` must be a String');
+	}
+
+	var S = $Object(value);
+	if (prototype !== $StringPrototype) {
+		if (setProto) {
+			setProto(S, prototype);
+		} else {
+			throw new $SyntaxError('StringCreate: a `proto` argument that is not `String.prototype` is not supported in an environment that does not support setting the [[Prototype]]');
+		}
+	}
+
+	var length = value.length;
+	DefinePropertyOrThrow(S, 'length', {
+		'[[Configurable]]': false,
+		'[[Enumerable]]': false,
+		'[[Value]]': length,
+		'[[Writable]]': false
+	});
+
+	return S;
+};

VISUALIZACION/node_modules/es-abstract/2015/StringGetIndexProperty.js

@@ -0,0 +1,52 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+var callBound = require('call-bind/callBound');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var $charAt = callBound('String.prototype.charAt');
+
+var isString = require('is-string');
+var isNegativeZero = require('is-negative-zero');
+var unbox = require('unbox-primitive');
+
+var CanonicalNumericIndexString = require('./CanonicalNumericIndexString');
+var IsInteger = require('./IsInteger');
+var IsPropertyKey = require('./IsPropertyKey');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-stringgetindexproperty
+
+module.exports = function StringGetIndexProperty(S, P) {
+	if (typeof S === 'string' || !isString(S)) {
+		throw new $TypeError('Assertion failed: `S` must be a boxed String Object');
+	}
+	if (!IsPropertyKey(P)) {
+		throw new $TypeError('Assertion failed: `P` must be a Property Key');
+	}
+
+	if (Type(P) !== 'String') {
+		return void undefined;
+	}
+
+	var index = CanonicalNumericIndexString(P);
+	if (typeof index === 'undefined' || !IsInteger(index) || isNegativeZero(index)) {
+		return void undefined;
+	}
+
+	var str = unbox(S);
+	var len = str.length;
+	if (index < 0 || len <= index) {
+		return void undefined;
+	}
+
+	var resultStr = $charAt(str, index);
+
+	return {
+		'[[Configurable]]': false,
+		'[[Enumerable]]': true,
+		'[[Value]]': resultStr,
+		'[[Writable]]': false
+	};
+};

VISUALIZACION/node_modules/es-abstract/2015/SymbolDescriptiveString.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var callBound = require('call-bind/callBound');
+
+var $SymbolToString = callBound('Symbol.prototype.toString', true);
+
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-symboldescriptivestring
+
+module.exports = function SymbolDescriptiveString(sym) {
+	if (Type(sym) !== 'Symbol') {
+		throw new $TypeError('Assertion failed: `sym` must be a Symbol');
+	}
+	return $SymbolToString(sym);
+};

VISUALIZACION/node_modules/es-abstract/2015/TestIntegrityLevel.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $gOPD = require('gopd');
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var every = require('../helpers/every');
+var OwnPropertyKeys = require('../helpers/OwnPropertyKeys');
+
+var IsDataDescriptor = require('./IsDataDescriptor');
+var IsExtensible = require('./IsExtensible');
+var ToPropertyDescriptor = require('./ToPropertyDescriptor');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/6.0/#sec-testintegritylevel
+
+module.exports = function TestIntegrityLevel(O, level) {
+	if (Type(O) !== 'Object') {
+		throw new $TypeError('Assertion failed: Type(O) is not Object');
+	}
+	if (level !== 'sealed' && level !== 'frozen') {
+		throw new $TypeError('Assertion failed: `level` must be `"sealed"` or `"frozen"`');
+	}
+	var status = IsExtensible(O);
+	if (status) {
+		return false;
+	}
+	var theKeys = OwnPropertyKeys(O);
+	return theKeys.length === 0 || every(theKeys, function (k) {
+		var currentDesc = $gOPD(O, k);
+		if (typeof currentDesc !== 'undefined') {
+			if (currentDesc.configurable) {
+				return false;
+			}
+			if (level === 'frozen' && IsDataDescriptor(ToPropertyDescriptor(currentDesc)) && currentDesc.writable) {
+				return false;
+			}
+		}
+		return true;
+	});
+};

VISUALIZACION/node_modules/es-abstract/2015/TimeClip.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $Date = GetIntrinsic('%Date%');
+var $Number = GetIntrinsic('%Number%');
+
+var $isFinite = require('../helpers/isFinite');
+
+var abs = require('./abs');
+var ToNumber = require('./ToNumber');
+
+// https://262.ecma-international.org/5.1/#sec-15.9.1.14
+
+module.exports = function TimeClip(time) {
+	if (!$isFinite(time) || abs(time) > 8.64e15) {
+		return NaN;
+	}
+	return $Number(new $Date(ToNumber(time)));
+};
+