cdk-comprehend-s3olap 2.0.35 → 2.0.36

package/node_modules/es-abstract/2018/TestIntegrityLevel.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $gOPD = require('../helpers/getOwnPropertyDescriptor');
+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://ecma-international.org/ecma-262/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;
+	});
+};

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

package/node_modules/es-abstract/2018/TimeFromYear.js

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

package/node_modules/es-abstract/2018/TimeString.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var $isNaN = require('../helpers/isNaN');
+var padTimeComponent = require('../helpers/padTimeComponent');
+
+var HourFromTime = require('./HourFromTime');
+var MinFromTime = require('./MinFromTime');
+var SecFromTime = require('./SecFromTime');
+var Type = require('./Type');
+
+// https://262.ecma-international.org/9.0/#sec-timestring
+
+module.exports = function TimeString(tv) {
+	if (Type(tv) !== 'Number' || $isNaN(tv)) {
+		throw new $TypeError('Assertion failed: `tv` must be a non-NaN Number');
+	}
+	var hour = HourFromTime(tv);
+	var minute = MinFromTime(tv);
+	var second = SecFromTime(tv);
+	return padTimeComponent(hour) + ':' + padTimeComponent(minute) + ':' + padTimeComponent(second) + '\x20GMT';
+};

package/node_modules/es-abstract/2018/TimeWithinDay.js

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

package/node_modules/es-abstract/2018/ToBoolean.js

@@ -0,0 +1,5 @@
+'use strict';
+
+// http://262.ecma-international.org/5.1/#sec-9.2
+
+module.exports = function ToBoolean(value) { return !!value; };

package/node_modules/es-abstract/2018/ToDateString.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+var $Date = GetIntrinsic('%Date%');
+
+var $isNaN = require('../helpers/isNaN');
+
+var Type = require('./Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-todatestring
+
+module.exports = function ToDateString(tv) {
+	if (Type(tv) !== 'Number') {
+		throw new $TypeError('Assertion failed: `tv` must be a Number');
+	}
+	if ($isNaN(tv)) {
+		return 'Invalid Date';
+	}
+	return $Date(tv);
+};

package/node_modules/es-abstract/2018/ToIndex.js

@@ -0,0 +1,26 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $RangeError = GetIntrinsic('%RangeError%');
+
+var ToInteger = require('./ToInteger');
+var ToLength = require('./ToLength');
+var SameValueZero = require('./SameValueZero');
+
+// https://262.ecma-international.org/8.0/#sec-toindex
+
+module.exports = function ToIndex(value) {
+	if (typeof value === 'undefined') {
+		return 0;
+	}
+	var integerIndex = ToInteger(value);
+	if (integerIndex < 0) {
+		throw new $RangeError('index must be >= 0');
+	}
+	var index = ToLength(integerIndex);
+	if (!SameValueZero(integerIndex, index)) {
+		throw new $RangeError('index must be >= 0 and < 2 ** 53 - 1');
+	}
+	return index;
+};

package/node_modules/es-abstract/2018/ToInt16.js

@@ -0,0 +1,10 @@
+'use strict';
+
+var ToUint16 = require('./ToUint16');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-toint16
+
+module.exports = function ToInt16(argument) {
+	var int16bit = ToUint16(argument);
+	return int16bit >= 0x8000 ? int16bit - 0x10000 : int16bit;
+};

package/node_modules/es-abstract/2018/ToInt32.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var ToNumber = require('./ToNumber');
+
+// http://262.ecma-international.org/5.1/#sec-9.5
+
+module.exports = function ToInt32(x) {
+	return ToNumber(x) >> 0;
+};

package/node_modules/es-abstract/2018/ToInt8.js

@@ -0,0 +1,10 @@
+'use strict';
+
+var ToUint8 = require('./ToUint8');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-toint8
+
+module.exports = function ToInt8(argument) {
+	var int8bit = ToUint8(argument);
+	return int8bit >= 0x80 ? int8bit - 0x100 : int8bit;
+};

package/node_modules/es-abstract/2018/ToInteger.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var ES5ToInteger = require('../5/ToInteger');
+
+var ToNumber = require('./ToNumber');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-tointeger
+
+module.exports = function ToInteger(value) {
+	var number = ToNumber(value);
+	return ES5ToInteger(number);
+};

package/node_modules/es-abstract/2018/ToLength.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var MAX_SAFE_INTEGER = require('../helpers/maxSafeInteger');
+
+var ToInteger = require('./ToInteger');
+
+module.exports = function ToLength(argument) {
+	var len = ToInteger(argument);
+	if (len <= 0) { return 0; } // includes converting -0 to +0
+	if (len > MAX_SAFE_INTEGER) { return MAX_SAFE_INTEGER; }
+	return len;
+};

package/node_modules/es-abstract/2018/ToNumber.js

@@ -0,0 +1,59 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+var $Number = GetIntrinsic('%Number%');
+var $RegExp = GetIntrinsic('%RegExp%');
+var $parseInteger = GetIntrinsic('%parseInt%');
+
+var callBound = require('call-bind/callBound');
+var regexTester = require('../helpers/regexTester');
+var isPrimitive = require('../helpers/isPrimitive');
+
+var $strSlice = callBound('String.prototype.slice');
+var isBinary = regexTester(/^0b[01]+$/i);
+var isOctal = regexTester(/^0o[0-7]+$/i);
+var isInvalidHexLiteral = regexTester(/^[-+]0x[0-9a-f]+$/i);
+var nonWS = ['\u0085', '\u200b', '\ufffe'].join('');
+var nonWSregex = new $RegExp('[' + nonWS + ']', 'g');
+var hasNonWS = regexTester(nonWSregex);
+
+// whitespace from: https://es5.github.io/#x15.5.4.20
+// implementation from https://github.com/es-shims/es5-shim/blob/v3.4.0/es5-shim.js#L1304-L1324
+var ws = [
+	'\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003',
+	'\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028',
+	'\u2029\uFEFF'
+].join('');
+var trimRegex = new RegExp('(^[' + ws + ']+)|([' + ws + ']+$)', 'g');
+var $replace = callBound('String.prototype.replace');
+var $trim = function (value) {
+	return $replace(value, trimRegex, '');
+};
+
+var ToPrimitive = require('./ToPrimitive');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-tonumber
+
+module.exports = function ToNumber(argument) {
+	var value = isPrimitive(argument) ? argument : ToPrimitive(argument, $Number);
+	if (typeof value === 'symbol') {
+		throw new $TypeError('Cannot convert a Symbol value to a number');
+	}
+	if (typeof value === 'string') {
+		if (isBinary(value)) {
+			return ToNumber($parseInteger($strSlice(value, 2), 2));
+		} else if (isOctal(value)) {
+			return ToNumber($parseInteger($strSlice(value, 2), 8));
+		} else if (hasNonWS(value) || isInvalidHexLiteral(value)) {
+			return NaN;
+		}
+		var trimmed = $trim(value);
+		if (trimmed !== value) {
+			return ToNumber(trimmed);
+		}
+
+	}
+	return $Number(value);
+};

package/node_modules/es-abstract/2018/ToObject.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $Object = GetIntrinsic('%Object%');
+
+var RequireObjectCoercible = require('./RequireObjectCoercible');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-toobject
+
+module.exports = function ToObject(value) {
+	RequireObjectCoercible(value);
+	return $Object(value);
+};

package/node_modules/es-abstract/2018/ToPrimitive.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var toPrimitive = require('es-to-primitive/es2015');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-toprimitive
+
+module.exports = function ToPrimitive(input) {
+	if (arguments.length > 1) {
+		return toPrimitive(input, arguments[1]);
+	}
+	return toPrimitive(input);
+};

package/node_modules/es-abstract/2018/ToPropertyDescriptor.js

@@ -0,0 +1,52 @@
+'use strict';
+
+var has = require('has');
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var Type = require('./Type');
+var ToBoolean = require('./ToBoolean');
+var IsCallable = require('./IsCallable');
+
+// https://262.ecma-international.org/5.1/#sec-8.10.5
+
+module.exports = function ToPropertyDescriptor(Obj) {
+	if (Type(Obj) !== 'Object') {
+		throw new $TypeError('ToPropertyDescriptor requires an object');
+	}
+
+	var desc = {};
+	if (has(Obj, 'enumerable')) {
+		desc['[[Enumerable]]'] = ToBoolean(Obj.enumerable);
+	}
+	if (has(Obj, 'configurable')) {
+		desc['[[Configurable]]'] = ToBoolean(Obj.configurable);
+	}
+	if (has(Obj, 'value')) {
+		desc['[[Value]]'] = Obj.value;
+	}
+	if (has(Obj, 'writable')) {
+		desc['[[Writable]]'] = ToBoolean(Obj.writable);
+	}
+	if (has(Obj, 'get')) {
+		var getter = Obj.get;
+		if (typeof getter !== 'undefined' && !IsCallable(getter)) {
+			throw new $TypeError('getter must be a function');
+		}
+		desc['[[Get]]'] = getter;
+	}
+	if (has(Obj, 'set')) {
+		var setter = Obj.set;
+		if (typeof setter !== 'undefined' && !IsCallable(setter)) {
+			throw new $TypeError('setter must be a function');
+		}
+		desc['[[Set]]'] = setter;
+	}
+
+	if ((has(desc, '[[Get]]') || has(desc, '[[Set]]')) && (has(desc, '[[Value]]') || has(desc, '[[Writable]]'))) {
+		throw new $TypeError('Invalid property descriptor. Cannot both specify accessors and a value or writable attribute');
+	}
+	return desc;
+};

package/node_modules/es-abstract/2018/ToPropertyKey.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $String = GetIntrinsic('%String%');
+
+var ToPrimitive = require('./ToPrimitive');
+var ToString = require('./ToString');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-topropertykey
+
+module.exports = function ToPropertyKey(argument) {
+	var key = ToPrimitive(argument, $String);
+	return typeof key === 'symbol' ? key : ToString(key);
+};

package/node_modules/es-abstract/2018/ToString.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $String = GetIntrinsic('%String%');
+var $TypeError = GetIntrinsic('%TypeError%');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-tostring
+
+module.exports = function ToString(argument) {
+	if (typeof argument === 'symbol') {
+		throw new $TypeError('Cannot convert a Symbol value to a string');
+	}
+	return $String(argument);
+};

package/node_modules/es-abstract/2018/ToUint16.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var abs = require('./abs');
+var floor = require('./floor');
+var modulo = require('./modulo');
+var ToNumber = require('./ToNumber');
+
+var $isNaN = require('../helpers/isNaN');
+var $isFinite = require('../helpers/isFinite');
+var $sign = require('../helpers/sign');
+
+// http://262.ecma-international.org/5.1/#sec-9.7
+
+module.exports = function ToUint16(value) {
+	var number = ToNumber(value);
+	if ($isNaN(number) || number === 0 || !$isFinite(number)) { return 0; }
+	var posInt = $sign(number) * floor(abs(number));
+	return modulo(posInt, 0x10000);
+};

package/node_modules/es-abstract/2018/ToUint32.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var ToNumber = require('./ToNumber');
+
+// http://262.ecma-international.org/5.1/#sec-9.6
+
+module.exports = function ToUint32(x) {
+	return ToNumber(x) >>> 0;
+};

package/node_modules/es-abstract/2018/ToUint8.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var ToNumber = require('./ToNumber');
+
+var $isNaN = require('../helpers/isNaN');
+var $isFinite = require('../helpers/isFinite');
+var $sign = require('../helpers/sign');
+
+var abs = require('./abs');
+var floor = require('./floor');
+var modulo = require('./modulo');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-touint8
+
+module.exports = function ToUint8(argument) {
+	var number = ToNumber(argument);
+	if ($isNaN(number) || number === 0 || !$isFinite(number)) { return 0; }
+	var posInt = $sign(number) * floor(abs(number));
+	return modulo(posInt, 0x100);
+};

package/node_modules/es-abstract/2018/ToUint8Clamp.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var ToNumber = require('./ToNumber');
+var floor = require('./floor');
+
+var $isNaN = require('../helpers/isNaN');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-touint8clamp
+
+module.exports = function ToUint8Clamp(argument) {
+	var number = ToNumber(argument);
+	if ($isNaN(number) || number <= 0) { return 0; }
+	if (number >= 0xFF) { return 0xFF; }
+	var f = floor(argument);
+	if (f + 0.5 < number) { return f + 1; }
+	if (number < f + 0.5) { return f; }
+	if (f % 2 !== 0) { return f + 1; }
+	return f;
+};

package/node_modules/es-abstract/2018/Type.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var ES5Type = require('../5/Type');
+
+// https://ecma-international.org/ecma-262/6.0/#sec-ecmascript-data-types-and-values
+
+module.exports = function Type(x) {
+	if (typeof x === 'symbol') {
+		return 'Symbol';
+	}
+	return ES5Type(x);
+};

package/node_modules/es-abstract/2018/UTF16Decode.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+var $fromCharCode = GetIntrinsic('%String.fromCharCode%');
+
+// https://262.ecma-international.org/7.0/#sec-utf16decode
+
+var isLeadingSurrogate = require('../helpers/isLeadingSurrogate');
+var isTrailingSurrogate = require('../helpers/isTrailingSurrogate');
+
+// https://262.ecma-international.org/11.0/#sec-utf16decodesurrogatepair
+
+module.exports = function UTF16Decode(lead, trail) {
+	if (!isLeadingSurrogate(lead) || !isTrailingSurrogate(trail)) {
+		throw new $TypeError('Assertion failed: `lead` must be a leading surrogate char code, and `trail` must be a trailing surrogate char code');
+	}
+	// var cp = (lead - 0xD800) * 0x400 + (trail - 0xDC00) + 0x10000;
+	return $fromCharCode(lead) + $fromCharCode(trail);
+};

package/node_modules/es-abstract/2018/UTF16Encoding.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+var $fromCharCode = GetIntrinsic('%String.fromCharCode%');
+
+var floor = require('./floor');
+var modulo = require('./modulo');
+
+var isCodePoint = require('../helpers/isCodePoint');
+
+// https://262.ecma-international.org/7.0/#sec-utf16encoding
+
+module.exports = function UTF16Encoding(cp) {
+	if (!isCodePoint(cp)) {
+		throw new $TypeError('Assertion failed: `cp` must be >= 0 and <= 0x10FFFF');
+	}
+	if (cp <= 65535) {
+		return $fromCharCode(cp);
+	}
+	var cu1 = floor((cp - 65536) / 1024) + 0xD800;
+	var cu2 = modulo(cp - 65536, 1024) + 0xDC00;
+	return $fromCharCode(cu1) + $fromCharCode(cu2);
+};

package/node_modules/es-abstract/2018/UnicodeEscape.js

@@ -0,0 +1,26 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = GetIntrinsic('%TypeError%');
+
+var callBound = require('call-bind/callBound');
+
+var $charCodeAt = callBound('String.prototype.charCodeAt');
+var $numberToString = callBound('Number.prototype.toString');
+var $toLowerCase = callBound('String.prototype.toLowerCase');
+var $strSlice = callBound('String.prototype.slice');
+
+// https://262.ecma-international.org/9.0/#sec-unicodeescape
+
+module.exports = function UnicodeEscape(C) {
+	if (typeof C !== 'string' || C.length !== 1) {
+		throw new $TypeError('Assertion failed: `C` must be a single code unit');
+	}
+	var n = $charCodeAt(C, 0);
+	if (n > 0xFFFF) {
+		throw new $TypeError('`Assertion failed: numeric value of `C` must be <= 0xFFFF');
+	}
+
+	return '\\u' + $strSlice('0000' + $toLowerCase($numberToString(n, 16)), -4);
+};