moodle-cli 0.7.0-alpha.6 → 0.7.0

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

@@ -0,0 +1,40 @@
+'use strict';
+
+var hasOwn = require('hasown');
+
+var $TypeError = require('es-errors/type');
+
+var getSymbolDescription = require('get-symbol-description');
+
+var DefinePropertyOrThrow = require('./DefinePropertyOrThrow');
+var IsExtensible = require('./IsExtensible');
+
+// 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) || hasOwn(F, 'name')) {
+		throw new $TypeError('Assertion failed: `F` must be extensible, and must not have a `name` own property');
+	}
+	if (typeof name !== 'symbol' && typeof name !== 'string') {
+		throw new $TypeError('Assertion failed: `name` must be a Symbol or a String');
+	}
+	if (typeof name === '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
+	});
+};

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

@@ -0,0 +1,57 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $SyntaxError = require('es-errors/syntax');
+var $TypeError = require('es-errors/type');
+var isObject = require('es-object-atoms/isObject');
+var $gOPD = require('gopd');
+var $preventExtensions = GetIntrinsic('%Object.preventExtensions%', true);
+var $gOPN = GetIntrinsic('%Object.getOwnPropertyNames%', true);
+
+var forEach = require('../helpers/forEach');
+
+var DefinePropertyOrThrow = require('./DefinePropertyOrThrow');
+var IsAccessorDescriptor = require('./IsAccessorDescriptor');
+var ToPropertyDescriptor = require('./ToPropertyDescriptor');
+
+// https://262.ecma-international.org/6.0/#sec-setintegritylevel
+
+module.exports = function SetIntegrityLevel(O, level) {
+	if (!isObject(O)) {
+		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;
+};

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

@@ -0,0 +1,110 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = require('es-errors/type');
+var $Uint8Array = GetIntrinsic('%Uint8Array%', true);
+
+var isInteger = require('math-intrinsics/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 hasOwn = require('hasown');
+
+var tableTAO = require('./tables/typed-array-objects');
+
+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' || !hasOwn(tableTAO.size, '$' + type)) {
+		throw new $TypeError('Assertion failed: `type` must be one of ' + tableTAO.choices);
+	}
+
+	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 = tableTAO.size['$' + type]; // step 7
+	if (!elementSize) {
+		throw new $TypeError('Assertion failed: `type` must be one of ' + tableTAO.choices);
+	}
+
+	// 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 = elementSize; // 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).
+};

package/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 = require('es-errors/type');
+var isObject = require('es-object-atoms/isObject');
+
+var IsConstructor = require('./IsConstructor');
+
+// https://262.ecma-international.org/6.0/#sec-speciesconstructor
+
+module.exports = function SpeciesConstructor(O, defaultConstructor) {
+	if (!isObject(O)) {
+		throw new $TypeError('Assertion failed: Type(O) is not Object');
+	}
+	var C = O.constructor;
+	if (typeof C === 'undefined') {
+		return defaultConstructor;
+	}
+	if (!isObject(C)) {
+		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');
+};

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

@@ -0,0 +1,35 @@
+'use strict';
+
+var callBound = require('call-bound');
+
+var $TypeError = require('es-errors/type');
+var isInteger = require('math-intrinsics/isInteger');
+
+var $charAt = callBound('String.prototype.charAt');
+
+// https://262.ecma-international.org/6.0/#sec-splitmatch
+
+module.exports = function SplitMatch(S, q, R) {
+	if (typeof 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 (typeof 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;
+};

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

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

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

@@ -0,0 +1,38 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $Object = require('es-object-atoms');
+var $StringPrototype = GetIntrinsic('%String.prototype%');
+var $SyntaxError = require('es-errors/syntax');
+var $TypeError = require('es-errors/type');
+var setProto = require('set-proto');
+
+var DefinePropertyOrThrow = require('./DefinePropertyOrThrow');
+
+// https://262.ecma-international.org/6.0/#sec-stringcreate
+
+module.exports = function StringCreate(value, prototype) {
+	if (typeof 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;
+};

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

@@ -0,0 +1,50 @@
+'use strict';
+
+var callBound = require('call-bound');
+
+var $TypeError = require('es-errors/type');
+
+var $charAt = callBound('String.prototype.charAt');
+
+var isString = require('is-string');
+var isNegativeZero = require('math-intrinsics/isNegativeZero');
+var unbox = require('unbox-primitive');
+
+var CanonicalNumericIndexString = require('./CanonicalNumericIndexString');
+var IsInteger = require('./IsInteger');
+var isPropertyKey = require('../helpers/isPropertyKey');
+
+// 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 (typeof 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
+	};
+};

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

@@ -0,0 +1,16 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+var callBound = require('call-bound');
+
+var $SymbolToString = callBound('Symbol.prototype.toString', true);
+
+// https://262.ecma-international.org/6.0/#sec-symboldescriptivestring
+
+module.exports = function SymbolDescriptiveString(sym) {
+	if (typeof sym !== 'symbol') {
+		throw new $TypeError('Assertion failed: `sym` must be a Symbol');
+	}
+	return $SymbolToString(sym);
+};

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

@@ -0,0 +1,40 @@
+'use strict';
+
+var $gOPD = require('gopd');
+var $TypeError = require('es-errors/type');
+
+var every = require('../helpers/every');
+var OwnPropertyKeys = require('own-keys');
+var isObject = require('es-object-atoms/isObject');
+
+var IsDataDescriptor = require('./IsDataDescriptor');
+var IsExtensible = require('./IsExtensible');
+var ToPropertyDescriptor = require('./ToPropertyDescriptor');
+
+// https://262.ecma-international.org/6.0/#sec-testintegritylevel
+
+module.exports = function TestIntegrityLevel(O, level) {
+	if (!isObject(O)) {
+		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 || !$gOPD) {
+		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/2015/TimeClip.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $Date = GetIntrinsic('%Date%');
+
+var $isFinite = require('math-intrinsics/isFinite');
+var abs = require('math-intrinsics/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 +new $Date(ToNumber(time));
+};
+

package/node_modules/es-abstract/2015/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/2015/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/2015/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/2015/ToDateString.js

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

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

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

package/node_modules/es-abstract/2015/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/2015/ToInt8.js

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

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

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

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

@@ -0,0 +1,14 @@
+'use strict';
+
+var MAX_SAFE_INTEGER = require('math-intrinsics/constants/maxSafeInteger');
+
+var ToInteger = require('./ToInteger');
+
+// https://262.ecma-international.org/6.0/#sec-tolength
+
+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/2015/ToNumber.js

@@ -0,0 +1,48 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+
+var $TypeError = require('es-errors/type');
+var $Number = GetIntrinsic('%Number%');
+var $RegExp = GetIntrinsic('%RegExp%');
+var $parseInteger = GetIntrinsic('%parseInt%');
+
+var callBound = require('call-bound');
+var regexTester = require('safe-regex-test');
+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);
+
+var $trim = require('string.prototype.trim');
+
+var ToPrimitive = require('./ToPrimitive');
+
+// https://262.ecma-international.org/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 +value;
+};

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

@@ -0,0 +1,5 @@
+'use strict';
+
+// https://262.ecma-international.org/6.0/#sec-toobject
+
+module.exports = require('es-object-atoms/ToObject');

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

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