cdk-comprehend-s3olap 2.0.33 → 2.0.36

package/node_modules/es-abstract/2021/BigIntBitwiseOp.js

@@ -0,0 +1,66 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+// var $BigInt = GetIntrinsic('%BigInt%', true);
+// var $pow = GetIntrinsic('%Math.pow%');
+
+// var BinaryAnd = require('./BinaryAnd');
+// var BinaryOr = require('./BinaryOr');
+// var BinaryXor = require('./BinaryXor');
+var Type = require('./Type');
+// var modulo = require('./modulo');
+
+// var zero = $BigInt && $BigInt(0);
+// var negOne = $BigInt && $BigInt(-1);
+// var two = $BigInt && $BigInt(2);
+
+// https://262.ecma-international.org/11.0/#sec-bigintbitwiseop
+
+module.exports = function BigIntBitwiseOp(op, x, y) {
+	if (op !== '&' && op !== '|' && op !== '^') {
+		throw new $TypeError('Assertion failed: `op` must be `&`, `|`, or `^`');
+	}
+	if (Type(x) !== 'BigInt' || Type(y) !== 'BigInt') {
+		throw new $TypeError('`x` and `y` must be BigInts');
+	}
+
+	if (op === '&') {
+		return x & y;
+	}
+	if (op === '|') {
+		return x | y;
+	}
+	return x ^ y;
+	/*
+	var result = zero;
+	var shift = 0;
+	while (x !== zero && x !== negOne && y !== zero && y !== negOne) {
+		var xDigit = modulo(x, two);
+		var yDigit = modulo(y, two);
+		if (op === '&') {
+			result += $pow(2, shift) * BinaryAnd(xDigit, yDigit);
+		} else if (op === '|') {
+			result += $pow(2, shift) * BinaryOr(xDigit, yDigit);
+		} else if (op === '^') {
+			result += $pow(2, shift) * BinaryXor(xDigit, yDigit);
+		}
+		shift += 1;
+		x = (x - xDigit) / two;
+		y = (y - yDigit) / two;
+	}
+	var tmp;
+	if (op === '&') {
+		tmp = BinaryAnd(modulo(x, two), modulo(y, two));
+	} else if (op === '|') {
+		tmp = BinaryAnd(modulo(x, two), modulo(y, two));
+	} else {
+		tmp = BinaryXor(modulo(x, two), modulo(y, two));
+	}
+	if (tmp !== 0) {
+		result -= $pow(2, shift);
+	}
+	return result;
+	*/
+};

package/node_modules/es-abstract/2021/BinaryAnd.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+// https://262.ecma-international.org/11.0/#sec-binaryand
+
+module.exports = function BinaryAnd(x, y) {
+	if ((x !== 0 && x !== 1) || (y !== 0 && y !== 1)) {
+		throw new $TypeError('Assertion failed: `x` and `y` must be either 0 or 1');
+	}
+	return x & y;
+};

package/node_modules/es-abstract/2021/BinaryOr.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+// https://262.ecma-international.org/11.0/#sec-binaryor
+
+module.exports = function BinaryOr(x, y) {
+	if ((x !== 0 && x !== 1) || (y !== 0 && y !== 1)) {
+		throw new $TypeError('Assertion failed: `x` and `y` must be either 0 or 1');
+	}
+	return x | y;
+};

package/node_modules/es-abstract/2021/BinaryXor.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+// https://262.ecma-international.org/11.0/#sec-binaryxor
+
+module.exports = function BinaryXor(x, y) {
+	if ((x !== 0 && x !== 1) || (y !== 0 && y !== 1)) {
+		throw new $TypeError('Assertion failed: `x` and `y` must be either 0 or 1');
+	}
+	return x ^ y;
+};

package/node_modules/es-abstract/2021/ByteListBitwiseOp.js

@@ -0,0 +1,44 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+var callBound = require('call-bind/callBound');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var $push = callBound('Array.prototype.push');
+
+var IsArray = require('./IsArray');
+
+var isByteValue = require('../helpers/isByteValue');
+
+// https://ecma-international.org/ecma-262/12.0/#sec-bytelistbitwiseop
+
+module.exports = function ByteListBitwiseOp(op, xBytes, yBytes) {
+	if (op !== '&' && op !== '^' && op !== '|') {
+		throw new $TypeError('Assertion failed: `op` must be `&`, `^`, or `|`');
+	}
+	if (!IsArray(xBytes) || !IsArray(yBytes) || xBytes.length !== yBytes.length) {
+		throw new $TypeError('Assertion failed: `xBytes` and `yBytes` must be same-length sequences of byte values (an integer 0-255, inclusive)');
+	}
+
+	var result = [];
+
+	for (var i = 0; i < xBytes.length; i += 1) {
+		var xByte = xBytes[i];
+		var yByte = yBytes[i];
+		if (!isByteValue(xByte) || !isByteValue(yByte)) {
+			throw new $TypeError('Assertion failed: `xBytes` and `yBytes` must be same-length sequences of byte values (an integer 0-255, inclusive)');
+		}
+		var resultByte;
+		if (op === '&') {
+			resultByte = xByte & yByte;
+		} else if (op === '^') {
+			resultByte = xByte ^ yByte;
+		} else {
+			resultByte = xByte | yByte;
+		}
+		$push(result, resultByte);
+	}
+
+	return result;
+};

package/node_modules/es-abstract/2021/ByteListEqual.js

@@ -0,0 +1,33 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var IsArray = require('./IsArray');
+
+var isByteValue = require('../helpers/isByteValue');
+
+// https://ecma-international.org/ecma-262/12.0/#sec-bytelistequal
+
+module.exports = function ByteListEqual(xBytes, yBytes) {
+	if (!IsArray(xBytes) || !IsArray(yBytes)) {
+		throw new $TypeError('Assertion failed: `xBytes` and `yBytes` must be sequences of byte values (an integer 0-255, inclusive)');
+	}
+
+	if (xBytes.length !== yBytes.length) {
+		return false;
+	}
+
+	for (var i = 0; i < xBytes.length; i += 1) {
+		var xByte = xBytes[i];
+		var yByte = yBytes[i];
+		if (!isByteValue(xByte) || !isByteValue(yByte)) {
+			throw new $TypeError('Assertion failed: `xBytes` and `yBytes` must be sequences of byte values (an integer 0-255, inclusive)');
+		}
+		if (xByte !== yByte) {
+			return false;
+		}
+	}
+	return true;
+};

package/node_modules/es-abstract/2021/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://ecma-international.org/ecma-262/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);
+};

package/node_modules/es-abstract/2021/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://ecma-international.org/ecma-262/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;
+};

package/node_modules/es-abstract/2021/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;
+};

package/node_modules/es-abstract/2021/ClearKeptObjects.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var SLOT = require('internal-slot');
+var keptObjects = [];
+
+// https://ecma-international.org/ecma-262/12.0/#sec-clear-kept-objects
+
+module.exports = function ClearKeptObjects() {
+	keptObjects.length = 0;
+};
+
+SLOT.set(module.exports, '[[es-abstract internal: KeptAlive]]', keptObjects);

package/node_modules/es-abstract/2021/CodePointAt.js

@@ -0,0 +1,58 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+var callBound = require('call-bind/callBound');
+var isLeadingSurrogate = require('../helpers/isLeadingSurrogate');
+var isTrailingSurrogate = require('../helpers/isTrailingSurrogate');
+
+var Type = require('./Type');
+var UTF16SurrogatePairToCodePoint = require('./UTF16SurrogatePairToCodePoint');
+
+var $charAt = callBound('String.prototype.charAt');
+var $charCodeAt = callBound('String.prototype.charCodeAt');
+
+// https://ecma-international.org/ecma-262/12.0/#sec-codepointat
+
+module.exports = function CodePointAt(string, position) {
+	if (Type(string) !== 'String') {
+		throw new $TypeError('Assertion failed: `string` must be a String');
+	}
+	var size = string.length;
+	if (position < 0 || position >= size) {
+		throw new $TypeError('Assertion failed: `position` must be >= 0, and < the length of `string`');
+	}
+	var first = $charCodeAt(string, position);
+	var cp = $charAt(string, position);
+	var firstIsLeading = isLeadingSurrogate(first);
+	var firstIsTrailing = isTrailingSurrogate(first);
+	if (!firstIsLeading && !firstIsTrailing) {
+		return {
+			'[[CodePoint]]': cp,
+			'[[CodeUnitCount]]': 1,
+			'[[IsUnpairedSurrogate]]': false
+		};
+	}
+	if (firstIsTrailing || (position + 1 === size)) {
+		return {
+			'[[CodePoint]]': cp,
+			'[[CodeUnitCount]]': 1,
+			'[[IsUnpairedSurrogate]]': true
+		};
+	}
+	var second = $charCodeAt(string, position + 1);
+	if (!isTrailingSurrogate(second)) {
+		return {
+			'[[CodePoint]]': cp,
+			'[[CodeUnitCount]]': 1,
+			'[[IsUnpairedSurrogate]]': true
+		};
+	}
+
+	return {
+		'[[CodePoint]]': UTF16SurrogatePairToCodePoint(first, second),
+		'[[CodeUnitCount]]': 2,
+		'[[IsUnpairedSurrogate]]': false
+	};
+};

package/node_modules/es-abstract/2021/CodePointsToString.js

@@ -0,0 +1,27 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var UTF16EncodeCodePoint = require('./UTF16EncodeCodePoint');
+var IsArray = require('./IsArray');
+
+var forEach = require('../helpers/forEach');
+var isCodePoint = require('../helpers/isCodePoint');
+
+// https://ecma-international.org/ecma-262/12.0/#sec-codepointstostring
+
+module.exports = function CodePointsToString(text) {
+	if (!IsArray(text)) {
+		throw new $TypeError('Assertion failed: `text` must be a sequence of Unicode Code Points');
+	}
+	var result = '';
+	forEach(text, function (cp) {
+		if (!isCodePoint(cp)) {
+			throw new $TypeError('Assertion failed: `text` must be a sequence of Unicode Code Points');
+		}
+		result += UTF16EncodeCodePoint(cp);
+	});
+	return result;
+};

package/node_modules/es-abstract/2021/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://ecma-international.org/ecma-262/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;
+};

package/node_modules/es-abstract/2021/CopyDataProperties.js

@@ -0,0 +1,70 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var callBound = require('call-bind/callBound');
+var forEach = require('../helpers/forEach');
+var every = require('../helpers/every');
+var some = require('../helpers/some');
+var OwnPropertyKeys = require('../helpers/OwnPropertyKeys');
+
+var $isEnumerable = callBound('Object.prototype.propertyIsEnumerable');
+
+var CreateDataPropertyOrThrow = require('./CreateDataPropertyOrThrow');
+var Get = require('./Get');
+var IsArray = require('./IsArray');
+var IsIntegralNumber = require('./IsIntegralNumber');
+var IsPropertyKey = require('./IsPropertyKey');
+var SameValue = require('./SameValue');
+var ToNumber = require('./ToNumber');
+var ToObject = require('./ToObject');
+var Type = require('./Type');
+
+// https://www.ecma-international.org/ecma-262/12.0/#sec-copydataproperties
+
+module.exports = function CopyDataProperties(target, source, excludedItems) {
+	if (Type(target) !== 'Object') {
+		throw new $TypeError('Assertion failed: "target" must be an Object');
+	}
+
+	if (!IsArray(excludedItems) || !every(excludedItems, IsPropertyKey)) {
+		throw new $TypeError('Assertion failed: "excludedItems" must be a List of Property Keys');
+	}
+
+	if (typeof source === 'undefined' || source === null) {
+		return target;
+	}
+
+	var from = ToObject(source);
+
+	var keys = OwnPropertyKeys(from);
+	forEach(keys, function (nextKey) {
+		var excluded = some(excludedItems, function (e) {
+			return SameValue(e, nextKey) === true;
+		});
+		/*
+		var excluded = false;
+
+		forEach(excludedItems, function (e) {
+			if (SameValue(e, nextKey) === true) {
+				excluded = true;
+			}
+		});
+		*/
+
+		var enumerable = $isEnumerable(from, nextKey) || (
+		// this is to handle string keys being non-enumerable in older engines
+			typeof source === 'string'
+			&& nextKey >= 0
+			&& IsIntegralNumber(ToNumber(nextKey))
+		);
+		if (excluded === false && enumerable) {
+			var propValue = Get(from, nextKey);
+			CreateDataPropertyOrThrow(target, nextKey, propValue);
+		}
+	});
+
+	return target;
+};

package/node_modules/es-abstract/2021/CreateDataProperty.js

@@ -0,0 +1,45 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var DefineOwnProperty = require('../helpers/DefineOwnProperty');
+
+var FromPropertyDescriptor = require('./FromPropertyDescriptor');
+var OrdinaryGetOwnProperty = require('./OrdinaryGetOwnProperty');
+var IsDataDescriptor = require('./IsDataDescriptor');
+var IsExtensible = require('./IsExtensible');
+var IsPropertyKey = require('./IsPropertyKey');
+var SameValue = require('./SameValue');
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/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 oldDesc = OrdinaryGetOwnProperty(O, P);
+	var extensible = !oldDesc || IsExtensible(O);
+	var nonConfigurable = oldDesc && !oldDesc['[[Configurable]]'];
+	if (nonConfigurable || !extensible) {
+		return false;
+	}
+	return DefineOwnProperty(
+		IsDataDescriptor,
+		SameValue,
+		FromPropertyDescriptor,
+		O,
+		P,
+		{
+			'[[Configurable]]': true,
+			'[[Enumerable]]': true,
+			'[[Value]]': V,
+			'[[Writable]]': true
+		}
+	);
+};

package/node_modules/es-abstract/2021/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://ecma-international.org/ecma-262/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;
+};

package/node_modules/es-abstract/2021/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://ecma-international.org/ecma-262/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 + '>';
+};

package/node_modules/es-abstract/2021/CreateIterResultObject.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/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
+	};
+};

package/node_modules/es-abstract/2021/CreateListFromArrayLike.js

@@ -0,0 +1,44 @@
+'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 LengthOfArrayLike = require('./LengthOfArrayLike');
+var ToString = require('./ToString');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/11.0/#sec-createlistfromarraylike
+
+module.exports = function CreateListFromArrayLike(obj) {
+	var elementTypes = arguments.length > 1
+		? arguments[1]
+		: ['Undefined', 'Null', 'Boolean', 'String', 'Symbol', 'Number', 'Object'];
+
+	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 = LengthOfArrayLike(obj);
+	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;
+};