diff --git a/dist/aicc.js b/dist/aicc.js new file mode 100644 index 0000000..61702e9 --- /dev/null +++ b/dist/aicc.js @@ -0,0 +1,7265 @@ +(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i + * Build: `lodash modularize exports="npm" -o ./` + * Copyright jQuery Foundation and other contributors + * Released under MIT license + * Based on Underscore.js 1.8.3 + * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + */ + +/** Used as the `TypeError` message for "Functions" methods. */ +var FUNC_ERROR_TEXT = 'Expected a function'; + +/** Used as references for various `Number` constants. */ +var NAN = 0 / 0; + +/** `Object#toString` result references. */ +var symbolTag = '[object Symbol]'; + +/** Used to match leading and trailing whitespace. */ +var reTrim = /^\s+|\s+$/g; + +/** Used to detect bad signed hexadecimal string values. */ +var reIsBadHex = /^[-+]0x[0-9a-f]+$/i; + +/** Used to detect binary string values. */ +var reIsBinary = /^0b[01]+$/i; + +/** Used to detect octal string values. */ +var reIsOctal = /^0o[0-7]+$/i; + +/** Built-in method references without a dependency on `root`. */ +var freeParseInt = parseInt; + +/** Detect free variable `global` from Node.js. */ +var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; + +/** Detect free variable `self`. */ +var freeSelf = typeof self == 'object' && self && self.Object === Object && self; + +/** Used as a reference to the global object. */ +var root = freeGlobal || freeSelf || Function('return this')(); + +/** Used for built-in method references. */ +var objectProto = Object.prototype; + +/** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ +var objectToString = objectProto.toString; + +/* Built-in method references for those with the same name as other `lodash` methods. */ +var nativeMax = Math.max, + nativeMin = Math.min; + +/** + * Gets the timestamp of the number of milliseconds that have elapsed since + * the Unix epoch (1 January 1970 00:00:00 UTC). + * + * @static + * @memberOf _ + * @since 2.4.0 + * @category Date + * @returns {number} Returns the timestamp. + * @example + * + * _.defer(function(stamp) { + * console.log(_.now() - stamp); + * }, _.now()); + * // => Logs the number of milliseconds it took for the deferred invocation. + */ +var now = function() { + return root.Date.now(); +}; + +/** + * Creates a debounced function that delays invoking `func` until after `wait` + * milliseconds have elapsed since the last time the debounced function was + * invoked. The debounced function comes with a `cancel` method to cancel + * delayed `func` invocations and a `flush` method to immediately invoke them. + * Provide `options` to indicate whether `func` should be invoked on the + * leading and/or trailing edge of the `wait` timeout. The `func` is invoked + * with the last arguments provided to the debounced function. Subsequent + * calls to the debounced function return the result of the last `func` + * invocation. + * + * **Note:** If `leading` and `trailing` options are `true`, `func` is + * invoked on the trailing edge of the timeout only if the debounced function + * is invoked more than once during the `wait` timeout. + * + * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred + * until to the next tick, similar to `setTimeout` with a timeout of `0`. + * + * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) + * for details over the differences between `_.debounce` and `_.throttle`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to debounce. + * @param {number} [wait=0] The number of milliseconds to delay. + * @param {Object} [options={}] The options object. + * @param {boolean} [options.leading=false] + * Specify invoking on the leading edge of the timeout. + * @param {number} [options.maxWait] + * The maximum time `func` is allowed to be delayed before it's invoked. + * @param {boolean} [options.trailing=true] + * Specify invoking on the trailing edge of the timeout. + * @returns {Function} Returns the new debounced function. + * @example + * + * // Avoid costly calculations while the window size is in flux. + * jQuery(window).on('resize', _.debounce(calculateLayout, 150)); + * + * // Invoke `sendMail` when clicked, debouncing subsequent calls. + * jQuery(element).on('click', _.debounce(sendMail, 300, { + * 'leading': true, + * 'trailing': false + * })); + * + * // Ensure `batchLog` is invoked once after 1 second of debounced calls. + * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 }); + * var source = new EventSource('/stream'); + * jQuery(source).on('message', debounced); + * + * // Cancel the trailing debounced invocation. + * jQuery(window).on('popstate', debounced.cancel); + */ +function debounce(func, wait, options) { + var lastArgs, + lastThis, + maxWait, + result, + timerId, + lastCallTime, + lastInvokeTime = 0, + leading = false, + maxing = false, + trailing = true; + + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + wait = toNumber(wait) || 0; + if (isObject(options)) { + leading = !!options.leading; + maxing = 'maxWait' in options; + maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait; + trailing = 'trailing' in options ? !!options.trailing : trailing; + } + + function invokeFunc(time) { + var args = lastArgs, + thisArg = lastThis; + + lastArgs = lastThis = undefined; + lastInvokeTime = time; + result = func.apply(thisArg, args); + return result; + } + + function leadingEdge(time) { + // Reset any `maxWait` timer. + lastInvokeTime = time; + // Start the timer for the trailing edge. + timerId = setTimeout(timerExpired, wait); + // Invoke the leading edge. + return leading ? invokeFunc(time) : result; + } + + function remainingWait(time) { + var timeSinceLastCall = time - lastCallTime, + timeSinceLastInvoke = time - lastInvokeTime, + result = wait - timeSinceLastCall; + + return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result; + } + + function shouldInvoke(time) { + var timeSinceLastCall = time - lastCallTime, + timeSinceLastInvoke = time - lastInvokeTime; + + // Either this is the first call, activity has stopped and we're at the + // trailing edge, the system time has gone backwards and we're treating + // it as the trailing edge, or we've hit the `maxWait` limit. + return (lastCallTime === undefined || (timeSinceLastCall >= wait) || + (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait)); + } + + function timerExpired() { + var time = now(); + if (shouldInvoke(time)) { + return trailingEdge(time); + } + // Restart the timer. + timerId = setTimeout(timerExpired, remainingWait(time)); + } + + function trailingEdge(time) { + timerId = undefined; + + // Only invoke if we have `lastArgs` which means `func` has been + // debounced at least once. + if (trailing && lastArgs) { + return invokeFunc(time); + } + lastArgs = lastThis = undefined; + return result; + } + + function cancel() { + if (timerId !== undefined) { + clearTimeout(timerId); + } + lastInvokeTime = 0; + lastArgs = lastCallTime = lastThis = timerId = undefined; + } + + function flush() { + return timerId === undefined ? result : trailingEdge(now()); + } + + function debounced() { + var time = now(), + isInvoking = shouldInvoke(time); + + lastArgs = arguments; + lastThis = this; + lastCallTime = time; + + if (isInvoking) { + if (timerId === undefined) { + return leadingEdge(lastCallTime); + } + if (maxing) { + // Handle invocations in a tight loop. + timerId = setTimeout(timerExpired, wait); + return invokeFunc(lastCallTime); + } + } + if (timerId === undefined) { + timerId = setTimeout(timerExpired, wait); + } + return result; + } + debounced.cancel = cancel; + debounced.flush = flush; + return debounced; +} + +/** + * Checks if `value` is the + * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) + * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an object, else `false`. + * @example + * + * _.isObject({}); + * // => true + * + * _.isObject([1, 2, 3]); + * // => true + * + * _.isObject(_.noop); + * // => true + * + * _.isObject(null); + * // => false + */ +function isObject(value) { + var type = typeof value; + return !!value && (type == 'object' || type == 'function'); +} + +/** + * Checks if `value` is object-like. A value is object-like if it's not `null` + * and has a `typeof` result of "object". + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is object-like, else `false`. + * @example + * + * _.isObjectLike({}); + * // => true + * + * _.isObjectLike([1, 2, 3]); + * // => true + * + * _.isObjectLike(_.noop); + * // => false + * + * _.isObjectLike(null); + * // => false + */ +function isObjectLike(value) { + return !!value && typeof value == 'object'; +} + +/** + * Checks if `value` is classified as a `Symbol` primitive or object. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. + * @example + * + * _.isSymbol(Symbol.iterator); + * // => true + * + * _.isSymbol('abc'); + * // => false + */ +function isSymbol(value) { + return typeof value == 'symbol' || + (isObjectLike(value) && objectToString.call(value) == symbolTag); +} + +/** + * Converts `value` to a number. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to process. + * @returns {number} Returns the number. + * @example + * + * _.toNumber(3.2); + * // => 3.2 + * + * _.toNumber(Number.MIN_VALUE); + * // => 5e-324 + * + * _.toNumber(Infinity); + * // => Infinity + * + * _.toNumber('3.2'); + * // => 3.2 + */ +function toNumber(value) { + if (typeof value == 'number') { + return value; + } + if (isSymbol(value)) { + return NAN; + } + if (isObject(value)) { + var other = typeof value.valueOf == 'function' ? value.valueOf() : value; + value = isObject(other) ? (other + '') : other; + } + if (typeof value != 'string') { + return value === 0 ? value : +value; + } + value = value.replace(reTrim, ''); + var isBinary = reIsBinary.test(value); + return (isBinary || reIsOctal.test(value)) + ? freeParseInt(value.slice(2), isBinary ? 2 : 8) + : (reIsBadHex.test(value) ? NAN : +value); +} + +module.exports = debounce; + +}).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) + +},{}],2:[function(require,module,exports){ +"use strict"; + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +var _Scorm12API2 = _interopRequireDefault(require("./Scorm12API")); + +var _aicc_cmi = require("./cmi/aicc_cmi"); + +var _scorm12_cmi = require("./cmi/scorm12_cmi"); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); } + +function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +/** + * The AICC API class + */ +var AICC = /*#__PURE__*/function (_Scorm12API) { + _inherits(AICC, _Scorm12API); + + var _super = _createSuper(AICC); + + /** + * Constructor to create AICC API object + * @param {object} settings + */ + function AICC(settings) { + var _this; + + _classCallCheck(this, AICC); + + var finalSettings = _objectSpread(_objectSpread({}, { + mastery_override: false + }), settings); + + _this = _super.call(this, finalSettings); + _this.cmi = new _aicc_cmi.CMI(); + _this.nav = new _scorm12_cmi.NAV(); + return _this; + } + /** + * Gets or builds a new child element to add to the array. + * + * @param {string} CMIElement + * @param {any} value + * @param {boolean} foundFirstIndex + * @return {object} + */ + + + _createClass(AICC, [{ + key: "getChildElement", + value: function getChildElement(CMIElement, value, foundFirstIndex) { + var newChild = _get(_getPrototypeOf(AICC.prototype), "getChildElement", this).call(this, CMIElement, value, foundFirstIndex); + + if (!newChild) { + if (this.stringMatches(CMIElement, 'cmi\\.evaluation\\.comments\\.\\d+')) { + newChild = new _aicc_cmi.CMIEvaluationCommentsObject(); + } else if (this.stringMatches(CMIElement, 'cmi\\.student_data\\.tries\\.\\d+')) { + newChild = new _aicc_cmi.CMITriesObject(); + } else if (this.stringMatches(CMIElement, 'cmi\\.student_data\\.attempt_records\\.\\d+')) { + newChild = new _aicc_cmi.CMIAttemptRecordsObject(); + } + } + + return newChild; + } + /** + * Replace the whole API with another + * + * @param {AICC} newAPI + */ + + }, { + key: "replaceWithAnotherScormAPI", + value: function replaceWithAnotherScormAPI(newAPI) { + // Data Model + this.cmi = newAPI.cmi; + this.nav = newAPI.nav; + } + }]); + + return AICC; +}(_Scorm12API2["default"]); + +exports["default"] = AICC; + +},{"./Scorm12API":4,"./cmi/aicc_cmi":5,"./cmi/scorm12_cmi":7}],3:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +var _common = require("./cmi/common"); + +var _exceptions = require("./exceptions"); + +var _error_codes2 = _interopRequireDefault(require("./constants/error_codes")); + +var _api_constants = _interopRequireDefault(require("./constants/api_constants")); + +var _utilities = require("./utilities"); + +var _lodash = _interopRequireDefault(require("lodash.debounce")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); } + +function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } + +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit(arr, i) { var _i = arr && (typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]); if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); } + +function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; } + +function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); } + +function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } } + +var global_constants = _api_constants["default"].global; +var scorm12_error_codes = _error_codes2["default"].scorm12; +/** + * Base API class for AICC, SCORM 1.2, and SCORM 2004. Should be considered + * abstract, and never initialized on it's own. + */ + +var _timeout = new WeakMap(); + +var _error_codes = new WeakMap(); + +var _settings = new WeakMap(); + +var BaseAPI = /*#__PURE__*/function () { + /** + * Constructor for Base API class. Sets some shared API fields, as well as + * sets up options for the API. + * @param {object} error_codes + * @param {object} settings + */ + function BaseAPI(error_codes, settings) { + _classCallCheck(this, BaseAPI); + + _timeout.set(this, { + writable: true, + value: void 0 + }); + + _error_codes.set(this, { + writable: true, + value: void 0 + }); + + _settings.set(this, { + writable: true, + value: { + autocommit: false, + autocommitSeconds: 10, + asyncCommit: false, + sendBeaconCommit: false, + lmsCommitUrl: false, + dataCommitFormat: 'json', + // valid formats are 'json' or 'flattened', 'params' + commitRequestDataType: 'application/json;charset=UTF-8', + autoProgress: false, + logLevel: global_constants.LOG_LEVEL_ERROR, + selfReportSessionTime: false, + alwaysSendTotalTime: false, + strict_errors: true, + responseHandler: function responseHandler(xhr) { + var result; + + if (typeof xhr !== 'undefined') { + result = JSON.parse(xhr.responseText); + + if (result === null || !{}.hasOwnProperty.call(result, 'result')) { + result = {}; + + if (xhr.status === 200) { + result.result = global_constants.SCORM_TRUE; + result.errorCode = 0; + } else { + result.result = global_constants.SCORM_FALSE; + result.errorCode = 101; + } + } + } + + return result; + } + } + }); + + _defineProperty(this, "cmi", void 0); + + _defineProperty(this, "startingData", void 0); + + if ((this instanceof BaseAPI ? this.constructor : void 0) === BaseAPI) { + throw new TypeError('Cannot construct BaseAPI instances directly'); + } + + this.currentState = global_constants.STATE_NOT_INITIALIZED; + this.lastErrorCode = 0; + this.listenerArray = []; + + _classPrivateFieldSet(this, _timeout, null); + + _classPrivateFieldSet(this, _error_codes, error_codes); + + this.settings = settings; + this.apiLogLevel = this.settings.logLevel; + this.selfReportSessionTime = this.settings.selfReportSessionTime; + } + /** + * Initialize the API + * @param {string} callbackName + * @param {string} initializeMessage + * @param {string} terminationMessage + * @return {string} + */ + + + _createClass(BaseAPI, [{ + key: "initialize", + value: function initialize(callbackName, initializeMessage, terminationMessage) { + var returnValue = global_constants.SCORM_FALSE; + + if (this.isInitialized()) { + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).INITIALIZED, initializeMessage); + } else if (this.isTerminated()) { + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).TERMINATED, terminationMessage); + } else { + if (this.selfReportSessionTime) { + this.cmi.setStartTime(); + } + + this.currentState = global_constants.STATE_INITIALIZED; + this.lastErrorCode = 0; + returnValue = global_constants.SCORM_TRUE; + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Getter for #error_codes + * @return {object} + */ + + }, { + key: "error_codes", + get: function get() { + return _classPrivateFieldGet(this, _error_codes); + } + /** + * Getter for #settings + * @return {object} + */ + + }, { + key: "settings", + get: function get() { + return _classPrivateFieldGet(this, _settings); + } + /** + * Setter for #settings + * @param {object} settings + */ + , + set: function set(settings) { + _classPrivateFieldSet(this, _settings, _objectSpread(_objectSpread({}, _classPrivateFieldGet(this, _settings)), settings)); + } + /** + * Terminates the current run of the API + * @param {string} callbackName + * @param {boolean} checkTerminated + * @return {string} + */ + + }, { + key: "terminate", + value: function terminate(callbackName, checkTerminated) { + var returnValue = global_constants.SCORM_FALSE; + + if (this.checkState(checkTerminated, _classPrivateFieldGet(this, _error_codes).TERMINATION_BEFORE_INIT, _classPrivateFieldGet(this, _error_codes).MULTIPLE_TERMINATION)) { + this.currentState = global_constants.STATE_TERMINATED; + var result = this.storeData(true); + + if (!this.settings.sendBeaconCommit && !this.settings.asyncCommit && typeof result.errorCode !== 'undefined' && result.errorCode > 0) { + this.throwSCORMError(result.errorCode); + } + + returnValue = typeof result !== 'undefined' && result.result ? result.result : global_constants.SCORM_FALSE; + if (checkTerminated) this.lastErrorCode = 0; + returnValue = global_constants.SCORM_TRUE; + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Get the value of the CMIElement. + * + * @param {string} callbackName + * @param {boolean} checkTerminated + * @param {string} CMIElement + * @return {string} + */ + + }, { + key: "getValue", + value: function getValue(callbackName, checkTerminated, CMIElement) { + var returnValue; + + if (this.checkState(checkTerminated, _classPrivateFieldGet(this, _error_codes).RETRIEVE_BEFORE_INIT, _classPrivateFieldGet(this, _error_codes).RETRIEVE_AFTER_TERM)) { + if (checkTerminated) this.lastErrorCode = 0; + + try { + returnValue = this.getCMIValue(CMIElement); + } catch (e) { + if (e instanceof _exceptions.ValidationError) { + this.lastErrorCode = e.errorCode; + returnValue = global_constants.SCORM_FALSE; + } else { + if (e.message) { + console.error(e.message); + } else { + console.error(e); + } + + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).GENERAL); + } + } + + this.processListeners(callbackName, CMIElement); + } + + this.apiLog(callbackName, CMIElement, ': returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Sets the value of the CMIElement. + * + * @param {string} callbackName + * @param {string} commitCallback + * @param {boolean} checkTerminated + * @param {string} CMIElement + * @param {*} value + * @return {string} + */ + + }, { + key: "setValue", + value: function setValue(callbackName, commitCallback, checkTerminated, CMIElement, value) { + if (value !== undefined) { + value = String(value); + } + + var returnValue = global_constants.SCORM_FALSE; + + if (this.checkState(checkTerminated, _classPrivateFieldGet(this, _error_codes).STORE_BEFORE_INIT, _classPrivateFieldGet(this, _error_codes).STORE_AFTER_TERM)) { + if (checkTerminated) this.lastErrorCode = 0; + + try { + returnValue = this.setCMIValue(CMIElement, value); + } catch (e) { + if (e instanceof _exceptions.ValidationError) { + this.lastErrorCode = e.errorCode; + returnValue = global_constants.SCORM_FALSE; + } else { + if (e.message) { + console.error(e.message); + } else { + console.error(e); + } + + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).GENERAL); + } + } + + this.processListeners(callbackName, CMIElement, value); + } + + if (returnValue === undefined) { + returnValue = global_constants.SCORM_FALSE; + } // If we didn't have any errors while setting the data, go ahead and + // schedule a commit, if autocommit is turned on + + + if (String(this.lastErrorCode) === '0') { + if (this.settings.autocommit && !_classPrivateFieldGet(this, _timeout)) { + this.scheduleCommit(this.settings.autocommitSeconds * 1000, commitCallback); + } + } + + this.apiLog(callbackName, CMIElement, ': ' + value + ': result: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Orders LMS to store all content parameters + * @param {string} callbackName + * @param {boolean} checkTerminated + * @return {string} + */ + + }, { + key: "commit", + value: function commit(callbackName, checkTerminated) { + this.clearScheduledCommit(); + var returnValue = global_constants.SCORM_FALSE; + + if (this.checkState(checkTerminated, _classPrivateFieldGet(this, _error_codes).COMMIT_BEFORE_INIT, _classPrivateFieldGet(this, _error_codes).COMMIT_AFTER_TERM)) { + var result = this.storeData(false); + + if (!this.settings.sendBeaconCommit && !this.settings.asyncCommit && result.errorCode && result.errorCode > 0) { + this.throwSCORMError(result.errorCode); + } + + returnValue = typeof result !== 'undefined' && result.result ? result.result : global_constants.SCORM_FALSE; + this.apiLog(callbackName, 'HttpRequest', ' Result: ' + returnValue, global_constants.LOG_LEVEL_DEBUG); + if (checkTerminated) this.lastErrorCode = 0; + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Returns last error code + * @param {string} callbackName + * @return {string} + */ + + }, { + key: "getLastError", + value: function getLastError(callbackName) { + var returnValue = String(this.lastErrorCode); + this.processListeners(callbackName); + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + return returnValue; + } + /** + * Returns the errorNumber error description + * + * @param {string} callbackName + * @param {(string|number)} CMIErrorCode + * @return {string} + */ + + }, { + key: "getErrorString", + value: function getErrorString(callbackName, CMIErrorCode) { + var returnValue = ''; + + if (CMIErrorCode !== null && CMIErrorCode !== '') { + returnValue = this.getLmsErrorMessageDetails(CMIErrorCode); + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + return returnValue; + } + /** + * Returns a comprehensive description of the errorNumber error. + * + * @param {string} callbackName + * @param {(string|number)} CMIErrorCode + * @return {string} + */ + + }, { + key: "getDiagnostic", + value: function getDiagnostic(callbackName, CMIErrorCode) { + var returnValue = ''; + + if (CMIErrorCode !== null && CMIErrorCode !== '') { + returnValue = this.getLmsErrorMessageDetails(CMIErrorCode, true); + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + return returnValue; + } + /** + * Checks the LMS state and ensures it has been initialized. + * + * @param {boolean} checkTerminated + * @param {number} beforeInitError + * @param {number} afterTermError + * @return {boolean} + */ + + }, { + key: "checkState", + value: function checkState(checkTerminated, beforeInitError, afterTermError) { + if (this.isNotInitialized()) { + this.throwSCORMError(beforeInitError); + return false; + } else if (checkTerminated && this.isTerminated()) { + this.throwSCORMError(afterTermError); + return false; + } + + return true; + } + /** + * Logging for all SCORM actions + * + * @param {string} functionName + * @param {string} CMIElement + * @param {string} logMessage + * @param {number}messageLevel + */ + + }, { + key: "apiLog", + value: function apiLog(functionName, CMIElement, logMessage, messageLevel) { + logMessage = this.formatMessage(functionName, CMIElement, logMessage); + + if (messageLevel >= this.apiLogLevel) { + switch (messageLevel) { + case global_constants.LOG_LEVEL_ERROR: + console.error(logMessage); + break; + + case global_constants.LOG_LEVEL_WARNING: + console.warn(logMessage); + break; + + case global_constants.LOG_LEVEL_INFO: + console.info(logMessage); + break; + + case global_constants.LOG_LEVEL_DEBUG: + if (console.debug) { + console.debug(logMessage); + } else { + console.log(logMessage); + } + + break; + } + } + } + /** + * Formats the SCORM messages for easy reading + * + * @param {string} functionName + * @param {string} CMIElement + * @param {string} message + * @return {string} + */ + + }, { + key: "formatMessage", + value: function formatMessage(functionName, CMIElement, message) { + var baseLength = 20; + var messageString = ''; + messageString += functionName; + var fillChars = baseLength - messageString.length; + + for (var i = 0; i < fillChars; i++) { + messageString += ' '; + } + + messageString += ': '; + + if (CMIElement) { + var CMIElementBaseLength = 70; + messageString += CMIElement; + fillChars = CMIElementBaseLength - messageString.length; + + for (var j = 0; j < fillChars; j++) { + messageString += ' '; + } + } + + if (message) { + messageString += message; + } + + return messageString; + } + /** + * Checks to see if {str} contains {tester} + * + * @param {string} str String to check against + * @param {string} tester String to check for + * @return {boolean} + */ + + }, { + key: "stringMatches", + value: function stringMatches(str, tester) { + return str && tester && str.match(tester); + } + /** + * Check to see if the specific object has the given property + * @param {*} refObject + * @param {string} attribute + * @return {boolean} + * @private + */ + + }, { + key: "_checkObjectHasProperty", + value: function _checkObjectHasProperty(refObject, attribute) { + return Object.hasOwnProperty.call(refObject, attribute) || Object.getOwnPropertyDescriptor(Object.getPrototypeOf(refObject), attribute) || attribute in refObject; + } + /** + * Returns the message that corresponds to errorNumber + * APIs that inherit BaseAPI should override this function + * + * @param {(string|number)} _errorNumber + * @param {boolean} _detail + * @return {string} + * @abstract + */ + + }, { + key: "getLmsErrorMessageDetails", + value: function getLmsErrorMessageDetails(_errorNumber, _detail) { + throw new Error('The getLmsErrorMessageDetails method has not been implemented'); + } + /** + * Gets the value for the specific element. + * APIs that inherit BaseAPI should override this function + * + * @param {string} _CMIElement + * @return {string} + * @abstract + */ + + }, { + key: "getCMIValue", + value: function getCMIValue(_CMIElement) { + throw new Error('The getCMIValue method has not been implemented'); + } + /** + * Sets the value for the specific element. + * APIs that inherit BaseAPI should override this function + * + * @param {string} _CMIElement + * @param {any} _value + * @return {string} + * @abstract + */ + + }, { + key: "setCMIValue", + value: function setCMIValue(_CMIElement, _value) { + throw new Error('The setCMIValue method has not been implemented'); + } + /** + * Shared API method to set a valid for a given element. + * + * @param {string} methodName + * @param {boolean} scorm2004 + * @param {string} CMIElement + * @param {*} value + * @return {string} + */ + + }, { + key: "_commonSetCMIValue", + value: function _commonSetCMIValue(methodName, scorm2004, CMIElement, value) { + if (!CMIElement || CMIElement === '') { + return global_constants.SCORM_FALSE; + } + + var structure = CMIElement.split('.'); + var refObject = this; + var returnValue = global_constants.SCORM_FALSE; + var foundFirstIndex = false; + var invalidErrorMessage = "The data model element passed to ".concat(methodName, " (").concat(CMIElement, ") is not a valid SCORM data model element."); + var invalidErrorCode = scorm2004 ? _classPrivateFieldGet(this, _error_codes).UNDEFINED_DATA_MODEL : _classPrivateFieldGet(this, _error_codes).GENERAL; + + for (var i = 0; i < structure.length; i++) { + var attribute = structure[i]; + + if (i === structure.length - 1) { + if (scorm2004 && attribute.substr(0, 8) === '{target=' && typeof refObject._isTargetValid == 'function') { + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).READ_ONLY_ELEMENT); + } else if (!this._checkObjectHasProperty(refObject, attribute)) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + } else { + if (this.isInitialized() && this.stringMatches(CMIElement, '\\.correct_responses\\.\\d+')) { + this.validateCorrectResponse(CMIElement, value); + } + + if (!scorm2004 || this.lastErrorCode === 0) { + refObject[attribute] = value; + returnValue = global_constants.SCORM_TRUE; + } + } + } else { + refObject = refObject[attribute]; + + if (!refObject) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + break; + } + + if (refObject instanceof _common.CMIArray) { + var index = parseInt(structure[i + 1], 10); // SCO is trying to set an item on an array + + if (!isNaN(index)) { + var item = refObject.childArray[index]; + + if (item) { + refObject = item; + foundFirstIndex = true; + } else { + var newChild = this.getChildElement(CMIElement, value, foundFirstIndex); + foundFirstIndex = true; + + if (!newChild) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + } else { + if (refObject.initialized) newChild.initialize(); + refObject.childArray.push(newChild); + refObject = newChild; + } + } // Have to update i value to skip the array position + + + i++; + } + } + } + } + + if (returnValue === global_constants.SCORM_FALSE) { + this.apiLog(methodName, null, "There was an error setting the value for: ".concat(CMIElement, ", value of: ").concat(value), global_constants.LOG_LEVEL_WARNING); + } + + return returnValue; + } + /** + * Abstract method for validating that a response is correct. + * + * @param {string} _CMIElement + * @param {*} _value + */ + + }, { + key: "validateCorrectResponse", + value: function validateCorrectResponse(_CMIElement, _value) {// just a stub method + } + /** + * Gets or builds a new child element to add to the array. + * APIs that inherit BaseAPI should override this method. + * + * @param {string} _CMIElement - unused + * @param {*} _value - unused + * @param {boolean} _foundFirstIndex - unused + * @return {*} + * @abstract + */ + + }, { + key: "getChildElement", + value: function getChildElement(_CMIElement, _value, _foundFirstIndex) { + throw new Error('The getChildElement method has not been implemented'); + } + /** + * Gets a value from the CMI Object + * + * @param {string} methodName + * @param {boolean} scorm2004 + * @param {string} CMIElement + * @return {*} + */ + + }, { + key: "_commonGetCMIValue", + value: function _commonGetCMIValue(methodName, scorm2004, CMIElement) { + if (!CMIElement || CMIElement === '') { + return ''; + } + + var structure = CMIElement.split('.'); + var refObject = this; + var attribute = null; + var uninitializedErrorMessage = "The data model element passed to ".concat(methodName, " (").concat(CMIElement, ") has not been initialized."); + var invalidErrorMessage = "The data model element passed to ".concat(methodName, " (").concat(CMIElement, ") is not a valid SCORM data model element."); + var invalidErrorCode = scorm2004 ? _classPrivateFieldGet(this, _error_codes).UNDEFINED_DATA_MODEL : _classPrivateFieldGet(this, _error_codes).GENERAL; + + for (var i = 0; i < structure.length; i++) { + attribute = structure[i]; + + if (!scorm2004) { + if (i === structure.length - 1) { + if (!this._checkObjectHasProperty(refObject, attribute)) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + return; + } + } + } else { + if (String(attribute).substr(0, 8) === '{target=' && typeof refObject._isTargetValid == 'function') { + var target = String(attribute).substr(8, String(attribute).length - 9); + return refObject._isTargetValid(target); + } else if (!this._checkObjectHasProperty(refObject, attribute)) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + return; + } + } + + refObject = refObject[attribute]; + + if (refObject === undefined) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + break; + } + + if (refObject instanceof _common.CMIArray) { + var index = parseInt(structure[i + 1], 10); // SCO is trying to set an item on an array + + if (!isNaN(index)) { + var item = refObject.childArray[index]; + + if (item) { + refObject = item; + } else { + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).VALUE_NOT_INITIALIZED, uninitializedErrorMessage); + break; + } // Have to update i value to skip the array position + + + i++; + } + } + } + + if (refObject === null || refObject === undefined) { + if (!scorm2004) { + if (attribute === '_children') { + this.throwSCORMError(scorm12_error_codes.CHILDREN_ERROR); + } else if (attribute === '_count') { + this.throwSCORMError(scorm12_error_codes.COUNT_ERROR); + } + } + } else { + return refObject; + } + } + /** + * Returns true if the API's current state is STATE_INITIALIZED + * + * @return {boolean} + */ + + }, { + key: "isInitialized", + value: function isInitialized() { + return this.currentState === global_constants.STATE_INITIALIZED; + } + /** + * Returns true if the API's current state is STATE_NOT_INITIALIZED + * + * @return {boolean} + */ + + }, { + key: "isNotInitialized", + value: function isNotInitialized() { + return this.currentState === global_constants.STATE_NOT_INITIALIZED; + } + /** + * Returns true if the API's current state is STATE_TERMINATED + * + * @return {boolean} + */ + + }, { + key: "isTerminated", + value: function isTerminated() { + return this.currentState === global_constants.STATE_TERMINATED; + } + /** + * Provides a mechanism for attaching to a specific SCORM event + * + * @param {string} listenerName + * @param {function} callback + */ + + }, { + key: "on", + value: function on(listenerName, callback) { + if (!callback) return; + var listenerFunctions = listenerName.split(' '); + + for (var i = 0; i < listenerFunctions.length; i++) { + var listenerSplit = listenerFunctions[i].split('.'); + if (listenerSplit.length === 0) return; + var functionName = listenerSplit[0]; + var CMIElement = null; + + if (listenerSplit.length > 1) { + CMIElement = listenerName.replace(functionName + '.', ''); + } + + this.listenerArray.push({ + functionName: functionName, + CMIElement: CMIElement, + callback: callback + }); + this.apiLog('on', functionName, "Added event listener: ".concat(this.listenerArray.length), global_constants.LOG_LEVEL_INFO); + } + } + /** + * Provides a mechanism for detaching a specific SCORM event listener + * + * @param {string} listenerName + * @param {function} callback + */ + + }, { + key: "off", + value: function off(listenerName, callback) { + var _this = this; + + if (!callback) return; + var listenerFunctions = listenerName.split(' '); + + var _loop = function _loop(i) { + var listenerSplit = listenerFunctions[i].split('.'); + if (listenerSplit.length === 0) return { + v: void 0 + }; + var functionName = listenerSplit[0]; + var CMIElement = null; + + if (listenerSplit.length > 1) { + CMIElement = listenerName.replace(functionName + '.', ''); + } + + var removeIndex = _this.listenerArray.findIndex(function (obj) { + return obj.functionName === functionName && obj.CMIElement === CMIElement && obj.callback === callback; + }); + + if (removeIndex !== -1) { + _this.listenerArray.splice(removeIndex, 1); + + _this.apiLog('off', functionName, "Removed event listener: ".concat(_this.listenerArray.length), global_constants.LOG_LEVEL_INFO); + } + }; + + for (var i = 0; i < listenerFunctions.length; i++) { + var _ret = _loop(i); + + if (_typeof(_ret) === "object") return _ret.v; + } + } + /** + * Provides a mechanism for clearing all listeners from a specific SCORM event + * + * @param {string} listenerName + */ + + }, { + key: "clear", + value: function clear(listenerName) { + var _this2 = this; + + var listenerFunctions = listenerName.split(' '); + + var _loop2 = function _loop2(i) { + var listenerSplit = listenerFunctions[i].split('.'); + if (listenerSplit.length === 0) return { + v: void 0 + }; + var functionName = listenerSplit[0]; + var CMIElement = null; + + if (listenerSplit.length > 1) { + CMIElement = listenerName.replace(functionName + '.', ''); + } + + _this2.listenerArray = _this2.listenerArray.filter(function (obj) { + return obj.functionName !== functionName && obj.CMIElement !== CMIElement; + }); + }; + + for (var i = 0; i < listenerFunctions.length; i++) { + var _ret2 = _loop2(i); + + if (_typeof(_ret2) === "object") return _ret2.v; + } + } + /** + * Processes any 'on' listeners that have been created + * + * @param {string} functionName + * @param {string} CMIElement + * @param {*} value + */ + + }, { + key: "processListeners", + value: function processListeners(functionName, CMIElement, value) { + this.apiLog(functionName, CMIElement, value); + + for (var i = 0; i < this.listenerArray.length; i++) { + var listener = this.listenerArray[i]; + var functionsMatch = listener.functionName === functionName; + var listenerHasCMIElement = !!listener.CMIElement; + var CMIElementsMatch = false; + + if (CMIElement && listener.CMIElement && listener.CMIElement.substring(listener.CMIElement.length - 1) === '*') { + CMIElementsMatch = CMIElement.indexOf(listener.CMIElement.substring(0, listener.CMIElement.length - 1)) === 0; + } else { + CMIElementsMatch = listener.CMIElement === CMIElement; + } + + if (functionsMatch && (!listenerHasCMIElement || CMIElementsMatch)) { + listener.callback(CMIElement, value); + } + } + } + /** + * Throws a SCORM error + * + * @param {number} errorNumber + * @param {string} message + */ + + }, { + key: "throwSCORMError", + value: function throwSCORMError(errorNumber, message) { + if (!message) { + message = this.getLmsErrorMessageDetails(errorNumber); + } + + this.apiLog('throwSCORMError', null, errorNumber + ': ' + message, global_constants.LOG_LEVEL_ERROR); + this.lastErrorCode = String(errorNumber); + } + /** + * Clears the last SCORM error code on success. + * + * @param {string} success + */ + + }, { + key: "clearSCORMError", + value: function clearSCORMError(success) { + if (success !== undefined && success !== global_constants.SCORM_FALSE) { + this.lastErrorCode = 0; + } + } + /** + * Attempts to store the data to the LMS, logs data if no LMS configured + * APIs that inherit BaseAPI should override this function + * + * @param {boolean} _calculateTotalTime + * @return {string} + * @abstract + */ + + }, { + key: "storeData", + value: function storeData(_calculateTotalTime) { + throw new Error('The storeData method has not been implemented'); + } + /** + * Load the CMI from a flattened JSON object + * @param {object} json + * @param {string} CMIElement + */ + + }, { + key: "loadFromFlattenedJSON", + value: function loadFromFlattenedJSON(json, CMIElement) { + var _this3 = this; + + if (!this.isNotInitialized()) { + console.error('loadFromFlattenedJSON can only be called before the call to lmsInitialize.'); + return; + } + /** + * Test match pattern. + * + * @param {string} a + * @param {string} c + * @param {RegExp} a_pattern + * @return {number} + */ + + + function testPattern(a, c, a_pattern) { + var a_match = a.match(a_pattern); + var c_match; + + if (a_match !== null && (c_match = c.match(a_pattern)) !== null) { + var a_num = Number(a_match[2]); + var c_num = Number(c_match[2]); + + if (a_num === c_num) { + if (a_match[3] === 'id') { + return -1; + } else if (a_match[3] === 'type') { + if (c_match[3] === 'id') { + return 1; + } else { + return -1; + } + } else { + return 1; + } + } + + return a_num - c_num; + } + + return null; + } + + var int_pattern = /^(cmi\.interactions\.)(\d+)\.(.*)$/; + var obj_pattern = /^(cmi\.objectives\.)(\d+)\.(.*)$/; + var result = Object.keys(json).map(function (key) { + return [String(key), json[key]]; + }); // CMI interactions need to have id and type loaded before any other fields + + result.sort(function (_ref, _ref2) { + var _ref3 = _slicedToArray(_ref, 2), + a = _ref3[0], + b = _ref3[1]; + + var _ref4 = _slicedToArray(_ref2, 2), + c = _ref4[0], + d = _ref4[1]; + + var test; + + if ((test = testPattern(a, c, int_pattern)) !== null) { + return test; + } + + if ((test = testPattern(a, c, obj_pattern)) !== null) { + return test; + } + + if (a < c) { + return -1; + } + + if (a > c) { + return 1; + } + + return 0; + }); + var obj; + result.forEach(function (element) { + obj = {}; + obj[element[0]] = element[1]; + + _this3.loadFromJSON((0, _utilities.unflatten)(obj), CMIElement); + }); + } + /** + * Loads CMI data from a JSON object. + * + * @param {object} json + * @param {string} CMIElement + */ + + }, { + key: "loadFromJSON", + value: function loadFromJSON(json, CMIElement) { + if (!this.isNotInitialized()) { + console.error('loadFromJSON can only be called before the call to lmsInitialize.'); + return; + } + + CMIElement = CMIElement !== undefined ? CMIElement : 'cmi'; + this.startingData = json; // could this be refactored down to flatten(json) then setCMIValue on each? + + for (var key in json) { + if ({}.hasOwnProperty.call(json, key) && json[key]) { + var currentCMIElement = (CMIElement ? CMIElement + '.' : '') + key; + var value = json[key]; + + if (value['childArray']) { + for (var i = 0; i < value['childArray'].length; i++) { + this.loadFromJSON(value['childArray'][i], currentCMIElement + '.' + i); + } + } else if (value.constructor === Object) { + this.loadFromJSON(value, currentCMIElement); + } else { + this.setCMIValue(currentCMIElement, value); + } + } + } + } + /** + * Render the CMI object to JSON for sending to an LMS. + * + * @return {string} + */ + + }, { + key: "renderCMIToJSONString", + value: function renderCMIToJSONString() { + var cmi = this.cmi; // Do we want/need to return fields that have no set value? + // return JSON.stringify({ cmi }, (k, v) => v === undefined ? null : v, 2); + + return JSON.stringify({ + cmi: cmi + }); + } + /** + * Returns a JS object representing the current cmi + * @return {object} + */ + + }, { + key: "renderCMIToJSONObject", + value: function renderCMIToJSONObject() { + // Do we want/need to return fields that have no set value? + // return JSON.stringify({ cmi }, (k, v) => v === undefined ? null : v, 2); + return JSON.parse(this.renderCMIToJSONString()); + } + /** + * Render the cmi object to the proper format for LMS commit + * APIs that inherit BaseAPI should override this function + * + * @param {boolean} _terminateCommit + * @return {*} + * @abstract + */ + + }, { + key: "renderCommitCMI", + value: function renderCommitCMI(_terminateCommit) { + throw new Error('The storeData method has not been implemented'); + } + /** + * Send the request to the LMS + * @param {string} url + * @param {object|Array} params + * @param {boolean} immediate + * @return {object} + */ + + }, { + key: "processHttpRequest", + value: function processHttpRequest(url, params) { + var immediate = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + var api = this; + + var process = function process(url, params, settings, error_codes) { + var genericError = { + 'result': global_constants.SCORM_FALSE, + 'errorCode': error_codes.GENERAL + }; + var result; + + if (!settings.sendBeaconCommit) { + var httpReq = new XMLHttpRequest(); + httpReq.open('POST', url, settings.asyncCommit); + + if (settings.asyncCommit) { + httpReq.onload = function (e) { + if (typeof settings.responseHandler === 'function') { + result = settings.responseHandler(httpReq); + } else { + result = JSON.parse(httpReq.responseText); + } + }; + } + + try { + if (params instanceof Array) { + httpReq.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded'); + httpReq.send(params.join('&')); + } else { + httpReq.setRequestHeader('Content-Type', settings.commitRequestDataType); + httpReq.send(JSON.stringify(params)); + } + + if (!settings.asyncCommit) { + if (typeof settings.responseHandler === 'function') { + result = settings.responseHandler(httpReq); + } else { + result = JSON.parse(httpReq.responseText); + } + } else { + result = {}; + result.result = global_constants.SCORM_TRUE; + result.errorCode = 0; + api.processListeners('CommitSuccess'); + return result; + } + } catch (e) { + console.error(e); + api.processListeners('CommitError'); + return genericError; + } + } else { + try { + var headers = { + type: settings.commitRequestDataType + }; + var blob; + + if (params instanceof Array) { + blob = new Blob([params.join('&')], headers); + } else { + blob = new Blob([JSON.stringify(params)], headers); + } + + result = {}; + + if (navigator.sendBeacon(url, blob)) { + result.result = global_constants.SCORM_TRUE; + result.errorCode = 0; + } else { + result.result = global_constants.SCORM_FALSE; + result.errorCode = 101; + } + } catch (e) { + console.error(e); + api.processListeners('CommitError'); + return genericError; + } + } + + if (typeof result === 'undefined') { + api.processListeners('CommitError'); + return genericError; + } + + if (result.result === true || result.result === global_constants.SCORM_TRUE) { + api.processListeners('CommitSuccess'); + } else { + api.processListeners('CommitError'); + } + + return result; + }; + + if (typeof _lodash["default"] !== 'undefined') { + var debounced = (0, _lodash["default"])(process, 500); + debounced(url, params, this.settings, this.error_codes); // if we're terminating, go ahead and commit immediately + + if (immediate) { + debounced.flush(); + } + + return { + result: global_constants.SCORM_TRUE, + errorCode: 0 + }; + } else { + return process(url, params, this.settings, this.error_codes); + } + } + /** + * Throws a SCORM error + * + * @param {number} when - the number of milliseconds to wait before committing + * @param {string} callback - the name of the commit event callback + */ + + }, { + key: "scheduleCommit", + value: function scheduleCommit(when, callback) { + _classPrivateFieldSet(this, _timeout, new ScheduledCommit(this, when, callback)); + + this.apiLog('scheduleCommit', '', 'scheduled', global_constants.LOG_LEVEL_DEBUG); + } + /** + * Clears and cancels any currently scheduled commits + */ + + }, { + key: "clearScheduledCommit", + value: function clearScheduledCommit() { + if (_classPrivateFieldGet(this, _timeout)) { + _classPrivateFieldGet(this, _timeout).cancel(); + + _classPrivateFieldSet(this, _timeout, null); + + this.apiLog('clearScheduledCommit', '', 'cleared', global_constants.LOG_LEVEL_DEBUG); + } + } + }]); + + return BaseAPI; +}(); +/** + * Private class that wraps a timeout call to the commit() function + */ + + +exports["default"] = BaseAPI; + +var _API = new WeakMap(); + +var _cancelled = new WeakMap(); + +var _timeout2 = new WeakMap(); + +var _callback = new WeakMap(); + +var ScheduledCommit = /*#__PURE__*/function () { + /** + * Constructor for ScheduledCommit + * @param {BaseAPI} API + * @param {number} when + * @param {string} callback + */ + function ScheduledCommit(API, when, callback) { + _classCallCheck(this, ScheduledCommit); + + _API.set(this, { + writable: true, + value: void 0 + }); + + _cancelled.set(this, { + writable: true, + value: false + }); + + _timeout2.set(this, { + writable: true, + value: void 0 + }); + + _callback.set(this, { + writable: true, + value: void 0 + }); + + _classPrivateFieldSet(this, _API, API); + + _classPrivateFieldSet(this, _timeout2, setTimeout(this.wrapper.bind(this), when)); + + _classPrivateFieldSet(this, _callback, callback); + } + /** + * Cancel any currently scheduled commit + */ + + + _createClass(ScheduledCommit, [{ + key: "cancel", + value: function cancel() { + _classPrivateFieldSet(this, _cancelled, true); + + if (_classPrivateFieldGet(this, _timeout2)) { + clearTimeout(_classPrivateFieldGet(this, _timeout2)); + } + } + /** + * Wrap the API commit call to check if the call has already been cancelled + */ + + }, { + key: "wrapper", + value: function wrapper() { + if (!_classPrivateFieldGet(this, _cancelled)) { + _classPrivateFieldGet(this, _API).commit(_classPrivateFieldGet(this, _callback)); + } + } + }]); + + return ScheduledCommit; +}(); + +},{"./cmi/common":6,"./constants/api_constants":8,"./constants/error_codes":9,"./exceptions":11,"./utilities":13,"lodash.debounce":1}],4:[function(require,module,exports){ +"use strict"; + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +var _BaseAPI2 = _interopRequireDefault(require("./BaseAPI")); + +var _scorm12_cmi = require("./cmi/scorm12_cmi"); + +var Utilities = _interopRequireWildcard(require("./utilities")); + +var _api_constants = _interopRequireDefault(require("./constants/api_constants")); + +var _error_codes = _interopRequireDefault(require("./constants/error_codes")); + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +var scorm12_constants = _api_constants["default"].scorm12; +var global_constants = _api_constants["default"].global; +var scorm12_error_codes = _error_codes["default"].scorm12; +/** + * API class for SCORM 1.2 + */ + +var Scorm12API = /*#__PURE__*/function (_BaseAPI) { + _inherits(Scorm12API, _BaseAPI); + + var _super = _createSuper(Scorm12API); + + /** + * Constructor for SCORM 1.2 API + * @param {object} settings + */ + function Scorm12API(settings) { + var _this; + + _classCallCheck(this, Scorm12API); + + var finalSettings = _objectSpread(_objectSpread({}, { + mastery_override: false + }), settings); + + _this = _super.call(this, scorm12_error_codes, finalSettings); + _this.cmi = new _scorm12_cmi.CMI(); + _this.nav = new _scorm12_cmi.NAV(); // Rename functions to match 1.2 Spec and expose to modules + + _this.LMSInitialize = _this.lmsInitialize; + _this.LMSFinish = _this.lmsFinish; + _this.LMSGetValue = _this.lmsGetValue; + _this.LMSSetValue = _this.lmsSetValue; + _this.LMSCommit = _this.lmsCommit; + _this.LMSGetLastError = _this.lmsGetLastError; + _this.LMSGetErrorString = _this.lmsGetErrorString; + _this.LMSGetDiagnostic = _this.lmsGetDiagnostic; + return _this; + } + /** + * lmsInitialize function from SCORM 1.2 Spec + * + * @return {string} bool + */ + + + _createClass(Scorm12API, [{ + key: "lmsInitialize", + value: function lmsInitialize() { + this.cmi.initialize(); + return this.initialize('LMSInitialize', 'LMS was already initialized!', 'LMS is already finished!'); + } + /** + * LMSFinish function from SCORM 1.2 Spec + * + * @return {string} bool + */ + + }, { + key: "lmsFinish", + value: function lmsFinish() { + var result = this.terminate('LMSFinish', true); + + if (result === global_constants.SCORM_TRUE) { + if (this.nav.event !== '') { + if (this.nav.event === 'continue') { + this.processListeners('SequenceNext'); + } else { + this.processListeners('SequencePrevious'); + } + } else if (this.settings.autoProgress) { + this.processListeners('SequenceNext'); + } + } + + return result; + } + /** + * LMSGetValue function from SCORM 1.2 Spec + * + * @param {string} CMIElement + * @return {string} + */ + + }, { + key: "lmsGetValue", + value: function lmsGetValue(CMIElement) { + return this.getValue('LMSGetValue', false, CMIElement); + } + /** + * LMSSetValue function from SCORM 1.2 Spec + * + * @param {string} CMIElement + * @param {*} value + * @return {string} + */ + + }, { + key: "lmsSetValue", + value: function lmsSetValue(CMIElement, value) { + return this.setValue('LMSSetValue', 'LMSCommit', false, CMIElement, value); + } + /** + * LMSCommit function from SCORM 1.2 Spec + * + * @return {string} bool + */ + + }, { + key: "lmsCommit", + value: function lmsCommit() { + return this.commit('LMSCommit', false); + } + /** + * LMSGetLastError function from SCORM 1.2 Spec + * + * @return {string} + */ + + }, { + key: "lmsGetLastError", + value: function lmsGetLastError() { + return this.getLastError('LMSGetLastError'); + } + /** + * LMSGetErrorString function from SCORM 1.2 Spec + * + * @param {string} CMIErrorCode + * @return {string} + */ + + }, { + key: "lmsGetErrorString", + value: function lmsGetErrorString(CMIErrorCode) { + return this.getErrorString('LMSGetErrorString', CMIErrorCode); + } + /** + * LMSGetDiagnostic function from SCORM 1.2 Spec + * + * @param {string} CMIErrorCode + * @return {string} + */ + + }, { + key: "lmsGetDiagnostic", + value: function lmsGetDiagnostic(CMIErrorCode) { + return this.getDiagnostic('LMSGetDiagnostic', CMIErrorCode); + } + /** + * Sets a value on the CMI Object + * + * @param {string} CMIElement + * @param {*} value + * @return {string} + */ + + }, { + key: "setCMIValue", + value: function setCMIValue(CMIElement, value) { + return this._commonSetCMIValue('LMSSetValue', false, CMIElement, value); + } + /** + * Gets a value from the CMI Object + * + * @param {string} CMIElement + * @return {*} + */ + + }, { + key: "getCMIValue", + value: function getCMIValue(CMIElement) { + return this._commonGetCMIValue('getCMIValue', false, CMIElement); + } + /** + * Gets or builds a new child element to add to the array. + * + * @param {string} CMIElement + * @param {*} value + * @param {boolean} foundFirstIndex + * @return {object} + */ + + }, { + key: "getChildElement", + value: function getChildElement(CMIElement, value, foundFirstIndex) { + var newChild; + + if (this.stringMatches(CMIElement, 'cmi\\.objectives\\.\\d+')) { + newChild = new _scorm12_cmi.CMIObjectivesObject(); + } else if (foundFirstIndex && this.stringMatches(CMIElement, 'cmi\\.interactions\\.\\d+\\.correct_responses\\.\\d+')) { + newChild = new _scorm12_cmi.CMIInteractionsCorrectResponsesObject(); + } else if (foundFirstIndex && this.stringMatches(CMIElement, 'cmi\\.interactions\\.\\d+\\.objectives\\.\\d+')) { + newChild = new _scorm12_cmi.CMIInteractionsObjectivesObject(); + } else if (!foundFirstIndex && this.stringMatches(CMIElement, 'cmi\\.interactions\\.\\d+')) { + newChild = new _scorm12_cmi.CMIInteractionsObject(); + } + + return newChild; + } + /** + * Validates Correct Response values + * + * @param {string} CMIElement + * @param {*} value + * @return {boolean} + */ + + }, { + key: "validateCorrectResponse", + value: function validateCorrectResponse(CMIElement, value) { + return true; + } + /** + * Returns the message that corresponds to errorNumber. + * + * @param {*} errorNumber + * @param {boolean} detail + * @return {string} + */ + + }, { + key: "getLmsErrorMessageDetails", + value: function getLmsErrorMessageDetails(errorNumber, detail) { + var basicMessage = 'No Error'; + var detailMessage = 'No Error'; // Set error number to string since inconsistent from modules if string or number + + errorNumber = String(errorNumber); + + if (scorm12_constants.error_descriptions[errorNumber]) { + basicMessage = scorm12_constants.error_descriptions[errorNumber].basicMessage; + detailMessage = scorm12_constants.error_descriptions[errorNumber].detailMessage; + } + + return detail ? detailMessage : basicMessage; + } + /** + * Replace the whole API with another + * + * @param {Scorm12API} newAPI + */ + + }, { + key: "replaceWithAnotherScormAPI", + value: function replaceWithAnotherScormAPI(newAPI) { + // Data Model + this.cmi = newAPI.cmi; + } + /** + * Render the cmi object to the proper format for LMS commit + * + * @param {boolean} terminateCommit + * @return {object|Array} + */ + + }, { + key: "renderCommitCMI", + value: function renderCommitCMI(terminateCommit) { + var cmiExport = this.renderCMIToJSONObject(); + + if (terminateCommit) { + cmiExport.cmi.core.total_time = this.cmi.getCurrentTotalTime(); + } + + var result = []; + var flattened = Utilities.flatten(cmiExport); + + switch (this.settings.dataCommitFormat) { + case 'flattened': + return Utilities.flatten(cmiExport); + + case 'params': + for (var item in flattened) { + if ({}.hasOwnProperty.call(flattened, item)) { + result.push("".concat(item, "=").concat(flattened[item])); + } + } + + return result; + + case 'json': + default: + return cmiExport; + } + } + /** + * Attempts to store the data to the LMS + * + * @param {boolean} terminateCommit + * @return {string} + */ + + }, { + key: "storeData", + value: function storeData(terminateCommit) { + if (terminateCommit) { + var originalStatus = this.cmi.core.lesson_status; + + if (originalStatus === 'not attempted') { + this.cmi.core.lesson_status = 'completed'; + } + + if (this.cmi.core.lesson_mode === 'normal') { + if (this.cmi.core.credit === 'credit') { + if (this.settings.mastery_override && this.cmi.student_data.mastery_score !== '' && this.cmi.core.score.raw !== '') { + if (parseFloat(this.cmi.core.score.raw) >= parseFloat(this.cmi.student_data.mastery_score)) { + this.cmi.core.lesson_status = 'passed'; + } else { + this.cmi.core.lesson_status = 'failed'; + } + } + } + } else if (this.cmi.core.lesson_mode === 'browse') { + var _this$startingData, _this$startingData$cm, _this$startingData$cm2; + + if ((((_this$startingData = this.startingData) === null || _this$startingData === void 0 ? void 0 : (_this$startingData$cm = _this$startingData.cmi) === null || _this$startingData$cm === void 0 ? void 0 : (_this$startingData$cm2 = _this$startingData$cm.core) === null || _this$startingData$cm2 === void 0 ? void 0 : _this$startingData$cm2.lesson_status) || '') === '' && originalStatus === 'not attempted') { + this.cmi.core.lesson_status = 'browsed'; + } + } + } + + var commitObject = this.renderCommitCMI(terminateCommit || this.settings.alwaysSendTotalTime); + + if (this.apiLogLevel === global_constants.LOG_LEVEL_DEBUG) { + console.debug('Commit (terminated: ' + (terminateCommit ? 'yes' : 'no') + '): '); + console.debug(commitObject); + } + + if (this.settings.lmsCommitUrl) { + return this.processHttpRequest(this.settings.lmsCommitUrl, commitObject, terminateCommit); + } else { + return global_constants.SCORM_TRUE; + } + } + }]); + + return Scorm12API; +}(_BaseAPI2["default"]); + +exports["default"] = Scorm12API; + +},{"./BaseAPI":3,"./cmi/scorm12_cmi":7,"./constants/api_constants":8,"./constants/error_codes":9,"./utilities":13}],5:[function(require,module,exports){ +"use strict"; + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.CMIEvaluationCommentsObject = exports.CMIAttemptRecordsObject = exports.CMIAttemptRecords = exports.CMITriesObject = exports.CMITries = exports.CMIPathsObject = exports.CMIPaths = exports.CMIStudentDemographics = exports.CMI = void 0; + +var Scorm12CMI = _interopRequireWildcard(require("./scorm12_cmi")); + +var _common = require("./common"); + +var _api_constants = _interopRequireDefault(require("../constants/api_constants")); + +var _regex = _interopRequireDefault(require("../constants/regex")); + +var _error_codes = _interopRequireDefault(require("../constants/error_codes")); + +var _exceptions = require("../exceptions"); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; } + +function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } } + +function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); } + +function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); } + +function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); } + +function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +var aicc_constants = _api_constants["default"].aicc; +var aicc_regex = _regex["default"].aicc; +var aicc_error_codes = _error_codes["default"].scorm12; +/** + * Helper method for throwing Read Only error + */ + +function throwReadOnlyError() { + throw new _exceptions.AICCValidationError(aicc_error_codes.READ_ONLY_ELEMENT); +} +/** + * Helper method, no reason to have to pass the same error codes every time + * @param {*} value + * @param {string} regexPattern + * @param {boolean} allowEmptyString + * @return {boolean} + */ + + +function checkAICCValidFormat(value, regexPattern, allowEmptyString) { + return (0, _common.checkValidFormat)(value, regexPattern, aicc_error_codes.TYPE_MISMATCH, _exceptions.AICCValidationError, allowEmptyString); +} +/** + * CMI Class for AICC + */ + + +var CMI = /*#__PURE__*/function (_Scorm12CMI$CMI) { + _inherits(CMI, _Scorm12CMI$CMI); + + var _super = _createSuper(CMI); + + /** + * Constructor for AICC CMI object + * @param {boolean} initialized + */ + function CMI(initialized) { + var _this; + + _classCallCheck(this, CMI); + + _this = _super.call(this, aicc_constants.cmi_children); + if (initialized) _this.initialize(); + _this.student_preference = new AICCStudentPreferences(); + _this.student_data = new AICCCMIStudentData(); + _this.student_demographics = new CMIStudentDemographics(); + _this.evaluation = new CMIEvaluation(); + _this.paths = new CMIPaths(); + return _this; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(CMI, [{ + key: "initialize", + value: function initialize() { + var _this$student_prefere, _this$student_data, _this$student_demogra, _this$evaluation, _this$paths; + + _get(_getPrototypeOf(CMI.prototype), "initialize", this).call(this); + + (_this$student_prefere = this.student_preference) === null || _this$student_prefere === void 0 ? void 0 : _this$student_prefere.initialize(); + (_this$student_data = this.student_data) === null || _this$student_data === void 0 ? void 0 : _this$student_data.initialize(); + (_this$student_demogra = this.student_demographics) === null || _this$student_demogra === void 0 ? void 0 : _this$student_demogra.initialize(); + (_this$evaluation = this.evaluation) === null || _this$evaluation === void 0 ? void 0 : _this$evaluation.initialize(); + (_this$paths = this.paths) === null || _this$paths === void 0 ? void 0 : _this$paths.initialize(); + } + /** + * toJSON for cmi + * + * @return { + * { + * suspend_data: string, + * launch_data: string, + * comments: string, + * comments_from_lms: string, + * core: CMICore, + * objectives: CMIObjectives, + * student_data: CMIStudentData, + * student_preference: CMIStudentPreference, + * interactions: CMIInteractions, + * paths: CMIPaths + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'suspend_data': this.suspend_data, + 'launch_data': this.launch_data, + 'comments': this.comments, + 'comments_from_lms': this.comments_from_lms, + 'core': this.core, + 'objectives': this.objectives, + 'student_data': this.student_data, + 'student_preference': this.student_preference, + 'student_demographics': this.student_demographics, + 'interactions': this.interactions, + 'evaluation': this.evaluation, + 'paths': this.paths + }; + delete this.jsonString; + return result; + } + }]); + + return CMI; +}(Scorm12CMI.CMI); +/** + * AICC Evaluation object + */ + + +exports.CMI = CMI; + +var CMIEvaluation = /*#__PURE__*/function (_BaseCMI) { + _inherits(CMIEvaluation, _BaseCMI); + + var _super2 = _createSuper(CMIEvaluation); + + /** + * Constructor for AICC Evaluation object + */ + function CMIEvaluation() { + var _this2; + + _classCallCheck(this, CMIEvaluation); + + _this2 = _super2.call(this); + _this2.comments = new CMIEvaluationComments(); + return _this2; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(CMIEvaluation, [{ + key: "initialize", + value: function initialize() { + var _this$comments; + + _get(_getPrototypeOf(CMIEvaluation.prototype), "initialize", this).call(this); + + (_this$comments = this.comments) === null || _this$comments === void 0 ? void 0 : _this$comments.initialize(); + } + /** + * toJSON for cmi.evaluation object + * @return {{comments: CMIEvaluationComments}} + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'comments': this.comments + }; + delete this.jsonString; + return result; + } + }]); + + return CMIEvaluation; +}(_common.BaseCMI); +/** + * Class representing AICC's cmi.evaluation.comments object + */ + + +var CMIEvaluationComments = /*#__PURE__*/function (_CMIArray) { + _inherits(CMIEvaluationComments, _CMIArray); + + var _super3 = _createSuper(CMIEvaluationComments); + + /** + * Constructor for AICC Evaluation Comments object + */ + function CMIEvaluationComments() { + _classCallCheck(this, CMIEvaluationComments); + + return _super3.call(this, { + children: aicc_constants.comments_children, + errorCode: aicc_error_codes.INVALID_SET_VALUE, + errorClass: _exceptions.AICCValidationError + }); + } + + return CMIEvaluationComments; +}(_common.CMIArray); +/** + * StudentPreferences class for AICC + */ + + +var _lesson_type = new WeakMap(); + +var _text_color = new WeakMap(); + +var _text_location = new WeakMap(); + +var _text_size = new WeakMap(); + +var _video = new WeakMap(); + +var AICCStudentPreferences = /*#__PURE__*/function (_Scorm12CMI$CMIStuden) { + _inherits(AICCStudentPreferences, _Scorm12CMI$CMIStuden); + + var _super4 = _createSuper(AICCStudentPreferences); + + /** + * Constructor for AICC Student Preferences object + */ + function AICCStudentPreferences() { + var _this3; + + _classCallCheck(this, AICCStudentPreferences); + + _this3 = _super4.call(this, aicc_constants.student_preference_children); + + _lesson_type.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _text_color.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _text_location.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _text_size.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _video.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _this3.windows = new _common.CMIArray({ + errorCode: aicc_error_codes.INVALID_SET_VALUE, + errorClass: _exceptions.AICCValidationError, + children: '' + }); + return _this3; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(AICCStudentPreferences, [{ + key: "initialize", + value: function initialize() { + var _this$windows; + + _get(_getPrototypeOf(AICCStudentPreferences.prototype), "initialize", this).call(this); + + (_this$windows = this.windows) === null || _this$windows === void 0 ? void 0 : _this$windows.initialize(); + } + }, { + key: "lesson_type", + get: + /** + * Getter for #lesson_type + * @return {string} + */ + function get() { + return _classPrivateFieldGet(this, _lesson_type); + } + /** + * Setter for #lesson_type + * @param {string} lesson_type + */ + , + set: function set(lesson_type) { + if (checkAICCValidFormat(lesson_type, aicc_regex.CMIString256)) { + _classPrivateFieldSet(this, _lesson_type, lesson_type); + } + } + /** + * Getter for #text_color + * @return {string} + */ + + }, { + key: "text_color", + get: function get() { + return _classPrivateFieldGet(this, _text_color); + } + /** + * Setter for #text_color + * @param {string} text_color + */ + , + set: function set(text_color) { + if (checkAICCValidFormat(text_color, aicc_regex.CMIString256)) { + _classPrivateFieldSet(this, _text_color, text_color); + } + } + /** + * Getter for #text_location + * @return {string} + */ + + }, { + key: "text_location", + get: function get() { + return _classPrivateFieldGet(this, _text_location); + } + /** + * Setter for #text_location + * @param {string} text_location + */ + , + set: function set(text_location) { + if (checkAICCValidFormat(text_location, aicc_regex.CMIString256)) { + _classPrivateFieldSet(this, _text_location, text_location); + } + } + /** + * Getter for #text_size + * @return {string} + */ + + }, { + key: "text_size", + get: function get() { + return _classPrivateFieldGet(this, _text_size); + } + /** + * Setter for #text_size + * @param {string} text_size + */ + , + set: function set(text_size) { + if (checkAICCValidFormat(text_size, aicc_regex.CMIString256)) { + _classPrivateFieldSet(this, _text_size, text_size); + } + } + /** + * Getter for #video + * @return {string} + */ + + }, { + key: "video", + get: function get() { + return _classPrivateFieldGet(this, _video); + } + /** + * Setter for #video + * @param {string} video + */ + , + set: function set(video) { + if (checkAICCValidFormat(video, aicc_regex.CMIString256)) { + _classPrivateFieldSet(this, _video, video); + } + } + /** + * toJSON for cmi.student_preference + * + * @return { + * { + * audio: string, + * language: string, + * speed: string, + * text: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'audio': this.audio, + 'language': this.language, + 'lesson_type': this.lesson_type, + 'speed': this.speed, + 'text': this.text, + 'text_color': this.text_color, + 'text_location': this.text_location, + 'text_size': this.text_size, + 'video': this.video, + 'windows': this.windows + }; + delete this.jsonString; + return result; + } + }]); + + return AICCStudentPreferences; +}(Scorm12CMI.CMIStudentPreference); +/** + * StudentData class for AICC + */ + + +var _tries_during_lesson = new WeakMap(); + +var AICCCMIStudentData = /*#__PURE__*/function (_Scorm12CMI$CMIStuden2) { + _inherits(AICCCMIStudentData, _Scorm12CMI$CMIStuden2); + + var _super5 = _createSuper(AICCCMIStudentData); + + /** + * Constructor for AICC StudentData object + */ + function AICCCMIStudentData() { + var _this4; + + _classCallCheck(this, AICCCMIStudentData); + + _this4 = _super5.call(this, aicc_constants.student_data_children); + + _tries_during_lesson.set(_assertThisInitialized(_this4), { + writable: true, + value: '' + }); + + _this4.tries = new CMITries(); + return _this4; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(AICCCMIStudentData, [{ + key: "initialize", + value: function initialize() { + var _this$tries; + + _get(_getPrototypeOf(AICCCMIStudentData.prototype), "initialize", this).call(this); + + (_this$tries = this.tries) === null || _this$tries === void 0 ? void 0 : _this$tries.initialize(); + } + }, { + key: "tries_during_lesson", + get: + /** + * Getter for tries_during_lesson + * @return {string} + */ + function get() { + return _classPrivateFieldGet(this, _tries_during_lesson); + } + /** + * Setter for #tries_during_lesson. Sets an error if trying to set after + * initialization. + * @param {string} tries_during_lesson + */ + , + set: function set(tries_during_lesson) { + !this.initialized ? _classPrivateFieldSet(this, _tries_during_lesson, tries_during_lesson) : throwReadOnlyError(); + } + /** + * toJSON for cmi.student_data object + * @return { + * { + * mastery_score: string, + * max_time_allowed: string, + * time_limit_action: string, + * tries: CMITries + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'mastery_score': this.mastery_score, + 'max_time_allowed': this.max_time_allowed, + 'time_limit_action': this.time_limit_action, + 'tries': this.tries + }; + delete this.jsonString; + return result; + } + }]); + + return AICCCMIStudentData; +}(Scorm12CMI.CMIStudentData); +/** + * Class representing the AICC cmi.student_demographics object + */ + + +var _children = new WeakMap(); + +var _city = new WeakMap(); + +var _class = new WeakMap(); + +var _company = new WeakMap(); + +var _country = new WeakMap(); + +var _experience = new WeakMap(); + +var _familiar_name = new WeakMap(); + +var _instructor_name = new WeakMap(); + +var _title = new WeakMap(); + +var _native_language = new WeakMap(); + +var _state = new WeakMap(); + +var _street_address = new WeakMap(); + +var _telephone = new WeakMap(); + +var _years_experience = new WeakMap(); + +var CMIStudentDemographics = /*#__PURE__*/function (_BaseCMI2) { + _inherits(CMIStudentDemographics, _BaseCMI2); + + var _super6 = _createSuper(CMIStudentDemographics); + + /** + * Constructor for AICC StudentDemographics object + */ + function CMIStudentDemographics() { + var _this5; + + _classCallCheck(this, CMIStudentDemographics); + + _this5 = _super6.call(this); + + _children.set(_assertThisInitialized(_this5), { + writable: true, + value: aicc_constants.student_demographics_children + }); + + _city.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _class.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _company.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _country.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _experience.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _familiar_name.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _instructor_name.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _title.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _native_language.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _state.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _street_address.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _telephone.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _years_experience.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + return _this5; + } + + _createClass(CMIStudentDemographics, [{ + key: "_children", + get: + /** + * Getter for _children + * @return {string} + */ + function get() { + return _classPrivateFieldGet(this, _children); + } + /** + * Getter for city + * @return {string} + */ + + }, { + key: "city", + get: function get() { + return _classPrivateFieldGet(this, _city); + } + /** + * Setter for #city. Sets an error if trying to set after + * initialization. + * @param {string} city + */ + , + set: function set(city) { + !this.initialized ? _classPrivateFieldSet(this, _city, city) : throwReadOnlyError(); + } + /** + * Getter for class + * @return {string} + */ + + }, { + key: "class", + get: function get() { + return _classPrivateFieldGet(this, _class); + } + /** + * Setter for #class. Sets an error if trying to set after + * initialization. + * @param {string} clazz + */ + , + set: function set(clazz) { + !this.initialized ? _classPrivateFieldSet(this, _class, clazz) : throwReadOnlyError(); + } + /** + * Getter for company + * @return {string} + */ + + }, { + key: "company", + get: function get() { + return _classPrivateFieldGet(this, _company); + } + /** + * Setter for #company. Sets an error if trying to set after + * initialization. + * @param {string} company + */ + , + set: function set(company) { + !this.initialized ? _classPrivateFieldSet(this, _company, company) : throwReadOnlyError(); + } + /** + * Getter for country + * @return {string} + */ + + }, { + key: "country", + get: function get() { + return _classPrivateFieldGet(this, _country); + } + /** + * Setter for #country. Sets an error if trying to set after + * initialization. + * @param {string} country + */ + , + set: function set(country) { + !this.initialized ? _classPrivateFieldSet(this, _country, country) : throwReadOnlyError(); + } + /** + * Getter for experience + * @return {string} + */ + + }, { + key: "experience", + get: function get() { + return _classPrivateFieldGet(this, _experience); + } + /** + * Setter for #experience. Sets an error if trying to set after + * initialization. + * @param {string} experience + */ + , + set: function set(experience) { + !this.initialized ? _classPrivateFieldSet(this, _experience, experience) : throwReadOnlyError(); + } + /** + * Getter for familiar_name + * @return {string} + */ + + }, { + key: "familiar_name", + get: function get() { + return _classPrivateFieldGet(this, _familiar_name); + } + /** + * Setter for #familiar_name. Sets an error if trying to set after + * initialization. + * @param {string} familiar_name + */ + , + set: function set(familiar_name) { + !this.initialized ? _classPrivateFieldSet(this, _familiar_name, familiar_name) : throwReadOnlyError(); + } + /** + * Getter for instructor_name + * @return {string} + */ + + }, { + key: "instructor_name", + get: function get() { + return _classPrivateFieldGet(this, _instructor_name); + } + /** + * Setter for #instructor_name. Sets an error if trying to set after + * initialization. + * @param {string} instructor_name + */ + , + set: function set(instructor_name) { + !this.initialized ? _classPrivateFieldSet(this, _instructor_name, instructor_name) : throwReadOnlyError(); + } + /** + * Getter for title + * @return {string} + */ + + }, { + key: "title", + get: function get() { + return _classPrivateFieldGet(this, _title); + } + /** + * Setter for #title. Sets an error if trying to set after + * initialization. + * @param {string} title + */ + , + set: function set(title) { + !this.initialized ? _classPrivateFieldSet(this, _title, title) : throwReadOnlyError(); + } + /** + * Getter for native_language + * @return {string} + */ + + }, { + key: "native_language", + get: function get() { + return _classPrivateFieldGet(this, _native_language); + } + /** + * Setter for #native_language. Sets an error if trying to set after + * initialization. + * @param {string} native_language + */ + , + set: function set(native_language) { + !this.initialized ? _classPrivateFieldSet(this, _native_language, native_language) : throwReadOnlyError(); + } + /** + * Getter for state + * @return {string} + */ + + }, { + key: "state", + get: function get() { + return _classPrivateFieldGet(this, _state); + } + /** + * Setter for #state. Sets an error if trying to set after + * initialization. + * @param {string} state + */ + , + set: function set(state) { + !this.initialized ? _classPrivateFieldSet(this, _state, state) : throwReadOnlyError(); + } + /** + * Getter for street_address + * @return {string} + */ + + }, { + key: "street_address", + get: function get() { + return _classPrivateFieldGet(this, _street_address); + } + /** + * Setter for #street_address. Sets an error if trying to set after + * initialization. + * @param {string} street_address + */ + , + set: function set(street_address) { + !this.initialized ? _classPrivateFieldSet(this, _street_address, street_address) : throwReadOnlyError(); + } + /** + * Getter for telephone + * @return {string} + */ + + }, { + key: "telephone", + get: function get() { + return _classPrivateFieldGet(this, _telephone); + } + /** + * Setter for #telephone. Sets an error if trying to set after + * initialization. + * @param {string} telephone + */ + , + set: function set(telephone) { + !this.initialized ? _classPrivateFieldSet(this, _telephone, telephone) : throwReadOnlyError(); + } + /** + * Getter for years_experience + * @return {string} + */ + + }, { + key: "years_experience", + get: function get() { + return _classPrivateFieldGet(this, _years_experience); + } + /** + * Setter for #years_experience. Sets an error if trying to set after + * initialization. + * @param {string} years_experience + */ + , + set: function set(years_experience) { + !this.initialized ? _classPrivateFieldSet(this, _years_experience, years_experience) : throwReadOnlyError(); + } + /** + * toJSON for cmi.student_demographics object + * @return { + * { + * city: string, + * class: string, + * company: string, + * country: string, + * experience: string, + * familiar_name: string, + * instructor_name: string, + * title: string, + * native_language: string, + * state: string, + * street_address: string, + * telephone: string, + * years_experience: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'city': this.city, + 'class': this["class"], + 'company': this.company, + 'country': this.country, + 'experience': this.experience, + 'familiar_name': this.familiar_name, + 'instructor_name': this.instructor_name, + 'title': this.title, + 'native_language': this.native_language, + 'state': this.state, + 'street_address': this.street_address, + 'telephone': this.telephone, + 'years_experience': this.years_experience + }; + delete this.jsonString; + return result; + } + }]); + + return CMIStudentDemographics; +}(_common.BaseCMI); +/** + * Class representing the AICC cmi.paths object + */ + + +exports.CMIStudentDemographics = CMIStudentDemographics; + +var CMIPaths = /*#__PURE__*/function (_CMIArray2) { + _inherits(CMIPaths, _CMIArray2); + + var _super7 = _createSuper(CMIPaths); + + /** + * Constructor for inline Paths Array class + */ + function CMIPaths() { + _classCallCheck(this, CMIPaths); + + return _super7.call(this, { + children: aicc_constants.paths_children + }); + } + + return CMIPaths; +}(_common.CMIArray); +/** + * Class for AICC Paths + */ + + +exports.CMIPaths = CMIPaths; + +var _location_id = new WeakMap(); + +var _date = new WeakMap(); + +var _time = new WeakMap(); + +var _status = new WeakMap(); + +var _why_left = new WeakMap(); + +var _time_in_element = new WeakMap(); + +var CMIPathsObject = /*#__PURE__*/function (_BaseCMI3) { + _inherits(CMIPathsObject, _BaseCMI3); + + var _super8 = _createSuper(CMIPathsObject); + + /** + * Constructor for AICC Paths objects + */ + function CMIPathsObject() { + var _this6; + + _classCallCheck(this, CMIPathsObject); + + _this6 = _super8.call(this); + + _location_id.set(_assertThisInitialized(_this6), { + writable: true, + value: '' + }); + + _date.set(_assertThisInitialized(_this6), { + writable: true, + value: '' + }); + + _time.set(_assertThisInitialized(_this6), { + writable: true, + value: '' + }); + + _status.set(_assertThisInitialized(_this6), { + writable: true, + value: '' + }); + + _why_left.set(_assertThisInitialized(_this6), { + writable: true, + value: '' + }); + + _time_in_element.set(_assertThisInitialized(_this6), { + writable: true, + value: '' + }); + + return _this6; + } + + _createClass(CMIPathsObject, [{ + key: "location_id", + get: + /** + * Getter for #location_id + * @return {string} + */ + function get() { + return _classPrivateFieldGet(this, _location_id); + } + /** + * Setter for #location_id + * @param {string} location_id + */ + , + set: function set(location_id) { + if (checkAICCValidFormat(location_id, aicc_regex.CMIString256)) { + _classPrivateFieldSet(this, _location_id, location_id); + } + } + /** + * Getter for #date + * @return {string} + */ + + }, { + key: "date", + get: function get() { + return _classPrivateFieldGet(this, _date); + } + /** + * Setter for #date + * @param {string} date + */ + , + set: function set(date) { + if (checkAICCValidFormat(date, aicc_regex.CMIString256)) { + _classPrivateFieldSet(this, _date, date); + } + } + /** + * Getter for #time + * @return {string} + */ + + }, { + key: "time", + get: function get() { + return _classPrivateFieldGet(this, _time); + } + /** + * Setter for #time + * @param {string} time + */ + , + set: function set(time) { + if (checkAICCValidFormat(time, aicc_regex.CMITime)) { + _classPrivateFieldSet(this, _time, time); + } + } + /** + * Getter for #status + * @return {string} + */ + + }, { + key: "status", + get: function get() { + return _classPrivateFieldGet(this, _status); + } + /** + * Setter for #status + * @param {string} status + */ + , + set: function set(status) { + if (checkAICCValidFormat(status, aicc_regex.CMIStatus2)) { + _classPrivateFieldSet(this, _status, status); + } + } + /** + * Getter for #why_left + * @return {string} + */ + + }, { + key: "why_left", + get: function get() { + return _classPrivateFieldGet(this, _why_left); + } + /** + * Setter for #why_left + * @param {string} why_left + */ + , + set: function set(why_left) { + if (checkAICCValidFormat(why_left, aicc_regex.CMIString256)) { + _classPrivateFieldSet(this, _why_left, why_left); + } + } + /** + * Getter for #time_in_element + * @return {string} + */ + + }, { + key: "time_in_element", + get: function get() { + return _classPrivateFieldGet(this, _time_in_element); + } + /** + * Setter for #time_in_element + * @param {string} time_in_element + */ + , + set: function set(time_in_element) { + if (checkAICCValidFormat(time_in_element, aicc_regex.CMITime)) { + _classPrivateFieldSet(this, _time_in_element, time_in_element); + } + } + /** + * toJSON for cmi.paths.n object + * @return { + * { + * location_id: string, + * date: string, + * time: string, + * status: string, + * why_left: string, + * time_in_element: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'location_id': this.location_id, + 'date': this.date, + 'time': this.time, + 'status': this.status, + 'why_left': this.why_left, + 'time_in_element': this.time_in_element + }; + delete this.jsonString; + return result; + } + }]); + + return CMIPathsObject; +}(_common.BaseCMI); +/** + * Class representing the AICC cmi.student_data.tries object + */ + + +exports.CMIPathsObject = CMIPathsObject; + +var CMITries = /*#__PURE__*/function (_CMIArray3) { + _inherits(CMITries, _CMIArray3); + + var _super9 = _createSuper(CMITries); + + /** + * Constructor for inline Tries Array class + */ + function CMITries() { + _classCallCheck(this, CMITries); + + return _super9.call(this, { + children: aicc_constants.tries_children + }); + } + + return CMITries; +}(_common.CMIArray); +/** + * Class for AICC Tries + */ + + +exports.CMITries = CMITries; + +var _status2 = new WeakMap(); + +var _time2 = new WeakMap(); + +var CMITriesObject = /*#__PURE__*/function (_BaseCMI4) { + _inherits(CMITriesObject, _BaseCMI4); + + var _super10 = _createSuper(CMITriesObject); + + /** + * Constructor for AICC Tries object + */ + function CMITriesObject() { + var _this7; + + _classCallCheck(this, CMITriesObject); + + _this7 = _super10.call(this); + + _status2.set(_assertThisInitialized(_this7), { + writable: true, + value: '' + }); + + _time2.set(_assertThisInitialized(_this7), { + writable: true, + value: '' + }); + + _this7.score = new _common.CMIScore({ + score_children: aicc_constants.score_children, + score_range: aicc_regex.score_range, + invalidErrorCode: aicc_error_codes.INVALID_SET_VALUE, + invalidTypeCode: aicc_error_codes.TYPE_MISMATCH, + invalidRangeCode: aicc_error_codes.VALUE_OUT_OF_RANGE, + errorClass: _exceptions.AICCValidationError + }); + return _this7; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(CMITriesObject, [{ + key: "initialize", + value: function initialize() { + var _this$score; + + _get(_getPrototypeOf(CMITriesObject.prototype), "initialize", this).call(this); + + (_this$score = this.score) === null || _this$score === void 0 ? void 0 : _this$score.initialize(); + } + }, { + key: "status", + get: + /** + * Getter for #status + * @return {string} + */ + function get() { + return _classPrivateFieldGet(this, _status2); + } + /** + * Setter for #status + * @param {string} status + */ + , + set: function set(status) { + if (checkAICCValidFormat(status, aicc_regex.CMIStatus2)) { + _classPrivateFieldSet(this, _status2, status); + } + } + /** + * Getter for #time + * @return {string} + */ + + }, { + key: "time", + get: function get() { + return _classPrivateFieldGet(this, _time2); + } + /** + * Setter for #time + * @param {string} time + */ + , + set: function set(time) { + if (checkAICCValidFormat(time, aicc_regex.CMITime)) { + _classPrivateFieldSet(this, _time2, time); + } + } + /** + * toJSON for cmi.student_data.tries.n object + * @return { + * { + * status: string, + * time: string, + * score: CMIScore + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'status': this.status, + 'time': this.time, + 'score': this.score + }; + delete this.jsonString; + return result; + } + }]); + + return CMITriesObject; +}(_common.BaseCMI); +/** + * Class for cmi.student_data.attempt_records array + */ + + +exports.CMITriesObject = CMITriesObject; + +var CMIAttemptRecords = /*#__PURE__*/function (_CMIArray4) { + _inherits(CMIAttemptRecords, _CMIArray4); + + var _super11 = _createSuper(CMIAttemptRecords); + + /** + * Constructor for inline Tries Array class + */ + function CMIAttemptRecords() { + _classCallCheck(this, CMIAttemptRecords); + + return _super11.call(this, { + children: aicc_constants.attempt_records_children + }); + } + + return CMIAttemptRecords; +}(_common.CMIArray); +/** + * Class for AICC Attempt Records + */ + + +exports.CMIAttemptRecords = CMIAttemptRecords; + +var _lesson_status = new WeakMap(); + +var CMIAttemptRecordsObject = /*#__PURE__*/function (_BaseCMI5) { + _inherits(CMIAttemptRecordsObject, _BaseCMI5); + + var _super12 = _createSuper(CMIAttemptRecordsObject); + + /** + * Constructor for AICC Attempt Records object + */ + function CMIAttemptRecordsObject() { + var _this8; + + _classCallCheck(this, CMIAttemptRecordsObject); + + _this8 = _super12.call(this); + + _lesson_status.set(_assertThisInitialized(_this8), { + writable: true, + value: '' + }); + + _this8.score = new _common.CMIScore({ + score_children: aicc_constants.score_children, + score_range: aicc_regex.score_range, + invalidErrorCode: aicc_error_codes.INVALID_SET_VALUE, + invalidTypeCode: aicc_error_codes.TYPE_MISMATCH, + invalidRangeCode: aicc_error_codes.VALUE_OUT_OF_RANGE, + errorClass: _exceptions.AICCValidationError + }); + return _this8; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(CMIAttemptRecordsObject, [{ + key: "initialize", + value: function initialize() { + var _this$score2; + + _get(_getPrototypeOf(CMIAttemptRecordsObject.prototype), "initialize", this).call(this); + + (_this$score2 = this.score) === null || _this$score2 === void 0 ? void 0 : _this$score2.initialize(); + } + }, { + key: "lesson_status", + get: + /** + * Getter for #lesson_status + * @return {string} + */ + function get() { + return _classPrivateFieldGet(this, _lesson_status); + } + /** + * Setter for #lesson_status + * @param {string} lesson_status + */ + , + set: function set(lesson_status) { + if (checkAICCValidFormat(lesson_status, aicc_regex.CMIStatus2)) { + _classPrivateFieldSet(this, _lesson_status, lesson_status); + } + } + /** + * toJSON for cmi.student_data.attempt_records.n object + * @return { + * { + * status: string, + * time: string, + * score: CMIScore + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'lesson_status': this.lesson_status, + 'score': this.score + }; + delete this.jsonString; + return result; + } + }]); + + return CMIAttemptRecordsObject; +}(_common.BaseCMI); +/** + * Class for AICC Evaluation Comments + */ + + +exports.CMIAttemptRecordsObject = CMIAttemptRecordsObject; + +var _content = new WeakMap(); + +var _location = new WeakMap(); + +var _time3 = new WeakMap(); + +var CMIEvaluationCommentsObject = /*#__PURE__*/function (_BaseCMI6) { + _inherits(CMIEvaluationCommentsObject, _BaseCMI6); + + var _super13 = _createSuper(CMIEvaluationCommentsObject); + + /** + * Constructor for Evaluation Comments + */ + function CMIEvaluationCommentsObject() { + var _this9; + + _classCallCheck(this, CMIEvaluationCommentsObject); + + _this9 = _super13.call(this); + + _content.set(_assertThisInitialized(_this9), { + writable: true, + value: '' + }); + + _location.set(_assertThisInitialized(_this9), { + writable: true, + value: '' + }); + + _time3.set(_assertThisInitialized(_this9), { + writable: true, + value: '' + }); + + return _this9; + } + + _createClass(CMIEvaluationCommentsObject, [{ + key: "content", + get: + /** + * Getter for #content + * @return {string} + */ + function get() { + return _classPrivateFieldGet(this, _content); + } + /** + * Setter for #content + * @param {string} content + */ + , + set: function set(content) { + if (checkAICCValidFormat(content, aicc_regex.CMIString256)) { + _classPrivateFieldSet(this, _content, content); + } + } + /** + * Getter for #location + * @return {string} + */ + + }, { + key: "location", + get: function get() { + return _classPrivateFieldGet(this, _location); + } + /** + * Setter for #location + * @param {string} location + */ + , + set: function set(location) { + if (checkAICCValidFormat(location, aicc_regex.CMIString256)) { + _classPrivateFieldSet(this, _location, location); + } + } + /** + * Getter for #time + * @return {string} + */ + + }, { + key: "time", + get: function get() { + return _classPrivateFieldGet(this, _time3); + } + /** + * Setting for #time + * @param {string} time + */ + , + set: function set(time) { + if (checkAICCValidFormat(time, aicc_regex.CMITime)) { + _classPrivateFieldSet(this, _time3, time); + } + } + /** + * toJSON for cmi.evaulation.comments.n object + * @return { + * { + * content: string, + * location: string, + * time: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'content': this.content, + 'location': this.location, + 'time': this.time + }; + delete this.jsonString; + return result; + } + }]); + + return CMIEvaluationCommentsObject; +}(_common.BaseCMI); + +exports.CMIEvaluationCommentsObject = CMIEvaluationCommentsObject; + +},{"../constants/api_constants":8,"../constants/error_codes":9,"../constants/regex":10,"../exceptions":11,"./common":6,"./scorm12_cmi":7}],6:[function(require,module,exports){ +"use strict"; + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.checkValidFormat = checkValidFormat; +exports.checkValidRange = checkValidRange; +exports.CMIArray = exports.CMIScore = exports.BaseCMI = void 0; + +var _api_constants = _interopRequireDefault(require("../constants/api_constants")); + +var _error_codes = _interopRequireDefault(require("../constants/error_codes")); + +var _regex = _interopRequireDefault(require("../constants/regex")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; } + +function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } } + +function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); } + +function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); } + +function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +var scorm12_constants = _api_constants["default"].scorm12; +var scorm12_regex = _regex["default"].scorm12; +var scorm12_error_codes = _error_codes["default"].scorm12; +/** + * Check if the value matches the proper format. If not, throw proper error code. + * + * @param {string} value + * @param {string} regexPattern + * @param {number} errorCode + * @param {class} errorClass + * @param {boolean} allowEmptyString + * @return {boolean} + */ + +function checkValidFormat(value, regexPattern, errorCode, errorClass, allowEmptyString) { + var formatRegex = new RegExp(regexPattern); + var matches = value.match(formatRegex); + + if (allowEmptyString && value === '') { + return true; + } + + if (value === undefined || !matches || matches[0] === '') { + throw new errorClass.prototype.constructor(errorCode); + } + + return true; +} +/** + * Check if the value matches the proper range. If not, throw proper error code. + * + * @param {*} value + * @param {string} rangePattern + * @param {number} errorCode + * @param {class} errorClass + * @return {boolean} + */ + + +function checkValidRange(value, rangePattern, errorCode, errorClass) { + var ranges = rangePattern.split('#'); + value = value * 1.0; + + if (value >= ranges[0]) { + if (ranges[1] === '*' || value <= ranges[1]) { + return true; + } else { + throw new errorClass.prototype.constructor(errorCode); + } + } else { + throw new errorClass.prototype.constructor(errorCode); + } +} +/** + * Base class for API cmi objects + */ + + +var _initialized = new WeakMap(); + +var _start_time = new WeakMap(); + +var BaseCMI = /*#__PURE__*/function () { + /** + * Constructor for BaseCMI, just marks the class as abstract + */ + function BaseCMI() { + _classCallCheck(this, BaseCMI); + + _defineProperty(this, "jsonString", false); + + _initialized.set(this, { + writable: true, + value: false + }); + + _start_time.set(this, { + writable: true, + value: void 0 + }); + + if ((this instanceof BaseCMI ? this.constructor : void 0) === BaseCMI) { + throw new TypeError('Cannot construct BaseCMI instances directly'); + } + } + /** + * Getter for #initialized + * @return {boolean} + */ + + + _createClass(BaseCMI, [{ + key: "initialized", + get: function get() { + return _classPrivateFieldGet(this, _initialized); + } + /** + * Getter for #start_time + * @return {Number} + */ + + }, { + key: "start_time", + get: function get() { + return _classPrivateFieldGet(this, _start_time); + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + }, { + key: "initialize", + value: function initialize() { + _classPrivateFieldSet(this, _initialized, true); + } + /** + * Called when the player should override the 'session_time' provided by + * the module + */ + + }, { + key: "setStartTime", + value: function setStartTime() { + _classPrivateFieldSet(this, _start_time, new Date().getTime()); + } + }]); + + return BaseCMI; +}(); +/** + * Base class for cmi *.score objects + */ + + +exports.BaseCMI = BaseCMI; + +var _children2 = new WeakMap(); + +var _score_range = new WeakMap(); + +var _invalid_error_code = new WeakMap(); + +var _invalid_type_code = new WeakMap(); + +var _invalid_range_code = new WeakMap(); + +var _decimal_regex = new WeakMap(); + +var _error_class = new WeakMap(); + +var _raw = new WeakMap(); + +var _min = new WeakMap(); + +var _max = new WeakMap(); + +var CMIScore = /*#__PURE__*/function (_BaseCMI) { + _inherits(CMIScore, _BaseCMI); + + var _super = _createSuper(CMIScore); + + /** + * Constructor for *.score + * @param {string} score_children + * @param {string} score_range + * @param {string} max + * @param {number} invalidErrorCode + * @param {number} invalidTypeCode + * @param {number} invalidRangeCode + * @param {string} decimalRegex + * @param {class} errorClass + */ + function CMIScore(_ref) { + var _this; + + var score_children = _ref.score_children, + score_range = _ref.score_range, + max = _ref.max, + invalidErrorCode = _ref.invalidErrorCode, + invalidTypeCode = _ref.invalidTypeCode, + invalidRangeCode = _ref.invalidRangeCode, + decimalRegex = _ref.decimalRegex, + errorClass = _ref.errorClass; + + _classCallCheck(this, CMIScore); + + _this = _super.call(this); + + _children2.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _score_range.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _invalid_error_code.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _invalid_type_code.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _invalid_range_code.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _decimal_regex.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _error_class.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _raw.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _min.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _max.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _classPrivateFieldSet(_assertThisInitialized(_this), _children2, score_children || scorm12_constants.score_children); + + _classPrivateFieldSet(_assertThisInitialized(_this), _score_range, !score_range ? false : scorm12_regex.score_range); + + _classPrivateFieldSet(_assertThisInitialized(_this), _max, max || max === '' ? max : '100'); + + _classPrivateFieldSet(_assertThisInitialized(_this), _invalid_error_code, invalidErrorCode || scorm12_error_codes.INVALID_SET_VALUE); + + _classPrivateFieldSet(_assertThisInitialized(_this), _invalid_type_code, invalidTypeCode || scorm12_error_codes.TYPE_MISMATCH); + + _classPrivateFieldSet(_assertThisInitialized(_this), _invalid_range_code, invalidRangeCode || scorm12_error_codes.VALUE_OUT_OF_RANGE); + + _classPrivateFieldSet(_assertThisInitialized(_this), _decimal_regex, decimalRegex || scorm12_regex.CMIDecimal); + + _classPrivateFieldSet(_assertThisInitialized(_this), _error_class, errorClass); + + return _this; + } + + _createClass(CMIScore, [{ + key: "_children", + get: + /** + * Getter for _children + * @return {string} + * @private + */ + function get() { + return _classPrivateFieldGet(this, _children2); + } + /** + * Setter for _children. Just throws an error. + * @param {string} _children + * @private + */ + , + set: function set(_children) { + throw new (_classPrivateFieldGet(this, _error_class).prototype.constructor)(_classPrivateFieldGet(this, _invalid_error_code)); + } + /** + * Getter for #raw + * @return {string} + */ + + }, { + key: "raw", + get: function get() { + return _classPrivateFieldGet(this, _raw); + } + /** + * Setter for #raw + * @param {string} raw + */ + , + set: function set(raw) { + if (checkValidFormat(raw, _classPrivateFieldGet(this, _decimal_regex), _classPrivateFieldGet(this, _invalid_type_code), _classPrivateFieldGet(this, _error_class)) && (!_classPrivateFieldGet(this, _score_range) || checkValidRange(raw, _classPrivateFieldGet(this, _score_range), _classPrivateFieldGet(this, _invalid_range_code), _classPrivateFieldGet(this, _error_class)))) { + _classPrivateFieldSet(this, _raw, raw); + } + } + /** + * Getter for #min + * @return {string} + */ + + }, { + key: "min", + get: function get() { + return _classPrivateFieldGet(this, _min); + } + /** + * Setter for #min + * @param {string} min + */ + , + set: function set(min) { + if (checkValidFormat(min, _classPrivateFieldGet(this, _decimal_regex), _classPrivateFieldGet(this, _invalid_type_code), _classPrivateFieldGet(this, _error_class)) && (!_classPrivateFieldGet(this, _score_range) || checkValidRange(min, _classPrivateFieldGet(this, _score_range), _classPrivateFieldGet(this, _invalid_range_code), _classPrivateFieldGet(this, _error_class)))) { + _classPrivateFieldSet(this, _min, min); + } + } + /** + * Getter for #max + * @return {string} + */ + + }, { + key: "max", + get: function get() { + return _classPrivateFieldGet(this, _max); + } + /** + * Setter for #max + * @param {string} max + */ + , + set: function set(max) { + if (checkValidFormat(max, _classPrivateFieldGet(this, _decimal_regex), _classPrivateFieldGet(this, _invalid_type_code), _classPrivateFieldGet(this, _error_class)) && (!_classPrivateFieldGet(this, _score_range) || checkValidRange(max, _classPrivateFieldGet(this, _score_range), _classPrivateFieldGet(this, _invalid_range_code), _classPrivateFieldGet(this, _error_class)))) { + _classPrivateFieldSet(this, _max, max); + } + } + /** + * toJSON for *.score + * @return {{min: string, max: string, raw: string}} + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'raw': this.raw, + 'min': this.min, + 'max': this.max + }; + delete this.jsonString; + return result; + } + }]); + + return CMIScore; +}(BaseCMI); +/** + * Base class for cmi *.n objects + */ + + +exports.CMIScore = CMIScore; + +var _errorCode = new WeakMap(); + +var _errorClass = new WeakMap(); + +var _children3 = new WeakMap(); + +var CMIArray = /*#__PURE__*/function (_BaseCMI2) { + _inherits(CMIArray, _BaseCMI2); + + var _super2 = _createSuper(CMIArray); + + /** + * Constructor cmi *.n arrays + * @param {string} children + * @param {number} errorCode + * @param {class} errorClass + */ + function CMIArray(_ref2) { + var _this2; + + var children = _ref2.children, + errorCode = _ref2.errorCode, + errorClass = _ref2.errorClass; + + _classCallCheck(this, CMIArray); + + _this2 = _super2.call(this); + + _errorCode.set(_assertThisInitialized(_this2), { + writable: true, + value: void 0 + }); + + _errorClass.set(_assertThisInitialized(_this2), { + writable: true, + value: void 0 + }); + + _children3.set(_assertThisInitialized(_this2), { + writable: true, + value: void 0 + }); + + _classPrivateFieldSet(_assertThisInitialized(_this2), _children3, children); + + _classPrivateFieldSet(_assertThisInitialized(_this2), _errorCode, errorCode); + + _classPrivateFieldSet(_assertThisInitialized(_this2), _errorClass, errorClass); + + _this2.childArray = []; + return _this2; + } + + _createClass(CMIArray, [{ + key: "_children", + get: + /** + * Getter for _children + * @return {*} + */ + function get() { + return _classPrivateFieldGet(this, _children3); + } + /** + * Setter for _children. Just throws an error. + * @param {string} _children + */ + , + set: function set(_children) { + throw new (_classPrivateFieldGet(this, _errorClass).prototype.constructor)(_classPrivateFieldGet(this, _errorCode)); + } + /** + * Getter for _count + * @return {number} + */ + + }, { + key: "_count", + get: function get() { + return this.childArray.length; + } + /** + * Setter for _count. Just throws an error. + * @param {number} _count + */ + , + set: function set(_count) { + throw new (_classPrivateFieldGet(this, _errorClass).prototype.constructor)(_classPrivateFieldGet(this, _errorCode)); + } + /** + * toJSON for *.n arrays + * @return {object} + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = {}; + + for (var i = 0; i < this.childArray.length; i++) { + result[i + ''] = this.childArray[i]; + } + + delete this.jsonString; + return result; + } + }]); + + return CMIArray; +}(BaseCMI); + +exports.CMIArray = CMIArray; + +},{"../constants/api_constants":8,"../constants/error_codes":9,"../constants/regex":10}],7:[function(require,module,exports){ +"use strict"; + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.throwReadOnlyError = throwReadOnlyError; +exports.throwWriteOnlyError = throwWriteOnlyError; +exports.check12ValidFormat = check12ValidFormat; +exports.check12ValidRange = check12ValidRange; +exports.NAV = exports.CMIInteractionsCorrectResponsesObject = exports.CMIInteractionsObjectivesObject = exports.CMIObjectivesObject = exports.CMIInteractionsObject = exports.CMIStudentPreference = exports.CMIStudentData = exports.CMI = void 0; + +var _common = require("./common"); + +var _api_constants = _interopRequireDefault(require("../constants/api_constants")); + +var _error_codes = _interopRequireDefault(require("../constants/error_codes")); + +var _regex = _interopRequireDefault(require("../constants/regex")); + +var _exceptions = require("../exceptions"); + +var Utilities = _interopRequireWildcard(require("../utilities")); + +var Util = Utilities; + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); } + +function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); } + +function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; } + +function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); } + +function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } } + +var scorm12_constants = _api_constants["default"].scorm12; +var scorm12_regex = _regex["default"].scorm12; +var scorm12_error_codes = _error_codes["default"].scorm12; +/** + * Helper method for throwing Read Only error + */ + +function throwReadOnlyError() { + throw new _exceptions.Scorm12ValidationError(scorm12_error_codes.READ_ONLY_ELEMENT); +} +/** + * Helper method for throwing Write Only error + */ + + +function throwWriteOnlyError() { + throw new _exceptions.Scorm12ValidationError(scorm12_error_codes.WRITE_ONLY_ELEMENT); +} +/** + * Helper method for throwing Invalid Set error + */ + + +function throwInvalidValueError() { + throw new _exceptions.Scorm12ValidationError(scorm12_error_codes.INVALID_SET_VALUE); +} +/** + * Helper method, no reason to have to pass the same error codes every time + * @param {*} value + * @param {string} regexPattern + * @param {boolean} allowEmptyString + * @return {boolean} + */ + + +function check12ValidFormat(value, regexPattern, allowEmptyString) { + return (0, _common.checkValidFormat)(value, regexPattern, scorm12_error_codes.TYPE_MISMATCH, _exceptions.Scorm12ValidationError, allowEmptyString); +} +/** + * Helper method, no reason to have to pass the same error codes every time + * @param {*} value + * @param {string} rangePattern + * @param {boolean} allowEmptyString + * @return {boolean} + */ + + +function check12ValidRange(value, rangePattern, allowEmptyString) { + return (0, _common.checkValidRange)(value, rangePattern, scorm12_error_codes.VALUE_OUT_OF_RANGE, _exceptions.Scorm12ValidationError, allowEmptyString); +} +/** + * Class representing the cmi object for SCORM 1.2 + */ + + +var _children2 = new WeakMap(); + +var _version2 = new WeakMap(); + +var _launch_data = new WeakMap(); + +var _comments = new WeakMap(); + +var _comments_from_lms = new WeakMap(); + +var CMI = /*#__PURE__*/function (_BaseCMI) { + _inherits(CMI, _BaseCMI); + + var _super = _createSuper(CMI); + + /** + * Constructor for the SCORM 1.2 cmi object + * @param {string} cmi_children + * @param {(CMIStudentData|AICCCMIStudentData)} student_data + * @param {boolean} initialized + */ + function CMI(cmi_children, student_data, initialized) { + var _this; + + _classCallCheck(this, CMI); + + _this = _super.call(this); + + _children2.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _version2.set(_assertThisInitialized(_this), { + writable: true, + value: '3.4' + }); + + _launch_data.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _comments.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _comments_from_lms.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _defineProperty(_assertThisInitialized(_this), "student_data", null); + + if (initialized) _this.initialize(); + + _classPrivateFieldSet(_assertThisInitialized(_this), _children2, cmi_children ? cmi_children : scorm12_constants.cmi_children); + + _this.core = new CMICore(); + _this.objectives = new CMIObjectives(); + _this.student_data = student_data ? student_data : new CMIStudentData(); + _this.student_preference = new CMIStudentPreference(); + _this.interactions = new CMIInteractions(); + return _this; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(CMI, [{ + key: "initialize", + value: function initialize() { + var _this$core, _this$objectives, _this$student_data, _this$student_prefere, _this$interactions; + + _get(_getPrototypeOf(CMI.prototype), "initialize", this).call(this); + + (_this$core = this.core) === null || _this$core === void 0 ? void 0 : _this$core.initialize(); + (_this$objectives = this.objectives) === null || _this$objectives === void 0 ? void 0 : _this$objectives.initialize(); + (_this$student_data = this.student_data) === null || _this$student_data === void 0 ? void 0 : _this$student_data.initialize(); + (_this$student_prefere = this.student_preference) === null || _this$student_prefere === void 0 ? void 0 : _this$student_prefere.initialize(); + (_this$interactions = this.interactions) === null || _this$interactions === void 0 ? void 0 : _this$interactions.initialize(); + } + /** + * toJSON for cmi + * + * @return { + * { + * suspend_data: string, + * launch_data: string, + * comments: string, + * comments_from_lms: string, + * core: CMICore, + * objectives: CMIObjectives, + * student_data: CMIStudentData, + * student_preference: CMIStudentPreference, + * interactions: CMIInteractions + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'suspend_data': this.suspend_data, + 'launch_data': this.launch_data, + 'comments': this.comments, + 'comments_from_lms': this.comments_from_lms, + 'core': this.core, + 'objectives': this.objectives, + 'student_data': this.student_data, + 'student_preference': this.student_preference, + 'interactions': this.interactions + }; + delete this.jsonString; + return result; + } + /** + * Getter for #_version + * @return {string} + */ + + }, { + key: "_version", + get: function get() { + return _classPrivateFieldGet(this, _version2); + } + /** + * Setter for #_version. Just throws an error. + * @param {string} _version + */ + , + set: function set(_version) { + throwInvalidValueError(); + } + /** + * Getter for #_children + * @return {string} + */ + + }, { + key: "_children", + get: function get() { + return _classPrivateFieldGet(this, _children2); + } + /** + * Setter for #_version. Just throws an error. + * @param {string} _children + */ + , + set: function set(_children) { + throwInvalidValueError(); + } + /** + * Getter for #suspend_data + * @return {string} + */ + + }, { + key: "suspend_data", + get: function get() { + var _this$core2; + + return (_this$core2 = this.core) === null || _this$core2 === void 0 ? void 0 : _this$core2.suspend_data; + } + /** + * Setter for #suspend_data + * @param {string} suspend_data + */ + , + set: function set(suspend_data) { + if (this.core) { + this.core.suspend_data = suspend_data; + } + } + /** + * Getter for #launch_data + * @return {string} + */ + + }, { + key: "launch_data", + get: function get() { + return _classPrivateFieldGet(this, _launch_data); + } + /** + * Setter for #launch_data. Can only be called before initialization. + * @param {string} launch_data + */ + , + set: function set(launch_data) { + !this.initialized ? _classPrivateFieldSet(this, _launch_data, launch_data) : throwReadOnlyError(); + } + /** + * Getter for #comments + * @return {string} + */ + + }, { + key: "comments", + get: function get() { + return _classPrivateFieldGet(this, _comments); + } + /** + * Setter for #comments + * @param {string} comments + */ + , + set: function set(comments) { + if (check12ValidFormat(comments, scorm12_regex.CMIString4096, true)) { + _classPrivateFieldSet(this, _comments, comments); + } + } + /** + * Getter for #comments_from_lms + * @return {string} + */ + + }, { + key: "comments_from_lms", + get: function get() { + return _classPrivateFieldGet(this, _comments_from_lms); + } + /** + * Setter for #comments_from_lms. Can only be called before initialization. + * @param {string} comments_from_lms + */ + , + set: function set(comments_from_lms) { + !this.initialized ? _classPrivateFieldSet(this, _comments_from_lms, comments_from_lms) : throwReadOnlyError(); + } + /** + * Adds the current session time to the existing total time. + * + * @return {string} + */ + + }, { + key: "getCurrentTotalTime", + value: function getCurrentTotalTime() { + return this.core.getCurrentTotalTime(this.start_time); + } + }]); + + return CMI; +}(_common.BaseCMI); +/** + * Class representing the cmi.core object + * @extends BaseCMI + */ + + +exports.CMI = CMI; + +var _children3 = new WeakMap(); + +var _student_id = new WeakMap(); + +var _student_name = new WeakMap(); + +var _lesson_location = new WeakMap(); + +var _credit = new WeakMap(); + +var _lesson_status = new WeakMap(); + +var _entry = new WeakMap(); + +var _total_time = new WeakMap(); + +var _lesson_mode = new WeakMap(); + +var _exit = new WeakMap(); + +var _session_time = new WeakMap(); + +var _suspend_data = new WeakMap(); + +var CMICore = /*#__PURE__*/function (_BaseCMI2) { + _inherits(CMICore, _BaseCMI2); + + var _super2 = _createSuper(CMICore); + + /** + * Constructor for cmi.core + */ + function CMICore() { + var _this2; + + _classCallCheck(this, CMICore); + + _this2 = _super2.call(this); + + _children3.set(_assertThisInitialized(_this2), { + writable: true, + value: scorm12_constants.core_children + }); + + _student_id.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _student_name.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _lesson_location.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _credit.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _lesson_status.set(_assertThisInitialized(_this2), { + writable: true, + value: 'not attempted' + }); + + _entry.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _total_time.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _lesson_mode.set(_assertThisInitialized(_this2), { + writable: true, + value: 'normal' + }); + + _exit.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _session_time.set(_assertThisInitialized(_this2), { + writable: true, + value: '00:00:00' + }); + + _suspend_data.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _this2.score = new _common.CMIScore({ + score_children: scorm12_constants.score_children, + score_range: scorm12_regex.score_range, + invalidErrorCode: scorm12_error_codes.INVALID_SET_VALUE, + invalidTypeCode: scorm12_error_codes.TYPE_MISMATCH, + invalidRangeCode: scorm12_error_codes.VALUE_OUT_OF_RANGE, + errorClass: _exceptions.Scorm12ValidationError + }); + return _this2; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(CMICore, [{ + key: "initialize", + value: function initialize() { + var _this$score; + + _get(_getPrototypeOf(CMICore.prototype), "initialize", this).call(this); + + (_this$score = this.score) === null || _this$score === void 0 ? void 0 : _this$score.initialize(); + } + }, { + key: "_children", + get: + /** + * Getter for #_children + * @return {string} + * @private + */ + function get() { + return _classPrivateFieldGet(this, _children3); + } + /** + * Setter for #_children. Just throws an error. + * @param {string} _children + * @private + */ + , + set: function set(_children) { + throwInvalidValueError(); + } + /** + * Getter for #student_id + * @return {string} + */ + + }, { + key: "student_id", + get: function get() { + return _classPrivateFieldGet(this, _student_id); + } + /** + * Setter for #student_id. Can only be called before initialization. + * @param {string} student_id + */ + , + set: function set(student_id) { + !this.initialized ? _classPrivateFieldSet(this, _student_id, student_id) : throwReadOnlyError(); + } + /** + * Getter for #student_name + * @return {string} + */ + + }, { + key: "student_name", + get: function get() { + return _classPrivateFieldGet(this, _student_name); + } + /** + * Setter for #student_name. Can only be called before initialization. + * @param {string} student_name + */ + , + set: function set(student_name) { + !this.initialized ? _classPrivateFieldSet(this, _student_name, student_name) : throwReadOnlyError(); + } + /** + * Getter for #lesson_location + * @return {string} + */ + + }, { + key: "lesson_location", + get: function get() { + return _classPrivateFieldGet(this, _lesson_location); + } + /** + * Setter for #lesson_location + * @param {string} lesson_location + */ + , + set: function set(lesson_location) { + if (check12ValidFormat(lesson_location, scorm12_regex.CMIString256, true)) { + _classPrivateFieldSet(this, _lesson_location, lesson_location); + } + } + /** + * Getter for #credit + * @return {string} + */ + + }, { + key: "credit", + get: function get() { + return _classPrivateFieldGet(this, _credit); + } + /** + * Setter for #credit. Can only be called before initialization. + * @param {string} credit + */ + , + set: function set(credit) { + !this.initialized ? _classPrivateFieldSet(this, _credit, credit) : throwReadOnlyError(); + } + /** + * Getter for #lesson_status + * @return {string} + */ + + }, { + key: "lesson_status", + get: function get() { + return _classPrivateFieldGet(this, _lesson_status); + } + /** + * Setter for #lesson_status + * @param {string} lesson_status + */ + , + set: function set(lesson_status) { + if (this.initialized) { + if (check12ValidFormat(lesson_status, scorm12_regex.CMIStatus)) { + _classPrivateFieldSet(this, _lesson_status, lesson_status); + } + } else { + if (check12ValidFormat(lesson_status, scorm12_regex.CMIStatus2)) { + _classPrivateFieldSet(this, _lesson_status, lesson_status); + } + } + } + /** + * Getter for #entry + * @return {string} + */ + + }, { + key: "entry", + get: function get() { + return _classPrivateFieldGet(this, _entry); + } + /** + * Setter for #entry. Can only be called before initialization. + * @param {string} entry + */ + , + set: function set(entry) { + !this.initialized ? _classPrivateFieldSet(this, _entry, entry) : throwReadOnlyError(); + } + /** + * Getter for #total_time + * @return {string} + */ + + }, { + key: "total_time", + get: function get() { + return _classPrivateFieldGet(this, _total_time); + } + /** + * Setter for #total_time. Can only be called before initialization. + * @param {string} total_time + */ + , + set: function set(total_time) { + !this.initialized ? _classPrivateFieldSet(this, _total_time, total_time) : throwReadOnlyError(); + } + /** + * Getter for #lesson_mode + * @return {string} + */ + + }, { + key: "lesson_mode", + get: function get() { + return _classPrivateFieldGet(this, _lesson_mode); + } + /** + * Setter for #lesson_mode. Can only be called before initialization. + * @param {string} lesson_mode + */ + , + set: function set(lesson_mode) { + !this.initialized ? _classPrivateFieldSet(this, _lesson_mode, lesson_mode) : throwReadOnlyError(); + } + /** + * Getter for #exit. Should only be called during JSON export. + * @return {*} + */ + + }, { + key: "exit", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _exit); + } + /** + * Setter for #exit + * @param {string} exit + */ + , + set: function set(exit) { + if (check12ValidFormat(exit, scorm12_regex.CMIExit, true)) { + _classPrivateFieldSet(this, _exit, exit); + } + } + /** + * Getter for #session_time. Should only be called during JSON export. + * @return {*} + */ + + }, { + key: "session_time", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _session_time); + } + /** + * Setter for #session_time + * @param {string} session_time + */ + , + set: function set(session_time) { + if (check12ValidFormat(session_time, scorm12_regex.CMITimespan)) { + _classPrivateFieldSet(this, _session_time, session_time); + } + } + /** + * Getter for #suspend_data + * @return {string} + */ + + }, { + key: "suspend_data", + get: function get() { + return _classPrivateFieldGet(this, _suspend_data); + } + /** + * Setter for #suspend_data + * @param {string} suspend_data + */ + , + set: function set(suspend_data) { + if (check12ValidFormat(suspend_data, scorm12_regex.CMIString4096, true)) { + _classPrivateFieldSet(this, _suspend_data, suspend_data); + } + } + /** + * Adds the current session time to the existing total time. + * @param {Number} start_time + * @return {string} + */ + + }, { + key: "getCurrentTotalTime", + value: function getCurrentTotalTime(start_time) { + var sessionTime = _classPrivateFieldGet(this, _session_time); + + var startTime = start_time; + + if (typeof startTime !== 'undefined' && startTime !== null) { + var seconds = new Date().getTime() - startTime; + sessionTime = Util.getSecondsAsHHMMSS(seconds / 1000); + } + + return Utilities.addHHMMSSTimeStrings(_classPrivateFieldGet(this, _total_time), sessionTime, new RegExp(scorm12_regex.CMITimespan)); + } + /** + * toJSON for cmi.core + * + * @return { + * { + * student_name: string, + * entry: string, + * exit: string, + * score: CMIScore, + * student_id: string, + * lesson_mode: string, + * lesson_location: string, + * lesson_status: string, + * credit: string, + * session_time: * + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'student_id': this.student_id, + 'student_name': this.student_name, + 'lesson_location': this.lesson_location, + 'credit': this.credit, + 'lesson_status': this.lesson_status, + 'entry': this.entry, + 'lesson_mode': this.lesson_mode, + 'exit': this.exit, + 'session_time': this.session_time, + 'score': this.score + }; + delete this.jsonString; + return result; + } + }]); + + return CMICore; +}(_common.BaseCMI); +/** + * Class representing SCORM 1.2's cmi.objectives object + * @extends CMIArray + */ + + +var CMIObjectives = /*#__PURE__*/function (_CMIArray) { + _inherits(CMIObjectives, _CMIArray); + + var _super3 = _createSuper(CMIObjectives); + + /** + * Constructor for cmi.objectives + */ + function CMIObjectives() { + _classCallCheck(this, CMIObjectives); + + return _super3.call(this, { + children: scorm12_constants.objectives_children, + errorCode: scorm12_error_codes.INVALID_SET_VALUE, + errorClass: _exceptions.Scorm12ValidationError + }); + } + + return CMIObjectives; +}(_common.CMIArray); +/** + * Class representing SCORM 1.2's cmi.student_data object + * @extends BaseCMI + */ + + +var _children4 = new WeakMap(); + +var _mastery_score = new WeakMap(); + +var _max_time_allowed = new WeakMap(); + +var _time_limit_action = new WeakMap(); + +var CMIStudentData = /*#__PURE__*/function (_BaseCMI3) { + _inherits(CMIStudentData, _BaseCMI3); + + var _super4 = _createSuper(CMIStudentData); + + /** + * Constructor for cmi.student_data + * @param {string} student_data_children + */ + function CMIStudentData(student_data_children) { + var _this3; + + _classCallCheck(this, CMIStudentData); + + _this3 = _super4.call(this); + + _children4.set(_assertThisInitialized(_this3), { + writable: true, + value: void 0 + }); + + _mastery_score.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _max_time_allowed.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _time_limit_action.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _classPrivateFieldSet(_assertThisInitialized(_this3), _children4, student_data_children ? student_data_children : scorm12_constants.student_data_children); + + return _this3; + } + /** + * Getter for #_children + * @return {*} + * @private + */ + + + _createClass(CMIStudentData, [{ + key: "_children", + get: function get() { + return _classPrivateFieldGet(this, _children4); + } + /** + * Setter for #_children. Just throws an error. + * @param {string} _children + * @private + */ + , + set: function set(_children) { + throwInvalidValueError(); + } + /** + * Getter for #master_score + * @return {string} + */ + + }, { + key: "mastery_score", + get: function get() { + return _classPrivateFieldGet(this, _mastery_score); + } + /** + * Setter for #master_score. Can only be called before initialization. + * @param {string} mastery_score + */ + , + set: function set(mastery_score) { + !this.initialized ? _classPrivateFieldSet(this, _mastery_score, mastery_score) : throwReadOnlyError(); + } + /** + * Getter for #max_time_allowed + * @return {string} + */ + + }, { + key: "max_time_allowed", + get: function get() { + return _classPrivateFieldGet(this, _max_time_allowed); + } + /** + * Setter for #max_time_allowed. Can only be called before initialization. + * @param {string} max_time_allowed + */ + , + set: function set(max_time_allowed) { + !this.initialized ? _classPrivateFieldSet(this, _max_time_allowed, max_time_allowed) : throwReadOnlyError(); + } + /** + * Getter for #time_limit_action + * @return {string} + */ + + }, { + key: "time_limit_action", + get: function get() { + return _classPrivateFieldGet(this, _time_limit_action); + } + /** + * Setter for #time_limit_action. Can only be called before initialization. + * @param {string} time_limit_action + */ + , + set: function set(time_limit_action) { + !this.initialized ? _classPrivateFieldSet(this, _time_limit_action, time_limit_action) : throwReadOnlyError(); + } + /** + * toJSON for cmi.student_data + * + * @return { + * { + * max_time_allowed: string, + * time_limit_action: string, + * mastery_score: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'mastery_score': this.mastery_score, + 'max_time_allowed': this.max_time_allowed, + 'time_limit_action': this.time_limit_action + }; + delete this.jsonString; + return result; + } + }]); + + return CMIStudentData; +}(_common.BaseCMI); +/** + * Class representing SCORM 1.2's cmi.student_preference object + * @extends BaseCMI + */ + + +exports.CMIStudentData = CMIStudentData; + +var _children5 = new WeakMap(); + +var _audio = new WeakMap(); + +var _language = new WeakMap(); + +var _speed = new WeakMap(); + +var _text = new WeakMap(); + +var CMIStudentPreference = /*#__PURE__*/function (_BaseCMI4) { + _inherits(CMIStudentPreference, _BaseCMI4); + + var _super5 = _createSuper(CMIStudentPreference); + + /** + * Constructor for cmi.student_preference + * @param {string} student_preference_children + */ + function CMIStudentPreference(student_preference_children) { + var _this4; + + _classCallCheck(this, CMIStudentPreference); + + _this4 = _super5.call(this); + + _children5.set(_assertThisInitialized(_this4), { + writable: true, + value: void 0 + }); + + _audio.set(_assertThisInitialized(_this4), { + writable: true, + value: '' + }); + + _language.set(_assertThisInitialized(_this4), { + writable: true, + value: '' + }); + + _speed.set(_assertThisInitialized(_this4), { + writable: true, + value: '' + }); + + _text.set(_assertThisInitialized(_this4), { + writable: true, + value: '' + }); + + _classPrivateFieldSet(_assertThisInitialized(_this4), _children5, student_preference_children ? student_preference_children : scorm12_constants.student_preference_children); + + return _this4; + } + + _createClass(CMIStudentPreference, [{ + key: "_children", + get: + /** + * Getter for #_children + * @return {string} + * @private + */ + function get() { + return _classPrivateFieldGet(this, _children5); + } + /** + * Setter for #_children. Just throws an error. + * @param {string} _children + * @private + */ + , + set: function set(_children) { + throwInvalidValueError(); + } + /** + * Getter for #audio + * @return {string} + */ + + }, { + key: "audio", + get: function get() { + return _classPrivateFieldGet(this, _audio); + } + /** + * Setter for #audio + * @param {string} audio + */ + , + set: function set(audio) { + if (check12ValidFormat(audio, scorm12_regex.CMISInteger) && check12ValidRange(audio, scorm12_regex.audio_range)) { + _classPrivateFieldSet(this, _audio, audio); + } + } + /** + * Getter for #language + * @return {string} + */ + + }, { + key: "language", + get: function get() { + return _classPrivateFieldGet(this, _language); + } + /** + * Setter for #language + * @param {string} language + */ + , + set: function set(language) { + if (check12ValidFormat(language, scorm12_regex.CMIString256)) { + _classPrivateFieldSet(this, _language, language); + } + } + /** + * Getter for #speed + * @return {string} + */ + + }, { + key: "speed", + get: function get() { + return _classPrivateFieldGet(this, _speed); + } + /** + * Setter for #speed + * @param {string} speed + */ + , + set: function set(speed) { + if (check12ValidFormat(speed, scorm12_regex.CMISInteger) && check12ValidRange(speed, scorm12_regex.speed_range)) { + _classPrivateFieldSet(this, _speed, speed); + } + } + /** + * Getter for #text + * @return {string} + */ + + }, { + key: "text", + get: function get() { + return _classPrivateFieldGet(this, _text); + } + /** + * Setter for #text + * @param {string} text + */ + , + set: function set(text) { + if (check12ValidFormat(text, scorm12_regex.CMISInteger) && check12ValidRange(text, scorm12_regex.text_range)) { + _classPrivateFieldSet(this, _text, text); + } + } + /** + * toJSON for cmi.student_preference + * + * @return { + * { + * audio: string, + * language: string, + * speed: string, + * text: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'audio': this.audio, + 'language': this.language, + 'speed': this.speed, + 'text': this.text + }; + delete this.jsonString; + return result; + } + }]); + + return CMIStudentPreference; +}(_common.BaseCMI); +/** + * Class representing SCORM 1.2's cmi.interactions object + * @extends BaseCMI + */ + + +exports.CMIStudentPreference = CMIStudentPreference; + +var CMIInteractions = /*#__PURE__*/function (_CMIArray2) { + _inherits(CMIInteractions, _CMIArray2); + + var _super6 = _createSuper(CMIInteractions); + + /** + * Constructor for cmi.interactions + */ + function CMIInteractions() { + _classCallCheck(this, CMIInteractions); + + return _super6.call(this, { + children: scorm12_constants.interactions_children, + errorCode: scorm12_error_codes.INVALID_SET_VALUE, + errorClass: _exceptions.Scorm12ValidationError + }); + } + + return CMIInteractions; +}(_common.CMIArray); +/** + * Class representing SCORM 1.2's cmi.interactions.n object + * @extends BaseCMI + */ + + +var _id = new WeakMap(); + +var _time = new WeakMap(); + +var _type = new WeakMap(); + +var _weighting = new WeakMap(); + +var _student_response = new WeakMap(); + +var _result = new WeakMap(); + +var _latency = new WeakMap(); + +var CMIInteractionsObject = /*#__PURE__*/function (_BaseCMI5) { + _inherits(CMIInteractionsObject, _BaseCMI5); + + var _super7 = _createSuper(CMIInteractionsObject); + + /** + * Constructor for cmi.interactions.n object + */ + function CMIInteractionsObject() { + var _this5; + + _classCallCheck(this, CMIInteractionsObject); + + _this5 = _super7.call(this); + + _id.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _time.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _type.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _weighting.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _student_response.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _result.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _latency.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _this5.objectives = new _common.CMIArray({ + errorCode: scorm12_error_codes.INVALID_SET_VALUE, + errorClass: _exceptions.Scorm12ValidationError, + children: scorm12_constants.objectives_children + }); + _this5.correct_responses = new _common.CMIArray({ + errorCode: scorm12_error_codes.INVALID_SET_VALUE, + errorClass: _exceptions.Scorm12ValidationError, + children: scorm12_constants.correct_responses_children + }); + return _this5; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(CMIInteractionsObject, [{ + key: "initialize", + value: function initialize() { + var _this$objectives2, _this$correct_respons; + + _get(_getPrototypeOf(CMIInteractionsObject.prototype), "initialize", this).call(this); + + (_this$objectives2 = this.objectives) === null || _this$objectives2 === void 0 ? void 0 : _this$objectives2.initialize(); + (_this$correct_respons = this.correct_responses) === null || _this$correct_respons === void 0 ? void 0 : _this$correct_respons.initialize(); + } + }, { + key: "id", + get: + /** + * Getter for #id. Should only be called during JSON export. + * @return {*} + */ + function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _id); + } + /** + * Setter for #id + * @param {string} id + */ + , + set: function set(id) { + if (check12ValidFormat(id, scorm12_regex.CMIIdentifier)) { + _classPrivateFieldSet(this, _id, id); + } + } + /** + * Getter for #time. Should only be called during JSON export. + * @return {*} + */ + + }, { + key: "time", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _time); + } + /** + * Setter for #time + * @param {string} time + */ + , + set: function set(time) { + if (check12ValidFormat(time, scorm12_regex.CMITime)) { + _classPrivateFieldSet(this, _time, time); + } + } + /** + * Getter for #type. Should only be called during JSON export. + * @return {*} + */ + + }, { + key: "type", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _type); + } + /** + * Setter for #type + * @param {string} type + */ + , + set: function set(type) { + if (check12ValidFormat(type, scorm12_regex.CMIType)) { + _classPrivateFieldSet(this, _type, type); + } + } + /** + * Getter for #weighting. Should only be called during JSON export. + * @return {*} + */ + + }, { + key: "weighting", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _weighting); + } + /** + * Setter for #weighting + * @param {string} weighting + */ + , + set: function set(weighting) { + if (check12ValidFormat(weighting, scorm12_regex.CMIDecimal) && check12ValidRange(weighting, scorm12_regex.weighting_range)) { + _classPrivateFieldSet(this, _weighting, weighting); + } + } + /** + * Getter for #student_response. Should only be called during JSON export. + * @return {*} + */ + + }, { + key: "student_response", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _student_response); + } + /** + * Setter for #student_response + * @param {string} student_response + */ + , + set: function set(student_response) { + if (check12ValidFormat(student_response, scorm12_regex.CMIFeedback, true)) { + _classPrivateFieldSet(this, _student_response, student_response); + } + } + /** + * Getter for #result. Should only be called during JSON export. + * @return {*} + */ + + }, { + key: "result", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _result); + } + /** + * Setter for #result + * @param {string} result + */ + , + set: function set(result) { + if (check12ValidFormat(result, scorm12_regex.CMIResult)) { + _classPrivateFieldSet(this, _result, result); + } + } + /** + * Getter for #latency. Should only be called during JSON export. + * @return {*} + */ + + }, { + key: "latency", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _latency); + } + /** + * Setter for #latency + * @param {string} latency + */ + , + set: function set(latency) { + if (check12ValidFormat(latency, scorm12_regex.CMITimespan)) { + _classPrivateFieldSet(this, _latency, latency); + } + } + /** + * toJSON for cmi.interactions.n + * + * @return { + * { + * id: string, + * time: string, + * type: string, + * weighting: string, + * student_response: string, + * result: string, + * latency: string, + * objectives: CMIArray, + * correct_responses: CMIArray + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'id': this.id, + 'time': this.time, + 'type': this.type, + 'weighting': this.weighting, + 'student_response': this.student_response, + 'result': this.result, + 'latency': this.latency, + 'objectives': this.objectives, + 'correct_responses': this.correct_responses + }; + delete this.jsonString; + return result; + } + }]); + + return CMIInteractionsObject; +}(_common.BaseCMI); +/** + * Class representing SCORM 1.2's cmi.objectives.n object + * @extends BaseCMI + */ + + +exports.CMIInteractionsObject = CMIInteractionsObject; + +var _id2 = new WeakMap(); + +var _status = new WeakMap(); + +var CMIObjectivesObject = /*#__PURE__*/function (_BaseCMI6) { + _inherits(CMIObjectivesObject, _BaseCMI6); + + var _super8 = _createSuper(CMIObjectivesObject); + + /** + * Constructor for cmi.objectives.n + */ + function CMIObjectivesObject() { + var _this6; + + _classCallCheck(this, CMIObjectivesObject); + + _this6 = _super8.call(this); + + _id2.set(_assertThisInitialized(_this6), { + writable: true, + value: '' + }); + + _status.set(_assertThisInitialized(_this6), { + writable: true, + value: '' + }); + + _this6.score = new _common.CMIScore({ + score_children: scorm12_constants.score_children, + score_range: scorm12_regex.score_range, + invalidErrorCode: scorm12_error_codes.INVALID_SET_VALUE, + invalidTypeCode: scorm12_error_codes.TYPE_MISMATCH, + invalidRangeCode: scorm12_error_codes.VALUE_OUT_OF_RANGE, + errorClass: _exceptions.Scorm12ValidationError + }); + return _this6; + } + + _createClass(CMIObjectivesObject, [{ + key: "id", + get: + /** + * Getter for #id + * @return {""} + */ + function get() { + return _classPrivateFieldGet(this, _id2); + } + /** + * Setter for #id + * @param {string} id + */ + , + set: function set(id) { + if (check12ValidFormat(id, scorm12_regex.CMIIdentifier)) { + _classPrivateFieldSet(this, _id2, id); + } + } + /** + * Getter for #status + * @return {""} + */ + + }, { + key: "status", + get: function get() { + return _classPrivateFieldGet(this, _status); + } + /** + * Setter for #status + * @param {string} status + */ + , + set: function set(status) { + if (check12ValidFormat(status, scorm12_regex.CMIStatus2)) { + _classPrivateFieldSet(this, _status, status); + } + } + /** + * toJSON for cmi.objectives.n + * @return { + * { + * id: string, + * status: string, + * score: CMIScore + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'id': this.id, + 'status': this.status, + 'score': this.score + }; + delete this.jsonString; + return result; + } + }]); + + return CMIObjectivesObject; +}(_common.BaseCMI); +/** + * Class representing SCORM 1.2's cmi.interactions.n.objectives.n object + * @extends BaseCMI + */ + + +exports.CMIObjectivesObject = CMIObjectivesObject; + +var _id3 = new WeakMap(); + +var CMIInteractionsObjectivesObject = /*#__PURE__*/function (_BaseCMI7) { + _inherits(CMIInteractionsObjectivesObject, _BaseCMI7); + + var _super9 = _createSuper(CMIInteractionsObjectivesObject); + + /** + * Constructor for cmi.interactions.n.objectives.n + */ + function CMIInteractionsObjectivesObject() { + var _this7; + + _classCallCheck(this, CMIInteractionsObjectivesObject); + + _this7 = _super9.call(this); + + _id3.set(_assertThisInitialized(_this7), { + writable: true, + value: '' + }); + + return _this7; + } + + _createClass(CMIInteractionsObjectivesObject, [{ + key: "id", + get: + /** + * Getter for #id + * @return {""} + */ + function get() { + return _classPrivateFieldGet(this, _id3); + } + /** + * Setter for #id + * @param {string} id + */ + , + set: function set(id) { + if (check12ValidFormat(id, scorm12_regex.CMIIdentifier)) { + _classPrivateFieldSet(this, _id3, id); + } + } + /** + * toJSON for cmi.interactions.n.objectives.n + * @return { + * { + * id: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'id': this.id + }; + delete this.jsonString; + return result; + } + }]); + + return CMIInteractionsObjectivesObject; +}(_common.BaseCMI); +/** + * Class representing SCORM 1.2's cmi.interactions.correct_responses.n object + * @extends BaseCMI + */ + + +exports.CMIInteractionsObjectivesObject = CMIInteractionsObjectivesObject; + +var _pattern = new WeakMap(); + +var CMIInteractionsCorrectResponsesObject = /*#__PURE__*/function (_BaseCMI8) { + _inherits(CMIInteractionsCorrectResponsesObject, _BaseCMI8); + + var _super10 = _createSuper(CMIInteractionsCorrectResponsesObject); + + /** + * Constructor for cmi.interactions.correct_responses.n + */ + function CMIInteractionsCorrectResponsesObject() { + var _this8; + + _classCallCheck(this, CMIInteractionsCorrectResponsesObject); + + _this8 = _super10.call(this); + + _pattern.set(_assertThisInitialized(_this8), { + writable: true, + value: '' + }); + + return _this8; + } + + _createClass(CMIInteractionsCorrectResponsesObject, [{ + key: "pattern", + get: + /** + * Getter for #pattern + * @return {string} + */ + function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _pattern); + } + /** + * Setter for #pattern + * @param {string} pattern + */ + , + set: function set(pattern) { + if (check12ValidFormat(pattern, scorm12_regex.CMIFeedback, true)) { + _classPrivateFieldSet(this, _pattern, pattern); + } + } + /** + * toJSON for cmi.interactions.correct_responses.n + * @return { + * { + * pattern: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'pattern': this.pattern + }; + delete this.jsonString; + return result; + } + }]); + + return CMIInteractionsCorrectResponsesObject; +}(_common.BaseCMI); +/** + * Class for AICC Navigation object + */ + + +exports.CMIInteractionsCorrectResponsesObject = CMIInteractionsCorrectResponsesObject; + +var _event = new WeakMap(); + +var NAV = /*#__PURE__*/function (_BaseCMI9) { + _inherits(NAV, _BaseCMI9); + + var _super11 = _createSuper(NAV); + + /** + * Constructor for NAV object + */ + function NAV() { + var _this9; + + _classCallCheck(this, NAV); + + _this9 = _super11.call(this); + + _event.set(_assertThisInitialized(_this9), { + writable: true, + value: '' + }); + + return _this9; + } + + _createClass(NAV, [{ + key: "event", + get: + /** + * Getter for #event + * @return {string} + */ + function get() { + return _classPrivateFieldGet(this, _event); + } + /** + * Setter for #event + * @param {string} event + */ + , + set: function set(event) { + if (check12ValidFormat(event, scorm12_regex.NAVEvent)) { + _classPrivateFieldSet(this, _event, event); + } + } + /** + * toJSON for nav object + * @return { + * { + * event: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'event': this.event + }; + delete this.jsonString; + return result; + } + }]); + + return NAV; +}(_common.BaseCMI); + +exports.NAV = NAV; + +},{"../constants/api_constants":8,"../constants/error_codes":9,"../constants/regex":10,"../exceptions":11,"../utilities":13,"./common":6}],8:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var global = { + SCORM_TRUE: 'true', + SCORM_FALSE: 'false', + STATE_NOT_INITIALIZED: 0, + STATE_INITIALIZED: 1, + STATE_TERMINATED: 2, + LOG_LEVEL_DEBUG: 1, + LOG_LEVEL_INFO: 2, + LOG_LEVEL_WARNING: 3, + LOG_LEVEL_ERROR: 4, + LOG_LEVEL_NONE: 5 +}; +var scorm12 = { + // Children lists + cmi_children: 'core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions', + core_children: 'student_id,student_name,lesson_location,credit,lesson_status,entry,score,total_time,lesson_mode,exit,session_time', + score_children: 'raw,min,max', + comments_children: 'content,location,time', + objectives_children: 'id,score,status', + correct_responses_children: 'pattern', + student_data_children: 'mastery_score,max_time_allowed,time_limit_action', + student_preference_children: 'audio,language,speed,text', + interactions_children: 'id,objectives,time,type,correct_responses,weighting,student_response,result,latency', + error_descriptions: { + '101': { + basicMessage: 'General Exception', + detailMessage: 'No specific error code exists to describe the error. Use LMSGetDiagnostic for more information' + }, + '201': { + basicMessage: 'Invalid argument error', + detailMessage: 'Indicates that an argument represents an invalid data model element or is otherwise incorrect.' + }, + '202': { + basicMessage: 'Element cannot have children', + detailMessage: 'Indicates that LMSGetValue was called with a data model element name that ends in "_children" for a data model element that does not support the "_children" suffix.' + }, + '203': { + basicMessage: 'Element not an array - cannot have count', + detailMessage: 'Indicates that LMSGetValue was called with a data model element name that ends in "_count" for a data model element that does not support the "_count" suffix.' + }, + '301': { + basicMessage: 'Not initialized', + detailMessage: 'Indicates that an API call was made before the call to lmsInitialize.' + }, + '401': { + basicMessage: 'Not implemented error', + detailMessage: 'The data model element indicated in a call to LMSGetValue or LMSSetValue is valid, but was not implemented by this LMS. SCORM 1.2 defines a set of data model elements as being optional for an LMS to implement.' + }, + '402': { + basicMessage: 'Invalid set value, element is a keyword', + detailMessage: 'Indicates that LMSSetValue was called on a data model element that represents a keyword (elements that end in "_children" and "_count").' + }, + '403': { + basicMessage: 'Element is read only', + detailMessage: 'LMSSetValue was called with a data model element that can only be read.' + }, + '404': { + basicMessage: 'Element is write only', + detailMessage: 'LMSGetValue was called on a data model element that can only be written to.' + }, + '405': { + basicMessage: 'Incorrect Data Type', + detailMessage: 'LMSSetValue was called with a value that is not consistent with the data format of the supplied data model element.' + }, + '407': { + basicMessage: 'Element Value Out Of Range', + detailMessage: 'The numeric value supplied to a LMSSetValue call is outside of the numeric range allowed for the supplied data model element.' + }, + '408': { + basicMessage: 'Data Model Dependency Not Established', + detailMessage: 'Some data model elements cannot be set until another data model element was set. This error condition indicates that the prerequisite element was not set before the dependent element.' + } + } +}; + +var aicc = _objectSpread(_objectSpread({}, scorm12), { + cmi_children: 'core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions,evaluation', + student_preference_children: 'audio,language,lesson_type,speed,text,text_color,text_location,text_size,video,windows', + student_data_children: 'attempt_number,tries,mastery_score,max_time_allowed,time_limit_action', + student_demographics_children: 'city,class,company,country,experience,familiar_name,instructor_name,title,native_language,state,street_address,telephone,years_experience', + tries_children: 'time,status,score', + attempt_records_children: 'score,lesson_status', + paths_children: 'location_id,date,time,status,why_left,time_in_element' +}); + +var scorm2004 = { + // Children lists + cmi_children: '_version,comments_from_learner,comments_from_lms,completion_status,credit,entry,exit,interactions,launch_data,learner_id,learner_name,learner_preference,location,max_time_allowed,mode,objectives,progress_measure,scaled_passing_score,score,session_time,success_status,suspend_data,time_limit_action,total_time', + comments_children: 'comment,timestamp,location', + score_children: 'max,raw,scaled,min', + objectives_children: 'progress_measure,completion_status,success_status,description,score,id', + correct_responses_children: 'pattern', + student_data_children: 'mastery_score,max_time_allowed,time_limit_action', + student_preference_children: 'audio_level,audio_captioning,delivery_speed,language', + interactions_children: 'id,type,objectives,timestamp,correct_responses,weighting,learner_response,result,latency,description', + error_descriptions: { + '0': { + basicMessage: 'No Error', + detailMessage: 'No error occurred, the previous API call was successful.' + }, + '101': { + basicMessage: 'General Exception', + detailMessage: 'No specific error code exists to describe the error. Use GetDiagnostic for more information.' + }, + '102': { + basicMessage: 'General Initialization Failure', + detailMessage: 'Call to Initialize failed for an unknown reason.' + }, + '103': { + basicMessage: 'Already Initialized', + detailMessage: 'Call to Initialize failed because Initialize was already called.' + }, + '104': { + basicMessage: 'Content Instance Terminated', + detailMessage: 'Call to Initialize failed because Terminate was already called.' + }, + '111': { + basicMessage: 'General Termination Failure', + detailMessage: 'Call to Terminate failed for an unknown reason.' + }, + '112': { + basicMessage: 'Termination Before Initialization', + detailMessage: 'Call to Terminate failed because it was made before the call to Initialize.' + }, + '113': { + basicMessage: 'Termination After Termination', + detailMessage: 'Call to Terminate failed because Terminate was already called.' + }, + '122': { + basicMessage: 'Retrieve Data Before Initialization', + detailMessage: 'Call to GetValue failed because it was made before the call to Initialize.' + }, + '123': { + basicMessage: 'Retrieve Data After Termination', + detailMessage: 'Call to GetValue failed because it was made after the call to Terminate.' + }, + '132': { + basicMessage: 'Store Data Before Initialization', + detailMessage: 'Call to SetValue failed because it was made before the call to Initialize.' + }, + '133': { + basicMessage: 'Store Data After Termination', + detailMessage: 'Call to SetValue failed because it was made after the call to Terminate.' + }, + '142': { + basicMessage: 'Commit Before Initialization', + detailMessage: 'Call to Commit failed because it was made before the call to Initialize.' + }, + '143': { + basicMessage: 'Commit After Termination', + detailMessage: 'Call to Commit failed because it was made after the call to Terminate.' + }, + '201': { + basicMessage: 'General Argument Error', + detailMessage: 'An invalid argument was passed to an API method (usually indicates that Initialize, Commit or Terminate did not receive the expected empty string argument.' + }, + '301': { + basicMessage: 'General Get Failure', + detailMessage: 'Indicates a failed GetValue call where no other specific error code is applicable. Use GetDiagnostic for more information.' + }, + '351': { + basicMessage: 'General Set Failure', + detailMessage: 'Indicates a failed SetValue call where no other specific error code is applicable. Use GetDiagnostic for more information.' + }, + '391': { + basicMessage: 'General Commit Failure', + detailMessage: 'Indicates a failed Commit call where no other specific error code is applicable. Use GetDiagnostic for more information.' + }, + '401': { + basicMessage: 'Undefined Data Model Element', + detailMessage: 'The data model element name passed to GetValue or SetValue is not a valid SCORM data model element.' + }, + '402': { + basicMessage: 'Unimplemented Data Model Element', + detailMessage: 'The data model element indicated in a call to GetValue or SetValue is valid, but was not implemented by this LMS. In SCORM 2004, this error would indicate an LMS that is not fully SCORM conformant.' + }, + '403': { + basicMessage: 'Data Model Element Value Not Initialized', + detailMessage: 'Attempt to read a data model element that has not been initialized by the LMS or through a SetValue call. This error condition is often reached during normal execution of a SCO.' + }, + '404': { + basicMessage: 'Data Model Element Is Read Only', + detailMessage: 'SetValue was called with a data model element that can only be read.' + }, + '405': { + basicMessage: 'Data Model Element Is Write Only', + detailMessage: 'GetValue was called on a data model element that can only be written to.' + }, + '406': { + basicMessage: 'Data Model Element Type Mismatch', + detailMessage: 'SetValue was called with a value that is not consistent with the data format of the supplied data model element.' + }, + '407': { + basicMessage: 'Data Model Element Value Out Of Range', + detailMessage: 'The numeric value supplied to a SetValue call is outside of the numeric range allowed for the supplied data model element.' + }, + '408': { + basicMessage: 'Data Model Dependency Not Established', + detailMessage: 'Some data model elements cannot be set until another data model element was set. This error condition indicates that the prerequisite element was not set before the dependent element.' + } + } +}; +var APIConstants = { + global: global, + scorm12: scorm12, + aicc: aicc, + scorm2004: scorm2004 +}; +var _default = APIConstants; +exports["default"] = _default; + +},{}],9:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var global = { + GENERAL: 101, + INITIALIZATION_FAILED: 101, + INITIALIZED: 101, + TERMINATED: 101, + TERMINATION_FAILURE: 101, + TERMINATION_BEFORE_INIT: 101, + MULTIPLE_TERMINATION: 101, + RETRIEVE_BEFORE_INIT: 101, + RETRIEVE_AFTER_TERM: 101, + STORE_BEFORE_INIT: 101, + STORE_AFTER_TERM: 101, + COMMIT_BEFORE_INIT: 101, + COMMIT_AFTER_TERM: 101, + ARGUMENT_ERROR: 101, + CHILDREN_ERROR: 101, + COUNT_ERROR: 101, + GENERAL_GET_FAILURE: 101, + GENERAL_SET_FAILURE: 101, + GENERAL_COMMIT_FAILURE: 101, + UNDEFINED_DATA_MODEL: 101, + UNIMPLEMENTED_ELEMENT: 101, + VALUE_NOT_INITIALIZED: 101, + INVALID_SET_VALUE: 101, + READ_ONLY_ELEMENT: 101, + WRITE_ONLY_ELEMENT: 101, + TYPE_MISMATCH: 101, + VALUE_OUT_OF_RANGE: 101, + DEPENDENCY_NOT_ESTABLISHED: 101 +}; + +var scorm12 = _objectSpread(_objectSpread({}, global), { + RETRIEVE_BEFORE_INIT: 301, + STORE_BEFORE_INIT: 301, + COMMIT_BEFORE_INIT: 301, + ARGUMENT_ERROR: 201, + CHILDREN_ERROR: 202, + COUNT_ERROR: 203, + UNDEFINED_DATA_MODEL: 401, + UNIMPLEMENTED_ELEMENT: 401, + VALUE_NOT_INITIALIZED: 301, + INVALID_SET_VALUE: 402, + READ_ONLY_ELEMENT: 403, + WRITE_ONLY_ELEMENT: 404, + TYPE_MISMATCH: 405, + VALUE_OUT_OF_RANGE: 407, + DEPENDENCY_NOT_ESTABLISHED: 408 +}); + +var scorm2004 = _objectSpread(_objectSpread({}, global), { + INITIALIZATION_FAILED: 102, + INITIALIZED: 103, + TERMINATED: 104, + TERMINATION_FAILURE: 111, + TERMINATION_BEFORE_INIT: 112, + MULTIPLE_TERMINATIONS: 113, + RETRIEVE_BEFORE_INIT: 122, + RETRIEVE_AFTER_TERM: 123, + STORE_BEFORE_INIT: 132, + STORE_AFTER_TERM: 133, + COMMIT_BEFORE_INIT: 142, + COMMIT_AFTER_TERM: 143, + ARGUMENT_ERROR: 201, + GENERAL_GET_FAILURE: 301, + GENERAL_SET_FAILURE: 351, + GENERAL_COMMIT_FAILURE: 391, + UNDEFINED_DATA_MODEL: 401, + UNIMPLEMENTED_ELEMENT: 402, + VALUE_NOT_INITIALIZED: 403, + READ_ONLY_ELEMENT: 404, + WRITE_ONLY_ELEMENT: 405, + TYPE_MISMATCH: 406, + VALUE_OUT_OF_RANGE: 407, + DEPENDENCY_NOT_ESTABLISHED: 408 +}); + +var ErrorCodes = { + scorm12: scorm12, + scorm2004: scorm2004 +}; +var _default = ErrorCodes; +exports["default"] = _default; + +},{}],10:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var scorm12 = { + CMIString256: '^.{0,255}$', + CMIString4096: '^.{0,4096}$', + CMITime: '^(?:[01]\\d|2[0123]):(?:[012345]\\d):(?:[012345]\\d)$', + // eslint-disable-line + CMITimespan: '^([0-9]{2,}):([0-9]{2}):([0-9]{2})(\.[0-9]{1,2})?$', + // eslint-disable-line + CMIInteger: '^\\d+$', + CMISInteger: '^-?([0-9]+)$', + CMIDecimal: '^-?([0-9]{0,3})(\.[0-9]*)?$', + // eslint-disable-line + CMIIdentifier: "^[\\u0021-\\u007E\\s]{0,255}$", + CMIFeedback: '^.{0,255}$', + // This must be redefined + CMIIndex: '[._](\\d+).', + // Vocabulary Data Type Definition + CMIStatus: '^(passed|completed|failed|incomplete|browsed)$', + CMIStatus2: '^(passed|completed|failed|incomplete|browsed|not attempted)$', + CMIExit: '^(time-out|suspend|logout|)$', + CMIType: '^(true-false|choice|fill-in|matching|performance|sequencing|likert|numeric)$', + CMIResult: '^(correct|wrong|unanticipated|neutral|([0-9]{0,3})?(\\.[0-9]*)?)$', + // eslint-disable-line + NAVEvent: '^(previous|continue)$', + // Data ranges + score_range: '0#100', + audio_range: '-1#100', + speed_range: '-100#100', + weighting_range: '-100#100', + text_range: '-1#1' +}; + +var aicc = _objectSpread(_objectSpread({}, scorm12), { + CMIIdentifier: '^\\w{1,255}$' +}); + +var scorm2004 = { + CMIString200: "^[\\u0000-\\uFFFF]{0,200}$", + CMIString250: "^[\\u0000-\\uFFFF]{0,250}$", + CMIString1000: "^[\\u0000-\\uFFFF]{0,1000}$", + CMIString4000: "^[\\u0000-\\uFFFF]{0,4000}$", + CMIString64000: "^[\\u0000-\\uFFFF]{0,64000}$", + CMILang: '^([a-zA-Z]{2,3}|i|x)(\-[a-zA-Z0-9\-]{2,8})?$|^$', + // eslint-disable-line + CMILangString250: '^(\{lang=([a-zA-Z]{2,3}|i|x)(\-[a-zA-Z0-9\-]{2,8})?\})?((?!\{.*$).{0,250}$)?$', + // eslint-disable-line + CMILangcr: '^((\{lang=([a-zA-Z]{2,3}|i|x)?(\-[a-zA-Z0-9\-]{2,8})?\}))(.*?)$', + // eslint-disable-line + CMILangString250cr: '^((\{lang=([a-zA-Z]{2,3}|i|x)?(\-[a-zA-Z0-9\-]{2,8})?\})?(.{0,250})?)?$', + // eslint-disable-line + CMILangString4000: '^(\{lang=([a-zA-Z]{2,3}|i|x)(\-[a-zA-Z0-9\-]{2,8})?\})?((?!\{.*$).{0,4000}$)?$', + // eslint-disable-line + CMITime: '^(19[7-9]{1}[0-9]{1}|20[0-2]{1}[0-9]{1}|203[0-8]{1})((-(0[1-9]{1}|1[0-2]{1}))((-(0[1-9]{1}|[1-2]{1}[0-9]{1}|3[0-1]{1}))(T([0-1]{1}[0-9]{1}|2[0-3]{1})((:[0-5]{1}[0-9]{1})((:[0-5]{1}[0-9]{1})((\\.[0-9]{1,2})((Z|([+|-]([0-1]{1}[0-9]{1}|2[0-3]{1})))(:[0-5]{1}[0-9]{1})?)?)?)?)?)?)?)?$', + CMITimespan: '^P(?:([.,\\d]+)Y)?(?:([.,\\d]+)M)?(?:([.,\\d]+)W)?(?:([.,\\d]+)D)?(?:T?(?:([.,\\d]+)H)?(?:([.,\\d]+)M)?(?:([.,\\d]+)S)?)?$', + CMIInteger: '^\\d+$', + CMISInteger: '^-?([0-9]+)$', + CMIDecimal: '^-?([0-9]{1,5})(\\.[0-9]{1,18})?$', + CMIIdentifier: '^\\S{1,250}[a-zA-Z0-9]$', + CMIShortIdentifier: '^[\\w\\.\\-\\_]{1,250}$', + // eslint-disable-line + CMILongIdentifier: '^(?:(?!urn:)\\S{1,4000}|urn:[A-Za-z0-9-]{1,31}:\\S{1,4000}|.{1,4000})$', + // need to re-examine this + CMIFeedback: '^.*$', + // This must be redefined + CMIIndex: '[._](\\d+).', + CMIIndexStore: '.N(\\d+).', + // Vocabulary Data Type Definition + CMICStatus: '^(completed|incomplete|not attempted|unknown)$', + CMISStatus: '^(passed|failed|unknown)$', + CMIExit: '^(time-out|suspend|logout|normal)$', + CMIType: '^(true-false|choice|fill-in|long-fill-in|matching|performance|sequencing|likert|numeric|other)$', + CMIResult: '^(correct|incorrect|unanticipated|neutral|-?([0-9]{1,4})(\\.[0-9]{1,18})?)$', + NAVEvent: '^(previous|continue|exit|exitAll|abandon|abandonAll|suspendAll|\{target=\\S{0,200}[a-zA-Z0-9]\}choice|jump)$', + // eslint-disable-line + NAVBoolean: '^(unknown|true|false$)', + NAVTarget: '^(previous|continue|choice.{target=\\S{0,200}[a-zA-Z0-9]})$', + // Data ranges + scaled_range: '-1#1', + audio_range: '0#*', + speed_range: '0#*', + text_range: '-1#1', + progress_range: '0#1' +}; +var Regex = { + aicc: aicc, + scorm12: scorm12, + scorm2004: scorm2004 +}; +var _default = Regex; +exports["default"] = _default; + +},{}],11:[function(require,module,exports){ +"use strict"; + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.Scorm2004ValidationError = exports.AICCValidationError = exports.Scorm12ValidationError = exports.ValidationError = void 0; + +var _api_constants = _interopRequireDefault(require("./constants/api_constants")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); } + +function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); } + +function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; } + +function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); } + +function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } } + +var scorm12_errors = _api_constants["default"].scorm12.error_descriptions; +var aicc_errors = _api_constants["default"].aicc.error_descriptions; +var scorm2004_errors = _api_constants["default"].scorm2004.error_descriptions; +/** + * Base Validation Exception + */ + +var _errorCode = new WeakMap(); + +var _errorMessage = new WeakMap(); + +var _detailedMessage = new WeakMap(); + +var ValidationError = /*#__PURE__*/function (_Error) { + _inherits(ValidationError, _Error); + + var _super = _createSuper(ValidationError); + + /** + * Constructor to take in an error message and code + * @param {number} errorCode + * @param {string} errorMessage + * @param {string} detailedMessage + */ + function ValidationError(errorCode, errorMessage, detailedMessage) { + var _this; + + _classCallCheck(this, ValidationError); + + _this = _super.call(this, errorMessage); + + _errorCode.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _errorMessage.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _detailedMessage.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _classPrivateFieldSet(_assertThisInitialized(_this), _errorCode, errorCode); + + _classPrivateFieldSet(_assertThisInitialized(_this), _errorMessage, errorMessage); + + _classPrivateFieldSet(_assertThisInitialized(_this), _detailedMessage, detailedMessage); + + return _this; + } + + _createClass(ValidationError, [{ + key: "errorCode", + get: + /** + * Getter for #errorCode + * @return {number} + */ + function get() { + return _classPrivateFieldGet(this, _errorCode); + } + /** + * Getter for #errorMessage + * @return {string} + */ + + }, { + key: "errorMessage", + get: function get() { + return _classPrivateFieldGet(this, _errorMessage); + } + /** + * Getter for #detailedMessage + * @return {string} + */ + + }, { + key: "detailedMessage", + get: function get() { + return _classPrivateFieldGet(this, _detailedMessage); + } + }]); + + return ValidationError; +}( /*#__PURE__*/_wrapNativeSuper(Error)); +/** + * SCORM 1.2 Validation Error + */ + + +exports.ValidationError = ValidationError; + +var Scorm12ValidationError = /*#__PURE__*/function (_ValidationError) { + _inherits(Scorm12ValidationError, _ValidationError); + + var _super2 = _createSuper(Scorm12ValidationError); + + /** + * Constructor to take in an error code + * @param {number} errorCode + */ + function Scorm12ValidationError(errorCode) { + var _this2; + + _classCallCheck(this, Scorm12ValidationError); + + if ({}.hasOwnProperty.call(scorm12_errors, String(errorCode))) { + _this2 = _super2.call(this, errorCode, scorm12_errors[String(errorCode)].basicMessage, scorm12_errors[String(errorCode)].detailMessage); + } else { + _this2 = _super2.call(this, 101, scorm12_errors['101'].basicMessage, scorm12_errors['101'].detailMessage); + } + + return _possibleConstructorReturn(_this2); + } + + return Scorm12ValidationError; +}(ValidationError); +/** + * AICC Validation Error + */ + + +exports.Scorm12ValidationError = Scorm12ValidationError; + +var AICCValidationError = /*#__PURE__*/function (_ValidationError2) { + _inherits(AICCValidationError, _ValidationError2); + + var _super3 = _createSuper(AICCValidationError); + + /** + * Constructor to take in an error code + * @param {number} errorCode + */ + function AICCValidationError(errorCode) { + var _this3; + + _classCallCheck(this, AICCValidationError); + + if ({}.hasOwnProperty.call(aicc_errors, String(errorCode))) { + _this3 = _super3.call(this, errorCode, aicc_errors[String(errorCode)].basicMessage, aicc_errors[String(errorCode)].detailMessage); + } else { + _this3 = _super3.call(this, 101, aicc_errors['101'].basicMessage, aicc_errors['101'].detailMessage); + } + + return _possibleConstructorReturn(_this3); + } + + return AICCValidationError; +}(ValidationError); +/** + * SCORM 2004 Validation Error + */ + + +exports.AICCValidationError = AICCValidationError; + +var Scorm2004ValidationError = /*#__PURE__*/function (_ValidationError3) { + _inherits(Scorm2004ValidationError, _ValidationError3); + + var _super4 = _createSuper(Scorm2004ValidationError); + + /** + * Constructor to take in an error code + * @param {number} errorCode + */ + function Scorm2004ValidationError(errorCode) { + var _this4; + + _classCallCheck(this, Scorm2004ValidationError); + + if ({}.hasOwnProperty.call(scorm2004_errors, String(errorCode))) { + _this4 = _super4.call(this, errorCode, scorm2004_errors[String(errorCode)].basicMessage, scorm2004_errors[String(errorCode)].detailMessage); + } else { + _this4 = _super4.call(this, 101, scorm2004_errors['101'].basicMessage, scorm2004_errors['101'].detailMessage); + } + + return _possibleConstructorReturn(_this4); + } + + return Scorm2004ValidationError; +}(ValidationError); + +exports.Scorm2004ValidationError = Scorm2004ValidationError; + +},{"./constants/api_constants":8}],12:[function(require,module,exports){ +"use strict"; + +var _AICC = _interopRequireDefault(require("../AICC")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +window.AICC = _AICC["default"]; + +},{"../AICC":2}],13:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.getSecondsAsHHMMSS = getSecondsAsHHMMSS; +exports.getSecondsAsISODuration = getSecondsAsISODuration; +exports.getTimeAsSeconds = getTimeAsSeconds; +exports.getDurationAsSeconds = getDurationAsSeconds; +exports.addTwoDurations = addTwoDurations; +exports.addHHMMSSTimeStrings = addHHMMSSTimeStrings; +exports.flatten = flatten; +exports.unflatten = unflatten; +exports.countDecimals = countDecimals; +exports.SECONDS_PER_DAY = exports.SECONDS_PER_HOUR = exports.SECONDS_PER_MINUTE = exports.SECONDS_PER_SECOND = void 0; + +function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); } + +function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } + +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit(arr, i) { var _i = arr && (typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]); if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } + +var SECONDS_PER_SECOND = 1.0; +exports.SECONDS_PER_SECOND = SECONDS_PER_SECOND; +var SECONDS_PER_MINUTE = 60; +exports.SECONDS_PER_MINUTE = SECONDS_PER_MINUTE; +var SECONDS_PER_HOUR = 60 * SECONDS_PER_MINUTE; +exports.SECONDS_PER_HOUR = SECONDS_PER_HOUR; +var SECONDS_PER_DAY = 24 * SECONDS_PER_HOUR; +exports.SECONDS_PER_DAY = SECONDS_PER_DAY; +var designations = [['D', SECONDS_PER_DAY], ['H', SECONDS_PER_HOUR], ['M', SECONDS_PER_MINUTE], ['S', SECONDS_PER_SECOND]]; +/** + * Converts a Number to a String of HH:MM:SS + * + * @param {Number} totalSeconds + * @return {string} + */ + +function getSecondsAsHHMMSS(totalSeconds) { + // SCORM spec does not deal with negative durations, give zero back + if (!totalSeconds || totalSeconds <= 0) { + return '00:00:00'; + } + + var hours = Math.floor(totalSeconds / SECONDS_PER_HOUR); + var dateObj = new Date(totalSeconds * 1000); + var minutes = dateObj.getUTCMinutes(); // make sure we add any possible decimal value + + var seconds = dateObj.getSeconds(); + var ms = totalSeconds % 1.0; + var msStr = ''; + + if (countDecimals(ms) > 0) { + if (countDecimals(ms) > 2) { + msStr = ms.toFixed(2); + } else { + msStr = String(ms); + } + + msStr = '.' + msStr.split('.')[1]; + } + + return (hours + ':' + minutes + ':' + seconds).replace(/\b\d\b/g, '0$&') + msStr; +} +/** + * Calculate the number of seconds from ISO 8601 Duration + * + * @param {Number} seconds + * @return {String} + */ + + +function getSecondsAsISODuration(seconds) { + // SCORM spec does not deal with negative durations, give zero back + if (!seconds || seconds <= 0) { + return 'PT0S'; + } + + var duration = 'P'; + var remainder = seconds; + designations.forEach(function (_ref) { + var _ref2 = _slicedToArray(_ref, 2), + sign = _ref2[0], + current_seconds = _ref2[1]; + + var value = Math.floor(remainder / current_seconds); + remainder = remainder % current_seconds; + + if (countDecimals(remainder) > 2) { + remainder = Number(Number(remainder).toFixed(2)); + } // If we have anything left in the remainder, and we're currently adding + // seconds to the duration, go ahead and add the decimal to the seconds + + + if (sign === 'S' && remainder > 0) { + value += remainder; + } + + if (value) { + if ((duration.indexOf('D') > 0 || sign === 'H' || sign === 'M' || sign === 'S') && duration.indexOf('T') === -1) { + duration += 'T'; + } + + duration += "".concat(value).concat(sign); + } + }); + return duration; +} +/** + * Calculate the number of seconds from HH:MM:SS.DDDDDD + * + * @param {string} timeString + * @param {RegExp} timeRegex + * @return {number} + */ + + +function getTimeAsSeconds(timeString, timeRegex) { + if (!timeString || typeof timeString !== 'string' || !timeString.match(timeRegex)) { + return 0; + } + + var parts = timeString.split(':'); + var hours = Number(parts[0]); + var minutes = Number(parts[1]); + var seconds = Number(parts[2]); + return hours * 3600 + minutes * 60 + seconds; +} +/** + * Calculate the number of seconds from ISO 8601 Duration + * + * @param {string} duration + * @param {RegExp} durationRegex + * @return {number} + */ + + +function getDurationAsSeconds(duration, durationRegex) { + if (!duration || !duration.match(durationRegex)) { + return 0; + } + + var _ref3 = new RegExp(durationRegex).exec(duration) || [], + _ref4 = _slicedToArray(_ref3, 8), + years = _ref4[1], + months = _ref4[2], + days = _ref4[4], + hours = _ref4[5], + minutes = _ref4[6], + seconds = _ref4[7]; + + var result = 0.0; + result += Number(seconds) * 1.0 || 0.0; + result += Number(minutes) * 60.0 || 0.0; + result += Number(hours) * 3600.0 || 0.0; + result += Number(days) * (60 * 60 * 24.0) || 0.0; + result += Number(years) * (60 * 60 * 24 * 365.0) || 0.0; + return result; +} +/** + * Adds together two ISO8601 Duration strings + * + * @param {string} first + * @param {string} second + * @param {RegExp} durationRegex + * @return {string} + */ + + +function addTwoDurations(first, second, durationRegex) { + return getSecondsAsISODuration(getDurationAsSeconds(first, durationRegex) + getDurationAsSeconds(second, durationRegex)); +} +/** + * Add together two HH:MM:SS.DD strings + * + * @param {string} first + * @param {string} second + * @param {RegExp} timeRegex + * @return {string} + */ + + +function addHHMMSSTimeStrings(first, second, timeRegex) { + return getSecondsAsHHMMSS(getTimeAsSeconds(first, timeRegex) + getTimeAsSeconds(second, timeRegex)); +} +/** + * Flatten a JSON object down to string paths for each values + * @param {object} data + * @return {object} + */ + + +function flatten(data) { + var result = {}; + /** + * Recurse through the object + * @param {*} cur + * @param {*} prop + */ + + function recurse(cur, prop) { + if (Object(cur) !== cur) { + result[prop] = cur; + } else if (Array.isArray(cur)) { + for (var i = 0, l = cur.length; i < l; i++) { + recurse(cur[i], prop + '[' + i + ']'); + if (l === 0) result[prop] = []; + } + } else { + var isEmpty = true; + + for (var p in cur) { + if ({}.hasOwnProperty.call(cur, p)) { + isEmpty = false; + recurse(cur[p], prop ? prop + '.' + p : p); + } + } + + if (isEmpty && prop) result[prop] = {}; + } + } + + recurse(data, ''); + return result; +} +/** + * Un-flatten a flat JSON object + * @param {object} data + * @return {object} + */ + + +function unflatten(data) { + 'use strict'; + + if (Object(data) !== data || Array.isArray(data)) return data; + var regex = /\.?([^.[\]]+)|\[(\d+)]/g; + var result = {}; + + for (var p in data) { + if ({}.hasOwnProperty.call(data, p)) { + var cur = result; + var prop = ''; + var m = regex.exec(p); + + while (m) { + cur = cur[prop] || (cur[prop] = m[2] ? [] : {}); + prop = m[2] || m[1]; + m = regex.exec(p); + } + + cur[prop] = data[p]; + } + } + + return result[''] || result; +} +/** + * Counts the number of decimal places + * @param {number} num + * @return {number} + */ + + +function countDecimals(num) { + if (Math.floor(num) === num || String(num).indexOf('.') < 0) return 0; + var parts = num.toString().split('.')[1]; + return parts.length || 0; +} + +},{}]},{},[12]) +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","node_modules/lodash.debounce/index.js","src/AICC.js","src/BaseAPI.js","src/Scorm12API.js","src/cmi/aicc_cmi.js","src/cmi/common.js","src/cmi/scorm12_cmi.js","src/constants/api_constants.js","src/constants/error_codes.js","src/constants/regex.js","src/exceptions.js","src/exports/aicc.js","src/utilities.js"],"names":[],"mappings":"AAAA;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACxXA;;AACA;;AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA;AACA;AACA;IACqB,I;;;;;AACnB;AACF;AACA;AACA;AACE,gBAAY,QAAZ,EAA0B;AAAA;;AAAA;;AACxB,QAAM,aAAa,mCACd;AACD,MAAA,gBAAgB,EAAE;AADjB,KADc,GAGX,QAHW,CAAnB;;AAMA,8BAAM,aAAN;AAEA,UAAK,GAAL,GAAW,IAAI,aAAJ,EAAX;AACA,UAAK,GAAL,GAAW,IAAI,gBAAJ,EAAX;AAVwB;AAWzB;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;;;;;WACE,yBAAgB,UAAhB,EAA4B,KAA5B,EAAmC,eAAnC,EAAoD;AAClD,UAAI,QAAQ,6EAAyB,UAAzB,EAAqC,KAArC,EAA4C,eAA5C,CAAZ;;AAEA,UAAI,CAAC,QAAL,EAAe;AACb,YAAI,KAAK,aAAL,CAAmB,UAAnB,EAA+B,oCAA/B,CAAJ,EAA0E;AACxE,UAAA,QAAQ,GAAG,IAAI,qCAAJ,EAAX;AACD,SAFD,MAEO,IAAI,KAAK,aAAL,CAAmB,UAAnB,EACP,mCADO,CAAJ,EACmC;AACxC,UAAA,QAAQ,GAAG,IAAI,wBAAJ,EAAX;AACD,SAHM,MAGA,IAAI,KAAK,aAAL,CAAmB,UAAnB,EACP,6CADO,CAAJ,EAC6C;AAClD,UAAA,QAAQ,GAAG,IAAI,iCAAJ,EAAX;AACD;AACF;;AAED,aAAO,QAAP;AACD;AAED;AACF;AACA;AACA;AACA;;;;WACE,oCAA2B,MAA3B,EAAmC;AACjC;AACA,WAAK,GAAL,GAAW,MAAM,CAAC,GAAlB;AACA,WAAK,GAAL,GAAW,MAAM,CAAC,GAAlB;AACD;;;;EArD+B,uB;;;;;;;;;;;;ACZlC;;AACA;;AACA;;AACA;;AACA;;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,IAAM,gBAAgB,GAAG,0BAAa,MAAtC;AACA,IAAM,mBAAmB,GAAG,yBAAW,OAAvC;AAEA;AACA;AACA;AACA;;;;;;;;IACqB,O;AAqCnB;AACF;AACA;AACA;AACA;AACA;AACE,mBAAY,WAAZ,EAAyB,QAAzB,EAAmC;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA,aAxCvB;AACV,QAAA,UAAU,EAAE,KADF;AAEV,QAAA,iBAAiB,EAAE,EAFT;AAGV,QAAA,WAAW,EAAE,KAHH;AAIV,QAAA,gBAAgB,EAAE,KAJR;AAKV,QAAA,YAAY,EAAE,KALJ;AAMV,QAAA,gBAAgB,EAAE,MANR;AAMgB;AAC1B,QAAA,qBAAqB,EAAE,gCAPb;AAQV,QAAA,YAAY,EAAE,KARJ;AASV,QAAA,QAAQ,EAAE,gBAAgB,CAAC,eATjB;AAUV,QAAA,qBAAqB,EAAE,KAVb;AAWV,QAAA,mBAAmB,EAAE,KAXX;AAYV,QAAA,aAAa,EAAE,IAZL;AAaV,QAAA,eAAe,EAAE,yBAAS,GAAT,EAAc;AAC7B,cAAI,MAAJ;;AACA,cAAI,OAAO,GAAP,KAAe,WAAnB,EAAgC;AAC9B,YAAA,MAAM,GAAG,IAAI,CAAC,KAAL,CAAW,GAAG,CAAC,YAAf,CAAT;;AACA,gBAAI,MAAM,KAAK,IAAX,IAAmB,CAAC,GAAG,cAAH,CAAkB,IAAlB,CAAuB,MAAvB,EAA+B,QAA/B,CAAxB,EAAkE;AAChE,cAAA,MAAM,GAAG,EAAT;;AACA,kBAAI,GAAG,CAAC,MAAJ,KAAe,GAAnB,EAAwB;AACtB,gBAAA,MAAM,CAAC,MAAP,GAAgB,gBAAgB,CAAC,UAAjC;AACA,gBAAA,MAAM,CAAC,SAAP,GAAmB,CAAnB;AACD,eAHD,MAGO;AACL,gBAAA,MAAM,CAAC,MAAP,GAAgB,gBAAgB,CAAC,WAAjC;AACA,gBAAA,MAAM,CAAC,SAAP,GAAmB,GAAnB;AACD;AACF;AACF;;AACD,iBAAO,MAAP;AACD;AA7BS;AAwCuB;;AAAA;;AAAA;;AACjC,QAAI,0DAAe,OAAnB,EAA4B;AAC1B,YAAM,IAAI,SAAJ,CAAc,6CAAd,CAAN;AACD;;AACD,SAAK,YAAL,GAAoB,gBAAgB,CAAC,qBAArC;AACA,SAAK,aAAL,GAAqB,CAArB;AACA,SAAK,aAAL,GAAqB,EAArB;;AAEA,0CAAgB,IAAhB;;AACA,8CAAoB,WAApB;;AAEA,SAAK,QAAL,GAAgB,QAAhB;AACA,SAAK,WAAL,GAAmB,KAAK,QAAL,CAAc,QAAjC;AACA,SAAK,qBAAL,GAA6B,KAAK,QAAL,CAAc,qBAA3C;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;;;;;WACE,oBACI,YADJ,EAEI,iBAFJ,EAGI,kBAHJ,EAGiC;AAC/B,UAAI,WAAW,GAAG,gBAAgB,CAAC,WAAnC;;AAEA,UAAI,KAAK,aAAL,EAAJ,EAA0B;AACxB,aAAK,eAAL,CAAqB,0CAAkB,WAAvC,EAAoD,iBAApD;AACD,OAFD,MAEO,IAAI,KAAK,YAAL,EAAJ,EAAyB;AAC9B,aAAK,eAAL,CAAqB,0CAAkB,UAAvC,EAAmD,kBAAnD;AACD,OAFM,MAEA;AACL,YAAI,KAAK,qBAAT,EAAgC;AAC9B,eAAK,GAAL,CAAS,YAAT;AACD;;AAED,aAAK,YAAL,GAAoB,gBAAgB,CAAC,iBAArC;AACA,aAAK,aAAL,GAAqB,CAArB;AACA,QAAA,WAAW,GAAG,gBAAgB,CAAC,UAA/B;AACA,aAAK,gBAAL,CAAsB,YAAtB;AACD;;AAED,WAAK,MAAL,CAAY,YAAZ,EAA0B,IAA1B,EAAgC,eAAe,WAA/C,EACI,gBAAgB,CAAC,cADrB;AAEA,WAAK,eAAL,CAAqB,WAArB;AAEA,aAAO,WAAP;AACD;AAED;AACF;AACA;AACA;;;;SACE,eAAkB;AAChB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;;;SACE,eAAe;AACb,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAa,QAAb,EAA+B;AAC7B,mGAAqB,IAArB,eAAwC,QAAxC;AACD;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,mBACI,YADJ,EAEI,eAFJ,EAE8B;AAC5B,UAAI,WAAW,GAAG,gBAAgB,CAAC,WAAnC;;AAEA,UAAI,KAAK,UAAL,CAAgB,eAAhB,EACA,0CAAkB,uBADlB,EAEA,0CAAkB,oBAFlB,CAAJ,EAE6C;AAC3C,aAAK,YAAL,GAAoB,gBAAgB,CAAC,gBAArC;AAEA,YAAM,MAAM,GAAG,KAAK,SAAL,CAAe,IAAf,CAAf;;AACA,YAAI,CAAC,KAAK,QAAL,CAAc,gBAAf,IAAmC,CAAC,KAAK,QAAL,CAAc,WAAlD,IACA,OAAO,MAAM,CAAC,SAAd,KAA4B,WAD5B,IAC2C,MAAM,CAAC,SAAP,GAAmB,CADlE,EACqE;AACnE,eAAK,eAAL,CAAqB,MAAM,CAAC,SAA5B;AACD;;AACD,QAAA,WAAW,GAAI,OAAO,MAAP,KAAkB,WAAlB,IAAiC,MAAM,CAAC,MAAzC,GACV,MAAM,CAAC,MADG,GACM,gBAAgB,CAAC,WADrC;AAGA,YAAI,eAAJ,EAAqB,KAAK,aAAL,GAAqB,CAArB;AAErB,QAAA,WAAW,GAAG,gBAAgB,CAAC,UAA/B;AACA,aAAK,gBAAL,CAAsB,YAAtB;AACD;;AAED,WAAK,MAAL,CAAY,YAAZ,EAA0B,IAA1B,EAAgC,eAAe,WAA/C,EACI,gBAAgB,CAAC,cADrB;AAEA,WAAK,eAAL,CAAqB,WAArB;AAEA,aAAO,WAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,kBACI,YADJ,EAEI,eAFJ,EAGI,UAHJ,EAGwB;AACtB,UAAI,WAAJ;;AAEA,UAAI,KAAK,UAAL,CAAgB,eAAhB,EACA,0CAAkB,oBADlB,EAEA,0CAAkB,mBAFlB,CAAJ,EAE4C;AAC1C,YAAI,eAAJ,EAAqB,KAAK,aAAL,GAAqB,CAArB;;AACrB,YAAI;AACF,UAAA,WAAW,GAAG,KAAK,WAAL,CAAiB,UAAjB,CAAd;AACD,SAFD,CAEE,OAAO,CAAP,EAAU;AACV,cAAI,CAAC,YAAY,2BAAjB,EAAkC;AAChC,iBAAK,aAAL,GAAqB,CAAC,CAAC,SAAvB;AACA,YAAA,WAAW,GAAG,gBAAgB,CAAC,WAA/B;AACD,WAHD,MAGO;AACL,gBAAI,CAAC,CAAC,OAAN,EAAe;AACb,cAAA,OAAO,CAAC,KAAR,CAAc,CAAC,CAAC,OAAhB;AACD,aAFD,MAEO;AACL,cAAA,OAAO,CAAC,KAAR,CAAc,CAAd;AACD;;AACD,iBAAK,eAAL,CAAqB,0CAAkB,OAAvC;AACD;AACF;;AACD,aAAK,gBAAL,CAAsB,YAAtB,EAAoC,UAApC;AACD;;AAED,WAAK,MAAL,CAAY,YAAZ,EAA0B,UAA1B,EAAsC,iBAAiB,WAAvD,EACI,gBAAgB,CAAC,cADrB;AAEA,WAAK,eAAL,CAAqB,WAArB;AAEA,aAAO,WAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,kBACI,YADJ,EAEI,cAFJ,EAGI,eAHJ,EAII,UAJJ,EAKI,KALJ,EAKW;AACT,UAAI,KAAK,KAAK,SAAd,EAAyB;AACvB,QAAA,KAAK,GAAG,MAAM,CAAC,KAAD,CAAd;AACD;;AACD,UAAI,WAAW,GAAG,gBAAgB,CAAC,WAAnC;;AAEA,UAAI,KAAK,UAAL,CAAgB,eAAhB,EAAiC,0CAAkB,iBAAnD,EACA,0CAAkB,gBADlB,CAAJ,EACyC;AACvC,YAAI,eAAJ,EAAqB,KAAK,aAAL,GAAqB,CAArB;;AACrB,YAAI;AACF,UAAA,WAAW,GAAG,KAAK,WAAL,CAAiB,UAAjB,EAA6B,KAA7B,CAAd;AACD,SAFD,CAEE,OAAO,CAAP,EAAU;AACV,cAAI,CAAC,YAAY,2BAAjB,EAAkC;AAChC,iBAAK,aAAL,GAAqB,CAAC,CAAC,SAAvB;AACA,YAAA,WAAW,GAAG,gBAAgB,CAAC,WAA/B;AACD,WAHD,MAGO;AACL,gBAAI,CAAC,CAAC,OAAN,EAAe;AACb,cAAA,OAAO,CAAC,KAAR,CAAc,CAAC,CAAC,OAAhB;AACD,aAFD,MAEO;AACL,cAAA,OAAO,CAAC,KAAR,CAAc,CAAd;AACD;;AACD,iBAAK,eAAL,CAAqB,0CAAkB,OAAvC;AACD;AACF;;AACD,aAAK,gBAAL,CAAsB,YAAtB,EAAoC,UAApC,EAAgD,KAAhD;AACD;;AAED,UAAI,WAAW,KAAK,SAApB,EAA+B;AAC7B,QAAA,WAAW,GAAG,gBAAgB,CAAC,WAA/B;AACD,OA7BQ,CA+BT;AACA;;;AACA,UAAI,MAAM,CAAC,KAAK,aAAN,CAAN,KAA+B,GAAnC,EAAwC;AACtC,YAAI,KAAK,QAAL,CAAc,UAAd,IAA4B,uBAAC,IAAD,WAAhC,EAAgD;AAC9C,eAAK,cAAL,CAAoB,KAAK,QAAL,CAAc,iBAAd,GAAkC,IAAtD,EAA4D,cAA5D;AACD;AACF;;AAED,WAAK,MAAL,CAAY,YAAZ,EAA0B,UAA1B,EACI,OAAO,KAAP,GAAe,YAAf,GAA8B,WADlC,EAEI,gBAAgB,CAAC,cAFrB;AAGA,WAAK,eAAL,CAAqB,WAArB;AAEA,aAAO,WAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,gBACI,YADJ,EAEI,eAFJ,EAE8B;AAC5B,WAAK,oBAAL;AAEA,UAAI,WAAW,GAAG,gBAAgB,CAAC,WAAnC;;AAEA,UAAI,KAAK,UAAL,CAAgB,eAAhB,EAAiC,0CAAkB,kBAAnD,EACA,0CAAkB,iBADlB,CAAJ,EAC0C;AACxC,YAAM,MAAM,GAAG,KAAK,SAAL,CAAe,KAAf,CAAf;;AACA,YAAI,CAAC,KAAK,QAAL,CAAc,gBAAf,IAAmC,CAAC,KAAK,QAAL,CAAc,WAAlD,IACA,MAAM,CAAC,SADP,IACoB,MAAM,CAAC,SAAP,GAAmB,CAD3C,EAC8C;AAC5C,eAAK,eAAL,CAAqB,MAAM,CAAC,SAA5B;AACD;;AACD,QAAA,WAAW,GAAI,OAAO,MAAP,KAAkB,WAAlB,IAAiC,MAAM,CAAC,MAAzC,GACV,MAAM,CAAC,MADG,GACM,gBAAgB,CAAC,WADrC;AAGA,aAAK,MAAL,CAAY,YAAZ,EAA0B,aAA1B,EAAyC,cAAc,WAAvD,EACI,gBAAgB,CAAC,eADrB;AAGA,YAAI,eAAJ,EAAqB,KAAK,aAAL,GAAqB,CAArB;AAErB,aAAK,gBAAL,CAAsB,YAAtB;AACD;;AAED,WAAK,MAAL,CAAY,YAAZ,EAA0B,IAA1B,EAAgC,eAAe,WAA/C,EACI,gBAAgB,CAAC,cADrB;AAEA,WAAK,eAAL,CAAqB,WAArB;AAEA,aAAO,WAAP;AACD;AAED;AACF;AACA;AACA;AACA;;;;WACE,sBAAa,YAAb,EAAmC;AACjC,UAAM,WAAW,GAAG,MAAM,CAAC,KAAK,aAAN,CAA1B;AAEA,WAAK,gBAAL,CAAsB,YAAtB;AAEA,WAAK,MAAL,CAAY,YAAZ,EAA0B,IAA1B,EAAgC,eAAe,WAA/C,EACI,gBAAgB,CAAC,cADrB;AAGA,aAAO,WAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;;;;WACE,wBAAe,YAAf,EAAqC,YAArC,EAAmD;AACjD,UAAI,WAAW,GAAG,EAAlB;;AAEA,UAAI,YAAY,KAAK,IAAjB,IAAyB,YAAY,KAAK,EAA9C,EAAkD;AAChD,QAAA,WAAW,GAAG,KAAK,yBAAL,CAA+B,YAA/B,CAAd;AACA,aAAK,gBAAL,CAAsB,YAAtB;AACD;;AAED,WAAK,MAAL,CAAY,YAAZ,EAA0B,IAA1B,EAAgC,eAAe,WAA/C,EACI,gBAAgB,CAAC,cADrB;AAGA,aAAO,WAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;;;;WACE,uBAAc,YAAd,EAAoC,YAApC,EAAkD;AAChD,UAAI,WAAW,GAAG,EAAlB;;AAEA,UAAI,YAAY,KAAK,IAAjB,IAAyB,YAAY,KAAK,EAA9C,EAAkD;AAChD,QAAA,WAAW,GAAG,KAAK,yBAAL,CAA+B,YAA/B,EAA6C,IAA7C,CAAd;AACA,aAAK,gBAAL,CAAsB,YAAtB;AACD;;AAED,WAAK,MAAL,CAAY,YAAZ,EAA0B,IAA1B,EAAgC,eAAe,WAA/C,EACI,gBAAgB,CAAC,cADrB;AAGA,aAAO,WAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,oBACI,eADJ,EAEI,eAFJ,EAGI,cAHJ,EAG6B;AAC3B,UAAI,KAAK,gBAAL,EAAJ,EAA6B;AAC3B,aAAK,eAAL,CAAqB,eAArB;AACA,eAAO,KAAP;AACD,OAHD,MAGO,IAAI,eAAe,IAAI,KAAK,YAAL,EAAvB,EAA4C;AACjD,aAAK,eAAL,CAAqB,cAArB;AACA,eAAO,KAAP;AACD;;AAED,aAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,gBACI,YADJ,EAEI,UAFJ,EAGI,UAHJ,EAII,YAJJ,EAI0B;AACxB,MAAA,UAAU,GAAG,KAAK,aAAL,CAAmB,YAAnB,EAAiC,UAAjC,EAA6C,UAA7C,CAAb;;AAEA,UAAI,YAAY,IAAI,KAAK,WAAzB,EAAsC;AACpC,gBAAQ,YAAR;AACE,eAAK,gBAAgB,CAAC,eAAtB;AACE,YAAA,OAAO,CAAC,KAAR,CAAc,UAAd;AACA;;AACF,eAAK,gBAAgB,CAAC,iBAAtB;AACE,YAAA,OAAO,CAAC,IAAR,CAAa,UAAb;AACA;;AACF,eAAK,gBAAgB,CAAC,cAAtB;AACE,YAAA,OAAO,CAAC,IAAR,CAAa,UAAb;AACA;;AACF,eAAK,gBAAgB,CAAC,eAAtB;AACE,gBAAI,OAAO,CAAC,KAAZ,EAAmB;AACjB,cAAA,OAAO,CAAC,KAAR,CAAc,UAAd;AACD,aAFD,MAEO;AACL,cAAA,OAAO,CAAC,GAAR,CAAY,UAAZ;AACD;;AACD;AAhBJ;AAkBD;AACF;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,uBAAc,YAAd,EAAoC,UAApC,EAAwD,OAAxD,EAAyE;AACvE,UAAM,UAAU,GAAG,EAAnB;AACA,UAAI,aAAa,GAAG,EAApB;AAEA,MAAA,aAAa,IAAI,YAAjB;AAEA,UAAI,SAAS,GAAG,UAAU,GAAG,aAAa,CAAC,MAA3C;;AAEA,WAAK,IAAI,CAAC,GAAG,CAAb,EAAgB,CAAC,GAAG,SAApB,EAA+B,CAAC,EAAhC,EAAoC;AAClC,QAAA,aAAa,IAAI,GAAjB;AACD;;AAED,MAAA,aAAa,IAAI,IAAjB;;AAEA,UAAI,UAAJ,EAAgB;AACd,YAAM,oBAAoB,GAAG,EAA7B;AAEA,QAAA,aAAa,IAAI,UAAjB;AAEA,QAAA,SAAS,GAAG,oBAAoB,GAAG,aAAa,CAAC,MAAjD;;AAEA,aAAK,IAAI,CAAC,GAAG,CAAb,EAAgB,CAAC,GAAG,SAApB,EAA+B,CAAC,EAAhC,EAAoC;AAClC,UAAA,aAAa,IAAI,GAAjB;AACD;AACF;;AAED,UAAI,OAAJ,EAAa;AACX,QAAA,aAAa,IAAI,OAAjB;AACD;;AAED,aAAO,aAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;;;;WACE,uBAAc,GAAd,EAA2B,MAA3B,EAA2C;AACzC,aAAO,GAAG,IAAI,MAAP,IAAiB,GAAG,CAAC,KAAJ,CAAU,MAAV,CAAxB;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;;;;WACE,iCAAwB,SAAxB,EAAmC,SAAnC,EAAsD;AACpD,aAAO,MAAM,CAAC,cAAP,CAAsB,IAAtB,CAA2B,SAA3B,EAAsC,SAAtC,KACH,MAAM,CAAC,wBAAP,CACI,MAAM,CAAC,cAAP,CAAsB,SAAtB,CADJ,EACsC,SADtC,CADG,IAGF,SAAS,IAAI,SAHlB;AAID;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,mCAA0B,YAA1B,EAAwC,OAAxC,EAAiD;AAC/C,YAAM,IAAI,KAAJ,CACF,+DADE,CAAN;AAED;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,qBAAY,WAAZ,EAAyB;AACvB,YAAM,IAAI,KAAJ,CAAU,iDAAV,CAAN;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,qBAAY,WAAZ,EAAyB,MAAzB,EAAiC;AAC/B,YAAM,IAAI,KAAJ,CAAU,iDAAV,CAAN;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,4BACI,UADJ,EACwB,SADxB,EAC4C,UAD5C,EACwD,KADxD,EAC+D;AAC7D,UAAI,CAAC,UAAD,IAAe,UAAU,KAAK,EAAlC,EAAsC;AACpC,eAAO,gBAAgB,CAAC,WAAxB;AACD;;AAED,UAAM,SAAS,GAAG,UAAU,CAAC,KAAX,CAAiB,GAAjB,CAAlB;AACA,UAAI,SAAS,GAAG,IAAhB;AACA,UAAI,WAAW,GAAG,gBAAgB,CAAC,WAAnC;AACA,UAAI,eAAe,GAAG,KAAtB;AAEA,UAAM,mBAAmB,8CAAuC,UAAvC,eAAsD,UAAtD,+CAAzB;AACA,UAAM,gBAAgB,GAAG,SAAS,GAC9B,0CAAkB,oBADY,GAE9B,0CAAkB,OAFtB;;AAIA,WAAK,IAAI,CAAC,GAAG,CAAb,EAAgB,CAAC,GAAG,SAAS,CAAC,MAA9B,EAAsC,CAAC,EAAvC,EAA2C;AACzC,YAAM,SAAS,GAAG,SAAS,CAAC,CAAD,CAA3B;;AAEA,YAAI,CAAC,KAAK,SAAS,CAAC,MAAV,GAAmB,CAA7B,EAAgC;AAC9B,cAAI,SAAS,IAAK,SAAS,CAAC,MAAV,CAAiB,CAAjB,EAAoB,CAApB,MAA2B,UAAzC,IACC,OAAO,SAAS,CAAC,cAAjB,IAAmC,UADxC,EACqD;AACnD,iBAAK,eAAL,CAAqB,0CAAkB,iBAAvC;AACD,WAHD,MAGO,IAAI,CAAC,KAAK,uBAAL,CAA6B,SAA7B,EAAwC,SAAxC,CAAL,EAAyD;AAC9D,iBAAK,eAAL,CAAqB,gBAArB,EAAuC,mBAAvC;AACD,WAFM,MAEA;AACL,gBAAI,KAAK,aAAL,MACA,KAAK,aAAL,CAAmB,UAAnB,EAA+B,6BAA/B,CADJ,EACmE;AACjE,mBAAK,uBAAL,CAA6B,UAA7B,EAAyC,KAAzC;AACD;;AAED,gBAAI,CAAC,SAAD,IAAc,KAAK,aAAL,KAAuB,CAAzC,EAA4C;AAC1C,cAAA,SAAS,CAAC,SAAD,CAAT,GAAuB,KAAvB;AACA,cAAA,WAAW,GAAG,gBAAgB,CAAC,UAA/B;AACD;AACF;AACF,SAjBD,MAiBO;AACL,UAAA,SAAS,GAAG,SAAS,CAAC,SAAD,CAArB;;AACA,cAAI,CAAC,SAAL,EAAgB;AACd,iBAAK,eAAL,CAAqB,gBAArB,EAAuC,mBAAvC;AACA;AACD;;AAED,cAAI,SAAS,YAAY,gBAAzB,EAAmC;AACjC,gBAAM,KAAK,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC,GAAG,CAAL,CAAV,EAAmB,EAAnB,CAAtB,CADiC,CAGjC;;AACA,gBAAI,CAAC,KAAK,CAAC,KAAD,CAAV,EAAmB;AACjB,kBAAM,IAAI,GAAG,SAAS,CAAC,UAAV,CAAqB,KAArB,CAAb;;AAEA,kBAAI,IAAJ,EAAU;AACR,gBAAA,SAAS,GAAG,IAAZ;AACA,gBAAA,eAAe,GAAG,IAAlB;AACD,eAHD,MAGO;AACL,oBAAM,QAAQ,GAAG,KAAK,eAAL,CAAqB,UAArB,EAAiC,KAAjC,EACb,eADa,CAAjB;AAEA,gBAAA,eAAe,GAAG,IAAlB;;AAEA,oBAAI,CAAC,QAAL,EAAe;AACb,uBAAK,eAAL,CAAqB,gBAArB,EAAuC,mBAAvC;AACD,iBAFD,MAEO;AACL,sBAAI,SAAS,CAAC,WAAd,EAA2B,QAAQ,CAAC,UAAT;AAE3B,kBAAA,SAAS,CAAC,UAAV,CAAqB,IAArB,CAA0B,QAA1B;AACA,kBAAA,SAAS,GAAG,QAAZ;AACD;AACF,eAnBgB,CAqBjB;;;AACA,cAAA,CAAC;AACF;AACF;AACF;AACF;;AAED,UAAI,WAAW,KAAK,gBAAgB,CAAC,WAArC,EAAkD;AAChD,aAAK,MAAL,CAAY,UAAZ,EAAwB,IAAxB,sDACiD,UADjD,yBAC0E,KAD1E,GAEI,gBAAgB,CAAC,iBAFrB;AAGD;;AAED,aAAO,WAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,iCAAwB,WAAxB,EAAqC,MAArC,EAA6C,CAC3C;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,yBAAgB,WAAhB,EAA6B,MAA7B,EAAqC,gBAArC,EAAuD;AACrD,YAAM,IAAI,KAAJ,CAAU,qDAAV,CAAN;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,4BAAmB,UAAnB,EAAuC,SAAvC,EAA2D,UAA3D,EAAuE;AACrE,UAAI,CAAC,UAAD,IAAe,UAAU,KAAK,EAAlC,EAAsC;AACpC,eAAO,EAAP;AACD;;AAED,UAAM,SAAS,GAAG,UAAU,CAAC,KAAX,CAAiB,GAAjB,CAAlB;AACA,UAAI,SAAS,GAAG,IAAhB;AACA,UAAI,SAAS,GAAG,IAAhB;AAEA,UAAM,yBAAyB,8CAAuC,UAAvC,eAAsD,UAAtD,gCAA/B;AACA,UAAM,mBAAmB,8CAAuC,UAAvC,eAAsD,UAAtD,+CAAzB;AACA,UAAM,gBAAgB,GAAG,SAAS,GAC9B,0CAAkB,oBADY,GAE9B,0CAAkB,OAFtB;;AAIA,WAAK,IAAI,CAAC,GAAG,CAAb,EAAgB,CAAC,GAAG,SAAS,CAAC,MAA9B,EAAsC,CAAC,EAAvC,EAA2C;AACzC,QAAA,SAAS,GAAG,SAAS,CAAC,CAAD,CAArB;;AAEA,YAAI,CAAC,SAAL,EAAgB;AACd,cAAI,CAAC,KAAK,SAAS,CAAC,MAAV,GAAmB,CAA7B,EAAgC;AAC9B,gBAAI,CAAC,KAAK,uBAAL,CAA6B,SAA7B,EAAwC,SAAxC,CAAL,EAAyD;AACvD,mBAAK,eAAL,CAAqB,gBAArB,EAAuC,mBAAvC;AACA;AACD;AACF;AACF,SAPD,MAOO;AACL,cAAK,MAAM,CAAC,SAAD,CAAN,CAAkB,MAAlB,CAAyB,CAAzB,EAA4B,CAA5B,MAAmC,UAApC,IACC,OAAO,SAAS,CAAC,cAAjB,IAAmC,UADxC,EACqD;AACnD,gBAAM,MAAM,GAAG,MAAM,CAAC,SAAD,CAAN,CACX,MADW,CACJ,CADI,EACD,MAAM,CAAC,SAAD,CAAN,CAAkB,MAAlB,GAA2B,CAD1B,CAAf;AAEA,mBAAO,SAAS,CAAC,cAAV,CAAyB,MAAzB,CAAP;AACD,WALD,MAKO,IAAI,CAAC,KAAK,uBAAL,CAA6B,SAA7B,EAAwC,SAAxC,CAAL,EAAyD;AAC9D,iBAAK,eAAL,CAAqB,gBAArB,EAAuC,mBAAvC;AACA;AACD;AACF;;AAED,QAAA,SAAS,GAAG,SAAS,CAAC,SAAD,CAArB;;AACA,YAAI,SAAS,KAAK,SAAlB,EAA6B;AAC3B,eAAK,eAAL,CAAqB,gBAArB,EAAuC,mBAAvC;AACA;AACD;;AAED,YAAI,SAAS,YAAY,gBAAzB,EAAmC;AACjC,cAAM,KAAK,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC,GAAG,CAAL,CAAV,EAAmB,EAAnB,CAAtB,CADiC,CAGjC;;AACA,cAAI,CAAC,KAAK,CAAC,KAAD,CAAV,EAAmB;AACjB,gBAAM,IAAI,GAAG,SAAS,CAAC,UAAV,CAAqB,KAArB,CAAb;;AAEA,gBAAI,IAAJ,EAAU;AACR,cAAA,SAAS,GAAG,IAAZ;AACD,aAFD,MAEO;AACL,mBAAK,eAAL,CAAqB,0CAAkB,qBAAvC,EACI,yBADJ;AAEA;AACD,aATgB,CAWjB;;;AACA,YAAA,CAAC;AACF;AACF;AACF;;AAED,UAAI,SAAS,KAAK,IAAd,IAAsB,SAAS,KAAK,SAAxC,EAAmD;AACjD,YAAI,CAAC,SAAL,EAAgB;AACd,cAAI,SAAS,KAAK,WAAlB,EAA+B;AAC7B,iBAAK,eAAL,CAAqB,mBAAmB,CAAC,cAAzC;AACD,WAFD,MAEO,IAAI,SAAS,KAAK,QAAlB,EAA4B;AACjC,iBAAK,eAAL,CAAqB,mBAAmB,CAAC,WAAzC;AACD;AACF;AACF,OARD,MAQO;AACL,eAAO,SAAP;AACD;AACF;AAED;AACF;AACA;AACA;AACA;;;;WACE,yBAAgB;AACd,aAAO,KAAK,YAAL,KAAsB,gBAAgB,CAAC,iBAA9C;AACD;AAED;AACF;AACA;AACA;AACA;;;;WACE,4BAAmB;AACjB,aAAO,KAAK,YAAL,KAAsB,gBAAgB,CAAC,qBAA9C;AACD;AAED;AACF;AACA;AACA;AACA;;;;WACE,wBAAe;AACb,aAAO,KAAK,YAAL,KAAsB,gBAAgB,CAAC,gBAA9C;AACD;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,YAAG,YAAH,EAAyB,QAAzB,EAA6C;AAC3C,UAAI,CAAC,QAAL,EAAe;AAEf,UAAM,iBAAiB,GAAG,YAAY,CAAC,KAAb,CAAmB,GAAnB,CAA1B;;AACA,WAAK,IAAI,CAAC,GAAG,CAAb,EAAgB,CAAC,GAAG,iBAAiB,CAAC,MAAtC,EAA8C,CAAC,EAA/C,EAAmD;AACjD,YAAM,aAAa,GAAG,iBAAiB,CAAC,CAAD,CAAjB,CAAqB,KAArB,CAA2B,GAA3B,CAAtB;AACA,YAAI,aAAa,CAAC,MAAd,KAAyB,CAA7B,EAAgC;AAEhC,YAAM,YAAY,GAAG,aAAa,CAAC,CAAD,CAAlC;AAEA,YAAI,UAAU,GAAG,IAAjB;;AACA,YAAI,aAAa,CAAC,MAAd,GAAuB,CAA3B,EAA8B;AAC5B,UAAA,UAAU,GAAG,YAAY,CAAC,OAAb,CAAqB,YAAY,GAAG,GAApC,EAAyC,EAAzC,CAAb;AACD;;AAED,aAAK,aAAL,CAAmB,IAAnB,CAAwB;AACtB,UAAA,YAAY,EAAE,YADQ;AAEtB,UAAA,UAAU,EAAE,UAFU;AAGtB,UAAA,QAAQ,EAAE;AAHY,SAAxB;AAMA,aAAK,MAAL,CAAY,IAAZ,EAAkB,YAAlB,kCAAyD,KAAK,aAAL,CAAmB,MAA5E,GAAsF,gBAAgB,CAAC,cAAvG;AACD;AACF;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,aAAI,YAAJ,EAA0B,QAA1B,EAA8C;AAAA;;AAC5C,UAAI,CAAC,QAAL,EAAe;AAEf,UAAM,iBAAiB,GAAG,YAAY,CAAC,KAAb,CAAmB,GAAnB,CAA1B;;AAH4C,iCAInC,CAJmC;AAK1C,YAAM,aAAa,GAAG,iBAAiB,CAAC,CAAD,CAAjB,CAAqB,KAArB,CAA2B,GAA3B,CAAtB;AACA,YAAI,aAAa,CAAC,MAAd,KAAyB,CAA7B,EAAgC;AAAA;AAAA;AAEhC,YAAM,YAAY,GAAG,aAAa,CAAC,CAAD,CAAlC;AAEA,YAAI,UAAU,GAAG,IAAjB;;AACA,YAAI,aAAa,CAAC,MAAd,GAAuB,CAA3B,EAA8B;AAC5B,UAAA,UAAU,GAAG,YAAY,CAAC,OAAb,CAAqB,YAAY,GAAG,GAApC,EAAyC,EAAzC,CAAb;AACD;;AAED,YAAM,WAAW,GAAG,KAAI,CAAC,aAAL,CAAmB,SAAnB,CAA6B,UAAC,GAAD;AAAA,iBAC/C,GAAG,CAAC,YAAJ,KAAqB,YAArB,IACA,GAAG,CAAC,UAAJ,KAAmB,UADnB,IAEA,GAAG,CAAC,QAAJ,KAAiB,QAH8B;AAAA,SAA7B,CAApB;;AAKA,YAAI,WAAW,KAAK,CAAC,CAArB,EAAwB;AACtB,UAAA,KAAI,CAAC,aAAL,CAAmB,MAAnB,CAA0B,WAA1B,EAAuC,CAAvC;;AACA,UAAA,KAAI,CAAC,MAAL,CAAY,KAAZ,EAAmB,YAAnB,oCAA4D,KAAI,CAAC,aAAL,CAAmB,MAA/E,GAAyF,gBAAgB,CAAC,cAA1G;AACD;AAvByC;;AAI5C,WAAK,IAAI,CAAC,GAAG,CAAb,EAAgB,CAAC,GAAG,iBAAiB,CAAC,MAAtC,EAA8C,CAAC,EAA/C,EAAmD;AAAA,yBAA1C,CAA0C;;AAAA;AAoBlD;AACF;AAED;AACF;AACA;AACA;AACA;;;;WACE,eAAM,YAAN,EAA4B;AAAA;;AAC1B,UAAM,iBAAiB,GAAG,YAAY,CAAC,KAAb,CAAmB,GAAnB,CAA1B;;AAD0B,mCAEjB,CAFiB;AAGxB,YAAM,aAAa,GAAG,iBAAiB,CAAC,CAAD,CAAjB,CAAqB,KAArB,CAA2B,GAA3B,CAAtB;AACA,YAAI,aAAa,CAAC,MAAd,KAAyB,CAA7B,EAAgC;AAAA;AAAA;AAEhC,YAAM,YAAY,GAAG,aAAa,CAAC,CAAD,CAAlC;AAEA,YAAI,UAAU,GAAG,IAAjB;;AACA,YAAI,aAAa,CAAC,MAAd,GAAuB,CAA3B,EAA8B;AAC5B,UAAA,UAAU,GAAG,YAAY,CAAC,OAAb,CAAqB,YAAY,GAAG,GAApC,EAAyC,EAAzC,CAAb;AACD;;AAED,QAAA,MAAI,CAAC,aAAL,GAAqB,MAAI,CAAC,aAAL,CAAmB,MAAnB,CAA0B,UAAC,GAAD;AAAA,iBAC7C,GAAG,CAAC,YAAJ,KAAqB,YAArB,IACA,GAAG,CAAC,UAAJ,KAAmB,UAF0B;AAAA,SAA1B,CAArB;AAbwB;;AAE1B,WAAK,IAAI,CAAC,GAAG,CAAb,EAAgB,CAAC,GAAG,iBAAiB,CAAC,MAAtC,EAA8C,CAAC,EAA/C,EAAmD;AAAA,2BAA1C,CAA0C;;AAAA;AAelD;AACF;AAED;AACF;AACA;AACA;AACA;AACA;AACA;;;;WACE,0BAAiB,YAAjB,EAAuC,UAAvC,EAA2D,KAA3D,EAAuE;AACrE,WAAK,MAAL,CAAY,YAAZ,EAA0B,UAA1B,EAAsC,KAAtC;;AACA,WAAK,IAAI,CAAC,GAAG,CAAb,EAAgB,CAAC,GAAG,KAAK,aAAL,CAAmB,MAAvC,EAA+C,CAAC,EAAhD,EAAoD;AAClD,YAAM,QAAQ,GAAG,KAAK,aAAL,CAAmB,CAAnB,CAAjB;AACA,YAAM,cAAc,GAAG,QAAQ,CAAC,YAAT,KAA0B,YAAjD;AACA,YAAM,qBAAqB,GAAG,CAAC,CAAC,QAAQ,CAAC,UAAzC;AACA,YAAI,gBAAgB,GAAG,KAAvB;;AACA,YAAI,UAAU,IAAI,QAAQ,CAAC,UAAvB,IACA,QAAQ,CAAC,UAAT,CAAoB,SAApB,CAA8B,QAAQ,CAAC,UAAT,CAAoB,MAApB,GAA6B,CAA3D,MACA,GAFJ,EAES;AACP,UAAA,gBAAgB,GAAG,UAAU,CAAC,OAAX,CAAmB,QAAQ,CAAC,UAAT,CAAoB,SAApB,CAA8B,CAA9B,EAClC,QAAQ,CAAC,UAAT,CAAoB,MAApB,GAA6B,CADK,CAAnB,MACsB,CADzC;AAED,SALD,MAKO;AACL,UAAA,gBAAgB,GAAG,QAAQ,CAAC,UAAT,KAAwB,UAA3C;AACD;;AAED,YAAI,cAAc,KAAK,CAAC,qBAAD,IAA0B,gBAA/B,CAAlB,EAAoE;AAClE,UAAA,QAAQ,CAAC,QAAT,CAAkB,UAAlB,EAA8B,KAA9B;AACD;AACF;AACF;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,yBAAgB,WAAhB,EAAqC,OAArC,EAAsD;AACpD,UAAI,CAAC,OAAL,EAAc;AACZ,QAAA,OAAO,GAAG,KAAK,yBAAL,CAA+B,WAA/B,CAAV;AACD;;AAED,WAAK,MAAL,CAAY,iBAAZ,EAA+B,IAA/B,EAAqC,WAAW,GAAG,IAAd,GAAqB,OAA1D,EACI,gBAAgB,CAAC,eADrB;AAGA,WAAK,aAAL,GAAqB,MAAM,CAAC,WAAD,CAA3B;AACD;AAED;AACF;AACA;AACA;AACA;;;;WACE,yBAAgB,OAAhB,EAAiC;AAC/B,UAAI,OAAO,KAAK,SAAZ,IAAyB,OAAO,KAAK,gBAAgB,CAAC,WAA1D,EAAuE;AACrE,aAAK,aAAL,GAAqB,CAArB;AACD;AACF;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,mBAAU,mBAAV,EAA+B;AAC7B,YAAM,IAAI,KAAJ,CACF,+CADE,CAAN;AAED;AAED;AACF;AACA;AACA;AACA;;;;WACE,+BAAsB,IAAtB,EAA4B,UAA5B,EAAwC;AAAA;;AACtC,UAAI,CAAC,KAAK,gBAAL,EAAL,EAA8B;AAC5B,QAAA,OAAO,CAAC,KAAR,CACI,4EADJ;AAEA;AACD;AAED;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;;;AACI,eAAS,WAAT,CAAqB,CAArB,EAAwB,CAAxB,EAA2B,SAA3B,EAAsC;AACpC,YAAM,OAAO,GAAG,CAAC,CAAC,KAAF,CAAQ,SAAR,CAAhB;AAEA,YAAI,OAAJ;;AACA,YAAI,OAAO,KAAK,IAAZ,IAAoB,CAAC,OAAO,GAAG,CAAC,CAAC,KAAF,CAAQ,SAAR,CAAX,MAAmC,IAA3D,EAAiE;AAC/D,cAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,CAAD,CAAR,CAApB;AACA,cAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,CAAD,CAAR,CAApB;;AACA,cAAI,KAAK,KAAK,KAAd,EAAqB;AACnB,gBAAI,OAAO,CAAC,CAAD,CAAP,KAAe,IAAnB,EAAyB;AACvB,qBAAO,CAAC,CAAR;AACD,aAFD,MAEO,IAAI,OAAO,CAAC,CAAD,CAAP,KAAe,MAAnB,EAA2B;AAChC,kBAAI,OAAO,CAAC,CAAD,CAAP,KAAe,IAAnB,EAAyB;AACvB,uBAAO,CAAP;AACD,eAFD,MAEO;AACL,uBAAO,CAAC,CAAR;AACD;AACF,aANM,MAMA;AACL,qBAAO,CAAP;AACD;AACF;;AACD,iBAAO,KAAK,GAAG,KAAf;AACD;;AAED,eAAO,IAAP;AACD;;AAED,UAAM,WAAW,GAAG,oCAApB;AACA,UAAM,WAAW,GAAG,kCAApB;AAEA,UAAM,MAAM,GAAG,MAAM,CAAC,IAAP,CAAY,IAAZ,EAAkB,GAAlB,CAAsB,UAAS,GAAT,EAAc;AACjD,eAAO,CAAC,MAAM,CAAC,GAAD,CAAP,EAAc,IAAI,CAAC,GAAD,CAAlB,CAAP;AACD,OAFc,CAAf,CA5CsC,CAgDtC;;AACA,MAAA,MAAM,CAAC,IAAP,CAAY,uBAAyB;AAAA;AAAA,YAAf,CAAe;AAAA,YAAZ,CAAY;;AAAA;AAAA,YAAP,CAAO;AAAA,YAAJ,CAAI;;AACnC,YAAI,IAAJ;;AACA,YAAI,CAAC,IAAI,GAAG,WAAW,CAAC,CAAD,EAAI,CAAJ,EAAO,WAAP,CAAnB,MAA4C,IAAhD,EAAsD;AACpD,iBAAO,IAAP;AACD;;AACD,YAAI,CAAC,IAAI,GAAG,WAAW,CAAC,CAAD,EAAI,CAAJ,EAAO,WAAP,CAAnB,MAA4C,IAAhD,EAAsD;AACpD,iBAAO,IAAP;AACD;;AAED,YAAI,CAAC,GAAG,CAAR,EAAW;AACT,iBAAO,CAAC,CAAR;AACD;;AACD,YAAI,CAAC,GAAG,CAAR,EAAW;AACT,iBAAO,CAAP;AACD;;AACD,eAAO,CAAP;AACD,OAhBD;AAkBA,UAAI,GAAJ;AACA,MAAA,MAAM,CAAC,OAAP,CAAe,UAAC,OAAD,EAAa;AAC1B,QAAA,GAAG,GAAG,EAAN;AACA,QAAA,GAAG,CAAC,OAAO,CAAC,CAAD,CAAR,CAAH,GAAkB,OAAO,CAAC,CAAD,CAAzB;;AACA,QAAA,MAAI,CAAC,YAAL,CAAkB,0BAAU,GAAV,CAAlB,EAAkC,UAAlC;AACD,OAJD;AAKD;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,sBAAa,IAAb,EAAmB,UAAnB,EAA+B;AAC7B,UAAI,CAAC,KAAK,gBAAL,EAAL,EAA8B;AAC5B,QAAA,OAAO,CAAC,KAAR,CACI,mEADJ;AAEA;AACD;;AAED,MAAA,UAAU,GAAG,UAAU,KAAK,SAAf,GAA2B,UAA3B,GAAwC,KAArD;AAEA,WAAK,YAAL,GAAoB,IAApB,CAT6B,CAW7B;;AACA,WAAK,IAAM,GAAX,IAAkB,IAAlB,EAAwB;AACtB,YAAI,GAAG,cAAH,CAAkB,IAAlB,CAAuB,IAAvB,EAA6B,GAA7B,KAAqC,IAAI,CAAC,GAAD,CAA7C,EAAoD;AAClD,cAAM,iBAAiB,GAAG,CAAC,UAAU,GAAG,UAAU,GAAG,GAAhB,GAAsB,EAAjC,IAAuC,GAAjE;AACA,cAAM,KAAK,GAAG,IAAI,CAAC,GAAD,CAAlB;;AAEA,cAAI,KAAK,CAAC,YAAD,CAAT,EAAyB;AACvB,iBAAK,IAAI,CAAC,GAAG,CAAb,EAAgB,CAAC,GAAG,KAAK,CAAC,YAAD,CAAL,CAAoB,MAAxC,EAAgD,CAAC,EAAjD,EAAqD;AACnD,mBAAK,YAAL,CAAkB,KAAK,CAAC,YAAD,CAAL,CAAoB,CAApB,CAAlB,EACI,iBAAiB,GAAG,GAApB,GAA0B,CAD9B;AAED;AACF,WALD,MAKO,IAAI,KAAK,CAAC,WAAN,KAAsB,MAA1B,EAAkC;AACvC,iBAAK,YAAL,CAAkB,KAAlB,EAAyB,iBAAzB;AACD,WAFM,MAEA;AACL,iBAAK,WAAL,CAAiB,iBAAjB,EAAoC,KAApC;AACD;AACF;AACF;AACF;AAED;AACF;AACA;AACA;AACA;;;;WACE,iCAAwB;AACtB,UAAM,GAAG,GAAG,KAAK,GAAjB,CADsB,CAEtB;AACA;;AACA,aAAO,IAAI,CAAC,SAAL,CAAe;AAAC,QAAA,GAAG,EAAH;AAAD,OAAf,CAAP;AACD;AAED;AACF;AACA;AACA;;;;WACE,iCAAwB;AACtB;AACA;AACA,aAAO,IAAI,CAAC,KAAL,CAAW,KAAK,qBAAL,EAAX,CAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,yBAAgB,gBAAhB,EAAkC;AAChC,YAAM,IAAI,KAAJ,CACF,+CADE,CAAN;AAED;AAED;AACF;AACA;AACA;AACA;AACA;AACA;;;;WACE,4BAAmB,GAAnB,EAAgC,MAAhC,EAA2D;AAAA,UAAnB,SAAmB,uEAAP,KAAO;AACzD,UAAM,GAAG,GAAG,IAAZ;;AACA,UAAM,OAAO,GAAG,SAAV,OAAU,CAAS,GAAT,EAAc,MAAd,EAAsB,QAAtB,EAAgC,WAAhC,EAA6C;AAC3D,YAAM,YAAY,GAAG;AACnB,oBAAU,gBAAgB,CAAC,WADR;AAEnB,uBAAa,WAAW,CAAC;AAFN,SAArB;AAKA,YAAI,MAAJ;;AACA,YAAI,CAAC,QAAQ,CAAC,gBAAd,EAAgC;AAC9B,cAAM,OAAO,GAAG,IAAI,cAAJ,EAAhB;AACA,UAAA,OAAO,CAAC,IAAR,CAAa,MAAb,EAAqB,GAArB,EAA0B,QAAQ,CAAC,WAAnC;;AACA,cAAI,QAAQ,CAAC,WAAb,EAA0B;AACxB,YAAA,OAAO,CAAC,MAAR,GAAiB,UAAS,CAAT,EAAY;AAC3B,kBAAI,OAAO,QAAQ,CAAC,eAAhB,KAAoC,UAAxC,EAAoD;AAClD,gBAAA,MAAM,GAAG,QAAQ,CAAC,eAAT,CAAyB,OAAzB,CAAT;AACD,eAFD,MAEO;AACL,gBAAA,MAAM,GAAG,IAAI,CAAC,KAAL,CAAW,OAAO,CAAC,YAAnB,CAAT;AACD;AACF,aAND;AAOD;;AACD,cAAI;AACF,gBAAI,MAAM,YAAY,KAAtB,EAA6B;AAC3B,cAAA,OAAO,CAAC,gBAAR,CAAyB,cAAzB,EACI,mCADJ;AAEA,cAAA,OAAO,CAAC,IAAR,CAAa,MAAM,CAAC,IAAP,CAAY,GAAZ,CAAb;AACD,aAJD,MAIO;AACL,cAAA,OAAO,CAAC,gBAAR,CAAyB,cAAzB,EACI,QAAQ,CAAC,qBADb;AAEA,cAAA,OAAO,CAAC,IAAR,CAAa,IAAI,CAAC,SAAL,CAAe,MAAf,CAAb;AACD;;AAED,gBAAI,CAAC,QAAQ,CAAC,WAAd,EAA2B;AACzB,kBAAI,OAAO,QAAQ,CAAC,eAAhB,KAAoC,UAAxC,EAAoD;AAClD,gBAAA,MAAM,GAAG,QAAQ,CAAC,eAAT,CAAyB,OAAzB,CAAT;AACD,eAFD,MAEO;AACL,gBAAA,MAAM,GAAG,IAAI,CAAC,KAAL,CAAW,OAAO,CAAC,YAAnB,CAAT;AACD;AACF,aAND,MAMO;AACL,cAAA,MAAM,GAAG,EAAT;AACA,cAAA,MAAM,CAAC,MAAP,GAAgB,gBAAgB,CAAC,UAAjC;AACA,cAAA,MAAM,CAAC,SAAP,GAAmB,CAAnB;AACA,cAAA,GAAG,CAAC,gBAAJ,CAAqB,eAArB;AACA,qBAAO,MAAP;AACD;AACF,WAxBD,CAwBE,OAAO,CAAP,EAAU;AACV,YAAA,OAAO,CAAC,KAAR,CAAc,CAAd;AACA,YAAA,GAAG,CAAC,gBAAJ,CAAqB,aAArB;AACA,mBAAO,YAAP;AACD;AACF,SAzCD,MAyCO;AACL,cAAI;AACF,gBAAM,OAAO,GAAG;AACd,cAAA,IAAI,EAAE,QAAQ,CAAC;AADD,aAAhB;AAGA,gBAAI,IAAJ;;AACA,gBAAI,MAAM,YAAY,KAAtB,EAA6B;AAC3B,cAAA,IAAI,GAAG,IAAI,IAAJ,CAAS,CAAC,MAAM,CAAC,IAAP,CAAY,GAAZ,CAAD,CAAT,EAA6B,OAA7B,CAAP;AACD,aAFD,MAEO;AACL,cAAA,IAAI,GAAG,IAAI,IAAJ,CAAS,CAAC,IAAI,CAAC,SAAL,CAAe,MAAf,CAAD,CAAT,EAAmC,OAAnC,CAAP;AACD;;AAED,YAAA,MAAM,GAAG,EAAT;;AACA,gBAAI,SAAS,CAAC,UAAV,CAAqB,GAArB,EAA0B,IAA1B,CAAJ,EAAqC;AACnC,cAAA,MAAM,CAAC,MAAP,GAAgB,gBAAgB,CAAC,UAAjC;AACA,cAAA,MAAM,CAAC,SAAP,GAAmB,CAAnB;AACD,aAHD,MAGO;AACL,cAAA,MAAM,CAAC,MAAP,GAAgB,gBAAgB,CAAC,WAAjC;AACA,cAAA,MAAM,CAAC,SAAP,GAAmB,GAAnB;AACD;AACF,WAnBD,CAmBE,OAAO,CAAP,EAAU;AACV,YAAA,OAAO,CAAC,KAAR,CAAc,CAAd;AACA,YAAA,GAAG,CAAC,gBAAJ,CAAqB,aAArB;AACA,mBAAO,YAAP;AACD;AACF;;AAED,YAAI,OAAO,MAAP,KAAkB,WAAtB,EAAmC;AACjC,UAAA,GAAG,CAAC,gBAAJ,CAAqB,aAArB;AACA,iBAAO,YAAP;AACD;;AAED,YAAI,MAAM,CAAC,MAAP,KAAkB,IAAlB,IACA,MAAM,CAAC,MAAP,KAAkB,gBAAgB,CAAC,UADvC,EACmD;AACjD,UAAA,GAAG,CAAC,gBAAJ,CAAqB,eAArB;AACD,SAHD,MAGO;AACL,UAAA,GAAG,CAAC,gBAAJ,CAAqB,aAArB;AACD;;AAED,eAAO,MAAP;AACD,OAxFD;;AA0FA,UAAI,OAAO,kBAAP,KAAoB,WAAxB,EAAqC;AACnC,YAAM,SAAS,GAAG,wBAAS,OAAT,EAAkB,GAAlB,CAAlB;AACA,QAAA,SAAS,CAAC,GAAD,EAAM,MAAN,EAAc,KAAK,QAAnB,EAA6B,KAAK,WAAlC,CAAT,CAFmC,CAInC;;AACA,YAAI,SAAJ,EAAe;AACb,UAAA,SAAS,CAAC,KAAV;AACD;;AAED,eAAO;AACL,UAAA,MAAM,EAAE,gBAAgB,CAAC,UADpB;AAEL,UAAA,SAAS,EAAE;AAFN,SAAP;AAID,OAbD,MAaO;AACL,eAAO,OAAO,CAAC,GAAD,EAAM,MAAN,EAAc,KAAK,QAAnB,EAA6B,KAAK,WAAlC,CAAd;AACD;AACF;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,wBAAe,IAAf,EAA6B,QAA7B,EAA+C;AAC7C,4CAAgB,IAAI,eAAJ,CAAoB,IAApB,EAA0B,IAA1B,EAAgC,QAAhC,CAAhB;;AACA,WAAK,MAAL,CAAY,gBAAZ,EAA8B,EAA9B,EAAkC,WAAlC,EACI,gBAAgB,CAAC,eADrB;AAED;AAED;AACF;AACA;;;;WACE,gCAAuB;AACrB,gCAAI,IAAJ,aAAmB;AACjB,8CAAc,MAAd;;AACA,8CAAgB,IAAhB;;AACA,aAAK,MAAL,CAAY,sBAAZ,EAAoC,EAApC,EAAwC,SAAxC,EACI,gBAAgB,CAAC,eADrB;AAED;AACF;;;;;AAGH;AACA;AACA;;;;;;;;;;;;;IACM,e;AAMJ;AACF;AACA;AACA;AACA;AACA;AACE,2BAAY,GAAZ,EAAsB,IAAtB,EAAoC,QAApC,EAAsD;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA,aAVzC;AAUyC;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AACpD,sCAAY,GAAZ;;AACA,2CAAgB,UAAU,CAAC,KAAK,OAAL,CAAa,IAAb,CAAkB,IAAlB,CAAD,EAA0B,IAA1B,CAA1B;;AACA,2CAAiB,QAAjB;AACD;AAED;AACF;AACA;;;;;WACE,kBAAS;AACP,8CAAkB,IAAlB;;AACA,gCAAI,IAAJ,cAAmB;AACjB,QAAA,YAAY,uBAAC,IAAD,aAAZ;AACD;AACF;AAED;AACF;AACA;;;;WACE,mBAAU;AACR,UAAI,uBAAC,IAAD,aAAJ,EAAsB;AACpB,0CAAU,MAAV,uBAAiB,IAAjB;AACD;AACF;;;;;;;;;;;;;;;;ACvuCH;;AACA;;AAOA;;AACA;;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,IAAM,iBAAiB,GAAG,0BAAa,OAAvC;AACA,IAAM,gBAAgB,GAAG,0BAAa,MAAtC;AACA,IAAM,mBAAmB,GAAG,wBAAW,OAAvC;AAEA;AACA;AACA;;IACqB,U;;;;;AACnB;AACF;AACA;AACA;AACE,sBAAY,QAAZ,EAA0B;AAAA;;AAAA;;AACxB,QAAM,aAAa,mCACd;AACD,MAAA,gBAAgB,EAAE;AADjB,KADc,GAGX,QAHW,CAAnB;;AAMA,8BAAM,mBAAN,EAA2B,aAA3B;AAEA,UAAK,GAAL,GAAW,IAAI,gBAAJ,EAAX;AACA,UAAK,GAAL,GAAW,IAAI,gBAAJ,EAAX,CAVwB,CAYxB;;AACA,UAAK,aAAL,GAAqB,MAAK,aAA1B;AACA,UAAK,SAAL,GAAiB,MAAK,SAAtB;AACA,UAAK,WAAL,GAAmB,MAAK,WAAxB;AACA,UAAK,WAAL,GAAmB,MAAK,WAAxB;AACA,UAAK,SAAL,GAAiB,MAAK,SAAtB;AACA,UAAK,eAAL,GAAuB,MAAK,eAA5B;AACA,UAAK,iBAAL,GAAyB,MAAK,iBAA9B;AACA,UAAK,gBAAL,GAAwB,MAAK,gBAA7B;AApBwB;AAqBzB;AAED;AACF;AACA;AACA;AACA;;;;;WACE,yBAAgB;AACd,WAAK,GAAL,CAAS,UAAT;AACA,aAAO,KAAK,UAAL,CAAgB,eAAhB,EAAiC,8BAAjC,EACH,0BADG,CAAP;AAED;AAED;AACF;AACA;AACA;AACA;;;;WACE,qBAAY;AACV,UAAM,MAAM,GAAG,KAAK,SAAL,CAAe,WAAf,EAA4B,IAA5B,CAAf;;AAEA,UAAI,MAAM,KAAK,gBAAgB,CAAC,UAAhC,EAA4C;AAC1C,YAAI,KAAK,GAAL,CAAS,KAAT,KAAmB,EAAvB,EAA2B;AACzB,cAAI,KAAK,GAAL,CAAS,KAAT,KAAmB,UAAvB,EAAmC;AACjC,iBAAK,gBAAL,CAAsB,cAAtB;AACD,WAFD,MAEO;AACL,iBAAK,gBAAL,CAAsB,kBAAtB;AACD;AACF,SAND,MAMO,IAAI,KAAK,QAAL,CAAc,YAAlB,EAAgC;AACrC,eAAK,gBAAL,CAAsB,cAAtB;AACD;AACF;;AAED,aAAO,MAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,qBAAY,UAAZ,EAAwB;AACtB,aAAO,KAAK,QAAL,CAAc,aAAd,EAA6B,KAA7B,EAAoC,UAApC,CAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;;;;WACE,qBAAY,UAAZ,EAAwB,KAAxB,EAA+B;AAC7B,aAAO,KAAK,QAAL,CAAc,aAAd,EAA6B,WAA7B,EAA0C,KAA1C,EAAiD,UAAjD,EAA6D,KAA7D,CAAP;AACD;AAED;AACF;AACA;AACA;AACA;;;;WACE,qBAAY;AACV,aAAO,KAAK,MAAL,CAAY,WAAZ,EAAyB,KAAzB,CAAP;AACD;AAED;AACF;AACA;AACA;AACA;;;;WACE,2BAAkB;AAChB,aAAO,KAAK,YAAL,CAAkB,iBAAlB,CAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,2BAAkB,YAAlB,EAAgC;AAC9B,aAAO,KAAK,cAAL,CAAoB,mBAApB,EAAyC,YAAzC,CAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,0BAAiB,YAAjB,EAA+B;AAC7B,aAAO,KAAK,aAAL,CAAmB,kBAAnB,EAAuC,YAAvC,CAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;;;;WACE,qBAAY,UAAZ,EAAwB,KAAxB,EAA+B;AAC7B,aAAO,KAAK,kBAAL,CAAwB,aAAxB,EAAuC,KAAvC,EAA8C,UAA9C,EAA0D,KAA1D,CAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,qBAAY,UAAZ,EAAwB;AACtB,aAAO,KAAK,kBAAL,CAAwB,aAAxB,EAAuC,KAAvC,EAA8C,UAA9C,CAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,yBAAgB,UAAhB,EAA4B,KAA5B,EAAmC,eAAnC,EAAoD;AAClD,UAAI,QAAJ;;AAEA,UAAI,KAAK,aAAL,CAAmB,UAAnB,EAA+B,yBAA/B,CAAJ,EAA+D;AAC7D,QAAA,QAAQ,GAAG,IAAI,gCAAJ,EAAX;AACD,OAFD,MAEO,IAAI,eAAe,IAAI,KAAK,aAAL,CAAmB,UAAnB,EAC1B,sDAD0B,CAAvB,EACsD;AAC3D,QAAA,QAAQ,GAAG,IAAI,kDAAJ,EAAX;AACD,OAHM,MAGA,IAAI,eAAe,IAAI,KAAK,aAAL,CAAmB,UAAnB,EAC1B,+CAD0B,CAAvB,EAC+C;AACpD,QAAA,QAAQ,GAAG,IAAI,4CAAJ,EAAX;AACD,OAHM,MAGA,IAAI,CAAC,eAAD,IACP,KAAK,aAAL,CAAmB,UAAnB,EAA+B,2BAA/B,CADG,EAC0D;AAC/D,QAAA,QAAQ,GAAG,IAAI,kCAAJ,EAAX;AACD;;AAED,aAAO,QAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;;;;WACE,iCAAwB,UAAxB,EAAoC,KAApC,EAA2C;AACzC,aAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;;;;WACE,mCAA0B,WAA1B,EAAuC,MAAvC,EAA+C;AAC7C,UAAI,YAAY,GAAG,UAAnB;AACA,UAAI,aAAa,GAAG,UAApB,CAF6C,CAI7C;;AACA,MAAA,WAAW,GAAG,MAAM,CAAC,WAAD,CAApB;;AACA,UAAI,iBAAiB,CAAC,kBAAlB,CAAqC,WAArC,CAAJ,EAAuD;AACrD,QAAA,YAAY,GAAG,iBAAiB,CAAC,kBAAlB,CAAqC,WAArC,EAAkD,YAAjE;AACA,QAAA,aAAa,GAAG,iBAAiB,CAAC,kBAAlB,CAAqC,WAArC,EAAkD,aAAlE;AACD;;AAED,aAAO,MAAM,GAAG,aAAH,GAAmB,YAAhC;AACD;AAED;AACF;AACA;AACA;AACA;;;;WACE,oCAA2B,MAA3B,EAAmC;AACjC;AACA,WAAK,GAAL,GAAW,MAAM,CAAC,GAAlB;AACD;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,yBAAgB,eAAhB,EAA0C;AACxC,UAAM,SAAS,GAAG,KAAK,qBAAL,EAAlB;;AAEA,UAAI,eAAJ,EAAqB;AACnB,QAAA,SAAS,CAAC,GAAV,CAAc,IAAd,CAAmB,UAAnB,GAAgC,KAAK,GAAL,CAAS,mBAAT,EAAhC;AACD;;AAED,UAAM,MAAM,GAAG,EAAf;AACA,UAAM,SAAS,GAAG,SAAS,CAAC,OAAV,CAAkB,SAAlB,CAAlB;;AACA,cAAQ,KAAK,QAAL,CAAc,gBAAtB;AACE,aAAK,WAAL;AACE,iBAAO,SAAS,CAAC,OAAV,CAAkB,SAAlB,CAAP;;AACF,aAAK,QAAL;AACE,eAAK,IAAM,IAAX,IAAmB,SAAnB,EAA8B;AAC5B,gBAAI,GAAG,cAAH,CAAkB,IAAlB,CAAuB,SAAvB,EAAkC,IAAlC,CAAJ,EAA6C;AAC3C,cAAA,MAAM,CAAC,IAAP,WAAe,IAAf,cAAuB,SAAS,CAAC,IAAD,CAAhC;AACD;AACF;;AACD,iBAAO,MAAP;;AACF,aAAK,MAAL;AACA;AACE,iBAAO,SAAP;AAZJ;AAcD;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,mBAAU,eAAV,EAAoC;AAClC,UAAI,eAAJ,EAAqB;AACnB,YAAM,cAAc,GAAG,KAAK,GAAL,CAAS,IAAT,CAAc,aAArC;;AACA,YAAI,cAAc,KAAK,eAAvB,EAAwC;AACtC,eAAK,GAAL,CAAS,IAAT,CAAc,aAAd,GAA8B,WAA9B;AACD;;AAED,YAAI,KAAK,GAAL,CAAS,IAAT,CAAc,WAAd,KAA8B,QAAlC,EAA4C;AAC1C,cAAI,KAAK,GAAL,CAAS,IAAT,CAAc,MAAd,KAAyB,QAA7B,EAAuC;AACrC,gBAAI,KAAK,QAAL,CAAc,gBAAd,IACA,KAAK,GAAL,CAAS,YAAT,CAAsB,aAAtB,KAAwC,EADxC,IAEA,KAAK,GAAL,CAAS,IAAT,CAAc,KAAd,CAAoB,GAApB,KAA4B,EAFhC,EAEoC;AAClC,kBAAI,UAAU,CAAC,KAAK,GAAL,CAAS,IAAT,CAAc,KAAd,CAAoB,GAArB,CAAV,IAAuC,UAAU,CAAC,KAAK,GAAL,CAAS,YAAT,CAAsB,aAAvB,CAArD,EAA4F;AAC1F,qBAAK,GAAL,CAAS,IAAT,CAAc,aAAd,GAA8B,QAA9B;AACD,eAFD,MAEO;AACL,qBAAK,GAAL,CAAS,IAAT,CAAc,aAAd,GAA8B,QAA9B;AACD;AACF;AACF;AACF,SAZD,MAYO,IAAI,KAAK,GAAL,CAAS,IAAT,CAAc,WAAd,KAA8B,QAAlC,EAA4C;AAAA;;AACjD,cAAI,CAAC,4BAAK,YAAL,mGAAmB,GAAnB,0GAAwB,IAAxB,kFAA8B,aAA9B,KAA+C,EAAhD,MAAwD,EAAxD,IAA8D,cAAc,KAAK,eAArF,EAAsG;AACpG,iBAAK,GAAL,CAAS,IAAT,CAAc,aAAd,GAA8B,SAA9B;AACD;AACF;AACF;;AAED,UAAM,YAAY,GAAG,KAAK,eAAL,CAAqB,eAAe,IACrD,KAAK,QAAL,CAAc,mBADG,CAArB;;AAGA,UAAI,KAAK,WAAL,KAAqB,gBAAgB,CAAC,eAA1C,EAA2D;AACzD,QAAA,OAAO,CAAC,KAAR,CAAc,0BAA0B,eAAe,GAAG,KAAH,GAAW,IAApD,IAA4D,KAA1E;AACA,QAAA,OAAO,CAAC,KAAR,CAAc,YAAd;AACD;;AACD,UAAI,KAAK,QAAL,CAAc,YAAlB,EAAgC;AAC9B,eAAO,KAAK,kBAAL,CAAwB,KAAK,QAAL,CAAc,YAAtC,EAAoD,YAApD,EAAkE,eAAlE,CAAP;AACD,OAFD,MAEO;AACL,eAAO,gBAAgB,CAAC,UAAxB;AACD;AACF;;;;EA9RqC,oB;;;;;;;;;;;;;;ACpBxC;;AACA;;AACA;;AACA;;AACA;;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,IAAM,cAAc,GAAG,0BAAa,IAApC;AACA,IAAM,UAAU,GAAG,kBAAM,IAAzB;AACA,IAAM,gBAAgB,GAAG,wBAAW,OAApC;AAEA;AACA;AACA;;AACA,SAAS,kBAAT,GAA8B;AAC5B,QAAM,IAAI,+BAAJ,CAAwB,gBAAgB,CAAC,iBAAzC,CAAN;AACD;AAED;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA,SAAS,oBAAT,CACI,KADJ,EAEI,YAFJ,EAGI,gBAHJ,EAGgC;AAC9B,SAAO,8BACH,KADG,EAEH,YAFG,EAGH,gBAAgB,CAAC,aAHd,EAIH,+BAJG,EAKH,gBALG,CAAP;AAOD;AAED;AACA;AACA;;;IACa,G;;;;;AACX;AACF;AACA;AACA;AACE,eAAY,WAAZ,EAAkC;AAAA;;AAAA;;AAChC,8BAAM,cAAc,CAAC,YAArB;AAEA,QAAI,WAAJ,EAAiB,MAAK,UAAL;AAEjB,UAAK,kBAAL,GAA0B,IAAI,sBAAJ,EAA1B;AACA,UAAK,YAAL,GAAoB,IAAI,kBAAJ,EAApB;AACA,UAAK,oBAAL,GAA4B,IAAI,sBAAJ,EAA5B;AACA,UAAK,UAAL,GAAkB,IAAI,aAAJ,EAAlB;AACA,UAAK,KAAL,GAAa,IAAI,QAAJ,EAAb;AATgC;AAUjC;AAED;AACF;AACA;;;;;WACE,sBAAa;AAAA;;AACX;;AACA,oCAAK,kBAAL,gFAAyB,UAAzB;AACA,iCAAK,YAAL,0EAAmB,UAAnB;AACA,oCAAK,oBAAL,gFAA2B,UAA3B;AACA,+BAAK,UAAL,sEAAiB,UAAjB;AACA,0BAAK,KAAL,4DAAY,UAAZ;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,kBAAS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,wBAAgB,KAAK,YADR;AAEb,uBAAe,KAAK,WAFP;AAGb,oBAAY,KAAK,QAHJ;AAIb,6BAAqB,KAAK,iBAJb;AAKb,gBAAQ,KAAK,IALA;AAMb,sBAAc,KAAK,UANN;AAOb,wBAAgB,KAAK,YAPR;AAQb,8BAAsB,KAAK,kBARd;AASb,gCAAwB,KAAK,oBAThB;AAUb,wBAAgB,KAAK,YAVR;AAWb,sBAAc,KAAK,UAXN;AAYb,iBAAS,KAAK;AAZD,OAAf;AAcA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;;EAjEsB,UAAU,CAAC,G;AAoEpC;AACA;AACA;;;;;IACM,a;;;;;AACJ;AACF;AACA;AACE,2BAAc;AAAA;;AAAA;;AACZ;AAEA,WAAK,QAAL,GAAgB,IAAI,qBAAJ,EAAhB;AAHY;AAIb;AAED;AACF;AACA;;;;;WACE,sBAAa;AAAA;;AACX;;AACA,6BAAK,QAAL,kEAAe,UAAf;AACD;AAED;AACF;AACA;AACA;;;;WACE,kBAAS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,oBAAY,KAAK;AADJ,OAAf;AAGA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;;EA7ByB,e;AAgC5B;AACA;AACA;;;IACM,qB;;;;;AACJ;AACF;AACA;AACE,mCAAc;AAAA;;AAAA,8BACN;AACJ,MAAA,QAAQ,EAAE,cAAc,CAAC,iBADrB;AAEJ,MAAA,SAAS,EAAE,gBAAgB,CAAC,iBAFxB;AAGJ,MAAA,UAAU,EAAE;AAHR,KADM;AAMb;;;EAViC,gB;AAapC;AACA;AACA;;;;;;;;;;;;;IACM,sB;;;;;AACJ;AACF;AACA;AACE,oCAAc;AAAA;;AAAA;;AACZ,gCAAM,cAAc,CAAC,2BAArB;;AADY;AAAA;AAAA,aAkBC;AAlBD;;AAAA;AAAA;AAAA,aAmBA;AAnBA;;AAAA;AAAA;AAAA,aAoBG;AApBH;;AAAA;AAAA;AAAA,aAqBD;AArBC;;AAAA;AAAA;AAAA,aAsBL;AAtBK;;AAGZ,WAAK,OAAL,GAAe,IAAI,gBAAJ,CAAa;AAC1B,MAAA,SAAS,EAAE,gBAAgB,CAAC,iBADF;AAE1B,MAAA,UAAU,EAAE,+BAFc;AAG1B,MAAA,QAAQ,EAAE;AAHgB,KAAb,CAAf;AAHY;AAQb;AAED;AACF;AACA;;;;;WACE,sBAAa;AAAA;;AACX;;AACA,4BAAK,OAAL,gEAAc,UAAd;AACD;;;;AAQD;AACF;AACA;AACA;AACE,mBAA0B;AACxB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAgB,WAAhB,EAAqC;AACnC,UAAI,oBAAoB,CAAC,WAAD,EAAc,UAAU,CAAC,YAAzB,CAAxB,EAAgE;AAC9D,kDAAoB,WAApB;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAAyB;AACvB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAe,UAAf,EAAmC;AACjC,UAAI,oBAAoB,CAAC,UAAD,EAAa,UAAU,CAAC,YAAxB,CAAxB,EAA+D;AAC7D,iDAAmB,UAAnB;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAA4B;AAC1B,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAkB,aAAlB,EAAyC;AACvC,UAAI,oBAAoB,CAAC,aAAD,EAAgB,UAAU,CAAC,YAA3B,CAAxB,EAAkE;AAChE,oDAAsB,aAAtB;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAAwB;AACtB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAc,SAAd,EAAiC;AAC/B,UAAI,oBAAoB,CAAC,SAAD,EAAY,UAAU,CAAC,YAAvB,CAAxB,EAA8D;AAC5D,gDAAkB,SAAlB;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAAoB;AAClB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAU,KAAV,EAAyB;AACvB,UAAI,oBAAoB,CAAC,KAAD,EAAQ,UAAU,CAAC,YAAnB,CAAxB,EAA0D;AACxD,4CAAc,KAAd;AACD;AACF;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,kBAAS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,iBAAS,KAAK,KADD;AAEb,oBAAY,KAAK,QAFJ;AAGb,uBAAe,KAAK,WAHP;AAIb,iBAAS,KAAK,KAJD;AAKb,gBAAQ,KAAK,IALA;AAMb,sBAAc,KAAK,UANN;AAOb,yBAAiB,KAAK,aAPT;AAQb,qBAAa,KAAK,SARL;AASb,iBAAS,KAAK,KATD;AAUb,mBAAW,KAAK;AAVH,OAAf;AAYA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;;EAlJkC,UAAU,CAAC,oB;AAqJhD;AACA;AACA;;;;;IACM,kB;;;;;AACJ;AACF;AACA;AACE,gCAAc;AAAA;;AAAA;;AACZ,gCAAM,cAAc,CAAC,qBAArB;;AADY;AAAA;AAAA,aAcS;AAdT;;AAGZ,WAAK,KAAL,GAAa,IAAI,QAAJ,EAAb;AAHY;AAIb;AAED;AACF;AACA;;;;;WACE,sBAAa;AAAA;;AACX;;AACA,0BAAK,KAAL,4DAAY,UAAZ;AACD;;;;AAID;AACF;AACA;AACA;AACE,mBAA0B;AACxB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAwB,mBAAxB,EAA6C;AAC3C,OAAC,KAAK,WAAN,yBACI,IADJ,wBACgC,mBADhC,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,kBAAS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,yBAAiB,KAAK,aADT;AAEb,4BAAoB,KAAK,gBAFZ;AAGb,6BAAqB,KAAK,iBAHb;AAIb,iBAAS,KAAK;AAJD,OAAf;AAMA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;;EA5D8B,UAAU,CAAC,c;AA+D5C;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IACa,sB;;;;;AACX;AACF;AACA;AACE,oCAAc;AAAA;;AAAA;;AACZ;;AADY;AAAA;AAAA,aAID,cAAc,CAAC;AAJd;;AAAA;AAAA;AAAA,aAKN;AALM;;AAAA;AAAA;AAAA,aAML;AANK;;AAAA;AAAA;AAAA,aAOH;AAPG;;AAAA;AAAA;AAAA,aAQH;AARG;;AAAA;AAAA;AAAA,aASA;AATA;;AAAA;AAAA;AAAA,aAUG;AAVH;;AAAA;AAAA;AAAA,aAWK;AAXL;;AAAA;AAAA;AAAA,aAYL;AAZK;;AAAA;AAAA;AAAA,aAaK;AAbL;;AAAA;AAAA;AAAA,aAcL;AAdK;;AAAA;AAAA;AAAA,aAeI;AAfJ;;AAAA;AAAA;AAAA,aAgBD;AAhBC;;AAAA;AAAA;AAAA,aAiBM;AAjBN;;AAAA;AAEb;;;;;AAiBD;AACF;AACA;AACA;AACE,mBAAgB;AACd,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;;;SACE,eAAW;AACT,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAS,IAAT,EAAe;AACb,OAAC,KAAK,WAAN,yBACI,IADJ,SACiB,IADjB,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAY;AACV,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAU,KAAV,EAAiB;AACf,OAAC,KAAK,WAAN,yBACI,IADJ,UACkB,KADlB,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAc;AACZ,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAY,OAAZ,EAAqB;AACnB,OAAC,KAAK,WAAN,yBACI,IADJ,YACoB,OADpB,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAc;AACZ,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAY,OAAZ,EAAqB;AACnB,OAAC,KAAK,WAAN,yBACI,IADJ,YACoB,OADpB,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAiB;AACf,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAe,UAAf,EAA2B;AACzB,OAAC,KAAK,WAAN,yBACI,IADJ,eACuB,UADvB,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAoB;AAClB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAkB,aAAlB,EAAiC;AAC/B,OAAC,KAAK,WAAN,yBACI,IADJ,kBAC0B,aAD1B,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAsB;AACpB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAoB,eAApB,EAAqC;AACnC,OAAC,KAAK,WAAN,yBACI,IADJ,oBAC4B,eAD5B,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAY;AACV,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAU,KAAV,EAAiB;AACf,OAAC,KAAK,WAAN,yBACI,IADJ,UACkB,KADlB,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAsB;AACpB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAoB,eAApB,EAAqC;AACnC,OAAC,KAAK,WAAN,yBACI,IADJ,oBAC4B,eAD5B,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAY;AACV,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAU,KAAV,EAAiB;AACf,OAAC,KAAK,WAAN,yBACI,IADJ,UACkB,KADlB,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAqB;AACnB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAmB,cAAnB,EAAmC;AACjC,OAAC,KAAK,WAAN,yBACI,IADJ,mBAC2B,cAD3B,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAgB;AACd,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAc,SAAd,EAAyB;AACvB,OAAC,KAAK,WAAN,yBACI,IADJ,cACsB,SADtB,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAuB;AACrB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAqB,gBAArB,EAAuC;AACrC,OAAC,KAAK,WAAN,yBACI,IADJ,qBAC6B,gBAD7B,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,kBAAS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,gBAAQ,KAAK,IADA;AAEb,iBAAS,aAFI;AAGb,mBAAW,KAAK,OAHH;AAIb,mBAAW,KAAK,OAJH;AAKb,sBAAc,KAAK,UALN;AAMb,yBAAiB,KAAK,aANT;AAOb,2BAAmB,KAAK,eAPX;AAQb,iBAAS,KAAK,KARD;AASb,2BAAmB,KAAK,eATX;AAUb,iBAAS,KAAK,KAVD;AAWb,0BAAkB,KAAK,cAXV;AAYb,qBAAa,KAAK,SAZL;AAab,4BAAoB,KAAK;AAbZ,OAAf;AAeA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;;EA7TyC,e;AAgU5C;AACA;AACA;;;;;IACa,Q;;;;;AACX;AACF;AACA;AACE,sBAAc;AAAA;;AAAA,8BACN;AAAC,MAAA,QAAQ,EAAE,cAAc,CAAC;AAA1B,KADM;AAEb;;;EAN2B,gB;AAS9B;AACA;AACA;;;;;;;;;;;;;;;;;IACa,c;;;;;AACX;AACF;AACA;AACE,4BAAc;AAAA;;AAAA;;AACZ;;AADY;AAAA;AAAA,aAIC;AAJD;;AAAA;AAAA;AAAA,aAKN;AALM;;AAAA;AAAA;AAAA,aAMN;AANM;;AAAA;AAAA;AAAA,aAOJ;AAPI;;AAAA;AAAA;AAAA,aAQF;AARE;;AAAA;AAAA;AAAA,aASK;AATL;;AAAA;AAEb;;;;;AASD;AACF;AACA;AACA;AACE,mBAAkB;AAChB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAgB,WAAhB,EAA6B;AAC3B,UAAI,oBAAoB,CAAC,WAAD,EAAc,UAAU,CAAC,YAAzB,CAAxB,EAAgE;AAC9D,kDAAoB,WAApB;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAAW;AACT,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAS,IAAT,EAAe;AACb,UAAI,oBAAoB,CAAC,IAAD,EAAO,UAAU,CAAC,YAAlB,CAAxB,EAAyD;AACvD,2CAAa,IAAb;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAAW;AACT,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAS,IAAT,EAAe;AACb,UAAI,oBAAoB,CAAC,IAAD,EAAO,UAAU,CAAC,OAAlB,CAAxB,EAAoD;AAClD,2CAAa,IAAb;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAAa;AACX,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAW,MAAX,EAAmB;AACjB,UAAI,oBAAoB,CAAC,MAAD,EAAS,UAAU,CAAC,UAApB,CAAxB,EAAyD;AACvD,6CAAe,MAAf;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAAe;AACb,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAa,QAAb,EAAuB;AACrB,UAAI,oBAAoB,CAAC,QAAD,EAAW,UAAU,CAAC,YAAtB,CAAxB,EAA6D;AAC3D,+CAAiB,QAAjB;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAAsB;AACpB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAoB,eAApB,EAAqC;AACnC,UAAI,oBAAoB,CAAC,eAAD,EAAkB,UAAU,CAAC,OAA7B,CAAxB,EAA+D;AAC7D,sDAAwB,eAAxB;AACD;AACF;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,kBAAS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,uBAAe,KAAK,WADP;AAEb,gBAAQ,KAAK,IAFA;AAGb,gBAAQ,KAAK,IAHA;AAIb,kBAAU,KAAK,MAJF;AAKb,oBAAY,KAAK,QALJ;AAMb,2BAAmB,KAAK;AANX,OAAf;AAQA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;;EApJiC,e;AAuJpC;AACA;AACA;;;;;IACa,Q;;;;;AACX;AACF;AACA;AACE,sBAAc;AAAA;;AAAA,8BACN;AAAC,MAAA,QAAQ,EAAE,cAAc,CAAC;AAA1B,KADM;AAEb;;;EAN2B,gB;AAS9B;AACA;AACA;;;;;;;;;IACa,c;;;;;AACX;AACF;AACA;AACE,4BAAc;AAAA;;AAAA;;AACZ;;AADY;AAAA;AAAA,aAsBJ;AAtBI;;AAAA;AAAA;AAAA,aAuBN;AAvBM;;AAGZ,WAAK,KAAL,GAAa,IAAI,gBAAJ,CACT;AACE,MAAA,cAAc,EAAE,cAAc,CAAC,cADjC;AAEE,MAAA,WAAW,EAAE,UAAU,CAAC,WAF1B;AAGE,MAAA,gBAAgB,EAAE,gBAAgB,CAAC,iBAHrC;AAIE,MAAA,eAAe,EAAE,gBAAgB,CAAC,aAJpC;AAKE,MAAA,gBAAgB,EAAE,gBAAgB,CAAC,kBALrC;AAME,MAAA,UAAU,EAAE;AANd,KADS,CAAb;AAHY;AAYb;AAED;AACF;AACA;;;;;WACE,sBAAa;AAAA;;AACX;;AACA,0BAAK,KAAL,4DAAY,UAAZ;AACD;;;;AAKD;AACF;AACA;AACA;AACE,mBAAa;AACX,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAW,MAAX,EAAmB;AACjB,UAAI,oBAAoB,CAAC,MAAD,EAAS,UAAU,CAAC,UAApB,CAAxB,EAAyD;AACvD,8CAAe,MAAf;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAAW;AACT,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAS,IAAT,EAAe;AACb,UAAI,oBAAoB,CAAC,IAAD,EAAO,UAAU,CAAC,OAAlB,CAAxB,EAAoD;AAClD,4CAAa,IAAb;AACD;AACF;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,kBAAS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,kBAAU,KAAK,MADF;AAEb,gBAAQ,KAAK,IAFA;AAGb,iBAAS,KAAK;AAHD,OAAf;AAKA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;;EApFiC,e;AAuFpC;AACA;AACA;;;;;IACa,iB;;;;;AACX;AACF;AACA;AACE,+BAAc;AAAA;;AAAA,+BACN;AAAC,MAAA,QAAQ,EAAE,cAAc,CAAC;AAA1B,KADM;AAEb;;;EANoC,gB;AASvC;AACA;AACA;;;;;;;IACa,uB;;;;;AACX;AACF;AACA;AACE,qCAAc;AAAA;;AAAA;;AACZ;;AADY;AAAA;AAAA,aAsBG;AAtBH;;AAGZ,WAAK,KAAL,GAAa,IAAI,gBAAJ,CACT;AACE,MAAA,cAAc,EAAE,cAAc,CAAC,cADjC;AAEE,MAAA,WAAW,EAAE,UAAU,CAAC,WAF1B;AAGE,MAAA,gBAAgB,EAAE,gBAAgB,CAAC,iBAHrC;AAIE,MAAA,eAAe,EAAE,gBAAgB,CAAC,aAJpC;AAKE,MAAA,gBAAgB,EAAE,gBAAgB,CAAC,kBALrC;AAME,MAAA,UAAU,EAAE;AANd,KADS,CAAb;AAHY;AAYb;AAED;AACF;AACA;;;;;WACE,sBAAa;AAAA;;AACX;;AACA,2BAAK,KAAL,8DAAY,UAAZ;AACD;;;;AAID;AACF;AACA;AACA;AACE,mBAAoB;AAClB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAkB,aAAlB,EAAiC;AAC/B,UAAI,oBAAoB,CAAC,aAAD,EAAgB,UAAU,CAAC,UAA3B,CAAxB,EAAgE;AAC9D,oDAAsB,aAAtB;AACD;AACF;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,kBAAS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,yBAAiB,KAAK,aADT;AAEb,iBAAS,KAAK;AAFD,OAAf;AAIA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;;EAhE0C,e;AAmE7C;AACA;AACA;;;;;;;;;;;IACa,2B;;;;;AACX;AACF;AACA;AACE,yCAAc;AAAA;;AAAA;;AACZ;;AADY;AAAA;AAAA,aAIH;AAJG;;AAAA;AAAA;AAAA,aAKF;AALE;;AAAA;AAAA;AAAA,aAMN;AANM;;AAAA;AAEb;;;;;AAMD;AACF;AACA;AACA;AACE,mBAAc;AACZ,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAY,OAAZ,EAAqB;AACnB,UAAI,oBAAoB,CAAC,OAAD,EAAU,UAAU,CAAC,YAArB,CAAxB,EAA4D;AAC1D,8CAAgB,OAAhB;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAAe;AACb,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAa,QAAb,EAAuB;AACrB,UAAI,oBAAoB,CAAC,QAAD,EAAW,UAAU,CAAC,YAAtB,CAAxB,EAA6D;AAC3D,+CAAiB,QAAjB;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAAW;AACT,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAS,IAAT,EAAe;AACb,UAAI,oBAAoB,CAAC,IAAD,EAAO,UAAU,CAAC,OAAlB,CAAxB,EAAoD;AAClD,4CAAa,IAAb;AACD;AACF;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,kBAAS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,mBAAW,KAAK,OADH;AAEb,oBAAY,KAAK,QAFJ;AAGb,gBAAQ,KAAK;AAHA,OAAf;AAKA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;;EArF8C,e;;;;;;;;;;;;;;;;AC7hCjD;;AACA;;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,IAAM,iBAAiB,GAAG,0BAAa,OAAvC;AACA,IAAM,aAAa,GAAG,kBAAM,OAA5B;AACA,IAAM,mBAAmB,GAAG,wBAAW,OAAvC;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACO,SAAS,gBAAT,CACH,KADG,EAEH,YAFG,EAGH,SAHG,EAIH,UAJG,EAKH,gBALG,EAKyB;AAC9B,MAAM,WAAW,GAAG,IAAI,MAAJ,CAAW,YAAX,CAApB;AACA,MAAM,OAAO,GAAG,KAAK,CAAC,KAAN,CAAY,WAAZ,CAAhB;;AACA,MAAI,gBAAgB,IAAI,KAAK,KAAK,EAAlC,EAAsC;AACpC,WAAO,IAAP;AACD;;AACD,MAAI,KAAK,KAAK,SAAV,IAAuB,CAAC,OAAxB,IAAmC,OAAO,CAAC,CAAD,CAAP,KAAe,EAAtD,EAA0D;AACxD,UAAM,IAAI,UAAU,CAAC,SAAX,CAAqB,WAAzB,CAAqC,SAArC,CAAN;AACD;;AACD,SAAO,IAAP;AACD;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACO,SAAS,eAAT,CACH,KADG,EAEH,YAFG,EAGH,SAHG,EAIH,UAJG,EAImB;AACxB,MAAM,MAAM,GAAG,YAAY,CAAC,KAAb,CAAmB,GAAnB,CAAf;AACA,EAAA,KAAK,GAAG,KAAK,GAAG,GAAhB;;AACA,MAAI,KAAK,IAAI,MAAM,CAAC,CAAD,CAAnB,EAAwB;AACtB,QAAK,MAAM,CAAC,CAAD,CAAN,KAAc,GAAf,IAAwB,KAAK,IAAI,MAAM,CAAC,CAAD,CAA3C,EAAiD;AAC/C,aAAO,IAAP;AACD,KAFD,MAEO;AACL,YAAM,IAAI,UAAU,CAAC,SAAX,CAAqB,WAAzB,CAAqC,SAArC,CAAN;AACD;AACF,GAND,MAMO;AACL,UAAM,IAAI,UAAU,CAAC,SAAX,CAAqB,WAAzB,CAAqC,SAArC,CAAN;AACD;AACF;AAED;AACA;AACA;;;;;;;IACa,O;AAKX;AACF;AACA;AACE,qBAAc;AAAA;;AAAA,wCAPD,KAOC;;AAAA;AAAA;AAAA,aANC;AAMD;;AAAA;AAAA;AAAA;AAAA;;AACZ,QAAI,0DAAe,OAAnB,EAA4B;AAC1B,YAAM,IAAI,SAAJ,CAAc,6CAAd,CAAN;AACD;AACF;AAED;AACF;AACA;AACA;;;;;SACE,eAAkB;AAChB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;;;SACE,eAAiB;AACf,mCAAO,IAAP;AACD;AAED;AACF;AACA;;;;WACE,sBAAa;AACX,gDAAoB,IAApB;AACD;AAED;AACF;AACA;AACA;;;;WACE,wBAAe;AACb,+CAAmB,IAAI,IAAJ,GAAW,OAAX,EAAnB;AACD;;;;;AAGH;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;;;;IACa,Q;;;;;AACX;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACE,0BAUO;AAAA;;AAAA,QARD,cAQC,QARD,cAQC;AAAA,QAPD,WAOC,QAPD,WAOC;AAAA,QAND,GAMC,QAND,GAMC;AAAA,QALD,gBAKC,QALD,gBAKC;AAAA,QAJD,eAIC,QAJD,eAIC;AAAA,QAHD,gBAGC,QAHD,gBAGC;AAAA,QAFD,YAEC,QAFD,YAEC;AAAA,QADD,UACC,QADD,UACC;;AAAA;;AACL;;AADK;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA,aAyBA;AAzBA;;AAAA;AAAA;AAAA,aA0BA;AA1BA;;AAAA;AAAA;AAAA;AAAA;;AAGL,qEAAkB,cAAc,IAC5B,iBAAiB,CAAC,cADtB;;AAEA,uEAAqB,CAAC,WAAD,GAAe,KAAf,GAAuB,aAAa,CAAC,WAA1D;;AACA,+DAAa,GAAG,IAAI,GAAG,KAAK,EAAhB,GAAsB,GAAtB,GAA4B,KAAxC;;AACA,8EAA4B,gBAAgB,IACxC,mBAAmB,CAAC,iBADxB;;AAEA,6EAA2B,eAAe,IACtC,mBAAmB,CAAC,aADxB;;AAEA,8EAA4B,gBAAgB,IACxC,mBAAmB,CAAC,kBADxB;;AAEA,yEAAuB,YAAY,IAC/B,aAAa,CAAC,UADlB;;AAEA,uEAAqB,UAArB;;AAfK;AAgBN;;;;;AAaD;AACF;AACA;AACA;AACA;AACE,mBAAgB;AACd,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAc,SAAd,EAAyB;AACvB,YAAM,KAAI,0CAAmB,SAAnB,CAA6B,WAAjC,wBAA6C,IAA7C,uBAAN;AACD;AAED;AACF;AACA;AACA;;;;SACE,eAAU;AACR,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAQ,GAAR,EAAa;AACX,UAAI,gBAAgB,CAAC,GAAD,wBAAM,IAAN,yCAA4B,IAA5B,6CAAsD,IAAtD,gBAAhB,KACC,uBAAC,IAAD,mBACG,eAAe,CAAC,GAAD,wBAAM,IAAN,uCAA0B,IAA1B,8CAAqD,IAArD,gBAFnB,CAAJ,EAEkG;AAChG,0CAAY,GAAZ;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAAU;AACR,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAQ,GAAR,EAAa;AACX,UAAI,gBAAgB,CAAC,GAAD,wBAAM,IAAN,yCAA4B,IAA5B,6CAAsD,IAAtD,gBAAhB,KACC,uBAAC,IAAD,mBACG,eAAe,CAAC,GAAD,wBAAM,IAAN,uCAA0B,IAA1B,8CAAqD,IAArD,gBAFnB,CAAJ,EAEkG;AAChG,0CAAY,GAAZ;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAAU;AACR,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAQ,GAAR,EAAa;AACX,UAAI,gBAAgB,CAAC,GAAD,wBAAM,IAAN,yCAA4B,IAA5B,6CAAsD,IAAtD,gBAAhB,KACC,uBAAC,IAAD,mBACG,eAAe,CAAC,GAAD,wBAAM,IAAN,uCAA0B,IAA1B,8CAAqD,IAArD,gBAFnB,CAAJ,EAEkG;AAChG,0CAAY,GAAZ;AACD;AACF;AAED;AACF;AACA;AACA;;;;WACE,kBAAS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,eAAO,KAAK,GADC;AAEb,eAAO,KAAK,GAFC;AAGb,eAAO,KAAK;AAHC,OAAf;AAKA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;;EA9I2B,O;AAiJ9B;AACA;AACA;;;;;;;;;;;IACa,Q;;;;;AACX;AACF;AACA;AACA;AACA;AACA;AACE,2BAA+C;AAAA;;AAAA,QAAlC,QAAkC,SAAlC,QAAkC;AAAA,QAAxB,SAAwB,SAAxB,SAAwB;AAAA,QAAb,UAAa,SAAb,UAAa;;AAAA;;AAC7C;;AAD6C;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAE7C,sEAAkB,QAAlB;;AACA,sEAAkB,SAAlB;;AACA,uEAAmB,UAAnB;;AACA,WAAK,UAAL,GAAkB,EAAlB;AAL6C;AAM9C;;;;;AAMD;AACF;AACA;AACA;AACE,mBAAgB;AACd,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAc,SAAd,EAAyB;AACvB,YAAM,KAAI,yCAAiB,SAAjB,CAA2B,WAA/B,wBAA2C,IAA3C,cAAN;AACD;AAED;AACF;AACA;AACA;;;;SACE,eAAa;AACX,aAAO,KAAK,UAAL,CAAgB,MAAvB;AACD;AAED;AACF;AACA;AACA;;SACE,aAAW,MAAX,EAAmB;AACjB,YAAM,KAAI,yCAAiB,SAAjB,CAA2B,WAA/B,wBAA2C,IAA3C,cAAN;AACD;AAED;AACF;AACA;AACA;;;;WACE,kBAAS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG,EAAf;;AACA,WAAK,IAAI,CAAC,GAAG,CAAb,EAAgB,CAAC,GAAG,KAAK,UAAL,CAAgB,MAApC,EAA4C,CAAC,EAA7C,EAAiD;AAC/C,QAAA,MAAM,CAAC,CAAC,GAAG,EAAL,CAAN,GAAiB,KAAK,UAAL,CAAgB,CAAhB,CAAjB;AACD;;AACD,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;;EA/D2B,O;;;;;;;;;;;;;;;;;;ACtQ9B;;AAOA;;AACA;;AACA;;AACA;;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,IAAM,iBAAiB,GAAG,0BAAa,OAAvC;AACA,IAAM,aAAa,GAAG,kBAAM,OAA5B;AACA,IAAM,mBAAmB,GAAG,wBAAW,OAAvC;AAEA;AACA;AACA;;AACO,SAAS,kBAAT,GAA8B;AACnC,QAAM,IAAI,kCAAJ,CAA2B,mBAAmB,CAAC,iBAA/C,CAAN;AACD;AAED;AACA;AACA;;;AACO,SAAS,mBAAT,GAA+B;AACpC,QAAM,IAAI,kCAAJ,CAA2B,mBAAmB,CAAC,kBAA/C,CAAN;AACD;AAED;AACA;AACA;;;AACA,SAAS,sBAAT,GAAkC;AAChC,QAAM,IAAI,kCAAJ,CAA2B,mBAAmB,CAAC,iBAA/C,CAAN;AACD;AAED;AACA;AACA;AACA;AACA;AACA;AACA;;;AACO,SAAS,kBAAT,CACH,KADG,EAEH,YAFG,EAGH,gBAHG,EAGyB;AAC9B,SAAO,8BACH,KADG,EAEH,YAFG,EAGH,mBAAmB,CAAC,aAHjB,EAIH,kCAJG,EAKH,gBALG,CAAP;AAOD;AAED;AACA;AACA;AACA;AACA;AACA;AACA;;;AACO,SAAS,iBAAT,CACH,KADG,EAEH,YAFG,EAGH,gBAHG,EAGyB;AAC9B,SAAO,6BACH,KADG,EAEH,YAFG,EAGH,mBAAmB,CAAC,kBAHjB,EAIH,kCAJG,EAKH,gBALG,CAAP;AAOD;AAED;AACA;AACA;;;;;;;;;;;;;IACa,G;;;;;AASX;AACF;AACA;AACA;AACA;AACA;AACE,eAAY,YAAZ,EAA0B,YAA1B,EAAwC,WAAxC,EAA8D;AAAA;;AAAA;;AAC5D;;AAD4D;AAAA;AAAA,aAdjD;AAciD;;AAAA;AAAA;AAAA,aAblD;AAakD;;AAAA;AAAA;AAAA,aAZ/C;AAY+C;;AAAA;AAAA;AAAA,aAXlD;AAWkD;;AAAA;AAAA;AAAA,aAVzC;AAUyC;;AAAA,mEAR/C,IAQ+C;;AAG5D,QAAI,WAAJ,EAAiB,MAAK,UAAL;;AAEjB,qEAAkB,YAAY,GAC1B,YAD0B,GAE1B,iBAAiB,CAAC,YAFtB;;AAGA,UAAK,IAAL,GAAY,IAAI,OAAJ,EAAZ;AACA,UAAK,UAAL,GAAkB,IAAI,aAAJ,EAAlB;AACA,UAAK,YAAL,GAAoB,YAAY,GAAG,YAAH,GAAkB,IAAI,cAAJ,EAAlD;AACA,UAAK,kBAAL,GAA0B,IAAI,oBAAJ,EAA1B;AACA,UAAK,YAAL,GAAoB,IAAI,eAAJ,EAApB;AAZ4D;AAa7D;AAED;AACF;AACA;;;;;WACE,sBAAa;AAAA;;AACX;;AACA,yBAAK,IAAL,0DAAW,UAAX;AACA,+BAAK,UAAL,sEAAiB,UAAjB;AACA,iCAAK,YAAL,0EAAmB,UAAnB;AACA,oCAAK,kBAAL,gFAAyB,UAAzB;AACA,iCAAK,YAAL,0EAAmB,UAAnB;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,kBAAS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,wBAAgB,KAAK,YADR;AAEb,uBAAe,KAAK,WAFP;AAGb,oBAAY,KAAK,QAHJ;AAIb,6BAAqB,KAAK,iBAJb;AAKb,gBAAQ,KAAK,IALA;AAMb,sBAAc,KAAK,UANN;AAOb,wBAAgB,KAAK,YAPR;AAQb,8BAAsB,KAAK,kBARd;AASb,wBAAgB,KAAK;AATR,OAAf;AAWA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;AAED;AACF;AACA;AACA;;;;SACE,eAAe;AACb,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAa,QAAb,EAAuB;AACrB,MAAA,sBAAsB;AACvB;AAED;AACF;AACA;AACA;;;;SACE,eAAgB;AACd,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAc,SAAd,EAAyB;AACvB,MAAA,sBAAsB;AACvB;AAED;AACF;AACA;AACA;;;;SACE,eAAmB;AAAA;;AACjB,4BAAO,KAAK,IAAZ,gDAAO,YAAW,YAAlB;AACD;AAED;AACF;AACA;AACA;;SACE,aAAiB,YAAjB,EAA+B;AAC7B,UAAI,KAAK,IAAT,EAAe;AACb,aAAK,IAAL,CAAU,YAAV,GAAyB,YAAzB;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAAkB;AAChB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAgB,WAAhB,EAA6B;AAC3B,OAAC,KAAK,WAAN,yBAAoB,IAApB,gBAAwC,WAAxC,IAAsD,kBAAkB,EAAxE;AACD;AAED;AACF;AACA;AACA;;;;SACE,eAAe;AACb,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAa,QAAb,EAAuB;AACrB,UAAI,kBAAkB,CAAC,QAAD,EAAW,aAAa,CAAC,aAAzB,EAAwC,IAAxC,CAAtB,EAAqE;AACnE,+CAAiB,QAAjB;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAAwB;AACtB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAsB,iBAAtB,EAAyC;AACvC,OAAC,KAAK,WAAN,yBACI,IADJ,sBAC8B,iBAD9B,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;AACA;;;;WACE,+BAAsB;AACpB,aAAO,KAAK,IAAL,CAAU,mBAAV,CAA8B,KAAK,UAAnC,CAAP;AACD;;;;EAzLsB,e;AA4LzB;AACA;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IACM,O;;;;;AACJ;AACF;AACA;AACE,qBAAc;AAAA;;AAAA;;AACZ;;AADY;AAAA;AAAA,aAsBD,iBAAiB,CAAC;AAtBjB;;AAAA;AAAA;AAAA,aAuBA;AAvBA;;AAAA;AAAA;AAAA,aAwBE;AAxBF;;AAAA;AAAA;AAAA,aAyBK;AAzBL;;AAAA;AAAA;AAAA,aA0BJ;AA1BI;;AAAA;AAAA;AAAA,aA2BG;AA3BH;;AAAA;AAAA;AAAA,aA4BL;AA5BK;;AAAA;AAAA;AAAA,aA6BA;AA7BA;;AAAA;AAAA;AAAA,aA8BC;AA9BD;;AAAA;AAAA;AAAA,aA+BN;AA/BM;;AAAA;AAAA;AAAA,aAgCE;AAhCF;;AAAA;AAAA;AAAA,aAiCE;AAjCF;;AAGZ,WAAK,KAAL,GAAa,IAAI,gBAAJ,CACT;AACE,MAAA,cAAc,EAAE,iBAAiB,CAAC,cADpC;AAEE,MAAA,WAAW,EAAE,aAAa,CAAC,WAF7B;AAGE,MAAA,gBAAgB,EAAE,mBAAmB,CAAC,iBAHxC;AAIE,MAAA,eAAe,EAAE,mBAAmB,CAAC,aAJvC;AAKE,MAAA,gBAAgB,EAAE,mBAAmB,CAAC,kBALxC;AAME,MAAA,UAAU,EAAE;AANd,KADS,CAAb;AAHY;AAYb;AAED;AACF;AACA;;;;;WACE,sBAAa;AAAA;;AACX;;AACA,0BAAK,KAAL,4DAAY,UAAZ;AACD;;;;AAeD;AACF;AACA;AACA;AACA;AACE,mBAAgB;AACd,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAc,SAAd,EAAyB;AACvB,MAAA,sBAAsB;AACvB;AAED;AACF;AACA;AACA;;;;SACE,eAAiB;AACf,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAe,UAAf,EAA2B;AACzB,OAAC,KAAK,WAAN,yBAAoB,IAApB,eAAuC,UAAvC,IAAoD,kBAAkB,EAAtE;AACD;AAED;AACF;AACA;AACA;;;;SACE,eAAmB;AACjB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAiB,YAAjB,EAA+B;AAC7B,OAAC,KAAK,WAAN,yBACI,IADJ,iBACyB,YADzB,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAsB;AACpB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAoB,eAApB,EAAqC;AACnC,UAAI,kBAAkB,CAAC,eAAD,EAAkB,aAAa,CAAC,YAAhC,EAA8C,IAA9C,CAAtB,EAA2E;AACzE,sDAAwB,eAAxB;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAAa;AACX,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAW,MAAX,EAAmB;AACjB,OAAC,KAAK,WAAN,yBAAoB,IAApB,WAAmC,MAAnC,IAA4C,kBAAkB,EAA9D;AACD;AAED;AACF;AACA;AACA;;;;SACE,eAAoB;AAClB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAkB,aAAlB,EAAiC;AAC/B,UAAI,KAAK,WAAT,EAAsB;AACpB,YAAI,kBAAkB,CAAC,aAAD,EAAgB,aAAa,CAAC,SAA9B,CAAtB,EAAgE;AAC9D,sDAAsB,aAAtB;AACD;AACF,OAJD,MAIO;AACL,YAAI,kBAAkB,CAAC,aAAD,EAAgB,aAAa,CAAC,UAA9B,CAAtB,EAAiE;AAC/D,sDAAsB,aAAtB;AACD;AACF;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAAY;AACV,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAU,KAAV,EAAiB;AACf,OAAC,KAAK,WAAN,yBAAoB,IAApB,UAAkC,KAAlC,IAA0C,kBAAkB,EAA5D;AACD;AAED;AACF;AACA;AACA;;;;SACE,eAAiB;AACf,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAe,UAAf,EAA2B;AACzB,OAAC,KAAK,WAAN,yBAAoB,IAApB,eAAuC,UAAvC,IAAoD,kBAAkB,EAAtE;AACD;AAED;AACF;AACA;AACA;;;;SACE,eAAkB;AAChB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAgB,WAAhB,EAA6B;AAC3B,OAAC,KAAK,WAAN,yBAAoB,IAApB,gBAAwC,WAAxC,IAAsD,kBAAkB,EAAxE;AACD;AAED;AACF;AACA;AACA;;;;SACE,eAAW;AACT,aAAQ,CAAC,KAAK,UAAP,GAAqB,mBAAmB,EAAxC,yBAA6C,IAA7C,QAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAS,IAAT,EAAe;AACb,UAAI,kBAAkB,CAAC,IAAD,EAAO,aAAa,CAAC,OAArB,EAA8B,IAA9B,CAAtB,EAA2D;AACzD,2CAAa,IAAb;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAAmB;AACjB,aAAQ,CAAC,KAAK,UAAP,GAAqB,mBAAmB,EAAxC,yBAA6C,IAA7C,gBAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAiB,YAAjB,EAA+B;AAC7B,UAAI,kBAAkB,CAAC,YAAD,EAAe,aAAa,CAAC,WAA7B,CAAtB,EAAiE;AAC/D,mDAAqB,YAArB;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAAmB;AACjB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAiB,YAAjB,EAA+B;AAC7B,UAAI,kBAAkB,CAAC,YAAD,EAAe,aAAa,CAAC,aAA7B,EAA4C,IAA5C,CAAtB,EAAyE;AACvE,mDAAqB,YAArB;AACD;AACF;AAED;AACF;AACA;AACA;AACA;;;;WACE,6BAAoB,UAApB,EAAwC;AACtC,UAAI,WAAW,yBAAG,IAAH,gBAAf;;AACA,UAAM,SAAS,GAAG,UAAlB;;AAEA,UAAI,OAAO,SAAP,KAAqB,WAArB,IAAoC,SAAS,KAAK,IAAtD,EAA4D;AAC1D,YAAM,OAAO,GAAG,IAAI,IAAJ,GAAW,OAAX,KAAuB,SAAvC;AACA,QAAA,WAAW,GAAG,IAAI,CAAC,kBAAL,CAAwB,OAAO,GAAG,IAAlC,CAAd;AACD;;AAED,aAAO,SAAS,CAAC,oBAAV,uBACH,IADG,gBAEH,WAFG,EAGH,IAAI,MAAJ,CAAW,aAAa,CAAC,WAAzB,CAHG,CAAP;AAKD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,kBAAS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,sBAAc,KAAK,UADN;AAEb,wBAAgB,KAAK,YAFR;AAGb,2BAAmB,KAAK,eAHX;AAIb,kBAAU,KAAK,MAJF;AAKb,yBAAiB,KAAK,aALT;AAMb,iBAAS,KAAK,KAND;AAOb,uBAAe,KAAK,WAPP;AAQb,gBAAQ,KAAK,IARA;AASb,wBAAgB,KAAK,YATR;AAUb,iBAAS,KAAK;AAVD,OAAf;AAYA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;;EAlTmB,e;AAqTtB;AACA;AACA;AACA;;;IACM,a;;;;;AACJ;AACF;AACA;AACE,2BAAc;AAAA;;AAAA,8BACN;AACJ,MAAA,QAAQ,EAAE,iBAAiB,CAAC,mBADxB;AAEJ,MAAA,SAAS,EAAE,mBAAmB,CAAC,iBAF3B;AAGJ,MAAA,UAAU,EAAE;AAHR,KADM;AAMb;;;EAVyB,gB;AAa5B;AACA;AACA;AACA;;;;;;;;;;;IACa,c;;;;;AAMX;AACF;AACA;AACA;AACE,0BAAY,qBAAZ,EAAmC;AAAA;;AAAA;;AACjC;;AADiC;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA,aARlB;AAQkB;;AAAA;AAAA;AAAA,aAPf;AAOe;;AAAA;AAAA;AAAA,aANd;AAMc;;AAGjC,sEAAkB,qBAAqB,GACnC,qBADmC,GAEnC,iBAAiB,CAAC,qBAFtB;;AAHiC;AAMlC;AAED;AACF;AACA;AACA;AACA;;;;;SACE,eAAgB;AACd,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAc,SAAd,EAAyB;AACvB,MAAA,sBAAsB;AACvB;AAED;AACF;AACA;AACA;;;;SACE,eAAoB;AAClB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAkB,aAAlB,EAAiC;AAC/B,OAAC,KAAK,WAAN,yBACI,IADJ,kBAC0B,aAD1B,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAuB;AACrB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAqB,gBAArB,EAAuC;AACrC,OAAC,KAAK,WAAN,yBACI,IADJ,qBAC6B,gBAD7B,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAwB;AACtB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAsB,iBAAtB,EAAyC;AACvC,OAAC,KAAK,WAAN,yBACI,IADJ,sBAC8B,iBAD9B,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,kBAAS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,yBAAiB,KAAK,aADT;AAEb,4BAAoB,KAAK,gBAFZ;AAGb,6BAAqB,KAAK;AAHb,OAAf;AAKA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;;EA9GiC,e;AAiHpC;AACA;AACA;AACA;;;;;;;;;;;;;;;IACa,oB;;;;;AAGX;AACF;AACA;AACA;AACE,gCAAY,2BAAZ,EAAyC;AAAA;;AAAA;;AACvC;;AADuC;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA,aAQhC;AARgC;;AAAA;AAAA;AAAA,aAS7B;AAT6B;;AAAA;AAAA;AAAA,aAUhC;AAVgC;;AAAA;AAAA;AAAA,aAWjC;AAXiC;;AAGvC,sEAAkB,2BAA2B,GACzC,2BADyC,GAEzC,iBAAiB,CAAC,2BAFtB;;AAHuC;AAMxC;;;;;AAOD;AACF;AACA;AACA;AACA;AACE,mBAAgB;AACd,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAc,SAAd,EAAyB;AACvB,MAAA,sBAAsB;AACvB;AAED;AACF;AACA;AACA;;;;SACE,eAAY;AACV,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAU,KAAV,EAAiB;AACf,UAAI,kBAAkB,CAAC,KAAD,EAAQ,aAAa,CAAC,WAAtB,CAAlB,IACA,iBAAiB,CAAC,KAAD,EAAQ,aAAa,CAAC,WAAtB,CADrB,EACyD;AACvD,4CAAc,KAAd;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAAe;AACb,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAa,QAAb,EAAuB;AACrB,UAAI,kBAAkB,CAAC,QAAD,EAAW,aAAa,CAAC,YAAzB,CAAtB,EAA8D;AAC5D,+CAAiB,QAAjB;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAAY;AACV,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAU,KAAV,EAAiB;AACf,UAAI,kBAAkB,CAAC,KAAD,EAAQ,aAAa,CAAC,WAAtB,CAAlB,IACA,iBAAiB,CAAC,KAAD,EAAQ,aAAa,CAAC,WAAtB,CADrB,EACyD;AACvD,4CAAc,KAAd;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAAW;AACT,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAS,IAAT,EAAe;AACb,UAAI,kBAAkB,CAAC,IAAD,EAAO,aAAa,CAAC,WAArB,CAAlB,IACA,iBAAiB,CAAC,IAAD,EAAO,aAAa,CAAC,UAArB,CADrB,EACuD;AACrD,2CAAa,IAAb;AACD;AACF;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,kBAAS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,iBAAS,KAAK,KADD;AAEb,oBAAY,KAAK,QAFJ;AAGb,iBAAS,KAAK,KAHD;AAIb,gBAAQ,KAAK;AAJA,OAAf;AAMA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;;EAvIuC,e;AA0I1C;AACA;AACA;AACA;;;;;IACM,e;;;;;AACJ;AACF;AACA;AACE,6BAAc;AAAA;;AAAA,8BACN;AACJ,MAAA,QAAQ,EAAE,iBAAiB,CAAC,qBADxB;AAEJ,MAAA,SAAS,EAAE,mBAAmB,CAAC,iBAF3B;AAGJ,MAAA,UAAU,EAAE;AAHR,KADM;AAMb;;;EAV2B,gB;AAa9B;AACA;AACA;AACA;;;;;;;;;;;;;;;;;IACa,qB;;;;;AACX;AACF;AACA;AACE,mCAAc;AAAA;;AAAA;;AACZ;;AADY;AAAA;AAAA,aAwBR;AAxBQ;;AAAA;AAAA;AAAA,aAyBN;AAzBM;;AAAA;AAAA;AAAA,aA0BN;AA1BM;;AAAA;AAAA;AAAA,aA2BD;AA3BC;;AAAA;AAAA;AAAA,aA4BM;AA5BN;;AAAA;AAAA;AAAA,aA6BJ;AA7BI;;AAAA;AAAA;AAAA,aA8BH;AA9BG;;AAGZ,WAAK,UAAL,GAAkB,IAAI,gBAAJ,CAAa;AAC7B,MAAA,SAAS,EAAE,mBAAmB,CAAC,iBADF;AAE7B,MAAA,UAAU,EAAE,kCAFiB;AAG7B,MAAA,QAAQ,EAAE,iBAAiB,CAAC;AAHC,KAAb,CAAlB;AAKA,WAAK,iBAAL,GAAyB,IAAI,gBAAJ,CAAa;AACpC,MAAA,SAAS,EAAE,mBAAmB,CAAC,iBADK;AAEpC,MAAA,UAAU,EAAE,kCAFwB;AAGpC,MAAA,QAAQ,EAAE,iBAAiB,CAAC;AAHQ,KAAb,CAAzB;AARY;AAab;AAED;AACF;AACA;;;;;WACE,sBAAa;AAAA;;AACX;;AACA,gCAAK,UAAL,wEAAiB,UAAjB;AACA,oCAAK,iBAAL,gFAAwB,UAAxB;AACD;;;;AAUD;AACF;AACA;AACA;AACE,mBAAS;AACP,aAAQ,CAAC,KAAK,UAAP,GAAqB,mBAAmB,EAAxC,yBAA6C,IAA7C,MAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAO,EAAP,EAAW;AACT,UAAI,kBAAkB,CAAC,EAAD,EAAK,aAAa,CAAC,aAAnB,CAAtB,EAAyD;AACvD,yCAAW,EAAX;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAAW;AACT,aAAQ,CAAC,KAAK,UAAP,GAAqB,mBAAmB,EAAxC,yBAA6C,IAA7C,QAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAS,IAAT,EAAe;AACb,UAAI,kBAAkB,CAAC,IAAD,EAAO,aAAa,CAAC,OAArB,CAAtB,EAAqD;AACnD,2CAAa,IAAb;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAAW;AACT,aAAQ,CAAC,KAAK,UAAP,GAAqB,mBAAmB,EAAxC,yBAA6C,IAA7C,QAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAS,IAAT,EAAe;AACb,UAAI,kBAAkB,CAAC,IAAD,EAAO,aAAa,CAAC,OAArB,CAAtB,EAAqD;AACnD,2CAAa,IAAb;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAAgB;AACd,aAAQ,CAAC,KAAK,UAAP,GACH,mBAAmB,EADhB,yBAEH,IAFG,aAAP;AAGD;AAED;AACF;AACA;AACA;;SACE,aAAc,SAAd,EAAyB;AACvB,UAAI,kBAAkB,CAAC,SAAD,EAAY,aAAa,CAAC,UAA1B,CAAlB,IACA,iBAAiB,CAAC,SAAD,EAAY,aAAa,CAAC,eAA1B,CADrB,EACiE;AAC/D,gDAAkB,SAAlB;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAAuB;AACrB,aAAQ,CAAC,KAAK,UAAP,GAAqB,mBAAmB,EAAxC,yBAA6C,IAA7C,oBAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAqB,gBAArB,EAAuC;AACrC,UAAI,kBAAkB,CAAC,gBAAD,EAAmB,aAAa,CAAC,WAAjC,EAA8C,IAA9C,CAAtB,EAA2E;AACzE,uDAAyB,gBAAzB;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAAa;AACX,aAAQ,CAAC,KAAK,UAAP,GAAqB,mBAAmB,EAAxC,yBAA6C,IAA7C,UAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAW,MAAX,EAAmB;AACjB,UAAI,kBAAkB,CAAC,MAAD,EAAS,aAAa,CAAC,SAAvB,CAAtB,EAAyD;AACvD,6CAAe,MAAf;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAAc;AACZ,aAAQ,CAAC,KAAK,UAAP,GAAqB,mBAAmB,EAAxC,yBAA6C,IAA7C,WAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAY,OAAZ,EAAqB;AACnB,UAAI,kBAAkB,CAAC,OAAD,EAAU,aAAa,CAAC,WAAxB,CAAtB,EAA4D;AAC1D,8CAAgB,OAAhB;AACD;AACF;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,kBAAS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,cAAM,KAAK,EADE;AAEb,gBAAQ,KAAK,IAFA;AAGb,gBAAQ,KAAK,IAHA;AAIb,qBAAa,KAAK,SAJL;AAKb,4BAAoB,KAAK,gBALZ;AAMb,kBAAU,KAAK,MANF;AAOb,mBAAW,KAAK,OAPH;AAQb,sBAAc,KAAK,UARN;AASb,6BAAqB,KAAK;AATb,OAAf;AAWA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;;EArMwC,e;AAwM3C;AACA;AACA;AACA;;;;;;;;;IACa,mB;;;;;AACX;AACF;AACA;AACE,iCAAc;AAAA;;AAAA;;AACZ;;AADY;AAAA;AAAA,aAcR;AAdQ;;AAAA;AAAA;AAAA,aAeJ;AAfI;;AAGZ,WAAK,KAAL,GAAa,IAAI,gBAAJ,CACT;AACE,MAAA,cAAc,EAAE,iBAAiB,CAAC,cADpC;AAEE,MAAA,WAAW,EAAE,aAAa,CAAC,WAF7B;AAGE,MAAA,gBAAgB,EAAE,mBAAmB,CAAC,iBAHxC;AAIE,MAAA,eAAe,EAAE,mBAAmB,CAAC,aAJvC;AAKE,MAAA,gBAAgB,EAAE,mBAAmB,CAAC,kBALxC;AAME,MAAA,UAAU,EAAE;AANd,KADS,CAAb;AAHY;AAYb;;;;;AAKD;AACF;AACA;AACA;AACE,mBAAS;AACP,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAO,EAAP,EAAW;AACT,UAAI,kBAAkB,CAAC,EAAD,EAAK,aAAa,CAAC,aAAnB,CAAtB,EAAyD;AACvD,0CAAW,EAAX;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAAa;AACX,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAW,MAAX,EAAmB;AACjB,UAAI,kBAAkB,CAAC,MAAD,EAAS,aAAa,CAAC,UAAvB,CAAtB,EAA0D;AACxD,6CAAe,MAAf;AACD;AACF;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,kBAAS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,cAAM,KAAK,EADE;AAEb,kBAAU,KAAK,MAFF;AAGb,iBAAS,KAAK;AAHD,OAAf;AAKA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;;EA5EsC,e;AA+EzC;AACA;AACA;AACA;;;;;;;IACa,+B;;;;;AACX;AACF;AACA;AACE,6CAAc;AAAA;;AAAA;;AACZ;;AADY;AAAA;AAAA,aAIR;AAJQ;;AAAA;AAEb;;;;;AAID;AACF;AACA;AACA;AACE,mBAAS;AACP,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAO,EAAP,EAAW;AACT,UAAI,kBAAkB,CAAC,EAAD,EAAK,aAAa,CAAC,aAAnB,CAAtB,EAAyD;AACvD,0CAAW,EAAX;AACD;AACF;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,kBAAS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,cAAM,KAAK;AADE,OAAf;AAGA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;;EA3CkD,e;AA8CrD;AACA;AACA;AACA;;;;;;;IACa,qC;;;;;AACX;AACF;AACA;AACE,mDAAc;AAAA;;AAAA;;AACZ;;AADY;AAAA;AAAA,aAIH;AAJG;;AAAA;AAEb;;;;;AAID;AACF;AACA;AACA;AACE,mBAAc;AACZ,aAAQ,CAAC,KAAK,UAAP,GAAqB,mBAAmB,EAAxC,yBAA6C,IAA7C,WAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAY,OAAZ,EAAqB;AACnB,UAAI,kBAAkB,CAAC,OAAD,EAAU,aAAa,CAAC,WAAxB,EAAqC,IAArC,CAAtB,EAAkE;AAChE,8CAAgB,OAAhB;AACD;AACF;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,kBAAS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,mBAAW,KAAK;AADH,OAAf;AAGA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;;EA3CwD,e;AA8C3D;AACA;AACA;;;;;;;IACa,G;;;;;AACX;AACF;AACA;AACE,iBAAc;AAAA;;AAAA;;AACZ;;AADY;AAAA;AAAA,aAIL;AAJK;;AAAA;AAEb;;;;;AAID;AACF;AACA;AACA;AACE,mBAAY;AACV,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAU,KAAV,EAAiB;AACf,UAAI,kBAAkB,CAAC,KAAD,EAAQ,aAAa,CAAC,QAAtB,CAAtB,EAAuD;AACrD,4CAAc,KAAd;AACD;AACF;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,kBAAS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,iBAAS,KAAK;AADD,OAAf;AAGA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;;EA3CsB,e;;;;;;;;;;;;;;;;;;ACjvCzB,IAAM,MAAM,GAAG;AACb,EAAA,UAAU,EAAE,MADC;AAEb,EAAA,WAAW,EAAE,OAFA;AAGb,EAAA,qBAAqB,EAAE,CAHV;AAIb,EAAA,iBAAiB,EAAE,CAJN;AAKb,EAAA,gBAAgB,EAAE,CALL;AAMb,EAAA,eAAe,EAAE,CANJ;AAOb,EAAA,cAAc,EAAE,CAPH;AAQb,EAAA,iBAAiB,EAAE,CARN;AASb,EAAA,eAAe,EAAE,CATJ;AAUb,EAAA,cAAc,EAAE;AAVH,CAAf;AAaA,IAAM,OAAO,GAAG;AACd;AACA,EAAA,YAAY,EAAE,gGAFA;AAGd,EAAA,aAAa,EAAE,mHAHD;AAId,EAAA,cAAc,EAAE,aAJF;AAKd,EAAA,iBAAiB,EAAE,uBALL;AAMd,EAAA,mBAAmB,EAAE,iBANP;AAOd,EAAA,0BAA0B,EAAE,SAPd;AAQd,EAAA,qBAAqB,EAAE,kDART;AASd,EAAA,2BAA2B,EAAE,2BATf;AAUd,EAAA,qBAAqB,EAAE,qFAVT;AAYd,EAAA,kBAAkB,EAAE;AAClB,WAAO;AACL,MAAA,YAAY,EAAE,mBADT;AAEL,MAAA,aAAa,EAAE;AAFV,KADW;AAKlB,WAAO;AACL,MAAA,YAAY,EAAE,wBADT;AAEL,MAAA,aAAa,EAAE;AAFV,KALW;AASlB,WAAO;AACL,MAAA,YAAY,EAAE,8BADT;AAEL,MAAA,aAAa,EAAE;AAFV,KATW;AAalB,WAAO;AACL,MAAA,YAAY,EAAE,0CADT;AAEL,MAAA,aAAa,EAAE;AAFV,KAbW;AAiBlB,WAAO;AACL,MAAA,YAAY,EAAE,iBADT;AAEL,MAAA,aAAa,EAAE;AAFV,KAjBW;AAqBlB,WAAO;AACL,MAAA,YAAY,EAAE,uBADT;AAEL,MAAA,aAAa,EAAE;AAFV,KArBW;AAyBlB,WAAO;AACL,MAAA,YAAY,EAAE,yCADT;AAEL,MAAA,aAAa,EAAE;AAFV,KAzBW;AA6BlB,WAAO;AACL,MAAA,YAAY,EAAE,sBADT;AAEL,MAAA,aAAa,EAAE;AAFV,KA7BW;AAiClB,WAAO;AACL,MAAA,YAAY,EAAE,uBADT;AAEL,MAAA,aAAa,EAAE;AAFV,KAjCW;AAqClB,WAAO;AACL,MAAA,YAAY,EAAE,qBADT;AAEL,MAAA,aAAa,EAAE;AAFV,KArCW;AAyClB,WAAO;AACL,MAAA,YAAY,EAAE,4BADT;AAEL,MAAA,aAAa,EAAE;AAFV,KAzCW;AA6ClB,WAAO;AACL,MAAA,YAAY,EAAE,uCADT;AAEL,MAAA,aAAa,EAAE;AAFV;AA7CW;AAZN,CAAhB;;AAgEA,IAAM,IAAI,mCACL,OADK,GACO;AACb,EAAA,YAAY,EAAE,2GADD;AAEb,EAAA,2BAA2B,EAAE,wFAFhB;AAGb,EAAA,qBAAqB,EAAE,uEAHV;AAIb,EAAA,6BAA6B,EAAE,2IAJlB;AAKb,EAAA,cAAc,EAAE,mBALH;AAMb,EAAA,wBAAwB,EAAE,qBANb;AAOb,EAAA,cAAc,EAAE;AAPH,CADP,CAAV;;AAYA,IAAM,SAAS,GAAG;AAChB;AACA,EAAA,YAAY,EAAE,sTAFE;AAGhB,EAAA,iBAAiB,EAAE,4BAHH;AAIhB,EAAA,cAAc,EAAE,oBAJA;AAKhB,EAAA,mBAAmB,EAAE,wEALL;AAMhB,EAAA,0BAA0B,EAAE,SANZ;AAOhB,EAAA,qBAAqB,EAAE,kDAPP;AAQhB,EAAA,2BAA2B,EAAE,sDARb;AAShB,EAAA,qBAAqB,EAAE,sGATP;AAWhB,EAAA,kBAAkB,EAAE;AAClB,SAAK;AACH,MAAA,YAAY,EAAE,UADX;AAEH,MAAA,aAAa,EAAE;AAFZ,KADa;AAKlB,WAAO;AACL,MAAA,YAAY,EAAE,mBADT;AAEL,MAAA,aAAa,EAAE;AAFV,KALW;AASlB,WAAO;AACL,MAAA,YAAY,EAAE,gCADT;AAEL,MAAA,aAAa,EAAE;AAFV,KATW;AAalB,WAAO;AACL,MAAA,YAAY,EAAE,qBADT;AAEL,MAAA,aAAa,EAAE;AAFV,KAbW;AAiBlB,WAAO;AACL,MAAA,YAAY,EAAE,6BADT;AAEL,MAAA,aAAa,EAAE;AAFV,KAjBW;AAqBlB,WAAO;AACL,MAAA,YAAY,EAAE,6BADT;AAEL,MAAA,aAAa,EAAE;AAFV,KArBW;AAyBlB,WAAO;AACL,MAAA,YAAY,EAAE,mCADT;AAEL,MAAA,aAAa,EAAE;AAFV,KAzBW;AA6BlB,WAAO;AACL,MAAA,YAAY,EAAE,+BADT;AAEL,MAAA,aAAa,EAAE;AAFV,KA7BW;AAiClB,WAAO;AACL,MAAA,YAAY,EAAE,qCADT;AAEL,MAAA,aAAa,EAAE;AAFV,KAjCW;AAqClB,WAAO;AACL,MAAA,YAAY,EAAE,iCADT;AAEL,MAAA,aAAa,EAAE;AAFV,KArCW;AAyClB,WAAO;AACL,MAAA,YAAY,EAAE,kCADT;AAEL,MAAA,aAAa,EAAE;AAFV,KAzCW;AA6ClB,WAAO;AACL,MAAA,YAAY,EAAE,8BADT;AAEL,MAAA,aAAa,EAAE;AAFV,KA7CW;AAiDlB,WAAO;AACL,MAAA,YAAY,EAAE,8BADT;AAEL,MAAA,aAAa,EAAE;AAFV,KAjDW;AAqDlB,WAAO;AACL,MAAA,YAAY,EAAE,0BADT;AAEL,MAAA,aAAa,EAAE;AAFV,KArDW;AAyDlB,WAAO;AACL,MAAA,YAAY,EAAE,wBADT;AAEL,MAAA,aAAa,EAAE;AAFV,KAzDW;AA6DlB,WAAO;AACL,MAAA,YAAY,EAAE,qBADT;AAEL,MAAA,aAAa,EAAE;AAFV,KA7DW;AAiElB,WAAO;AACL,MAAA,YAAY,EAAE,qBADT;AAEL,MAAA,aAAa,EAAE;AAFV,KAjEW;AAqElB,WAAO;AACL,MAAA,YAAY,EAAE,wBADT;AAEL,MAAA,aAAa,EAAE;AAFV,KArEW;AAyElB,WAAO;AACL,MAAA,YAAY,EAAE,8BADT;AAEL,MAAA,aAAa,EAAE;AAFV,KAzEW;AA6ElB,WAAO;AACL,MAAA,YAAY,EAAE,kCADT;AAEL,MAAA,aAAa,EAAE;AAFV,KA7EW;AAiFlB,WAAO;AACL,MAAA,YAAY,EAAE,0CADT;AAEL,MAAA,aAAa,EAAE;AAFV,KAjFW;AAqFlB,WAAO;AACL,MAAA,YAAY,EAAE,iCADT;AAEL,MAAA,aAAa,EAAE;AAFV,KArFW;AAyFlB,WAAO;AACL,MAAA,YAAY,EAAE,kCADT;AAEL,MAAA,aAAa,EAAE;AAFV,KAzFW;AA6FlB,WAAO;AACL,MAAA,YAAY,EAAE,kCADT;AAEL,MAAA,aAAa,EAAE;AAFV,KA7FW;AAiGlB,WAAO;AACL,MAAA,YAAY,EAAE,uCADT;AAEL,MAAA,aAAa,EAAE;AAFV,KAjGW;AAqGlB,WAAO;AACL,MAAA,YAAY,EAAE,uCADT;AAEL,MAAA,aAAa,EAAE;AAFV;AArGW;AAXJ,CAAlB;AAuHA,IAAM,YAAY,GAAG;AACnB,EAAA,MAAM,EAAE,MADW;AAEnB,EAAA,OAAO,EAAE,OAFU;AAGnB,EAAA,IAAI,EAAE,IAHa;AAInB,EAAA,SAAS,EAAE;AAJQ,CAArB;eAOe,Y;;;;;;;;;;;;;;;;;ACxNf,IAAM,MAAM,GAAG;AACb,EAAA,OAAO,EAAE,GADI;AAEb,EAAA,qBAAqB,EAAE,GAFV;AAGb,EAAA,WAAW,EAAE,GAHA;AAIb,EAAA,UAAU,EAAE,GAJC;AAKb,EAAA,mBAAmB,EAAE,GALR;AAMb,EAAA,uBAAuB,EAAE,GANZ;AAOb,EAAA,oBAAoB,EAAE,GAPT;AAQb,EAAA,oBAAoB,EAAE,GART;AASb,EAAA,mBAAmB,EAAE,GATR;AAUb,EAAA,iBAAiB,EAAE,GAVN;AAWb,EAAA,gBAAgB,EAAE,GAXL;AAYb,EAAA,kBAAkB,EAAE,GAZP;AAab,EAAA,iBAAiB,EAAE,GAbN;AAcb,EAAA,cAAc,EAAE,GAdH;AAeb,EAAA,cAAc,EAAE,GAfH;AAgBb,EAAA,WAAW,EAAE,GAhBA;AAiBb,EAAA,mBAAmB,EAAE,GAjBR;AAkBb,EAAA,mBAAmB,EAAE,GAlBR;AAmBb,EAAA,sBAAsB,EAAE,GAnBX;AAoBb,EAAA,oBAAoB,EAAE,GApBT;AAqBb,EAAA,qBAAqB,EAAE,GArBV;AAsBb,EAAA,qBAAqB,EAAE,GAtBV;AAuBb,EAAA,iBAAiB,EAAE,GAvBN;AAwBb,EAAA,iBAAiB,EAAE,GAxBN;AAyBb,EAAA,kBAAkB,EAAE,GAzBP;AA0Bb,EAAA,aAAa,EAAE,GA1BF;AA2Bb,EAAA,kBAAkB,EAAE,GA3BP;AA4Bb,EAAA,0BAA0B,EAAE;AA5Bf,CAAf;;AA+BA,IAAM,OAAO,mCACR,MADQ,GACG;AACZ,EAAA,oBAAoB,EAAE,GADV;AAEZ,EAAA,iBAAiB,EAAE,GAFP;AAGZ,EAAA,kBAAkB,EAAE,GAHR;AAIZ,EAAA,cAAc,EAAE,GAJJ;AAKZ,EAAA,cAAc,EAAE,GALJ;AAMZ,EAAA,WAAW,EAAE,GAND;AAOZ,EAAA,oBAAoB,EAAE,GAPV;AAQZ,EAAA,qBAAqB,EAAE,GARX;AASZ,EAAA,qBAAqB,EAAE,GATX;AAUZ,EAAA,iBAAiB,EAAE,GAVP;AAWZ,EAAA,iBAAiB,EAAE,GAXP;AAYZ,EAAA,kBAAkB,EAAE,GAZR;AAaZ,EAAA,aAAa,EAAE,GAbH;AAcZ,EAAA,kBAAkB,EAAE,GAdR;AAeZ,EAAA,0BAA0B,EAAE;AAfhB,CADH,CAAb;;AAoBA,IAAM,SAAS,mCACV,MADU,GACC;AACZ,EAAA,qBAAqB,EAAE,GADX;AAEZ,EAAA,WAAW,EAAE,GAFD;AAGZ,EAAA,UAAU,EAAE,GAHA;AAIZ,EAAA,mBAAmB,EAAE,GAJT;AAKZ,EAAA,uBAAuB,EAAE,GALb;AAMZ,EAAA,qBAAqB,EAAE,GANX;AAOZ,EAAA,oBAAoB,EAAE,GAPV;AAQZ,EAAA,mBAAmB,EAAE,GART;AASZ,EAAA,iBAAiB,EAAE,GATP;AAUZ,EAAA,gBAAgB,EAAE,GAVN;AAWZ,EAAA,kBAAkB,EAAE,GAXR;AAYZ,EAAA,iBAAiB,EAAE,GAZP;AAaZ,EAAA,cAAc,EAAE,GAbJ;AAcZ,EAAA,mBAAmB,EAAE,GAdT;AAeZ,EAAA,mBAAmB,EAAE,GAfT;AAgBZ,EAAA,sBAAsB,EAAE,GAhBZ;AAiBZ,EAAA,oBAAoB,EAAE,GAjBV;AAkBZ,EAAA,qBAAqB,EAAE,GAlBX;AAmBZ,EAAA,qBAAqB,EAAE,GAnBX;AAoBZ,EAAA,iBAAiB,EAAE,GApBP;AAqBZ,EAAA,kBAAkB,EAAE,GArBR;AAsBZ,EAAA,aAAa,EAAE,GAtBH;AAuBZ,EAAA,kBAAkB,EAAE,GAvBR;AAwBZ,EAAA,0BAA0B,EAAE;AAxBhB,CADD,CAAf;;AA6BA,IAAM,UAAU,GAAG;AACjB,EAAA,OAAO,EAAE,OADQ;AAEjB,EAAA,SAAS,EAAE;AAFM,CAAnB;eAKe,U;;;;;;;;;;;;;;;;;ACpFf,IAAM,OAAO,GAAG;AACd,EAAA,YAAY,EAAE,YADA;AAEd,EAAA,aAAa,EAAE,aAFD;AAGd,EAAA,OAAO,EAAE,uDAHK;AAGoD;AAClE,EAAA,WAAW,EAAE,oDAJC;AAIqD;AACnE,EAAA,UAAU,EAAE,QALE;AAMd,EAAA,WAAW,EAAE,cANC;AAOd,EAAA,UAAU,EAAE,6BAPE;AAO6B;AAC3C,EAAA,aAAa,EAAE,+BARD;AASd,EAAA,WAAW,EAAE,YATC;AASa;AAC3B,EAAA,QAAQ,EAAE,aAVI;AAYd;AACA,EAAA,SAAS,EAAE,gDAbG;AAcd,EAAA,UAAU,EAAE,8DAdE;AAed,EAAA,OAAO,EAAE,8BAfK;AAgBd,EAAA,OAAO,EAAE,8EAhBK;AAiBd,EAAA,SAAS,EAAE,mEAjBG;AAiBkE;AAChF,EAAA,QAAQ,EAAE,uBAlBI;AAoBd;AACA,EAAA,WAAW,EAAE,OArBC;AAsBd,EAAA,WAAW,EAAE,QAtBC;AAuBd,EAAA,WAAW,EAAE,UAvBC;AAwBd,EAAA,eAAe,EAAE,UAxBH;AAyBd,EAAA,UAAU,EAAE;AAzBE,CAAhB;;AA4BA,IAAM,IAAI,mCACL,OADK,GACO;AACb,EAAA,aAAa,EAAE;AADF,CADP,CAAV;;AAMA,IAAM,SAAS,GAAG;AAChB,EAAA,YAAY,EAAE,4BADE;AAEhB,EAAA,YAAY,EAAE,4BAFE;AAGhB,EAAA,aAAa,EAAE,6BAHC;AAIhB,EAAA,aAAa,EAAE,6BAJC;AAKhB,EAAA,cAAc,EAAE,8BALA;AAMhB,EAAA,OAAO,EAAE,iDANO;AAM4C;AAC5D,EAAA,gBAAgB,EAAE,+EAPF;AAOmF;AACnG,EAAA,SAAS,EAAE,iEARK;AAQ8D;AAC9E,EAAA,kBAAkB,EAAE,yEATJ;AAS+E;AAC/F,EAAA,iBAAiB,EAAE,gFAVH;AAUqF;AACrG,EAAA,OAAO,EAAE,0RAXO;AAYhB,EAAA,WAAW,EAAE,4HAZG;AAahB,EAAA,UAAU,EAAE,QAbI;AAchB,EAAA,WAAW,EAAE,cAdG;AAehB,EAAA,UAAU,EAAE,mCAfI;AAgBhB,EAAA,aAAa,EAAE,yBAhBC;AAiBhB,EAAA,kBAAkB,EAAE,yBAjBJ;AAiB+B;AAC/C,EAAA,iBAAiB,EAAE,wEAlBH;AAkB6E;AAC7F,EAAA,WAAW,EAAE,MAnBG;AAmBK;AACrB,EAAA,QAAQ,EAAE,aApBM;AAqBhB,EAAA,aAAa,EAAE,WArBC;AAuBhB;AACA,EAAA,UAAU,EAAE,gDAxBI;AAyBhB,EAAA,UAAU,EAAE,2BAzBI;AA0BhB,EAAA,OAAO,EAAE,oCA1BO;AA2BhB,EAAA,OAAO,EAAE,iGA3BO;AA4BhB,EAAA,SAAS,EAAE,6EA5BK;AA6BhB,EAAA,QAAQ,EAAE,8GA7BM;AA6B0G;AAC1H,EAAA,UAAU,EAAE,wBA9BI;AA+BhB,EAAA,SAAS,EAAE,6DA/BK;AAiChB;AACA,EAAA,YAAY,EAAE,MAlCE;AAmChB,EAAA,WAAW,EAAE,KAnCG;AAoChB,EAAA,WAAW,EAAE,KApCG;AAqChB,EAAA,UAAU,EAAE,MArCI;AAsChB,EAAA,cAAc,EAAE;AAtCA,CAAlB;AAyCA,IAAM,KAAK,GAAG;AACZ,EAAA,IAAI,EAAE,IADM;AAEZ,EAAA,OAAO,EAAE,OAFG;AAGZ,EAAA,SAAS,EAAE;AAHC,CAAd;eAMe,K;;;;;;;;;;;;;ACjFf;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,IAAM,cAAc,GAAG,0BAAa,OAAb,CAAqB,kBAA5C;AACA,IAAM,WAAW,GAAG,0BAAa,IAAb,CAAkB,kBAAtC;AACA,IAAM,gBAAgB,GAAG,0BAAa,SAAb,CAAuB,kBAAhD;AAEA;AACA;AACA;;;;;;;;IACa,e;;;;;AACX;AACF;AACA;AACA;AACA;AACA;AACE,2BAAY,SAAZ,EAA+B,YAA/B,EAAqD,eAArD,EAA8E;AAAA;;AAAA;;AAC5E,8BAAM,YAAN;;AAD4E;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAE5E,qEAAkB,SAAlB;;AACA,wEAAqB,YAArB;;AACA,2EAAwB,eAAxB;;AAJ4E;AAK7E;;;;;AAMD;AACF;AACA;AACA;AACE,mBAAgB;AACd,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;;;SACE,eAAmB;AACjB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;;;SACE,eAAsB;AACpB,mCAAO,IAAP;AACD;;;;iCAxCkC,K;AA2CrC;AACA;AACA;;;;;IACa,sB;;;;;AACX;AACF;AACA;AACA;AACE,kCAAY,SAAZ,EAA+B;AAAA;;AAAA;;AAC7B,QAAI,GAAG,cAAH,CAAkB,IAAlB,CAAuB,cAAvB,EAAuC,MAAM,CAAC,SAAD,CAA7C,CAAJ,EAA+D;AAC7D,kCAAM,SAAN,EAAiB,cAAc,CAAC,MAAM,CAAC,SAAD,CAAP,CAAd,CAAkC,YAAnD,EAAiE,cAAc,CAAC,MAAM,CAAC,SAAD,CAAP,CAAd,CAAkC,aAAnG;AACD,KAFD,MAEO;AACL,kCAAM,GAAN,EAAW,cAAc,CAAC,KAAD,CAAd,CAAsB,YAAjC,EAA+C,cAAc,CAAC,KAAD,CAAd,CAAsB,aAArE;AACD;;AAL4B;AAM9B;;;EAXyC,e;AAc5C;AACA;AACA;;;;;IACa,mB;;;;;AACX;AACF;AACA;AACA;AACE,+BAAY,SAAZ,EAA+B;AAAA;;AAAA;;AAC7B,QAAI,GAAG,cAAH,CAAkB,IAAlB,CAAuB,WAAvB,EAAoC,MAAM,CAAC,SAAD,CAA1C,CAAJ,EAA4D;AAC1D,kCAAM,SAAN,EAAiB,WAAW,CAAC,MAAM,CAAC,SAAD,CAAP,CAAX,CAA+B,YAAhD,EAA8D,WAAW,CAAC,MAAM,CAAC,SAAD,CAAP,CAAX,CAA+B,aAA7F;AACD,KAFD,MAEO;AACL,kCAAM,GAAN,EAAW,WAAW,CAAC,KAAD,CAAX,CAAmB,YAA9B,EAA4C,WAAW,CAAC,KAAD,CAAX,CAAmB,aAA/D;AACD;;AAL4B;AAM9B;;;EAXsC,e;AAczC;AACA;AACA;;;;;IACa,wB;;;;;AACX;AACF;AACA;AACA;AACE,oCAAY,SAAZ,EAA+B;AAAA;;AAAA;;AAC7B,QAAI,GAAG,cAAH,CAAkB,IAAlB,CAAuB,gBAAvB,EAAyC,MAAM,CAAC,SAAD,CAA/C,CAAJ,EAAiE;AAC/D,kCAAM,SAAN,EAAiB,gBAAgB,CAAC,MAAM,CAAC,SAAD,CAAP,CAAhB,CAAoC,YAArD,EAAmE,gBAAgB,CAAC,MAAM,CAAC,SAAD,CAAP,CAAhB,CAAoC,aAAvG;AACD,KAFD,MAEO;AACL,kCAAM,GAAN,EAAW,gBAAgB,CAAC,KAAD,CAAhB,CAAwB,YAAnC,EAAiD,gBAAgB,CAAC,KAAD,CAAhB,CAAwB,aAAzE;AACD;;AAL4B;AAM9B;;;EAX2C,e;;;;;;;AC3F9C;;;;AAEA,MAAM,CAAC,IAAP,GAAc,gBAAd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACDO,IAAM,kBAAkB,GAAG,GAA3B;;AACA,IAAM,kBAAkB,GAAG,EAA3B;;AACA,IAAM,gBAAgB,GAAG,KAAK,kBAA9B;;AACA,IAAM,eAAe,GAAG,KAAK,gBAA7B;;AAEP,IAAM,YAAY,GAAG,CACnB,CAAC,GAAD,EAAM,eAAN,CADmB,EAEnB,CAAC,GAAD,EAAM,gBAAN,CAFmB,EAGnB,CAAC,GAAD,EAAM,kBAAN,CAHmB,EAInB,CAAC,GAAD,EAAM,kBAAN,CAJmB,CAArB;AAOA;AACA;AACA;AACA;AACA;AACA;;AACO,SAAS,kBAAT,CAA4B,YAA5B,EAAkD;AACvD;AACA,MAAI,CAAC,YAAD,IAAiB,YAAY,IAAI,CAArC,EAAwC;AACtC,WAAO,UAAP;AACD;;AAED,MAAM,KAAK,GAAG,IAAI,CAAC,KAAL,CAAW,YAAY,GAAG,gBAA1B,CAAd;AAEA,MAAM,OAAO,GAAG,IAAI,IAAJ,CAAS,YAAY,GAAG,IAAxB,CAAhB;AACA,MAAM,OAAO,GAAG,OAAO,CAAC,aAAR,EAAhB,CATuD,CAUvD;;AACA,MAAM,OAAO,GAAG,OAAO,CAAC,UAAR,EAAhB;AACA,MAAM,EAAE,GAAG,YAAY,GAAG,GAA1B;AACA,MAAI,KAAK,GAAG,EAAZ;;AACA,MAAI,aAAa,CAAC,EAAD,CAAb,GAAoB,CAAxB,EAA2B;AACzB,QAAI,aAAa,CAAC,EAAD,CAAb,GAAoB,CAAxB,EAA2B;AACzB,MAAA,KAAK,GAAG,EAAE,CAAC,OAAH,CAAW,CAAX,CAAR;AACD,KAFD,MAEO;AACL,MAAA,KAAK,GAAG,MAAM,CAAC,EAAD,CAAd;AACD;;AACD,IAAA,KAAK,GAAG,MAAM,KAAK,CAAC,KAAN,CAAY,GAAZ,EAAiB,CAAjB,CAAd;AACD;;AAED,SAAO,CAAC,KAAK,GAAG,GAAR,GAAc,OAAd,GAAwB,GAAxB,GAA8B,OAA/B,EAAwC,OAAxC,CAAgD,SAAhD,EACH,KADG,IACM,KADb;AAED;AAED;AACA;AACA;AACA;AACA;AACA;;;AACO,SAAS,uBAAT,CAAiC,OAAjC,EAAkD;AACvD;AACA,MAAI,CAAC,OAAD,IAAY,OAAO,IAAI,CAA3B,EAA8B;AAC5B,WAAO,MAAP;AACD;;AAED,MAAI,QAAQ,GAAG,GAAf;AACA,MAAI,SAAS,GAAG,OAAhB;AAEA,EAAA,YAAY,CAAC,OAAb,CAAqB,gBAA6B;AAAA;AAAA,QAA3B,IAA2B;AAAA,QAArB,eAAqB;;AAChD,QAAI,KAAK,GAAG,IAAI,CAAC,KAAL,CAAW,SAAS,GAAG,eAAvB,CAAZ;AAEA,IAAA,SAAS,GAAG,SAAS,GAAG,eAAxB;;AACA,QAAI,aAAa,CAAC,SAAD,CAAb,GAA2B,CAA/B,EAAkC;AAChC,MAAA,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,SAAD,CAAN,CAAkB,OAAlB,CAA0B,CAA1B,CAAD,CAAlB;AACD,KAN+C,CAOhD;AACA;;;AACA,QAAI,IAAI,KAAK,GAAT,IAAgB,SAAS,GAAG,CAAhC,EAAmC;AACjC,MAAA,KAAK,IAAI,SAAT;AACD;;AAED,QAAI,KAAJ,EAAW;AACT,UAAI,CAAC,QAAQ,CAAC,OAAT,CAAiB,GAAjB,IAAwB,CAAxB,IACD,IAAI,KAAK,GADR,IACe,IAAI,KAAK,GADxB,IAC+B,IAAI,KAAK,GADzC,KAEA,QAAQ,CAAC,OAAT,CAAiB,GAAjB,MAA0B,CAAC,CAF/B,EAEkC;AAChC,QAAA,QAAQ,IAAI,GAAZ;AACD;;AACD,MAAA,QAAQ,cAAO,KAAP,SAAe,IAAf,CAAR;AACD;AACF,GArBD;AAuBA,SAAO,QAAP;AACD;AAED;AACA;AACA;AACA;AACA;AACA;AACA;;;AACO,SAAS,gBAAT,CAA0B,UAA1B,EAA8C,SAA9C,EAAiE;AACtE,MAAI,CAAC,UAAD,IAAe,OAAO,UAAP,KAAsB,QAArC,IACA,CAAC,UAAU,CAAC,KAAX,CAAiB,SAAjB,CADL,EACkC;AAChC,WAAO,CAAP;AACD;;AACD,MAAM,KAAK,GAAG,UAAU,CAAC,KAAX,CAAiB,GAAjB,CAAd;AACA,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,CAAD,CAAN,CAApB;AACA,MAAM,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC,CAAD,CAAN,CAAtB;AACA,MAAM,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC,CAAD,CAAN,CAAtB;AACA,SAAQ,KAAK,GAAG,IAAT,GAAkB,OAAO,GAAG,EAA5B,GAAkC,OAAzC;AACD;AAED;AACA;AACA;AACA;AACA;AACA;AACA;;;AACO,SAAS,oBAAT,CAA8B,QAA9B,EAAgD,aAAhD,EAAuE;AAC5E,MAAI,CAAC,QAAD,IAAa,CAAC,QAAQ,CAAC,KAAT,CAAe,aAAf,CAAlB,EAAiD;AAC/C,WAAO,CAAP;AACD;;AAED,cAA2D,IAAI,MAAJ,CACvD,aADuD,EACxC,IADwC,CACnC,QADmC,KACtB,EADrC;AAAA;AAAA,MAAS,KAAT;AAAA,MAAgB,MAAhB;AAAA,MAA0B,IAA1B;AAAA,MAAgC,KAAhC;AAAA,MAAuC,OAAvC;AAAA,MAAgD,OAAhD;;AAGA,MAAI,MAAM,GAAG,GAAb;AAEA,EAAA,MAAM,IAAK,MAAM,CAAC,OAAD,CAAN,GAAkB,GAAlB,IAAyB,GAApC;AACA,EAAA,MAAM,IAAK,MAAM,CAAC,OAAD,CAAN,GAAkB,IAAlB,IAA0B,GAArC;AACA,EAAA,MAAM,IAAK,MAAM,CAAC,KAAD,CAAN,GAAgB,MAAhB,IAA0B,GAArC;AACA,EAAA,MAAM,IAAK,MAAM,CAAC,IAAD,CAAN,IAAgB,KAAK,EAAL,GAAU,IAA1B,KAAmC,GAA9C;AACA,EAAA,MAAM,IAAK,MAAM,CAAC,KAAD,CAAN,IAAiB,KAAK,EAAL,GAAU,EAAV,GAAe,KAAhC,KAA0C,GAArD;AAEA,SAAO,MAAP;AACD;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACO,SAAS,eAAT,CACH,KADG,EAEH,MAFG,EAGH,aAHG,EAGoB;AACzB,SAAO,uBAAuB,CAC1B,oBAAoB,CAAC,KAAD,EAAQ,aAAR,CAApB,GACA,oBAAoB,CAAC,MAAD,EAAS,aAAT,CAFM,CAA9B;AAID;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACO,SAAS,oBAAT,CACH,KADG,EAEH,MAFG,EAGH,SAHG,EAGgB;AACrB,SAAO,kBAAkB,CACrB,gBAAgB,CAAC,KAAD,EAAQ,SAAR,CAAhB,GACA,gBAAgB,CACZ,MADY,EACJ,SADI,CAFK,CAAzB;AAKD;AAED;AACA;AACA;AACA;AACA;;;AACO,SAAS,OAAT,CAAiB,IAAjB,EAAuB;AAC5B,MAAM,MAAM,GAAG,EAAf;AAEA;AACF;AACA;AACA;AACA;;AACE,WAAS,OAAT,CAAiB,GAAjB,EAAsB,IAAtB,EAA4B;AAC1B,QAAI,MAAM,CAAC,GAAD,CAAN,KAAgB,GAApB,EAAyB;AACvB,MAAA,MAAM,CAAC,IAAD,CAAN,GAAe,GAAf;AACD,KAFD,MAEO,IAAI,KAAK,CAAC,OAAN,CAAc,GAAd,CAAJ,EAAwB;AAC7B,WAAK,IAAI,CAAC,GAAG,CAAR,EAAW,CAAC,GAAG,GAAG,CAAC,MAAxB,EAAgC,CAAC,GAAG,CAApC,EAAuC,CAAC,EAAxC,EAA4C;AAC1C,QAAA,OAAO,CAAC,GAAG,CAAC,CAAD,CAAJ,EAAS,IAAI,GAAG,GAAP,GAAa,CAAb,GAAiB,GAA1B,CAAP;AACA,YAAI,CAAC,KAAK,CAAV,EAAa,MAAM,CAAC,IAAD,CAAN,GAAe,EAAf;AACd;AACF,KALM,MAKA;AACL,UAAI,OAAO,GAAG,IAAd;;AACA,WAAK,IAAM,CAAX,IAAgB,GAAhB,EAAqB;AACnB,YAAI,GAAG,cAAH,CAAkB,IAAlB,CAAuB,GAAvB,EAA4B,CAA5B,CAAJ,EAAoC;AAClC,UAAA,OAAO,GAAG,KAAV;AACA,UAAA,OAAO,CAAC,GAAG,CAAC,CAAD,CAAJ,EAAS,IAAI,GAAG,IAAI,GAAG,GAAP,GAAa,CAAhB,GAAoB,CAAjC,CAAP;AACD;AACF;;AACD,UAAI,OAAO,IAAI,IAAf,EAAqB,MAAM,CAAC,IAAD,CAAN,GAAe,EAAf;AACtB;AACF;;AAED,EAAA,OAAO,CAAC,IAAD,EAAO,EAAP,CAAP;AACA,SAAO,MAAP;AACD;AAED;AACA;AACA;AACA;AACA;;;AACO,SAAS,SAAT,CAAmB,IAAnB,EAAyB;AAC9B;;AACA,MAAI,MAAM,CAAC,IAAD,CAAN,KAAiB,IAAjB,IAAyB,KAAK,CAAC,OAAN,CAAc,IAAd,CAA7B,EAAkD,OAAO,IAAP;AAClD,MAAM,KAAK,GAAG,yBAAd;AACA,MAAM,MAAM,GAAG,EAAf;;AACA,OAAK,IAAM,CAAX,IAAgB,IAAhB,EAAsB;AACpB,QAAI,GAAG,cAAH,CAAkB,IAAlB,CAAuB,IAAvB,EAA6B,CAA7B,CAAJ,EAAqC;AACnC,UAAI,GAAG,GAAG,MAAV;AACA,UAAI,IAAI,GAAG,EAAX;AACA,UAAI,CAAC,GAAG,KAAK,CAAC,IAAN,CAAW,CAAX,CAAR;;AACA,aAAO,CAAP,EAAU;AACR,QAAA,GAAG,GAAG,GAAG,CAAC,IAAD,CAAH,KAAc,GAAG,CAAC,IAAD,CAAH,GAAa,CAAC,CAAC,CAAD,CAAD,GAAO,EAAP,GAAY,EAAvC,CAAN;AACA,QAAA,IAAI,GAAG,CAAC,CAAC,CAAD,CAAD,IAAQ,CAAC,CAAC,CAAD,CAAhB;AACA,QAAA,CAAC,GAAG,KAAK,CAAC,IAAN,CAAW,CAAX,CAAJ;AACD;;AACD,MAAA,GAAG,CAAC,IAAD,CAAH,GAAY,IAAI,CAAC,CAAD,CAAhB;AACD;AACF;;AACD,SAAO,MAAM,CAAC,EAAD,CAAN,IAAc,MAArB;AACD;AAED;AACA;AACA;AACA;AACA;;;AACO,SAAS,aAAT,CAAuB,GAAvB,EAAoC;AACzC,MAAI,IAAI,CAAC,KAAL,CAAW,GAAX,MAAoB,GAApB,IAA2B,MAAM,CAAC,GAAD,CAAN,CAAY,OAAZ,CAAoB,GAApB,IAA2B,CAA1D,EAA6D,OAAO,CAAP;AAC7D,MAAM,KAAK,GAAG,GAAG,CAAC,QAAJ,GAAe,KAAf,CAAqB,GAArB,EAA0B,CAA1B,CAAd;AACA,SAAO,KAAK,CAAC,MAAN,IAAgB,CAAvB;AACD","file":"generated.js","sourceRoot":"","sourcesContent":["(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()","/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the `TypeError` message for \"Functions\" methods. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n  return root.Date.now();\n};\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        result = wait - timeSinceLastCall;\n\n    return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && objectToString.call(value) == symbolTag);\n}\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = value.replace(reTrim, '');\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = debounce;\n","// @flow\nimport Scorm12API from './Scorm12API';\nimport {\n  CMI,\n  CMIAttemptRecordsObject,\n  CMIEvaluationCommentsObject,\n  CMITriesObject,\n} from './cmi/aicc_cmi';\nimport {NAV} from './cmi/scorm12_cmi';\n\n/**\n * The AICC API class\n */\nexport default class AICC extends Scorm12API {\n  /**\n   * Constructor to create AICC API object\n   * @param {object} settings\n   */\n  constructor(settings: {}) {\n    const finalSettings = {\n      ...{\n        mastery_override: false,\n      }, ...settings,\n    };\n\n    super(finalSettings);\n\n    this.cmi = new CMI();\n    this.nav = new NAV();\n  }\n\n  /**\n   * Gets or builds a new child element to add to the array.\n   *\n   * @param {string} CMIElement\n   * @param {any} value\n   * @param {boolean} foundFirstIndex\n   * @return {object}\n   */\n  getChildElement(CMIElement, value, foundFirstIndex) {\n    let newChild = super.getChildElement(CMIElement, value, foundFirstIndex);\n\n    if (!newChild) {\n      if (this.stringMatches(CMIElement, 'cmi\\\\.evaluation\\\\.comments\\\\.\\\\d+')) {\n        newChild = new CMIEvaluationCommentsObject();\n      } else if (this.stringMatches(CMIElement,\n          'cmi\\\\.student_data\\\\.tries\\\\.\\\\d+')) {\n        newChild = new CMITriesObject();\n      } else if (this.stringMatches(CMIElement,\n          'cmi\\\\.student_data\\\\.attempt_records\\\\.\\\\d+')) {\n        newChild = new CMIAttemptRecordsObject();\n      }\n    }\n\n    return newChild;\n  }\n\n  /**\n   * Replace the whole API with another\n   *\n   * @param {AICC} newAPI\n   */\n  replaceWithAnotherScormAPI(newAPI) {\n    // Data Model\n    this.cmi = newAPI.cmi;\n    this.nav = newAPI.nav;\n  }\n}\n","// @flow\nimport {CMIArray} from './cmi/common';\nimport {ValidationError} from './exceptions';\nimport ErrorCodes from './constants/error_codes';\nimport APIConstants from './constants/api_constants';\nimport {unflatten} from './utilities';\nimport debounce from 'lodash.debounce';\n\nconst global_constants = APIConstants.global;\nconst scorm12_error_codes = ErrorCodes.scorm12;\n\n/**\n * Base API class for AICC, SCORM 1.2, and SCORM 2004. Should be considered\n * abstract, and never initialized on it's own.\n */\nexport default class BaseAPI {\n  #timeout;\n  #error_codes;\n  #settings = {\n    autocommit: false,\n    autocommitSeconds: 10,\n    asyncCommit: false,\n    sendBeaconCommit: false,\n    lmsCommitUrl: false,\n    dataCommitFormat: 'json', // valid formats are 'json' or 'flattened', 'params'\n    commitRequestDataType: 'application/json;charset=UTF-8',\n    autoProgress: false,\n    logLevel: global_constants.LOG_LEVEL_ERROR,\n    selfReportSessionTime: false,\n    alwaysSendTotalTime: false,\n    strict_errors: true,\n    responseHandler: function(xhr) {\n      let result;\n      if (typeof xhr !== 'undefined') {\n        result = JSON.parse(xhr.responseText);\n        if (result === null || !{}.hasOwnProperty.call(result, 'result')) {\n          result = {};\n          if (xhr.status === 200) {\n            result.result = global_constants.SCORM_TRUE;\n            result.errorCode = 0;\n          } else {\n            result.result = global_constants.SCORM_FALSE;\n            result.errorCode = 101;\n          }\n        }\n      }\n      return result;\n    },\n  };\n  cmi;\n  startingData: {};\n\n  /**\n   * Constructor for Base API class. Sets some shared API fields, as well as\n   * sets up options for the API.\n   * @param {object} error_codes\n   * @param {object} settings\n   */\n  constructor(error_codes, settings) {\n    if (new.target === BaseAPI) {\n      throw new TypeError('Cannot construct BaseAPI instances directly');\n    }\n    this.currentState = global_constants.STATE_NOT_INITIALIZED;\n    this.lastErrorCode = 0;\n    this.listenerArray = [];\n\n    this.#timeout = null;\n    this.#error_codes = error_codes;\n\n    this.settings = settings;\n    this.apiLogLevel = this.settings.logLevel;\n    this.selfReportSessionTime = this.settings.selfReportSessionTime;\n  }\n\n  /**\n   * Initialize the API\n   * @param {string} callbackName\n   * @param {string} initializeMessage\n   * @param {string} terminationMessage\n   * @return {string}\n   */\n  initialize(\n      callbackName: String,\n      initializeMessage?: String,\n      terminationMessage?: String) {\n    let returnValue = global_constants.SCORM_FALSE;\n\n    if (this.isInitialized()) {\n      this.throwSCORMError(this.#error_codes.INITIALIZED, initializeMessage);\n    } else if (this.isTerminated()) {\n      this.throwSCORMError(this.#error_codes.TERMINATED, terminationMessage);\n    } else {\n      if (this.selfReportSessionTime) {\n        this.cmi.setStartTime();\n      }\n\n      this.currentState = global_constants.STATE_INITIALIZED;\n      this.lastErrorCode = 0;\n      returnValue = global_constants.SCORM_TRUE;\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n    this.clearSCORMError(returnValue);\n\n    return returnValue;\n  }\n\n  /**\n   * Getter for #error_codes\n   * @return {object}\n   */\n  get error_codes() {\n    return this.#error_codes;\n  }\n\n  /**\n   * Getter for #settings\n   * @return {object}\n   */\n  get settings() {\n    return this.#settings;\n  }\n\n  /**\n   * Setter for #settings\n   * @param {object} settings\n   */\n  set settings(settings: Object) {\n    this.#settings = {...this.#settings, ...settings};\n  }\n\n  /**\n   * Terminates the current run of the API\n   * @param {string} callbackName\n   * @param {boolean} checkTerminated\n   * @return {string}\n   */\n  terminate(\n      callbackName: String,\n      checkTerminated: boolean) {\n    let returnValue = global_constants.SCORM_FALSE;\n\n    if (this.checkState(checkTerminated,\n        this.#error_codes.TERMINATION_BEFORE_INIT,\n        this.#error_codes.MULTIPLE_TERMINATION)) {\n      this.currentState = global_constants.STATE_TERMINATED;\n\n      const result = this.storeData(true);\n      if (!this.settings.sendBeaconCommit && !this.settings.asyncCommit &&\n          typeof result.errorCode !== 'undefined' && result.errorCode > 0) {\n        this.throwSCORMError(result.errorCode);\n      }\n      returnValue = (typeof result !== 'undefined' && result.result) ?\n          result.result : global_constants.SCORM_FALSE;\n\n      if (checkTerminated) this.lastErrorCode = 0;\n\n      returnValue = global_constants.SCORM_TRUE;\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n    this.clearSCORMError(returnValue);\n\n    return returnValue;\n  }\n\n  /**\n   * Get the value of the CMIElement.\n   *\n   * @param {string} callbackName\n   * @param {boolean} checkTerminated\n   * @param {string} CMIElement\n   * @return {string}\n   */\n  getValue(\n      callbackName: String,\n      checkTerminated: boolean,\n      CMIElement: String) {\n    let returnValue;\n\n    if (this.checkState(checkTerminated,\n        this.#error_codes.RETRIEVE_BEFORE_INIT,\n        this.#error_codes.RETRIEVE_AFTER_TERM)) {\n      if (checkTerminated) this.lastErrorCode = 0;\n      try {\n        returnValue = this.getCMIValue(CMIElement);\n      } catch (e) {\n        if (e instanceof ValidationError) {\n          this.lastErrorCode = e.errorCode;\n          returnValue = global_constants.SCORM_FALSE;\n        } else {\n          if (e.message) {\n            console.error(e.message);\n          } else {\n            console.error(e);\n          }\n          this.throwSCORMError(this.#error_codes.GENERAL);\n        }\n      }\n      this.processListeners(callbackName, CMIElement);\n    }\n\n    this.apiLog(callbackName, CMIElement, ': returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n    this.clearSCORMError(returnValue);\n\n    return returnValue;\n  }\n\n  /**\n   * Sets the value of the CMIElement.\n   *\n   * @param {string} callbackName\n   * @param {string} commitCallback\n   * @param {boolean} checkTerminated\n   * @param {string} CMIElement\n   * @param {*} value\n   * @return {string}\n   */\n  setValue(\n      callbackName: String,\n      commitCallback: String,\n      checkTerminated: boolean,\n      CMIElement,\n      value) {\n    if (value !== undefined) {\n      value = String(value);\n    }\n    let returnValue = global_constants.SCORM_FALSE;\n\n    if (this.checkState(checkTerminated, this.#error_codes.STORE_BEFORE_INIT,\n        this.#error_codes.STORE_AFTER_TERM)) {\n      if (checkTerminated) this.lastErrorCode = 0;\n      try {\n        returnValue = this.setCMIValue(CMIElement, value);\n      } catch (e) {\n        if (e instanceof ValidationError) {\n          this.lastErrorCode = e.errorCode;\n          returnValue = global_constants.SCORM_FALSE;\n        } else {\n          if (e.message) {\n            console.error(e.message);\n          } else {\n            console.error(e);\n          }\n          this.throwSCORMError(this.#error_codes.GENERAL);\n        }\n      }\n      this.processListeners(callbackName, CMIElement, value);\n    }\n\n    if (returnValue === undefined) {\n      returnValue = global_constants.SCORM_FALSE;\n    }\n\n    // If we didn't have any errors while setting the data, go ahead and\n    // schedule a commit, if autocommit is turned on\n    if (String(this.lastErrorCode) === '0') {\n      if (this.settings.autocommit && !this.#timeout) {\n        this.scheduleCommit(this.settings.autocommitSeconds * 1000, commitCallback);\n      }\n    }\n\n    this.apiLog(callbackName, CMIElement,\n        ': ' + value + ': result: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n    this.clearSCORMError(returnValue);\n\n    return returnValue;\n  }\n\n  /**\n   * Orders LMS to store all content parameters\n   * @param {string} callbackName\n   * @param {boolean} checkTerminated\n   * @return {string}\n   */\n  commit(\n      callbackName: String,\n      checkTerminated: boolean) {\n    this.clearScheduledCommit();\n\n    let returnValue = global_constants.SCORM_FALSE;\n\n    if (this.checkState(checkTerminated, this.#error_codes.COMMIT_BEFORE_INIT,\n        this.#error_codes.COMMIT_AFTER_TERM)) {\n      const result = this.storeData(false);\n      if (!this.settings.sendBeaconCommit && !this.settings.asyncCommit &&\n          result.errorCode && result.errorCode > 0) {\n        this.throwSCORMError(result.errorCode);\n      }\n      returnValue = (typeof result !== 'undefined' && result.result) ?\n          result.result : global_constants.SCORM_FALSE;\n\n      this.apiLog(callbackName, 'HttpRequest', ' Result: ' + returnValue,\n          global_constants.LOG_LEVEL_DEBUG);\n\n      if (checkTerminated) this.lastErrorCode = 0;\n\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n    this.clearSCORMError(returnValue);\n\n    return returnValue;\n  }\n\n  /**\n   * Returns last error code\n   * @param {string} callbackName\n   * @return {string}\n   */\n  getLastError(callbackName: String) {\n    const returnValue = String(this.lastErrorCode);\n\n    this.processListeners(callbackName);\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n\n    return returnValue;\n  }\n\n  /**\n   * Returns the errorNumber error description\n   *\n   * @param {string} callbackName\n   * @param {(string|number)} CMIErrorCode\n   * @return {string}\n   */\n  getErrorString(callbackName: String, CMIErrorCode) {\n    let returnValue = '';\n\n    if (CMIErrorCode !== null && CMIErrorCode !== '') {\n      returnValue = this.getLmsErrorMessageDetails(CMIErrorCode);\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n\n    return returnValue;\n  }\n\n  /**\n   * Returns a comprehensive description of the errorNumber error.\n   *\n   * @param {string} callbackName\n   * @param {(string|number)} CMIErrorCode\n   * @return {string}\n   */\n  getDiagnostic(callbackName: String, CMIErrorCode) {\n    let returnValue = '';\n\n    if (CMIErrorCode !== null && CMIErrorCode !== '') {\n      returnValue = this.getLmsErrorMessageDetails(CMIErrorCode, true);\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n\n    return returnValue;\n  }\n\n  /**\n   * Checks the LMS state and ensures it has been initialized.\n   *\n   * @param {boolean} checkTerminated\n   * @param {number} beforeInitError\n   * @param {number} afterTermError\n   * @return {boolean}\n   */\n  checkState(\n      checkTerminated: boolean,\n      beforeInitError: number,\n      afterTermError?: number) {\n    if (this.isNotInitialized()) {\n      this.throwSCORMError(beforeInitError);\n      return false;\n    } else if (checkTerminated && this.isTerminated()) {\n      this.throwSCORMError(afterTermError);\n      return false;\n    }\n\n    return true;\n  }\n\n  /**\n   * Logging for all SCORM actions\n   *\n   * @param {string} functionName\n   * @param {string} CMIElement\n   * @param {string} logMessage\n   * @param {number}messageLevel\n   */\n  apiLog(\n      functionName: String,\n      CMIElement: String,\n      logMessage: String,\n      messageLevel: number) {\n    logMessage = this.formatMessage(functionName, CMIElement, logMessage);\n\n    if (messageLevel >= this.apiLogLevel) {\n      switch (messageLevel) {\n        case global_constants.LOG_LEVEL_ERROR:\n          console.error(logMessage);\n          break;\n        case global_constants.LOG_LEVEL_WARNING:\n          console.warn(logMessage);\n          break;\n        case global_constants.LOG_LEVEL_INFO:\n          console.info(logMessage);\n          break;\n        case global_constants.LOG_LEVEL_DEBUG:\n          if (console.debug) {\n            console.debug(logMessage);\n          } else {\n            console.log(logMessage);\n          }\n          break;\n      }\n    }\n  }\n\n  /**\n   * Formats the SCORM messages for easy reading\n   *\n   * @param {string} functionName\n   * @param {string} CMIElement\n   * @param {string} message\n   * @return {string}\n   */\n  formatMessage(functionName: String, CMIElement: String, message: String) {\n    const baseLength = 20;\n    let messageString = '';\n\n    messageString += functionName;\n\n    let fillChars = baseLength - messageString.length;\n\n    for (let i = 0; i < fillChars; i++) {\n      messageString += ' ';\n    }\n\n    messageString += ': ';\n\n    if (CMIElement) {\n      const CMIElementBaseLength = 70;\n\n      messageString += CMIElement;\n\n      fillChars = CMIElementBaseLength - messageString.length;\n\n      for (let j = 0; j < fillChars; j++) {\n        messageString += ' ';\n      }\n    }\n\n    if (message) {\n      messageString += message;\n    }\n\n    return messageString;\n  }\n\n  /**\n   * Checks to see if {str} contains {tester}\n   *\n   * @param {string} str String to check against\n   * @param {string} tester String to check for\n   * @return {boolean}\n   */\n  stringMatches(str: String, tester: String) {\n    return str && tester && str.match(tester);\n  }\n\n  /**\n   * Check to see if the specific object has the given property\n   * @param {*} refObject\n   * @param {string} attribute\n   * @return {boolean}\n   * @private\n   */\n  _checkObjectHasProperty(refObject, attribute: String) {\n    return Object.hasOwnProperty.call(refObject, attribute) ||\n        Object.getOwnPropertyDescriptor(\n            Object.getPrototypeOf(refObject), attribute) ||\n        (attribute in refObject);\n  }\n\n  /**\n   * Returns the message that corresponds to errorNumber\n   * APIs that inherit BaseAPI should override this function\n   *\n   * @param {(string|number)} _errorNumber\n   * @param {boolean} _detail\n   * @return {string}\n   * @abstract\n   */\n  getLmsErrorMessageDetails(_errorNumber, _detail) {\n    throw new Error(\n        'The getLmsErrorMessageDetails method has not been implemented');\n  }\n\n  /**\n   * Gets the value for the specific element.\n   * APIs that inherit BaseAPI should override this function\n   *\n   * @param {string} _CMIElement\n   * @return {string}\n   * @abstract\n   */\n  getCMIValue(_CMIElement) {\n    throw new Error('The getCMIValue method has not been implemented');\n  }\n\n  /**\n   * Sets the value for the specific element.\n   * APIs that inherit BaseAPI should override this function\n   *\n   * @param {string} _CMIElement\n   * @param {any} _value\n   * @return {string}\n   * @abstract\n   */\n  setCMIValue(_CMIElement, _value) {\n    throw new Error('The setCMIValue method has not been implemented');\n  }\n\n  /**\n   * Shared API method to set a valid for a given element.\n   *\n   * @param {string} methodName\n   * @param {boolean} scorm2004\n   * @param {string} CMIElement\n   * @param {*} value\n   * @return {string}\n   */\n  _commonSetCMIValue(\n      methodName: String, scorm2004: boolean, CMIElement, value) {\n    if (!CMIElement || CMIElement === '') {\n      return global_constants.SCORM_FALSE;\n    }\n\n    const structure = CMIElement.split('.');\n    let refObject = this;\n    let returnValue = global_constants.SCORM_FALSE;\n    let foundFirstIndex = false;\n\n    const invalidErrorMessage = `The data model element passed to ${methodName} (${CMIElement}) is not a valid SCORM data model element.`;\n    const invalidErrorCode = scorm2004 ?\n        this.#error_codes.UNDEFINED_DATA_MODEL :\n        this.#error_codes.GENERAL;\n\n    for (let i = 0; i < structure.length; i++) {\n      const attribute = structure[i];\n\n      if (i === structure.length - 1) {\n        if (scorm2004 && (attribute.substr(0, 8) === '{target=') &&\n            (typeof refObject._isTargetValid == 'function')) {\n          this.throwSCORMError(this.#error_codes.READ_ONLY_ELEMENT);\n        } else if (!this._checkObjectHasProperty(refObject, attribute)) {\n          this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n        } else {\n          if (this.isInitialized() &&\n              this.stringMatches(CMIElement, '\\\\.correct_responses\\\\.\\\\d+')) {\n            this.validateCorrectResponse(CMIElement, value);\n          }\n\n          if (!scorm2004 || this.lastErrorCode === 0) {\n            refObject[attribute] = value;\n            returnValue = global_constants.SCORM_TRUE;\n          }\n        }\n      } else {\n        refObject = refObject[attribute];\n        if (!refObject) {\n          this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n          break;\n        }\n\n        if (refObject instanceof CMIArray) {\n          const index = parseInt(structure[i + 1], 10);\n\n          // SCO is trying to set an item on an array\n          if (!isNaN(index)) {\n            const item = refObject.childArray[index];\n\n            if (item) {\n              refObject = item;\n              foundFirstIndex = true;\n            } else {\n              const newChild = this.getChildElement(CMIElement, value,\n                  foundFirstIndex);\n              foundFirstIndex = true;\n\n              if (!newChild) {\n                this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n              } else {\n                if (refObject.initialized) newChild.initialize();\n\n                refObject.childArray.push(newChild);\n                refObject = newChild;\n              }\n            }\n\n            // Have to update i value to skip the array position\n            i++;\n          }\n        }\n      }\n    }\n\n    if (returnValue === global_constants.SCORM_FALSE) {\n      this.apiLog(methodName, null,\n          `There was an error setting the value for: ${CMIElement}, value of: ${value}`,\n          global_constants.LOG_LEVEL_WARNING);\n    }\n\n    return returnValue;\n  }\n\n  /**\n   * Abstract method for validating that a response is correct.\n   *\n   * @param {string} _CMIElement\n   * @param {*} _value\n   */\n  validateCorrectResponse(_CMIElement, _value) {\n    // just a stub method\n  }\n\n  /**\n   * Gets or builds a new child element to add to the array.\n   * APIs that inherit BaseAPI should override this method.\n   *\n   * @param {string} _CMIElement - unused\n   * @param {*} _value - unused\n   * @param {boolean} _foundFirstIndex - unused\n   * @return {*}\n   * @abstract\n   */\n  getChildElement(_CMIElement, _value, _foundFirstIndex) {\n    throw new Error('The getChildElement method has not been implemented');\n  }\n\n  /**\n   * Gets a value from the CMI Object\n   *\n   * @param {string} methodName\n   * @param {boolean} scorm2004\n   * @param {string} CMIElement\n   * @return {*}\n   */\n  _commonGetCMIValue(methodName: String, scorm2004: boolean, CMIElement) {\n    if (!CMIElement || CMIElement === '') {\n      return '';\n    }\n\n    const structure = CMIElement.split('.');\n    let refObject = this;\n    let attribute = null;\n\n    const uninitializedErrorMessage = `The data model element passed to ${methodName} (${CMIElement}) has not been initialized.`;\n    const invalidErrorMessage = `The data model element passed to ${methodName} (${CMIElement}) is not a valid SCORM data model element.`;\n    const invalidErrorCode = scorm2004 ?\n        this.#error_codes.UNDEFINED_DATA_MODEL :\n        this.#error_codes.GENERAL;\n\n    for (let i = 0; i < structure.length; i++) {\n      attribute = structure[i];\n\n      if (!scorm2004) {\n        if (i === structure.length - 1) {\n          if (!this._checkObjectHasProperty(refObject, attribute)) {\n            this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n            return;\n          }\n        }\n      } else {\n        if ((String(attribute).substr(0, 8) === '{target=') &&\n            (typeof refObject._isTargetValid == 'function')) {\n          const target = String(attribute).\n              substr(8, String(attribute).length - 9);\n          return refObject._isTargetValid(target);\n        } else if (!this._checkObjectHasProperty(refObject, attribute)) {\n          this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n          return;\n        }\n      }\n\n      refObject = refObject[attribute];\n      if (refObject === undefined) {\n        this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n        break;\n      }\n\n      if (refObject instanceof CMIArray) {\n        const index = parseInt(structure[i + 1], 10);\n\n        // SCO is trying to set an item on an array\n        if (!isNaN(index)) {\n          const item = refObject.childArray[index];\n\n          if (item) {\n            refObject = item;\n          } else {\n            this.throwSCORMError(this.#error_codes.VALUE_NOT_INITIALIZED,\n                uninitializedErrorMessage);\n            break;\n          }\n\n          // Have to update i value to skip the array position\n          i++;\n        }\n      }\n    }\n\n    if (refObject === null || refObject === undefined) {\n      if (!scorm2004) {\n        if (attribute === '_children') {\n          this.throwSCORMError(scorm12_error_codes.CHILDREN_ERROR);\n        } else if (attribute === '_count') {\n          this.throwSCORMError(scorm12_error_codes.COUNT_ERROR);\n        }\n      }\n    } else {\n      return refObject;\n    }\n  }\n\n  /**\n   * Returns true if the API's current state is STATE_INITIALIZED\n   *\n   * @return {boolean}\n   */\n  isInitialized() {\n    return this.currentState === global_constants.STATE_INITIALIZED;\n  }\n\n  /**\n   * Returns true if the API's current state is STATE_NOT_INITIALIZED\n   *\n   * @return {boolean}\n   */\n  isNotInitialized() {\n    return this.currentState === global_constants.STATE_NOT_INITIALIZED;\n  }\n\n  /**\n   * Returns true if the API's current state is STATE_TERMINATED\n   *\n   * @return {boolean}\n   */\n  isTerminated() {\n    return this.currentState === global_constants.STATE_TERMINATED;\n  }\n\n  /**\n   * Provides a mechanism for attaching to a specific SCORM event\n   *\n   * @param {string} listenerName\n   * @param {function} callback\n   */\n  on(listenerName: String, callback: function) {\n    if (!callback) return;\n\n    const listenerFunctions = listenerName.split(' ');\n    for (let i = 0; i < listenerFunctions.length; i++) {\n      const listenerSplit = listenerFunctions[i].split('.');\n      if (listenerSplit.length === 0) return;\n\n      const functionName = listenerSplit[0];\n\n      let CMIElement = null;\n      if (listenerSplit.length > 1) {\n        CMIElement = listenerName.replace(functionName + '.', '');\n      }\n\n      this.listenerArray.push({\n        functionName: functionName,\n        CMIElement: CMIElement,\n        callback: callback,\n      });\n\n      this.apiLog('on', functionName, `Added event listener: ${this.listenerArray.length}`, global_constants.LOG_LEVEL_INFO);\n    }\n  }\n\n  /**\n   * Provides a mechanism for detaching a specific SCORM event listener\n   *\n   * @param {string} listenerName\n   * @param {function} callback\n   */\n  off(listenerName: String, callback: function) {\n    if (!callback) return;\n\n    const listenerFunctions = listenerName.split(' ');\n    for (let i = 0; i < listenerFunctions.length; i++) {\n      const listenerSplit = listenerFunctions[i].split('.');\n      if (listenerSplit.length === 0) return;\n\n      const functionName = listenerSplit[0];\n\n      let CMIElement = null;\n      if (listenerSplit.length > 1) {\n        CMIElement = listenerName.replace(functionName + '.', '');\n      }\n\n      const removeIndex = this.listenerArray.findIndex((obj) =>\n        obj.functionName === functionName &&\n        obj.CMIElement === CMIElement &&\n        obj.callback === callback\n      );\n      if (removeIndex !== -1) {\n        this.listenerArray.splice(removeIndex, 1);\n        this.apiLog('off', functionName, `Removed event listener: ${this.listenerArray.length}`, global_constants.LOG_LEVEL_INFO);\n      }\n    }\n  }\n\n  /**\n   * Provides a mechanism for clearing all listeners from a specific SCORM event\n   *\n   * @param {string} listenerName\n   */\n  clear(listenerName: String) {\n    const listenerFunctions = listenerName.split(' ');\n    for (let i = 0; i < listenerFunctions.length; i++) {\n      const listenerSplit = listenerFunctions[i].split('.');\n      if (listenerSplit.length === 0) return;\n\n      const functionName = listenerSplit[0];\n\n      let CMIElement = null;\n      if (listenerSplit.length > 1) {\n        CMIElement = listenerName.replace(functionName + '.', '');\n      }\n\n      this.listenerArray = this.listenerArray.filter((obj) =>\n        obj.functionName !== functionName &&\n        obj.CMIElement !== CMIElement,\n      );\n    }\n  }\n\n  /**\n   * Processes any 'on' listeners that have been created\n   *\n   * @param {string} functionName\n   * @param {string} CMIElement\n   * @param {*} value\n   */\n  processListeners(functionName: String, CMIElement: String, value: any) {\n    this.apiLog(functionName, CMIElement, value);\n    for (let i = 0; i < this.listenerArray.length; i++) {\n      const listener = this.listenerArray[i];\n      const functionsMatch = listener.functionName === functionName;\n      const listenerHasCMIElement = !!listener.CMIElement;\n      let CMIElementsMatch = false;\n      if (CMIElement && listener.CMIElement &&\n          listener.CMIElement.substring(listener.CMIElement.length - 1) ===\n          '*') {\n        CMIElementsMatch = CMIElement.indexOf(listener.CMIElement.substring(0,\n            listener.CMIElement.length - 1)) === 0;\n      } else {\n        CMIElementsMatch = listener.CMIElement === CMIElement;\n      }\n\n      if (functionsMatch && (!listenerHasCMIElement || CMIElementsMatch)) {\n        listener.callback(CMIElement, value);\n      }\n    }\n  }\n\n  /**\n   * Throws a SCORM error\n   *\n   * @param {number} errorNumber\n   * @param {string} message\n   */\n  throwSCORMError(errorNumber: number, message: String) {\n    if (!message) {\n      message = this.getLmsErrorMessageDetails(errorNumber);\n    }\n\n    this.apiLog('throwSCORMError', null, errorNumber + ': ' + message,\n        global_constants.LOG_LEVEL_ERROR);\n\n    this.lastErrorCode = String(errorNumber);\n  }\n\n  /**\n   * Clears the last SCORM error code on success.\n   *\n   * @param {string} success\n   */\n  clearSCORMError(success: String) {\n    if (success !== undefined && success !== global_constants.SCORM_FALSE) {\n      this.lastErrorCode = 0;\n    }\n  }\n\n  /**\n   * Attempts to store the data to the LMS, logs data if no LMS configured\n   * APIs that inherit BaseAPI should override this function\n   *\n   * @param {boolean} _calculateTotalTime\n   * @return {string}\n   * @abstract\n   */\n  storeData(_calculateTotalTime) {\n    throw new Error(\n        'The storeData method has not been implemented');\n  }\n\n  /**\n   * Load the CMI from a flattened JSON object\n   * @param {object} json\n   * @param {string} CMIElement\n   */\n  loadFromFlattenedJSON(json, CMIElement) {\n    if (!this.isNotInitialized()) {\n      console.error(\n          'loadFromFlattenedJSON can only be called before the call to lmsInitialize.');\n      return;\n    }\n\n    /**\n     * Test match pattern.\n     *\n     * @param {string} a\n     * @param {string} c\n     * @param {RegExp} a_pattern\n     * @return {number}\n     */\n    function testPattern(a, c, a_pattern) {\n      const a_match = a.match(a_pattern);\n\n      let c_match;\n      if (a_match !== null && (c_match = c.match(a_pattern)) !== null) {\n        const a_num = Number(a_match[2]);\n        const c_num = Number(c_match[2]);\n        if (a_num === c_num) {\n          if (a_match[3] === 'id') {\n            return -1;\n          } else if (a_match[3] === 'type') {\n            if (c_match[3] === 'id') {\n              return 1;\n            } else {\n              return -1;\n            }\n          } else {\n            return 1;\n          }\n        }\n        return a_num - c_num;\n      }\n\n      return null;\n    }\n\n    const int_pattern = /^(cmi\\.interactions\\.)(\\d+)\\.(.*)$/;\n    const obj_pattern = /^(cmi\\.objectives\\.)(\\d+)\\.(.*)$/;\n\n    const result = Object.keys(json).map(function(key) {\n      return [String(key), json[key]];\n    });\n\n    // CMI interactions need to have id and type loaded before any other fields\n    result.sort(function([a, b], [c, d]) {\n      let test;\n      if ((test = testPattern(a, c, int_pattern)) !== null) {\n        return test;\n      }\n      if ((test = testPattern(a, c, obj_pattern)) !== null) {\n        return test;\n      }\n\n      if (a < c) {\n        return -1;\n      }\n      if (a > c) {\n        return 1;\n      }\n      return 0;\n    });\n\n    let obj;\n    result.forEach((element) => {\n      obj = {};\n      obj[element[0]] = element[1];\n      this.loadFromJSON(unflatten(obj), CMIElement);\n    });\n  }\n\n  /**\n   * Loads CMI data from a JSON object.\n   *\n   * @param {object} json\n   * @param {string} CMIElement\n   */\n  loadFromJSON(json, CMIElement) {\n    if (!this.isNotInitialized()) {\n      console.error(\n          'loadFromJSON can only be called before the call to lmsInitialize.');\n      return;\n    }\n\n    CMIElement = CMIElement !== undefined ? CMIElement : 'cmi';\n\n    this.startingData = json;\n\n    // could this be refactored down to flatten(json) then setCMIValue on each?\n    for (const key in json) {\n      if ({}.hasOwnProperty.call(json, key) && json[key]) {\n        const currentCMIElement = (CMIElement ? CMIElement + '.' : '') + key;\n        const value = json[key];\n\n        if (value['childArray']) {\n          for (let i = 0; i < value['childArray'].length; i++) {\n            this.loadFromJSON(value['childArray'][i],\n                currentCMIElement + '.' + i);\n          }\n        } else if (value.constructor === Object) {\n          this.loadFromJSON(value, currentCMIElement);\n        } else {\n          this.setCMIValue(currentCMIElement, value);\n        }\n      }\n    }\n  }\n\n  /**\n   * Render the CMI object to JSON for sending to an LMS.\n   *\n   * @return {string}\n   */\n  renderCMIToJSONString() {\n    const cmi = this.cmi;\n    // Do we want/need to return fields that have no set value?\n    // return JSON.stringify({ cmi }, (k, v) => v === undefined ? null : v, 2);\n    return JSON.stringify({cmi});\n  }\n\n  /**\n   * Returns a JS object representing the current cmi\n   * @return {object}\n   */\n  renderCMIToJSONObject() {\n    // Do we want/need to return fields that have no set value?\n    // return JSON.stringify({ cmi }, (k, v) => v === undefined ? null : v, 2);\n    return JSON.parse(this.renderCMIToJSONString());\n  }\n\n  /**\n   * Render the cmi object to the proper format for LMS commit\n   * APIs that inherit BaseAPI should override this function\n   *\n   * @param {boolean} _terminateCommit\n   * @return {*}\n   * @abstract\n   */\n  renderCommitCMI(_terminateCommit) {\n    throw new Error(\n        'The storeData method has not been implemented');\n  }\n\n  /**\n   * Send the request to the LMS\n   * @param {string} url\n   * @param {object|Array} params\n   * @param {boolean} immediate\n   * @return {object}\n   */\n  processHttpRequest(url: String, params, immediate = false) {\n    const api = this;\n    const process = function(url, params, settings, error_codes) {\n      const genericError = {\n        'result': global_constants.SCORM_FALSE,\n        'errorCode': error_codes.GENERAL,\n      };\n\n      let result;\n      if (!settings.sendBeaconCommit) {\n        const httpReq = new XMLHttpRequest();\n        httpReq.open('POST', url, settings.asyncCommit);\n        if (settings.asyncCommit) {\n          httpReq.onload = function(e) {\n            if (typeof settings.responseHandler === 'function') {\n              result = settings.responseHandler(httpReq);\n            } else {\n              result = JSON.parse(httpReq.responseText);\n            }\n          };\n        }\n        try {\n          if (params instanceof Array) {\n            httpReq.setRequestHeader('Content-Type',\n                'application/x-www-form-urlencoded');\n            httpReq.send(params.join('&'));\n          } else {\n            httpReq.setRequestHeader('Content-Type',\n                settings.commitRequestDataType);\n            httpReq.send(JSON.stringify(params));\n          }\n\n          if (!settings.asyncCommit) {\n            if (typeof settings.responseHandler === 'function') {\n              result = settings.responseHandler(httpReq);\n            } else {\n              result = JSON.parse(httpReq.responseText);\n            }\n          } else {\n            result = {};\n            result.result = global_constants.SCORM_TRUE;\n            result.errorCode = 0;\n            api.processListeners('CommitSuccess');\n            return result;\n          }\n        } catch (e) {\n          console.error(e);\n          api.processListeners('CommitError');\n          return genericError;\n        }\n      } else {\n        try {\n          const headers = {\n            type: settings.commitRequestDataType,\n          };\n          let blob;\n          if (params instanceof Array) {\n            blob = new Blob([params.join('&')], headers);\n          } else {\n            blob = new Blob([JSON.stringify(params)], headers);\n          }\n\n          result = {};\n          if (navigator.sendBeacon(url, blob)) {\n            result.result = global_constants.SCORM_TRUE;\n            result.errorCode = 0;\n          } else {\n            result.result = global_constants.SCORM_FALSE;\n            result.errorCode = 101;\n          }\n        } catch (e) {\n          console.error(e);\n          api.processListeners('CommitError');\n          return genericError;\n        }\n      }\n\n      if (typeof result === 'undefined') {\n        api.processListeners('CommitError');\n        return genericError;\n      }\n\n      if (result.result === true ||\n          result.result === global_constants.SCORM_TRUE) {\n        api.processListeners('CommitSuccess');\n      } else {\n        api.processListeners('CommitError');\n      }\n\n      return result;\n    };\n\n    if (typeof debounce !== 'undefined') {\n      const debounced = debounce(process, 500);\n      debounced(url, params, this.settings, this.error_codes);\n\n      // if we're terminating, go ahead and commit immediately\n      if (immediate) {\n        debounced.flush();\n      }\n\n      return {\n        result: global_constants.SCORM_TRUE,\n        errorCode: 0,\n      };\n    } else {\n      return process(url, params, this.settings, this.error_codes);\n    }\n  }\n\n  /**\n   * Throws a SCORM error\n   *\n   * @param {number} when - the number of milliseconds to wait before committing\n   * @param {string} callback - the name of the commit event callback\n   */\n  scheduleCommit(when: number, callback: string) {\n    this.#timeout = new ScheduledCommit(this, when, callback);\n    this.apiLog('scheduleCommit', '', 'scheduled',\n        global_constants.LOG_LEVEL_DEBUG);\n  }\n\n  /**\n   * Clears and cancels any currently scheduled commits\n   */\n  clearScheduledCommit() {\n    if (this.#timeout) {\n      this.#timeout.cancel();\n      this.#timeout = null;\n      this.apiLog('clearScheduledCommit', '', 'cleared',\n          global_constants.LOG_LEVEL_DEBUG);\n    }\n  }\n}\n\n/**\n * Private class that wraps a timeout call to the commit() function\n */\nclass ScheduledCommit {\n  #API;\n  #cancelled = false;\n  #timeout;\n  #callback;\n\n  /**\n   * Constructor for ScheduledCommit\n   * @param {BaseAPI} API\n   * @param {number} when\n   * @param {string} callback\n   */\n  constructor(API: any, when: number, callback: string) {\n    this.#API = API;\n    this.#timeout = setTimeout(this.wrapper.bind(this), when);\n    this.#callback = callback;\n  }\n\n  /**\n   * Cancel any currently scheduled commit\n   */\n  cancel() {\n    this.#cancelled = true;\n    if (this.#timeout) {\n      clearTimeout(this.#timeout);\n    }\n  }\n\n  /**\n   * Wrap the API commit call to check if the call has already been cancelled\n   */\n  wrapper() {\n    if (!this.#cancelled) {\n      this.#API.commit(this.#callback);\n    }\n  }\n}\n","// @flow\nimport BaseAPI from './BaseAPI';\nimport {\n  CMI,\n  CMIInteractionsCorrectResponsesObject,\n  CMIInteractionsObject,\n  CMIInteractionsObjectivesObject,\n  CMIObjectivesObject, NAV,\n} from './cmi/scorm12_cmi';\nimport * as Utilities from './utilities';\nimport APIConstants from './constants/api_constants';\nimport ErrorCodes from './constants/error_codes';\n\nconst scorm12_constants = APIConstants.scorm12;\nconst global_constants = APIConstants.global;\nconst scorm12_error_codes = ErrorCodes.scorm12;\n\n/**\n * API class for SCORM 1.2\n */\nexport default class Scorm12API extends BaseAPI {\n  /**\n   * Constructor for SCORM 1.2 API\n   * @param {object} settings\n   */\n  constructor(settings: {}) {\n    const finalSettings = {\n      ...{\n        mastery_override: false,\n      }, ...settings,\n    };\n\n    super(scorm12_error_codes, finalSettings);\n\n    this.cmi = new CMI();\n    this.nav = new NAV();\n\n    // Rename functions to match 1.2 Spec and expose to modules\n    this.LMSInitialize = this.lmsInitialize;\n    this.LMSFinish = this.lmsFinish;\n    this.LMSGetValue = this.lmsGetValue;\n    this.LMSSetValue = this.lmsSetValue;\n    this.LMSCommit = this.lmsCommit;\n    this.LMSGetLastError = this.lmsGetLastError;\n    this.LMSGetErrorString = this.lmsGetErrorString;\n    this.LMSGetDiagnostic = this.lmsGetDiagnostic;\n  }\n\n  /**\n   * lmsInitialize function from SCORM 1.2 Spec\n   *\n   * @return {string} bool\n   */\n  lmsInitialize() {\n    this.cmi.initialize();\n    return this.initialize('LMSInitialize', 'LMS was already initialized!',\n        'LMS is already finished!');\n  }\n\n  /**\n   * LMSFinish function from SCORM 1.2 Spec\n   *\n   * @return {string} bool\n   */\n  lmsFinish() {\n    const result = this.terminate('LMSFinish', true);\n\n    if (result === global_constants.SCORM_TRUE) {\n      if (this.nav.event !== '') {\n        if (this.nav.event === 'continue') {\n          this.processListeners('SequenceNext');\n        } else {\n          this.processListeners('SequencePrevious');\n        }\n      } else if (this.settings.autoProgress) {\n        this.processListeners('SequenceNext');\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * LMSGetValue function from SCORM 1.2 Spec\n   *\n   * @param {string} CMIElement\n   * @return {string}\n   */\n  lmsGetValue(CMIElement) {\n    return this.getValue('LMSGetValue', false, CMIElement);\n  }\n\n  /**\n   * LMSSetValue function from SCORM 1.2 Spec\n   *\n   * @param {string} CMIElement\n   * @param {*} value\n   * @return {string}\n   */\n  lmsSetValue(CMIElement, value) {\n    return this.setValue('LMSSetValue', 'LMSCommit', false, CMIElement, value);\n  }\n\n  /**\n   * LMSCommit function from SCORM 1.2 Spec\n   *\n   * @return {string} bool\n   */\n  lmsCommit() {\n    return this.commit('LMSCommit', false);\n  }\n\n  /**\n   * LMSGetLastError function from SCORM 1.2 Spec\n   *\n   * @return {string}\n   */\n  lmsGetLastError() {\n    return this.getLastError('LMSGetLastError');\n  }\n\n  /**\n   * LMSGetErrorString function from SCORM 1.2 Spec\n   *\n   * @param {string} CMIErrorCode\n   * @return {string}\n   */\n  lmsGetErrorString(CMIErrorCode) {\n    return this.getErrorString('LMSGetErrorString', CMIErrorCode);\n  }\n\n  /**\n   * LMSGetDiagnostic function from SCORM 1.2 Spec\n   *\n   * @param {string} CMIErrorCode\n   * @return {string}\n   */\n  lmsGetDiagnostic(CMIErrorCode) {\n    return this.getDiagnostic('LMSGetDiagnostic', CMIErrorCode);\n  }\n\n  /**\n   * Sets a value on the CMI Object\n   *\n   * @param {string} CMIElement\n   * @param {*} value\n   * @return {string}\n   */\n  setCMIValue(CMIElement, value) {\n    return this._commonSetCMIValue('LMSSetValue', false, CMIElement, value);\n  }\n\n  /**\n   * Gets a value from the CMI Object\n   *\n   * @param {string} CMIElement\n   * @return {*}\n   */\n  getCMIValue(CMIElement) {\n    return this._commonGetCMIValue('getCMIValue', false, CMIElement);\n  }\n\n  /**\n   * Gets or builds a new child element to add to the array.\n   *\n   * @param {string} CMIElement\n   * @param {*} value\n   * @param {boolean} foundFirstIndex\n   * @return {object}\n   */\n  getChildElement(CMIElement, value, foundFirstIndex) {\n    let newChild;\n\n    if (this.stringMatches(CMIElement, 'cmi\\\\.objectives\\\\.\\\\d+')) {\n      newChild = new CMIObjectivesObject();\n    } else if (foundFirstIndex && this.stringMatches(CMIElement,\n        'cmi\\\\.interactions\\\\.\\\\d+\\\\.correct_responses\\\\.\\\\d+')) {\n      newChild = new CMIInteractionsCorrectResponsesObject();\n    } else if (foundFirstIndex && this.stringMatches(CMIElement,\n        'cmi\\\\.interactions\\\\.\\\\d+\\\\.objectives\\\\.\\\\d+')) {\n      newChild = new CMIInteractionsObjectivesObject();\n    } else if (!foundFirstIndex &&\n        this.stringMatches(CMIElement, 'cmi\\\\.interactions\\\\.\\\\d+')) {\n      newChild = new CMIInteractionsObject();\n    }\n\n    return newChild;\n  }\n\n  /**\n   * Validates Correct Response values\n   *\n   * @param {string} CMIElement\n   * @param {*} value\n   * @return {boolean}\n   */\n  validateCorrectResponse(CMIElement, value) {\n    return true;\n  }\n\n  /**\n   * Returns the message that corresponds to errorNumber.\n   *\n   * @param {*} errorNumber\n   * @param {boolean} detail\n   * @return {string}\n   */\n  getLmsErrorMessageDetails(errorNumber, detail) {\n    let basicMessage = 'No Error';\n    let detailMessage = 'No Error';\n\n    // Set error number to string since inconsistent from modules if string or number\n    errorNumber = String(errorNumber);\n    if (scorm12_constants.error_descriptions[errorNumber]) {\n      basicMessage = scorm12_constants.error_descriptions[errorNumber].basicMessage;\n      detailMessage = scorm12_constants.error_descriptions[errorNumber].detailMessage;\n    }\n\n    return detail ? detailMessage : basicMessage;\n  }\n\n  /**\n   * Replace the whole API with another\n   *\n   * @param {Scorm12API} newAPI\n   */\n  replaceWithAnotherScormAPI(newAPI) {\n    // Data Model\n    this.cmi = newAPI.cmi;\n  }\n\n  /**\n   * Render the cmi object to the proper format for LMS commit\n   *\n   * @param {boolean} terminateCommit\n   * @return {object|Array}\n   */\n  renderCommitCMI(terminateCommit: boolean) {\n    const cmiExport = this.renderCMIToJSONObject();\n\n    if (terminateCommit) {\n      cmiExport.cmi.core.total_time = this.cmi.getCurrentTotalTime();\n    }\n\n    const result = [];\n    const flattened = Utilities.flatten(cmiExport);\n    switch (this.settings.dataCommitFormat) {\n      case 'flattened':\n        return Utilities.flatten(cmiExport);\n      case 'params':\n        for (const item in flattened) {\n          if ({}.hasOwnProperty.call(flattened, item)) {\n            result.push(`${item}=${flattened[item]}`);\n          }\n        }\n        return result;\n      case 'json':\n      default:\n        return cmiExport;\n    }\n  }\n\n  /**\n   * Attempts to store the data to the LMS\n   *\n   * @param {boolean} terminateCommit\n   * @return {string}\n   */\n  storeData(terminateCommit: boolean) {\n    if (terminateCommit) {\n      const originalStatus = this.cmi.core.lesson_status;\n      if (originalStatus === 'not attempted') {\n        this.cmi.core.lesson_status = 'completed';\n      }\n\n      if (this.cmi.core.lesson_mode === 'normal') {\n        if (this.cmi.core.credit === 'credit') {\n          if (this.settings.mastery_override &&\n              this.cmi.student_data.mastery_score !== '' &&\n              this.cmi.core.score.raw !== '') {\n            if (parseFloat(this.cmi.core.score.raw) >= parseFloat(this.cmi.student_data.mastery_score)) {\n              this.cmi.core.lesson_status = 'passed';\n            } else {\n              this.cmi.core.lesson_status = 'failed';\n            }\n          }\n        }\n      } else if (this.cmi.core.lesson_mode === 'browse') {\n        if ((this.startingData?.cmi?.core?.lesson_status || '') === '' && originalStatus === 'not attempted') {\n          this.cmi.core.lesson_status = 'browsed';\n        }\n      }\n    }\n\n    const commitObject = this.renderCommitCMI(terminateCommit ||\n        this.settings.alwaysSendTotalTime);\n\n    if (this.apiLogLevel === global_constants.LOG_LEVEL_DEBUG) {\n      console.debug('Commit (terminated: ' + (terminateCommit ? 'yes' : 'no') + '): ');\n      console.debug(commitObject);\n    }\n    if (this.settings.lmsCommitUrl) {\n      return this.processHttpRequest(this.settings.lmsCommitUrl, commitObject, terminateCommit);\n    } else {\n      return global_constants.SCORM_TRUE;\n    }\n  }\n}\n","import * as Scorm12CMI from './scorm12_cmi';\nimport {BaseCMI, checkValidFormat, CMIArray, CMIScore} from './common';\nimport APIConstants from '../constants/api_constants';\nimport Regex from '../constants/regex';\nimport ErrorCodes from '../constants/error_codes';\nimport {AICCValidationError} from '../exceptions';\n\nconst aicc_constants = APIConstants.aicc;\nconst aicc_regex = Regex.aicc;\nconst aicc_error_codes = ErrorCodes.scorm12;\n\n/**\n * Helper method for throwing Read Only error\n */\nfunction throwReadOnlyError() {\n  throw new AICCValidationError(aicc_error_codes.READ_ONLY_ELEMENT);\n}\n\n/**\n * Helper method, no reason to have to pass the same error codes every time\n * @param {*} value\n * @param {string} regexPattern\n * @param {boolean} allowEmptyString\n * @return {boolean}\n */\nfunction checkAICCValidFormat(\n    value: String,\n    regexPattern: String,\n    allowEmptyString?: boolean) {\n  return checkValidFormat(\n      value,\n      regexPattern,\n      aicc_error_codes.TYPE_MISMATCH,\n      AICCValidationError,\n      allowEmptyString\n  );\n}\n\n/**\n * CMI Class for AICC\n */\nexport class CMI extends Scorm12CMI.CMI {\n  /**\n   * Constructor for AICC CMI object\n   * @param {boolean} initialized\n   */\n  constructor(initialized: boolean) {\n    super(aicc_constants.cmi_children);\n\n    if (initialized) this.initialize();\n\n    this.student_preference = new AICCStudentPreferences();\n    this.student_data = new AICCCMIStudentData();\n    this.student_demographics = new CMIStudentDemographics();\n    this.evaluation = new CMIEvaluation();\n    this.paths = new CMIPaths();\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.student_preference?.initialize();\n    this.student_data?.initialize();\n    this.student_demographics?.initialize();\n    this.evaluation?.initialize();\n    this.paths?.initialize();\n  }\n\n  /**\n   * toJSON for cmi\n   *\n   * @return {\n   *    {\n   *      suspend_data: string,\n   *      launch_data: string,\n   *      comments: string,\n   *      comments_from_lms: string,\n   *      core: CMICore,\n   *      objectives: CMIObjectives,\n   *      student_data: CMIStudentData,\n   *      student_preference: CMIStudentPreference,\n   *      interactions: CMIInteractions,\n   *      paths: CMIPaths\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'suspend_data': this.suspend_data,\n      'launch_data': this.launch_data,\n      'comments': this.comments,\n      'comments_from_lms': this.comments_from_lms,\n      'core': this.core,\n      'objectives': this.objectives,\n      'student_data': this.student_data,\n      'student_preference': this.student_preference,\n      'student_demographics': this.student_demographics,\n      'interactions': this.interactions,\n      'evaluation': this.evaluation,\n      'paths': this.paths,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * AICC Evaluation object\n */\nclass CMIEvaluation extends BaseCMI {\n  /**\n   * Constructor for AICC Evaluation object\n   */\n  constructor() {\n    super();\n\n    this.comments = new CMIEvaluationComments();\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.comments?.initialize();\n  }\n\n  /**\n   * toJSON for cmi.evaluation object\n   * @return {{comments: CMIEvaluationComments}}\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'comments': this.comments,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing AICC's cmi.evaluation.comments object\n */\nclass CMIEvaluationComments extends CMIArray {\n  /**\n   * Constructor for AICC Evaluation Comments object\n   */\n  constructor() {\n    super({\n      children: aicc_constants.comments_children,\n      errorCode: aicc_error_codes.INVALID_SET_VALUE,\n      errorClass: AICCValidationError,\n    });\n  }\n}\n\n/**\n * StudentPreferences class for AICC\n */\nclass AICCStudentPreferences extends Scorm12CMI.CMIStudentPreference {\n  /**\n   * Constructor for AICC Student Preferences object\n   */\n  constructor() {\n    super(aicc_constants.student_preference_children);\n\n    this.windows = new CMIArray({\n      errorCode: aicc_error_codes.INVALID_SET_VALUE,\n      errorClass: AICCValidationError,\n      children: '',\n    });\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.windows?.initialize();\n  }\n\n  #lesson_type = '';\n  #text_color = '';\n  #text_location = '';\n  #text_size = '';\n  #video = '';\n\n  /**\n   * Getter for #lesson_type\n   * @return {string}\n   */\n  get lesson_type(): string {\n    return this.#lesson_type;\n  }\n\n  /**\n   * Setter for #lesson_type\n   * @param {string} lesson_type\n   */\n  set lesson_type(lesson_type: string) {\n    if (checkAICCValidFormat(lesson_type, aicc_regex.CMIString256)) {\n      this.#lesson_type = lesson_type;\n    }\n  }\n\n  /**\n   * Getter for #text_color\n   * @return {string}\n   */\n  get text_color(): string {\n    return this.#text_color;\n  }\n\n  /**\n   * Setter for #text_color\n   * @param {string} text_color\n   */\n  set text_color(text_color: string) {\n    if (checkAICCValidFormat(text_color, aicc_regex.CMIString256)) {\n      this.#text_color = text_color;\n    }\n  }\n\n  /**\n   * Getter for #text_location\n   * @return {string}\n   */\n  get text_location(): string {\n    return this.#text_location;\n  }\n\n  /**\n   * Setter for #text_location\n   * @param {string} text_location\n   */\n  set text_location(text_location: string) {\n    if (checkAICCValidFormat(text_location, aicc_regex.CMIString256)) {\n      this.#text_location = text_location;\n    }\n  }\n\n  /**\n   * Getter for #text_size\n   * @return {string}\n   */\n  get text_size(): string {\n    return this.#text_size;\n  }\n\n  /**\n   * Setter for #text_size\n   * @param {string} text_size\n   */\n  set text_size(text_size: string) {\n    if (checkAICCValidFormat(text_size, aicc_regex.CMIString256)) {\n      this.#text_size = text_size;\n    }\n  }\n\n  /**\n   * Getter for #video\n   * @return {string}\n   */\n  get video(): string {\n    return this.#video;\n  }\n\n  /**\n   * Setter for #video\n   * @param {string} video\n   */\n  set video(video: string) {\n    if (checkAICCValidFormat(video, aicc_regex.CMIString256)) {\n      this.#video = video;\n    }\n  }\n\n  /**\n   * toJSON for cmi.student_preference\n   *\n   * @return {\n   *    {\n   *      audio: string,\n   *      language: string,\n   *      speed: string,\n   *      text: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'audio': this.audio,\n      'language': this.language,\n      'lesson_type': this.lesson_type,\n      'speed': this.speed,\n      'text': this.text,\n      'text_color': this.text_color,\n      'text_location': this.text_location,\n      'text_size': this.text_size,\n      'video': this.video,\n      'windows': this.windows,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * StudentData class for AICC\n */\nclass AICCCMIStudentData extends Scorm12CMI.CMIStudentData {\n  /**\n   * Constructor for AICC StudentData object\n   */\n  constructor() {\n    super(aicc_constants.student_data_children);\n\n    this.tries = new CMITries();\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.tries?.initialize();\n  }\n\n  #tries_during_lesson = '';\n\n  /**\n   * Getter for tries_during_lesson\n   * @return {string}\n   */\n  get tries_during_lesson() {\n    return this.#tries_during_lesson;\n  }\n\n  /**\n   * Setter for #tries_during_lesson. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} tries_during_lesson\n   */\n  set tries_during_lesson(tries_during_lesson) {\n    !this.initialized ?\n        this.#tries_during_lesson = tries_during_lesson :\n        throwReadOnlyError();\n  }\n\n  /**\n   * toJSON for cmi.student_data object\n   * @return {\n   *    {\n   *      mastery_score: string,\n   *      max_time_allowed: string,\n   *      time_limit_action: string,\n   *      tries: CMITries\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'mastery_score': this.mastery_score,\n      'max_time_allowed': this.max_time_allowed,\n      'time_limit_action': this.time_limit_action,\n      'tries': this.tries,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing the AICC cmi.student_demographics object\n */\nexport class CMIStudentDemographics extends BaseCMI {\n  /**\n   * Constructor for AICC StudentDemographics object\n   */\n  constructor() {\n    super();\n  }\n\n  #_children = aicc_constants.student_demographics_children;\n  #city = '';\n  #class = '';\n  #company = '';\n  #country = '';\n  #experience = '';\n  #familiar_name = '';\n  #instructor_name = '';\n  #title = '';\n  #native_language = '';\n  #state = '';\n  #street_address = '';\n  #telephone = '';\n  #years_experience = '';\n\n  /**\n   * Getter for _children\n   * @return {string}\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Getter for city\n   * @return {string}\n   */\n  get city() {\n    return this.#city;\n  }\n\n  /**\n   * Setter for #city. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} city\n   */\n  set city(city) {\n    !this.initialized ?\n        this.#city = city :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for class\n   * @return {string}\n   */\n  get class() {\n    return this.#class;\n  }\n\n  /**\n   * Setter for #class. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} clazz\n   */\n  set class(clazz) {\n    !this.initialized ?\n        this.#class = clazz :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for company\n   * @return {string}\n   */\n  get company() {\n    return this.#company;\n  }\n\n  /**\n   * Setter for #company. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} company\n   */\n  set company(company) {\n    !this.initialized ?\n        this.#company = company :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for country\n   * @return {string}\n   */\n  get country() {\n    return this.#country;\n  }\n\n  /**\n   * Setter for #country. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} country\n   */\n  set country(country) {\n    !this.initialized ?\n        this.#country = country :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for experience\n   * @return {string}\n   */\n  get experience() {\n    return this.#experience;\n  }\n\n  /**\n   * Setter for #experience. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} experience\n   */\n  set experience(experience) {\n    !this.initialized ?\n        this.#experience = experience :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for familiar_name\n   * @return {string}\n   */\n  get familiar_name() {\n    return this.#familiar_name;\n  }\n\n  /**\n   * Setter for #familiar_name. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} familiar_name\n   */\n  set familiar_name(familiar_name) {\n    !this.initialized ?\n        this.#familiar_name = familiar_name :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for instructor_name\n   * @return {string}\n   */\n  get instructor_name() {\n    return this.#instructor_name;\n  }\n\n  /**\n   * Setter for #instructor_name. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} instructor_name\n   */\n  set instructor_name(instructor_name) {\n    !this.initialized ?\n        this.#instructor_name = instructor_name :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for title\n   * @return {string}\n   */\n  get title() {\n    return this.#title;\n  }\n\n  /**\n   * Setter for #title. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} title\n   */\n  set title(title) {\n    !this.initialized ?\n        this.#title = title :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for native_language\n   * @return {string}\n   */\n  get native_language() {\n    return this.#native_language;\n  }\n\n  /**\n   * Setter for #native_language. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} native_language\n   */\n  set native_language(native_language) {\n    !this.initialized ?\n        this.#native_language = native_language :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for state\n   * @return {string}\n   */\n  get state() {\n    return this.#state;\n  }\n\n  /**\n   * Setter for #state. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} state\n   */\n  set state(state) {\n    !this.initialized ?\n        this.#state = state :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for street_address\n   * @return {string}\n   */\n  get street_address() {\n    return this.#street_address;\n  }\n\n  /**\n   * Setter for #street_address. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} street_address\n   */\n  set street_address(street_address) {\n    !this.initialized ?\n        this.#street_address = street_address :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for telephone\n   * @return {string}\n   */\n  get telephone() {\n    return this.#telephone;\n  }\n\n  /**\n   * Setter for #telephone. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} telephone\n   */\n  set telephone(telephone) {\n    !this.initialized ?\n        this.#telephone = telephone :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for years_experience\n   * @return {string}\n   */\n  get years_experience() {\n    return this.#years_experience;\n  }\n\n  /**\n   * Setter for #years_experience. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} years_experience\n   */\n  set years_experience(years_experience) {\n    !this.initialized ?\n        this.#years_experience = years_experience :\n        throwReadOnlyError();\n  }\n\n  /**\n   * toJSON for cmi.student_demographics object\n   * @return {\n   *      {\n   *        city: string,\n   *        class: string,\n   *        company: string,\n   *        country: string,\n   *        experience: string,\n   *        familiar_name: string,\n   *        instructor_name: string,\n   *        title: string,\n   *        native_language: string,\n   *        state: string,\n   *        street_address: string,\n   *        telephone: string,\n   *        years_experience: string\n   *      }\n   *    }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'city': this.city,\n      'class': this.class,\n      'company': this.company,\n      'country': this.country,\n      'experience': this.experience,\n      'familiar_name': this.familiar_name,\n      'instructor_name': this.instructor_name,\n      'title': this.title,\n      'native_language': this.native_language,\n      'state': this.state,\n      'street_address': this.street_address,\n      'telephone': this.telephone,\n      'years_experience': this.years_experience,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing the AICC cmi.paths object\n */\nexport class CMIPaths extends CMIArray {\n  /**\n   * Constructor for inline Paths Array class\n   */\n  constructor() {\n    super({children: aicc_constants.paths_children});\n  }\n}\n\n/**\n * Class for AICC Paths\n */\nexport class CMIPathsObject extends BaseCMI {\n  /**\n   * Constructor for AICC Paths objects\n   */\n  constructor() {\n    super();\n  }\n\n  #location_id = '';\n  #date = '';\n  #time = '';\n  #status = '';\n  #why_left = '';\n  #time_in_element = '';\n\n  /**\n   * Getter for #location_id\n   * @return {string}\n   */\n  get location_id() {\n    return this.#location_id;\n  }\n\n  /**\n   * Setter for #location_id\n   * @param {string} location_id\n   */\n  set location_id(location_id) {\n    if (checkAICCValidFormat(location_id, aicc_regex.CMIString256)) {\n      this.#location_id = location_id;\n    }\n  }\n\n  /**\n   * Getter for #date\n   * @return {string}\n   */\n  get date() {\n    return this.#date;\n  }\n\n  /**\n   * Setter for #date\n   * @param {string} date\n   */\n  set date(date) {\n    if (checkAICCValidFormat(date, aicc_regex.CMIString256)) {\n      this.#date = date;\n    }\n  }\n\n  /**\n   * Getter for #time\n   * @return {string}\n   */\n  get time() {\n    return this.#time;\n  }\n\n  /**\n   * Setter for #time\n   * @param {string} time\n   */\n  set time(time) {\n    if (checkAICCValidFormat(time, aicc_regex.CMITime)) {\n      this.#time = time;\n    }\n  }\n\n  /**\n   * Getter for #status\n   * @return {string}\n   */\n  get status() {\n    return this.#status;\n  }\n\n  /**\n   * Setter for #status\n   * @param {string} status\n   */\n  set status(status) {\n    if (checkAICCValidFormat(status, aicc_regex.CMIStatus2)) {\n      this.#status = status;\n    }\n  }\n\n  /**\n   * Getter for #why_left\n   * @return {string}\n   */\n  get why_left() {\n    return this.#why_left;\n  }\n\n  /**\n   * Setter for #why_left\n   * @param {string} why_left\n   */\n  set why_left(why_left) {\n    if (checkAICCValidFormat(why_left, aicc_regex.CMIString256)) {\n      this.#why_left = why_left;\n    }\n  }\n\n  /**\n   * Getter for #time_in_element\n   * @return {string}\n   */\n  get time_in_element() {\n    return this.#time_in_element;\n  }\n\n  /**\n   * Setter for #time_in_element\n   * @param {string} time_in_element\n   */\n  set time_in_element(time_in_element) {\n    if (checkAICCValidFormat(time_in_element, aicc_regex.CMITime)) {\n      this.#time_in_element = time_in_element;\n    }\n  }\n\n  /**\n   * toJSON for cmi.paths.n object\n   * @return {\n   *    {\n   *      location_id: string,\n   *      date: string,\n   *      time: string,\n   *      status: string,\n   *      why_left: string,\n   *      time_in_element: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'location_id': this.location_id,\n      'date': this.date,\n      'time': this.time,\n      'status': this.status,\n      'why_left': this.why_left,\n      'time_in_element': this.time_in_element,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing the AICC cmi.student_data.tries object\n */\nexport class CMITries extends CMIArray {\n  /**\n   * Constructor for inline Tries Array class\n   */\n  constructor() {\n    super({children: aicc_constants.tries_children});\n  }\n}\n\n/**\n * Class for AICC Tries\n */\nexport class CMITriesObject extends BaseCMI {\n  /**\n   * Constructor for AICC Tries object\n   */\n  constructor() {\n    super();\n\n    this.score = new CMIScore(\n        {\n          score_children: aicc_constants.score_children,\n          score_range: aicc_regex.score_range,\n          invalidErrorCode: aicc_error_codes.INVALID_SET_VALUE,\n          invalidTypeCode: aicc_error_codes.TYPE_MISMATCH,\n          invalidRangeCode: aicc_error_codes.VALUE_OUT_OF_RANGE,\n          errorClass: AICCValidationError,\n        });\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.score?.initialize();\n  }\n\n  #status = '';\n  #time = '';\n\n  /**\n   * Getter for #status\n   * @return {string}\n   */\n  get status() {\n    return this.#status;\n  }\n\n  /**\n   * Setter for #status\n   * @param {string} status\n   */\n  set status(status) {\n    if (checkAICCValidFormat(status, aicc_regex.CMIStatus2)) {\n      this.#status = status;\n    }\n  }\n\n  /**\n   * Getter for #time\n   * @return {string}\n   */\n  get time() {\n    return this.#time;\n  }\n\n  /**\n   * Setter for #time\n   * @param {string} time\n   */\n  set time(time) {\n    if (checkAICCValidFormat(time, aicc_regex.CMITime)) {\n      this.#time = time;\n    }\n  }\n\n  /**\n   * toJSON for cmi.student_data.tries.n object\n   * @return {\n   *    {\n   *      status: string,\n   *      time: string,\n   *      score: CMIScore\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'status': this.status,\n      'time': this.time,\n      'score': this.score,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class for cmi.student_data.attempt_records array\n */\nexport class CMIAttemptRecords extends CMIArray {\n  /**\n   * Constructor for inline Tries Array class\n   */\n  constructor() {\n    super({children: aicc_constants.attempt_records_children});\n  }\n}\n\n/**\n * Class for AICC Attempt Records\n */\nexport class CMIAttemptRecordsObject extends BaseCMI {\n  /**\n   * Constructor for AICC Attempt Records object\n   */\n  constructor() {\n    super();\n\n    this.score = new CMIScore(\n        {\n          score_children: aicc_constants.score_children,\n          score_range: aicc_regex.score_range,\n          invalidErrorCode: aicc_error_codes.INVALID_SET_VALUE,\n          invalidTypeCode: aicc_error_codes.TYPE_MISMATCH,\n          invalidRangeCode: aicc_error_codes.VALUE_OUT_OF_RANGE,\n          errorClass: AICCValidationError,\n        });\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.score?.initialize();\n  }\n\n  #lesson_status = '';\n\n  /**\n   * Getter for #lesson_status\n   * @return {string}\n   */\n  get lesson_status() {\n    return this.#lesson_status;\n  }\n\n  /**\n   * Setter for #lesson_status\n   * @param {string} lesson_status\n   */\n  set lesson_status(lesson_status) {\n    if (checkAICCValidFormat(lesson_status, aicc_regex.CMIStatus2)) {\n      this.#lesson_status = lesson_status;\n    }\n  }\n\n  /**\n   * toJSON for cmi.student_data.attempt_records.n object\n   * @return {\n   *    {\n   *      status: string,\n   *      time: string,\n   *      score: CMIScore\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'lesson_status': this.lesson_status,\n      'score': this.score,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class for AICC Evaluation Comments\n */\nexport class CMIEvaluationCommentsObject extends BaseCMI {\n  /**\n   * Constructor for Evaluation Comments\n   */\n  constructor() {\n    super();\n  }\n\n  #content = '';\n  #location = '';\n  #time = '';\n\n  /**\n   * Getter for #content\n   * @return {string}\n   */\n  get content() {\n    return this.#content;\n  }\n\n  /**\n   * Setter for #content\n   * @param {string} content\n   */\n  set content(content) {\n    if (checkAICCValidFormat(content, aicc_regex.CMIString256)) {\n      this.#content = content;\n    }\n  }\n\n  /**\n   * Getter for #location\n   * @return {string}\n   */\n  get location() {\n    return this.#location;\n  }\n\n  /**\n   * Setter for #location\n   * @param {string} location\n   */\n  set location(location) {\n    if (checkAICCValidFormat(location, aicc_regex.CMIString256)) {\n      this.#location = location;\n    }\n  }\n\n  /**\n   * Getter for #time\n   * @return {string}\n   */\n  get time() {\n    return this.#time;\n  }\n\n  /**\n   * Setting for #time\n   * @param {string} time\n   */\n  set time(time) {\n    if (checkAICCValidFormat(time, aicc_regex.CMITime)) {\n      this.#time = time;\n    }\n  }\n\n  /**\n   * toJSON for cmi.evaulation.comments.n object\n   * @return {\n   *    {\n   *      content: string,\n   *      location: string,\n   *      time: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'content': this.content,\n      'location': this.location,\n      'time': this.time,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n","// @flow\nimport APIConstants from '../constants/api_constants';\nimport ErrorCodes from '../constants/error_codes';\nimport Regex from '../constants/regex';\n\nconst scorm12_constants = APIConstants.scorm12;\nconst scorm12_regex = Regex.scorm12;\nconst scorm12_error_codes = ErrorCodes.scorm12;\n\n/**\n * Check if the value matches the proper format. If not, throw proper error code.\n *\n * @param {string} value\n * @param {string} regexPattern\n * @param {number} errorCode\n * @param {class} errorClass\n * @param {boolean} allowEmptyString\n * @return {boolean}\n */\nexport function checkValidFormat(\n    value: String,\n    regexPattern: String,\n    errorCode: number,\n    errorClass: function,\n    allowEmptyString?: boolean) {\n  const formatRegex = new RegExp(regexPattern);\n  const matches = value.match(formatRegex);\n  if (allowEmptyString && value === '') {\n    return true;\n  }\n  if (value === undefined || !matches || matches[0] === '') {\n    throw new errorClass.prototype.constructor(errorCode);\n  }\n  return true;\n}\n\n/**\n * Check if the value matches the proper range. If not, throw proper error code.\n *\n * @param {*} value\n * @param {string} rangePattern\n * @param {number} errorCode\n * @param {class} errorClass\n * @return {boolean}\n */\nexport function checkValidRange(\n    value: any,\n    rangePattern: String,\n    errorCode: number,\n    errorClass: function) {\n  const ranges = rangePattern.split('#');\n  value = value * 1.0;\n  if (value >= ranges[0]) {\n    if ((ranges[1] === '*') || (value <= ranges[1])) {\n      return true;\n    } else {\n      throw new errorClass.prototype.constructor(errorCode);\n    }\n  } else {\n    throw new errorClass.prototype.constructor(errorCode);\n  }\n}\n\n/**\n * Base class for API cmi objects\n */\nexport class BaseCMI {\n  jsonString = false;\n  #initialized = false;\n  #start_time;\n\n  /**\n   * Constructor for BaseCMI, just marks the class as abstract\n   */\n  constructor() {\n    if (new.target === BaseCMI) {\n      throw new TypeError('Cannot construct BaseCMI instances directly');\n    }\n  }\n\n  /**\n   * Getter for #initialized\n   * @return {boolean}\n   */\n  get initialized() {\n    return this.#initialized;\n  }\n\n  /**\n   * Getter for #start_time\n   * @return {Number}\n   */\n  get start_time() {\n    return this.#start_time;\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    this.#initialized = true;\n  }\n\n  /**\n   * Called when the player should override the 'session_time' provided by\n   * the module\n   */\n  setStartTime() {\n    this.#start_time = new Date().getTime();\n  }\n}\n\n/**\n * Base class for cmi *.score objects\n */\nexport class CMIScore extends BaseCMI {\n  /**\n   * Constructor for *.score\n   * @param {string} score_children\n   * @param {string} score_range\n   * @param {string} max\n   * @param {number} invalidErrorCode\n   * @param {number} invalidTypeCode\n   * @param {number} invalidRangeCode\n   * @param {string} decimalRegex\n   * @param {class} errorClass\n   */\n  constructor(\n      {\n        score_children,\n        score_range,\n        max,\n        invalidErrorCode,\n        invalidTypeCode,\n        invalidRangeCode,\n        decimalRegex,\n        errorClass,\n      }) {\n    super();\n\n    this.#_children = score_children ||\n        scorm12_constants.score_children;\n    this.#_score_range = !score_range ? false : scorm12_regex.score_range;\n    this.#max = (max || max === '') ? max : '100';\n    this.#_invalid_error_code = invalidErrorCode ||\n        scorm12_error_codes.INVALID_SET_VALUE;\n    this.#_invalid_type_code = invalidTypeCode ||\n        scorm12_error_codes.TYPE_MISMATCH;\n    this.#_invalid_range_code = invalidRangeCode ||\n        scorm12_error_codes.VALUE_OUT_OF_RANGE;\n    this.#_decimal_regex = decimalRegex ||\n        scorm12_regex.CMIDecimal;\n    this.#_error_class = errorClass;\n  }\n\n  #_children;\n  #_score_range;\n  #_invalid_error_code;\n  #_invalid_type_code;\n  #_invalid_range_code;\n  #_decimal_regex;\n  #_error_class;\n  #raw = '';\n  #min = '';\n  #max;\n\n  /**\n   * Getter for _children\n   * @return {string}\n   * @private\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for _children. Just throws an error.\n   * @param {string} _children\n   * @private\n   */\n  set _children(_children) {\n    throw new this.#_error_class.prototype.constructor(this.#_invalid_error_code);\n  }\n\n  /**\n   * Getter for #raw\n   * @return {string}\n   */\n  get raw() {\n    return this.#raw;\n  }\n\n  /**\n   * Setter for #raw\n   * @param {string} raw\n   */\n  set raw(raw) {\n    if (checkValidFormat(raw, this.#_decimal_regex, this.#_invalid_type_code, this.#_error_class) &&\n        (!this.#_score_range ||\n            checkValidRange(raw, this.#_score_range, this.#_invalid_range_code, this.#_error_class))) {\n      this.#raw = raw;\n    }\n  }\n\n  /**\n   * Getter for #min\n   * @return {string}\n   */\n  get min() {\n    return this.#min;\n  }\n\n  /**\n   * Setter for #min\n   * @param {string} min\n   */\n  set min(min) {\n    if (checkValidFormat(min, this.#_decimal_regex, this.#_invalid_type_code, this.#_error_class) &&\n        (!this.#_score_range ||\n            checkValidRange(min, this.#_score_range, this.#_invalid_range_code, this.#_error_class))) {\n      this.#min = min;\n    }\n  }\n\n  /**\n   * Getter for #max\n   * @return {string}\n   */\n  get max() {\n    return this.#max;\n  }\n\n  /**\n   * Setter for #max\n   * @param {string} max\n   */\n  set max(max) {\n    if (checkValidFormat(max, this.#_decimal_regex, this.#_invalid_type_code, this.#_error_class) &&\n        (!this.#_score_range ||\n            checkValidRange(max, this.#_score_range, this.#_invalid_range_code, this.#_error_class))) {\n      this.#max = max;\n    }\n  }\n\n  /**\n   * toJSON for *.score\n   * @return {{min: string, max: string, raw: string}}\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'raw': this.raw,\n      'min': this.min,\n      'max': this.max,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Base class for cmi *.n objects\n */\nexport class CMIArray extends BaseCMI {\n  /**\n   * Constructor cmi *.n arrays\n   * @param {string} children\n   * @param {number} errorCode\n   * @param {class} errorClass\n   */\n  constructor({children, errorCode, errorClass}) {\n    super();\n    this.#_children = children;\n    this.#errorCode = errorCode;\n    this.#errorClass = errorClass;\n    this.childArray = [];\n  }\n\n  #errorCode;\n  #errorClass;\n  #_children;\n\n  /**\n   * Getter for _children\n   * @return {*}\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for _children. Just throws an error.\n   * @param {string} _children\n   */\n  set _children(_children) {\n    throw new this.#errorClass.prototype.constructor(this.#errorCode);\n  }\n\n  /**\n   * Getter for _count\n   * @return {number}\n   */\n  get _count() {\n    return this.childArray.length;\n  }\n\n  /**\n   * Setter for _count. Just throws an error.\n   * @param {number} _count\n   */\n  set _count(_count) {\n    throw new this.#errorClass.prototype.constructor(this.#errorCode);\n  }\n\n  /**\n   * toJSON for *.n arrays\n   * @return {object}\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {};\n    for (let i = 0; i < this.childArray.length; i++) {\n      result[i + ''] = this.childArray[i];\n    }\n    delete this.jsonString;\n    return result;\n  }\n}\n","// @flow\nimport {\n  BaseCMI,\n  checkValidFormat,\n  checkValidRange,\n  CMIArray,\n  CMIScore,\n} from './common';\nimport APIConstants from '../constants/api_constants';\nimport ErrorCodes from '../constants/error_codes';\nimport Regex from '../constants/regex';\nimport {Scorm12ValidationError} from '../exceptions';\nimport * as Utilities from '../utilities';\nimport * as Util from '../utilities';\n\nconst scorm12_constants = APIConstants.scorm12;\nconst scorm12_regex = Regex.scorm12;\nconst scorm12_error_codes = ErrorCodes.scorm12;\n\n/**\n * Helper method for throwing Read Only error\n */\nexport function throwReadOnlyError() {\n  throw new Scorm12ValidationError(scorm12_error_codes.READ_ONLY_ELEMENT);\n}\n\n/**\n * Helper method for throwing Write Only error\n */\nexport function throwWriteOnlyError() {\n  throw new Scorm12ValidationError(scorm12_error_codes.WRITE_ONLY_ELEMENT);\n}\n\n/**\n * Helper method for throwing Invalid Set error\n */\nfunction throwInvalidValueError() {\n  throw new Scorm12ValidationError(scorm12_error_codes.INVALID_SET_VALUE);\n}\n\n/**\n * Helper method, no reason to have to pass the same error codes every time\n * @param {*} value\n * @param {string} regexPattern\n * @param {boolean} allowEmptyString\n * @return {boolean}\n */\nexport function check12ValidFormat(\n    value: String,\n    regexPattern: String,\n    allowEmptyString?: boolean) {\n  return checkValidFormat(\n      value,\n      regexPattern,\n      scorm12_error_codes.TYPE_MISMATCH,\n      Scorm12ValidationError,\n      allowEmptyString\n  );\n}\n\n/**\n * Helper method, no reason to have to pass the same error codes every time\n * @param {*} value\n * @param {string} rangePattern\n * @param {boolean} allowEmptyString\n * @return {boolean}\n */\nexport function check12ValidRange(\n    value: any,\n    rangePattern: String,\n    allowEmptyString?: boolean) {\n  return checkValidRange(\n      value,\n      rangePattern,\n      scorm12_error_codes.VALUE_OUT_OF_RANGE,\n      Scorm12ValidationError,\n      allowEmptyString\n  );\n}\n\n/**\n * Class representing the cmi object for SCORM 1.2\n */\nexport class CMI extends BaseCMI {\n  #_children = '';\n  #_version = '3.4';\n  #launch_data = '';\n  #comments = '';\n  #comments_from_lms = '';\n\n  student_data = null;\n\n  /**\n   * Constructor for the SCORM 1.2 cmi object\n   * @param {string} cmi_children\n   * @param {(CMIStudentData|AICCCMIStudentData)} student_data\n   * @param {boolean} initialized\n   */\n  constructor(cmi_children, student_data, initialized: boolean) {\n    super();\n\n    if (initialized) this.initialize();\n\n    this.#_children = cmi_children ?\n        cmi_children :\n        scorm12_constants.cmi_children;\n    this.core = new CMICore();\n    this.objectives = new CMIObjectives();\n    this.student_data = student_data ? student_data : new CMIStudentData();\n    this.student_preference = new CMIStudentPreference();\n    this.interactions = new CMIInteractions();\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.core?.initialize();\n    this.objectives?.initialize();\n    this.student_data?.initialize();\n    this.student_preference?.initialize();\n    this.interactions?.initialize();\n  }\n\n  /**\n   * toJSON for cmi\n   *\n   * @return {\n   *    {\n   *      suspend_data: string,\n   *      launch_data: string,\n   *      comments: string,\n   *      comments_from_lms: string,\n   *      core: CMICore,\n   *      objectives: CMIObjectives,\n   *      student_data: CMIStudentData,\n   *      student_preference: CMIStudentPreference,\n   *      interactions: CMIInteractions\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'suspend_data': this.suspend_data,\n      'launch_data': this.launch_data,\n      'comments': this.comments,\n      'comments_from_lms': this.comments_from_lms,\n      'core': this.core,\n      'objectives': this.objectives,\n      'student_data': this.student_data,\n      'student_preference': this.student_preference,\n      'interactions': this.interactions,\n    };\n    delete this.jsonString;\n    return result;\n  }\n\n  /**\n   * Getter for #_version\n   * @return {string}\n   */\n  get _version() {\n    return this.#_version;\n  }\n\n  /**\n   * Setter for #_version. Just throws an error.\n   * @param {string} _version\n   */\n  set _version(_version) {\n    throwInvalidValueError();\n  }\n\n  /**\n   * Getter for #_children\n   * @return {string}\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for #_version. Just throws an error.\n   * @param {string} _children\n   */\n  set _children(_children) {\n    throwInvalidValueError();\n  }\n\n  /**\n   * Getter for #suspend_data\n   * @return {string}\n   */\n  get suspend_data() {\n    return this.core?.suspend_data;\n  }\n\n  /**\n   * Setter for #suspend_data\n   * @param {string} suspend_data\n   */\n  set suspend_data(suspend_data) {\n    if (this.core) {\n      this.core.suspend_data = suspend_data;\n    }\n  }\n\n  /**\n   * Getter for #launch_data\n   * @return {string}\n   */\n  get launch_data() {\n    return this.#launch_data;\n  }\n\n  /**\n   * Setter for #launch_data. Can only be called before  initialization.\n   * @param {string} launch_data\n   */\n  set launch_data(launch_data) {\n    !this.initialized ? this.#launch_data = launch_data : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #comments\n   * @return {string}\n   */\n  get comments() {\n    return this.#comments;\n  }\n\n  /**\n   * Setter for #comments\n   * @param {string} comments\n   */\n  set comments(comments) {\n    if (check12ValidFormat(comments, scorm12_regex.CMIString4096, true)) {\n      this.#comments = comments;\n    }\n  }\n\n  /**\n   * Getter for #comments_from_lms\n   * @return {string}\n   */\n  get comments_from_lms() {\n    return this.#comments_from_lms;\n  }\n\n  /**\n   * Setter for #comments_from_lms. Can only be called before  initialization.\n   * @param {string} comments_from_lms\n   */\n  set comments_from_lms(comments_from_lms) {\n    !this.initialized ?\n        this.#comments_from_lms = comments_from_lms :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Adds the current session time to the existing total time.\n   *\n   * @return {string}\n   */\n  getCurrentTotalTime() {\n    return this.core.getCurrentTotalTime(this.start_time);\n  }\n}\n\n/**\n * Class representing the cmi.core object\n * @extends BaseCMI\n */\nclass CMICore extends BaseCMI {\n  /**\n   * Constructor for cmi.core\n   */\n  constructor() {\n    super();\n\n    this.score = new CMIScore(\n        {\n          score_children: scorm12_constants.score_children,\n          score_range: scorm12_regex.score_range,\n          invalidErrorCode: scorm12_error_codes.INVALID_SET_VALUE,\n          invalidTypeCode: scorm12_error_codes.TYPE_MISMATCH,\n          invalidRangeCode: scorm12_error_codes.VALUE_OUT_OF_RANGE,\n          errorClass: Scorm12ValidationError,\n        });\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.score?.initialize();\n  }\n\n  #_children = scorm12_constants.core_children;\n  #student_id = '';\n  #student_name = '';\n  #lesson_location = '';\n  #credit = '';\n  #lesson_status = 'not attempted';\n  #entry = '';\n  #total_time = '';\n  #lesson_mode = 'normal';\n  #exit = '';\n  #session_time = '00:00:00';\n  #suspend_data = '';\n\n  /**\n   * Getter for #_children\n   * @return {string}\n   * @private\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for #_children. Just throws an error.\n   * @param {string} _children\n   * @private\n   */\n  set _children(_children) {\n    throwInvalidValueError();\n  }\n\n  /**\n   * Getter for #student_id\n   * @return {string}\n   */\n  get student_id() {\n    return this.#student_id;\n  }\n\n  /**\n   * Setter for #student_id. Can only be called before  initialization.\n   * @param {string} student_id\n   */\n  set student_id(student_id) {\n    !this.initialized ? this.#student_id = student_id : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #student_name\n   * @return {string}\n   */\n  get student_name() {\n    return this.#student_name;\n  }\n\n  /**\n   * Setter for #student_name. Can only be called before  initialization.\n   * @param {string} student_name\n   */\n  set student_name(student_name) {\n    !this.initialized ?\n        this.#student_name = student_name :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #lesson_location\n   * @return {string}\n   */\n  get lesson_location() {\n    return this.#lesson_location;\n  }\n\n  /**\n   * Setter for #lesson_location\n   * @param {string} lesson_location\n   */\n  set lesson_location(lesson_location) {\n    if (check12ValidFormat(lesson_location, scorm12_regex.CMIString256, true)) {\n      this.#lesson_location = lesson_location;\n    }\n  }\n\n  /**\n   * Getter for #credit\n   * @return {string}\n   */\n  get credit() {\n    return this.#credit;\n  }\n\n  /**\n   * Setter for #credit. Can only be called before  initialization.\n   * @param {string} credit\n   */\n  set credit(credit) {\n    !this.initialized ? this.#credit = credit : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #lesson_status\n   * @return {string}\n   */\n  get lesson_status() {\n    return this.#lesson_status;\n  }\n\n  /**\n   * Setter for #lesson_status\n   * @param {string} lesson_status\n   */\n  set lesson_status(lesson_status) {\n    if (this.initialized) {\n      if (check12ValidFormat(lesson_status, scorm12_regex.CMIStatus)) {\n        this.#lesson_status = lesson_status;\n      }\n    } else {\n      if (check12ValidFormat(lesson_status, scorm12_regex.CMIStatus2)) {\n        this.#lesson_status = lesson_status;\n      }\n    }\n  }\n\n  /**\n   * Getter for #entry\n   * @return {string}\n   */\n  get entry() {\n    return this.#entry;\n  }\n\n  /**\n   * Setter for #entry. Can only be called before  initialization.\n   * @param {string} entry\n   */\n  set entry(entry) {\n    !this.initialized ? this.#entry = entry : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #total_time\n   * @return {string}\n   */\n  get total_time() {\n    return this.#total_time;\n  }\n\n  /**\n   * Setter for #total_time. Can only be called before  initialization.\n   * @param {string} total_time\n   */\n  set total_time(total_time) {\n    !this.initialized ? this.#total_time = total_time : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #lesson_mode\n   * @return {string}\n   */\n  get lesson_mode() {\n    return this.#lesson_mode;\n  }\n\n  /**\n   * Setter for #lesson_mode. Can only be called before  initialization.\n   * @param {string} lesson_mode\n   */\n  set lesson_mode(lesson_mode) {\n    !this.initialized ? this.#lesson_mode = lesson_mode : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #exit. Should only be called during JSON export.\n   * @return {*}\n   */\n  get exit() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#exit;\n  }\n\n  /**\n   * Setter for #exit\n   * @param {string} exit\n   */\n  set exit(exit) {\n    if (check12ValidFormat(exit, scorm12_regex.CMIExit, true)) {\n      this.#exit = exit;\n    }\n  }\n\n  /**\n   * Getter for #session_time. Should only be called during JSON export.\n   * @return {*}\n   */\n  get session_time() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#session_time;\n  }\n\n  /**\n   * Setter for #session_time\n   * @param {string} session_time\n   */\n  set session_time(session_time) {\n    if (check12ValidFormat(session_time, scorm12_regex.CMITimespan)) {\n      this.#session_time = session_time;\n    }\n  }\n\n  /**\n   * Getter for #suspend_data\n   * @return {string}\n   */\n  get suspend_data() {\n    return this.#suspend_data;\n  }\n\n  /**\n   * Setter for #suspend_data\n   * @param {string} suspend_data\n   */\n  set suspend_data(suspend_data) {\n    if (check12ValidFormat(suspend_data, scorm12_regex.CMIString4096, true)) {\n      this.#suspend_data = suspend_data;\n    }\n  }\n\n  /**\n   * Adds the current session time to the existing total time.\n   * @param {Number} start_time\n   * @return {string}\n   */\n  getCurrentTotalTime(start_time: Number) {\n    let sessionTime = this.#session_time;\n    const startTime = start_time;\n\n    if (typeof startTime !== 'undefined' && startTime !== null) {\n      const seconds = new Date().getTime() - startTime;\n      sessionTime = Util.getSecondsAsHHMMSS(seconds / 1000);\n    }\n\n    return Utilities.addHHMMSSTimeStrings(\n        this.#total_time,\n        sessionTime,\n        new RegExp(scorm12_regex.CMITimespan),\n    );\n  }\n\n  /**\n   * toJSON for cmi.core\n   *\n   * @return {\n   *    {\n   *      student_name: string,\n   *      entry: string,\n   *      exit: string,\n   *      score: CMIScore,\n   *      student_id: string,\n   *      lesson_mode: string,\n   *      lesson_location: string,\n   *      lesson_status: string,\n   *      credit: string,\n   *      session_time: *\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'student_id': this.student_id,\n      'student_name': this.student_name,\n      'lesson_location': this.lesson_location,\n      'credit': this.credit,\n      'lesson_status': this.lesson_status,\n      'entry': this.entry,\n      'lesson_mode': this.lesson_mode,\n      'exit': this.exit,\n      'session_time': this.session_time,\n      'score': this.score,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.objectives object\n * @extends CMIArray\n */\nclass CMIObjectives extends CMIArray {\n  /**\n   * Constructor for cmi.objectives\n   */\n  constructor() {\n    super({\n      children: scorm12_constants.objectives_children,\n      errorCode: scorm12_error_codes.INVALID_SET_VALUE,\n      errorClass: Scorm12ValidationError,\n    });\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.student_data object\n * @extends BaseCMI\n */\nexport class CMIStudentData extends BaseCMI {\n  #_children;\n  #mastery_score = '';\n  #max_time_allowed = '';\n  #time_limit_action = '';\n\n  /**\n   * Constructor for cmi.student_data\n   * @param {string} student_data_children\n   */\n  constructor(student_data_children) {\n    super();\n\n    this.#_children = student_data_children ?\n        student_data_children :\n        scorm12_constants.student_data_children;\n  }\n\n  /**\n   * Getter for #_children\n   * @return {*}\n   * @private\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for #_children. Just throws an error.\n   * @param {string} _children\n   * @private\n   */\n  set _children(_children) {\n    throwInvalidValueError();\n  }\n\n  /**\n   * Getter for #master_score\n   * @return {string}\n   */\n  get mastery_score() {\n    return this.#mastery_score;\n  }\n\n  /**\n   * Setter for #master_score. Can only be called before  initialization.\n   * @param {string} mastery_score\n   */\n  set mastery_score(mastery_score) {\n    !this.initialized ?\n        this.#mastery_score = mastery_score :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #max_time_allowed\n   * @return {string}\n   */\n  get max_time_allowed() {\n    return this.#max_time_allowed;\n  }\n\n  /**\n   * Setter for #max_time_allowed. Can only be called before  initialization.\n   * @param {string} max_time_allowed\n   */\n  set max_time_allowed(max_time_allowed) {\n    !this.initialized ?\n        this.#max_time_allowed = max_time_allowed :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #time_limit_action\n   * @return {string}\n   */\n  get time_limit_action() {\n    return this.#time_limit_action;\n  }\n\n  /**\n   * Setter for #time_limit_action. Can only be called before  initialization.\n   * @param {string} time_limit_action\n   */\n  set time_limit_action(time_limit_action) {\n    !this.initialized ?\n        this.#time_limit_action = time_limit_action :\n        throwReadOnlyError();\n  }\n\n  /**\n   * toJSON for cmi.student_data\n   *\n   * @return {\n   *    {\n   *      max_time_allowed: string,\n   *      time_limit_action: string,\n   *      mastery_score: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'mastery_score': this.mastery_score,\n      'max_time_allowed': this.max_time_allowed,\n      'time_limit_action': this.time_limit_action,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.student_preference object\n * @extends BaseCMI\n */\nexport class CMIStudentPreference extends BaseCMI {\n  #_children;\n\n  /**\n   * Constructor for cmi.student_preference\n   * @param {string} student_preference_children\n   */\n  constructor(student_preference_children) {\n    super();\n\n    this.#_children = student_preference_children ?\n        student_preference_children :\n        scorm12_constants.student_preference_children;\n  }\n\n  #audio = '';\n  #language = '';\n  #speed = '';\n  #text = '';\n\n  /**\n   * Getter for #_children\n   * @return {string}\n   * @private\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for #_children. Just throws an error.\n   * @param {string} _children\n   * @private\n   */\n  set _children(_children) {\n    throwInvalidValueError();\n  }\n\n  /**\n   * Getter for #audio\n   * @return {string}\n   */\n  get audio() {\n    return this.#audio;\n  }\n\n  /**\n   * Setter for #audio\n   * @param {string} audio\n   */\n  set audio(audio) {\n    if (check12ValidFormat(audio, scorm12_regex.CMISInteger) &&\n        check12ValidRange(audio, scorm12_regex.audio_range)) {\n      this.#audio = audio;\n    }\n  }\n\n  /**\n   * Getter for #language\n   * @return {string}\n   */\n  get language() {\n    return this.#language;\n  }\n\n  /**\n   * Setter for #language\n   * @param {string} language\n   */\n  set language(language) {\n    if (check12ValidFormat(language, scorm12_regex.CMIString256)) {\n      this.#language = language;\n    }\n  }\n\n  /**\n   * Getter for #speed\n   * @return {string}\n   */\n  get speed() {\n    return this.#speed;\n  }\n\n  /**\n   * Setter for #speed\n   * @param {string} speed\n   */\n  set speed(speed) {\n    if (check12ValidFormat(speed, scorm12_regex.CMISInteger) &&\n        check12ValidRange(speed, scorm12_regex.speed_range)) {\n      this.#speed = speed;\n    }\n  }\n\n  /**\n   * Getter for #text\n   * @return {string}\n   */\n  get text() {\n    return this.#text;\n  }\n\n  /**\n   * Setter for #text\n   * @param {string} text\n   */\n  set text(text) {\n    if (check12ValidFormat(text, scorm12_regex.CMISInteger) &&\n        check12ValidRange(text, scorm12_regex.text_range)) {\n      this.#text = text;\n    }\n  }\n\n  /**\n   * toJSON for cmi.student_preference\n   *\n   * @return {\n   *    {\n   *      audio: string,\n   *      language: string,\n   *      speed: string,\n   *      text: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'audio': this.audio,\n      'language': this.language,\n      'speed': this.speed,\n      'text': this.text,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.interactions object\n * @extends BaseCMI\n */\nclass CMIInteractions extends CMIArray {\n  /**\n   * Constructor for cmi.interactions\n   */\n  constructor() {\n    super({\n      children: scorm12_constants.interactions_children,\n      errorCode: scorm12_error_codes.INVALID_SET_VALUE,\n      errorClass: Scorm12ValidationError,\n    });\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.interactions.n object\n * @extends BaseCMI\n */\nexport class CMIInteractionsObject extends BaseCMI {\n  /**\n   * Constructor for cmi.interactions.n object\n   */\n  constructor() {\n    super();\n\n    this.objectives = new CMIArray({\n      errorCode: scorm12_error_codes.INVALID_SET_VALUE,\n      errorClass: Scorm12ValidationError,\n      children: scorm12_constants.objectives_children,\n    });\n    this.correct_responses = new CMIArray({\n      errorCode: scorm12_error_codes.INVALID_SET_VALUE,\n      errorClass: Scorm12ValidationError,\n      children: scorm12_constants.correct_responses_children,\n    });\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.objectives?.initialize();\n    this.correct_responses?.initialize();\n  }\n\n  #id = '';\n  #time = '';\n  #type = '';\n  #weighting = '';\n  #student_response = '';\n  #result = '';\n  #latency = '';\n\n  /**\n   * Getter for #id. Should only be called during JSON export.\n   * @return {*}\n   */\n  get id() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#id;\n  }\n\n  /**\n   * Setter for #id\n   * @param {string} id\n   */\n  set id(id) {\n    if (check12ValidFormat(id, scorm12_regex.CMIIdentifier)) {\n      this.#id = id;\n    }\n  }\n\n  /**\n   * Getter for #time. Should only be called during JSON export.\n   * @return {*}\n   */\n  get time() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#time;\n  }\n\n  /**\n   * Setter for #time\n   * @param {string} time\n   */\n  set time(time) {\n    if (check12ValidFormat(time, scorm12_regex.CMITime)) {\n      this.#time = time;\n    }\n  }\n\n  /**\n   * Getter for #type. Should only be called during JSON export.\n   * @return {*}\n   */\n  get type() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#type;\n  }\n\n  /**\n   * Setter for #type\n   * @param {string} type\n   */\n  set type(type) {\n    if (check12ValidFormat(type, scorm12_regex.CMIType)) {\n      this.#type = type;\n    }\n  }\n\n  /**\n   * Getter for #weighting. Should only be called during JSON export.\n   * @return {*}\n   */\n  get weighting() {\n    return (!this.jsonString) ?\n        throwWriteOnlyError() :\n        this.#weighting;\n  }\n\n  /**\n   * Setter for #weighting\n   * @param {string} weighting\n   */\n  set weighting(weighting) {\n    if (check12ValidFormat(weighting, scorm12_regex.CMIDecimal) &&\n        check12ValidRange(weighting, scorm12_regex.weighting_range)) {\n      this.#weighting = weighting;\n    }\n  }\n\n  /**\n   * Getter for #student_response. Should only be called during JSON export.\n   * @return {*}\n   */\n  get student_response() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#student_response;\n  }\n\n  /**\n   * Setter for #student_response\n   * @param {string} student_response\n   */\n  set student_response(student_response) {\n    if (check12ValidFormat(student_response, scorm12_regex.CMIFeedback, true)) {\n      this.#student_response = student_response;\n    }\n  }\n\n  /**\n   * Getter for #result. Should only be called during JSON export.\n   * @return {*}\n   */\n  get result() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#result;\n  }\n\n  /**\n   * Setter for #result\n   * @param {string} result\n   */\n  set result(result) {\n    if (check12ValidFormat(result, scorm12_regex.CMIResult)) {\n      this.#result = result;\n    }\n  }\n\n  /**\n   * Getter for #latency. Should only be called during JSON export.\n   * @return {*}\n   */\n  get latency() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#latency;\n  }\n\n  /**\n   * Setter for #latency\n   * @param {string} latency\n   */\n  set latency(latency) {\n    if (check12ValidFormat(latency, scorm12_regex.CMITimespan)) {\n      this.#latency = latency;\n    }\n  }\n\n  /**\n   * toJSON for cmi.interactions.n\n   *\n   * @return {\n   *    {\n   *      id: string,\n   *      time: string,\n   *      type: string,\n   *      weighting: string,\n   *      student_response: string,\n   *      result: string,\n   *      latency: string,\n   *      objectives: CMIArray,\n   *      correct_responses: CMIArray\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'id': this.id,\n      'time': this.time,\n      'type': this.type,\n      'weighting': this.weighting,\n      'student_response': this.student_response,\n      'result': this.result,\n      'latency': this.latency,\n      'objectives': this.objectives,\n      'correct_responses': this.correct_responses,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.objectives.n object\n * @extends BaseCMI\n */\nexport class CMIObjectivesObject extends BaseCMI {\n  /**\n   * Constructor for cmi.objectives.n\n   */\n  constructor() {\n    super();\n\n    this.score = new CMIScore(\n        {\n          score_children: scorm12_constants.score_children,\n          score_range: scorm12_regex.score_range,\n          invalidErrorCode: scorm12_error_codes.INVALID_SET_VALUE,\n          invalidTypeCode: scorm12_error_codes.TYPE_MISMATCH,\n          invalidRangeCode: scorm12_error_codes.VALUE_OUT_OF_RANGE,\n          errorClass: Scorm12ValidationError,\n        });\n  }\n\n  #id = '';\n  #status = '';\n\n  /**\n   * Getter for #id\n   * @return {\"\"}\n   */\n  get id() {\n    return this.#id;\n  }\n\n  /**\n   * Setter for #id\n   * @param {string} id\n   */\n  set id(id) {\n    if (check12ValidFormat(id, scorm12_regex.CMIIdentifier)) {\n      this.#id = id;\n    }\n  }\n\n  /**\n   * Getter for #status\n   * @return {\"\"}\n   */\n  get status() {\n    return this.#status;\n  }\n\n  /**\n   * Setter for #status\n   * @param {string} status\n   */\n  set status(status) {\n    if (check12ValidFormat(status, scorm12_regex.CMIStatus2)) {\n      this.#status = status;\n    }\n  }\n\n  /**\n   * toJSON for cmi.objectives.n\n   * @return {\n   *    {\n   *      id: string,\n   *      status: string,\n   *      score: CMIScore\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'id': this.id,\n      'status': this.status,\n      'score': this.score,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.interactions.n.objectives.n object\n * @extends BaseCMI\n */\nexport class CMIInteractionsObjectivesObject extends BaseCMI {\n  /**\n   * Constructor for cmi.interactions.n.objectives.n\n   */\n  constructor() {\n    super();\n  }\n\n  #id = '';\n\n  /**\n   * Getter for #id\n   * @return {\"\"}\n   */\n  get id() {\n    return this.#id;\n  }\n\n  /**\n   * Setter for #id\n   * @param {string} id\n   */\n  set id(id) {\n    if (check12ValidFormat(id, scorm12_regex.CMIIdentifier)) {\n      this.#id = id;\n    }\n  }\n\n  /**\n   * toJSON for cmi.interactions.n.objectives.n\n   * @return {\n   *    {\n   *      id: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'id': this.id,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.interactions.correct_responses.n object\n * @extends BaseCMI\n */\nexport class CMIInteractionsCorrectResponsesObject extends BaseCMI {\n  /**\n   * Constructor for cmi.interactions.correct_responses.n\n   */\n  constructor() {\n    super();\n  }\n\n  #pattern = '';\n\n  /**\n   * Getter for #pattern\n   * @return {string}\n   */\n  get pattern() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#pattern;\n  }\n\n  /**\n   * Setter for #pattern\n   * @param {string} pattern\n   */\n  set pattern(pattern) {\n    if (check12ValidFormat(pattern, scorm12_regex.CMIFeedback, true)) {\n      this.#pattern = pattern;\n    }\n  }\n\n  /**\n   * toJSON for cmi.interactions.correct_responses.n\n   * @return {\n   *    {\n   *      pattern: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'pattern': this.pattern,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class for AICC Navigation object\n */\nexport class NAV extends BaseCMI {\n  /**\n   * Constructor for NAV object\n   */\n  constructor() {\n    super();\n  }\n\n  #event = '';\n\n  /**\n   * Getter for #event\n   * @return {string}\n   */\n  get event() {\n    return this.#event;\n  }\n\n  /**\n   * Setter for #event\n   * @param {string} event\n   */\n  set event(event) {\n    if (check12ValidFormat(event, scorm12_regex.NAVEvent)) {\n      this.#event = event;\n    }\n  }\n\n  /**\n   * toJSON for nav object\n   * @return {\n   *    {\n   *      event: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'event': this.event,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n","// @flow\n\nconst global = {\n  SCORM_TRUE: 'true',\n  SCORM_FALSE: 'false',\n  STATE_NOT_INITIALIZED: 0,\n  STATE_INITIALIZED: 1,\n  STATE_TERMINATED: 2,\n  LOG_LEVEL_DEBUG: 1,\n  LOG_LEVEL_INFO: 2,\n  LOG_LEVEL_WARNING: 3,\n  LOG_LEVEL_ERROR: 4,\n  LOG_LEVEL_NONE: 5,\n};\n\nconst scorm12 = {\n  // Children lists\n  cmi_children: 'core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions',\n  core_children: 'student_id,student_name,lesson_location,credit,lesson_status,entry,score,total_time,lesson_mode,exit,session_time',\n  score_children: 'raw,min,max',\n  comments_children: 'content,location,time',\n  objectives_children: 'id,score,status',\n  correct_responses_children: 'pattern',\n  student_data_children: 'mastery_score,max_time_allowed,time_limit_action',\n  student_preference_children: 'audio,language,speed,text',\n  interactions_children: 'id,objectives,time,type,correct_responses,weighting,student_response,result,latency',\n\n  error_descriptions: {\n    '101': {\n      basicMessage: 'General Exception',\n      detailMessage: 'No specific error code exists to describe the error. Use LMSGetDiagnostic for more information',\n    },\n    '201': {\n      basicMessage: 'Invalid argument error',\n      detailMessage: 'Indicates that an argument represents an invalid data model element or is otherwise incorrect.',\n    },\n    '202': {\n      basicMessage: 'Element cannot have children',\n      detailMessage: 'Indicates that LMSGetValue was called with a data model element name that ends in \"_children\" for a data model element that does not support the \"_children\" suffix.',\n    },\n    '203': {\n      basicMessage: 'Element not an array - cannot have count',\n      detailMessage: 'Indicates that LMSGetValue was called with a data model element name that ends in \"_count\" for a data model element that does not support the \"_count\" suffix.',\n    },\n    '301': {\n      basicMessage: 'Not initialized',\n      detailMessage: 'Indicates that an API call was made before the call to lmsInitialize.',\n    },\n    '401': {\n      basicMessage: 'Not implemented error',\n      detailMessage: 'The data model element indicated in a call to LMSGetValue or LMSSetValue is valid, but was not implemented by this LMS. SCORM 1.2 defines a set of data model elements as being optional for an LMS to implement.',\n    },\n    '402': {\n      basicMessage: 'Invalid set value, element is a keyword',\n      detailMessage: 'Indicates that LMSSetValue was called on a data model element that represents a keyword (elements that end in \"_children\" and \"_count\").',\n    },\n    '403': {\n      basicMessage: 'Element is read only',\n      detailMessage: 'LMSSetValue was called with a data model element that can only be read.',\n    },\n    '404': {\n      basicMessage: 'Element is write only',\n      detailMessage: 'LMSGetValue was called on a data model element that can only be written to.',\n    },\n    '405': {\n      basicMessage: 'Incorrect Data Type',\n      detailMessage: 'LMSSetValue was called with a value that is not consistent with the data format of the supplied data model element.',\n    },\n    '407': {\n      basicMessage: 'Element Value Out Of Range',\n      detailMessage: 'The numeric value supplied to a LMSSetValue call is outside of the numeric range allowed for the supplied data model element.',\n    },\n    '408': {\n      basicMessage: 'Data Model Dependency Not Established',\n      detailMessage: 'Some data model elements cannot be set until another data model element was set. This error condition indicates that the prerequisite element was not set before the dependent element.',\n    },\n  },\n};\n\nconst aicc = {\n  ...scorm12, ...{\n    cmi_children: 'core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions,evaluation',\n    student_preference_children: 'audio,language,lesson_type,speed,text,text_color,text_location,text_size,video,windows',\n    student_data_children: 'attempt_number,tries,mastery_score,max_time_allowed,time_limit_action',\n    student_demographics_children: 'city,class,company,country,experience,familiar_name,instructor_name,title,native_language,state,street_address,telephone,years_experience',\n    tries_children: 'time,status,score',\n    attempt_records_children: 'score,lesson_status',\n    paths_children: 'location_id,date,time,status,why_left,time_in_element',\n  },\n};\n\nconst scorm2004 = {\n  // Children lists\n  cmi_children: '_version,comments_from_learner,comments_from_lms,completion_status,credit,entry,exit,interactions,launch_data,learner_id,learner_name,learner_preference,location,max_time_allowed,mode,objectives,progress_measure,scaled_passing_score,score,session_time,success_status,suspend_data,time_limit_action,total_time',\n  comments_children: 'comment,timestamp,location',\n  score_children: 'max,raw,scaled,min',\n  objectives_children: 'progress_measure,completion_status,success_status,description,score,id',\n  correct_responses_children: 'pattern',\n  student_data_children: 'mastery_score,max_time_allowed,time_limit_action',\n  student_preference_children: 'audio_level,audio_captioning,delivery_speed,language',\n  interactions_children: 'id,type,objectives,timestamp,correct_responses,weighting,learner_response,result,latency,description',\n\n  error_descriptions: {\n    '0': {\n      basicMessage: 'No Error',\n      detailMessage: 'No error occurred, the previous API call was successful.',\n    },\n    '101': {\n      basicMessage: 'General Exception',\n      detailMessage: 'No specific error code exists to describe the error. Use GetDiagnostic for more information.',\n    },\n    '102': {\n      basicMessage: 'General Initialization Failure',\n      detailMessage: 'Call to Initialize failed for an unknown reason.',\n    },\n    '103': {\n      basicMessage: 'Already Initialized',\n      detailMessage: 'Call to Initialize failed because Initialize was already called.',\n    },\n    '104': {\n      basicMessage: 'Content Instance Terminated',\n      detailMessage: 'Call to Initialize failed because Terminate was already called.',\n    },\n    '111': {\n      basicMessage: 'General Termination Failure',\n      detailMessage: 'Call to Terminate failed for an unknown reason.',\n    },\n    '112': {\n      basicMessage: 'Termination Before Initialization',\n      detailMessage: 'Call to Terminate failed because it was made before the call to Initialize.',\n    },\n    '113': {\n      basicMessage: 'Termination After Termination',\n      detailMessage: 'Call to Terminate failed because Terminate was already called.',\n    },\n    '122': {\n      basicMessage: 'Retrieve Data Before Initialization',\n      detailMessage: 'Call to GetValue failed because it was made before the call to Initialize.',\n    },\n    '123': {\n      basicMessage: 'Retrieve Data After Termination',\n      detailMessage: 'Call to GetValue failed because it was made after the call to Terminate.',\n    },\n    '132': {\n      basicMessage: 'Store Data Before Initialization',\n      detailMessage: 'Call to SetValue failed because it was made before the call to Initialize.',\n    },\n    '133': {\n      basicMessage: 'Store Data After Termination',\n      detailMessage: 'Call to SetValue failed because it was made after the call to Terminate.',\n    },\n    '142': {\n      basicMessage: 'Commit Before Initialization',\n      detailMessage: 'Call to Commit failed because it was made before the call to Initialize.',\n    },\n    '143': {\n      basicMessage: 'Commit After Termination',\n      detailMessage: 'Call to Commit failed because it was made after the call to Terminate.',\n    },\n    '201': {\n      basicMessage: 'General Argument Error',\n      detailMessage: 'An invalid argument was passed to an API method (usually indicates that Initialize, Commit or Terminate did not receive the expected empty string argument.',\n    },\n    '301': {\n      basicMessage: 'General Get Failure',\n      detailMessage: 'Indicates a failed GetValue call where no other specific error code is applicable. Use GetDiagnostic for more information.',\n    },\n    '351': {\n      basicMessage: 'General Set Failure',\n      detailMessage: 'Indicates a failed SetValue call where no other specific error code is applicable. Use GetDiagnostic for more information.',\n    },\n    '391': {\n      basicMessage: 'General Commit Failure',\n      detailMessage: 'Indicates a failed Commit call where no other specific error code is applicable. Use GetDiagnostic for more information.',\n    },\n    '401': {\n      basicMessage: 'Undefined Data Model Element',\n      detailMessage: 'The data model element name passed to GetValue or SetValue is not a valid SCORM data model element.',\n    },\n    '402': {\n      basicMessage: 'Unimplemented Data Model Element',\n      detailMessage: 'The data model element indicated in a call to GetValue or SetValue is valid, but was not implemented by this LMS. In SCORM 2004, this error would indicate an LMS that is not fully SCORM conformant.',\n    },\n    '403': {\n      basicMessage: 'Data Model Element Value Not Initialized',\n      detailMessage: 'Attempt to read a data model element that has not been initialized by the LMS or through a SetValue call. This error condition is often reached during normal execution of a SCO.',\n    },\n    '404': {\n      basicMessage: 'Data Model Element Is Read Only',\n      detailMessage: 'SetValue was called with a data model element that can only be read.',\n    },\n    '405': {\n      basicMessage: 'Data Model Element Is Write Only',\n      detailMessage: 'GetValue was called on a data model element that can only be written to.',\n    },\n    '406': {\n      basicMessage: 'Data Model Element Type Mismatch',\n      detailMessage: 'SetValue was called with a value that is not consistent with the data format of the supplied data model element.',\n    },\n    '407': {\n      basicMessage: 'Data Model Element Value Out Of Range',\n      detailMessage: 'The numeric value supplied to a SetValue call is outside of the numeric range allowed for the supplied data model element.',\n    },\n    '408': {\n      basicMessage: 'Data Model Dependency Not Established',\n      detailMessage: 'Some data model elements cannot be set until another data model element was set. This error condition indicates that the prerequisite element was not set before the dependent element.',\n    },\n  },\n};\n\nconst APIConstants = {\n  global: global,\n  scorm12: scorm12,\n  aicc: aicc,\n  scorm2004: scorm2004,\n};\n\nexport default APIConstants;\n","// @flow\nconst global = {\n  GENERAL: 101,\n  INITIALIZATION_FAILED: 101,\n  INITIALIZED: 101,\n  TERMINATED: 101,\n  TERMINATION_FAILURE: 101,\n  TERMINATION_BEFORE_INIT: 101,\n  MULTIPLE_TERMINATION: 101,\n  RETRIEVE_BEFORE_INIT: 101,\n  RETRIEVE_AFTER_TERM: 101,\n  STORE_BEFORE_INIT: 101,\n  STORE_AFTER_TERM: 101,\n  COMMIT_BEFORE_INIT: 101,\n  COMMIT_AFTER_TERM: 101,\n  ARGUMENT_ERROR: 101,\n  CHILDREN_ERROR: 101,\n  COUNT_ERROR: 101,\n  GENERAL_GET_FAILURE: 101,\n  GENERAL_SET_FAILURE: 101,\n  GENERAL_COMMIT_FAILURE: 101,\n  UNDEFINED_DATA_MODEL: 101,\n  UNIMPLEMENTED_ELEMENT: 101,\n  VALUE_NOT_INITIALIZED: 101,\n  INVALID_SET_VALUE: 101,\n  READ_ONLY_ELEMENT: 101,\n  WRITE_ONLY_ELEMENT: 101,\n  TYPE_MISMATCH: 101,\n  VALUE_OUT_OF_RANGE: 101,\n  DEPENDENCY_NOT_ESTABLISHED: 101,\n};\n\nconst scorm12 = {\n  ...global, ...{\n    RETRIEVE_BEFORE_INIT: 301,\n    STORE_BEFORE_INIT: 301,\n    COMMIT_BEFORE_INIT: 301,\n    ARGUMENT_ERROR: 201,\n    CHILDREN_ERROR: 202,\n    COUNT_ERROR: 203,\n    UNDEFINED_DATA_MODEL: 401,\n    UNIMPLEMENTED_ELEMENT: 401,\n    VALUE_NOT_INITIALIZED: 301,\n    INVALID_SET_VALUE: 402,\n    READ_ONLY_ELEMENT: 403,\n    WRITE_ONLY_ELEMENT: 404,\n    TYPE_MISMATCH: 405,\n    VALUE_OUT_OF_RANGE: 407,\n    DEPENDENCY_NOT_ESTABLISHED: 408,\n  },\n};\n\nconst scorm2004 = {\n  ...global, ...{\n    INITIALIZATION_FAILED: 102,\n    INITIALIZED: 103,\n    TERMINATED: 104,\n    TERMINATION_FAILURE: 111,\n    TERMINATION_BEFORE_INIT: 112,\n    MULTIPLE_TERMINATIONS: 113,\n    RETRIEVE_BEFORE_INIT: 122,\n    RETRIEVE_AFTER_TERM: 123,\n    STORE_BEFORE_INIT: 132,\n    STORE_AFTER_TERM: 133,\n    COMMIT_BEFORE_INIT: 142,\n    COMMIT_AFTER_TERM: 143,\n    ARGUMENT_ERROR: 201,\n    GENERAL_GET_FAILURE: 301,\n    GENERAL_SET_FAILURE: 351,\n    GENERAL_COMMIT_FAILURE: 391,\n    UNDEFINED_DATA_MODEL: 401,\n    UNIMPLEMENTED_ELEMENT: 402,\n    VALUE_NOT_INITIALIZED: 403,\n    READ_ONLY_ELEMENT: 404,\n    WRITE_ONLY_ELEMENT: 405,\n    TYPE_MISMATCH: 406,\n    VALUE_OUT_OF_RANGE: 407,\n    DEPENDENCY_NOT_ESTABLISHED: 408,\n  },\n};\n\nconst ErrorCodes = {\n  scorm12: scorm12,\n  scorm2004: scorm2004,\n};\n\nexport default ErrorCodes;\n","// @flow\n\nconst scorm12 = {\n  CMIString256: '^.{0,255}$',\n  CMIString4096: '^.{0,4096}$',\n  CMITime: '^(?:[01]\\\\d|2[0123]):(?:[012345]\\\\d):(?:[012345]\\\\d)$', // eslint-disable-line\n  CMITimespan: '^([0-9]{2,}):([0-9]{2}):([0-9]{2})(\\.[0-9]{1,2})?$', // eslint-disable-line\n  CMIInteger: '^\\\\d+$',\n  CMISInteger: '^-?([0-9]+)$',\n  CMIDecimal: '^-?([0-9]{0,3})(\\.[0-9]*)?$', // eslint-disable-line\n  CMIIdentifier: '^[\\\\u0021-\\\\u007E\\\\s]{0,255}$',\n  CMIFeedback: '^.{0,255}$', // This must be redefined\n  CMIIndex: '[._](\\\\d+).',\n\n  // Vocabulary Data Type Definition\n  CMIStatus: '^(passed|completed|failed|incomplete|browsed)$',\n  CMIStatus2: '^(passed|completed|failed|incomplete|browsed|not attempted)$',\n  CMIExit: '^(time-out|suspend|logout|)$',\n  CMIType: '^(true-false|choice|fill-in|matching|performance|sequencing|likert|numeric)$',\n  CMIResult: '^(correct|wrong|unanticipated|neutral|([0-9]{0,3})?(\\\\.[0-9]*)?)$', // eslint-disable-line\n  NAVEvent: '^(previous|continue)$',\n\n  // Data ranges\n  score_range: '0#100',\n  audio_range: '-1#100',\n  speed_range: '-100#100',\n  weighting_range: '-100#100',\n  text_range: '-1#1',\n};\n\nconst aicc = {\n  ...scorm12, ...{\n    CMIIdentifier: '^\\\\w{1,255}$',\n  },\n};\n\nconst scorm2004 = {\n  CMIString200: '^[\\\\u0000-\\\\uFFFF]{0,200}$',\n  CMIString250: '^[\\\\u0000-\\\\uFFFF]{0,250}$',\n  CMIString1000: '^[\\\\u0000-\\\\uFFFF]{0,1000}$',\n  CMIString4000: '^[\\\\u0000-\\\\uFFFF]{0,4000}$',\n  CMIString64000: '^[\\\\u0000-\\\\uFFFF]{0,64000}$',\n  CMILang: '^([a-zA-Z]{2,3}|i|x)(\\-[a-zA-Z0-9\\-]{2,8})?$|^$', // eslint-disable-line\n  CMILangString250: '^(\\{lang=([a-zA-Z]{2,3}|i|x)(\\-[a-zA-Z0-9\\-]{2,8})?\\})?((?!\\{.*$).{0,250}$)?$', // eslint-disable-line\n  CMILangcr: '^((\\{lang=([a-zA-Z]{2,3}|i|x)?(\\-[a-zA-Z0-9\\-]{2,8})?\\}))(.*?)$', // eslint-disable-line\n  CMILangString250cr: '^((\\{lang=([a-zA-Z]{2,3}|i|x)?(\\-[a-zA-Z0-9\\-]{2,8})?\\})?(.{0,250})?)?$', // eslint-disable-line\n  CMILangString4000: '^(\\{lang=([a-zA-Z]{2,3}|i|x)(\\-[a-zA-Z0-9\\-]{2,8})?\\})?((?!\\{.*$).{0,4000}$)?$', // eslint-disable-line\n  CMITime: '^(19[7-9]{1}[0-9]{1}|20[0-2]{1}[0-9]{1}|203[0-8]{1})((-(0[1-9]{1}|1[0-2]{1}))((-(0[1-9]{1}|[1-2]{1}[0-9]{1}|3[0-1]{1}))(T([0-1]{1}[0-9]{1}|2[0-3]{1})((:[0-5]{1}[0-9]{1})((:[0-5]{1}[0-9]{1})((\\\\.[0-9]{1,2})((Z|([+|-]([0-1]{1}[0-9]{1}|2[0-3]{1})))(:[0-5]{1}[0-9]{1})?)?)?)?)?)?)?)?$',\n  CMITimespan: '^P(?:([.,\\\\d]+)Y)?(?:([.,\\\\d]+)M)?(?:([.,\\\\d]+)W)?(?:([.,\\\\d]+)D)?(?:T?(?:([.,\\\\d]+)H)?(?:([.,\\\\d]+)M)?(?:([.,\\\\d]+)S)?)?$',\n  CMIInteger: '^\\\\d+$',\n  CMISInteger: '^-?([0-9]+)$',\n  CMIDecimal: '^-?([0-9]{1,5})(\\\\.[0-9]{1,18})?$',\n  CMIIdentifier: '^\\\\S{1,250}[a-zA-Z0-9]$',\n  CMIShortIdentifier: '^[\\\\w\\\\.\\\\-\\\\_]{1,250}$', // eslint-disable-line\n  CMILongIdentifier: '^(?:(?!urn:)\\\\S{1,4000}|urn:[A-Za-z0-9-]{1,31}:\\\\S{1,4000}|.{1,4000})$', // need to re-examine this\n  CMIFeedback: '^.*$', // This must be redefined\n  CMIIndex: '[._](\\\\d+).',\n  CMIIndexStore: '.N(\\\\d+).',\n\n  // Vocabulary Data Type Definition\n  CMICStatus: '^(completed|incomplete|not attempted|unknown)$',\n  CMISStatus: '^(passed|failed|unknown)$',\n  CMIExit: '^(time-out|suspend|logout|normal)$',\n  CMIType: '^(true-false|choice|fill-in|long-fill-in|matching|performance|sequencing|likert|numeric|other)$',\n  CMIResult: '^(correct|incorrect|unanticipated|neutral|-?([0-9]{1,4})(\\\\.[0-9]{1,18})?)$',\n  NAVEvent: '^(previous|continue|exit|exitAll|abandon|abandonAll|suspendAll|\\{target=\\\\S{0,200}[a-zA-Z0-9]\\}choice|jump)$', // eslint-disable-line\n  NAVBoolean: '^(unknown|true|false$)',\n  NAVTarget: '^(previous|continue|choice.{target=\\\\S{0,200}[a-zA-Z0-9]})$',\n\n  // Data ranges\n  scaled_range: '-1#1',\n  audio_range: '0#*',\n  speed_range: '0#*',\n  text_range: '-1#1',\n  progress_range: '0#1',\n};\n\nconst Regex = {\n  aicc: aicc,\n  scorm12: scorm12,\n  scorm2004: scorm2004,\n};\n\nexport default Regex;\n","// @flow\n\nimport APIConstants from './constants/api_constants';\n\nconst scorm12_errors = APIConstants.scorm12.error_descriptions;\nconst aicc_errors = APIConstants.aicc.error_descriptions;\nconst scorm2004_errors = APIConstants.scorm2004.error_descriptions;\n\n/**\n * Base Validation Exception\n */\nexport class ValidationError extends Error {\n  /**\n   * Constructor to take in an error message and code\n   * @param {number} errorCode\n   * @param {string} errorMessage\n   * @param {string} detailedMessage\n   */\n  constructor(errorCode: number, errorMessage: String, detailedMessage: String) {\n    super(errorMessage);\n    this.#errorCode = errorCode;\n    this.#errorMessage = errorMessage;\n    this.#detailedMessage = detailedMessage;\n  }\n\n  #errorCode;\n  #errorMessage;\n  #detailedMessage;\n\n  /**\n   * Getter for #errorCode\n   * @return {number}\n   */\n  get errorCode() {\n    return this.#errorCode;\n  }\n\n  /**\n   * Getter for #errorMessage\n   * @return {string}\n   */\n  get errorMessage() {\n    return this.#errorMessage;\n  }\n\n  /**\n   * Getter for #detailedMessage\n   * @return {string}\n   */\n  get detailedMessage() {\n    return this.#detailedMessage;\n  }\n}\n\n/**\n * SCORM 1.2 Validation Error\n */\nexport class Scorm12ValidationError extends ValidationError {\n  /**\n   * Constructor to take in an error code\n   * @param {number} errorCode\n   */\n  constructor(errorCode: number) {\n    if ({}.hasOwnProperty.call(scorm12_errors, String(errorCode))) {\n      super(errorCode, scorm12_errors[String(errorCode)].basicMessage, scorm12_errors[String(errorCode)].detailMessage);\n    } else {\n      super(101, scorm12_errors['101'].basicMessage, scorm12_errors['101'].detailMessage);\n    }\n  }\n}\n\n/**\n * AICC Validation Error\n */\nexport class AICCValidationError extends ValidationError {\n  /**\n   * Constructor to take in an error code\n   * @param {number} errorCode\n   */\n  constructor(errorCode: number) {\n    if ({}.hasOwnProperty.call(aicc_errors, String(errorCode))) {\n      super(errorCode, aicc_errors[String(errorCode)].basicMessage, aicc_errors[String(errorCode)].detailMessage);\n    } else {\n      super(101, aicc_errors['101'].basicMessage, aicc_errors['101'].detailMessage);\n    }\n  }\n}\n\n/**\n * SCORM 2004 Validation Error\n */\nexport class Scorm2004ValidationError extends ValidationError {\n  /**\n   * Constructor to take in an error code\n   * @param {number} errorCode\n   */\n  constructor(errorCode: number) {\n    if ({}.hasOwnProperty.call(scorm2004_errors, String(errorCode))) {\n      super(errorCode, scorm2004_errors[String(errorCode)].basicMessage, scorm2004_errors[String(errorCode)].detailMessage);\n    } else {\n      super(101, scorm2004_errors['101'].basicMessage, scorm2004_errors['101'].detailMessage);\n    }\n  }\n}\n","import AICC from '../AICC';\n\nwindow.AICC = AICC;\n","// @flow\nexport const SECONDS_PER_SECOND = 1.0;\nexport const SECONDS_PER_MINUTE = 60;\nexport const SECONDS_PER_HOUR = 60 * SECONDS_PER_MINUTE;\nexport const SECONDS_PER_DAY = 24 * SECONDS_PER_HOUR;\n\nconst designations = [\n  ['D', SECONDS_PER_DAY],\n  ['H', SECONDS_PER_HOUR],\n  ['M', SECONDS_PER_MINUTE],\n  ['S', SECONDS_PER_SECOND],\n];\n\n/**\n * Converts a Number to a String of HH:MM:SS\n *\n * @param {Number} totalSeconds\n * @return {string}\n */\nexport function getSecondsAsHHMMSS(totalSeconds: Number) {\n  // SCORM spec does not deal with negative durations, give zero back\n  if (!totalSeconds || totalSeconds <= 0) {\n    return '00:00:00';\n  }\n\n  const hours = Math.floor(totalSeconds / SECONDS_PER_HOUR);\n\n  const dateObj = new Date(totalSeconds * 1000);\n  const minutes = dateObj.getUTCMinutes();\n  // make sure we add any possible decimal value\n  const seconds = dateObj.getSeconds();\n  const ms = totalSeconds % 1.0;\n  let msStr = '';\n  if (countDecimals(ms) > 0) {\n    if (countDecimals(ms) > 2) {\n      msStr = ms.toFixed(2);\n    } else {\n      msStr = String(ms);\n    }\n    msStr = '.' + msStr.split('.')[1];\n  }\n\n  return (hours + ':' + minutes + ':' + seconds).replace(/\\b\\d\\b/g,\n      '0$&') + msStr;\n}\n\n/**\n * Calculate the number of seconds from ISO 8601 Duration\n *\n * @param {Number} seconds\n * @return {String}\n */\nexport function getSecondsAsISODuration(seconds: Number) {\n  // SCORM spec does not deal with negative durations, give zero back\n  if (!seconds || seconds <= 0) {\n    return 'PT0S';\n  }\n\n  let duration = 'P';\n  let remainder = seconds;\n\n  designations.forEach(([sign, current_seconds]) => {\n    let value = Math.floor(remainder / current_seconds);\n\n    remainder = remainder % current_seconds;\n    if (countDecimals(remainder) > 2) {\n      remainder = Number(Number(remainder).toFixed(2));\n    }\n    // If we have anything left in the remainder, and we're currently adding\n    // seconds to the duration, go ahead and add the decimal to the seconds\n    if (sign === 'S' && remainder > 0) {\n      value += remainder;\n    }\n\n    if (value) {\n      if ((duration.indexOf('D') > 0 ||\n          sign === 'H' || sign === 'M' || sign === 'S') &&\n          duration.indexOf('T') === -1) {\n        duration += 'T';\n      }\n      duration += `${value}${sign}`;\n    }\n  });\n\n  return duration;\n}\n\n/**\n * Calculate the number of seconds from HH:MM:SS.DDDDDD\n *\n * @param {string} timeString\n * @param {RegExp} timeRegex\n * @return {number}\n */\nexport function getTimeAsSeconds(timeString: String, timeRegex: RegExp) {\n  if (!timeString || typeof timeString !== 'string' ||\n      !timeString.match(timeRegex)) {\n    return 0;\n  }\n  const parts = timeString.split(':');\n  const hours = Number(parts[0]);\n  const minutes = Number(parts[1]);\n  const seconds = Number(parts[2]);\n  return (hours * 3600) + (minutes * 60) + seconds;\n}\n\n/**\n * Calculate the number of seconds from ISO 8601 Duration\n *\n * @param {string} duration\n * @param {RegExp} durationRegex\n * @return {number}\n */\nexport function getDurationAsSeconds(duration: String, durationRegex: RegExp) {\n  if (!duration || !duration.match(durationRegex)) {\n    return 0;\n  }\n\n  const [, years, months, , days, hours, minutes, seconds] = new RegExp(\n      durationRegex).exec(duration) || [];\n\n  let result = 0.0;\n\n  result += (Number(seconds) * 1.0 || 0.0);\n  result += (Number(minutes) * 60.0 || 0.0);\n  result += (Number(hours) * 3600.0 || 0.0);\n  result += (Number(days) * (60 * 60 * 24.0) || 0.0);\n  result += (Number(years) * (60 * 60 * 24 * 365.0) || 0.0);\n\n  return result;\n}\n\n/**\n * Adds together two ISO8601 Duration strings\n *\n * @param {string} first\n * @param {string} second\n * @param {RegExp} durationRegex\n * @return {string}\n */\nexport function addTwoDurations(\n    first: String,\n    second: String,\n    durationRegex: RegExp) {\n  return getSecondsAsISODuration(\n      getDurationAsSeconds(first, durationRegex) +\n      getDurationAsSeconds(second, durationRegex),\n  );\n}\n\n/**\n * Add together two HH:MM:SS.DD strings\n *\n * @param {string} first\n * @param {string} second\n * @param {RegExp} timeRegex\n * @return {string}\n */\nexport function addHHMMSSTimeStrings(\n    first: String,\n    second: String,\n    timeRegex: RegExp) {\n  return getSecondsAsHHMMSS(\n      getTimeAsSeconds(first, timeRegex) +\n      getTimeAsSeconds(\n          second, timeRegex),\n  );\n}\n\n/**\n * Flatten a JSON object down to string paths for each values\n * @param {object} data\n * @return {object}\n */\nexport function flatten(data) {\n  const result = {};\n\n  /**\n   * Recurse through the object\n   * @param {*} cur\n   * @param {*} prop\n   */\n  function recurse(cur, prop) {\n    if (Object(cur) !== cur) {\n      result[prop] = cur;\n    } else if (Array.isArray(cur)) {\n      for (let i = 0, l = cur.length; i < l; i++) {\n        recurse(cur[i], prop + '[' + i + ']');\n        if (l === 0) result[prop] = [];\n      }\n    } else {\n      let isEmpty = true;\n      for (const p in cur) {\n        if ({}.hasOwnProperty.call(cur, p)) {\n          isEmpty = false;\n          recurse(cur[p], prop ? prop + '.' + p : p);\n        }\n      }\n      if (isEmpty && prop) result[prop] = {};\n    }\n  }\n\n  recurse(data, '');\n  return result;\n}\n\n/**\n * Un-flatten a flat JSON object\n * @param {object} data\n * @return {object}\n */\nexport function unflatten(data) {\n  'use strict';\n  if (Object(data) !== data || Array.isArray(data)) return data;\n  const regex = /\\.?([^.[\\]]+)|\\[(\\d+)]/g;\n  const result = {};\n  for (const p in data) {\n    if ({}.hasOwnProperty.call(data, p)) {\n      let cur = result;\n      let prop = '';\n      let m = regex.exec(p);\n      while (m) {\n        cur = cur[prop] || (cur[prop] = (m[2] ? [] : {}));\n        prop = m[2] || m[1];\n        m = regex.exec(p);\n      }\n      cur[prop] = data[p];\n    }\n  }\n  return result[''] || result;\n}\n\n/**\n * Counts the number of decimal places\n * @param {number} num\n * @return {number}\n */\nexport function countDecimals(num: number) {\n  if (Math.floor(num) === num || String(num).indexOf('.') < 0) return 0;\n  const parts = num.toString().split('.')[1];\n  return parts.length || 0;\n}\n"]} diff --git a/dist/aicc.min.js b/dist/aicc.min.js new file mode 100644 index 0000000..b5b2453 --- /dev/null +++ b/dist/aicc.min.js @@ -0,0 +1,7263 @@ +(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i + * Build: `lodash modularize exports="npm" -o ./` + * Copyright jQuery Foundation and other contributors + * Released under MIT license + * Based on Underscore.js 1.8.3 + * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + */ + +/** Used as the `TypeError` message for "Functions" methods. */ +var FUNC_ERROR_TEXT = 'Expected a function'; + +/** Used as references for various `Number` constants. */ +var NAN = 0 / 0; + +/** `Object#toString` result references. */ +var symbolTag = '[object Symbol]'; + +/** Used to match leading and trailing whitespace. */ +var reTrim = /^\s+|\s+$/g; + +/** Used to detect bad signed hexadecimal string values. */ +var reIsBadHex = /^[-+]0x[0-9a-f]+$/i; + +/** Used to detect binary string values. */ +var reIsBinary = /^0b[01]+$/i; + +/** Used to detect octal string values. */ +var reIsOctal = /^0o[0-7]+$/i; + +/** Built-in method references without a dependency on `root`. */ +var freeParseInt = parseInt; + +/** Detect free variable `global` from Node.js. */ +var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; + +/** Detect free variable `self`. */ +var freeSelf = typeof self == 'object' && self && self.Object === Object && self; + +/** Used as a reference to the global object. */ +var root = freeGlobal || freeSelf || Function('return this')(); + +/** Used for built-in method references. */ +var objectProto = Object.prototype; + +/** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ +var objectToString = objectProto.toString; + +/* Built-in method references for those with the same name as other `lodash` methods. */ +var nativeMax = Math.max, + nativeMin = Math.min; + +/** + * Gets the timestamp of the number of milliseconds that have elapsed since + * the Unix epoch (1 January 1970 00:00:00 UTC). + * + * @static + * @memberOf _ + * @since 2.4.0 + * @category Date + * @returns {number} Returns the timestamp. + * @example + * + * _.defer(function(stamp) { + * console.log(_.now() - stamp); + * }, _.now()); + * // => Logs the number of milliseconds it took for the deferred invocation. + */ +var now = function() { + return root.Date.now(); +}; + +/** + * Creates a debounced function that delays invoking `func` until after `wait` + * milliseconds have elapsed since the last time the debounced function was + * invoked. The debounced function comes with a `cancel` method to cancel + * delayed `func` invocations and a `flush` method to immediately invoke them. + * Provide `options` to indicate whether `func` should be invoked on the + * leading and/or trailing edge of the `wait` timeout. The `func` is invoked + * with the last arguments provided to the debounced function. Subsequent + * calls to the debounced function return the result of the last `func` + * invocation. + * + * **Note:** If `leading` and `trailing` options are `true`, `func` is + * invoked on the trailing edge of the timeout only if the debounced function + * is invoked more than once during the `wait` timeout. + * + * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred + * until to the next tick, similar to `setTimeout` with a timeout of `0`. + * + * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) + * for details over the differences between `_.debounce` and `_.throttle`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to debounce. + * @param {number} [wait=0] The number of milliseconds to delay. + * @param {Object} [options={}] The options object. + * @param {boolean} [options.leading=false] + * Specify invoking on the leading edge of the timeout. + * @param {number} [options.maxWait] + * The maximum time `func` is allowed to be delayed before it's invoked. + * @param {boolean} [options.trailing=true] + * Specify invoking on the trailing edge of the timeout. + * @returns {Function} Returns the new debounced function. + * @example + * + * // Avoid costly calculations while the window size is in flux. + * jQuery(window).on('resize', _.debounce(calculateLayout, 150)); + * + * // Invoke `sendMail` when clicked, debouncing subsequent calls. + * jQuery(element).on('click', _.debounce(sendMail, 300, { + * 'leading': true, + * 'trailing': false + * })); + * + * // Ensure `batchLog` is invoked once after 1 second of debounced calls. + * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 }); + * var source = new EventSource('/stream'); + * jQuery(source).on('message', debounced); + * + * // Cancel the trailing debounced invocation. + * jQuery(window).on('popstate', debounced.cancel); + */ +function debounce(func, wait, options) { + var lastArgs, + lastThis, + maxWait, + result, + timerId, + lastCallTime, + lastInvokeTime = 0, + leading = false, + maxing = false, + trailing = true; + + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + wait = toNumber(wait) || 0; + if (isObject(options)) { + leading = !!options.leading; + maxing = 'maxWait' in options; + maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait; + trailing = 'trailing' in options ? !!options.trailing : trailing; + } + + function invokeFunc(time) { + var args = lastArgs, + thisArg = lastThis; + + lastArgs = lastThis = undefined; + lastInvokeTime = time; + result = func.apply(thisArg, args); + return result; + } + + function leadingEdge(time) { + // Reset any `maxWait` timer. + lastInvokeTime = time; + // Start the timer for the trailing edge. + timerId = setTimeout(timerExpired, wait); + // Invoke the leading edge. + return leading ? invokeFunc(time) : result; + } + + function remainingWait(time) { + var timeSinceLastCall = time - lastCallTime, + timeSinceLastInvoke = time - lastInvokeTime, + result = wait - timeSinceLastCall; + + return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result; + } + + function shouldInvoke(time) { + var timeSinceLastCall = time - lastCallTime, + timeSinceLastInvoke = time - lastInvokeTime; + + // Either this is the first call, activity has stopped and we're at the + // trailing edge, the system time has gone backwards and we're treating + // it as the trailing edge, or we've hit the `maxWait` limit. + return (lastCallTime === undefined || (timeSinceLastCall >= wait) || + (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait)); + } + + function timerExpired() { + var time = now(); + if (shouldInvoke(time)) { + return trailingEdge(time); + } + // Restart the timer. + timerId = setTimeout(timerExpired, remainingWait(time)); + } + + function trailingEdge(time) { + timerId = undefined; + + // Only invoke if we have `lastArgs` which means `func` has been + // debounced at least once. + if (trailing && lastArgs) { + return invokeFunc(time); + } + lastArgs = lastThis = undefined; + return result; + } + + function cancel() { + if (timerId !== undefined) { + clearTimeout(timerId); + } + lastInvokeTime = 0; + lastArgs = lastCallTime = lastThis = timerId = undefined; + } + + function flush() { + return timerId === undefined ? result : trailingEdge(now()); + } + + function debounced() { + var time = now(), + isInvoking = shouldInvoke(time); + + lastArgs = arguments; + lastThis = this; + lastCallTime = time; + + if (isInvoking) { + if (timerId === undefined) { + return leadingEdge(lastCallTime); + } + if (maxing) { + // Handle invocations in a tight loop. + timerId = setTimeout(timerExpired, wait); + return invokeFunc(lastCallTime); + } + } + if (timerId === undefined) { + timerId = setTimeout(timerExpired, wait); + } + return result; + } + debounced.cancel = cancel; + debounced.flush = flush; + return debounced; +} + +/** + * Checks if `value` is the + * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) + * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an object, else `false`. + * @example + * + * _.isObject({}); + * // => true + * + * _.isObject([1, 2, 3]); + * // => true + * + * _.isObject(_.noop); + * // => true + * + * _.isObject(null); + * // => false + */ +function isObject(value) { + var type = typeof value; + return !!value && (type == 'object' || type == 'function'); +} + +/** + * Checks if `value` is object-like. A value is object-like if it's not `null` + * and has a `typeof` result of "object". + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is object-like, else `false`. + * @example + * + * _.isObjectLike({}); + * // => true + * + * _.isObjectLike([1, 2, 3]); + * // => true + * + * _.isObjectLike(_.noop); + * // => false + * + * _.isObjectLike(null); + * // => false + */ +function isObjectLike(value) { + return !!value && typeof value == 'object'; +} + +/** + * Checks if `value` is classified as a `Symbol` primitive or object. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. + * @example + * + * _.isSymbol(Symbol.iterator); + * // => true + * + * _.isSymbol('abc'); + * // => false + */ +function isSymbol(value) { + return typeof value == 'symbol' || + (isObjectLike(value) && objectToString.call(value) == symbolTag); +} + +/** + * Converts `value` to a number. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to process. + * @returns {number} Returns the number. + * @example + * + * _.toNumber(3.2); + * // => 3.2 + * + * _.toNumber(Number.MIN_VALUE); + * // => 5e-324 + * + * _.toNumber(Infinity); + * // => Infinity + * + * _.toNumber('3.2'); + * // => 3.2 + */ +function toNumber(value) { + if (typeof value == 'number') { + return value; + } + if (isSymbol(value)) { + return NAN; + } + if (isObject(value)) { + var other = typeof value.valueOf == 'function' ? value.valueOf() : value; + value = isObject(other) ? (other + '') : other; + } + if (typeof value != 'string') { + return value === 0 ? value : +value; + } + value = value.replace(reTrim, ''); + var isBinary = reIsBinary.test(value); + return (isBinary || reIsOctal.test(value)) + ? freeParseInt(value.slice(2), isBinary ? 2 : 8) + : (reIsBadHex.test(value) ? NAN : +value); +} + +module.exports = debounce; + +}).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +},{}],2:[function(require,module,exports){ +"use strict"; + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +var _Scorm12API2 = _interopRequireDefault(require("./Scorm12API")); + +var _aicc_cmi = require("./cmi/aicc_cmi"); + +var _scorm12_cmi = require("./cmi/scorm12_cmi"); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); } + +function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +/** + * The AICC API class + */ +var AICC = /*#__PURE__*/function (_Scorm12API) { + _inherits(AICC, _Scorm12API); + + var _super = _createSuper(AICC); + + /** + * Constructor to create AICC API object + * @param {object} settings + */ + function AICC(settings) { + var _this; + + _classCallCheck(this, AICC); + + var finalSettings = _objectSpread(_objectSpread({}, { + mastery_override: false + }), settings); + + _this = _super.call(this, finalSettings); + _this.cmi = new _aicc_cmi.CMI(); + _this.nav = new _scorm12_cmi.NAV(); + return _this; + } + /** + * Gets or builds a new child element to add to the array. + * + * @param {string} CMIElement + * @param {any} value + * @param {boolean} foundFirstIndex + * @return {object} + */ + + + _createClass(AICC, [{ + key: "getChildElement", + value: function getChildElement(CMIElement, value, foundFirstIndex) { + var newChild = _get(_getPrototypeOf(AICC.prototype), "getChildElement", this).call(this, CMIElement, value, foundFirstIndex); + + if (!newChild) { + if (this.stringMatches(CMIElement, 'cmi\\.evaluation\\.comments\\.\\d+')) { + newChild = new _aicc_cmi.CMIEvaluationCommentsObject(); + } else if (this.stringMatches(CMIElement, 'cmi\\.student_data\\.tries\\.\\d+')) { + newChild = new _aicc_cmi.CMITriesObject(); + } else if (this.stringMatches(CMIElement, 'cmi\\.student_data\\.attempt_records\\.\\d+')) { + newChild = new _aicc_cmi.CMIAttemptRecordsObject(); + } + } + + return newChild; + } + /** + * Replace the whole API with another + * + * @param {AICC} newAPI + */ + + }, { + key: "replaceWithAnotherScormAPI", + value: function replaceWithAnotherScormAPI(newAPI) { + // Data Model + this.cmi = newAPI.cmi; + this.nav = newAPI.nav; + } + }]); + + return AICC; +}(_Scorm12API2["default"]); + +exports["default"] = AICC; + +},{"./Scorm12API":4,"./cmi/aicc_cmi":5,"./cmi/scorm12_cmi":7}],3:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +var _common = require("./cmi/common"); + +var _exceptions = require("./exceptions"); + +var _error_codes2 = _interopRequireDefault(require("./constants/error_codes")); + +var _api_constants = _interopRequireDefault(require("./constants/api_constants")); + +var _utilities = require("./utilities"); + +var _lodash = _interopRequireDefault(require("lodash.debounce")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); } + +function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } + +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit(arr, i) { var _i = arr && (typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]); if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); } + +function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; } + +function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); } + +function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } } + +var global_constants = _api_constants["default"].global; +var scorm12_error_codes = _error_codes2["default"].scorm12; +/** + * Base API class for AICC, SCORM 1.2, and SCORM 2004. Should be considered + * abstract, and never initialized on it's own. + */ + +var _timeout = new WeakMap(); + +var _error_codes = new WeakMap(); + +var _settings = new WeakMap(); + +var BaseAPI = /*#__PURE__*/function () { + /** + * Constructor for Base API class. Sets some shared API fields, as well as + * sets up options for the API. + * @param {object} error_codes + * @param {object} settings + */ + function BaseAPI(error_codes, settings) { + _classCallCheck(this, BaseAPI); + + _timeout.set(this, { + writable: true, + value: void 0 + }); + + _error_codes.set(this, { + writable: true, + value: void 0 + }); + + _settings.set(this, { + writable: true, + value: { + autocommit: false, + autocommitSeconds: 10, + asyncCommit: false, + sendBeaconCommit: false, + lmsCommitUrl: false, + dataCommitFormat: 'json', + // valid formats are 'json' or 'flattened', 'params' + commitRequestDataType: 'application/json;charset=UTF-8', + autoProgress: false, + logLevel: global_constants.LOG_LEVEL_ERROR, + selfReportSessionTime: false, + alwaysSendTotalTime: false, + strict_errors: true, + responseHandler: function responseHandler(xhr) { + var result; + + if (typeof xhr !== 'undefined') { + result = JSON.parse(xhr.responseText); + + if (result === null || !{}.hasOwnProperty.call(result, 'result')) { + result = {}; + + if (xhr.status === 200) { + result.result = global_constants.SCORM_TRUE; + result.errorCode = 0; + } else { + result.result = global_constants.SCORM_FALSE; + result.errorCode = 101; + } + } + } + + return result; + } + } + }); + + _defineProperty(this, "cmi", void 0); + + _defineProperty(this, "startingData", void 0); + + if ((this instanceof BaseAPI ? this.constructor : void 0) === BaseAPI) { + throw new TypeError('Cannot construct BaseAPI instances directly'); + } + + this.currentState = global_constants.STATE_NOT_INITIALIZED; + this.lastErrorCode = 0; + this.listenerArray = []; + + _classPrivateFieldSet(this, _timeout, null); + + _classPrivateFieldSet(this, _error_codes, error_codes); + + this.settings = settings; + this.apiLogLevel = this.settings.logLevel; + this.selfReportSessionTime = this.settings.selfReportSessionTime; + } + /** + * Initialize the API + * @param {string} callbackName + * @param {string} initializeMessage + * @param {string} terminationMessage + * @return {string} + */ + + + _createClass(BaseAPI, [{ + key: "initialize", + value: function initialize(callbackName, initializeMessage, terminationMessage) { + var returnValue = global_constants.SCORM_FALSE; + + if (this.isInitialized()) { + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).INITIALIZED, initializeMessage); + } else if (this.isTerminated()) { + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).TERMINATED, terminationMessage); + } else { + if (this.selfReportSessionTime) { + this.cmi.setStartTime(); + } + + this.currentState = global_constants.STATE_INITIALIZED; + this.lastErrorCode = 0; + returnValue = global_constants.SCORM_TRUE; + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Getter for #error_codes + * @return {object} + */ + + }, { + key: "error_codes", + get: function get() { + return _classPrivateFieldGet(this, _error_codes); + } + /** + * Getter for #settings + * @return {object} + */ + + }, { + key: "settings", + get: function get() { + return _classPrivateFieldGet(this, _settings); + } + /** + * Setter for #settings + * @param {object} settings + */ + , + set: function set(settings) { + _classPrivateFieldSet(this, _settings, _objectSpread(_objectSpread({}, _classPrivateFieldGet(this, _settings)), settings)); + } + /** + * Terminates the current run of the API + * @param {string} callbackName + * @param {boolean} checkTerminated + * @return {string} + */ + + }, { + key: "terminate", + value: function terminate(callbackName, checkTerminated) { + var returnValue = global_constants.SCORM_FALSE; + + if (this.checkState(checkTerminated, _classPrivateFieldGet(this, _error_codes).TERMINATION_BEFORE_INIT, _classPrivateFieldGet(this, _error_codes).MULTIPLE_TERMINATION)) { + this.currentState = global_constants.STATE_TERMINATED; + var result = this.storeData(true); + + if (!this.settings.sendBeaconCommit && !this.settings.asyncCommit && typeof result.errorCode !== 'undefined' && result.errorCode > 0) { + this.throwSCORMError(result.errorCode); + } + + returnValue = typeof result !== 'undefined' && result.result ? result.result : global_constants.SCORM_FALSE; + if (checkTerminated) this.lastErrorCode = 0; + returnValue = global_constants.SCORM_TRUE; + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Get the value of the CMIElement. + * + * @param {string} callbackName + * @param {boolean} checkTerminated + * @param {string} CMIElement + * @return {string} + */ + + }, { + key: "getValue", + value: function getValue(callbackName, checkTerminated, CMIElement) { + var returnValue; + + if (this.checkState(checkTerminated, _classPrivateFieldGet(this, _error_codes).RETRIEVE_BEFORE_INIT, _classPrivateFieldGet(this, _error_codes).RETRIEVE_AFTER_TERM)) { + if (checkTerminated) this.lastErrorCode = 0; + + try { + returnValue = this.getCMIValue(CMIElement); + } catch (e) { + if (e instanceof _exceptions.ValidationError) { + this.lastErrorCode = e.errorCode; + returnValue = global_constants.SCORM_FALSE; + } else { + if (e.message) { + console.error(e.message); + } else { + console.error(e); + } + + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).GENERAL); + } + } + + this.processListeners(callbackName, CMIElement); + } + + this.apiLog(callbackName, CMIElement, ': returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Sets the value of the CMIElement. + * + * @param {string} callbackName + * @param {string} commitCallback + * @param {boolean} checkTerminated + * @param {string} CMIElement + * @param {*} value + * @return {string} + */ + + }, { + key: "setValue", + value: function setValue(callbackName, commitCallback, checkTerminated, CMIElement, value) { + if (value !== undefined) { + value = String(value); + } + + var returnValue = global_constants.SCORM_FALSE; + + if (this.checkState(checkTerminated, _classPrivateFieldGet(this, _error_codes).STORE_BEFORE_INIT, _classPrivateFieldGet(this, _error_codes).STORE_AFTER_TERM)) { + if (checkTerminated) this.lastErrorCode = 0; + + try { + returnValue = this.setCMIValue(CMIElement, value); + } catch (e) { + if (e instanceof _exceptions.ValidationError) { + this.lastErrorCode = e.errorCode; + returnValue = global_constants.SCORM_FALSE; + } else { + if (e.message) { + console.error(e.message); + } else { + console.error(e); + } + + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).GENERAL); + } + } + + this.processListeners(callbackName, CMIElement, value); + } + + if (returnValue === undefined) { + returnValue = global_constants.SCORM_FALSE; + } // If we didn't have any errors while setting the data, go ahead and + // schedule a commit, if autocommit is turned on + + + if (String(this.lastErrorCode) === '0') { + if (this.settings.autocommit && !_classPrivateFieldGet(this, _timeout)) { + this.scheduleCommit(this.settings.autocommitSeconds * 1000, commitCallback); + } + } + + this.apiLog(callbackName, CMIElement, ': ' + value + ': result: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Orders LMS to store all content parameters + * @param {string} callbackName + * @param {boolean} checkTerminated + * @return {string} + */ + + }, { + key: "commit", + value: function commit(callbackName, checkTerminated) { + this.clearScheduledCommit(); + var returnValue = global_constants.SCORM_FALSE; + + if (this.checkState(checkTerminated, _classPrivateFieldGet(this, _error_codes).COMMIT_BEFORE_INIT, _classPrivateFieldGet(this, _error_codes).COMMIT_AFTER_TERM)) { + var result = this.storeData(false); + + if (!this.settings.sendBeaconCommit && !this.settings.asyncCommit && result.errorCode && result.errorCode > 0) { + this.throwSCORMError(result.errorCode); + } + + returnValue = typeof result !== 'undefined' && result.result ? result.result : global_constants.SCORM_FALSE; + this.apiLog(callbackName, 'HttpRequest', ' Result: ' + returnValue, global_constants.LOG_LEVEL_DEBUG); + if (checkTerminated) this.lastErrorCode = 0; + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Returns last error code + * @param {string} callbackName + * @return {string} + */ + + }, { + key: "getLastError", + value: function getLastError(callbackName) { + var returnValue = String(this.lastErrorCode); + this.processListeners(callbackName); + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + return returnValue; + } + /** + * Returns the errorNumber error description + * + * @param {string} callbackName + * @param {(string|number)} CMIErrorCode + * @return {string} + */ + + }, { + key: "getErrorString", + value: function getErrorString(callbackName, CMIErrorCode) { + var returnValue = ''; + + if (CMIErrorCode !== null && CMIErrorCode !== '') { + returnValue = this.getLmsErrorMessageDetails(CMIErrorCode); + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + return returnValue; + } + /** + * Returns a comprehensive description of the errorNumber error. + * + * @param {string} callbackName + * @param {(string|number)} CMIErrorCode + * @return {string} + */ + + }, { + key: "getDiagnostic", + value: function getDiagnostic(callbackName, CMIErrorCode) { + var returnValue = ''; + + if (CMIErrorCode !== null && CMIErrorCode !== '') { + returnValue = this.getLmsErrorMessageDetails(CMIErrorCode, true); + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + return returnValue; + } + /** + * Checks the LMS state and ensures it has been initialized. + * + * @param {boolean} checkTerminated + * @param {number} beforeInitError + * @param {number} afterTermError + * @return {boolean} + */ + + }, { + key: "checkState", + value: function checkState(checkTerminated, beforeInitError, afterTermError) { + if (this.isNotInitialized()) { + this.throwSCORMError(beforeInitError); + return false; + } else if (checkTerminated && this.isTerminated()) { + this.throwSCORMError(afterTermError); + return false; + } + + return true; + } + /** + * Logging for all SCORM actions + * + * @param {string} functionName + * @param {string} CMIElement + * @param {string} logMessage + * @param {number}messageLevel + */ + + }, { + key: "apiLog", + value: function apiLog(functionName, CMIElement, logMessage, messageLevel) { + logMessage = this.formatMessage(functionName, CMIElement, logMessage); + + if (messageLevel >= this.apiLogLevel) { + switch (messageLevel) { + case global_constants.LOG_LEVEL_ERROR: + console.error(logMessage); + break; + + case global_constants.LOG_LEVEL_WARNING: + console.warn(logMessage); + break; + + case global_constants.LOG_LEVEL_INFO: + console.info(logMessage); + break; + + case global_constants.LOG_LEVEL_DEBUG: + if (console.debug) { + console.debug(logMessage); + } else { + console.log(logMessage); + } + + break; + } + } + } + /** + * Formats the SCORM messages for easy reading + * + * @param {string} functionName + * @param {string} CMIElement + * @param {string} message + * @return {string} + */ + + }, { + key: "formatMessage", + value: function formatMessage(functionName, CMIElement, message) { + var baseLength = 20; + var messageString = ''; + messageString += functionName; + var fillChars = baseLength - messageString.length; + + for (var i = 0; i < fillChars; i++) { + messageString += ' '; + } + + messageString += ': '; + + if (CMIElement) { + var CMIElementBaseLength = 70; + messageString += CMIElement; + fillChars = CMIElementBaseLength - messageString.length; + + for (var j = 0; j < fillChars; j++) { + messageString += ' '; + } + } + + if (message) { + messageString += message; + } + + return messageString; + } + /** + * Checks to see if {str} contains {tester} + * + * @param {string} str String to check against + * @param {string} tester String to check for + * @return {boolean} + */ + + }, { + key: "stringMatches", + value: function stringMatches(str, tester) { + return str && tester && str.match(tester); + } + /** + * Check to see if the specific object has the given property + * @param {*} refObject + * @param {string} attribute + * @return {boolean} + * @private + */ + + }, { + key: "_checkObjectHasProperty", + value: function _checkObjectHasProperty(refObject, attribute) { + return Object.hasOwnProperty.call(refObject, attribute) || Object.getOwnPropertyDescriptor(Object.getPrototypeOf(refObject), attribute) || attribute in refObject; + } + /** + * Returns the message that corresponds to errorNumber + * APIs that inherit BaseAPI should override this function + * + * @param {(string|number)} _errorNumber + * @param {boolean} _detail + * @return {string} + * @abstract + */ + + }, { + key: "getLmsErrorMessageDetails", + value: function getLmsErrorMessageDetails(_errorNumber, _detail) { + throw new Error('The getLmsErrorMessageDetails method has not been implemented'); + } + /** + * Gets the value for the specific element. + * APIs that inherit BaseAPI should override this function + * + * @param {string} _CMIElement + * @return {string} + * @abstract + */ + + }, { + key: "getCMIValue", + value: function getCMIValue(_CMIElement) { + throw new Error('The getCMIValue method has not been implemented'); + } + /** + * Sets the value for the specific element. + * APIs that inherit BaseAPI should override this function + * + * @param {string} _CMIElement + * @param {any} _value + * @return {string} + * @abstract + */ + + }, { + key: "setCMIValue", + value: function setCMIValue(_CMIElement, _value) { + throw new Error('The setCMIValue method has not been implemented'); + } + /** + * Shared API method to set a valid for a given element. + * + * @param {string} methodName + * @param {boolean} scorm2004 + * @param {string} CMIElement + * @param {*} value + * @return {string} + */ + + }, { + key: "_commonSetCMIValue", + value: function _commonSetCMIValue(methodName, scorm2004, CMIElement, value) { + if (!CMIElement || CMIElement === '') { + return global_constants.SCORM_FALSE; + } + + var structure = CMIElement.split('.'); + var refObject = this; + var returnValue = global_constants.SCORM_FALSE; + var foundFirstIndex = false; + var invalidErrorMessage = "The data model element passed to ".concat(methodName, " (").concat(CMIElement, ") is not a valid SCORM data model element."); + var invalidErrorCode = scorm2004 ? _classPrivateFieldGet(this, _error_codes).UNDEFINED_DATA_MODEL : _classPrivateFieldGet(this, _error_codes).GENERAL; + + for (var i = 0; i < structure.length; i++) { + var attribute = structure[i]; + + if (i === structure.length - 1) { + if (scorm2004 && attribute.substr(0, 8) === '{target=' && typeof refObject._isTargetValid == 'function') { + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).READ_ONLY_ELEMENT); + } else if (!this._checkObjectHasProperty(refObject, attribute)) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + } else { + if (this.isInitialized() && this.stringMatches(CMIElement, '\\.correct_responses\\.\\d+')) { + this.validateCorrectResponse(CMIElement, value); + } + + if (!scorm2004 || this.lastErrorCode === 0) { + refObject[attribute] = value; + returnValue = global_constants.SCORM_TRUE; + } + } + } else { + refObject = refObject[attribute]; + + if (!refObject) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + break; + } + + if (refObject instanceof _common.CMIArray) { + var index = parseInt(structure[i + 1], 10); // SCO is trying to set an item on an array + + if (!isNaN(index)) { + var item = refObject.childArray[index]; + + if (item) { + refObject = item; + foundFirstIndex = true; + } else { + var newChild = this.getChildElement(CMIElement, value, foundFirstIndex); + foundFirstIndex = true; + + if (!newChild) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + } else { + if (refObject.initialized) newChild.initialize(); + refObject.childArray.push(newChild); + refObject = newChild; + } + } // Have to update i value to skip the array position + + + i++; + } + } + } + } + + if (returnValue === global_constants.SCORM_FALSE) { + this.apiLog(methodName, null, "There was an error setting the value for: ".concat(CMIElement, ", value of: ").concat(value), global_constants.LOG_LEVEL_WARNING); + } + + return returnValue; + } + /** + * Abstract method for validating that a response is correct. + * + * @param {string} _CMIElement + * @param {*} _value + */ + + }, { + key: "validateCorrectResponse", + value: function validateCorrectResponse(_CMIElement, _value) {// just a stub method + } + /** + * Gets or builds a new child element to add to the array. + * APIs that inherit BaseAPI should override this method. + * + * @param {string} _CMIElement - unused + * @param {*} _value - unused + * @param {boolean} _foundFirstIndex - unused + * @return {*} + * @abstract + */ + + }, { + key: "getChildElement", + value: function getChildElement(_CMIElement, _value, _foundFirstIndex) { + throw new Error('The getChildElement method has not been implemented'); + } + /** + * Gets a value from the CMI Object + * + * @param {string} methodName + * @param {boolean} scorm2004 + * @param {string} CMIElement + * @return {*} + */ + + }, { + key: "_commonGetCMIValue", + value: function _commonGetCMIValue(methodName, scorm2004, CMIElement) { + if (!CMIElement || CMIElement === '') { + return ''; + } + + var structure = CMIElement.split('.'); + var refObject = this; + var attribute = null; + var uninitializedErrorMessage = "The data model element passed to ".concat(methodName, " (").concat(CMIElement, ") has not been initialized."); + var invalidErrorMessage = "The data model element passed to ".concat(methodName, " (").concat(CMIElement, ") is not a valid SCORM data model element."); + var invalidErrorCode = scorm2004 ? _classPrivateFieldGet(this, _error_codes).UNDEFINED_DATA_MODEL : _classPrivateFieldGet(this, _error_codes).GENERAL; + + for (var i = 0; i < structure.length; i++) { + attribute = structure[i]; + + if (!scorm2004) { + if (i === structure.length - 1) { + if (!this._checkObjectHasProperty(refObject, attribute)) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + return; + } + } + } else { + if (String(attribute).substr(0, 8) === '{target=' && typeof refObject._isTargetValid == 'function') { + var target = String(attribute).substr(8, String(attribute).length - 9); + return refObject._isTargetValid(target); + } else if (!this._checkObjectHasProperty(refObject, attribute)) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + return; + } + } + + refObject = refObject[attribute]; + + if (refObject === undefined) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + break; + } + + if (refObject instanceof _common.CMIArray) { + var index = parseInt(structure[i + 1], 10); // SCO is trying to set an item on an array + + if (!isNaN(index)) { + var item = refObject.childArray[index]; + + if (item) { + refObject = item; + } else { + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).VALUE_NOT_INITIALIZED, uninitializedErrorMessage); + break; + } // Have to update i value to skip the array position + + + i++; + } + } + } + + if (refObject === null || refObject === undefined) { + if (!scorm2004) { + if (attribute === '_children') { + this.throwSCORMError(scorm12_error_codes.CHILDREN_ERROR); + } else if (attribute === '_count') { + this.throwSCORMError(scorm12_error_codes.COUNT_ERROR); + } + } + } else { + return refObject; + } + } + /** + * Returns true if the API's current state is STATE_INITIALIZED + * + * @return {boolean} + */ + + }, { + key: "isInitialized", + value: function isInitialized() { + return this.currentState === global_constants.STATE_INITIALIZED; + } + /** + * Returns true if the API's current state is STATE_NOT_INITIALIZED + * + * @return {boolean} + */ + + }, { + key: "isNotInitialized", + value: function isNotInitialized() { + return this.currentState === global_constants.STATE_NOT_INITIALIZED; + } + /** + * Returns true if the API's current state is STATE_TERMINATED + * + * @return {boolean} + */ + + }, { + key: "isTerminated", + value: function isTerminated() { + return this.currentState === global_constants.STATE_TERMINATED; + } + /** + * Provides a mechanism for attaching to a specific SCORM event + * + * @param {string} listenerName + * @param {function} callback + */ + + }, { + key: "on", + value: function on(listenerName, callback) { + if (!callback) return; + var listenerFunctions = listenerName.split(' '); + + for (var i = 0; i < listenerFunctions.length; i++) { + var listenerSplit = listenerFunctions[i].split('.'); + if (listenerSplit.length === 0) return; + var functionName = listenerSplit[0]; + var CMIElement = null; + + if (listenerSplit.length > 1) { + CMIElement = listenerName.replace(functionName + '.', ''); + } + + this.listenerArray.push({ + functionName: functionName, + CMIElement: CMIElement, + callback: callback + }); + this.apiLog('on', functionName, "Added event listener: ".concat(this.listenerArray.length), global_constants.LOG_LEVEL_INFO); + } + } + /** + * Provides a mechanism for detaching a specific SCORM event listener + * + * @param {string} listenerName + * @param {function} callback + */ + + }, { + key: "off", + value: function off(listenerName, callback) { + var _this = this; + + if (!callback) return; + var listenerFunctions = listenerName.split(' '); + + var _loop = function _loop(i) { + var listenerSplit = listenerFunctions[i].split('.'); + if (listenerSplit.length === 0) return { + v: void 0 + }; + var functionName = listenerSplit[0]; + var CMIElement = null; + + if (listenerSplit.length > 1) { + CMIElement = listenerName.replace(functionName + '.', ''); + } + + var removeIndex = _this.listenerArray.findIndex(function (obj) { + return obj.functionName === functionName && obj.CMIElement === CMIElement && obj.callback === callback; + }); + + if (removeIndex !== -1) { + _this.listenerArray.splice(removeIndex, 1); + + _this.apiLog('off', functionName, "Removed event listener: ".concat(_this.listenerArray.length), global_constants.LOG_LEVEL_INFO); + } + }; + + for (var i = 0; i < listenerFunctions.length; i++) { + var _ret = _loop(i); + + if (_typeof(_ret) === "object") return _ret.v; + } + } + /** + * Provides a mechanism for clearing all listeners from a specific SCORM event + * + * @param {string} listenerName + */ + + }, { + key: "clear", + value: function clear(listenerName) { + var _this2 = this; + + var listenerFunctions = listenerName.split(' '); + + var _loop2 = function _loop2(i) { + var listenerSplit = listenerFunctions[i].split('.'); + if (listenerSplit.length === 0) return { + v: void 0 + }; + var functionName = listenerSplit[0]; + var CMIElement = null; + + if (listenerSplit.length > 1) { + CMIElement = listenerName.replace(functionName + '.', ''); + } + + _this2.listenerArray = _this2.listenerArray.filter(function (obj) { + return obj.functionName !== functionName && obj.CMIElement !== CMIElement; + }); + }; + + for (var i = 0; i < listenerFunctions.length; i++) { + var _ret2 = _loop2(i); + + if (_typeof(_ret2) === "object") return _ret2.v; + } + } + /** + * Processes any 'on' listeners that have been created + * + * @param {string} functionName + * @param {string} CMIElement + * @param {*} value + */ + + }, { + key: "processListeners", + value: function processListeners(functionName, CMIElement, value) { + this.apiLog(functionName, CMIElement, value); + + for (var i = 0; i < this.listenerArray.length; i++) { + var listener = this.listenerArray[i]; + var functionsMatch = listener.functionName === functionName; + var listenerHasCMIElement = !!listener.CMIElement; + var CMIElementsMatch = false; + + if (CMIElement && listener.CMIElement && listener.CMIElement.substring(listener.CMIElement.length - 1) === '*') { + CMIElementsMatch = CMIElement.indexOf(listener.CMIElement.substring(0, listener.CMIElement.length - 1)) === 0; + } else { + CMIElementsMatch = listener.CMIElement === CMIElement; + } + + if (functionsMatch && (!listenerHasCMIElement || CMIElementsMatch)) { + listener.callback(CMIElement, value); + } + } + } + /** + * Throws a SCORM error + * + * @param {number} errorNumber + * @param {string} message + */ + + }, { + key: "throwSCORMError", + value: function throwSCORMError(errorNumber, message) { + if (!message) { + message = this.getLmsErrorMessageDetails(errorNumber); + } + + this.apiLog('throwSCORMError', null, errorNumber + ': ' + message, global_constants.LOG_LEVEL_ERROR); + this.lastErrorCode = String(errorNumber); + } + /** + * Clears the last SCORM error code on success. + * + * @param {string} success + */ + + }, { + key: "clearSCORMError", + value: function clearSCORMError(success) { + if (success !== undefined && success !== global_constants.SCORM_FALSE) { + this.lastErrorCode = 0; + } + } + /** + * Attempts to store the data to the LMS, logs data if no LMS configured + * APIs that inherit BaseAPI should override this function + * + * @param {boolean} _calculateTotalTime + * @return {string} + * @abstract + */ + + }, { + key: "storeData", + value: function storeData(_calculateTotalTime) { + throw new Error('The storeData method has not been implemented'); + } + /** + * Load the CMI from a flattened JSON object + * @param {object} json + * @param {string} CMIElement + */ + + }, { + key: "loadFromFlattenedJSON", + value: function loadFromFlattenedJSON(json, CMIElement) { + var _this3 = this; + + if (!this.isNotInitialized()) { + console.error('loadFromFlattenedJSON can only be called before the call to lmsInitialize.'); + return; + } + /** + * Test match pattern. + * + * @param {string} a + * @param {string} c + * @param {RegExp} a_pattern + * @return {number} + */ + + + function testPattern(a, c, a_pattern) { + var a_match = a.match(a_pattern); + var c_match; + + if (a_match !== null && (c_match = c.match(a_pattern)) !== null) { + var a_num = Number(a_match[2]); + var c_num = Number(c_match[2]); + + if (a_num === c_num) { + if (a_match[3] === 'id') { + return -1; + } else if (a_match[3] === 'type') { + if (c_match[3] === 'id') { + return 1; + } else { + return -1; + } + } else { + return 1; + } + } + + return a_num - c_num; + } + + return null; + } + + var int_pattern = /^(cmi\.interactions\.)(\d+)\.(.*)$/; + var obj_pattern = /^(cmi\.objectives\.)(\d+)\.(.*)$/; + var result = Object.keys(json).map(function (key) { + return [String(key), json[key]]; + }); // CMI interactions need to have id and type loaded before any other fields + + result.sort(function (_ref, _ref2) { + var _ref3 = _slicedToArray(_ref, 2), + a = _ref3[0], + b = _ref3[1]; + + var _ref4 = _slicedToArray(_ref2, 2), + c = _ref4[0], + d = _ref4[1]; + + var test; + + if ((test = testPattern(a, c, int_pattern)) !== null) { + return test; + } + + if ((test = testPattern(a, c, obj_pattern)) !== null) { + return test; + } + + if (a < c) { + return -1; + } + + if (a > c) { + return 1; + } + + return 0; + }); + var obj; + result.forEach(function (element) { + obj = {}; + obj[element[0]] = element[1]; + + _this3.loadFromJSON((0, _utilities.unflatten)(obj), CMIElement); + }); + } + /** + * Loads CMI data from a JSON object. + * + * @param {object} json + * @param {string} CMIElement + */ + + }, { + key: "loadFromJSON", + value: function loadFromJSON(json, CMIElement) { + if (!this.isNotInitialized()) { + console.error('loadFromJSON can only be called before the call to lmsInitialize.'); + return; + } + + CMIElement = CMIElement !== undefined ? CMIElement : 'cmi'; + this.startingData = json; // could this be refactored down to flatten(json) then setCMIValue on each? + + for (var key in json) { + if ({}.hasOwnProperty.call(json, key) && json[key]) { + var currentCMIElement = (CMIElement ? CMIElement + '.' : '') + key; + var value = json[key]; + + if (value['childArray']) { + for (var i = 0; i < value['childArray'].length; i++) { + this.loadFromJSON(value['childArray'][i], currentCMIElement + '.' + i); + } + } else if (value.constructor === Object) { + this.loadFromJSON(value, currentCMIElement); + } else { + this.setCMIValue(currentCMIElement, value); + } + } + } + } + /** + * Render the CMI object to JSON for sending to an LMS. + * + * @return {string} + */ + + }, { + key: "renderCMIToJSONString", + value: function renderCMIToJSONString() { + var cmi = this.cmi; // Do we want/need to return fields that have no set value? + // return JSON.stringify({ cmi }, (k, v) => v === undefined ? null : v, 2); + + return JSON.stringify({ + cmi: cmi + }); + } + /** + * Returns a JS object representing the current cmi + * @return {object} + */ + + }, { + key: "renderCMIToJSONObject", + value: function renderCMIToJSONObject() { + // Do we want/need to return fields that have no set value? + // return JSON.stringify({ cmi }, (k, v) => v === undefined ? null : v, 2); + return JSON.parse(this.renderCMIToJSONString()); + } + /** + * Render the cmi object to the proper format for LMS commit + * APIs that inherit BaseAPI should override this function + * + * @param {boolean} _terminateCommit + * @return {*} + * @abstract + */ + + }, { + key: "renderCommitCMI", + value: function renderCommitCMI(_terminateCommit) { + throw new Error('The storeData method has not been implemented'); + } + /** + * Send the request to the LMS + * @param {string} url + * @param {object|Array} params + * @param {boolean} immediate + * @return {object} + */ + + }, { + key: "processHttpRequest", + value: function processHttpRequest(url, params) { + var immediate = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + var api = this; + + var process = function process(url, params, settings, error_codes) { + var genericError = { + 'result': global_constants.SCORM_FALSE, + 'errorCode': error_codes.GENERAL + }; + var result; + + if (!settings.sendBeaconCommit) { + var httpReq = new XMLHttpRequest(); + httpReq.open('POST', url, settings.asyncCommit); + + if (settings.asyncCommit) { + httpReq.onload = function (e) { + if (typeof settings.responseHandler === 'function') { + result = settings.responseHandler(httpReq); + } else { + result = JSON.parse(httpReq.responseText); + } + }; + } + + try { + if (params instanceof Array) { + httpReq.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded'); + httpReq.send(params.join('&')); + } else { + httpReq.setRequestHeader('Content-Type', settings.commitRequestDataType); + httpReq.send(JSON.stringify(params)); + } + + if (!settings.asyncCommit) { + if (typeof settings.responseHandler === 'function') { + result = settings.responseHandler(httpReq); + } else { + result = JSON.parse(httpReq.responseText); + } + } else { + result = {}; + result.result = global_constants.SCORM_TRUE; + result.errorCode = 0; + api.processListeners('CommitSuccess'); + return result; + } + } catch (e) { + console.error(e); + api.processListeners('CommitError'); + return genericError; + } + } else { + try { + var headers = { + type: settings.commitRequestDataType + }; + var blob; + + if (params instanceof Array) { + blob = new Blob([params.join('&')], headers); + } else { + blob = new Blob([JSON.stringify(params)], headers); + } + + result = {}; + + if (navigator.sendBeacon(url, blob)) { + result.result = global_constants.SCORM_TRUE; + result.errorCode = 0; + } else { + result.result = global_constants.SCORM_FALSE; + result.errorCode = 101; + } + } catch (e) { + console.error(e); + api.processListeners('CommitError'); + return genericError; + } + } + + if (typeof result === 'undefined') { + api.processListeners('CommitError'); + return genericError; + } + + if (result.result === true || result.result === global_constants.SCORM_TRUE) { + api.processListeners('CommitSuccess'); + } else { + api.processListeners('CommitError'); + } + + return result; + }; + + if (typeof _lodash["default"] !== 'undefined') { + var debounced = (0, _lodash["default"])(process, 500); + debounced(url, params, this.settings, this.error_codes); // if we're terminating, go ahead and commit immediately + + if (immediate) { + debounced.flush(); + } + + return { + result: global_constants.SCORM_TRUE, + errorCode: 0 + }; + } else { + return process(url, params, this.settings, this.error_codes); + } + } + /** + * Throws a SCORM error + * + * @param {number} when - the number of milliseconds to wait before committing + * @param {string} callback - the name of the commit event callback + */ + + }, { + key: "scheduleCommit", + value: function scheduleCommit(when, callback) { + _classPrivateFieldSet(this, _timeout, new ScheduledCommit(this, when, callback)); + + this.apiLog('scheduleCommit', '', 'scheduled', global_constants.LOG_LEVEL_DEBUG); + } + /** + * Clears and cancels any currently scheduled commits + */ + + }, { + key: "clearScheduledCommit", + value: function clearScheduledCommit() { + if (_classPrivateFieldGet(this, _timeout)) { + _classPrivateFieldGet(this, _timeout).cancel(); + + _classPrivateFieldSet(this, _timeout, null); + + this.apiLog('clearScheduledCommit', '', 'cleared', global_constants.LOG_LEVEL_DEBUG); + } + } + }]); + + return BaseAPI; +}(); +/** + * Private class that wraps a timeout call to the commit() function + */ + + +exports["default"] = BaseAPI; + +var _API = new WeakMap(); + +var _cancelled = new WeakMap(); + +var _timeout2 = new WeakMap(); + +var _callback = new WeakMap(); + +var ScheduledCommit = /*#__PURE__*/function () { + /** + * Constructor for ScheduledCommit + * @param {BaseAPI} API + * @param {number} when + * @param {string} callback + */ + function ScheduledCommit(API, when, callback) { + _classCallCheck(this, ScheduledCommit); + + _API.set(this, { + writable: true, + value: void 0 + }); + + _cancelled.set(this, { + writable: true, + value: false + }); + + _timeout2.set(this, { + writable: true, + value: void 0 + }); + + _callback.set(this, { + writable: true, + value: void 0 + }); + + _classPrivateFieldSet(this, _API, API); + + _classPrivateFieldSet(this, _timeout2, setTimeout(this.wrapper.bind(this), when)); + + _classPrivateFieldSet(this, _callback, callback); + } + /** + * Cancel any currently scheduled commit + */ + + + _createClass(ScheduledCommit, [{ + key: "cancel", + value: function cancel() { + _classPrivateFieldSet(this, _cancelled, true); + + if (_classPrivateFieldGet(this, _timeout2)) { + clearTimeout(_classPrivateFieldGet(this, _timeout2)); + } + } + /** + * Wrap the API commit call to check if the call has already been cancelled + */ + + }, { + key: "wrapper", + value: function wrapper() { + if (!_classPrivateFieldGet(this, _cancelled)) { + _classPrivateFieldGet(this, _API).commit(_classPrivateFieldGet(this, _callback)); + } + } + }]); + + return ScheduledCommit; +}(); + +},{"./cmi/common":6,"./constants/api_constants":8,"./constants/error_codes":9,"./exceptions":11,"./utilities":13,"lodash.debounce":1}],4:[function(require,module,exports){ +"use strict"; + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +var _BaseAPI2 = _interopRequireDefault(require("./BaseAPI")); + +var _scorm12_cmi = require("./cmi/scorm12_cmi"); + +var Utilities = _interopRequireWildcard(require("./utilities")); + +var _api_constants = _interopRequireDefault(require("./constants/api_constants")); + +var _error_codes = _interopRequireDefault(require("./constants/error_codes")); + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +var scorm12_constants = _api_constants["default"].scorm12; +var global_constants = _api_constants["default"].global; +var scorm12_error_codes = _error_codes["default"].scorm12; +/** + * API class for SCORM 1.2 + */ + +var Scorm12API = /*#__PURE__*/function (_BaseAPI) { + _inherits(Scorm12API, _BaseAPI); + + var _super = _createSuper(Scorm12API); + + /** + * Constructor for SCORM 1.2 API + * @param {object} settings + */ + function Scorm12API(settings) { + var _this; + + _classCallCheck(this, Scorm12API); + + var finalSettings = _objectSpread(_objectSpread({}, { + mastery_override: false + }), settings); + + _this = _super.call(this, scorm12_error_codes, finalSettings); + _this.cmi = new _scorm12_cmi.CMI(); + _this.nav = new _scorm12_cmi.NAV(); // Rename functions to match 1.2 Spec and expose to modules + + _this.LMSInitialize = _this.lmsInitialize; + _this.LMSFinish = _this.lmsFinish; + _this.LMSGetValue = _this.lmsGetValue; + _this.LMSSetValue = _this.lmsSetValue; + _this.LMSCommit = _this.lmsCommit; + _this.LMSGetLastError = _this.lmsGetLastError; + _this.LMSGetErrorString = _this.lmsGetErrorString; + _this.LMSGetDiagnostic = _this.lmsGetDiagnostic; + return _this; + } + /** + * lmsInitialize function from SCORM 1.2 Spec + * + * @return {string} bool + */ + + + _createClass(Scorm12API, [{ + key: "lmsInitialize", + value: function lmsInitialize() { + this.cmi.initialize(); + return this.initialize('LMSInitialize', 'LMS was already initialized!', 'LMS is already finished!'); + } + /** + * LMSFinish function from SCORM 1.2 Spec + * + * @return {string} bool + */ + + }, { + key: "lmsFinish", + value: function lmsFinish() { + var result = this.terminate('LMSFinish', true); + + if (result === global_constants.SCORM_TRUE) { + if (this.nav.event !== '') { + if (this.nav.event === 'continue') { + this.processListeners('SequenceNext'); + } else { + this.processListeners('SequencePrevious'); + } + } else if (this.settings.autoProgress) { + this.processListeners('SequenceNext'); + } + } + + return result; + } + /** + * LMSGetValue function from SCORM 1.2 Spec + * + * @param {string} CMIElement + * @return {string} + */ + + }, { + key: "lmsGetValue", + value: function lmsGetValue(CMIElement) { + return this.getValue('LMSGetValue', false, CMIElement); + } + /** + * LMSSetValue function from SCORM 1.2 Spec + * + * @param {string} CMIElement + * @param {*} value + * @return {string} + */ + + }, { + key: "lmsSetValue", + value: function lmsSetValue(CMIElement, value) { + return this.setValue('LMSSetValue', 'LMSCommit', false, CMIElement, value); + } + /** + * LMSCommit function from SCORM 1.2 Spec + * + * @return {string} bool + */ + + }, { + key: "lmsCommit", + value: function lmsCommit() { + return this.commit('LMSCommit', false); + } + /** + * LMSGetLastError function from SCORM 1.2 Spec + * + * @return {string} + */ + + }, { + key: "lmsGetLastError", + value: function lmsGetLastError() { + return this.getLastError('LMSGetLastError'); + } + /** + * LMSGetErrorString function from SCORM 1.2 Spec + * + * @param {string} CMIErrorCode + * @return {string} + */ + + }, { + key: "lmsGetErrorString", + value: function lmsGetErrorString(CMIErrorCode) { + return this.getErrorString('LMSGetErrorString', CMIErrorCode); + } + /** + * LMSGetDiagnostic function from SCORM 1.2 Spec + * + * @param {string} CMIErrorCode + * @return {string} + */ + + }, { + key: "lmsGetDiagnostic", + value: function lmsGetDiagnostic(CMIErrorCode) { + return this.getDiagnostic('LMSGetDiagnostic', CMIErrorCode); + } + /** + * Sets a value on the CMI Object + * + * @param {string} CMIElement + * @param {*} value + * @return {string} + */ + + }, { + key: "setCMIValue", + value: function setCMIValue(CMIElement, value) { + return this._commonSetCMIValue('LMSSetValue', false, CMIElement, value); + } + /** + * Gets a value from the CMI Object + * + * @param {string} CMIElement + * @return {*} + */ + + }, { + key: "getCMIValue", + value: function getCMIValue(CMIElement) { + return this._commonGetCMIValue('getCMIValue', false, CMIElement); + } + /** + * Gets or builds a new child element to add to the array. + * + * @param {string} CMIElement + * @param {*} value + * @param {boolean} foundFirstIndex + * @return {object} + */ + + }, { + key: "getChildElement", + value: function getChildElement(CMIElement, value, foundFirstIndex) { + var newChild; + + if (this.stringMatches(CMIElement, 'cmi\\.objectives\\.\\d+')) { + newChild = new _scorm12_cmi.CMIObjectivesObject(); + } else if (foundFirstIndex && this.stringMatches(CMIElement, 'cmi\\.interactions\\.\\d+\\.correct_responses\\.\\d+')) { + newChild = new _scorm12_cmi.CMIInteractionsCorrectResponsesObject(); + } else if (foundFirstIndex && this.stringMatches(CMIElement, 'cmi\\.interactions\\.\\d+\\.objectives\\.\\d+')) { + newChild = new _scorm12_cmi.CMIInteractionsObjectivesObject(); + } else if (!foundFirstIndex && this.stringMatches(CMIElement, 'cmi\\.interactions\\.\\d+')) { + newChild = new _scorm12_cmi.CMIInteractionsObject(); + } + + return newChild; + } + /** + * Validates Correct Response values + * + * @param {string} CMIElement + * @param {*} value + * @return {boolean} + */ + + }, { + key: "validateCorrectResponse", + value: function validateCorrectResponse(CMIElement, value) { + return true; + } + /** + * Returns the message that corresponds to errorNumber. + * + * @param {*} errorNumber + * @param {boolean} detail + * @return {string} + */ + + }, { + key: "getLmsErrorMessageDetails", + value: function getLmsErrorMessageDetails(errorNumber, detail) { + var basicMessage = 'No Error'; + var detailMessage = 'No Error'; // Set error number to string since inconsistent from modules if string or number + + errorNumber = String(errorNumber); + + if (scorm12_constants.error_descriptions[errorNumber]) { + basicMessage = scorm12_constants.error_descriptions[errorNumber].basicMessage; + detailMessage = scorm12_constants.error_descriptions[errorNumber].detailMessage; + } + + return detail ? detailMessage : basicMessage; + } + /** + * Replace the whole API with another + * + * @param {Scorm12API} newAPI + */ + + }, { + key: "replaceWithAnotherScormAPI", + value: function replaceWithAnotherScormAPI(newAPI) { + // Data Model + this.cmi = newAPI.cmi; + } + /** + * Render the cmi object to the proper format for LMS commit + * + * @param {boolean} terminateCommit + * @return {object|Array} + */ + + }, { + key: "renderCommitCMI", + value: function renderCommitCMI(terminateCommit) { + var cmiExport = this.renderCMIToJSONObject(); + + if (terminateCommit) { + cmiExport.cmi.core.total_time = this.cmi.getCurrentTotalTime(); + } + + var result = []; + var flattened = Utilities.flatten(cmiExport); + + switch (this.settings.dataCommitFormat) { + case 'flattened': + return Utilities.flatten(cmiExport); + + case 'params': + for (var item in flattened) { + if ({}.hasOwnProperty.call(flattened, item)) { + result.push("".concat(item, "=").concat(flattened[item])); + } + } + + return result; + + case 'json': + default: + return cmiExport; + } + } + /** + * Attempts to store the data to the LMS + * + * @param {boolean} terminateCommit + * @return {string} + */ + + }, { + key: "storeData", + value: function storeData(terminateCommit) { + if (terminateCommit) { + var originalStatus = this.cmi.core.lesson_status; + + if (originalStatus === 'not attempted') { + this.cmi.core.lesson_status = 'completed'; + } + + if (this.cmi.core.lesson_mode === 'normal') { + if (this.cmi.core.credit === 'credit') { + if (this.settings.mastery_override && this.cmi.student_data.mastery_score !== '' && this.cmi.core.score.raw !== '') { + if (parseFloat(this.cmi.core.score.raw) >= parseFloat(this.cmi.student_data.mastery_score)) { + this.cmi.core.lesson_status = 'passed'; + } else { + this.cmi.core.lesson_status = 'failed'; + } + } + } + } else if (this.cmi.core.lesson_mode === 'browse') { + var _this$startingData, _this$startingData$cm, _this$startingData$cm2; + + if ((((_this$startingData = this.startingData) === null || _this$startingData === void 0 ? void 0 : (_this$startingData$cm = _this$startingData.cmi) === null || _this$startingData$cm === void 0 ? void 0 : (_this$startingData$cm2 = _this$startingData$cm.core) === null || _this$startingData$cm2 === void 0 ? void 0 : _this$startingData$cm2.lesson_status) || '') === '' && originalStatus === 'not attempted') { + this.cmi.core.lesson_status = 'browsed'; + } + } + } + + var commitObject = this.renderCommitCMI(terminateCommit || this.settings.alwaysSendTotalTime); + + if (this.apiLogLevel === global_constants.LOG_LEVEL_DEBUG) { + console.debug('Commit (terminated: ' + (terminateCommit ? 'yes' : 'no') + '): '); + console.debug(commitObject); + } + + if (this.settings.lmsCommitUrl) { + return this.processHttpRequest(this.settings.lmsCommitUrl, commitObject, terminateCommit); + } else { + return global_constants.SCORM_TRUE; + } + } + }]); + + return Scorm12API; +}(_BaseAPI2["default"]); + +exports["default"] = Scorm12API; + +},{"./BaseAPI":3,"./cmi/scorm12_cmi":7,"./constants/api_constants":8,"./constants/error_codes":9,"./utilities":13}],5:[function(require,module,exports){ +"use strict"; + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.CMIEvaluationCommentsObject = exports.CMIAttemptRecordsObject = exports.CMIAttemptRecords = exports.CMITriesObject = exports.CMITries = exports.CMIPathsObject = exports.CMIPaths = exports.CMIStudentDemographics = exports.CMI = void 0; + +var Scorm12CMI = _interopRequireWildcard(require("./scorm12_cmi")); + +var _common = require("./common"); + +var _api_constants = _interopRequireDefault(require("../constants/api_constants")); + +var _regex = _interopRequireDefault(require("../constants/regex")); + +var _error_codes = _interopRequireDefault(require("../constants/error_codes")); + +var _exceptions = require("../exceptions"); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; } + +function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } } + +function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); } + +function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); } + +function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); } + +function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +var aicc_constants = _api_constants["default"].aicc; +var aicc_regex = _regex["default"].aicc; +var aicc_error_codes = _error_codes["default"].scorm12; +/** + * Helper method for throwing Read Only error + */ + +function throwReadOnlyError() { + throw new _exceptions.AICCValidationError(aicc_error_codes.READ_ONLY_ELEMENT); +} +/** + * Helper method, no reason to have to pass the same error codes every time + * @param {*} value + * @param {string} regexPattern + * @param {boolean} allowEmptyString + * @return {boolean} + */ + + +function checkAICCValidFormat(value, regexPattern, allowEmptyString) { + return (0, _common.checkValidFormat)(value, regexPattern, aicc_error_codes.TYPE_MISMATCH, _exceptions.AICCValidationError, allowEmptyString); +} +/** + * CMI Class for AICC + */ + + +var CMI = /*#__PURE__*/function (_Scorm12CMI$CMI) { + _inherits(CMI, _Scorm12CMI$CMI); + + var _super = _createSuper(CMI); + + /** + * Constructor for AICC CMI object + * @param {boolean} initialized + */ + function CMI(initialized) { + var _this; + + _classCallCheck(this, CMI); + + _this = _super.call(this, aicc_constants.cmi_children); + if (initialized) _this.initialize(); + _this.student_preference = new AICCStudentPreferences(); + _this.student_data = new AICCCMIStudentData(); + _this.student_demographics = new CMIStudentDemographics(); + _this.evaluation = new CMIEvaluation(); + _this.paths = new CMIPaths(); + return _this; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(CMI, [{ + key: "initialize", + value: function initialize() { + var _this$student_prefere, _this$student_data, _this$student_demogra, _this$evaluation, _this$paths; + + _get(_getPrototypeOf(CMI.prototype), "initialize", this).call(this); + + (_this$student_prefere = this.student_preference) === null || _this$student_prefere === void 0 ? void 0 : _this$student_prefere.initialize(); + (_this$student_data = this.student_data) === null || _this$student_data === void 0 ? void 0 : _this$student_data.initialize(); + (_this$student_demogra = this.student_demographics) === null || _this$student_demogra === void 0 ? void 0 : _this$student_demogra.initialize(); + (_this$evaluation = this.evaluation) === null || _this$evaluation === void 0 ? void 0 : _this$evaluation.initialize(); + (_this$paths = this.paths) === null || _this$paths === void 0 ? void 0 : _this$paths.initialize(); + } + /** + * toJSON for cmi + * + * @return { + * { + * suspend_data: string, + * launch_data: string, + * comments: string, + * comments_from_lms: string, + * core: CMICore, + * objectives: CMIObjectives, + * student_data: CMIStudentData, + * student_preference: CMIStudentPreference, + * interactions: CMIInteractions, + * paths: CMIPaths + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'suspend_data': this.suspend_data, + 'launch_data': this.launch_data, + 'comments': this.comments, + 'comments_from_lms': this.comments_from_lms, + 'core': this.core, + 'objectives': this.objectives, + 'student_data': this.student_data, + 'student_preference': this.student_preference, + 'student_demographics': this.student_demographics, + 'interactions': this.interactions, + 'evaluation': this.evaluation, + 'paths': this.paths + }; + delete this.jsonString; + return result; + } + }]); + + return CMI; +}(Scorm12CMI.CMI); +/** + * AICC Evaluation object + */ + + +exports.CMI = CMI; + +var CMIEvaluation = /*#__PURE__*/function (_BaseCMI) { + _inherits(CMIEvaluation, _BaseCMI); + + var _super2 = _createSuper(CMIEvaluation); + + /** + * Constructor for AICC Evaluation object + */ + function CMIEvaluation() { + var _this2; + + _classCallCheck(this, CMIEvaluation); + + _this2 = _super2.call(this); + _this2.comments = new CMIEvaluationComments(); + return _this2; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(CMIEvaluation, [{ + key: "initialize", + value: function initialize() { + var _this$comments; + + _get(_getPrototypeOf(CMIEvaluation.prototype), "initialize", this).call(this); + + (_this$comments = this.comments) === null || _this$comments === void 0 ? void 0 : _this$comments.initialize(); + } + /** + * toJSON for cmi.evaluation object + * @return {{comments: CMIEvaluationComments}} + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'comments': this.comments + }; + delete this.jsonString; + return result; + } + }]); + + return CMIEvaluation; +}(_common.BaseCMI); +/** + * Class representing AICC's cmi.evaluation.comments object + */ + + +var CMIEvaluationComments = /*#__PURE__*/function (_CMIArray) { + _inherits(CMIEvaluationComments, _CMIArray); + + var _super3 = _createSuper(CMIEvaluationComments); + + /** + * Constructor for AICC Evaluation Comments object + */ + function CMIEvaluationComments() { + _classCallCheck(this, CMIEvaluationComments); + + return _super3.call(this, { + children: aicc_constants.comments_children, + errorCode: aicc_error_codes.INVALID_SET_VALUE, + errorClass: _exceptions.AICCValidationError + }); + } + + return CMIEvaluationComments; +}(_common.CMIArray); +/** + * StudentPreferences class for AICC + */ + + +var _lesson_type = new WeakMap(); + +var _text_color = new WeakMap(); + +var _text_location = new WeakMap(); + +var _text_size = new WeakMap(); + +var _video = new WeakMap(); + +var AICCStudentPreferences = /*#__PURE__*/function (_Scorm12CMI$CMIStuden) { + _inherits(AICCStudentPreferences, _Scorm12CMI$CMIStuden); + + var _super4 = _createSuper(AICCStudentPreferences); + + /** + * Constructor for AICC Student Preferences object + */ + function AICCStudentPreferences() { + var _this3; + + _classCallCheck(this, AICCStudentPreferences); + + _this3 = _super4.call(this, aicc_constants.student_preference_children); + + _lesson_type.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _text_color.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _text_location.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _text_size.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _video.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _this3.windows = new _common.CMIArray({ + errorCode: aicc_error_codes.INVALID_SET_VALUE, + errorClass: _exceptions.AICCValidationError, + children: '' + }); + return _this3; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(AICCStudentPreferences, [{ + key: "initialize", + value: function initialize() { + var _this$windows; + + _get(_getPrototypeOf(AICCStudentPreferences.prototype), "initialize", this).call(this); + + (_this$windows = this.windows) === null || _this$windows === void 0 ? void 0 : _this$windows.initialize(); + } + }, { + key: "lesson_type", + get: + /** + * Getter for #lesson_type + * @return {string} + */ + function get() { + return _classPrivateFieldGet(this, _lesson_type); + } + /** + * Setter for #lesson_type + * @param {string} lesson_type + */ + , + set: function set(lesson_type) { + if (checkAICCValidFormat(lesson_type, aicc_regex.CMIString256)) { + _classPrivateFieldSet(this, _lesson_type, lesson_type); + } + } + /** + * Getter for #text_color + * @return {string} + */ + + }, { + key: "text_color", + get: function get() { + return _classPrivateFieldGet(this, _text_color); + } + /** + * Setter for #text_color + * @param {string} text_color + */ + , + set: function set(text_color) { + if (checkAICCValidFormat(text_color, aicc_regex.CMIString256)) { + _classPrivateFieldSet(this, _text_color, text_color); + } + } + /** + * Getter for #text_location + * @return {string} + */ + + }, { + key: "text_location", + get: function get() { + return _classPrivateFieldGet(this, _text_location); + } + /** + * Setter for #text_location + * @param {string} text_location + */ + , + set: function set(text_location) { + if (checkAICCValidFormat(text_location, aicc_regex.CMIString256)) { + _classPrivateFieldSet(this, _text_location, text_location); + } + } + /** + * Getter for #text_size + * @return {string} + */ + + }, { + key: "text_size", + get: function get() { + return _classPrivateFieldGet(this, _text_size); + } + /** + * Setter for #text_size + * @param {string} text_size + */ + , + set: function set(text_size) { + if (checkAICCValidFormat(text_size, aicc_regex.CMIString256)) { + _classPrivateFieldSet(this, _text_size, text_size); + } + } + /** + * Getter for #video + * @return {string} + */ + + }, { + key: "video", + get: function get() { + return _classPrivateFieldGet(this, _video); + } + /** + * Setter for #video + * @param {string} video + */ + , + set: function set(video) { + if (checkAICCValidFormat(video, aicc_regex.CMIString256)) { + _classPrivateFieldSet(this, _video, video); + } + } + /** + * toJSON for cmi.student_preference + * + * @return { + * { + * audio: string, + * language: string, + * speed: string, + * text: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'audio': this.audio, + 'language': this.language, + 'lesson_type': this.lesson_type, + 'speed': this.speed, + 'text': this.text, + 'text_color': this.text_color, + 'text_location': this.text_location, + 'text_size': this.text_size, + 'video': this.video, + 'windows': this.windows + }; + delete this.jsonString; + return result; + } + }]); + + return AICCStudentPreferences; +}(Scorm12CMI.CMIStudentPreference); +/** + * StudentData class for AICC + */ + + +var _tries_during_lesson = new WeakMap(); + +var AICCCMIStudentData = /*#__PURE__*/function (_Scorm12CMI$CMIStuden2) { + _inherits(AICCCMIStudentData, _Scorm12CMI$CMIStuden2); + + var _super5 = _createSuper(AICCCMIStudentData); + + /** + * Constructor for AICC StudentData object + */ + function AICCCMIStudentData() { + var _this4; + + _classCallCheck(this, AICCCMIStudentData); + + _this4 = _super5.call(this, aicc_constants.student_data_children); + + _tries_during_lesson.set(_assertThisInitialized(_this4), { + writable: true, + value: '' + }); + + _this4.tries = new CMITries(); + return _this4; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(AICCCMIStudentData, [{ + key: "initialize", + value: function initialize() { + var _this$tries; + + _get(_getPrototypeOf(AICCCMIStudentData.prototype), "initialize", this).call(this); + + (_this$tries = this.tries) === null || _this$tries === void 0 ? void 0 : _this$tries.initialize(); + } + }, { + key: "tries_during_lesson", + get: + /** + * Getter for tries_during_lesson + * @return {string} + */ + function get() { + return _classPrivateFieldGet(this, _tries_during_lesson); + } + /** + * Setter for #tries_during_lesson. Sets an error if trying to set after + * initialization. + * @param {string} tries_during_lesson + */ + , + set: function set(tries_during_lesson) { + !this.initialized ? _classPrivateFieldSet(this, _tries_during_lesson, tries_during_lesson) : throwReadOnlyError(); + } + /** + * toJSON for cmi.student_data object + * @return { + * { + * mastery_score: string, + * max_time_allowed: string, + * time_limit_action: string, + * tries: CMITries + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'mastery_score': this.mastery_score, + 'max_time_allowed': this.max_time_allowed, + 'time_limit_action': this.time_limit_action, + 'tries': this.tries + }; + delete this.jsonString; + return result; + } + }]); + + return AICCCMIStudentData; +}(Scorm12CMI.CMIStudentData); +/** + * Class representing the AICC cmi.student_demographics object + */ + + +var _children = new WeakMap(); + +var _city = new WeakMap(); + +var _class = new WeakMap(); + +var _company = new WeakMap(); + +var _country = new WeakMap(); + +var _experience = new WeakMap(); + +var _familiar_name = new WeakMap(); + +var _instructor_name = new WeakMap(); + +var _title = new WeakMap(); + +var _native_language = new WeakMap(); + +var _state = new WeakMap(); + +var _street_address = new WeakMap(); + +var _telephone = new WeakMap(); + +var _years_experience = new WeakMap(); + +var CMIStudentDemographics = /*#__PURE__*/function (_BaseCMI2) { + _inherits(CMIStudentDemographics, _BaseCMI2); + + var _super6 = _createSuper(CMIStudentDemographics); + + /** + * Constructor for AICC StudentDemographics object + */ + function CMIStudentDemographics() { + var _this5; + + _classCallCheck(this, CMIStudentDemographics); + + _this5 = _super6.call(this); + + _children.set(_assertThisInitialized(_this5), { + writable: true, + value: aicc_constants.student_demographics_children + }); + + _city.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _class.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _company.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _country.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _experience.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _familiar_name.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _instructor_name.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _title.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _native_language.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _state.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _street_address.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _telephone.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _years_experience.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + return _this5; + } + + _createClass(CMIStudentDemographics, [{ + key: "_children", + get: + /** + * Getter for _children + * @return {string} + */ + function get() { + return _classPrivateFieldGet(this, _children); + } + /** + * Getter for city + * @return {string} + */ + + }, { + key: "city", + get: function get() { + return _classPrivateFieldGet(this, _city); + } + /** + * Setter for #city. Sets an error if trying to set after + * initialization. + * @param {string} city + */ + , + set: function set(city) { + !this.initialized ? _classPrivateFieldSet(this, _city, city) : throwReadOnlyError(); + } + /** + * Getter for class + * @return {string} + */ + + }, { + key: "class", + get: function get() { + return _classPrivateFieldGet(this, _class); + } + /** + * Setter for #class. Sets an error if trying to set after + * initialization. + * @param {string} clazz + */ + , + set: function set(clazz) { + !this.initialized ? _classPrivateFieldSet(this, _class, clazz) : throwReadOnlyError(); + } + /** + * Getter for company + * @return {string} + */ + + }, { + key: "company", + get: function get() { + return _classPrivateFieldGet(this, _company); + } + /** + * Setter for #company. Sets an error if trying to set after + * initialization. + * @param {string} company + */ + , + set: function set(company) { + !this.initialized ? _classPrivateFieldSet(this, _company, company) : throwReadOnlyError(); + } + /** + * Getter for country + * @return {string} + */ + + }, { + key: "country", + get: function get() { + return _classPrivateFieldGet(this, _country); + } + /** + * Setter for #country. Sets an error if trying to set after + * initialization. + * @param {string} country + */ + , + set: function set(country) { + !this.initialized ? _classPrivateFieldSet(this, _country, country) : throwReadOnlyError(); + } + /** + * Getter for experience + * @return {string} + */ + + }, { + key: "experience", + get: function get() { + return _classPrivateFieldGet(this, _experience); + } + /** + * Setter for #experience. Sets an error if trying to set after + * initialization. + * @param {string} experience + */ + , + set: function set(experience) { + !this.initialized ? _classPrivateFieldSet(this, _experience, experience) : throwReadOnlyError(); + } + /** + * Getter for familiar_name + * @return {string} + */ + + }, { + key: "familiar_name", + get: function get() { + return _classPrivateFieldGet(this, _familiar_name); + } + /** + * Setter for #familiar_name. Sets an error if trying to set after + * initialization. + * @param {string} familiar_name + */ + , + set: function set(familiar_name) { + !this.initialized ? _classPrivateFieldSet(this, _familiar_name, familiar_name) : throwReadOnlyError(); + } + /** + * Getter for instructor_name + * @return {string} + */ + + }, { + key: "instructor_name", + get: function get() { + return _classPrivateFieldGet(this, _instructor_name); + } + /** + * Setter for #instructor_name. Sets an error if trying to set after + * initialization. + * @param {string} instructor_name + */ + , + set: function set(instructor_name) { + !this.initialized ? _classPrivateFieldSet(this, _instructor_name, instructor_name) : throwReadOnlyError(); + } + /** + * Getter for title + * @return {string} + */ + + }, { + key: "title", + get: function get() { + return _classPrivateFieldGet(this, _title); + } + /** + * Setter for #title. Sets an error if trying to set after + * initialization. + * @param {string} title + */ + , + set: function set(title) { + !this.initialized ? _classPrivateFieldSet(this, _title, title) : throwReadOnlyError(); + } + /** + * Getter for native_language + * @return {string} + */ + + }, { + key: "native_language", + get: function get() { + return _classPrivateFieldGet(this, _native_language); + } + /** + * Setter for #native_language. Sets an error if trying to set after + * initialization. + * @param {string} native_language + */ + , + set: function set(native_language) { + !this.initialized ? _classPrivateFieldSet(this, _native_language, native_language) : throwReadOnlyError(); + } + /** + * Getter for state + * @return {string} + */ + + }, { + key: "state", + get: function get() { + return _classPrivateFieldGet(this, _state); + } + /** + * Setter for #state. Sets an error if trying to set after + * initialization. + * @param {string} state + */ + , + set: function set(state) { + !this.initialized ? _classPrivateFieldSet(this, _state, state) : throwReadOnlyError(); + } + /** + * Getter for street_address + * @return {string} + */ + + }, { + key: "street_address", + get: function get() { + return _classPrivateFieldGet(this, _street_address); + } + /** + * Setter for #street_address. Sets an error if trying to set after + * initialization. + * @param {string} street_address + */ + , + set: function set(street_address) { + !this.initialized ? _classPrivateFieldSet(this, _street_address, street_address) : throwReadOnlyError(); + } + /** + * Getter for telephone + * @return {string} + */ + + }, { + key: "telephone", + get: function get() { + return _classPrivateFieldGet(this, _telephone); + } + /** + * Setter for #telephone. Sets an error if trying to set after + * initialization. + * @param {string} telephone + */ + , + set: function set(telephone) { + !this.initialized ? _classPrivateFieldSet(this, _telephone, telephone) : throwReadOnlyError(); + } + /** + * Getter for years_experience + * @return {string} + */ + + }, { + key: "years_experience", + get: function get() { + return _classPrivateFieldGet(this, _years_experience); + } + /** + * Setter for #years_experience. Sets an error if trying to set after + * initialization. + * @param {string} years_experience + */ + , + set: function set(years_experience) { + !this.initialized ? _classPrivateFieldSet(this, _years_experience, years_experience) : throwReadOnlyError(); + } + /** + * toJSON for cmi.student_demographics object + * @return { + * { + * city: string, + * class: string, + * company: string, + * country: string, + * experience: string, + * familiar_name: string, + * instructor_name: string, + * title: string, + * native_language: string, + * state: string, + * street_address: string, + * telephone: string, + * years_experience: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'city': this.city, + 'class': this["class"], + 'company': this.company, + 'country': this.country, + 'experience': this.experience, + 'familiar_name': this.familiar_name, + 'instructor_name': this.instructor_name, + 'title': this.title, + 'native_language': this.native_language, + 'state': this.state, + 'street_address': this.street_address, + 'telephone': this.telephone, + 'years_experience': this.years_experience + }; + delete this.jsonString; + return result; + } + }]); + + return CMIStudentDemographics; +}(_common.BaseCMI); +/** + * Class representing the AICC cmi.paths object + */ + + +exports.CMIStudentDemographics = CMIStudentDemographics; + +var CMIPaths = /*#__PURE__*/function (_CMIArray2) { + _inherits(CMIPaths, _CMIArray2); + + var _super7 = _createSuper(CMIPaths); + + /** + * Constructor for inline Paths Array class + */ + function CMIPaths() { + _classCallCheck(this, CMIPaths); + + return _super7.call(this, { + children: aicc_constants.paths_children + }); + } + + return CMIPaths; +}(_common.CMIArray); +/** + * Class for AICC Paths + */ + + +exports.CMIPaths = CMIPaths; + +var _location_id = new WeakMap(); + +var _date = new WeakMap(); + +var _time = new WeakMap(); + +var _status = new WeakMap(); + +var _why_left = new WeakMap(); + +var _time_in_element = new WeakMap(); + +var CMIPathsObject = /*#__PURE__*/function (_BaseCMI3) { + _inherits(CMIPathsObject, _BaseCMI3); + + var _super8 = _createSuper(CMIPathsObject); + + /** + * Constructor for AICC Paths objects + */ + function CMIPathsObject() { + var _this6; + + _classCallCheck(this, CMIPathsObject); + + _this6 = _super8.call(this); + + _location_id.set(_assertThisInitialized(_this6), { + writable: true, + value: '' + }); + + _date.set(_assertThisInitialized(_this6), { + writable: true, + value: '' + }); + + _time.set(_assertThisInitialized(_this6), { + writable: true, + value: '' + }); + + _status.set(_assertThisInitialized(_this6), { + writable: true, + value: '' + }); + + _why_left.set(_assertThisInitialized(_this6), { + writable: true, + value: '' + }); + + _time_in_element.set(_assertThisInitialized(_this6), { + writable: true, + value: '' + }); + + return _this6; + } + + _createClass(CMIPathsObject, [{ + key: "location_id", + get: + /** + * Getter for #location_id + * @return {string} + */ + function get() { + return _classPrivateFieldGet(this, _location_id); + } + /** + * Setter for #location_id + * @param {string} location_id + */ + , + set: function set(location_id) { + if (checkAICCValidFormat(location_id, aicc_regex.CMIString256)) { + _classPrivateFieldSet(this, _location_id, location_id); + } + } + /** + * Getter for #date + * @return {string} + */ + + }, { + key: "date", + get: function get() { + return _classPrivateFieldGet(this, _date); + } + /** + * Setter for #date + * @param {string} date + */ + , + set: function set(date) { + if (checkAICCValidFormat(date, aicc_regex.CMIString256)) { + _classPrivateFieldSet(this, _date, date); + } + } + /** + * Getter for #time + * @return {string} + */ + + }, { + key: "time", + get: function get() { + return _classPrivateFieldGet(this, _time); + } + /** + * Setter for #time + * @param {string} time + */ + , + set: function set(time) { + if (checkAICCValidFormat(time, aicc_regex.CMITime)) { + _classPrivateFieldSet(this, _time, time); + } + } + /** + * Getter for #status + * @return {string} + */ + + }, { + key: "status", + get: function get() { + return _classPrivateFieldGet(this, _status); + } + /** + * Setter for #status + * @param {string} status + */ + , + set: function set(status) { + if (checkAICCValidFormat(status, aicc_regex.CMIStatus2)) { + _classPrivateFieldSet(this, _status, status); + } + } + /** + * Getter for #why_left + * @return {string} + */ + + }, { + key: "why_left", + get: function get() { + return _classPrivateFieldGet(this, _why_left); + } + /** + * Setter for #why_left + * @param {string} why_left + */ + , + set: function set(why_left) { + if (checkAICCValidFormat(why_left, aicc_regex.CMIString256)) { + _classPrivateFieldSet(this, _why_left, why_left); + } + } + /** + * Getter for #time_in_element + * @return {string} + */ + + }, { + key: "time_in_element", + get: function get() { + return _classPrivateFieldGet(this, _time_in_element); + } + /** + * Setter for #time_in_element + * @param {string} time_in_element + */ + , + set: function set(time_in_element) { + if (checkAICCValidFormat(time_in_element, aicc_regex.CMITime)) { + _classPrivateFieldSet(this, _time_in_element, time_in_element); + } + } + /** + * toJSON for cmi.paths.n object + * @return { + * { + * location_id: string, + * date: string, + * time: string, + * status: string, + * why_left: string, + * time_in_element: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'location_id': this.location_id, + 'date': this.date, + 'time': this.time, + 'status': this.status, + 'why_left': this.why_left, + 'time_in_element': this.time_in_element + }; + delete this.jsonString; + return result; + } + }]); + + return CMIPathsObject; +}(_common.BaseCMI); +/** + * Class representing the AICC cmi.student_data.tries object + */ + + +exports.CMIPathsObject = CMIPathsObject; + +var CMITries = /*#__PURE__*/function (_CMIArray3) { + _inherits(CMITries, _CMIArray3); + + var _super9 = _createSuper(CMITries); + + /** + * Constructor for inline Tries Array class + */ + function CMITries() { + _classCallCheck(this, CMITries); + + return _super9.call(this, { + children: aicc_constants.tries_children + }); + } + + return CMITries; +}(_common.CMIArray); +/** + * Class for AICC Tries + */ + + +exports.CMITries = CMITries; + +var _status2 = new WeakMap(); + +var _time2 = new WeakMap(); + +var CMITriesObject = /*#__PURE__*/function (_BaseCMI4) { + _inherits(CMITriesObject, _BaseCMI4); + + var _super10 = _createSuper(CMITriesObject); + + /** + * Constructor for AICC Tries object + */ + function CMITriesObject() { + var _this7; + + _classCallCheck(this, CMITriesObject); + + _this7 = _super10.call(this); + + _status2.set(_assertThisInitialized(_this7), { + writable: true, + value: '' + }); + + _time2.set(_assertThisInitialized(_this7), { + writable: true, + value: '' + }); + + _this7.score = new _common.CMIScore({ + score_children: aicc_constants.score_children, + score_range: aicc_regex.score_range, + invalidErrorCode: aicc_error_codes.INVALID_SET_VALUE, + invalidTypeCode: aicc_error_codes.TYPE_MISMATCH, + invalidRangeCode: aicc_error_codes.VALUE_OUT_OF_RANGE, + errorClass: _exceptions.AICCValidationError + }); + return _this7; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(CMITriesObject, [{ + key: "initialize", + value: function initialize() { + var _this$score; + + _get(_getPrototypeOf(CMITriesObject.prototype), "initialize", this).call(this); + + (_this$score = this.score) === null || _this$score === void 0 ? void 0 : _this$score.initialize(); + } + }, { + key: "status", + get: + /** + * Getter for #status + * @return {string} + */ + function get() { + return _classPrivateFieldGet(this, _status2); + } + /** + * Setter for #status + * @param {string} status + */ + , + set: function set(status) { + if (checkAICCValidFormat(status, aicc_regex.CMIStatus2)) { + _classPrivateFieldSet(this, _status2, status); + } + } + /** + * Getter for #time + * @return {string} + */ + + }, { + key: "time", + get: function get() { + return _classPrivateFieldGet(this, _time2); + } + /** + * Setter for #time + * @param {string} time + */ + , + set: function set(time) { + if (checkAICCValidFormat(time, aicc_regex.CMITime)) { + _classPrivateFieldSet(this, _time2, time); + } + } + /** + * toJSON for cmi.student_data.tries.n object + * @return { + * { + * status: string, + * time: string, + * score: CMIScore + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'status': this.status, + 'time': this.time, + 'score': this.score + }; + delete this.jsonString; + return result; + } + }]); + + return CMITriesObject; +}(_common.BaseCMI); +/** + * Class for cmi.student_data.attempt_records array + */ + + +exports.CMITriesObject = CMITriesObject; + +var CMIAttemptRecords = /*#__PURE__*/function (_CMIArray4) { + _inherits(CMIAttemptRecords, _CMIArray4); + + var _super11 = _createSuper(CMIAttemptRecords); + + /** + * Constructor for inline Tries Array class + */ + function CMIAttemptRecords() { + _classCallCheck(this, CMIAttemptRecords); + + return _super11.call(this, { + children: aicc_constants.attempt_records_children + }); + } + + return CMIAttemptRecords; +}(_common.CMIArray); +/** + * Class for AICC Attempt Records + */ + + +exports.CMIAttemptRecords = CMIAttemptRecords; + +var _lesson_status = new WeakMap(); + +var CMIAttemptRecordsObject = /*#__PURE__*/function (_BaseCMI5) { + _inherits(CMIAttemptRecordsObject, _BaseCMI5); + + var _super12 = _createSuper(CMIAttemptRecordsObject); + + /** + * Constructor for AICC Attempt Records object + */ + function CMIAttemptRecordsObject() { + var _this8; + + _classCallCheck(this, CMIAttemptRecordsObject); + + _this8 = _super12.call(this); + + _lesson_status.set(_assertThisInitialized(_this8), { + writable: true, + value: '' + }); + + _this8.score = new _common.CMIScore({ + score_children: aicc_constants.score_children, + score_range: aicc_regex.score_range, + invalidErrorCode: aicc_error_codes.INVALID_SET_VALUE, + invalidTypeCode: aicc_error_codes.TYPE_MISMATCH, + invalidRangeCode: aicc_error_codes.VALUE_OUT_OF_RANGE, + errorClass: _exceptions.AICCValidationError + }); + return _this8; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(CMIAttemptRecordsObject, [{ + key: "initialize", + value: function initialize() { + var _this$score2; + + _get(_getPrototypeOf(CMIAttemptRecordsObject.prototype), "initialize", this).call(this); + + (_this$score2 = this.score) === null || _this$score2 === void 0 ? void 0 : _this$score2.initialize(); + } + }, { + key: "lesson_status", + get: + /** + * Getter for #lesson_status + * @return {string} + */ + function get() { + return _classPrivateFieldGet(this, _lesson_status); + } + /** + * Setter for #lesson_status + * @param {string} lesson_status + */ + , + set: function set(lesson_status) { + if (checkAICCValidFormat(lesson_status, aicc_regex.CMIStatus2)) { + _classPrivateFieldSet(this, _lesson_status, lesson_status); + } + } + /** + * toJSON for cmi.student_data.attempt_records.n object + * @return { + * { + * status: string, + * time: string, + * score: CMIScore + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'lesson_status': this.lesson_status, + 'score': this.score + }; + delete this.jsonString; + return result; + } + }]); + + return CMIAttemptRecordsObject; +}(_common.BaseCMI); +/** + * Class for AICC Evaluation Comments + */ + + +exports.CMIAttemptRecordsObject = CMIAttemptRecordsObject; + +var _content = new WeakMap(); + +var _location = new WeakMap(); + +var _time3 = new WeakMap(); + +var CMIEvaluationCommentsObject = /*#__PURE__*/function (_BaseCMI6) { + _inherits(CMIEvaluationCommentsObject, _BaseCMI6); + + var _super13 = _createSuper(CMIEvaluationCommentsObject); + + /** + * Constructor for Evaluation Comments + */ + function CMIEvaluationCommentsObject() { + var _this9; + + _classCallCheck(this, CMIEvaluationCommentsObject); + + _this9 = _super13.call(this); + + _content.set(_assertThisInitialized(_this9), { + writable: true, + value: '' + }); + + _location.set(_assertThisInitialized(_this9), { + writable: true, + value: '' + }); + + _time3.set(_assertThisInitialized(_this9), { + writable: true, + value: '' + }); + + return _this9; + } + + _createClass(CMIEvaluationCommentsObject, [{ + key: "content", + get: + /** + * Getter for #content + * @return {string} + */ + function get() { + return _classPrivateFieldGet(this, _content); + } + /** + * Setter for #content + * @param {string} content + */ + , + set: function set(content) { + if (checkAICCValidFormat(content, aicc_regex.CMIString256)) { + _classPrivateFieldSet(this, _content, content); + } + } + /** + * Getter for #location + * @return {string} + */ + + }, { + key: "location", + get: function get() { + return _classPrivateFieldGet(this, _location); + } + /** + * Setter for #location + * @param {string} location + */ + , + set: function set(location) { + if (checkAICCValidFormat(location, aicc_regex.CMIString256)) { + _classPrivateFieldSet(this, _location, location); + } + } + /** + * Getter for #time + * @return {string} + */ + + }, { + key: "time", + get: function get() { + return _classPrivateFieldGet(this, _time3); + } + /** + * Setting for #time + * @param {string} time + */ + , + set: function set(time) { + if (checkAICCValidFormat(time, aicc_regex.CMITime)) { + _classPrivateFieldSet(this, _time3, time); + } + } + /** + * toJSON for cmi.evaulation.comments.n object + * @return { + * { + * content: string, + * location: string, + * time: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'content': this.content, + 'location': this.location, + 'time': this.time + }; + delete this.jsonString; + return result; + } + }]); + + return CMIEvaluationCommentsObject; +}(_common.BaseCMI); + +exports.CMIEvaluationCommentsObject = CMIEvaluationCommentsObject; + +},{"../constants/api_constants":8,"../constants/error_codes":9,"../constants/regex":10,"../exceptions":11,"./common":6,"./scorm12_cmi":7}],6:[function(require,module,exports){ +"use strict"; + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.checkValidFormat = checkValidFormat; +exports.checkValidRange = checkValidRange; +exports.CMIArray = exports.CMIScore = exports.BaseCMI = void 0; + +var _api_constants = _interopRequireDefault(require("../constants/api_constants")); + +var _error_codes = _interopRequireDefault(require("../constants/error_codes")); + +var _regex = _interopRequireDefault(require("../constants/regex")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; } + +function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } } + +function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); } + +function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); } + +function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +var scorm12_constants = _api_constants["default"].scorm12; +var scorm12_regex = _regex["default"].scorm12; +var scorm12_error_codes = _error_codes["default"].scorm12; +/** + * Check if the value matches the proper format. If not, throw proper error code. + * + * @param {string} value + * @param {string} regexPattern + * @param {number} errorCode + * @param {class} errorClass + * @param {boolean} allowEmptyString + * @return {boolean} + */ + +function checkValidFormat(value, regexPattern, errorCode, errorClass, allowEmptyString) { + var formatRegex = new RegExp(regexPattern); + var matches = value.match(formatRegex); + + if (allowEmptyString && value === '') { + return true; + } + + if (value === undefined || !matches || matches[0] === '') { + throw new errorClass.prototype.constructor(errorCode); + } + + return true; +} +/** + * Check if the value matches the proper range. If not, throw proper error code. + * + * @param {*} value + * @param {string} rangePattern + * @param {number} errorCode + * @param {class} errorClass + * @return {boolean} + */ + + +function checkValidRange(value, rangePattern, errorCode, errorClass) { + var ranges = rangePattern.split('#'); + value = value * 1.0; + + if (value >= ranges[0]) { + if (ranges[1] === '*' || value <= ranges[1]) { + return true; + } else { + throw new errorClass.prototype.constructor(errorCode); + } + } else { + throw new errorClass.prototype.constructor(errorCode); + } +} +/** + * Base class for API cmi objects + */ + + +var _initialized = new WeakMap(); + +var _start_time = new WeakMap(); + +var BaseCMI = /*#__PURE__*/function () { + /** + * Constructor for BaseCMI, just marks the class as abstract + */ + function BaseCMI() { + _classCallCheck(this, BaseCMI); + + _defineProperty(this, "jsonString", false); + + _initialized.set(this, { + writable: true, + value: false + }); + + _start_time.set(this, { + writable: true, + value: void 0 + }); + + if ((this instanceof BaseCMI ? this.constructor : void 0) === BaseCMI) { + throw new TypeError('Cannot construct BaseCMI instances directly'); + } + } + /** + * Getter for #initialized + * @return {boolean} + */ + + + _createClass(BaseCMI, [{ + key: "initialized", + get: function get() { + return _classPrivateFieldGet(this, _initialized); + } + /** + * Getter for #start_time + * @return {Number} + */ + + }, { + key: "start_time", + get: function get() { + return _classPrivateFieldGet(this, _start_time); + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + }, { + key: "initialize", + value: function initialize() { + _classPrivateFieldSet(this, _initialized, true); + } + /** + * Called when the player should override the 'session_time' provided by + * the module + */ + + }, { + key: "setStartTime", + value: function setStartTime() { + _classPrivateFieldSet(this, _start_time, new Date().getTime()); + } + }]); + + return BaseCMI; +}(); +/** + * Base class for cmi *.score objects + */ + + +exports.BaseCMI = BaseCMI; + +var _children2 = new WeakMap(); + +var _score_range = new WeakMap(); + +var _invalid_error_code = new WeakMap(); + +var _invalid_type_code = new WeakMap(); + +var _invalid_range_code = new WeakMap(); + +var _decimal_regex = new WeakMap(); + +var _error_class = new WeakMap(); + +var _raw = new WeakMap(); + +var _min = new WeakMap(); + +var _max = new WeakMap(); + +var CMIScore = /*#__PURE__*/function (_BaseCMI) { + _inherits(CMIScore, _BaseCMI); + + var _super = _createSuper(CMIScore); + + /** + * Constructor for *.score + * @param {string} score_children + * @param {string} score_range + * @param {string} max + * @param {number} invalidErrorCode + * @param {number} invalidTypeCode + * @param {number} invalidRangeCode + * @param {string} decimalRegex + * @param {class} errorClass + */ + function CMIScore(_ref) { + var _this; + + var score_children = _ref.score_children, + score_range = _ref.score_range, + max = _ref.max, + invalidErrorCode = _ref.invalidErrorCode, + invalidTypeCode = _ref.invalidTypeCode, + invalidRangeCode = _ref.invalidRangeCode, + decimalRegex = _ref.decimalRegex, + errorClass = _ref.errorClass; + + _classCallCheck(this, CMIScore); + + _this = _super.call(this); + + _children2.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _score_range.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _invalid_error_code.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _invalid_type_code.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _invalid_range_code.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _decimal_regex.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _error_class.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _raw.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _min.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _max.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _classPrivateFieldSet(_assertThisInitialized(_this), _children2, score_children || scorm12_constants.score_children); + + _classPrivateFieldSet(_assertThisInitialized(_this), _score_range, !score_range ? false : scorm12_regex.score_range); + + _classPrivateFieldSet(_assertThisInitialized(_this), _max, max || max === '' ? max : '100'); + + _classPrivateFieldSet(_assertThisInitialized(_this), _invalid_error_code, invalidErrorCode || scorm12_error_codes.INVALID_SET_VALUE); + + _classPrivateFieldSet(_assertThisInitialized(_this), _invalid_type_code, invalidTypeCode || scorm12_error_codes.TYPE_MISMATCH); + + _classPrivateFieldSet(_assertThisInitialized(_this), _invalid_range_code, invalidRangeCode || scorm12_error_codes.VALUE_OUT_OF_RANGE); + + _classPrivateFieldSet(_assertThisInitialized(_this), _decimal_regex, decimalRegex || scorm12_regex.CMIDecimal); + + _classPrivateFieldSet(_assertThisInitialized(_this), _error_class, errorClass); + + return _this; + } + + _createClass(CMIScore, [{ + key: "_children", + get: + /** + * Getter for _children + * @return {string} + * @private + */ + function get() { + return _classPrivateFieldGet(this, _children2); + } + /** + * Setter for _children. Just throws an error. + * @param {string} _children + * @private + */ + , + set: function set(_children) { + throw new (_classPrivateFieldGet(this, _error_class).prototype.constructor)(_classPrivateFieldGet(this, _invalid_error_code)); + } + /** + * Getter for #raw + * @return {string} + */ + + }, { + key: "raw", + get: function get() { + return _classPrivateFieldGet(this, _raw); + } + /** + * Setter for #raw + * @param {string} raw + */ + , + set: function set(raw) { + if (checkValidFormat(raw, _classPrivateFieldGet(this, _decimal_regex), _classPrivateFieldGet(this, _invalid_type_code), _classPrivateFieldGet(this, _error_class)) && (!_classPrivateFieldGet(this, _score_range) || checkValidRange(raw, _classPrivateFieldGet(this, _score_range), _classPrivateFieldGet(this, _invalid_range_code), _classPrivateFieldGet(this, _error_class)))) { + _classPrivateFieldSet(this, _raw, raw); + } + } + /** + * Getter for #min + * @return {string} + */ + + }, { + key: "min", + get: function get() { + return _classPrivateFieldGet(this, _min); + } + /** + * Setter for #min + * @param {string} min + */ + , + set: function set(min) { + if (checkValidFormat(min, _classPrivateFieldGet(this, _decimal_regex), _classPrivateFieldGet(this, _invalid_type_code), _classPrivateFieldGet(this, _error_class)) && (!_classPrivateFieldGet(this, _score_range) || checkValidRange(min, _classPrivateFieldGet(this, _score_range), _classPrivateFieldGet(this, _invalid_range_code), _classPrivateFieldGet(this, _error_class)))) { + _classPrivateFieldSet(this, _min, min); + } + } + /** + * Getter for #max + * @return {string} + */ + + }, { + key: "max", + get: function get() { + return _classPrivateFieldGet(this, _max); + } + /** + * Setter for #max + * @param {string} max + */ + , + set: function set(max) { + if (checkValidFormat(max, _classPrivateFieldGet(this, _decimal_regex), _classPrivateFieldGet(this, _invalid_type_code), _classPrivateFieldGet(this, _error_class)) && (!_classPrivateFieldGet(this, _score_range) || checkValidRange(max, _classPrivateFieldGet(this, _score_range), _classPrivateFieldGet(this, _invalid_range_code), _classPrivateFieldGet(this, _error_class)))) { + _classPrivateFieldSet(this, _max, max); + } + } + /** + * toJSON for *.score + * @return {{min: string, max: string, raw: string}} + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'raw': this.raw, + 'min': this.min, + 'max': this.max + }; + delete this.jsonString; + return result; + } + }]); + + return CMIScore; +}(BaseCMI); +/** + * Base class for cmi *.n objects + */ + + +exports.CMIScore = CMIScore; + +var _errorCode = new WeakMap(); + +var _errorClass = new WeakMap(); + +var _children3 = new WeakMap(); + +var CMIArray = /*#__PURE__*/function (_BaseCMI2) { + _inherits(CMIArray, _BaseCMI2); + + var _super2 = _createSuper(CMIArray); + + /** + * Constructor cmi *.n arrays + * @param {string} children + * @param {number} errorCode + * @param {class} errorClass + */ + function CMIArray(_ref2) { + var _this2; + + var children = _ref2.children, + errorCode = _ref2.errorCode, + errorClass = _ref2.errorClass; + + _classCallCheck(this, CMIArray); + + _this2 = _super2.call(this); + + _errorCode.set(_assertThisInitialized(_this2), { + writable: true, + value: void 0 + }); + + _errorClass.set(_assertThisInitialized(_this2), { + writable: true, + value: void 0 + }); + + _children3.set(_assertThisInitialized(_this2), { + writable: true, + value: void 0 + }); + + _classPrivateFieldSet(_assertThisInitialized(_this2), _children3, children); + + _classPrivateFieldSet(_assertThisInitialized(_this2), _errorCode, errorCode); + + _classPrivateFieldSet(_assertThisInitialized(_this2), _errorClass, errorClass); + + _this2.childArray = []; + return _this2; + } + + _createClass(CMIArray, [{ + key: "_children", + get: + /** + * Getter for _children + * @return {*} + */ + function get() { + return _classPrivateFieldGet(this, _children3); + } + /** + * Setter for _children. Just throws an error. + * @param {string} _children + */ + , + set: function set(_children) { + throw new (_classPrivateFieldGet(this, _errorClass).prototype.constructor)(_classPrivateFieldGet(this, _errorCode)); + } + /** + * Getter for _count + * @return {number} + */ + + }, { + key: "_count", + get: function get() { + return this.childArray.length; + } + /** + * Setter for _count. Just throws an error. + * @param {number} _count + */ + , + set: function set(_count) { + throw new (_classPrivateFieldGet(this, _errorClass).prototype.constructor)(_classPrivateFieldGet(this, _errorCode)); + } + /** + * toJSON for *.n arrays + * @return {object} + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = {}; + + for (var i = 0; i < this.childArray.length; i++) { + result[i + ''] = this.childArray[i]; + } + + delete this.jsonString; + return result; + } + }]); + + return CMIArray; +}(BaseCMI); + +exports.CMIArray = CMIArray; + +},{"../constants/api_constants":8,"../constants/error_codes":9,"../constants/regex":10}],7:[function(require,module,exports){ +"use strict"; + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.throwReadOnlyError = throwReadOnlyError; +exports.throwWriteOnlyError = throwWriteOnlyError; +exports.check12ValidFormat = check12ValidFormat; +exports.check12ValidRange = check12ValidRange; +exports.NAV = exports.CMIInteractionsCorrectResponsesObject = exports.CMIInteractionsObjectivesObject = exports.CMIObjectivesObject = exports.CMIInteractionsObject = exports.CMIStudentPreference = exports.CMIStudentData = exports.CMI = void 0; + +var _common = require("./common"); + +var _api_constants = _interopRequireDefault(require("../constants/api_constants")); + +var _error_codes = _interopRequireDefault(require("../constants/error_codes")); + +var _regex = _interopRequireDefault(require("../constants/regex")); + +var _exceptions = require("../exceptions"); + +var Utilities = _interopRequireWildcard(require("../utilities")); + +var Util = Utilities; + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); } + +function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); } + +function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; } + +function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); } + +function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } } + +var scorm12_constants = _api_constants["default"].scorm12; +var scorm12_regex = _regex["default"].scorm12; +var scorm12_error_codes = _error_codes["default"].scorm12; +/** + * Helper method for throwing Read Only error + */ + +function throwReadOnlyError() { + throw new _exceptions.Scorm12ValidationError(scorm12_error_codes.READ_ONLY_ELEMENT); +} +/** + * Helper method for throwing Write Only error + */ + + +function throwWriteOnlyError() { + throw new _exceptions.Scorm12ValidationError(scorm12_error_codes.WRITE_ONLY_ELEMENT); +} +/** + * Helper method for throwing Invalid Set error + */ + + +function throwInvalidValueError() { + throw new _exceptions.Scorm12ValidationError(scorm12_error_codes.INVALID_SET_VALUE); +} +/** + * Helper method, no reason to have to pass the same error codes every time + * @param {*} value + * @param {string} regexPattern + * @param {boolean} allowEmptyString + * @return {boolean} + */ + + +function check12ValidFormat(value, regexPattern, allowEmptyString) { + return (0, _common.checkValidFormat)(value, regexPattern, scorm12_error_codes.TYPE_MISMATCH, _exceptions.Scorm12ValidationError, allowEmptyString); +} +/** + * Helper method, no reason to have to pass the same error codes every time + * @param {*} value + * @param {string} rangePattern + * @param {boolean} allowEmptyString + * @return {boolean} + */ + + +function check12ValidRange(value, rangePattern, allowEmptyString) { + return (0, _common.checkValidRange)(value, rangePattern, scorm12_error_codes.VALUE_OUT_OF_RANGE, _exceptions.Scorm12ValidationError, allowEmptyString); +} +/** + * Class representing the cmi object for SCORM 1.2 + */ + + +var _children2 = new WeakMap(); + +var _version2 = new WeakMap(); + +var _launch_data = new WeakMap(); + +var _comments = new WeakMap(); + +var _comments_from_lms = new WeakMap(); + +var CMI = /*#__PURE__*/function (_BaseCMI) { + _inherits(CMI, _BaseCMI); + + var _super = _createSuper(CMI); + + /** + * Constructor for the SCORM 1.2 cmi object + * @param {string} cmi_children + * @param {(CMIStudentData|AICCCMIStudentData)} student_data + * @param {boolean} initialized + */ + function CMI(cmi_children, student_data, initialized) { + var _this; + + _classCallCheck(this, CMI); + + _this = _super.call(this); + + _children2.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _version2.set(_assertThisInitialized(_this), { + writable: true, + value: '3.4' + }); + + _launch_data.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _comments.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _comments_from_lms.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _defineProperty(_assertThisInitialized(_this), "student_data", null); + + if (initialized) _this.initialize(); + + _classPrivateFieldSet(_assertThisInitialized(_this), _children2, cmi_children ? cmi_children : scorm12_constants.cmi_children); + + _this.core = new CMICore(); + _this.objectives = new CMIObjectives(); + _this.student_data = student_data ? student_data : new CMIStudentData(); + _this.student_preference = new CMIStudentPreference(); + _this.interactions = new CMIInteractions(); + return _this; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(CMI, [{ + key: "initialize", + value: function initialize() { + var _this$core, _this$objectives, _this$student_data, _this$student_prefere, _this$interactions; + + _get(_getPrototypeOf(CMI.prototype), "initialize", this).call(this); + + (_this$core = this.core) === null || _this$core === void 0 ? void 0 : _this$core.initialize(); + (_this$objectives = this.objectives) === null || _this$objectives === void 0 ? void 0 : _this$objectives.initialize(); + (_this$student_data = this.student_data) === null || _this$student_data === void 0 ? void 0 : _this$student_data.initialize(); + (_this$student_prefere = this.student_preference) === null || _this$student_prefere === void 0 ? void 0 : _this$student_prefere.initialize(); + (_this$interactions = this.interactions) === null || _this$interactions === void 0 ? void 0 : _this$interactions.initialize(); + } + /** + * toJSON for cmi + * + * @return { + * { + * suspend_data: string, + * launch_data: string, + * comments: string, + * comments_from_lms: string, + * core: CMICore, + * objectives: CMIObjectives, + * student_data: CMIStudentData, + * student_preference: CMIStudentPreference, + * interactions: CMIInteractions + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'suspend_data': this.suspend_data, + 'launch_data': this.launch_data, + 'comments': this.comments, + 'comments_from_lms': this.comments_from_lms, + 'core': this.core, + 'objectives': this.objectives, + 'student_data': this.student_data, + 'student_preference': this.student_preference, + 'interactions': this.interactions + }; + delete this.jsonString; + return result; + } + /** + * Getter for #_version + * @return {string} + */ + + }, { + key: "_version", + get: function get() { + return _classPrivateFieldGet(this, _version2); + } + /** + * Setter for #_version. Just throws an error. + * @param {string} _version + */ + , + set: function set(_version) { + throwInvalidValueError(); + } + /** + * Getter for #_children + * @return {string} + */ + + }, { + key: "_children", + get: function get() { + return _classPrivateFieldGet(this, _children2); + } + /** + * Setter for #_version. Just throws an error. + * @param {string} _children + */ + , + set: function set(_children) { + throwInvalidValueError(); + } + /** + * Getter for #suspend_data + * @return {string} + */ + + }, { + key: "suspend_data", + get: function get() { + var _this$core2; + + return (_this$core2 = this.core) === null || _this$core2 === void 0 ? void 0 : _this$core2.suspend_data; + } + /** + * Setter for #suspend_data + * @param {string} suspend_data + */ + , + set: function set(suspend_data) { + if (this.core) { + this.core.suspend_data = suspend_data; + } + } + /** + * Getter for #launch_data + * @return {string} + */ + + }, { + key: "launch_data", + get: function get() { + return _classPrivateFieldGet(this, _launch_data); + } + /** + * Setter for #launch_data. Can only be called before initialization. + * @param {string} launch_data + */ + , + set: function set(launch_data) { + !this.initialized ? _classPrivateFieldSet(this, _launch_data, launch_data) : throwReadOnlyError(); + } + /** + * Getter for #comments + * @return {string} + */ + + }, { + key: "comments", + get: function get() { + return _classPrivateFieldGet(this, _comments); + } + /** + * Setter for #comments + * @param {string} comments + */ + , + set: function set(comments) { + if (check12ValidFormat(comments, scorm12_regex.CMIString4096, true)) { + _classPrivateFieldSet(this, _comments, comments); + } + } + /** + * Getter for #comments_from_lms + * @return {string} + */ + + }, { + key: "comments_from_lms", + get: function get() { + return _classPrivateFieldGet(this, _comments_from_lms); + } + /** + * Setter for #comments_from_lms. Can only be called before initialization. + * @param {string} comments_from_lms + */ + , + set: function set(comments_from_lms) { + !this.initialized ? _classPrivateFieldSet(this, _comments_from_lms, comments_from_lms) : throwReadOnlyError(); + } + /** + * Adds the current session time to the existing total time. + * + * @return {string} + */ + + }, { + key: "getCurrentTotalTime", + value: function getCurrentTotalTime() { + return this.core.getCurrentTotalTime(this.start_time); + } + }]); + + return CMI; +}(_common.BaseCMI); +/** + * Class representing the cmi.core object + * @extends BaseCMI + */ + + +exports.CMI = CMI; + +var _children3 = new WeakMap(); + +var _student_id = new WeakMap(); + +var _student_name = new WeakMap(); + +var _lesson_location = new WeakMap(); + +var _credit = new WeakMap(); + +var _lesson_status = new WeakMap(); + +var _entry = new WeakMap(); + +var _total_time = new WeakMap(); + +var _lesson_mode = new WeakMap(); + +var _exit = new WeakMap(); + +var _session_time = new WeakMap(); + +var _suspend_data = new WeakMap(); + +var CMICore = /*#__PURE__*/function (_BaseCMI2) { + _inherits(CMICore, _BaseCMI2); + + var _super2 = _createSuper(CMICore); + + /** + * Constructor for cmi.core + */ + function CMICore() { + var _this2; + + _classCallCheck(this, CMICore); + + _this2 = _super2.call(this); + + _children3.set(_assertThisInitialized(_this2), { + writable: true, + value: scorm12_constants.core_children + }); + + _student_id.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _student_name.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _lesson_location.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _credit.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _lesson_status.set(_assertThisInitialized(_this2), { + writable: true, + value: 'not attempted' + }); + + _entry.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _total_time.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _lesson_mode.set(_assertThisInitialized(_this2), { + writable: true, + value: 'normal' + }); + + _exit.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _session_time.set(_assertThisInitialized(_this2), { + writable: true, + value: '00:00:00' + }); + + _suspend_data.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _this2.score = new _common.CMIScore({ + score_children: scorm12_constants.score_children, + score_range: scorm12_regex.score_range, + invalidErrorCode: scorm12_error_codes.INVALID_SET_VALUE, + invalidTypeCode: scorm12_error_codes.TYPE_MISMATCH, + invalidRangeCode: scorm12_error_codes.VALUE_OUT_OF_RANGE, + errorClass: _exceptions.Scorm12ValidationError + }); + return _this2; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(CMICore, [{ + key: "initialize", + value: function initialize() { + var _this$score; + + _get(_getPrototypeOf(CMICore.prototype), "initialize", this).call(this); + + (_this$score = this.score) === null || _this$score === void 0 ? void 0 : _this$score.initialize(); + } + }, { + key: "_children", + get: + /** + * Getter for #_children + * @return {string} + * @private + */ + function get() { + return _classPrivateFieldGet(this, _children3); + } + /** + * Setter for #_children. Just throws an error. + * @param {string} _children + * @private + */ + , + set: function set(_children) { + throwInvalidValueError(); + } + /** + * Getter for #student_id + * @return {string} + */ + + }, { + key: "student_id", + get: function get() { + return _classPrivateFieldGet(this, _student_id); + } + /** + * Setter for #student_id. Can only be called before initialization. + * @param {string} student_id + */ + , + set: function set(student_id) { + !this.initialized ? _classPrivateFieldSet(this, _student_id, student_id) : throwReadOnlyError(); + } + /** + * Getter for #student_name + * @return {string} + */ + + }, { + key: "student_name", + get: function get() { + return _classPrivateFieldGet(this, _student_name); + } + /** + * Setter for #student_name. Can only be called before initialization. + * @param {string} student_name + */ + , + set: function set(student_name) { + !this.initialized ? _classPrivateFieldSet(this, _student_name, student_name) : throwReadOnlyError(); + } + /** + * Getter for #lesson_location + * @return {string} + */ + + }, { + key: "lesson_location", + get: function get() { + return _classPrivateFieldGet(this, _lesson_location); + } + /** + * Setter for #lesson_location + * @param {string} lesson_location + */ + , + set: function set(lesson_location) { + if (check12ValidFormat(lesson_location, scorm12_regex.CMIString256, true)) { + _classPrivateFieldSet(this, _lesson_location, lesson_location); + } + } + /** + * Getter for #credit + * @return {string} + */ + + }, { + key: "credit", + get: function get() { + return _classPrivateFieldGet(this, _credit); + } + /** + * Setter for #credit. Can only be called before initialization. + * @param {string} credit + */ + , + set: function set(credit) { + !this.initialized ? _classPrivateFieldSet(this, _credit, credit) : throwReadOnlyError(); + } + /** + * Getter for #lesson_status + * @return {string} + */ + + }, { + key: "lesson_status", + get: function get() { + return _classPrivateFieldGet(this, _lesson_status); + } + /** + * Setter for #lesson_status + * @param {string} lesson_status + */ + , + set: function set(lesson_status) { + if (this.initialized) { + if (check12ValidFormat(lesson_status, scorm12_regex.CMIStatus)) { + _classPrivateFieldSet(this, _lesson_status, lesson_status); + } + } else { + if (check12ValidFormat(lesson_status, scorm12_regex.CMIStatus2)) { + _classPrivateFieldSet(this, _lesson_status, lesson_status); + } + } + } + /** + * Getter for #entry + * @return {string} + */ + + }, { + key: "entry", + get: function get() { + return _classPrivateFieldGet(this, _entry); + } + /** + * Setter for #entry. Can only be called before initialization. + * @param {string} entry + */ + , + set: function set(entry) { + !this.initialized ? _classPrivateFieldSet(this, _entry, entry) : throwReadOnlyError(); + } + /** + * Getter for #total_time + * @return {string} + */ + + }, { + key: "total_time", + get: function get() { + return _classPrivateFieldGet(this, _total_time); + } + /** + * Setter for #total_time. Can only be called before initialization. + * @param {string} total_time + */ + , + set: function set(total_time) { + !this.initialized ? _classPrivateFieldSet(this, _total_time, total_time) : throwReadOnlyError(); + } + /** + * Getter for #lesson_mode + * @return {string} + */ + + }, { + key: "lesson_mode", + get: function get() { + return _classPrivateFieldGet(this, _lesson_mode); + } + /** + * Setter for #lesson_mode. Can only be called before initialization. + * @param {string} lesson_mode + */ + , + set: function set(lesson_mode) { + !this.initialized ? _classPrivateFieldSet(this, _lesson_mode, lesson_mode) : throwReadOnlyError(); + } + /** + * Getter for #exit. Should only be called during JSON export. + * @return {*} + */ + + }, { + key: "exit", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _exit); + } + /** + * Setter for #exit + * @param {string} exit + */ + , + set: function set(exit) { + if (check12ValidFormat(exit, scorm12_regex.CMIExit, true)) { + _classPrivateFieldSet(this, _exit, exit); + } + } + /** + * Getter for #session_time. Should only be called during JSON export. + * @return {*} + */ + + }, { + key: "session_time", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _session_time); + } + /** + * Setter for #session_time + * @param {string} session_time + */ + , + set: function set(session_time) { + if (check12ValidFormat(session_time, scorm12_regex.CMITimespan)) { + _classPrivateFieldSet(this, _session_time, session_time); + } + } + /** + * Getter for #suspend_data + * @return {string} + */ + + }, { + key: "suspend_data", + get: function get() { + return _classPrivateFieldGet(this, _suspend_data); + } + /** + * Setter for #suspend_data + * @param {string} suspend_data + */ + , + set: function set(suspend_data) { + if (check12ValidFormat(suspend_data, scorm12_regex.CMIString4096, true)) { + _classPrivateFieldSet(this, _suspend_data, suspend_data); + } + } + /** + * Adds the current session time to the existing total time. + * @param {Number} start_time + * @return {string} + */ + + }, { + key: "getCurrentTotalTime", + value: function getCurrentTotalTime(start_time) { + var sessionTime = _classPrivateFieldGet(this, _session_time); + + var startTime = start_time; + + if (typeof startTime !== 'undefined' && startTime !== null) { + var seconds = new Date().getTime() - startTime; + sessionTime = Util.getSecondsAsHHMMSS(seconds / 1000); + } + + return Utilities.addHHMMSSTimeStrings(_classPrivateFieldGet(this, _total_time), sessionTime, new RegExp(scorm12_regex.CMITimespan)); + } + /** + * toJSON for cmi.core + * + * @return { + * { + * student_name: string, + * entry: string, + * exit: string, + * score: CMIScore, + * student_id: string, + * lesson_mode: string, + * lesson_location: string, + * lesson_status: string, + * credit: string, + * session_time: * + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'student_id': this.student_id, + 'student_name': this.student_name, + 'lesson_location': this.lesson_location, + 'credit': this.credit, + 'lesson_status': this.lesson_status, + 'entry': this.entry, + 'lesson_mode': this.lesson_mode, + 'exit': this.exit, + 'session_time': this.session_time, + 'score': this.score + }; + delete this.jsonString; + return result; + } + }]); + + return CMICore; +}(_common.BaseCMI); +/** + * Class representing SCORM 1.2's cmi.objectives object + * @extends CMIArray + */ + + +var CMIObjectives = /*#__PURE__*/function (_CMIArray) { + _inherits(CMIObjectives, _CMIArray); + + var _super3 = _createSuper(CMIObjectives); + + /** + * Constructor for cmi.objectives + */ + function CMIObjectives() { + _classCallCheck(this, CMIObjectives); + + return _super3.call(this, { + children: scorm12_constants.objectives_children, + errorCode: scorm12_error_codes.INVALID_SET_VALUE, + errorClass: _exceptions.Scorm12ValidationError + }); + } + + return CMIObjectives; +}(_common.CMIArray); +/** + * Class representing SCORM 1.2's cmi.student_data object + * @extends BaseCMI + */ + + +var _children4 = new WeakMap(); + +var _mastery_score = new WeakMap(); + +var _max_time_allowed = new WeakMap(); + +var _time_limit_action = new WeakMap(); + +var CMIStudentData = /*#__PURE__*/function (_BaseCMI3) { + _inherits(CMIStudentData, _BaseCMI3); + + var _super4 = _createSuper(CMIStudentData); + + /** + * Constructor for cmi.student_data + * @param {string} student_data_children + */ + function CMIStudentData(student_data_children) { + var _this3; + + _classCallCheck(this, CMIStudentData); + + _this3 = _super4.call(this); + + _children4.set(_assertThisInitialized(_this3), { + writable: true, + value: void 0 + }); + + _mastery_score.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _max_time_allowed.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _time_limit_action.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _classPrivateFieldSet(_assertThisInitialized(_this3), _children4, student_data_children ? student_data_children : scorm12_constants.student_data_children); + + return _this3; + } + /** + * Getter for #_children + * @return {*} + * @private + */ + + + _createClass(CMIStudentData, [{ + key: "_children", + get: function get() { + return _classPrivateFieldGet(this, _children4); + } + /** + * Setter for #_children. Just throws an error. + * @param {string} _children + * @private + */ + , + set: function set(_children) { + throwInvalidValueError(); + } + /** + * Getter for #master_score + * @return {string} + */ + + }, { + key: "mastery_score", + get: function get() { + return _classPrivateFieldGet(this, _mastery_score); + } + /** + * Setter for #master_score. Can only be called before initialization. + * @param {string} mastery_score + */ + , + set: function set(mastery_score) { + !this.initialized ? _classPrivateFieldSet(this, _mastery_score, mastery_score) : throwReadOnlyError(); + } + /** + * Getter for #max_time_allowed + * @return {string} + */ + + }, { + key: "max_time_allowed", + get: function get() { + return _classPrivateFieldGet(this, _max_time_allowed); + } + /** + * Setter for #max_time_allowed. Can only be called before initialization. + * @param {string} max_time_allowed + */ + , + set: function set(max_time_allowed) { + !this.initialized ? _classPrivateFieldSet(this, _max_time_allowed, max_time_allowed) : throwReadOnlyError(); + } + /** + * Getter for #time_limit_action + * @return {string} + */ + + }, { + key: "time_limit_action", + get: function get() { + return _classPrivateFieldGet(this, _time_limit_action); + } + /** + * Setter for #time_limit_action. Can only be called before initialization. + * @param {string} time_limit_action + */ + , + set: function set(time_limit_action) { + !this.initialized ? _classPrivateFieldSet(this, _time_limit_action, time_limit_action) : throwReadOnlyError(); + } + /** + * toJSON for cmi.student_data + * + * @return { + * { + * max_time_allowed: string, + * time_limit_action: string, + * mastery_score: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'mastery_score': this.mastery_score, + 'max_time_allowed': this.max_time_allowed, + 'time_limit_action': this.time_limit_action + }; + delete this.jsonString; + return result; + } + }]); + + return CMIStudentData; +}(_common.BaseCMI); +/** + * Class representing SCORM 1.2's cmi.student_preference object + * @extends BaseCMI + */ + + +exports.CMIStudentData = CMIStudentData; + +var _children5 = new WeakMap(); + +var _audio = new WeakMap(); + +var _language = new WeakMap(); + +var _speed = new WeakMap(); + +var _text = new WeakMap(); + +var CMIStudentPreference = /*#__PURE__*/function (_BaseCMI4) { + _inherits(CMIStudentPreference, _BaseCMI4); + + var _super5 = _createSuper(CMIStudentPreference); + + /** + * Constructor for cmi.student_preference + * @param {string} student_preference_children + */ + function CMIStudentPreference(student_preference_children) { + var _this4; + + _classCallCheck(this, CMIStudentPreference); + + _this4 = _super5.call(this); + + _children5.set(_assertThisInitialized(_this4), { + writable: true, + value: void 0 + }); + + _audio.set(_assertThisInitialized(_this4), { + writable: true, + value: '' + }); + + _language.set(_assertThisInitialized(_this4), { + writable: true, + value: '' + }); + + _speed.set(_assertThisInitialized(_this4), { + writable: true, + value: '' + }); + + _text.set(_assertThisInitialized(_this4), { + writable: true, + value: '' + }); + + _classPrivateFieldSet(_assertThisInitialized(_this4), _children5, student_preference_children ? student_preference_children : scorm12_constants.student_preference_children); + + return _this4; + } + + _createClass(CMIStudentPreference, [{ + key: "_children", + get: + /** + * Getter for #_children + * @return {string} + * @private + */ + function get() { + return _classPrivateFieldGet(this, _children5); + } + /** + * Setter for #_children. Just throws an error. + * @param {string} _children + * @private + */ + , + set: function set(_children) { + throwInvalidValueError(); + } + /** + * Getter for #audio + * @return {string} + */ + + }, { + key: "audio", + get: function get() { + return _classPrivateFieldGet(this, _audio); + } + /** + * Setter for #audio + * @param {string} audio + */ + , + set: function set(audio) { + if (check12ValidFormat(audio, scorm12_regex.CMISInteger) && check12ValidRange(audio, scorm12_regex.audio_range)) { + _classPrivateFieldSet(this, _audio, audio); + } + } + /** + * Getter for #language + * @return {string} + */ + + }, { + key: "language", + get: function get() { + return _classPrivateFieldGet(this, _language); + } + /** + * Setter for #language + * @param {string} language + */ + , + set: function set(language) { + if (check12ValidFormat(language, scorm12_regex.CMIString256)) { + _classPrivateFieldSet(this, _language, language); + } + } + /** + * Getter for #speed + * @return {string} + */ + + }, { + key: "speed", + get: function get() { + return _classPrivateFieldGet(this, _speed); + } + /** + * Setter for #speed + * @param {string} speed + */ + , + set: function set(speed) { + if (check12ValidFormat(speed, scorm12_regex.CMISInteger) && check12ValidRange(speed, scorm12_regex.speed_range)) { + _classPrivateFieldSet(this, _speed, speed); + } + } + /** + * Getter for #text + * @return {string} + */ + + }, { + key: "text", + get: function get() { + return _classPrivateFieldGet(this, _text); + } + /** + * Setter for #text + * @param {string} text + */ + , + set: function set(text) { + if (check12ValidFormat(text, scorm12_regex.CMISInteger) && check12ValidRange(text, scorm12_regex.text_range)) { + _classPrivateFieldSet(this, _text, text); + } + } + /** + * toJSON for cmi.student_preference + * + * @return { + * { + * audio: string, + * language: string, + * speed: string, + * text: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'audio': this.audio, + 'language': this.language, + 'speed': this.speed, + 'text': this.text + }; + delete this.jsonString; + return result; + } + }]); + + return CMIStudentPreference; +}(_common.BaseCMI); +/** + * Class representing SCORM 1.2's cmi.interactions object + * @extends BaseCMI + */ + + +exports.CMIStudentPreference = CMIStudentPreference; + +var CMIInteractions = /*#__PURE__*/function (_CMIArray2) { + _inherits(CMIInteractions, _CMIArray2); + + var _super6 = _createSuper(CMIInteractions); + + /** + * Constructor for cmi.interactions + */ + function CMIInteractions() { + _classCallCheck(this, CMIInteractions); + + return _super6.call(this, { + children: scorm12_constants.interactions_children, + errorCode: scorm12_error_codes.INVALID_SET_VALUE, + errorClass: _exceptions.Scorm12ValidationError + }); + } + + return CMIInteractions; +}(_common.CMIArray); +/** + * Class representing SCORM 1.2's cmi.interactions.n object + * @extends BaseCMI + */ + + +var _id = new WeakMap(); + +var _time = new WeakMap(); + +var _type = new WeakMap(); + +var _weighting = new WeakMap(); + +var _student_response = new WeakMap(); + +var _result = new WeakMap(); + +var _latency = new WeakMap(); + +var CMIInteractionsObject = /*#__PURE__*/function (_BaseCMI5) { + _inherits(CMIInteractionsObject, _BaseCMI5); + + var _super7 = _createSuper(CMIInteractionsObject); + + /** + * Constructor for cmi.interactions.n object + */ + function CMIInteractionsObject() { + var _this5; + + _classCallCheck(this, CMIInteractionsObject); + + _this5 = _super7.call(this); + + _id.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _time.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _type.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _weighting.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _student_response.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _result.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _latency.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _this5.objectives = new _common.CMIArray({ + errorCode: scorm12_error_codes.INVALID_SET_VALUE, + errorClass: _exceptions.Scorm12ValidationError, + children: scorm12_constants.objectives_children + }); + _this5.correct_responses = new _common.CMIArray({ + errorCode: scorm12_error_codes.INVALID_SET_VALUE, + errorClass: _exceptions.Scorm12ValidationError, + children: scorm12_constants.correct_responses_children + }); + return _this5; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(CMIInteractionsObject, [{ + key: "initialize", + value: function initialize() { + var _this$objectives2, _this$correct_respons; + + _get(_getPrototypeOf(CMIInteractionsObject.prototype), "initialize", this).call(this); + + (_this$objectives2 = this.objectives) === null || _this$objectives2 === void 0 ? void 0 : _this$objectives2.initialize(); + (_this$correct_respons = this.correct_responses) === null || _this$correct_respons === void 0 ? void 0 : _this$correct_respons.initialize(); + } + }, { + key: "id", + get: + /** + * Getter for #id. Should only be called during JSON export. + * @return {*} + */ + function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _id); + } + /** + * Setter for #id + * @param {string} id + */ + , + set: function set(id) { + if (check12ValidFormat(id, scorm12_regex.CMIIdentifier)) { + _classPrivateFieldSet(this, _id, id); + } + } + /** + * Getter for #time. Should only be called during JSON export. + * @return {*} + */ + + }, { + key: "time", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _time); + } + /** + * Setter for #time + * @param {string} time + */ + , + set: function set(time) { + if (check12ValidFormat(time, scorm12_regex.CMITime)) { + _classPrivateFieldSet(this, _time, time); + } + } + /** + * Getter for #type. Should only be called during JSON export. + * @return {*} + */ + + }, { + key: "type", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _type); + } + /** + * Setter for #type + * @param {string} type + */ + , + set: function set(type) { + if (check12ValidFormat(type, scorm12_regex.CMIType)) { + _classPrivateFieldSet(this, _type, type); + } + } + /** + * Getter for #weighting. Should only be called during JSON export. + * @return {*} + */ + + }, { + key: "weighting", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _weighting); + } + /** + * Setter for #weighting + * @param {string} weighting + */ + , + set: function set(weighting) { + if (check12ValidFormat(weighting, scorm12_regex.CMIDecimal) && check12ValidRange(weighting, scorm12_regex.weighting_range)) { + _classPrivateFieldSet(this, _weighting, weighting); + } + } + /** + * Getter for #student_response. Should only be called during JSON export. + * @return {*} + */ + + }, { + key: "student_response", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _student_response); + } + /** + * Setter for #student_response + * @param {string} student_response + */ + , + set: function set(student_response) { + if (check12ValidFormat(student_response, scorm12_regex.CMIFeedback, true)) { + _classPrivateFieldSet(this, _student_response, student_response); + } + } + /** + * Getter for #result. Should only be called during JSON export. + * @return {*} + */ + + }, { + key: "result", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _result); + } + /** + * Setter for #result + * @param {string} result + */ + , + set: function set(result) { + if (check12ValidFormat(result, scorm12_regex.CMIResult)) { + _classPrivateFieldSet(this, _result, result); + } + } + /** + * Getter for #latency. Should only be called during JSON export. + * @return {*} + */ + + }, { + key: "latency", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _latency); + } + /** + * Setter for #latency + * @param {string} latency + */ + , + set: function set(latency) { + if (check12ValidFormat(latency, scorm12_regex.CMITimespan)) { + _classPrivateFieldSet(this, _latency, latency); + } + } + /** + * toJSON for cmi.interactions.n + * + * @return { + * { + * id: string, + * time: string, + * type: string, + * weighting: string, + * student_response: string, + * result: string, + * latency: string, + * objectives: CMIArray, + * correct_responses: CMIArray + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'id': this.id, + 'time': this.time, + 'type': this.type, + 'weighting': this.weighting, + 'student_response': this.student_response, + 'result': this.result, + 'latency': this.latency, + 'objectives': this.objectives, + 'correct_responses': this.correct_responses + }; + delete this.jsonString; + return result; + } + }]); + + return CMIInteractionsObject; +}(_common.BaseCMI); +/** + * Class representing SCORM 1.2's cmi.objectives.n object + * @extends BaseCMI + */ + + +exports.CMIInteractionsObject = CMIInteractionsObject; + +var _id2 = new WeakMap(); + +var _status = new WeakMap(); + +var CMIObjectivesObject = /*#__PURE__*/function (_BaseCMI6) { + _inherits(CMIObjectivesObject, _BaseCMI6); + + var _super8 = _createSuper(CMIObjectivesObject); + + /** + * Constructor for cmi.objectives.n + */ + function CMIObjectivesObject() { + var _this6; + + _classCallCheck(this, CMIObjectivesObject); + + _this6 = _super8.call(this); + + _id2.set(_assertThisInitialized(_this6), { + writable: true, + value: '' + }); + + _status.set(_assertThisInitialized(_this6), { + writable: true, + value: '' + }); + + _this6.score = new _common.CMIScore({ + score_children: scorm12_constants.score_children, + score_range: scorm12_regex.score_range, + invalidErrorCode: scorm12_error_codes.INVALID_SET_VALUE, + invalidTypeCode: scorm12_error_codes.TYPE_MISMATCH, + invalidRangeCode: scorm12_error_codes.VALUE_OUT_OF_RANGE, + errorClass: _exceptions.Scorm12ValidationError + }); + return _this6; + } + + _createClass(CMIObjectivesObject, [{ + key: "id", + get: + /** + * Getter for #id + * @return {""} + */ + function get() { + return _classPrivateFieldGet(this, _id2); + } + /** + * Setter for #id + * @param {string} id + */ + , + set: function set(id) { + if (check12ValidFormat(id, scorm12_regex.CMIIdentifier)) { + _classPrivateFieldSet(this, _id2, id); + } + } + /** + * Getter for #status + * @return {""} + */ + + }, { + key: "status", + get: function get() { + return _classPrivateFieldGet(this, _status); + } + /** + * Setter for #status + * @param {string} status + */ + , + set: function set(status) { + if (check12ValidFormat(status, scorm12_regex.CMIStatus2)) { + _classPrivateFieldSet(this, _status, status); + } + } + /** + * toJSON for cmi.objectives.n + * @return { + * { + * id: string, + * status: string, + * score: CMIScore + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'id': this.id, + 'status': this.status, + 'score': this.score + }; + delete this.jsonString; + return result; + } + }]); + + return CMIObjectivesObject; +}(_common.BaseCMI); +/** + * Class representing SCORM 1.2's cmi.interactions.n.objectives.n object + * @extends BaseCMI + */ + + +exports.CMIObjectivesObject = CMIObjectivesObject; + +var _id3 = new WeakMap(); + +var CMIInteractionsObjectivesObject = /*#__PURE__*/function (_BaseCMI7) { + _inherits(CMIInteractionsObjectivesObject, _BaseCMI7); + + var _super9 = _createSuper(CMIInteractionsObjectivesObject); + + /** + * Constructor for cmi.interactions.n.objectives.n + */ + function CMIInteractionsObjectivesObject() { + var _this7; + + _classCallCheck(this, CMIInteractionsObjectivesObject); + + _this7 = _super9.call(this); + + _id3.set(_assertThisInitialized(_this7), { + writable: true, + value: '' + }); + + return _this7; + } + + _createClass(CMIInteractionsObjectivesObject, [{ + key: "id", + get: + /** + * Getter for #id + * @return {""} + */ + function get() { + return _classPrivateFieldGet(this, _id3); + } + /** + * Setter for #id + * @param {string} id + */ + , + set: function set(id) { + if (check12ValidFormat(id, scorm12_regex.CMIIdentifier)) { + _classPrivateFieldSet(this, _id3, id); + } + } + /** + * toJSON for cmi.interactions.n.objectives.n + * @return { + * { + * id: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'id': this.id + }; + delete this.jsonString; + return result; + } + }]); + + return CMIInteractionsObjectivesObject; +}(_common.BaseCMI); +/** + * Class representing SCORM 1.2's cmi.interactions.correct_responses.n object + * @extends BaseCMI + */ + + +exports.CMIInteractionsObjectivesObject = CMIInteractionsObjectivesObject; + +var _pattern = new WeakMap(); + +var CMIInteractionsCorrectResponsesObject = /*#__PURE__*/function (_BaseCMI8) { + _inherits(CMIInteractionsCorrectResponsesObject, _BaseCMI8); + + var _super10 = _createSuper(CMIInteractionsCorrectResponsesObject); + + /** + * Constructor for cmi.interactions.correct_responses.n + */ + function CMIInteractionsCorrectResponsesObject() { + var _this8; + + _classCallCheck(this, CMIInteractionsCorrectResponsesObject); + + _this8 = _super10.call(this); + + _pattern.set(_assertThisInitialized(_this8), { + writable: true, + value: '' + }); + + return _this8; + } + + _createClass(CMIInteractionsCorrectResponsesObject, [{ + key: "pattern", + get: + /** + * Getter for #pattern + * @return {string} + */ + function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _pattern); + } + /** + * Setter for #pattern + * @param {string} pattern + */ + , + set: function set(pattern) { + if (check12ValidFormat(pattern, scorm12_regex.CMIFeedback, true)) { + _classPrivateFieldSet(this, _pattern, pattern); + } + } + /** + * toJSON for cmi.interactions.correct_responses.n + * @return { + * { + * pattern: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'pattern': this.pattern + }; + delete this.jsonString; + return result; + } + }]); + + return CMIInteractionsCorrectResponsesObject; +}(_common.BaseCMI); +/** + * Class for AICC Navigation object + */ + + +exports.CMIInteractionsCorrectResponsesObject = CMIInteractionsCorrectResponsesObject; + +var _event = new WeakMap(); + +var NAV = /*#__PURE__*/function (_BaseCMI9) { + _inherits(NAV, _BaseCMI9); + + var _super11 = _createSuper(NAV); + + /** + * Constructor for NAV object + */ + function NAV() { + var _this9; + + _classCallCheck(this, NAV); + + _this9 = _super11.call(this); + + _event.set(_assertThisInitialized(_this9), { + writable: true, + value: '' + }); + + return _this9; + } + + _createClass(NAV, [{ + key: "event", + get: + /** + * Getter for #event + * @return {string} + */ + function get() { + return _classPrivateFieldGet(this, _event); + } + /** + * Setter for #event + * @param {string} event + */ + , + set: function set(event) { + if (check12ValidFormat(event, scorm12_regex.NAVEvent)) { + _classPrivateFieldSet(this, _event, event); + } + } + /** + * toJSON for nav object + * @return { + * { + * event: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'event': this.event + }; + delete this.jsonString; + return result; + } + }]); + + return NAV; +}(_common.BaseCMI); + +exports.NAV = NAV; + +},{"../constants/api_constants":8,"../constants/error_codes":9,"../constants/regex":10,"../exceptions":11,"../utilities":13,"./common":6}],8:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var global = { + SCORM_TRUE: 'true', + SCORM_FALSE: 'false', + STATE_NOT_INITIALIZED: 0, + STATE_INITIALIZED: 1, + STATE_TERMINATED: 2, + LOG_LEVEL_DEBUG: 1, + LOG_LEVEL_INFO: 2, + LOG_LEVEL_WARNING: 3, + LOG_LEVEL_ERROR: 4, + LOG_LEVEL_NONE: 5 +}; +var scorm12 = { + // Children lists + cmi_children: 'core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions', + core_children: 'student_id,student_name,lesson_location,credit,lesson_status,entry,score,total_time,lesson_mode,exit,session_time', + score_children: 'raw,min,max', + comments_children: 'content,location,time', + objectives_children: 'id,score,status', + correct_responses_children: 'pattern', + student_data_children: 'mastery_score,max_time_allowed,time_limit_action', + student_preference_children: 'audio,language,speed,text', + interactions_children: 'id,objectives,time,type,correct_responses,weighting,student_response,result,latency', + error_descriptions: { + '101': { + basicMessage: 'General Exception', + detailMessage: 'No specific error code exists to describe the error. Use LMSGetDiagnostic for more information' + }, + '201': { + basicMessage: 'Invalid argument error', + detailMessage: 'Indicates that an argument represents an invalid data model element or is otherwise incorrect.' + }, + '202': { + basicMessage: 'Element cannot have children', + detailMessage: 'Indicates that LMSGetValue was called with a data model element name that ends in "_children" for a data model element that does not support the "_children" suffix.' + }, + '203': { + basicMessage: 'Element not an array - cannot have count', + detailMessage: 'Indicates that LMSGetValue was called with a data model element name that ends in "_count" for a data model element that does not support the "_count" suffix.' + }, + '301': { + basicMessage: 'Not initialized', + detailMessage: 'Indicates that an API call was made before the call to lmsInitialize.' + }, + '401': { + basicMessage: 'Not implemented error', + detailMessage: 'The data model element indicated in a call to LMSGetValue or LMSSetValue is valid, but was not implemented by this LMS. SCORM 1.2 defines a set of data model elements as being optional for an LMS to implement.' + }, + '402': { + basicMessage: 'Invalid set value, element is a keyword', + detailMessage: 'Indicates that LMSSetValue was called on a data model element that represents a keyword (elements that end in "_children" and "_count").' + }, + '403': { + basicMessage: 'Element is read only', + detailMessage: 'LMSSetValue was called with a data model element that can only be read.' + }, + '404': { + basicMessage: 'Element is write only', + detailMessage: 'LMSGetValue was called on a data model element that can only be written to.' + }, + '405': { + basicMessage: 'Incorrect Data Type', + detailMessage: 'LMSSetValue was called with a value that is not consistent with the data format of the supplied data model element.' + }, + '407': { + basicMessage: 'Element Value Out Of Range', + detailMessage: 'The numeric value supplied to a LMSSetValue call is outside of the numeric range allowed for the supplied data model element.' + }, + '408': { + basicMessage: 'Data Model Dependency Not Established', + detailMessage: 'Some data model elements cannot be set until another data model element was set. This error condition indicates that the prerequisite element was not set before the dependent element.' + } + } +}; + +var aicc = _objectSpread(_objectSpread({}, scorm12), { + cmi_children: 'core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions,evaluation', + student_preference_children: 'audio,language,lesson_type,speed,text,text_color,text_location,text_size,video,windows', + student_data_children: 'attempt_number,tries,mastery_score,max_time_allowed,time_limit_action', + student_demographics_children: 'city,class,company,country,experience,familiar_name,instructor_name,title,native_language,state,street_address,telephone,years_experience', + tries_children: 'time,status,score', + attempt_records_children: 'score,lesson_status', + paths_children: 'location_id,date,time,status,why_left,time_in_element' +}); + +var scorm2004 = { + // Children lists + cmi_children: '_version,comments_from_learner,comments_from_lms,completion_status,credit,entry,exit,interactions,launch_data,learner_id,learner_name,learner_preference,location,max_time_allowed,mode,objectives,progress_measure,scaled_passing_score,score,session_time,success_status,suspend_data,time_limit_action,total_time', + comments_children: 'comment,timestamp,location', + score_children: 'max,raw,scaled,min', + objectives_children: 'progress_measure,completion_status,success_status,description,score,id', + correct_responses_children: 'pattern', + student_data_children: 'mastery_score,max_time_allowed,time_limit_action', + student_preference_children: 'audio_level,audio_captioning,delivery_speed,language', + interactions_children: 'id,type,objectives,timestamp,correct_responses,weighting,learner_response,result,latency,description', + error_descriptions: { + '0': { + basicMessage: 'No Error', + detailMessage: 'No error occurred, the previous API call was successful.' + }, + '101': { + basicMessage: 'General Exception', + detailMessage: 'No specific error code exists to describe the error. Use GetDiagnostic for more information.' + }, + '102': { + basicMessage: 'General Initialization Failure', + detailMessage: 'Call to Initialize failed for an unknown reason.' + }, + '103': { + basicMessage: 'Already Initialized', + detailMessage: 'Call to Initialize failed because Initialize was already called.' + }, + '104': { + basicMessage: 'Content Instance Terminated', + detailMessage: 'Call to Initialize failed because Terminate was already called.' + }, + '111': { + basicMessage: 'General Termination Failure', + detailMessage: 'Call to Terminate failed for an unknown reason.' + }, + '112': { + basicMessage: 'Termination Before Initialization', + detailMessage: 'Call to Terminate failed because it was made before the call to Initialize.' + }, + '113': { + basicMessage: 'Termination After Termination', + detailMessage: 'Call to Terminate failed because Terminate was already called.' + }, + '122': { + basicMessage: 'Retrieve Data Before Initialization', + detailMessage: 'Call to GetValue failed because it was made before the call to Initialize.' + }, + '123': { + basicMessage: 'Retrieve Data After Termination', + detailMessage: 'Call to GetValue failed because it was made after the call to Terminate.' + }, + '132': { + basicMessage: 'Store Data Before Initialization', + detailMessage: 'Call to SetValue failed because it was made before the call to Initialize.' + }, + '133': { + basicMessage: 'Store Data After Termination', + detailMessage: 'Call to SetValue failed because it was made after the call to Terminate.' + }, + '142': { + basicMessage: 'Commit Before Initialization', + detailMessage: 'Call to Commit failed because it was made before the call to Initialize.' + }, + '143': { + basicMessage: 'Commit After Termination', + detailMessage: 'Call to Commit failed because it was made after the call to Terminate.' + }, + '201': { + basicMessage: 'General Argument Error', + detailMessage: 'An invalid argument was passed to an API method (usually indicates that Initialize, Commit or Terminate did not receive the expected empty string argument.' + }, + '301': { + basicMessage: 'General Get Failure', + detailMessage: 'Indicates a failed GetValue call where no other specific error code is applicable. Use GetDiagnostic for more information.' + }, + '351': { + basicMessage: 'General Set Failure', + detailMessage: 'Indicates a failed SetValue call where no other specific error code is applicable. Use GetDiagnostic for more information.' + }, + '391': { + basicMessage: 'General Commit Failure', + detailMessage: 'Indicates a failed Commit call where no other specific error code is applicable. Use GetDiagnostic for more information.' + }, + '401': { + basicMessage: 'Undefined Data Model Element', + detailMessage: 'The data model element name passed to GetValue or SetValue is not a valid SCORM data model element.' + }, + '402': { + basicMessage: 'Unimplemented Data Model Element', + detailMessage: 'The data model element indicated in a call to GetValue or SetValue is valid, but was not implemented by this LMS. In SCORM 2004, this error would indicate an LMS that is not fully SCORM conformant.' + }, + '403': { + basicMessage: 'Data Model Element Value Not Initialized', + detailMessage: 'Attempt to read a data model element that has not been initialized by the LMS or through a SetValue call. This error condition is often reached during normal execution of a SCO.' + }, + '404': { + basicMessage: 'Data Model Element Is Read Only', + detailMessage: 'SetValue was called with a data model element that can only be read.' + }, + '405': { + basicMessage: 'Data Model Element Is Write Only', + detailMessage: 'GetValue was called on a data model element that can only be written to.' + }, + '406': { + basicMessage: 'Data Model Element Type Mismatch', + detailMessage: 'SetValue was called with a value that is not consistent with the data format of the supplied data model element.' + }, + '407': { + basicMessage: 'Data Model Element Value Out Of Range', + detailMessage: 'The numeric value supplied to a SetValue call is outside of the numeric range allowed for the supplied data model element.' + }, + '408': { + basicMessage: 'Data Model Dependency Not Established', + detailMessage: 'Some data model elements cannot be set until another data model element was set. This error condition indicates that the prerequisite element was not set before the dependent element.' + } + } +}; +var APIConstants = { + global: global, + scorm12: scorm12, + aicc: aicc, + scorm2004: scorm2004 +}; +var _default = APIConstants; +exports["default"] = _default; + +},{}],9:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var global = { + GENERAL: 101, + INITIALIZATION_FAILED: 101, + INITIALIZED: 101, + TERMINATED: 101, + TERMINATION_FAILURE: 101, + TERMINATION_BEFORE_INIT: 101, + MULTIPLE_TERMINATION: 101, + RETRIEVE_BEFORE_INIT: 101, + RETRIEVE_AFTER_TERM: 101, + STORE_BEFORE_INIT: 101, + STORE_AFTER_TERM: 101, + COMMIT_BEFORE_INIT: 101, + COMMIT_AFTER_TERM: 101, + ARGUMENT_ERROR: 101, + CHILDREN_ERROR: 101, + COUNT_ERROR: 101, + GENERAL_GET_FAILURE: 101, + GENERAL_SET_FAILURE: 101, + GENERAL_COMMIT_FAILURE: 101, + UNDEFINED_DATA_MODEL: 101, + UNIMPLEMENTED_ELEMENT: 101, + VALUE_NOT_INITIALIZED: 101, + INVALID_SET_VALUE: 101, + READ_ONLY_ELEMENT: 101, + WRITE_ONLY_ELEMENT: 101, + TYPE_MISMATCH: 101, + VALUE_OUT_OF_RANGE: 101, + DEPENDENCY_NOT_ESTABLISHED: 101 +}; + +var scorm12 = _objectSpread(_objectSpread({}, global), { + RETRIEVE_BEFORE_INIT: 301, + STORE_BEFORE_INIT: 301, + COMMIT_BEFORE_INIT: 301, + ARGUMENT_ERROR: 201, + CHILDREN_ERROR: 202, + COUNT_ERROR: 203, + UNDEFINED_DATA_MODEL: 401, + UNIMPLEMENTED_ELEMENT: 401, + VALUE_NOT_INITIALIZED: 301, + INVALID_SET_VALUE: 402, + READ_ONLY_ELEMENT: 403, + WRITE_ONLY_ELEMENT: 404, + TYPE_MISMATCH: 405, + VALUE_OUT_OF_RANGE: 407, + DEPENDENCY_NOT_ESTABLISHED: 408 +}); + +var scorm2004 = _objectSpread(_objectSpread({}, global), { + INITIALIZATION_FAILED: 102, + INITIALIZED: 103, + TERMINATED: 104, + TERMINATION_FAILURE: 111, + TERMINATION_BEFORE_INIT: 112, + MULTIPLE_TERMINATIONS: 113, + RETRIEVE_BEFORE_INIT: 122, + RETRIEVE_AFTER_TERM: 123, + STORE_BEFORE_INIT: 132, + STORE_AFTER_TERM: 133, + COMMIT_BEFORE_INIT: 142, + COMMIT_AFTER_TERM: 143, + ARGUMENT_ERROR: 201, + GENERAL_GET_FAILURE: 301, + GENERAL_SET_FAILURE: 351, + GENERAL_COMMIT_FAILURE: 391, + UNDEFINED_DATA_MODEL: 401, + UNIMPLEMENTED_ELEMENT: 402, + VALUE_NOT_INITIALIZED: 403, + READ_ONLY_ELEMENT: 404, + WRITE_ONLY_ELEMENT: 405, + TYPE_MISMATCH: 406, + VALUE_OUT_OF_RANGE: 407, + DEPENDENCY_NOT_ESTABLISHED: 408 +}); + +var ErrorCodes = { + scorm12: scorm12, + scorm2004: scorm2004 +}; +var _default = ErrorCodes; +exports["default"] = _default; + +},{}],10:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var scorm12 = { + CMIString256: '^.{0,255}$', + CMIString4096: '^.{0,4096}$', + CMITime: '^(?:[01]\\d|2[0123]):(?:[012345]\\d):(?:[012345]\\d)$', + // eslint-disable-line + CMITimespan: '^([0-9]{2,}):([0-9]{2}):([0-9]{2})(\.[0-9]{1,2})?$', + // eslint-disable-line + CMIInteger: '^\\d+$', + CMISInteger: '^-?([0-9]+)$', + CMIDecimal: '^-?([0-9]{0,3})(\.[0-9]*)?$', + // eslint-disable-line + CMIIdentifier: "^[\\u0021-\\u007E\\s]{0,255}$", + CMIFeedback: '^.{0,255}$', + // This must be redefined + CMIIndex: '[._](\\d+).', + // Vocabulary Data Type Definition + CMIStatus: '^(passed|completed|failed|incomplete|browsed)$', + CMIStatus2: '^(passed|completed|failed|incomplete|browsed|not attempted)$', + CMIExit: '^(time-out|suspend|logout|)$', + CMIType: '^(true-false|choice|fill-in|matching|performance|sequencing|likert|numeric)$', + CMIResult: '^(correct|wrong|unanticipated|neutral|([0-9]{0,3})?(\\.[0-9]*)?)$', + // eslint-disable-line + NAVEvent: '^(previous|continue)$', + // Data ranges + score_range: '0#100', + audio_range: '-1#100', + speed_range: '-100#100', + weighting_range: '-100#100', + text_range: '-1#1' +}; + +var aicc = _objectSpread(_objectSpread({}, scorm12), { + CMIIdentifier: '^\\w{1,255}$' +}); + +var scorm2004 = { + CMIString200: "^[\\u0000-\\uFFFF]{0,200}$", + CMIString250: "^[\\u0000-\\uFFFF]{0,250}$", + CMIString1000: "^[\\u0000-\\uFFFF]{0,1000}$", + CMIString4000: "^[\\u0000-\\uFFFF]{0,4000}$", + CMIString64000: "^[\\u0000-\\uFFFF]{0,64000}$", + CMILang: '^([a-zA-Z]{2,3}|i|x)(\-[a-zA-Z0-9\-]{2,8})?$|^$', + // eslint-disable-line + CMILangString250: '^(\{lang=([a-zA-Z]{2,3}|i|x)(\-[a-zA-Z0-9\-]{2,8})?\})?((?!\{.*$).{0,250}$)?$', + // eslint-disable-line + CMILangcr: '^((\{lang=([a-zA-Z]{2,3}|i|x)?(\-[a-zA-Z0-9\-]{2,8})?\}))(.*?)$', + // eslint-disable-line + CMILangString250cr: '^((\{lang=([a-zA-Z]{2,3}|i|x)?(\-[a-zA-Z0-9\-]{2,8})?\})?(.{0,250})?)?$', + // eslint-disable-line + CMILangString4000: '^(\{lang=([a-zA-Z]{2,3}|i|x)(\-[a-zA-Z0-9\-]{2,8})?\})?((?!\{.*$).{0,4000}$)?$', + // eslint-disable-line + CMITime: '^(19[7-9]{1}[0-9]{1}|20[0-2]{1}[0-9]{1}|203[0-8]{1})((-(0[1-9]{1}|1[0-2]{1}))((-(0[1-9]{1}|[1-2]{1}[0-9]{1}|3[0-1]{1}))(T([0-1]{1}[0-9]{1}|2[0-3]{1})((:[0-5]{1}[0-9]{1})((:[0-5]{1}[0-9]{1})((\\.[0-9]{1,2})((Z|([+|-]([0-1]{1}[0-9]{1}|2[0-3]{1})))(:[0-5]{1}[0-9]{1})?)?)?)?)?)?)?)?$', + CMITimespan: '^P(?:([.,\\d]+)Y)?(?:([.,\\d]+)M)?(?:([.,\\d]+)W)?(?:([.,\\d]+)D)?(?:T?(?:([.,\\d]+)H)?(?:([.,\\d]+)M)?(?:([.,\\d]+)S)?)?$', + CMIInteger: '^\\d+$', + CMISInteger: '^-?([0-9]+)$', + CMIDecimal: '^-?([0-9]{1,5})(\\.[0-9]{1,18})?$', + CMIIdentifier: '^\\S{1,250}[a-zA-Z0-9]$', + CMIShortIdentifier: '^[\\w\\.\\-\\_]{1,250}$', + // eslint-disable-line + CMILongIdentifier: '^(?:(?!urn:)\\S{1,4000}|urn:[A-Za-z0-9-]{1,31}:\\S{1,4000}|.{1,4000})$', + // need to re-examine this + CMIFeedback: '^.*$', + // This must be redefined + CMIIndex: '[._](\\d+).', + CMIIndexStore: '.N(\\d+).', + // Vocabulary Data Type Definition + CMICStatus: '^(completed|incomplete|not attempted|unknown)$', + CMISStatus: '^(passed|failed|unknown)$', + CMIExit: '^(time-out|suspend|logout|normal)$', + CMIType: '^(true-false|choice|fill-in|long-fill-in|matching|performance|sequencing|likert|numeric|other)$', + CMIResult: '^(correct|incorrect|unanticipated|neutral|-?([0-9]{1,4})(\\.[0-9]{1,18})?)$', + NAVEvent: '^(previous|continue|exit|exitAll|abandon|abandonAll|suspendAll|\{target=\\S{0,200}[a-zA-Z0-9]\}choice|jump)$', + // eslint-disable-line + NAVBoolean: '^(unknown|true|false$)', + NAVTarget: '^(previous|continue|choice.{target=\\S{0,200}[a-zA-Z0-9]})$', + // Data ranges + scaled_range: '-1#1', + audio_range: '0#*', + speed_range: '0#*', + text_range: '-1#1', + progress_range: '0#1' +}; +var Regex = { + aicc: aicc, + scorm12: scorm12, + scorm2004: scorm2004 +}; +var _default = Regex; +exports["default"] = _default; + +},{}],11:[function(require,module,exports){ +"use strict"; + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.Scorm2004ValidationError = exports.AICCValidationError = exports.Scorm12ValidationError = exports.ValidationError = void 0; + +var _api_constants = _interopRequireDefault(require("./constants/api_constants")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); } + +function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); } + +function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; } + +function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); } + +function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } } + +var scorm12_errors = _api_constants["default"].scorm12.error_descriptions; +var aicc_errors = _api_constants["default"].aicc.error_descriptions; +var scorm2004_errors = _api_constants["default"].scorm2004.error_descriptions; +/** + * Base Validation Exception + */ + +var _errorCode = new WeakMap(); + +var _errorMessage = new WeakMap(); + +var _detailedMessage = new WeakMap(); + +var ValidationError = /*#__PURE__*/function (_Error) { + _inherits(ValidationError, _Error); + + var _super = _createSuper(ValidationError); + + /** + * Constructor to take in an error message and code + * @param {number} errorCode + * @param {string} errorMessage + * @param {string} detailedMessage + */ + function ValidationError(errorCode, errorMessage, detailedMessage) { + var _this; + + _classCallCheck(this, ValidationError); + + _this = _super.call(this, errorMessage); + + _errorCode.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _errorMessage.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _detailedMessage.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _classPrivateFieldSet(_assertThisInitialized(_this), _errorCode, errorCode); + + _classPrivateFieldSet(_assertThisInitialized(_this), _errorMessage, errorMessage); + + _classPrivateFieldSet(_assertThisInitialized(_this), _detailedMessage, detailedMessage); + + return _this; + } + + _createClass(ValidationError, [{ + key: "errorCode", + get: + /** + * Getter for #errorCode + * @return {number} + */ + function get() { + return _classPrivateFieldGet(this, _errorCode); + } + /** + * Getter for #errorMessage + * @return {string} + */ + + }, { + key: "errorMessage", + get: function get() { + return _classPrivateFieldGet(this, _errorMessage); + } + /** + * Getter for #detailedMessage + * @return {string} + */ + + }, { + key: "detailedMessage", + get: function get() { + return _classPrivateFieldGet(this, _detailedMessage); + } + }]); + + return ValidationError; +}( /*#__PURE__*/_wrapNativeSuper(Error)); +/** + * SCORM 1.2 Validation Error + */ + + +exports.ValidationError = ValidationError; + +var Scorm12ValidationError = /*#__PURE__*/function (_ValidationError) { + _inherits(Scorm12ValidationError, _ValidationError); + + var _super2 = _createSuper(Scorm12ValidationError); + + /** + * Constructor to take in an error code + * @param {number} errorCode + */ + function Scorm12ValidationError(errorCode) { + var _this2; + + _classCallCheck(this, Scorm12ValidationError); + + if ({}.hasOwnProperty.call(scorm12_errors, String(errorCode))) { + _this2 = _super2.call(this, errorCode, scorm12_errors[String(errorCode)].basicMessage, scorm12_errors[String(errorCode)].detailMessage); + } else { + _this2 = _super2.call(this, 101, scorm12_errors['101'].basicMessage, scorm12_errors['101'].detailMessage); + } + + return _possibleConstructorReturn(_this2); + } + + return Scorm12ValidationError; +}(ValidationError); +/** + * AICC Validation Error + */ + + +exports.Scorm12ValidationError = Scorm12ValidationError; + +var AICCValidationError = /*#__PURE__*/function (_ValidationError2) { + _inherits(AICCValidationError, _ValidationError2); + + var _super3 = _createSuper(AICCValidationError); + + /** + * Constructor to take in an error code + * @param {number} errorCode + */ + function AICCValidationError(errorCode) { + var _this3; + + _classCallCheck(this, AICCValidationError); + + if ({}.hasOwnProperty.call(aicc_errors, String(errorCode))) { + _this3 = _super3.call(this, errorCode, aicc_errors[String(errorCode)].basicMessage, aicc_errors[String(errorCode)].detailMessage); + } else { + _this3 = _super3.call(this, 101, aicc_errors['101'].basicMessage, aicc_errors['101'].detailMessage); + } + + return _possibleConstructorReturn(_this3); + } + + return AICCValidationError; +}(ValidationError); +/** + * SCORM 2004 Validation Error + */ + + +exports.AICCValidationError = AICCValidationError; + +var Scorm2004ValidationError = /*#__PURE__*/function (_ValidationError3) { + _inherits(Scorm2004ValidationError, _ValidationError3); + + var _super4 = _createSuper(Scorm2004ValidationError); + + /** + * Constructor to take in an error code + * @param {number} errorCode + */ + function Scorm2004ValidationError(errorCode) { + var _this4; + + _classCallCheck(this, Scorm2004ValidationError); + + if ({}.hasOwnProperty.call(scorm2004_errors, String(errorCode))) { + _this4 = _super4.call(this, errorCode, scorm2004_errors[String(errorCode)].basicMessage, scorm2004_errors[String(errorCode)].detailMessage); + } else { + _this4 = _super4.call(this, 101, scorm2004_errors['101'].basicMessage, scorm2004_errors['101'].detailMessage); + } + + return _possibleConstructorReturn(_this4); + } + + return Scorm2004ValidationError; +}(ValidationError); + +exports.Scorm2004ValidationError = Scorm2004ValidationError; + +},{"./constants/api_constants":8}],12:[function(require,module,exports){ +"use strict"; + +var _AICC = _interopRequireDefault(require("../AICC")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +window.AICC = _AICC["default"]; + +},{"../AICC":2}],13:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.getSecondsAsHHMMSS = getSecondsAsHHMMSS; +exports.getSecondsAsISODuration = getSecondsAsISODuration; +exports.getTimeAsSeconds = getTimeAsSeconds; +exports.getDurationAsSeconds = getDurationAsSeconds; +exports.addTwoDurations = addTwoDurations; +exports.addHHMMSSTimeStrings = addHHMMSSTimeStrings; +exports.flatten = flatten; +exports.unflatten = unflatten; +exports.countDecimals = countDecimals; +exports.SECONDS_PER_DAY = exports.SECONDS_PER_HOUR = exports.SECONDS_PER_MINUTE = exports.SECONDS_PER_SECOND = void 0; + +function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); } + +function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } + +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit(arr, i) { var _i = arr && (typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]); if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } + +var SECONDS_PER_SECOND = 1.0; +exports.SECONDS_PER_SECOND = SECONDS_PER_SECOND; +var SECONDS_PER_MINUTE = 60; +exports.SECONDS_PER_MINUTE = SECONDS_PER_MINUTE; +var SECONDS_PER_HOUR = 60 * SECONDS_PER_MINUTE; +exports.SECONDS_PER_HOUR = SECONDS_PER_HOUR; +var SECONDS_PER_DAY = 24 * SECONDS_PER_HOUR; +exports.SECONDS_PER_DAY = SECONDS_PER_DAY; +var designations = [['D', SECONDS_PER_DAY], ['H', SECONDS_PER_HOUR], ['M', SECONDS_PER_MINUTE], ['S', SECONDS_PER_SECOND]]; +/** + * Converts a Number to a String of HH:MM:SS + * + * @param {Number} totalSeconds + * @return {string} + */ + +function getSecondsAsHHMMSS(totalSeconds) { + // SCORM spec does not deal with negative durations, give zero back + if (!totalSeconds || totalSeconds <= 0) { + return '00:00:00'; + } + + var hours = Math.floor(totalSeconds / SECONDS_PER_HOUR); + var dateObj = new Date(totalSeconds * 1000); + var minutes = dateObj.getUTCMinutes(); // make sure we add any possible decimal value + + var seconds = dateObj.getSeconds(); + var ms = totalSeconds % 1.0; + var msStr = ''; + + if (countDecimals(ms) > 0) { + if (countDecimals(ms) > 2) { + msStr = ms.toFixed(2); + } else { + msStr = String(ms); + } + + msStr = '.' + msStr.split('.')[1]; + } + + return (hours + ':' + minutes + ':' + seconds).replace(/\b\d\b/g, '0$&') + msStr; +} +/** + * Calculate the number of seconds from ISO 8601 Duration + * + * @param {Number} seconds + * @return {String} + */ + + +function getSecondsAsISODuration(seconds) { + // SCORM spec does not deal with negative durations, give zero back + if (!seconds || seconds <= 0) { + return 'PT0S'; + } + + var duration = 'P'; + var remainder = seconds; + designations.forEach(function (_ref) { + var _ref2 = _slicedToArray(_ref, 2), + sign = _ref2[0], + current_seconds = _ref2[1]; + + var value = Math.floor(remainder / current_seconds); + remainder = remainder % current_seconds; + + if (countDecimals(remainder) > 2) { + remainder = Number(Number(remainder).toFixed(2)); + } // If we have anything left in the remainder, and we're currently adding + // seconds to the duration, go ahead and add the decimal to the seconds + + + if (sign === 'S' && remainder > 0) { + value += remainder; + } + + if (value) { + if ((duration.indexOf('D') > 0 || sign === 'H' || sign === 'M' || sign === 'S') && duration.indexOf('T') === -1) { + duration += 'T'; + } + + duration += "".concat(value).concat(sign); + } + }); + return duration; +} +/** + * Calculate the number of seconds from HH:MM:SS.DDDDDD + * + * @param {string} timeString + * @param {RegExp} timeRegex + * @return {number} + */ + + +function getTimeAsSeconds(timeString, timeRegex) { + if (!timeString || typeof timeString !== 'string' || !timeString.match(timeRegex)) { + return 0; + } + + var parts = timeString.split(':'); + var hours = Number(parts[0]); + var minutes = Number(parts[1]); + var seconds = Number(parts[2]); + return hours * 3600 + minutes * 60 + seconds; +} +/** + * Calculate the number of seconds from ISO 8601 Duration + * + * @param {string} duration + * @param {RegExp} durationRegex + * @return {number} + */ + + +function getDurationAsSeconds(duration, durationRegex) { + if (!duration || !duration.match(durationRegex)) { + return 0; + } + + var _ref3 = new RegExp(durationRegex).exec(duration) || [], + _ref4 = _slicedToArray(_ref3, 8), + years = _ref4[1], + months = _ref4[2], + days = _ref4[4], + hours = _ref4[5], + minutes = _ref4[6], + seconds = _ref4[7]; + + var result = 0.0; + result += Number(seconds) * 1.0 || 0.0; + result += Number(minutes) * 60.0 || 0.0; + result += Number(hours) * 3600.0 || 0.0; + result += Number(days) * (60 * 60 * 24.0) || 0.0; + result += Number(years) * (60 * 60 * 24 * 365.0) || 0.0; + return result; +} +/** + * Adds together two ISO8601 Duration strings + * + * @param {string} first + * @param {string} second + * @param {RegExp} durationRegex + * @return {string} + */ + + +function addTwoDurations(first, second, durationRegex) { + return getSecondsAsISODuration(getDurationAsSeconds(first, durationRegex) + getDurationAsSeconds(second, durationRegex)); +} +/** + * Add together two HH:MM:SS.DD strings + * + * @param {string} first + * @param {string} second + * @param {RegExp} timeRegex + * @return {string} + */ + + +function addHHMMSSTimeStrings(first, second, timeRegex) { + return getSecondsAsHHMMSS(getTimeAsSeconds(first, timeRegex) + getTimeAsSeconds(second, timeRegex)); +} +/** + * Flatten a JSON object down to string paths for each values + * @param {object} data + * @return {object} + */ + + +function flatten(data) { + var result = {}; + /** + * Recurse through the object + * @param {*} cur + * @param {*} prop + */ + + function recurse(cur, prop) { + if (Object(cur) !== cur) { + result[prop] = cur; + } else if (Array.isArray(cur)) { + for (var i = 0, l = cur.length; i < l; i++) { + recurse(cur[i], prop + '[' + i + ']'); + if (l === 0) result[prop] = []; + } + } else { + var isEmpty = true; + + for (var p in cur) { + if ({}.hasOwnProperty.call(cur, p)) { + isEmpty = false; + recurse(cur[p], prop ? prop + '.' + p : p); + } + } + + if (isEmpty && prop) result[prop] = {}; + } + } + + recurse(data, ''); + return result; +} +/** + * Un-flatten a flat JSON object + * @param {object} data + * @return {object} + */ + + +function unflatten(data) { + 'use strict'; + + if (Object(data) !== data || Array.isArray(data)) return data; + var regex = /\.?([^.[\]]+)|\[(\d+)]/g; + var result = {}; + + for (var p in data) { + if ({}.hasOwnProperty.call(data, p)) { + var cur = result; + var prop = ''; + var m = regex.exec(p); + + while (m) { + cur = cur[prop] || (cur[prop] = m[2] ? [] : {}); + prop = m[2] || m[1]; + m = regex.exec(p); + } + + cur[prop] = data[p]; + } + } + + return result[''] || result; +} +/** + * Counts the number of decimal places + * @param {number} num + * @return {number} + */ + + +function countDecimals(num) { + if (Math.floor(num) === num || String(num).indexOf('.') < 0) return 0; + var parts = num.toString().split('.')[1]; + return parts.length || 0; +} + +},{}]},{},[12]); diff --git a/dist/scorm-again.js b/dist/scorm-again.js index 024c672..c5f84dc 100644 --- a/dist/scorm-again.js +++ b/dist/scorm-again.js @@ -566,11 +566,11 @@ var scorm12_error_codes = _error_codes2["default"].scorm12; * abstract, and never initialized on it's own. */ -var _timeout = /*#__PURE__*/new WeakMap(); +var _timeout = new WeakMap(); -var _error_codes = /*#__PURE__*/new WeakMap(); +var _error_codes = new WeakMap(); -var _settings = /*#__PURE__*/new WeakMap(); +var _settings = new WeakMap(); var BaseAPI = /*#__PURE__*/function () { /** @@ -1844,13 +1844,13 @@ var BaseAPI = /*#__PURE__*/function () { exports["default"] = BaseAPI; -var _API = /*#__PURE__*/new WeakMap(); +var _API = new WeakMap(); -var _cancelled = /*#__PURE__*/new WeakMap(); +var _cancelled = new WeakMap(); -var _timeout2 = /*#__PURE__*/new WeakMap(); +var _timeout2 = new WeakMap(); -var _callback = /*#__PURE__*/new WeakMap(); +var _callback = new WeakMap(); var ScheduledCommit = /*#__PURE__*/function () { /** @@ -2383,7 +2383,7 @@ var scorm2004_regex = _regex["default"].scorm2004; * API class for SCORM 2004 */ -var _version = /*#__PURE__*/new WeakMap(); +var _version = new WeakMap(); var Scorm2004API = /*#__PURE__*/function (_BaseAPI) { _inherits(Scorm2004API, _BaseAPI); @@ -3256,15 +3256,15 @@ var CMIEvaluationComments = /*#__PURE__*/function (_CMIArray) { */ -var _lesson_type = /*#__PURE__*/new WeakMap(); +var _lesson_type = new WeakMap(); -var _text_color = /*#__PURE__*/new WeakMap(); +var _text_color = new WeakMap(); -var _text_location = /*#__PURE__*/new WeakMap(); +var _text_location = new WeakMap(); -var _text_size = /*#__PURE__*/new WeakMap(); +var _text_size = new WeakMap(); -var _video = /*#__PURE__*/new WeakMap(); +var _video = new WeakMap(); var AICCStudentPreferences = /*#__PURE__*/function (_Scorm12CMI$CMIStuden) { _inherits(AICCStudentPreferences, _Scorm12CMI$CMIStuden); @@ -3468,7 +3468,7 @@ var AICCStudentPreferences = /*#__PURE__*/function (_Scorm12CMI$CMIStuden) { */ -var _tries_during_lesson = /*#__PURE__*/new WeakMap(); +var _tries_during_lesson = new WeakMap(); var AICCCMIStudentData = /*#__PURE__*/function (_Scorm12CMI$CMIStuden2) { _inherits(AICCCMIStudentData, _Scorm12CMI$CMIStuden2); @@ -3560,33 +3560,33 @@ var AICCCMIStudentData = /*#__PURE__*/function (_Scorm12CMI$CMIStuden2) { */ -var _children = /*#__PURE__*/new WeakMap(); +var _children = new WeakMap(); -var _city = /*#__PURE__*/new WeakMap(); +var _city = new WeakMap(); -var _class = /*#__PURE__*/new WeakMap(); +var _class = new WeakMap(); -var _company = /*#__PURE__*/new WeakMap(); +var _company = new WeakMap(); -var _country = /*#__PURE__*/new WeakMap(); +var _country = new WeakMap(); -var _experience = /*#__PURE__*/new WeakMap(); +var _experience = new WeakMap(); -var _familiar_name = /*#__PURE__*/new WeakMap(); +var _familiar_name = new WeakMap(); -var _instructor_name = /*#__PURE__*/new WeakMap(); +var _instructor_name = new WeakMap(); -var _title = /*#__PURE__*/new WeakMap(); +var _title = new WeakMap(); -var _native_language = /*#__PURE__*/new WeakMap(); +var _native_language = new WeakMap(); -var _state = /*#__PURE__*/new WeakMap(); +var _state = new WeakMap(); -var _street_address = /*#__PURE__*/new WeakMap(); +var _street_address = new WeakMap(); -var _telephone = /*#__PURE__*/new WeakMap(); +var _telephone = new WeakMap(); -var _years_experience = /*#__PURE__*/new WeakMap(); +var _years_experience = new WeakMap(); var CMIStudentDemographics = /*#__PURE__*/function (_BaseCMI2) { _inherits(CMIStudentDemographics, _BaseCMI2); @@ -4012,17 +4012,17 @@ var CMIPaths = /*#__PURE__*/function (_CMIArray2) { exports.CMIPaths = CMIPaths; -var _location_id = /*#__PURE__*/new WeakMap(); +var _location_id = new WeakMap(); -var _date = /*#__PURE__*/new WeakMap(); +var _date = new WeakMap(); -var _time = /*#__PURE__*/new WeakMap(); +var _time = new WeakMap(); -var _status = /*#__PURE__*/new WeakMap(); +var _status = new WeakMap(); -var _why_left = /*#__PURE__*/new WeakMap(); +var _why_left = new WeakMap(); -var _time_in_element = /*#__PURE__*/new WeakMap(); +var _time_in_element = new WeakMap(); var CMIPathsObject = /*#__PURE__*/function (_BaseCMI3) { _inherits(CMIPathsObject, _BaseCMI3); @@ -4257,9 +4257,9 @@ var CMITries = /*#__PURE__*/function (_CMIArray3) { exports.CMITries = CMITries; -var _status2 = /*#__PURE__*/new WeakMap(); +var _status2 = new WeakMap(); -var _time2 = /*#__PURE__*/new WeakMap(); +var _time2 = new WeakMap(); var CMITriesObject = /*#__PURE__*/function (_BaseCMI4) { _inherits(CMITriesObject, _BaseCMI4); @@ -4409,7 +4409,7 @@ var CMIAttemptRecords = /*#__PURE__*/function (_CMIArray4) { exports.CMIAttemptRecords = CMIAttemptRecords; -var _lesson_status = /*#__PURE__*/new WeakMap(); +var _lesson_status = new WeakMap(); var CMIAttemptRecordsObject = /*#__PURE__*/function (_BaseCMI5) { _inherits(CMIAttemptRecordsObject, _BaseCMI5); @@ -4508,11 +4508,11 @@ var CMIAttemptRecordsObject = /*#__PURE__*/function (_BaseCMI5) { exports.CMIAttemptRecordsObject = CMIAttemptRecordsObject; -var _content = /*#__PURE__*/new WeakMap(); +var _content = new WeakMap(); -var _location = /*#__PURE__*/new WeakMap(); +var _location = new WeakMap(); -var _time3 = /*#__PURE__*/new WeakMap(); +var _time3 = new WeakMap(); var CMIEvaluationCommentsObject = /*#__PURE__*/function (_BaseCMI6) { _inherits(CMIEvaluationCommentsObject, _BaseCMI6); @@ -4747,9 +4747,9 @@ function checkValidRange(value, rangePattern, errorCode, errorClass) { */ -var _initialized = /*#__PURE__*/new WeakMap(); +var _initialized = new WeakMap(); -var _start_time = /*#__PURE__*/new WeakMap(); +var _start_time = new WeakMap(); var BaseCMI = /*#__PURE__*/function () { /** @@ -4825,25 +4825,25 @@ var BaseCMI = /*#__PURE__*/function () { exports.BaseCMI = BaseCMI; -var _children2 = /*#__PURE__*/new WeakMap(); +var _children2 = new WeakMap(); -var _score_range = /*#__PURE__*/new WeakMap(); +var _score_range = new WeakMap(); -var _invalid_error_code = /*#__PURE__*/new WeakMap(); +var _invalid_error_code = new WeakMap(); -var _invalid_type_code = /*#__PURE__*/new WeakMap(); +var _invalid_type_code = new WeakMap(); -var _invalid_range_code = /*#__PURE__*/new WeakMap(); +var _invalid_range_code = new WeakMap(); -var _decimal_regex = /*#__PURE__*/new WeakMap(); +var _decimal_regex = new WeakMap(); -var _error_class = /*#__PURE__*/new WeakMap(); +var _error_class = new WeakMap(); -var _raw = /*#__PURE__*/new WeakMap(); +var _raw = new WeakMap(); -var _min = /*#__PURE__*/new WeakMap(); +var _min = new WeakMap(); -var _max = /*#__PURE__*/new WeakMap(); +var _max = new WeakMap(); var CMIScore = /*#__PURE__*/function (_BaseCMI) { _inherits(CMIScore, _BaseCMI); @@ -5054,11 +5054,11 @@ var CMIScore = /*#__PURE__*/function (_BaseCMI) { exports.CMIScore = CMIScore; -var _errorCode = /*#__PURE__*/new WeakMap(); +var _errorCode = new WeakMap(); -var _errorClass = /*#__PURE__*/new WeakMap(); +var _errorClass = new WeakMap(); -var _children3 = /*#__PURE__*/new WeakMap(); +var _children3 = new WeakMap(); var CMIArray = /*#__PURE__*/function (_BaseCMI2) { _inherits(CMIArray, _BaseCMI2); @@ -5293,15 +5293,15 @@ function check12ValidRange(value, rangePattern, allowEmptyString) { */ -var _children2 = /*#__PURE__*/new WeakMap(); +var _children2 = new WeakMap(); -var _version2 = /*#__PURE__*/new WeakMap(); +var _version2 = new WeakMap(); -var _launch_data = /*#__PURE__*/new WeakMap(); +var _launch_data = new WeakMap(); -var _comments = /*#__PURE__*/new WeakMap(); +var _comments = new WeakMap(); -var _comments_from_lms = /*#__PURE__*/new WeakMap(); +var _comments_from_lms = new WeakMap(); var CMI = /*#__PURE__*/function (_BaseCMI) { _inherits(CMI, _BaseCMI); @@ -5550,29 +5550,29 @@ var CMI = /*#__PURE__*/function (_BaseCMI) { exports.CMI = CMI; -var _children3 = /*#__PURE__*/new WeakMap(); +var _children3 = new WeakMap(); -var _student_id = /*#__PURE__*/new WeakMap(); +var _student_id = new WeakMap(); -var _student_name = /*#__PURE__*/new WeakMap(); +var _student_name = new WeakMap(); -var _lesson_location = /*#__PURE__*/new WeakMap(); +var _lesson_location = new WeakMap(); -var _credit = /*#__PURE__*/new WeakMap(); +var _credit = new WeakMap(); -var _lesson_status = /*#__PURE__*/new WeakMap(); +var _lesson_status = new WeakMap(); -var _entry = /*#__PURE__*/new WeakMap(); +var _entry = new WeakMap(); -var _total_time = /*#__PURE__*/new WeakMap(); +var _total_time = new WeakMap(); -var _lesson_mode = /*#__PURE__*/new WeakMap(); +var _lesson_mode = new WeakMap(); -var _exit = /*#__PURE__*/new WeakMap(); +var _exit = new WeakMap(); -var _session_time = /*#__PURE__*/new WeakMap(); +var _session_time = new WeakMap(); -var _suspend_data = /*#__PURE__*/new WeakMap(); +var _suspend_data = new WeakMap(); var CMICore = /*#__PURE__*/function (_BaseCMI2) { _inherits(CMICore, _BaseCMI2); @@ -6001,13 +6001,13 @@ var CMIObjectives = /*#__PURE__*/function (_CMIArray) { */ -var _children4 = /*#__PURE__*/new WeakMap(); +var _children4 = new WeakMap(); -var _mastery_score = /*#__PURE__*/new WeakMap(); +var _mastery_score = new WeakMap(); -var _max_time_allowed = /*#__PURE__*/new WeakMap(); +var _max_time_allowed = new WeakMap(); -var _time_limit_action = /*#__PURE__*/new WeakMap(); +var _time_limit_action = new WeakMap(); var CMIStudentData = /*#__PURE__*/function (_BaseCMI3) { _inherits(CMIStudentData, _BaseCMI3); @@ -6160,15 +6160,15 @@ var CMIStudentData = /*#__PURE__*/function (_BaseCMI3) { exports.CMIStudentData = CMIStudentData; -var _children5 = /*#__PURE__*/new WeakMap(); +var _children5 = new WeakMap(); -var _audio = /*#__PURE__*/new WeakMap(); +var _audio = new WeakMap(); -var _language = /*#__PURE__*/new WeakMap(); +var _language = new WeakMap(); -var _speed = /*#__PURE__*/new WeakMap(); +var _speed = new WeakMap(); -var _text = /*#__PURE__*/new WeakMap(); +var _text = new WeakMap(); var CMIStudentPreference = /*#__PURE__*/function (_BaseCMI4) { _inherits(CMIStudentPreference, _BaseCMI4); @@ -6380,19 +6380,19 @@ var CMIInteractions = /*#__PURE__*/function (_CMIArray2) { */ -var _id = /*#__PURE__*/new WeakMap(); +var _id = new WeakMap(); -var _time = /*#__PURE__*/new WeakMap(); +var _time = new WeakMap(); -var _type = /*#__PURE__*/new WeakMap(); +var _type = new WeakMap(); -var _weighting = /*#__PURE__*/new WeakMap(); +var _weighting = new WeakMap(); -var _student_response = /*#__PURE__*/new WeakMap(); +var _student_response = new WeakMap(); -var _result = /*#__PURE__*/new WeakMap(); +var _result = new WeakMap(); -var _latency = /*#__PURE__*/new WeakMap(); +var _latency = new WeakMap(); var CMIInteractionsObject = /*#__PURE__*/function (_BaseCMI5) { _inherits(CMIInteractionsObject, _BaseCMI5); @@ -6659,9 +6659,9 @@ var CMIInteractionsObject = /*#__PURE__*/function (_BaseCMI5) { exports.CMIInteractionsObject = CMIInteractionsObject; -var _id2 = /*#__PURE__*/new WeakMap(); +var _id2 = new WeakMap(); -var _status = /*#__PURE__*/new WeakMap(); +var _status = new WeakMap(); var CMIObjectivesObject = /*#__PURE__*/function (_BaseCMI6) { _inherits(CMIObjectivesObject, _BaseCMI6); @@ -6774,7 +6774,7 @@ var CMIObjectivesObject = /*#__PURE__*/function (_BaseCMI6) { exports.CMIObjectivesObject = CMIObjectivesObject; -var _id3 = /*#__PURE__*/new WeakMap(); +var _id3 = new WeakMap(); var CMIInteractionsObjectivesObject = /*#__PURE__*/function (_BaseCMI7) { _inherits(CMIInteractionsObjectivesObject, _BaseCMI7); @@ -6850,7 +6850,7 @@ var CMIInteractionsObjectivesObject = /*#__PURE__*/function (_BaseCMI7) { exports.CMIInteractionsObjectivesObject = CMIInteractionsObjectivesObject; -var _pattern = /*#__PURE__*/new WeakMap(); +var _pattern = new WeakMap(); var CMIInteractionsCorrectResponsesObject = /*#__PURE__*/function (_BaseCMI8) { _inherits(CMIInteractionsCorrectResponsesObject, _BaseCMI8); @@ -6925,7 +6925,7 @@ var CMIInteractionsCorrectResponsesObject = /*#__PURE__*/function (_BaseCMI8) { exports.CMIInteractionsCorrectResponsesObject = CMIInteractionsCorrectResponsesObject; -var _event = /*#__PURE__*/new WeakMap(); +var _event = new WeakMap(); var NAV = /*#__PURE__*/function (_BaseCMI9) { _inherits(NAV, _BaseCMI9); @@ -7133,45 +7133,45 @@ function check2004ValidRange(value, rangePattern) { */ -var _version2 = /*#__PURE__*/new WeakMap(); +var _version2 = new WeakMap(); -var _children2 = /*#__PURE__*/new WeakMap(); +var _children2 = new WeakMap(); -var _completion_status = /*#__PURE__*/new WeakMap(); +var _completion_status = new WeakMap(); -var _completion_threshold = /*#__PURE__*/new WeakMap(); +var _completion_threshold = new WeakMap(); -var _credit = /*#__PURE__*/new WeakMap(); +var _credit = new WeakMap(); -var _entry = /*#__PURE__*/new WeakMap(); +var _entry = new WeakMap(); -var _exit = /*#__PURE__*/new WeakMap(); +var _exit = new WeakMap(); -var _launch_data = /*#__PURE__*/new WeakMap(); +var _launch_data = new WeakMap(); -var _learner_id = /*#__PURE__*/new WeakMap(); +var _learner_id = new WeakMap(); -var _learner_name = /*#__PURE__*/new WeakMap(); +var _learner_name = new WeakMap(); -var _location = /*#__PURE__*/new WeakMap(); +var _location = new WeakMap(); -var _max_time_allowed = /*#__PURE__*/new WeakMap(); +var _max_time_allowed = new WeakMap(); -var _mode = /*#__PURE__*/new WeakMap(); +var _mode = new WeakMap(); -var _progress_measure = /*#__PURE__*/new WeakMap(); +var _progress_measure = new WeakMap(); -var _scaled_passing_score = /*#__PURE__*/new WeakMap(); +var _scaled_passing_score = new WeakMap(); -var _session_time = /*#__PURE__*/new WeakMap(); +var _session_time = new WeakMap(); -var _success_status = /*#__PURE__*/new WeakMap(); +var _success_status = new WeakMap(); -var _suspend_data = /*#__PURE__*/new WeakMap(); +var _suspend_data = new WeakMap(); -var _time_limit_action = /*#__PURE__*/new WeakMap(); +var _time_limit_action = new WeakMap(); -var _total_time = /*#__PURE__*/new WeakMap(); +var _total_time = new WeakMap(); var CMI = /*#__PURE__*/function (_BaseCMI) { _inherits(CMI, _BaseCMI); @@ -7790,15 +7790,15 @@ var CMI = /*#__PURE__*/function (_BaseCMI) { exports.CMI = CMI; -var _children3 = /*#__PURE__*/new WeakMap(); +var _children3 = new WeakMap(); -var _audio_level = /*#__PURE__*/new WeakMap(); +var _audio_level = new WeakMap(); -var _language = /*#__PURE__*/new WeakMap(); +var _language = new WeakMap(); -var _delivery_speed = /*#__PURE__*/new WeakMap(); +var _delivery_speed = new WeakMap(); -var _audio_captioning = /*#__PURE__*/new WeakMap(); +var _audio_captioning = new WeakMap(); var CMILearnerPreference = /*#__PURE__*/function (_BaseCMI2) { _inherits(CMILearnerPreference, _BaseCMI2); @@ -8078,21 +8078,21 @@ var CMICommentsFromLearner = /*#__PURE__*/function (_CMIArray4) { */ -var _id = /*#__PURE__*/new WeakMap(); +var _id = new WeakMap(); -var _type = /*#__PURE__*/new WeakMap(); +var _type = new WeakMap(); -var _timestamp = /*#__PURE__*/new WeakMap(); +var _timestamp = new WeakMap(); -var _weighting = /*#__PURE__*/new WeakMap(); +var _weighting = new WeakMap(); -var _learner_response = /*#__PURE__*/new WeakMap(); +var _learner_response = new WeakMap(); -var _result = /*#__PURE__*/new WeakMap(); +var _result = new WeakMap(); -var _latency = /*#__PURE__*/new WeakMap(); +var _latency = new WeakMap(); -var _description = /*#__PURE__*/new WeakMap(); +var _description = new WeakMap(); var CMIInteractionsObject = /*#__PURE__*/function (_BaseCMI3) { _inherits(CMIInteractionsObject, _BaseCMI3); @@ -8457,15 +8457,15 @@ var CMIInteractionsObject = /*#__PURE__*/function (_BaseCMI3) { exports.CMIInteractionsObject = CMIInteractionsObject; -var _id2 = /*#__PURE__*/new WeakMap(); +var _id2 = new WeakMap(); -var _success_status2 = /*#__PURE__*/new WeakMap(); +var _success_status2 = new WeakMap(); -var _completion_status2 = /*#__PURE__*/new WeakMap(); +var _completion_status2 = new WeakMap(); -var _progress_measure2 = /*#__PURE__*/new WeakMap(); +var _progress_measure2 = new WeakMap(); -var _description2 = /*#__PURE__*/new WeakMap(); +var _description2 = new WeakMap(); var CMIObjectivesObject = /*#__PURE__*/function (_BaseCMI4) { _inherits(CMIObjectivesObject, _BaseCMI4); @@ -8681,7 +8681,7 @@ var CMIObjectivesObject = /*#__PURE__*/function (_BaseCMI4) { exports.CMIObjectivesObject = CMIObjectivesObject; -var _scaled = /*#__PURE__*/new WeakMap(); +var _scaled = new WeakMap(); var Scorm2004CMIScore = /*#__PURE__*/function (_CMIScore) { _inherits(Scorm2004CMIScore, _CMIScore); @@ -8769,13 +8769,13 @@ var Scorm2004CMIScore = /*#__PURE__*/function (_CMIScore) { */ -var _comment = /*#__PURE__*/new WeakMap(); +var _comment = new WeakMap(); -var _location2 = /*#__PURE__*/new WeakMap(); +var _location2 = new WeakMap(); -var _timestamp2 = /*#__PURE__*/new WeakMap(); +var _timestamp2 = new WeakMap(); -var _readOnlyAfterInit = /*#__PURE__*/new WeakMap(); +var _readOnlyAfterInit = new WeakMap(); var CMICommentsObject = /*#__PURE__*/function (_BaseCMI5) { _inherits(CMICommentsObject, _BaseCMI5); @@ -8932,7 +8932,7 @@ var CMICommentsObject = /*#__PURE__*/function (_BaseCMI5) { exports.CMICommentsObject = CMICommentsObject; -var _id3 = /*#__PURE__*/new WeakMap(); +var _id3 = new WeakMap(); var CMIInteractionsObjectivesObject = /*#__PURE__*/function (_BaseCMI6) { _inherits(CMIInteractionsObjectivesObject, _BaseCMI6); @@ -9007,7 +9007,7 @@ var CMIInteractionsObjectivesObject = /*#__PURE__*/function (_BaseCMI6) { exports.CMIInteractionsObjectivesObject = CMIInteractionsObjectivesObject; -var _pattern = /*#__PURE__*/new WeakMap(); +var _pattern = new WeakMap(); var CMIInteractionsCorrectResponsesObject = /*#__PURE__*/function (_BaseCMI7) { _inherits(CMIInteractionsCorrectResponsesObject, _BaseCMI7); @@ -9145,7 +9145,7 @@ var ADL = /*#__PURE__*/function (_BaseCMI8) { exports.ADL = ADL; -var _request = /*#__PURE__*/new WeakMap(); +var _request = new WeakMap(); var ADLNav = /*#__PURE__*/function (_BaseCMI9) { _inherits(ADLNav, _BaseCMI9); @@ -9233,9 +9233,9 @@ var ADLNav = /*#__PURE__*/function (_BaseCMI9) { */ -var _continue = /*#__PURE__*/new WeakMap(); +var _continue = new WeakMap(); -var _previous = /*#__PURE__*/new WeakMap(); +var _previous = new WeakMap(); var ADLNavRequestValid = /*#__PURE__*/function (_BaseCMI10) { _inherits(ADLNavRequestValid, _BaseCMI10); @@ -9246,6 +9246,8 @@ var ADLNavRequestValid = /*#__PURE__*/function (_BaseCMI10) { * Constructor for adl.nav.request_valid */ function ADLNavRequestValid() { + var _temp, _temp2; + var _this11; _classCallCheck(this, ADLNavRequestValid); @@ -9262,29 +9264,21 @@ var ADLNavRequestValid = /*#__PURE__*/function (_BaseCMI10) { value: 'unknown' }); - _defineProperty(_assertThisInitialized(_this11), "choice", /*#__PURE__*/function () { - function _class2() { - _classCallCheck(this, _class2); + _defineProperty(_assertThisInitialized(_this11), "choice", (_temp = function _temp() { + _classCallCheck(this, _temp); - _defineProperty(this, "_isTargetValid", function (_target) { - return 'unknown'; - }); - } + _defineProperty(this, "_isTargetValid", function (_target) { + return 'unknown'; + }); + }, _temp)); - return _class2; - }()); + _defineProperty(_assertThisInitialized(_this11), "jump", (_temp2 = function _temp2() { + _classCallCheck(this, _temp2); - _defineProperty(_assertThisInitialized(_this11), "jump", /*#__PURE__*/function () { - function _class4() { - _classCallCheck(this, _class4); - - _defineProperty(this, "_isTargetValid", function (_target) { - return 'unknown'; - }); - } - - return _class4; - }()); + _defineProperty(this, "_isTargetValid", function (_target) { + return 'unknown'; + }); + }, _temp2)); return _this11; } @@ -10404,11 +10398,11 @@ var scorm2004_errors = _api_constants["default"].scorm2004.error_descriptions; * Base Validation Exception */ -var _errorCode = /*#__PURE__*/new WeakMap(); +var _errorCode = new WeakMap(); -var _errorMessage = /*#__PURE__*/new WeakMap(); +var _errorMessage = new WeakMap(); -var _detailedMessage = /*#__PURE__*/new WeakMap(); +var _detailedMessage = new WeakMap(); var ValidationError = /*#__PURE__*/function (_Error) { _inherits(ValidationError, _Error); @@ -10588,11 +10582,11 @@ exports.Scorm2004ValidationError = Scorm2004ValidationError; },{"./constants/api_constants":10}],16:[function(require,module,exports){ "use strict"; -var _Scorm2004API = _interopRequireDefault(require("./Scorm2004API")); +var _Scorm2004API = _interopRequireDefault(require("../Scorm2004API")); -var _Scorm12API = _interopRequireDefault(require("./Scorm12API")); +var _Scorm12API = _interopRequireDefault(require("../Scorm12API")); -var _AICC = _interopRequireDefault(require("./AICC")); +var _AICC = _interopRequireDefault(require("../AICC")); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } @@ -10600,7 +10594,7 @@ window.Scorm12API = _Scorm12API["default"]; window.Scorm2004API = _Scorm2004API["default"]; window.AICC = _AICC["default"]; -},{"./AICC":2,"./Scorm12API":4,"./Scorm2004API":5}],17:[function(require,module,exports){ +},{"../AICC":2,"../Scorm12API":4,"../Scorm2004API":5}],17:[function(require,module,exports){ "use strict"; Object.defineProperty(exports, "__esModule", { @@ -10877,5 +10871,5 @@ function countDecimals(num) { return parts.length || 0; } -},{}]},{},[2,3,6,7,8,9,10,11,12,13,14,15,16,4,5,17]) -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","node_modules/lodash.debounce/index.js","src/AICC.js","src/BaseAPI.js","src/Scorm12API.js","src/Scorm2004API.js","src/cmi/aicc_cmi.js","src/cmi/common.js","src/cmi/scorm12_cmi.js","src/cmi/scorm2004_cmi.js","src/constants/api_constants.js","src/constants/error_codes.js","src/constants/language_constants.js","src/constants/regex.js","src/constants/response_constants.js","src/exceptions.js","src/exports.js","src/utilities.js"],"names":[],"mappings":"AAAA;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACxXA;;AACA;;AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA;AACA;AACA;IACqB,I;;;;;AACnB;AACF;AACA;AACA;AACE,gBAAY,QAAZ,EAA0B;AAAA;;AAAA;;AACxB,QAAM,aAAa,mCACd;AACD,MAAA,gBAAgB,EAAE;AADjB,KADc,GAGX,QAHW,CAAnB;;AAMA,8BAAM,aAAN;AAEA,UAAK,GAAL,GAAW,IAAI,aAAJ,EAAX;AACA,UAAK,GAAL,GAAW,IAAI,gBAAJ,EAAX;AAVwB;AAWzB;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;;;;;WACE,yBAAgB,UAAhB,EAA4B,KAA5B,EAAmC,eAAnC,EAAoD;AAClD,UAAI,QAAQ,6EAAyB,UAAzB,EAAqC,KAArC,EAA4C,eAA5C,CAAZ;;AAEA,UAAI,CAAC,QAAL,EAAe;AACb,YAAI,KA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EI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAsB;AACpB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAoB,eAApB,EAAqC;AACnC,OAAC,KAAK,WAAN,yBACI,IADJ,oBAC4B,eAD5B,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAY;AACV,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAU,KAAV,EAAiB;AACf,OAAC,KAAK,WAAN,yBACI,IADJ,UACkB,KADlB,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAsB;AACpB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAoB,eAApB,EAAqC;AACnC,OAAC,KAAK,WAAN,yBACI,IADJ,oBAC4B,eAD5B,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAY;AACV,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAU,KAAV,EAAiB;AACf,OAAC,KAAK,WAAN,yBACI,IADJ,UACkB,KADlB,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAqB;AACnB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAmB,cAAnB,EAAmC;AACjC,OAAC,KAAK,WAAN,yBACI,IADJ,mBAC2B,cAD3B,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAgB;AACd,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAc,SAAd,EAAyB;AACvB,OAAC,KAAK,WAAN,yBACI,IADJ,cACsB,SADtB,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAuB;AACrB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAqB,gBAArB,EAAuC;AACrC,OAAC,KAAK,WAAN,yBACI,IADJ,qBAC6B,gBAD7B,IAEI,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","file":"generated.js","sourceRoot":"","sourcesContent":["(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()","/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the `TypeError` message for \"Functions\" methods. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n  return root.Date.now();\n};\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        result = wait - timeSinceLastCall;\n\n    return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && objectToString.call(value) == symbolTag);\n}\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = value.replace(reTrim, '');\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = debounce;\n","// @flow\nimport Scorm12API from './Scorm12API';\nimport {\n  CMI,\n  CMIAttemptRecordsObject,\n  CMIEvaluationCommentsObject,\n  CMITriesObject,\n} from './cmi/aicc_cmi';\nimport {NAV} from './cmi/scorm12_cmi';\n\n/**\n * The AICC API class\n */\nexport default class AICC extends Scorm12API {\n  /**\n   * Constructor to create AICC API object\n   * @param {object} settings\n   */\n  constructor(settings: {}) {\n    const finalSettings = {\n      ...{\n        mastery_override: false,\n      }, ...settings,\n    };\n\n    super(finalSettings);\n\n    this.cmi = new CMI();\n    this.nav = new NAV();\n  }\n\n  /**\n   * Gets or builds a new child element to add to the array.\n   *\n   * @param {string} CMIElement\n   * @param {any} value\n   * @param {boolean} foundFirstIndex\n   * @return {object}\n   */\n  getChildElement(CMIElement, value, foundFirstIndex) {\n    let newChild = super.getChildElement(CMIElement, value, foundFirstIndex);\n\n    if (!newChild) {\n      if (this.stringMatches(CMIElement, 'cmi\\\\.evaluation\\\\.comments\\\\.\\\\d+')) {\n        newChild = new CMIEvaluationCommentsObject();\n      } else if (this.stringMatches(CMIElement,\n          'cmi\\\\.student_data\\\\.tries\\\\.\\\\d+')) {\n        newChild = new CMITriesObject();\n      } else if (this.stringMatches(CMIElement,\n          'cmi\\\\.student_data\\\\.attempt_records\\\\.\\\\d+')) {\n        newChild = new CMIAttemptRecordsObject();\n      }\n    }\n\n    return newChild;\n  }\n\n  /**\n   * Replace the whole API with another\n   *\n   * @param {AICC} newAPI\n   */\n  replaceWithAnotherScormAPI(newAPI) {\n    // Data Model\n    this.cmi = newAPI.cmi;\n    this.nav = newAPI.nav;\n  }\n}\n","// @flow\nimport {CMIArray} from './cmi/common';\nimport {ValidationError} from './exceptions';\nimport ErrorCodes from './constants/error_codes';\nimport APIConstants from './constants/api_constants';\nimport {unflatten} from './utilities';\nimport debounce from 'lodash.debounce';\n\nconst global_constants = APIConstants.global;\nconst scorm12_error_codes = ErrorCodes.scorm12;\n\n/**\n * Base API class for AICC, SCORM 1.2, and SCORM 2004. Should be considered\n * abstract, and never initialized on it's own.\n */\nexport default class BaseAPI {\n  #timeout;\n  #error_codes;\n  #settings = {\n    autocommit: false,\n    autocommitSeconds: 10,\n    asyncCommit: false,\n    sendBeaconCommit: false,\n    lmsCommitUrl: false,\n    dataCommitFormat: 'json', // valid formats are 'json' or 'flattened', 'params'\n    commitRequestDataType: 'application/json;charset=UTF-8',\n    autoProgress: false,\n    logLevel: global_constants.LOG_LEVEL_ERROR,\n    selfReportSessionTime: false,\n    alwaysSendTotalTime: false,\n    strict_errors: true,\n    responseHandler: function(xhr) {\n      let result;\n      if (typeof xhr !== 'undefined') {\n        result = JSON.parse(xhr.responseText);\n        if (result === null || !{}.hasOwnProperty.call(result, 'result')) {\n          result = {};\n          if (xhr.status === 200) {\n            result.result = global_constants.SCORM_TRUE;\n            result.errorCode = 0;\n          } else {\n            result.result = global_constants.SCORM_FALSE;\n            result.errorCode = 101;\n          }\n        }\n      }\n      return result;\n    },\n  };\n  cmi;\n  startingData: {};\n\n  /**\n   * Constructor for Base API class. Sets some shared API fields, as well as\n   * sets up options for the API.\n   * @param {object} error_codes\n   * @param {object} settings\n   */\n  constructor(error_codes, settings) {\n    if (new.target === BaseAPI) {\n      throw new TypeError('Cannot construct BaseAPI instances directly');\n    }\n    this.currentState = global_constants.STATE_NOT_INITIALIZED;\n    this.lastErrorCode = 0;\n    this.listenerArray = [];\n\n    this.#timeout = null;\n    this.#error_codes = error_codes;\n\n    this.settings = settings;\n    this.apiLogLevel = this.settings.logLevel;\n    this.selfReportSessionTime = this.settings.selfReportSessionTime;\n  }\n\n  /**\n   * Initialize the API\n   * @param {string} callbackName\n   * @param {string} initializeMessage\n   * @param {string} terminationMessage\n   * @return {string}\n   */\n  initialize(\n      callbackName: String,\n      initializeMessage?: String,\n      terminationMessage?: String) {\n    let returnValue = global_constants.SCORM_FALSE;\n\n    if (this.isInitialized()) {\n      this.throwSCORMError(this.#error_codes.INITIALIZED, initializeMessage);\n    } else if (this.isTerminated()) {\n      this.throwSCORMError(this.#error_codes.TERMINATED, terminationMessage);\n    } else {\n      if (this.selfReportSessionTime) {\n        this.cmi.setStartTime();\n      }\n\n      this.currentState = global_constants.STATE_INITIALIZED;\n      this.lastErrorCode = 0;\n      returnValue = global_constants.SCORM_TRUE;\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n    this.clearSCORMError(returnValue);\n\n    return returnValue;\n  }\n\n  /**\n   * Getter for #error_codes\n   * @return {object}\n   */\n  get error_codes() {\n    return this.#error_codes;\n  }\n\n  /**\n   * Getter for #settings\n   * @return {object}\n   */\n  get settings() {\n    return this.#settings;\n  }\n\n  /**\n   * Setter for #settings\n   * @param {object} settings\n   */\n  set settings(settings: Object) {\n    this.#settings = {...this.#settings, ...settings};\n  }\n\n  /**\n   * Terminates the current run of the API\n   * @param {string} callbackName\n   * @param {boolean} checkTerminated\n   * @return {string}\n   */\n  terminate(\n      callbackName: String,\n      checkTerminated: boolean) {\n    let returnValue = global_constants.SCORM_FALSE;\n\n    if (this.checkState(checkTerminated,\n        this.#error_codes.TERMINATION_BEFORE_INIT,\n        this.#error_codes.MULTIPLE_TERMINATION)) {\n      this.currentState = global_constants.STATE_TERMINATED;\n\n      const result = this.storeData(true);\n      if (!this.settings.sendBeaconCommit && !this.settings.asyncCommit &&\n          typeof result.errorCode !== 'undefined' && result.errorCode > 0) {\n        this.throwSCORMError(result.errorCode);\n      }\n      returnValue = (typeof result !== 'undefined' && result.result) ?\n          result.result : global_constants.SCORM_FALSE;\n\n      if (checkTerminated) this.lastErrorCode = 0;\n\n      returnValue = global_constants.SCORM_TRUE;\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n    this.clearSCORMError(returnValue);\n\n    return returnValue;\n  }\n\n  /**\n   * Get the value of the CMIElement.\n   *\n   * @param {string} callbackName\n   * @param {boolean} checkTerminated\n   * @param {string} CMIElement\n   * @return {string}\n   */\n  getValue(\n      callbackName: String,\n      checkTerminated: boolean,\n      CMIElement: String) {\n    let returnValue;\n\n    if (this.checkState(checkTerminated,\n        this.#error_codes.RETRIEVE_BEFORE_INIT,\n        this.#error_codes.RETRIEVE_AFTER_TERM)) {\n      if (checkTerminated) this.lastErrorCode = 0;\n      try {\n        returnValue = this.getCMIValue(CMIElement);\n      } catch (e) {\n        if (e instanceof ValidationError) {\n          this.lastErrorCode = e.errorCode;\n          returnValue = global_constants.SCORM_FALSE;\n        } else {\n          if (e.message) {\n            console.error(e.message);\n          } else {\n            console.error(e);\n          }\n          this.throwSCORMError(this.#error_codes.GENERAL);\n        }\n      }\n      this.processListeners(callbackName, CMIElement);\n    }\n\n    this.apiLog(callbackName, CMIElement, ': returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n    this.clearSCORMError(returnValue);\n\n    return returnValue;\n  }\n\n  /**\n   * Sets the value of the CMIElement.\n   *\n   * @param {string} callbackName\n   * @param {string} commitCallback\n   * @param {boolean} checkTerminated\n   * @param {string} CMIElement\n   * @param {*} value\n   * @return {string}\n   */\n  setValue(\n      callbackName: String,\n      commitCallback: String,\n      checkTerminated: boolean,\n      CMIElement,\n      value) {\n    if (value !== undefined) {\n      value = String(value);\n    }\n    let returnValue = global_constants.SCORM_FALSE;\n\n    if (this.checkState(checkTerminated, this.#error_codes.STORE_BEFORE_INIT,\n        this.#error_codes.STORE_AFTER_TERM)) {\n      if (checkTerminated) this.lastErrorCode = 0;\n      try {\n        returnValue = this.setCMIValue(CMIElement, value);\n      } catch (e) {\n        if (e instanceof ValidationError) {\n          this.lastErrorCode = e.errorCode;\n          returnValue = global_constants.SCORM_FALSE;\n        } else {\n          if (e.message) {\n            console.error(e.message);\n          } else {\n            console.error(e);\n          }\n          this.throwSCORMError(this.#error_codes.GENERAL);\n        }\n      }\n      this.processListeners(callbackName, CMIElement, value);\n    }\n\n    if (returnValue === undefined) {\n      returnValue = global_constants.SCORM_FALSE;\n    }\n\n    // If we didn't have any errors while setting the data, go ahead and\n    // schedule a commit, if autocommit is turned on\n    if (String(this.lastErrorCode) === '0') {\n      if (this.settings.autocommit && !this.#timeout) {\n        this.scheduleCommit(this.settings.autocommitSeconds * 1000, commitCallback);\n      }\n    }\n\n    this.apiLog(callbackName, CMIElement,\n        ': ' + value + ': result: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n    this.clearSCORMError(returnValue);\n\n    return returnValue;\n  }\n\n  /**\n   * Orders LMS to store all content parameters\n   * @param {string} callbackName\n   * @param {boolean} checkTerminated\n   * @return {string}\n   */\n  commit(\n      callbackName: String,\n      checkTerminated: boolean) {\n    this.clearScheduledCommit();\n\n    let returnValue = global_constants.SCORM_FALSE;\n\n    if (this.checkState(checkTerminated, this.#error_codes.COMMIT_BEFORE_INIT,\n        this.#error_codes.COMMIT_AFTER_TERM)) {\n      const result = this.storeData(false);\n      if (!this.settings.sendBeaconCommit && !this.settings.asyncCommit &&\n          result.errorCode && result.errorCode > 0) {\n        this.throwSCORMError(result.errorCode);\n      }\n      returnValue = (typeof result !== 'undefined' && result.result) ?\n          result.result : global_constants.SCORM_FALSE;\n\n      this.apiLog(callbackName, 'HttpRequest', ' Result: ' + returnValue,\n          global_constants.LOG_LEVEL_DEBUG);\n\n      if (checkTerminated) this.lastErrorCode = 0;\n\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n    this.clearSCORMError(returnValue);\n\n    return returnValue;\n  }\n\n  /**\n   * Returns last error code\n   * @param {string} callbackName\n   * @return {string}\n   */\n  getLastError(callbackName: String) {\n    const returnValue = String(this.lastErrorCode);\n\n    this.processListeners(callbackName);\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n\n    return returnValue;\n  }\n\n  /**\n   * Returns the errorNumber error description\n   *\n   * @param {string} callbackName\n   * @param {(string|number)} CMIErrorCode\n   * @return {string}\n   */\n  getErrorString(callbackName: String, CMIErrorCode) {\n    let returnValue = '';\n\n    if (CMIErrorCode !== null && CMIErrorCode !== '') {\n      returnValue = this.getLmsErrorMessageDetails(CMIErrorCode);\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n\n    return returnValue;\n  }\n\n  /**\n   * Returns a comprehensive description of the errorNumber error.\n   *\n   * @param {string} callbackName\n   * @param {(string|number)} CMIErrorCode\n   * @return {string}\n   */\n  getDiagnostic(callbackName: String, CMIErrorCode) {\n    let returnValue = '';\n\n    if (CMIErrorCode !== null && CMIErrorCode !== '') {\n      returnValue = this.getLmsErrorMessageDetails(CMIErrorCode, true);\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n\n    return returnValue;\n  }\n\n  /**\n   * Checks the LMS state and ensures it has been initialized.\n   *\n   * @param {boolean} checkTerminated\n   * @param {number} beforeInitError\n   * @param {number} afterTermError\n   * @return {boolean}\n   */\n  checkState(\n      checkTerminated: boolean,\n      beforeInitError: number,\n      afterTermError?: number) {\n    if (this.isNotInitialized()) {\n      this.throwSCORMError(beforeInitError);\n      return false;\n    } else if (checkTerminated && this.isTerminated()) {\n      this.throwSCORMError(afterTermError);\n      return false;\n    }\n\n    return true;\n  }\n\n  /**\n   * Logging for all SCORM actions\n   *\n   * @param {string} functionName\n   * @param {string} CMIElement\n   * @param {string} logMessage\n   * @param {number}messageLevel\n   */\n  apiLog(\n      functionName: String,\n      CMIElement: String,\n      logMessage: String,\n      messageLevel: number) {\n    logMessage = this.formatMessage(functionName, CMIElement, logMessage);\n\n    if (messageLevel >= this.apiLogLevel) {\n      switch (messageLevel) {\n        case global_constants.LOG_LEVEL_ERROR:\n          console.error(logMessage);\n          break;\n        case global_constants.LOG_LEVEL_WARNING:\n          console.warn(logMessage);\n          break;\n        case global_constants.LOG_LEVEL_INFO:\n          console.info(logMessage);\n          break;\n        case global_constants.LOG_LEVEL_DEBUG:\n          if (console.debug) {\n            console.debug(logMessage);\n          } else {\n            console.log(logMessage);\n          }\n          break;\n      }\n    }\n  }\n\n  /**\n   * Formats the SCORM messages for easy reading\n   *\n   * @param {string} functionName\n   * @param {string} CMIElement\n   * @param {string} message\n   * @return {string}\n   */\n  formatMessage(functionName: String, CMIElement: String, message: String) {\n    const baseLength = 20;\n    let messageString = '';\n\n    messageString += functionName;\n\n    let fillChars = baseLength - messageString.length;\n\n    for (let i = 0; i < fillChars; i++) {\n      messageString += ' ';\n    }\n\n    messageString += ': ';\n\n    if (CMIElement) {\n      const CMIElementBaseLength = 70;\n\n      messageString += CMIElement;\n\n      fillChars = CMIElementBaseLength - messageString.length;\n\n      for (let j = 0; j < fillChars; j++) {\n        messageString += ' ';\n      }\n    }\n\n    if (message) {\n      messageString += message;\n    }\n\n    return messageString;\n  }\n\n  /**\n   * Checks to see if {str} contains {tester}\n   *\n   * @param {string} str String to check against\n   * @param {string} tester String to check for\n   * @return {boolean}\n   */\n  stringMatches(str: String, tester: String) {\n    return str && tester && str.match(tester);\n  }\n\n  /**\n   * Check to see if the specific object has the given property\n   * @param {*} refObject\n   * @param {string} attribute\n   * @return {boolean}\n   * @private\n   */\n  _checkObjectHasProperty(refObject, attribute: String) {\n    return Object.hasOwnProperty.call(refObject, attribute) ||\n        Object.getOwnPropertyDescriptor(\n            Object.getPrototypeOf(refObject), attribute) ||\n        (attribute in refObject);\n  }\n\n  /**\n   * Returns the message that corresponds to errorNumber\n   * APIs that inherit BaseAPI should override this function\n   *\n   * @param {(string|number)} _errorNumber\n   * @param {boolean} _detail\n   * @return {string}\n   * @abstract\n   */\n  getLmsErrorMessageDetails(_errorNumber, _detail) {\n    throw new Error(\n        'The getLmsErrorMessageDetails method has not been implemented');\n  }\n\n  /**\n   * Gets the value for the specific element.\n   * APIs that inherit BaseAPI should override this function\n   *\n   * @param {string} _CMIElement\n   * @return {string}\n   * @abstract\n   */\n  getCMIValue(_CMIElement) {\n    throw new Error('The getCMIValue method has not been implemented');\n  }\n\n  /**\n   * Sets the value for the specific element.\n   * APIs that inherit BaseAPI should override this function\n   *\n   * @param {string} _CMIElement\n   * @param {any} _value\n   * @return {string}\n   * @abstract\n   */\n  setCMIValue(_CMIElement, _value) {\n    throw new Error('The setCMIValue method has not been implemented');\n  }\n\n  /**\n   * Shared API method to set a valid for a given element.\n   *\n   * @param {string} methodName\n   * @param {boolean} scorm2004\n   * @param {string} CMIElement\n   * @param {*} value\n   * @return {string}\n   */\n  _commonSetCMIValue(\n      methodName: String, scorm2004: boolean, CMIElement, value) {\n    if (!CMIElement || CMIElement === '') {\n      return global_constants.SCORM_FALSE;\n    }\n\n    const structure = CMIElement.split('.');\n    let refObject = this;\n    let returnValue = global_constants.SCORM_FALSE;\n    let foundFirstIndex = false;\n\n    const invalidErrorMessage = `The data model element passed to ${methodName} (${CMIElement}) is not a valid SCORM data model element.`;\n    const invalidErrorCode = scorm2004 ?\n        this.#error_codes.UNDEFINED_DATA_MODEL :\n        this.#error_codes.GENERAL;\n\n    for (let i = 0; i < structure.length; i++) {\n      const attribute = structure[i];\n\n      if (i === structure.length - 1) {\n        if (scorm2004 && (attribute.substr(0, 8) === '{target=') &&\n            (typeof refObject._isTargetValid == 'function')) {\n          this.throwSCORMError(this.#error_codes.READ_ONLY_ELEMENT);\n        } else if (!this._checkObjectHasProperty(refObject, attribute)) {\n          this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n        } else {\n          if (this.isInitialized() &&\n              this.stringMatches(CMIElement, '\\\\.correct_responses\\\\.\\\\d+')) {\n            this.validateCorrectResponse(CMIElement, value);\n          }\n\n          if (!scorm2004 || this.lastErrorCode === 0) {\n            refObject[attribute] = value;\n            returnValue = global_constants.SCORM_TRUE;\n          }\n        }\n      } else {\n        refObject = refObject[attribute];\n        if (!refObject) {\n          this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n          break;\n        }\n\n        if (refObject instanceof CMIArray) {\n          const index = parseInt(structure[i + 1], 10);\n\n          // SCO is trying to set an item on an array\n          if (!isNaN(index)) {\n            const item = refObject.childArray[index];\n\n            if (item) {\n              refObject = item;\n              foundFirstIndex = true;\n            } else {\n              const newChild = this.getChildElement(CMIElement, value,\n                  foundFirstIndex);\n              foundFirstIndex = true;\n\n              if (!newChild) {\n                this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n              } else {\n                if (refObject.initialized) newChild.initialize();\n\n                refObject.childArray.push(newChild);\n                refObject = newChild;\n              }\n            }\n\n            // Have to update i value to skip the array position\n            i++;\n          }\n        }\n      }\n    }\n\n    if (returnValue === global_constants.SCORM_FALSE) {\n      this.apiLog(methodName, null,\n          `There was an error setting the value for: ${CMIElement}, value of: ${value}`,\n          global_constants.LOG_LEVEL_WARNING);\n    }\n\n    return returnValue;\n  }\n\n  /**\n   * Abstract method for validating that a response is correct.\n   *\n   * @param {string} _CMIElement\n   * @param {*} _value\n   */\n  validateCorrectResponse(_CMIElement, _value) {\n    // just a stub method\n  }\n\n  /**\n   * Gets or builds a new child element to add to the array.\n   * APIs that inherit BaseAPI should override this method.\n   *\n   * @param {string} _CMIElement - unused\n   * @param {*} _value - unused\n   * @param {boolean} _foundFirstIndex - unused\n   * @return {*}\n   * @abstract\n   */\n  getChildElement(_CMIElement, _value, _foundFirstIndex) {\n    throw new Error('The getChildElement method has not been implemented');\n  }\n\n  /**\n   * Gets a value from the CMI Object\n   *\n   * @param {string} methodName\n   * @param {boolean} scorm2004\n   * @param {string} CMIElement\n   * @return {*}\n   */\n  _commonGetCMIValue(methodName: String, scorm2004: boolean, CMIElement) {\n    if (!CMIElement || CMIElement === '') {\n      return '';\n    }\n\n    const structure = CMIElement.split('.');\n    let refObject = this;\n    let attribute = null;\n\n    const uninitializedErrorMessage = `The data model element passed to ${methodName} (${CMIElement}) has not been initialized.`;\n    const invalidErrorMessage = `The data model element passed to ${methodName} (${CMIElement}) is not a valid SCORM data model element.`;\n    const invalidErrorCode = scorm2004 ?\n        this.#error_codes.UNDEFINED_DATA_MODEL :\n        this.#error_codes.GENERAL;\n\n    for (let i = 0; i < structure.length; i++) {\n      attribute = structure[i];\n\n      if (!scorm2004) {\n        if (i === structure.length - 1) {\n          if (!this._checkObjectHasProperty(refObject, attribute)) {\n            this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n            return;\n          }\n        }\n      } else {\n        if ((String(attribute).substr(0, 8) === '{target=') &&\n            (typeof refObject._isTargetValid == 'function')) {\n          const target = String(attribute).\n              substr(8, String(attribute).length - 9);\n          return refObject._isTargetValid(target);\n        } else if (!this._checkObjectHasProperty(refObject, attribute)) {\n          this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n          return;\n        }\n      }\n\n      refObject = refObject[attribute];\n      if (refObject === undefined) {\n        this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n        break;\n      }\n\n      if (refObject instanceof CMIArray) {\n        const index = parseInt(structure[i + 1], 10);\n\n        // SCO is trying to set an item on an array\n        if (!isNaN(index)) {\n          const item = refObject.childArray[index];\n\n          if (item) {\n            refObject = item;\n          } else {\n            this.throwSCORMError(this.#error_codes.VALUE_NOT_INITIALIZED,\n                uninitializedErrorMessage);\n            break;\n          }\n\n          // Have to update i value to skip the array position\n          i++;\n        }\n      }\n    }\n\n    if (refObject === null || refObject === undefined) {\n      if (!scorm2004) {\n        if (attribute === '_children') {\n          this.throwSCORMError(scorm12_error_codes.CHILDREN_ERROR);\n        } else if (attribute === '_count') {\n          this.throwSCORMError(scorm12_error_codes.COUNT_ERROR);\n        }\n      }\n    } else {\n      return refObject;\n    }\n  }\n\n  /**\n   * Returns true if the API's current state is STATE_INITIALIZED\n   *\n   * @return {boolean}\n   */\n  isInitialized() {\n    return this.currentState === global_constants.STATE_INITIALIZED;\n  }\n\n  /**\n   * Returns true if the API's current state is STATE_NOT_INITIALIZED\n   *\n   * @return {boolean}\n   */\n  isNotInitialized() {\n    return this.currentState === global_constants.STATE_NOT_INITIALIZED;\n  }\n\n  /**\n   * Returns true if the API's current state is STATE_TERMINATED\n   *\n   * @return {boolean}\n   */\n  isTerminated() {\n    return this.currentState === global_constants.STATE_TERMINATED;\n  }\n\n  /**\n   * Provides a mechanism for attaching to a specific SCORM event\n   *\n   * @param {string} listenerName\n   * @param {function} callback\n   */\n  on(listenerName: String, callback: function) {\n    if (!callback) return;\n\n    const listenerFunctions = listenerName.split(' ');\n    for (let i = 0; i < listenerFunctions.length; i++) {\n      const listenerSplit = listenerFunctions[i].split('.');\n      if (listenerSplit.length === 0) return;\n\n      const functionName = listenerSplit[0];\n\n      let CMIElement = null;\n      if (listenerSplit.length > 1) {\n        CMIElement = listenerName.replace(functionName + '.', '');\n      }\n\n      this.listenerArray.push({\n        functionName: functionName,\n        CMIElement: CMIElement,\n        callback: callback,\n      });\n\n      this.apiLog('on', functionName, `Added event listener: ${this.listenerArray.length}`, global_constants.LOG_LEVEL_INFO);\n    }\n  }\n\n  /**\n   * Provides a mechanism for detaching a specific SCORM event listener\n   *\n   * @param {string} listenerName\n   * @param {function} callback\n   */\n  off(listenerName: String, callback: function) {\n    if (!callback) return;\n\n    const listenerFunctions = listenerName.split(' ');\n    for (let i = 0; i < listenerFunctions.length; i++) {\n      const listenerSplit = listenerFunctions[i].split('.');\n      if (listenerSplit.length === 0) return;\n\n      const functionName = listenerSplit[0];\n\n      let CMIElement = null;\n      if (listenerSplit.length > 1) {\n        CMIElement = listenerName.replace(functionName + '.', '');\n      }\n\n      const removeIndex = this.listenerArray.findIndex((obj) =>\n        obj.functionName === functionName &&\n        obj.CMIElement === CMIElement &&\n        obj.callback === callback\n      );\n      if (removeIndex !== -1) {\n        this.listenerArray.splice(removeIndex, 1);\n        this.apiLog('off', functionName, `Removed event listener: ${this.listenerArray.length}`, global_constants.LOG_LEVEL_INFO);\n      }\n    }\n  }\n\n  /**\n   * Provides a mechanism for clearing all listeners from a specific SCORM event\n   *\n   * @param {string} listenerName\n   */\n  clear(listenerName: String) {\n    const listenerFunctions = listenerName.split(' ');\n    for (let i = 0; i < listenerFunctions.length; i++) {\n      const listenerSplit = listenerFunctions[i].split('.');\n      if (listenerSplit.length === 0) return;\n\n      const functionName = listenerSplit[0];\n\n      let CMIElement = null;\n      if (listenerSplit.length > 1) {\n        CMIElement = listenerName.replace(functionName + '.', '');\n      }\n\n      this.listenerArray = this.listenerArray.filter((obj) =>\n        obj.functionName !== functionName &&\n        obj.CMIElement !== CMIElement,\n      );\n    }\n  }\n\n  /**\n   * Processes any 'on' listeners that have been created\n   *\n   * @param {string} functionName\n   * @param {string} CMIElement\n   * @param {*} value\n   */\n  processListeners(functionName: String, CMIElement: String, value: any) {\n    this.apiLog(functionName, CMIElement, value);\n    for (let i = 0; i < this.listenerArray.length; i++) {\n      const listener = this.listenerArray[i];\n      const functionsMatch = listener.functionName === functionName;\n      const listenerHasCMIElement = !!listener.CMIElement;\n      let CMIElementsMatch = false;\n      if (CMIElement && listener.CMIElement &&\n          listener.CMIElement.substring(listener.CMIElement.length - 1) ===\n          '*') {\n        CMIElementsMatch = CMIElement.indexOf(listener.CMIElement.substring(0,\n            listener.CMIElement.length - 1)) === 0;\n      } else {\n        CMIElementsMatch = listener.CMIElement === CMIElement;\n      }\n\n      if (functionsMatch && (!listenerHasCMIElement || CMIElementsMatch)) {\n        listener.callback(CMIElement, value);\n      }\n    }\n  }\n\n  /**\n   * Throws a SCORM error\n   *\n   * @param {number} errorNumber\n   * @param {string} message\n   */\n  throwSCORMError(errorNumber: number, message: String) {\n    if (!message) {\n      message = this.getLmsErrorMessageDetails(errorNumber);\n    }\n\n    this.apiLog('throwSCORMError', null, errorNumber + ': ' + message,\n        global_constants.LOG_LEVEL_ERROR);\n\n    this.lastErrorCode = String(errorNumber);\n  }\n\n  /**\n   * Clears the last SCORM error code on success.\n   *\n   * @param {string} success\n   */\n  clearSCORMError(success: String) {\n    if (success !== undefined && success !== global_constants.SCORM_FALSE) {\n      this.lastErrorCode = 0;\n    }\n  }\n\n  /**\n   * Attempts to store the data to the LMS, logs data if no LMS configured\n   * APIs that inherit BaseAPI should override this function\n   *\n   * @param {boolean} _calculateTotalTime\n   * @return {string}\n   * @abstract\n   */\n  storeData(_calculateTotalTime) {\n    throw new Error(\n        'The storeData method has not been implemented');\n  }\n\n  /**\n   * Load the CMI from a flattened JSON object\n   * @param {object} json\n   * @param {string} CMIElement\n   */\n  loadFromFlattenedJSON(json, CMIElement) {\n    if (!this.isNotInitialized()) {\n      console.error(\n          'loadFromFlattenedJSON can only be called before the call to lmsInitialize.');\n      return;\n    }\n\n    /**\n     * Test match pattern.\n     *\n     * @param {string} a\n     * @param {string} c\n     * @param {RegExp} a_pattern\n     * @return {number}\n     */\n    function testPattern(a, c, a_pattern) {\n      const a_match = a.match(a_pattern);\n\n      let c_match;\n      if (a_match !== null && (c_match = c.match(a_pattern)) !== null) {\n        const a_num = Number(a_match[2]);\n        const c_num = Number(c_match[2]);\n        if (a_num === c_num) {\n          if (a_match[3] === 'id') {\n            return -1;\n          } else if (a_match[3] === 'type') {\n            if (c_match[3] === 'id') {\n              return 1;\n            } else {\n              return -1;\n            }\n          } else {\n            return 1;\n          }\n        }\n        return a_num - c_num;\n      }\n\n      return null;\n    }\n\n    const int_pattern = /^(cmi\\.interactions\\.)(\\d+)\\.(.*)$/;\n    const obj_pattern = /^(cmi\\.objectives\\.)(\\d+)\\.(.*)$/;\n\n    const result = Object.keys(json).map(function(key) {\n      return [String(key), json[key]];\n    });\n\n    // CMI interactions need to have id and type loaded before any other fields\n    result.sort(function([a, b], [c, d]) {\n      let test;\n      if ((test = testPattern(a, c, int_pattern)) !== null) {\n        return test;\n      }\n      if ((test = testPattern(a, c, obj_pattern)) !== null) {\n        return test;\n      }\n\n      if (a < c) {\n        return -1;\n      }\n      if (a > c) {\n        return 1;\n      }\n      return 0;\n    });\n\n    let obj;\n    result.forEach((element) => {\n      obj = {};\n      obj[element[0]] = element[1];\n      this.loadFromJSON(unflatten(obj), CMIElement);\n    });\n  }\n\n  /**\n   * Loads CMI data from a JSON object.\n   *\n   * @param {object} json\n   * @param {string} CMIElement\n   */\n  loadFromJSON(json, CMIElement) {\n    if (!this.isNotInitialized()) {\n      console.error(\n          'loadFromJSON can only be called before the call to lmsInitialize.');\n      return;\n    }\n\n    CMIElement = CMIElement !== undefined ? CMIElement : 'cmi';\n\n    this.startingData = json;\n\n    // could this be refactored down to flatten(json) then setCMIValue on each?\n    for (const key in json) {\n      if ({}.hasOwnProperty.call(json, key) && json[key]) {\n        const currentCMIElement = (CMIElement ? CMIElement + '.' : '') + key;\n        const value = json[key];\n\n        if (value['childArray']) {\n          for (let i = 0; i < value['childArray'].length; i++) {\n            this.loadFromJSON(value['childArray'][i],\n                currentCMIElement + '.' + i);\n          }\n        } else if (value.constructor === Object) {\n          this.loadFromJSON(value, currentCMIElement);\n        } else {\n          this.setCMIValue(currentCMIElement, value);\n        }\n      }\n    }\n  }\n\n  /**\n   * Render the CMI object to JSON for sending to an LMS.\n   *\n   * @return {string}\n   */\n  renderCMIToJSONString() {\n    const cmi = this.cmi;\n    // Do we want/need to return fields that have no set value?\n    // return JSON.stringify({ cmi }, (k, v) => v === undefined ? null : v, 2);\n    return JSON.stringify({cmi});\n  }\n\n  /**\n   * Returns a JS object representing the current cmi\n   * @return {object}\n   */\n  renderCMIToJSONObject() {\n    // Do we want/need to return fields that have no set value?\n    // return JSON.stringify({ cmi }, (k, v) => v === undefined ? null : v, 2);\n    return JSON.parse(this.renderCMIToJSONString());\n  }\n\n  /**\n   * Render the cmi object to the proper format for LMS commit\n   * APIs that inherit BaseAPI should override this function\n   *\n   * @param {boolean} _terminateCommit\n   * @return {*}\n   * @abstract\n   */\n  renderCommitCMI(_terminateCommit) {\n    throw new Error(\n        'The storeData method has not been implemented');\n  }\n\n  /**\n   * Send the request to the LMS\n   * @param {string} url\n   * @param {object|Array} params\n   * @param {boolean} immediate\n   * @return {object}\n   */\n  processHttpRequest(url: String, params, immediate = false) {\n    const api = this;\n    const process = function(url, params, settings, error_codes) {\n      const genericError = {\n        'result': global_constants.SCORM_FALSE,\n        'errorCode': error_codes.GENERAL,\n      };\n\n      let result;\n      if (!settings.sendBeaconCommit) {\n        const httpReq = new XMLHttpRequest();\n        httpReq.open('POST', url, settings.asyncCommit);\n        if (settings.asyncCommit) {\n          httpReq.onload = function(e) {\n            if (typeof settings.responseHandler === 'function') {\n              result = settings.responseHandler(httpReq);\n            } else {\n              result = JSON.parse(httpReq.responseText);\n            }\n          };\n        }\n        try {\n          if (params instanceof Array) {\n            httpReq.setRequestHeader('Content-Type',\n                'application/x-www-form-urlencoded');\n            httpReq.send(params.join('&'));\n          } else {\n            httpReq.setRequestHeader('Content-Type',\n                settings.commitRequestDataType);\n            httpReq.send(JSON.stringify(params));\n          }\n\n          if (!settings.asyncCommit) {\n            if (typeof settings.responseHandler === 'function') {\n              result = settings.responseHandler(httpReq);\n            } else {\n              result = JSON.parse(httpReq.responseText);\n            }\n          } else {\n            result = {};\n            result.result = global_constants.SCORM_TRUE;\n            result.errorCode = 0;\n            api.processListeners('CommitSuccess');\n            return result;\n          }\n        } catch (e) {\n          console.error(e);\n          api.processListeners('CommitError');\n          return genericError;\n        }\n      } else {\n        try {\n          const headers = {\n            type: settings.commitRequestDataType,\n          };\n          let blob;\n          if (params instanceof Array) {\n            blob = new Blob([params.join('&')], headers);\n          } else {\n            blob = new Blob([JSON.stringify(params)], headers);\n          }\n\n          result = {};\n          if (navigator.sendBeacon(url, blob)) {\n            result.result = global_constants.SCORM_TRUE;\n            result.errorCode = 0;\n          } else {\n            result.result = global_constants.SCORM_FALSE;\n            result.errorCode = 101;\n          }\n        } catch (e) {\n          console.error(e);\n          api.processListeners('CommitError');\n          return genericError;\n        }\n      }\n\n      if (typeof result === 'undefined') {\n        api.processListeners('CommitError');\n        return genericError;\n      }\n\n      if (result.result === true ||\n          result.result === global_constants.SCORM_TRUE) {\n        api.processListeners('CommitSuccess');\n      } else {\n        api.processListeners('CommitError');\n      }\n\n      return result;\n    };\n\n    if (typeof debounce !== 'undefined') {\n      const debounced = debounce(process, 500);\n      debounced(url, params, this.settings, this.error_codes);\n\n      // if we're terminating, go ahead and commit immediately\n      if (immediate) {\n        debounced.flush();\n      }\n\n      return {\n        result: global_constants.SCORM_TRUE,\n        errorCode: 0,\n      };\n    } else {\n      return process(url, params, this.settings, this.error_codes);\n    }\n  }\n\n  /**\n   * Throws a SCORM error\n   *\n   * @param {number} when - the number of milliseconds to wait before committing\n   * @param {string} callback - the name of the commit event callback\n   */\n  scheduleCommit(when: number, callback: string) {\n    this.#timeout = new ScheduledCommit(this, when, callback);\n    this.apiLog('scheduleCommit', '', 'scheduled',\n        global_constants.LOG_LEVEL_DEBUG);\n  }\n\n  /**\n   * Clears and cancels any currently scheduled commits\n   */\n  clearScheduledCommit() {\n    if (this.#timeout) {\n      this.#timeout.cancel();\n      this.#timeout = null;\n      this.apiLog('clearScheduledCommit', '', 'cleared',\n          global_constants.LOG_LEVEL_DEBUG);\n    }\n  }\n}\n\n/**\n * Private class that wraps a timeout call to the commit() function\n */\nclass ScheduledCommit {\n  #API;\n  #cancelled = false;\n  #timeout;\n  #callback;\n\n  /**\n   * Constructor for ScheduledCommit\n   * @param {BaseAPI} API\n   * @param {number} when\n   * @param {string} callback\n   */\n  constructor(API: any, when: number, callback: string) {\n    this.#API = API;\n    this.#timeout = setTimeout(this.wrapper.bind(this), when);\n    this.#callback = callback;\n  }\n\n  /**\n   * Cancel any currently scheduled commit\n   */\n  cancel() {\n    this.#cancelled = true;\n    if (this.#timeout) {\n      clearTimeout(this.#timeout);\n    }\n  }\n\n  /**\n   * Wrap the API commit call to check if the call has already been cancelled\n   */\n  wrapper() {\n    if (!this.#cancelled) {\n      this.#API.commit(this.#callback);\n    }\n  }\n}\n","// @flow\nimport BaseAPI from './BaseAPI';\nimport {\n  CMI,\n  CMIInteractionsCorrectResponsesObject,\n  CMIInteractionsObject,\n  CMIInteractionsObjectivesObject,\n  CMIObjectivesObject, NAV,\n} from './cmi/scorm12_cmi';\nimport * as Utilities from './utilities';\nimport APIConstants from './constants/api_constants';\nimport ErrorCodes from './constants/error_codes';\n\nconst scorm12_constants = APIConstants.scorm12;\nconst global_constants = APIConstants.global;\nconst scorm12_error_codes = ErrorCodes.scorm12;\n\n/**\n * API class for SCORM 1.2\n */\nexport default class Scorm12API extends BaseAPI {\n  /**\n   * Constructor for SCORM 1.2 API\n   * @param {object} settings\n   */\n  constructor(settings: {}) {\n    const finalSettings = {\n      ...{\n        mastery_override: false,\n      }, ...settings,\n    };\n\n    super(scorm12_error_codes, finalSettings);\n\n    this.cmi = new CMI();\n    this.nav = new NAV();\n\n    // Rename functions to match 1.2 Spec and expose to modules\n    this.LMSInitialize = this.lmsInitialize;\n    this.LMSFinish = this.lmsFinish;\n    this.LMSGetValue = this.lmsGetValue;\n    this.LMSSetValue = this.lmsSetValue;\n    this.LMSCommit = this.lmsCommit;\n    this.LMSGetLastError = this.lmsGetLastError;\n    this.LMSGetErrorString = this.lmsGetErrorString;\n    this.LMSGetDiagnostic = this.lmsGetDiagnostic;\n  }\n\n  /**\n   * lmsInitialize function from SCORM 1.2 Spec\n   *\n   * @return {string} bool\n   */\n  lmsInitialize() {\n    this.cmi.initialize();\n    return this.initialize('LMSInitialize', 'LMS was already initialized!',\n        'LMS is already finished!');\n  }\n\n  /**\n   * LMSFinish function from SCORM 1.2 Spec\n   *\n   * @return {string} bool\n   */\n  lmsFinish() {\n    const result = this.terminate('LMSFinish', true);\n\n    if (result === global_constants.SCORM_TRUE) {\n      if (this.nav.event !== '') {\n        if (this.nav.event === 'continue') {\n          this.processListeners('SequenceNext');\n        } else {\n          this.processListeners('SequencePrevious');\n        }\n      } else if (this.settings.autoProgress) {\n        this.processListeners('SequenceNext');\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * LMSGetValue function from SCORM 1.2 Spec\n   *\n   * @param {string} CMIElement\n   * @return {string}\n   */\n  lmsGetValue(CMIElement) {\n    return this.getValue('LMSGetValue', false, CMIElement);\n  }\n\n  /**\n   * LMSSetValue function from SCORM 1.2 Spec\n   *\n   * @param {string} CMIElement\n   * @param {*} value\n   * @return {string}\n   */\n  lmsSetValue(CMIElement, value) {\n    return this.setValue('LMSSetValue', 'LMSCommit', false, CMIElement, value);\n  }\n\n  /**\n   * LMSCommit function from SCORM 1.2 Spec\n   *\n   * @return {string} bool\n   */\n  lmsCommit() {\n    return this.commit('LMSCommit', false);\n  }\n\n  /**\n   * LMSGetLastError function from SCORM 1.2 Spec\n   *\n   * @return {string}\n   */\n  lmsGetLastError() {\n    return this.getLastError('LMSGetLastError');\n  }\n\n  /**\n   * LMSGetErrorString function from SCORM 1.2 Spec\n   *\n   * @param {string} CMIErrorCode\n   * @return {string}\n   */\n  lmsGetErrorString(CMIErrorCode) {\n    return this.getErrorString('LMSGetErrorString', CMIErrorCode);\n  }\n\n  /**\n   * LMSGetDiagnostic function from SCORM 1.2 Spec\n   *\n   * @param {string} CMIErrorCode\n   * @return {string}\n   */\n  lmsGetDiagnostic(CMIErrorCode) {\n    return this.getDiagnostic('LMSGetDiagnostic', CMIErrorCode);\n  }\n\n  /**\n   * Sets a value on the CMI Object\n   *\n   * @param {string} CMIElement\n   * @param {*} value\n   * @return {string}\n   */\n  setCMIValue(CMIElement, value) {\n    return this._commonSetCMIValue('LMSSetValue', false, CMIElement, value);\n  }\n\n  /**\n   * Gets a value from the CMI Object\n   *\n   * @param {string} CMIElement\n   * @return {*}\n   */\n  getCMIValue(CMIElement) {\n    return this._commonGetCMIValue('getCMIValue', false, CMIElement);\n  }\n\n  /**\n   * Gets or builds a new child element to add to the array.\n   *\n   * @param {string} CMIElement\n   * @param {*} value\n   * @param {boolean} foundFirstIndex\n   * @return {object}\n   */\n  getChildElement(CMIElement, value, foundFirstIndex) {\n    let newChild;\n\n    if (this.stringMatches(CMIElement, 'cmi\\\\.objectives\\\\.\\\\d+')) {\n      newChild = new CMIObjectivesObject();\n    } else if (foundFirstIndex && this.stringMatches(CMIElement,\n        'cmi\\\\.interactions\\\\.\\\\d+\\\\.correct_responses\\\\.\\\\d+')) {\n      newChild = new CMIInteractionsCorrectResponsesObject();\n    } else if (foundFirstIndex && this.stringMatches(CMIElement,\n        'cmi\\\\.interactions\\\\.\\\\d+\\\\.objectives\\\\.\\\\d+')) {\n      newChild = new CMIInteractionsObjectivesObject();\n    } else if (!foundFirstIndex &&\n        this.stringMatches(CMIElement, 'cmi\\\\.interactions\\\\.\\\\d+')) {\n      newChild = new CMIInteractionsObject();\n    }\n\n    return newChild;\n  }\n\n  /**\n   * Validates Correct Response values\n   *\n   * @param {string} CMIElement\n   * @param {*} value\n   * @return {boolean}\n   */\n  validateCorrectResponse(CMIElement, value) {\n    return true;\n  }\n\n  /**\n   * Returns the message that corresponds to errorNumber.\n   *\n   * @param {*} errorNumber\n   * @param {boolean} detail\n   * @return {string}\n   */\n  getLmsErrorMessageDetails(errorNumber, detail) {\n    let basicMessage = 'No Error';\n    let detailMessage = 'No Error';\n\n    // Set error number to string since inconsistent from modules if string or number\n    errorNumber = String(errorNumber);\n    if (scorm12_constants.error_descriptions[errorNumber]) {\n      basicMessage = scorm12_constants.error_descriptions[errorNumber].basicMessage;\n      detailMessage = scorm12_constants.error_descriptions[errorNumber].detailMessage;\n    }\n\n    return detail ? detailMessage : basicMessage;\n  }\n\n  /**\n   * Replace the whole API with another\n   *\n   * @param {Scorm12API} newAPI\n   */\n  replaceWithAnotherScormAPI(newAPI) {\n    // Data Model\n    this.cmi = newAPI.cmi;\n  }\n\n  /**\n   * Render the cmi object to the proper format for LMS commit\n   *\n   * @param {boolean} terminateCommit\n   * @return {object|Array}\n   */\n  renderCommitCMI(terminateCommit: boolean) {\n    const cmiExport = this.renderCMIToJSONObject();\n\n    if (terminateCommit) {\n      cmiExport.cmi.core.total_time = this.cmi.getCurrentTotalTime();\n    }\n\n    const result = [];\n    const flattened = Utilities.flatten(cmiExport);\n    switch (this.settings.dataCommitFormat) {\n      case 'flattened':\n        return Utilities.flatten(cmiExport);\n      case 'params':\n        for (const item in flattened) {\n          if ({}.hasOwnProperty.call(flattened, item)) {\n            result.push(`${item}=${flattened[item]}`);\n          }\n        }\n        return result;\n      case 'json':\n      default:\n        return cmiExport;\n    }\n  }\n\n  /**\n   * Attempts to store the data to the LMS\n   *\n   * @param {boolean} terminateCommit\n   * @return {string}\n   */\n  storeData(terminateCommit: boolean) {\n    if (terminateCommit) {\n      const originalStatus = this.cmi.core.lesson_status;\n      if (originalStatus === 'not attempted') {\n        this.cmi.core.lesson_status = 'completed';\n      }\n\n      if (this.cmi.core.lesson_mode === 'normal') {\n        if (this.cmi.core.credit === 'credit') {\n          if (this.settings.mastery_override &&\n              this.cmi.student_data.mastery_score !== '' &&\n              this.cmi.core.score.raw !== '') {\n            if (parseFloat(this.cmi.core.score.raw) >= parseFloat(this.cmi.student_data.mastery_score)) {\n              this.cmi.core.lesson_status = 'passed';\n            } else {\n              this.cmi.core.lesson_status = 'failed';\n            }\n          }\n        }\n      } else if (this.cmi.core.lesson_mode === 'browse') {\n        if ((this.startingData?.cmi?.core?.lesson_status || '') === '' && originalStatus === 'not attempted') {\n          this.cmi.core.lesson_status = 'browsed';\n        }\n      }\n    }\n\n    const commitObject = this.renderCommitCMI(terminateCommit ||\n        this.settings.alwaysSendTotalTime);\n\n    if (this.apiLogLevel === global_constants.LOG_LEVEL_DEBUG) {\n      console.debug('Commit (terminated: ' + (terminateCommit ? 'yes' : 'no') + '): ');\n      console.debug(commitObject);\n    }\n    if (this.settings.lmsCommitUrl) {\n      return this.processHttpRequest(this.settings.lmsCommitUrl, commitObject, terminateCommit);\n    } else {\n      return global_constants.SCORM_TRUE;\n    }\n  }\n}\n","// @flow\nimport BaseAPI from './BaseAPI';\nimport {\n  ADL,\n  CMI,\n  CMICommentsObject,\n  CMIInteractionsCorrectResponsesObject,\n  CMIInteractionsObject,\n  CMIInteractionsObjectivesObject,\n  CMIObjectivesObject,\n} from './cmi/scorm2004_cmi';\nimport * as Utilities from './utilities';\nimport APIConstants from './constants/api_constants';\nimport ErrorCodes from './constants/error_codes';\nimport Responses from './constants/response_constants';\nimport ValidLanguages from './constants/language_constants';\nimport Regex from './constants/regex';\n\nconst scorm2004_constants = APIConstants.scorm2004;\nconst global_constants = APIConstants.global;\nconst scorm2004_error_codes = ErrorCodes.scorm2004;\nconst correct_responses = Responses.correct;\nconst scorm2004_regex = Regex.scorm2004;\n\n/**\n * API class for SCORM 2004\n */\nexport default class Scorm2004API extends BaseAPI {\n  #version: '1.0';\n\n  /**\n   * Constructor for SCORM 2004 API\n   * @param {object} settings\n   */\n  constructor(settings: {}) {\n    const finalSettings = {\n      ...{\n        mastery_override: false,\n      }, ...settings,\n    };\n\n    super(scorm2004_error_codes, finalSettings);\n\n    this.cmi = new CMI();\n    this.adl = new ADL();\n\n    // Rename functions to match 2004 Spec and expose to modules\n    this.Initialize = this.lmsInitialize;\n    this.Terminate = this.lmsTerminate;\n    this.GetValue = this.lmsGetValue;\n    this.SetValue = this.lmsSetValue;\n    this.Commit = this.lmsCommit;\n    this.GetLastError = this.lmsGetLastError;\n    this.GetErrorString = this.lmsGetErrorString;\n    this.GetDiagnostic = this.lmsGetDiagnostic;\n  }\n\n  /**\n   * Getter for #version\n   * @return {string}\n   */\n  get version() {\n    return this.#version;\n  }\n\n  /**\n   * @return {string} bool\n   */\n  lmsInitialize() {\n    this.cmi.initialize();\n    return this.initialize('Initialize');\n  }\n\n  /**\n   * @return {string} bool\n   */\n  lmsTerminate() {\n    const result = this.terminate('Terminate', true);\n\n    if (result === global_constants.SCORM_TRUE) {\n      if (this.adl.nav.request !== '_none_') {\n        switch (this.adl.nav.request) {\n          case 'continue':\n            this.processListeners('SequenceNext');\n            break;\n          case 'previous':\n            this.processListeners('SequencePrevious');\n            break;\n          case 'choice':\n            this.processListeners('SequenceChoice');\n            break;\n          case 'exit':\n            this.processListeners('SequenceExit');\n            break;\n          case 'exitAll':\n            this.processListeners('SequenceExitAll');\n            break;\n          case 'abandon':\n            this.processListeners('SequenceAbandon');\n            break;\n          case 'abandonAll':\n            this.processListeners('SequenceAbandonAll');\n            break;\n        }\n      } else if (this.settings.autoProgress) {\n        this.processListeners('SequenceNext');\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * @param {string} CMIElement\n   * @return {string}\n   */\n  lmsGetValue(CMIElement) {\n    return this.getValue('GetValue', true, CMIElement);\n  }\n\n  /**\n   * @param {string} CMIElement\n   * @param {any} value\n   * @return {string}\n   */\n  lmsSetValue(CMIElement, value) {\n    return this.setValue('SetValue', 'Commit', true, CMIElement, value);\n  }\n\n  /**\n   * Orders LMS to store all content parameters\n   *\n   * @return {string} bool\n   */\n  lmsCommit() {\n    return this.commit('Commit');\n  }\n\n  /**\n   * Returns last error code\n   *\n   * @return {string}\n   */\n  lmsGetLastError() {\n    return this.getLastError('GetLastError');\n  }\n\n  /**\n   * Returns the errorNumber error description\n   *\n   * @param {(string|number)} CMIErrorCode\n   * @return {string}\n   */\n  lmsGetErrorString(CMIErrorCode) {\n    return this.getErrorString('GetErrorString', CMIErrorCode);\n  }\n\n  /**\n   * Returns a comprehensive description of the errorNumber error.\n   *\n   * @param {(string|number)} CMIErrorCode\n   * @return {string}\n   */\n  lmsGetDiagnostic(CMIErrorCode) {\n    return this.getDiagnostic('GetDiagnostic', CMIErrorCode);\n  }\n\n  /**\n   * Sets a value on the CMI Object\n   *\n   * @param {string} CMIElement\n   * @param {any} value\n   * @return {string}\n   */\n  setCMIValue(CMIElement, value) {\n    return this._commonSetCMIValue('SetValue', true, CMIElement, value);\n  }\n\n  /**\n   * Gets or builds a new child element to add to the array.\n   *\n   * @param {string} CMIElement\n   * @param {any} value\n   * @param {boolean} foundFirstIndex\n   * @return {any}\n   */\n  getChildElement(CMIElement, value, foundFirstIndex) {\n    let newChild;\n\n    if (this.stringMatches(CMIElement, 'cmi\\\\.objectives\\\\.\\\\d+')) {\n      newChild = new CMIObjectivesObject();\n    } else if (foundFirstIndex && this.stringMatches(CMIElement,\n        'cmi\\\\.interactions\\\\.\\\\d+\\\\.correct_responses\\\\.\\\\d+')) {\n      const parts = CMIElement.split('.');\n      const index = Number(parts[2]);\n      const interaction = this.cmi.interactions.childArray[index];\n      if (this.isInitialized()) {\n        if (!interaction.type) {\n          this.throwSCORMError(\n              scorm2004_error_codes.DEPENDENCY_NOT_ESTABLISHED);\n        } else {\n          this.checkDuplicateChoiceResponse(interaction, value);\n\n          const response_type = correct_responses[interaction.type];\n          if (response_type) {\n            this.checkValidResponseType(response_type, value, interaction.type);\n          } else {\n            this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE,\n                'Incorrect Response Type: ' + interaction.type);\n          }\n        }\n      }\n      if (this.lastErrorCode === 0) {\n        newChild = new CMIInteractionsCorrectResponsesObject();\n      }\n    } else if (foundFirstIndex && this.stringMatches(CMIElement,\n        'cmi\\\\.interactions\\\\.\\\\d+\\\\.objectives\\\\.\\\\d+')) {\n      newChild = new CMIInteractionsObjectivesObject();\n    } else if (!foundFirstIndex &&\n        this.stringMatches(CMIElement, 'cmi\\\\.interactions\\\\.\\\\d+')) {\n      newChild = new CMIInteractionsObject();\n    } else if (this.stringMatches(CMIElement,\n        'cmi\\\\.comments_from_learner\\\\.\\\\d+')) {\n      newChild = new CMICommentsObject();\n    } else if (this.stringMatches(CMIElement,\n        'cmi\\\\.comments_from_lms\\\\.\\\\d+')) {\n      newChild = new CMICommentsObject(true);\n    }\n\n    return newChild;\n  }\n\n  /**\n   * Checks for valid response types\n   * @param {object} response_type\n   * @param {any} value\n   * @param {string} interaction_type\n   */\n  checkValidResponseType(response_type, value, interaction_type) {\n    let nodes = [];\n    if (response_type?.delimiter) {\n      nodes = String(value).split(response_type.delimiter);\n    } else {\n      nodes[0] = value;\n    }\n\n    if (nodes.length > 0 && nodes.length <= response_type.max) {\n      this.checkCorrectResponseValue(interaction_type, nodes, value);\n    } else if (nodes.length > response_type.max) {\n      this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE,\n          'Data Model Element Pattern Too Long');\n    }\n  }\n\n  /**\n   * Checks for duplicate 'choice' responses.\n   * @param {CMIInteractionsObject} interaction\n   * @param {any} value\n   */\n  checkDuplicateChoiceResponse(interaction, value) {\n    const interaction_count = interaction.correct_responses._count;\n    if (interaction.type === 'choice') {\n      for (let i = 0; i < interaction_count && this.lastErrorCode ===\n      0; i++) {\n        const response = interaction.correct_responses.childArray[i];\n        if (response.pattern === value) {\n          this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE);\n        }\n      }\n    }\n  }\n\n  /**\n   * Validate correct response.\n   * @param {string} CMIElement\n   * @param {*} value\n   */\n  validateCorrectResponse(CMIElement, value) {\n    const parts = CMIElement.split('.');\n    const index = Number(parts[2]);\n    const pattern_index = Number(parts[4]);\n    const interaction = this.cmi.interactions.childArray[index];\n\n    const interaction_count = interaction.correct_responses._count;\n    this.checkDuplicateChoiceResponse(interaction, value);\n\n    const response_type = correct_responses[interaction.type];\n    if (typeof response_type.limit === 'undefined' || interaction_count <=\n        response_type.limit) {\n      this.checkValidResponseType(response_type, value, interaction.type);\n\n      if (this.lastErrorCode === 0 &&\n          (!response_type.duplicate ||\n              !this.checkDuplicatedPattern(interaction.correct_responses,\n                  pattern_index, value)) ||\n          (this.lastErrorCode === 0 && value === '')) {\n        // do nothing, we want the inverse\n      } else {\n        if (this.lastErrorCode === 0) {\n          this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE,\n              'Data Model Element Pattern Already Exists');\n        }\n      }\n    } else {\n      this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE,\n          'Data Model Element Collection Limit Reached');\n    }\n  }\n\n  /**\n   * Gets a value from the CMI Object\n   *\n   * @param {string} CMIElement\n   * @return {*}\n   */\n  getCMIValue(CMIElement) {\n    return this._commonGetCMIValue('GetValue', true, CMIElement);\n  }\n\n  /**\n   * Returns the message that corresponds to errorNumber.\n   *\n   * @param {(string|number)} errorNumber\n   * @param {boolean} detail\n   * @return {string}\n   */\n  getLmsErrorMessageDetails(errorNumber, detail) {\n    let basicMessage = '';\n    let detailMessage = '';\n\n    // Set error number to string since inconsistent from modules if string or number\n    errorNumber = String(errorNumber);\n    if (scorm2004_constants.error_descriptions[errorNumber]) {\n      basicMessage = scorm2004_constants.error_descriptions[errorNumber].basicMessage;\n      detailMessage = scorm2004_constants.error_descriptions[errorNumber].detailMessage;\n    }\n\n    return detail ? detailMessage : basicMessage;\n  }\n\n  /**\n   * Check to see if a correct_response value has been duplicated\n   * @param {CMIArray} correct_response\n   * @param {number} current_index\n   * @param {*} value\n   * @return {boolean}\n   */\n  checkDuplicatedPattern = (correct_response, current_index, value) => {\n    let found = false;\n    const count = correct_response._count;\n    for (let i = 0; i < count && !found; i++) {\n      if (i !== current_index && correct_response.childArray[i] === value) {\n        found = true;\n      }\n    }\n    return found;\n  };\n\n  /**\n   * Checks for a valid correct_response value\n   * @param {string} interaction_type\n   * @param {Array} nodes\n   * @param {*} value\n   */\n  checkCorrectResponseValue(interaction_type, nodes, value) {\n    const response = correct_responses[interaction_type];\n    const formatRegex = new RegExp(response.format);\n    for (let i = 0; i < nodes.length && this.lastErrorCode === 0; i++) {\n      if (interaction_type.match(\n          '^(fill-in|long-fill-in|matching|performance|sequencing)$')) {\n        nodes[i] = this.removeCorrectResponsePrefixes(nodes[i]);\n      }\n\n      if (response?.delimiter2) {\n        const values = nodes[i].split(response.delimiter2);\n        if (values.length === 2) {\n          const matches = values[0].match(formatRegex);\n          if (!matches) {\n            this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n          } else {\n            if (!values[1].match(new RegExp(response.format2))) {\n              this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n            }\n          }\n        } else {\n          this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n        }\n      } else {\n        const matches = nodes[i].match(formatRegex);\n        if ((!matches && value !== '') ||\n            (!matches && interaction_type === 'true-false')) {\n          this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n        } else {\n          if (interaction_type === 'numeric' && nodes.length > 1) {\n            if (Number(nodes[0]) > Number(nodes[1])) {\n              this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n            }\n          } else {\n            if (nodes[i] !== '' && response.unique) {\n              for (let j = 0; j < i && this.lastErrorCode === 0; j++) {\n                if (nodes[i] === nodes[j]) {\n                  this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n                }\n              }\n            }\n          }\n        }\n      }\n    }\n  }\n\n  /**\n   * Remove prefixes from correct_response\n   * @param {string} node\n   * @return {*}\n   */\n  removeCorrectResponsePrefixes(node) {\n    let seenOrder = false;\n    let seenCase = false;\n    let seenLang = false;\n\n    const prefixRegex = new RegExp(\n        '^({(lang|case_matters|order_matters)=([^}]+)})');\n    let matches = node.match(prefixRegex);\n    let langMatches = null;\n    while (matches) {\n      switch (matches[2]) {\n        case 'lang':\n          langMatches = node.match(scorm2004_regex.CMILangcr);\n          if (langMatches) {\n            const lang = langMatches[3];\n            if (lang !== undefined && lang.length > 0) {\n              if (ValidLanguages[lang.toLowerCase()] === undefined) {\n                this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n              }\n            }\n          }\n          seenLang = true;\n          break;\n        case 'case_matters':\n          if (!seenLang && !seenOrder && !seenCase) {\n            if (matches[3] !== 'true' && matches[3] !== 'false') {\n              this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n            }\n          }\n\n          seenCase = true;\n          break;\n        case 'order_matters':\n          if (!seenCase && !seenLang && !seenOrder) {\n            if (matches[3] !== 'true' && matches[3] !== 'false') {\n              this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n            }\n          }\n\n          seenOrder = true;\n          break;\n        default:\n          break;\n      }\n      node = node.substr(matches[1].length);\n      matches = node.match(prefixRegex);\n    }\n\n    return node;\n  }\n\n  /**\n   * Replace the whole API with another\n   * @param {Scorm2004API} newAPI\n   */\n  replaceWithAnotherScormAPI(newAPI) {\n    // Data Model\n    this.cmi = newAPI.cmi;\n    this.adl = newAPI.adl;\n  }\n\n  /**\n   * Render the cmi object to the proper format for LMS commit\n   *\n   * @param {boolean} terminateCommit\n   * @return {object|Array}\n   */\n  renderCommitCMI(terminateCommit: boolean) {\n    const cmiExport = this.renderCMIToJSONObject();\n\n    if (terminateCommit) {\n      cmiExport.cmi.total_time = this.cmi.getCurrentTotalTime();\n    }\n\n    const result = [];\n    const flattened = Utilities.flatten(cmiExport);\n    switch (this.settings.dataCommitFormat) {\n      case 'flattened':\n        return Utilities.flatten(cmiExport);\n      case 'params':\n        for (const item in flattened) {\n          if ({}.hasOwnProperty.call(flattened, item)) {\n            result.push(`${item}=${flattened[item]}`);\n          }\n        }\n        return result;\n      case 'json':\n      default:\n        return cmiExport;\n    }\n  }\n\n  /**\n   * Attempts to store the data to the LMS\n   *\n   * @param {boolean} terminateCommit\n   * @return {string}\n   */\n  storeData(terminateCommit: boolean) {\n    if (terminateCommit) {\n      if (this.cmi.mode === 'normal') {\n        if (this.cmi.credit === 'credit') {\n          if (this.cmi.completion_threshold && this.cmi.progress_measure) {\n            if (this.cmi.progress_measure >= this.cmi.completion_threshold) {\n              console.debug('Setting Completion Status: Completed');\n              this.cmi.completion_status = 'completed';\n            } else {\n              console.debug('Setting Completion Status: Incomplete');\n              this.cmi.completion_status = 'incomplete';\n            }\n          }\n          if (this.cmi.scaled_passing_score && this.cmi.score.scaled) {\n            if (this.cmi.score.scaled >= this.cmi.scaled_passing_score) {\n              console.debug('Setting Success Status: Passed');\n              this.cmi.success_status = 'passed';\n            } else {\n              console.debug('Setting Success Status: Failed');\n              this.cmi.success_status = 'failed';\n            }\n          }\n        }\n      }\n    }\n\n    let navRequest = false;\n    if (this.adl.nav.request !== (this.startingData?.adl?.nav?.request) &&\n        this.adl.nav.request !== '_none_') {\n      this.adl.nav.request = encodeURIComponent(this.adl.nav.request);\n      navRequest = true;\n    }\n\n    const commitObject = this.renderCommitCMI(terminateCommit ||\n        this.settings.alwaysSendTotalTime);\n\n    if (this.apiLogLevel === global_constants.LOG_LEVEL_DEBUG) {\n      console.debug('Commit (terminated: ' +\n            (terminateCommit ? 'yes' : 'no') + '): ');\n      console.debug(commitObject);\n    }\n    if (this.settings.lmsCommitUrl) {\n      const result = this.processHttpRequest(this.settings.lmsCommitUrl,\n          commitObject, terminateCommit);\n\n      // check if this is a sequencing call, and then call the necessary JS\n      {\n        if (navRequest && result.navRequest !== undefined &&\n            result.navRequest !== '') {\n          Function(`\"use strict\";(() => { ${result.navRequest} })()`)();\n        }\n      }\n      return result;\n    } else {\n      return global_constants.SCORM_TRUE;\n    }\n  }\n}\n","import * as Scorm12CMI from './scorm12_cmi';\nimport {BaseCMI, checkValidFormat, CMIArray, CMIScore} from './common';\nimport APIConstants from '../constants/api_constants';\nimport Regex from '../constants/regex';\nimport ErrorCodes from '../constants/error_codes';\nimport {AICCValidationError} from '../exceptions';\n\nconst aicc_constants = APIConstants.aicc;\nconst aicc_regex = Regex.aicc;\nconst aicc_error_codes = ErrorCodes.scorm12;\n\n/**\n * Helper method for throwing Read Only error\n */\nfunction throwReadOnlyError() {\n  throw new AICCValidationError(aicc_error_codes.READ_ONLY_ELEMENT);\n}\n\n/**\n * Helper method, no reason to have to pass the same error codes every time\n * @param {*} value\n * @param {string} regexPattern\n * @param {boolean} allowEmptyString\n * @return {boolean}\n */\nfunction checkAICCValidFormat(\n    value: String,\n    regexPattern: String,\n    allowEmptyString?: boolean) {\n  return checkValidFormat(\n      value,\n      regexPattern,\n      aicc_error_codes.TYPE_MISMATCH,\n      AICCValidationError,\n      allowEmptyString\n  );\n}\n\n/**\n * CMI Class for AICC\n */\nexport class CMI extends Scorm12CMI.CMI {\n  /**\n   * Constructor for AICC CMI object\n   * @param {boolean} initialized\n   */\n  constructor(initialized: boolean) {\n    super(aicc_constants.cmi_children);\n\n    if (initialized) this.initialize();\n\n    this.student_preference = new AICCStudentPreferences();\n    this.student_data = new AICCCMIStudentData();\n    this.student_demographics = new CMIStudentDemographics();\n    this.evaluation = new CMIEvaluation();\n    this.paths = new CMIPaths();\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.student_preference?.initialize();\n    this.student_data?.initialize();\n    this.student_demographics?.initialize();\n    this.evaluation?.initialize();\n    this.paths?.initialize();\n  }\n\n  /**\n   * toJSON for cmi\n   *\n   * @return {\n   *    {\n   *      suspend_data: string,\n   *      launch_data: string,\n   *      comments: string,\n   *      comments_from_lms: string,\n   *      core: CMICore,\n   *      objectives: CMIObjectives,\n   *      student_data: CMIStudentData,\n   *      student_preference: CMIStudentPreference,\n   *      interactions: CMIInteractions,\n   *      paths: CMIPaths\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'suspend_data': this.suspend_data,\n      'launch_data': this.launch_data,\n      'comments': this.comments,\n      'comments_from_lms': this.comments_from_lms,\n      'core': this.core,\n      'objectives': this.objectives,\n      'student_data': this.student_data,\n      'student_preference': this.student_preference,\n      'student_demographics': this.student_demographics,\n      'interactions': this.interactions,\n      'evaluation': this.evaluation,\n      'paths': this.paths,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * AICC Evaluation object\n */\nclass CMIEvaluation extends BaseCMI {\n  /**\n   * Constructor for AICC Evaluation object\n   */\n  constructor() {\n    super();\n\n    this.comments = new CMIEvaluationComments();\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.comments?.initialize();\n  }\n\n  /**\n   * toJSON for cmi.evaluation object\n   * @return {{comments: CMIEvaluationComments}}\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'comments': this.comments,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing AICC's cmi.evaluation.comments object\n */\nclass CMIEvaluationComments extends CMIArray {\n  /**\n   * Constructor for AICC Evaluation Comments object\n   */\n  constructor() {\n    super({\n      children: aicc_constants.comments_children,\n      errorCode: aicc_error_codes.INVALID_SET_VALUE,\n      errorClass: AICCValidationError,\n    });\n  }\n}\n\n/**\n * StudentPreferences class for AICC\n */\nclass AICCStudentPreferences extends Scorm12CMI.CMIStudentPreference {\n  /**\n   * Constructor for AICC Student Preferences object\n   */\n  constructor() {\n    super(aicc_constants.student_preference_children);\n\n    this.windows = new CMIArray({\n      errorCode: aicc_error_codes.INVALID_SET_VALUE,\n      errorClass: AICCValidationError,\n      children: '',\n    });\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.windows?.initialize();\n  }\n\n  #lesson_type = '';\n  #text_color = '';\n  #text_location = '';\n  #text_size = '';\n  #video = '';\n\n  /**\n   * Getter for #lesson_type\n   * @return {string}\n   */\n  get lesson_type(): string {\n    return this.#lesson_type;\n  }\n\n  /**\n   * Setter for #lesson_type\n   * @param {string} lesson_type\n   */\n  set lesson_type(lesson_type: string) {\n    if (checkAICCValidFormat(lesson_type, aicc_regex.CMIString256)) {\n      this.#lesson_type = lesson_type;\n    }\n  }\n\n  /**\n   * Getter for #text_color\n   * @return {string}\n   */\n  get text_color(): string {\n    return this.#text_color;\n  }\n\n  /**\n   * Setter for #text_color\n   * @param {string} text_color\n   */\n  set text_color(text_color: string) {\n    if (checkAICCValidFormat(text_color, aicc_regex.CMIString256)) {\n      this.#text_color = text_color;\n    }\n  }\n\n  /**\n   * Getter for #text_location\n   * @return {string}\n   */\n  get text_location(): string {\n    return this.#text_location;\n  }\n\n  /**\n   * Setter for #text_location\n   * @param {string} text_location\n   */\n  set text_location(text_location: string) {\n    if (checkAICCValidFormat(text_location, aicc_regex.CMIString256)) {\n      this.#text_location = text_location;\n    }\n  }\n\n  /**\n   * Getter for #text_size\n   * @return {string}\n   */\n  get text_size(): string {\n    return this.#text_size;\n  }\n\n  /**\n   * Setter for #text_size\n   * @param {string} text_size\n   */\n  set text_size(text_size: string) {\n    if (checkAICCValidFormat(text_size, aicc_regex.CMIString256)) {\n      this.#text_size = text_size;\n    }\n  }\n\n  /**\n   * Getter for #video\n   * @return {string}\n   */\n  get video(): string {\n    return this.#video;\n  }\n\n  /**\n   * Setter for #video\n   * @param {string} video\n   */\n  set video(video: string) {\n    if (checkAICCValidFormat(video, aicc_regex.CMIString256)) {\n      this.#video = video;\n    }\n  }\n\n  /**\n   * toJSON for cmi.student_preference\n   *\n   * @return {\n   *    {\n   *      audio: string,\n   *      language: string,\n   *      speed: string,\n   *      text: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'audio': this.audio,\n      'language': this.language,\n      'lesson_type': this.lesson_type,\n      'speed': this.speed,\n      'text': this.text,\n      'text_color': this.text_color,\n      'text_location': this.text_location,\n      'text_size': this.text_size,\n      'video': this.video,\n      'windows': this.windows,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * StudentData class for AICC\n */\nclass AICCCMIStudentData extends Scorm12CMI.CMIStudentData {\n  /**\n   * Constructor for AICC StudentData object\n   */\n  constructor() {\n    super(aicc_constants.student_data_children);\n\n    this.tries = new CMITries();\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.tries?.initialize();\n  }\n\n  #tries_during_lesson = '';\n\n  /**\n   * Getter for tries_during_lesson\n   * @return {string}\n   */\n  get tries_during_lesson() {\n    return this.#tries_during_lesson;\n  }\n\n  /**\n   * Setter for #tries_during_lesson. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} tries_during_lesson\n   */\n  set tries_during_lesson(tries_during_lesson) {\n    !this.initialized ?\n        this.#tries_during_lesson = tries_during_lesson :\n        throwReadOnlyError();\n  }\n\n  /**\n   * toJSON for cmi.student_data object\n   * @return {\n   *    {\n   *      mastery_score: string,\n   *      max_time_allowed: string,\n   *      time_limit_action: string,\n   *      tries: CMITries\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'mastery_score': this.mastery_score,\n      'max_time_allowed': this.max_time_allowed,\n      'time_limit_action': this.time_limit_action,\n      'tries': this.tries,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing the AICC cmi.student_demographics object\n */\nexport class CMIStudentDemographics extends BaseCMI {\n  /**\n   * Constructor for AICC StudentDemographics object\n   */\n  constructor() {\n    super();\n  }\n\n  #_children = aicc_constants.student_demographics_children;\n  #city = '';\n  #class = '';\n  #company = '';\n  #country = '';\n  #experience = '';\n  #familiar_name = '';\n  #instructor_name = '';\n  #title = '';\n  #native_language = '';\n  #state = '';\n  #street_address = '';\n  #telephone = '';\n  #years_experience = '';\n\n  /**\n   * Getter for _children\n   * @return {string}\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Getter for city\n   * @return {string}\n   */\n  get city() {\n    return this.#city;\n  }\n\n  /**\n   * Setter for #city. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} city\n   */\n  set city(city) {\n    !this.initialized ?\n        this.#city = city :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for class\n   * @return {string}\n   */\n  get class() {\n    return this.#class;\n  }\n\n  /**\n   * Setter for #class. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} clazz\n   */\n  set class(clazz) {\n    !this.initialized ?\n        this.#class = clazz :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for company\n   * @return {string}\n   */\n  get company() {\n    return this.#company;\n  }\n\n  /**\n   * Setter for #company. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} company\n   */\n  set company(company) {\n    !this.initialized ?\n        this.#company = company :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for country\n   * @return {string}\n   */\n  get country() {\n    return this.#country;\n  }\n\n  /**\n   * Setter for #country. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} country\n   */\n  set country(country) {\n    !this.initialized ?\n        this.#country = country :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for experience\n   * @return {string}\n   */\n  get experience() {\n    return this.#experience;\n  }\n\n  /**\n   * Setter for #experience. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} experience\n   */\n  set experience(experience) {\n    !this.initialized ?\n        this.#experience = experience :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for familiar_name\n   * @return {string}\n   */\n  get familiar_name() {\n    return this.#familiar_name;\n  }\n\n  /**\n   * Setter for #familiar_name. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} familiar_name\n   */\n  set familiar_name(familiar_name) {\n    !this.initialized ?\n        this.#familiar_name = familiar_name :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for instructor_name\n   * @return {string}\n   */\n  get instructor_name() {\n    return this.#instructor_name;\n  }\n\n  /**\n   * Setter for #instructor_name. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} instructor_name\n   */\n  set instructor_name(instructor_name) {\n    !this.initialized ?\n        this.#instructor_name = instructor_name :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for title\n   * @return {string}\n   */\n  get title() {\n    return this.#title;\n  }\n\n  /**\n   * Setter for #title. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} title\n   */\n  set title(title) {\n    !this.initialized ?\n        this.#title = title :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for native_language\n   * @return {string}\n   */\n  get native_language() {\n    return this.#native_language;\n  }\n\n  /**\n   * Setter for #native_language. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} native_language\n   */\n  set native_language(native_language) {\n    !this.initialized ?\n        this.#native_language = native_language :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for state\n   * @return {string}\n   */\n  get state() {\n    return this.#state;\n  }\n\n  /**\n   * Setter for #state. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} state\n   */\n  set state(state) {\n    !this.initialized ?\n        this.#state = state :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for street_address\n   * @return {string}\n   */\n  get street_address() {\n    return this.#street_address;\n  }\n\n  /**\n   * Setter for #street_address. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} street_address\n   */\n  set street_address(street_address) {\n    !this.initialized ?\n        this.#street_address = street_address :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for telephone\n   * @return {string}\n   */\n  get telephone() {\n    return this.#telephone;\n  }\n\n  /**\n   * Setter for #telephone. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} telephone\n   */\n  set telephone(telephone) {\n    !this.initialized ?\n        this.#telephone = telephone :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for years_experience\n   * @return {string}\n   */\n  get years_experience() {\n    return this.#years_experience;\n  }\n\n  /**\n   * Setter for #years_experience. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} years_experience\n   */\n  set years_experience(years_experience) {\n    !this.initialized ?\n        this.#years_experience = years_experience :\n        throwReadOnlyError();\n  }\n\n  /**\n   * toJSON for cmi.student_demographics object\n   * @return {\n   *      {\n   *        city: string,\n   *        class: string,\n   *        company: string,\n   *        country: string,\n   *        experience: string,\n   *        familiar_name: string,\n   *        instructor_name: string,\n   *        title: string,\n   *        native_language: string,\n   *        state: string,\n   *        street_address: string,\n   *        telephone: string,\n   *        years_experience: string\n   *      }\n   *    }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'city': this.city,\n      'class': this.class,\n      'company': this.company,\n      'country': this.country,\n      'experience': this.experience,\n      'familiar_name': this.familiar_name,\n      'instructor_name': this.instructor_name,\n      'title': this.title,\n      'native_language': this.native_language,\n      'state': this.state,\n      'street_address': this.street_address,\n      'telephone': this.telephone,\n      'years_experience': this.years_experience,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing the AICC cmi.paths object\n */\nexport class CMIPaths extends CMIArray {\n  /**\n   * Constructor for inline Paths Array class\n   */\n  constructor() {\n    super({children: aicc_constants.paths_children});\n  }\n}\n\n/**\n * Class for AICC Paths\n */\nexport class CMIPathsObject extends BaseCMI {\n  /**\n   * Constructor for AICC Paths objects\n   */\n  constructor() {\n    super();\n  }\n\n  #location_id = '';\n  #date = '';\n  #time = '';\n  #status = '';\n  #why_left = '';\n  #time_in_element = '';\n\n  /**\n   * Getter for #location_id\n   * @return {string}\n   */\n  get location_id() {\n    return this.#location_id;\n  }\n\n  /**\n   * Setter for #location_id\n   * @param {string} location_id\n   */\n  set location_id(location_id) {\n    if (checkAICCValidFormat(location_id, aicc_regex.CMIString256)) {\n      this.#location_id = location_id;\n    }\n  }\n\n  /**\n   * Getter for #date\n   * @return {string}\n   */\n  get date() {\n    return this.#date;\n  }\n\n  /**\n   * Setter for #date\n   * @param {string} date\n   */\n  set date(date) {\n    if (checkAICCValidFormat(date, aicc_regex.CMIString256)) {\n      this.#date = date;\n    }\n  }\n\n  /**\n   * Getter for #time\n   * @return {string}\n   */\n  get time() {\n    return this.#time;\n  }\n\n  /**\n   * Setter for #time\n   * @param {string} time\n   */\n  set time(time) {\n    if (checkAICCValidFormat(time, aicc_regex.CMITime)) {\n      this.#time = time;\n    }\n  }\n\n  /**\n   * Getter for #status\n   * @return {string}\n   */\n  get status() {\n    return this.#status;\n  }\n\n  /**\n   * Setter for #status\n   * @param {string} status\n   */\n  set status(status) {\n    if (checkAICCValidFormat(status, aicc_regex.CMIStatus2)) {\n      this.#status = status;\n    }\n  }\n\n  /**\n   * Getter for #why_left\n   * @return {string}\n   */\n  get why_left() {\n    return this.#why_left;\n  }\n\n  /**\n   * Setter for #why_left\n   * @param {string} why_left\n   */\n  set why_left(why_left) {\n    if (checkAICCValidFormat(why_left, aicc_regex.CMIString256)) {\n      this.#why_left = why_left;\n    }\n  }\n\n  /**\n   * Getter for #time_in_element\n   * @return {string}\n   */\n  get time_in_element() {\n    return this.#time_in_element;\n  }\n\n  /**\n   * Setter for #time_in_element\n   * @param {string} time_in_element\n   */\n  set time_in_element(time_in_element) {\n    if (checkAICCValidFormat(time_in_element, aicc_regex.CMITime)) {\n      this.#time_in_element = time_in_element;\n    }\n  }\n\n  /**\n   * toJSON for cmi.paths.n object\n   * @return {\n   *    {\n   *      location_id: string,\n   *      date: string,\n   *      time: string,\n   *      status: string,\n   *      why_left: string,\n   *      time_in_element: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'location_id': this.location_id,\n      'date': this.date,\n      'time': this.time,\n      'status': this.status,\n      'why_left': this.why_left,\n      'time_in_element': this.time_in_element,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing the AICC cmi.student_data.tries object\n */\nexport class CMITries extends CMIArray {\n  /**\n   * Constructor for inline Tries Array class\n   */\n  constructor() {\n    super({children: aicc_constants.tries_children});\n  }\n}\n\n/**\n * Class for AICC Tries\n */\nexport class CMITriesObject extends BaseCMI {\n  /**\n   * Constructor for AICC Tries object\n   */\n  constructor() {\n    super();\n\n    this.score = new CMIScore(\n        {\n          score_children: aicc_constants.score_children,\n          score_range: aicc_regex.score_range,\n          invalidErrorCode: aicc_error_codes.INVALID_SET_VALUE,\n          invalidTypeCode: aicc_error_codes.TYPE_MISMATCH,\n          invalidRangeCode: aicc_error_codes.VALUE_OUT_OF_RANGE,\n          errorClass: AICCValidationError,\n        });\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.score?.initialize();\n  }\n\n  #status = '';\n  #time = '';\n\n  /**\n   * Getter for #status\n   * @return {string}\n   */\n  get status() {\n    return this.#status;\n  }\n\n  /**\n   * Setter for #status\n   * @param {string} status\n   */\n  set status(status) {\n    if (checkAICCValidFormat(status, aicc_regex.CMIStatus2)) {\n      this.#status = status;\n    }\n  }\n\n  /**\n   * Getter for #time\n   * @return {string}\n   */\n  get time() {\n    return this.#time;\n  }\n\n  /**\n   * Setter for #time\n   * @param {string} time\n   */\n  set time(time) {\n    if (checkAICCValidFormat(time, aicc_regex.CMITime)) {\n      this.#time = time;\n    }\n  }\n\n  /**\n   * toJSON for cmi.student_data.tries.n object\n   * @return {\n   *    {\n   *      status: string,\n   *      time: string,\n   *      score: CMIScore\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'status': this.status,\n      'time': this.time,\n      'score': this.score,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class for cmi.student_data.attempt_records array\n */\nexport class CMIAttemptRecords extends CMIArray {\n  /**\n   * Constructor for inline Tries Array class\n   */\n  constructor() {\n    super({children: aicc_constants.attempt_records_children});\n  }\n}\n\n/**\n * Class for AICC Attempt Records\n */\nexport class CMIAttemptRecordsObject extends BaseCMI {\n  /**\n   * Constructor for AICC Attempt Records object\n   */\n  constructor() {\n    super();\n\n    this.score = new CMIScore(\n        {\n          score_children: aicc_constants.score_children,\n          score_range: aicc_regex.score_range,\n          invalidErrorCode: aicc_error_codes.INVALID_SET_VALUE,\n          invalidTypeCode: aicc_error_codes.TYPE_MISMATCH,\n          invalidRangeCode: aicc_error_codes.VALUE_OUT_OF_RANGE,\n          errorClass: AICCValidationError,\n        });\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.score?.initialize();\n  }\n\n  #lesson_status = '';\n\n  /**\n   * Getter for #lesson_status\n   * @return {string}\n   */\n  get lesson_status() {\n    return this.#lesson_status;\n  }\n\n  /**\n   * Setter for #lesson_status\n   * @param {string} lesson_status\n   */\n  set lesson_status(lesson_status) {\n    if (checkAICCValidFormat(lesson_status, aicc_regex.CMIStatus2)) {\n      this.#lesson_status = lesson_status;\n    }\n  }\n\n  /**\n   * toJSON for cmi.student_data.attempt_records.n object\n   * @return {\n   *    {\n   *      status: string,\n   *      time: string,\n   *      score: CMIScore\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'lesson_status': this.lesson_status,\n      'score': this.score,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class for AICC Evaluation Comments\n */\nexport class CMIEvaluationCommentsObject extends BaseCMI {\n  /**\n   * Constructor for Evaluation Comments\n   */\n  constructor() {\n    super();\n  }\n\n  #content = '';\n  #location = '';\n  #time = '';\n\n  /**\n   * Getter for #content\n   * @return {string}\n   */\n  get content() {\n    return this.#content;\n  }\n\n  /**\n   * Setter for #content\n   * @param {string} content\n   */\n  set content(content) {\n    if (checkAICCValidFormat(content, aicc_regex.CMIString256)) {\n      this.#content = content;\n    }\n  }\n\n  /**\n   * Getter for #location\n   * @return {string}\n   */\n  get location() {\n    return this.#location;\n  }\n\n  /**\n   * Setter for #location\n   * @param {string} location\n   */\n  set location(location) {\n    if (checkAICCValidFormat(location, aicc_regex.CMIString256)) {\n      this.#location = location;\n    }\n  }\n\n  /**\n   * Getter for #time\n   * @return {string}\n   */\n  get time() {\n    return this.#time;\n  }\n\n  /**\n   * Setting for #time\n   * @param {string} time\n   */\n  set time(time) {\n    if (checkAICCValidFormat(time, aicc_regex.CMITime)) {\n      this.#time = time;\n    }\n  }\n\n  /**\n   * toJSON for cmi.evaulation.comments.n object\n   * @return {\n   *    {\n   *      content: string,\n   *      location: string,\n   *      time: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'content': this.content,\n      'location': this.location,\n      'time': this.time,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n","// @flow\nimport APIConstants from '../constants/api_constants';\nimport ErrorCodes from '../constants/error_codes';\nimport Regex from '../constants/regex';\n\nconst scorm12_constants = APIConstants.scorm12;\nconst scorm12_regex = Regex.scorm12;\nconst scorm12_error_codes = ErrorCodes.scorm12;\n\n/**\n * Check if the value matches the proper format. If not, throw proper error code.\n *\n * @param {string} value\n * @param {string} regexPattern\n * @param {number} errorCode\n * @param {class} errorClass\n * @param {boolean} allowEmptyString\n * @return {boolean}\n */\nexport function checkValidFormat(\n    value: String,\n    regexPattern: String,\n    errorCode: number,\n    errorClass: function,\n    allowEmptyString?: boolean) {\n  const formatRegex = new RegExp(regexPattern);\n  const matches = value.match(formatRegex);\n  if (allowEmptyString && value === '') {\n    return true;\n  }\n  if (value === undefined || !matches || matches[0] === '') {\n    throw new errorClass.prototype.constructor(errorCode);\n  }\n  return true;\n}\n\n/**\n * Check if the value matches the proper range. If not, throw proper error code.\n *\n * @param {*} value\n * @param {string} rangePattern\n * @param {number} errorCode\n * @param {class} errorClass\n * @return {boolean}\n */\nexport function checkValidRange(\n    value: any,\n    rangePattern: String,\n    errorCode: number,\n    errorClass: function) {\n  const ranges = rangePattern.split('#');\n  value = value * 1.0;\n  if (value >= ranges[0]) {\n    if ((ranges[1] === '*') || (value <= ranges[1])) {\n      return true;\n    } else {\n      throw new errorClass.prototype.constructor(errorCode);\n    }\n  } else {\n    throw new errorClass.prototype.constructor(errorCode);\n  }\n}\n\n/**\n * Base class for API cmi objects\n */\nexport class BaseCMI {\n  jsonString = false;\n  #initialized = false;\n  #start_time;\n\n  /**\n   * Constructor for BaseCMI, just marks the class as abstract\n   */\n  constructor() {\n    if (new.target === BaseCMI) {\n      throw new TypeError('Cannot construct BaseCMI instances directly');\n    }\n  }\n\n  /**\n   * Getter for #initialized\n   * @return {boolean}\n   */\n  get initialized() {\n    return this.#initialized;\n  }\n\n  /**\n   * Getter for #start_time\n   * @return {Number}\n   */\n  get start_time() {\n    return this.#start_time;\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    this.#initialized = true;\n  }\n\n  /**\n   * Called when the player should override the 'session_time' provided by\n   * the module\n   */\n  setStartTime() {\n    this.#start_time = new Date().getTime();\n  }\n}\n\n/**\n * Base class for cmi *.score objects\n */\nexport class CMIScore extends BaseCMI {\n  /**\n   * Constructor for *.score\n   * @param {string} score_children\n   * @param {string} score_range\n   * @param {string} max\n   * @param {number} invalidErrorCode\n   * @param {number} invalidTypeCode\n   * @param {number} invalidRangeCode\n   * @param {string} decimalRegex\n   * @param {class} errorClass\n   */\n  constructor(\n      {\n        score_children,\n        score_range,\n        max,\n        invalidErrorCode,\n        invalidTypeCode,\n        invalidRangeCode,\n        decimalRegex,\n        errorClass,\n      }) {\n    super();\n\n    this.#_children = score_children ||\n        scorm12_constants.score_children;\n    this.#_score_range = !score_range ? false : scorm12_regex.score_range;\n    this.#max = (max || max === '') ? max : '100';\n    this.#_invalid_error_code = invalidErrorCode ||\n        scorm12_error_codes.INVALID_SET_VALUE;\n    this.#_invalid_type_code = invalidTypeCode ||\n        scorm12_error_codes.TYPE_MISMATCH;\n    this.#_invalid_range_code = invalidRangeCode ||\n        scorm12_error_codes.VALUE_OUT_OF_RANGE;\n    this.#_decimal_regex = decimalRegex ||\n        scorm12_regex.CMIDecimal;\n    this.#_error_class = errorClass;\n  }\n\n  #_children;\n  #_score_range;\n  #_invalid_error_code;\n  #_invalid_type_code;\n  #_invalid_range_code;\n  #_decimal_regex;\n  #_error_class;\n  #raw = '';\n  #min = '';\n  #max;\n\n  /**\n   * Getter for _children\n   * @return {string}\n   * @private\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for _children. Just throws an error.\n   * @param {string} _children\n   * @private\n   */\n  set _children(_children) {\n    throw new this.#_error_class.prototype.constructor(this.#_invalid_error_code);\n  }\n\n  /**\n   * Getter for #raw\n   * @return {string}\n   */\n  get raw() {\n    return this.#raw;\n  }\n\n  /**\n   * Setter for #raw\n   * @param {string} raw\n   */\n  set raw(raw) {\n    if (checkValidFormat(raw, this.#_decimal_regex, this.#_invalid_type_code, this.#_error_class) &&\n        (!this.#_score_range ||\n            checkValidRange(raw, this.#_score_range, this.#_invalid_range_code, this.#_error_class))) {\n      this.#raw = raw;\n    }\n  }\n\n  /**\n   * Getter for #min\n   * @return {string}\n   */\n  get min() {\n    return this.#min;\n  }\n\n  /**\n   * Setter for #min\n   * @param {string} min\n   */\n  set min(min) {\n    if (checkValidFormat(min, this.#_decimal_regex, this.#_invalid_type_code, this.#_error_class) &&\n        (!this.#_score_range ||\n            checkValidRange(min, this.#_score_range, this.#_invalid_range_code, this.#_error_class))) {\n      this.#min = min;\n    }\n  }\n\n  /**\n   * Getter for #max\n   * @return {string}\n   */\n  get max() {\n    return this.#max;\n  }\n\n  /**\n   * Setter for #max\n   * @param {string} max\n   */\n  set max(max) {\n    if (checkValidFormat(max, this.#_decimal_regex, this.#_invalid_type_code, this.#_error_class) &&\n        (!this.#_score_range ||\n            checkValidRange(max, this.#_score_range, this.#_invalid_range_code, this.#_error_class))) {\n      this.#max = max;\n    }\n  }\n\n  /**\n   * toJSON for *.score\n   * @return {{min: string, max: string, raw: string}}\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'raw': this.raw,\n      'min': this.min,\n      'max': this.max,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Base class for cmi *.n objects\n */\nexport class CMIArray extends BaseCMI {\n  /**\n   * Constructor cmi *.n arrays\n   * @param {string} children\n   * @param {number} errorCode\n   * @param {class} errorClass\n   */\n  constructor({children, errorCode, errorClass}) {\n    super();\n    this.#_children = children;\n    this.#errorCode = errorCode;\n    this.#errorClass = errorClass;\n    this.childArray = [];\n  }\n\n  #errorCode;\n  #errorClass;\n  #_children;\n\n  /**\n   * Getter for _children\n   * @return {*}\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for _children. Just throws an error.\n   * @param {string} _children\n   */\n  set _children(_children) {\n    throw new this.#errorClass.prototype.constructor(this.#errorCode);\n  }\n\n  /**\n   * Getter for _count\n   * @return {number}\n   */\n  get _count() {\n    return this.childArray.length;\n  }\n\n  /**\n   * Setter for _count. Just throws an error.\n   * @param {number} _count\n   */\n  set _count(_count) {\n    throw new this.#errorClass.prototype.constructor(this.#errorCode);\n  }\n\n  /**\n   * toJSON for *.n arrays\n   * @return {object}\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {};\n    for (let i = 0; i < this.childArray.length; i++) {\n      result[i + ''] = this.childArray[i];\n    }\n    delete this.jsonString;\n    return result;\n  }\n}\n","// @flow\nimport {\n  BaseCMI,\n  checkValidFormat,\n  checkValidRange,\n  CMIArray,\n  CMIScore,\n} from './common';\nimport APIConstants from '../constants/api_constants';\nimport ErrorCodes from '../constants/error_codes';\nimport Regex from '../constants/regex';\nimport {Scorm12ValidationError} from '../exceptions';\nimport * as Utilities from '../utilities';\nimport * as Util from '../utilities';\n\nconst scorm12_constants = APIConstants.scorm12;\nconst scorm12_regex = Regex.scorm12;\nconst scorm12_error_codes = ErrorCodes.scorm12;\n\n/**\n * Helper method for throwing Read Only error\n */\nexport function throwReadOnlyError() {\n  throw new Scorm12ValidationError(scorm12_error_codes.READ_ONLY_ELEMENT);\n}\n\n/**\n * Helper method for throwing Write Only error\n */\nexport function throwWriteOnlyError() {\n  throw new Scorm12ValidationError(scorm12_error_codes.WRITE_ONLY_ELEMENT);\n}\n\n/**\n * Helper method for throwing Invalid Set error\n */\nfunction throwInvalidValueError() {\n  throw new Scorm12ValidationError(scorm12_error_codes.INVALID_SET_VALUE);\n}\n\n/**\n * Helper method, no reason to have to pass the same error codes every time\n * @param {*} value\n * @param {string} regexPattern\n * @param {boolean} allowEmptyString\n * @return {boolean}\n */\nexport function check12ValidFormat(\n    value: String,\n    regexPattern: String,\n    allowEmptyString?: boolean) {\n  return checkValidFormat(\n      value,\n      regexPattern,\n      scorm12_error_codes.TYPE_MISMATCH,\n      Scorm12ValidationError,\n      allowEmptyString\n  );\n}\n\n/**\n * Helper method, no reason to have to pass the same error codes every time\n * @param {*} value\n * @param {string} rangePattern\n * @param {boolean} allowEmptyString\n * @return {boolean}\n */\nexport function check12ValidRange(\n    value: any,\n    rangePattern: String,\n    allowEmptyString?: boolean) {\n  return checkValidRange(\n      value,\n      rangePattern,\n      scorm12_error_codes.VALUE_OUT_OF_RANGE,\n      Scorm12ValidationError,\n      allowEmptyString\n  );\n}\n\n/**\n * Class representing the cmi object for SCORM 1.2\n */\nexport class CMI extends BaseCMI {\n  #_children = '';\n  #_version = '3.4';\n  #launch_data = '';\n  #comments = '';\n  #comments_from_lms = '';\n\n  student_data = null;\n\n  /**\n   * Constructor for the SCORM 1.2 cmi object\n   * @param {string} cmi_children\n   * @param {(CMIStudentData|AICCCMIStudentData)} student_data\n   * @param {boolean} initialized\n   */\n  constructor(cmi_children, student_data, initialized: boolean) {\n    super();\n\n    if (initialized) this.initialize();\n\n    this.#_children = cmi_children ?\n        cmi_children :\n        scorm12_constants.cmi_children;\n    this.core = new CMICore();\n    this.objectives = new CMIObjectives();\n    this.student_data = student_data ? student_data : new CMIStudentData();\n    this.student_preference = new CMIStudentPreference();\n    this.interactions = new CMIInteractions();\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.core?.initialize();\n    this.objectives?.initialize();\n    this.student_data?.initialize();\n    this.student_preference?.initialize();\n    this.interactions?.initialize();\n  }\n\n  /**\n   * toJSON for cmi\n   *\n   * @return {\n   *    {\n   *      suspend_data: string,\n   *      launch_data: string,\n   *      comments: string,\n   *      comments_from_lms: string,\n   *      core: CMICore,\n   *      objectives: CMIObjectives,\n   *      student_data: CMIStudentData,\n   *      student_preference: CMIStudentPreference,\n   *      interactions: CMIInteractions\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'suspend_data': this.suspend_data,\n      'launch_data': this.launch_data,\n      'comments': this.comments,\n      'comments_from_lms': this.comments_from_lms,\n      'core': this.core,\n      'objectives': this.objectives,\n      'student_data': this.student_data,\n      'student_preference': this.student_preference,\n      'interactions': this.interactions,\n    };\n    delete this.jsonString;\n    return result;\n  }\n\n  /**\n   * Getter for #_version\n   * @return {string}\n   */\n  get _version() {\n    return this.#_version;\n  }\n\n  /**\n   * Setter for #_version. Just throws an error.\n   * @param {string} _version\n   */\n  set _version(_version) {\n    throwInvalidValueError();\n  }\n\n  /**\n   * Getter for #_children\n   * @return {string}\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for #_version. Just throws an error.\n   * @param {string} _children\n   */\n  set _children(_children) {\n    throwInvalidValueError();\n  }\n\n  /**\n   * Getter for #suspend_data\n   * @return {string}\n   */\n  get suspend_data() {\n    return this.core?.suspend_data;\n  }\n\n  /**\n   * Setter for #suspend_data\n   * @param {string} suspend_data\n   */\n  set suspend_data(suspend_data) {\n    if (this.core) {\n      this.core.suspend_data = suspend_data;\n    }\n  }\n\n  /**\n   * Getter for #launch_data\n   * @return {string}\n   */\n  get launch_data() {\n    return this.#launch_data;\n  }\n\n  /**\n   * Setter for #launch_data. Can only be called before  initialization.\n   * @param {string} launch_data\n   */\n  set launch_data(launch_data) {\n    !this.initialized ? this.#launch_data = launch_data : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #comments\n   * @return {string}\n   */\n  get comments() {\n    return this.#comments;\n  }\n\n  /**\n   * Setter for #comments\n   * @param {string} comments\n   */\n  set comments(comments) {\n    if (check12ValidFormat(comments, scorm12_regex.CMIString4096, true)) {\n      this.#comments = comments;\n    }\n  }\n\n  /**\n   * Getter for #comments_from_lms\n   * @return {string}\n   */\n  get comments_from_lms() {\n    return this.#comments_from_lms;\n  }\n\n  /**\n   * Setter for #comments_from_lms. Can only be called before  initialization.\n   * @param {string} comments_from_lms\n   */\n  set comments_from_lms(comments_from_lms) {\n    !this.initialized ?\n        this.#comments_from_lms = comments_from_lms :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Adds the current session time to the existing total time.\n   *\n   * @return {string}\n   */\n  getCurrentTotalTime() {\n    return this.core.getCurrentTotalTime(this.start_time);\n  }\n}\n\n/**\n * Class representing the cmi.core object\n * @extends BaseCMI\n */\nclass CMICore extends BaseCMI {\n  /**\n   * Constructor for cmi.core\n   */\n  constructor() {\n    super();\n\n    this.score = new CMIScore(\n        {\n          score_children: scorm12_constants.score_children,\n          score_range: scorm12_regex.score_range,\n          invalidErrorCode: scorm12_error_codes.INVALID_SET_VALUE,\n          invalidTypeCode: scorm12_error_codes.TYPE_MISMATCH,\n          invalidRangeCode: scorm12_error_codes.VALUE_OUT_OF_RANGE,\n          errorClass: Scorm12ValidationError,\n        });\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.score?.initialize();\n  }\n\n  #_children = scorm12_constants.core_children;\n  #student_id = '';\n  #student_name = '';\n  #lesson_location = '';\n  #credit = '';\n  #lesson_status = 'not attempted';\n  #entry = '';\n  #total_time = '';\n  #lesson_mode = 'normal';\n  #exit = '';\n  #session_time = '00:00:00';\n  #suspend_data = '';\n\n  /**\n   * Getter for #_children\n   * @return {string}\n   * @private\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for #_children. Just throws an error.\n   * @param {string} _children\n   * @private\n   */\n  set _children(_children) {\n    throwInvalidValueError();\n  }\n\n  /**\n   * Getter for #student_id\n   * @return {string}\n   */\n  get student_id() {\n    return this.#student_id;\n  }\n\n  /**\n   * Setter for #student_id. Can only be called before  initialization.\n   * @param {string} student_id\n   */\n  set student_id(student_id) {\n    !this.initialized ? this.#student_id = student_id : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #student_name\n   * @return {string}\n   */\n  get student_name() {\n    return this.#student_name;\n  }\n\n  /**\n   * Setter for #student_name. Can only be called before  initialization.\n   * @param {string} student_name\n   */\n  set student_name(student_name) {\n    !this.initialized ?\n        this.#student_name = student_name :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #lesson_location\n   * @return {string}\n   */\n  get lesson_location() {\n    return this.#lesson_location;\n  }\n\n  /**\n   * Setter for #lesson_location\n   * @param {string} lesson_location\n   */\n  set lesson_location(lesson_location) {\n    if (check12ValidFormat(lesson_location, scorm12_regex.CMIString256, true)) {\n      this.#lesson_location = lesson_location;\n    }\n  }\n\n  /**\n   * Getter for #credit\n   * @return {string}\n   */\n  get credit() {\n    return this.#credit;\n  }\n\n  /**\n   * Setter for #credit. Can only be called before  initialization.\n   * @param {string} credit\n   */\n  set credit(credit) {\n    !this.initialized ? this.#credit = credit : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #lesson_status\n   * @return {string}\n   */\n  get lesson_status() {\n    return this.#lesson_status;\n  }\n\n  /**\n   * Setter for #lesson_status\n   * @param {string} lesson_status\n   */\n  set lesson_status(lesson_status) {\n    if (this.initialized) {\n      if (check12ValidFormat(lesson_status, scorm12_regex.CMIStatus)) {\n        this.#lesson_status = lesson_status;\n      }\n    } else {\n      if (check12ValidFormat(lesson_status, scorm12_regex.CMIStatus2)) {\n        this.#lesson_status = lesson_status;\n      }\n    }\n  }\n\n  /**\n   * Getter for #entry\n   * @return {string}\n   */\n  get entry() {\n    return this.#entry;\n  }\n\n  /**\n   * Setter for #entry. Can only be called before  initialization.\n   * @param {string} entry\n   */\n  set entry(entry) {\n    !this.initialized ? this.#entry = entry : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #total_time\n   * @return {string}\n   */\n  get total_time() {\n    return this.#total_time;\n  }\n\n  /**\n   * Setter for #total_time. Can only be called before  initialization.\n   * @param {string} total_time\n   */\n  set total_time(total_time) {\n    !this.initialized ? this.#total_time = total_time : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #lesson_mode\n   * @return {string}\n   */\n  get lesson_mode() {\n    return this.#lesson_mode;\n  }\n\n  /**\n   * Setter for #lesson_mode. Can only be called before  initialization.\n   * @param {string} lesson_mode\n   */\n  set lesson_mode(lesson_mode) {\n    !this.initialized ? this.#lesson_mode = lesson_mode : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #exit. Should only be called during JSON export.\n   * @return {*}\n   */\n  get exit() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#exit;\n  }\n\n  /**\n   * Setter for #exit\n   * @param {string} exit\n   */\n  set exit(exit) {\n    if (check12ValidFormat(exit, scorm12_regex.CMIExit, true)) {\n      this.#exit = exit;\n    }\n  }\n\n  /**\n   * Getter for #session_time. Should only be called during JSON export.\n   * @return {*}\n   */\n  get session_time() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#session_time;\n  }\n\n  /**\n   * Setter for #session_time\n   * @param {string} session_time\n   */\n  set session_time(session_time) {\n    if (check12ValidFormat(session_time, scorm12_regex.CMITimespan)) {\n      this.#session_time = session_time;\n    }\n  }\n\n  /**\n   * Getter for #suspend_data\n   * @return {string}\n   */\n  get suspend_data() {\n    return this.#suspend_data;\n  }\n\n  /**\n   * Setter for #suspend_data\n   * @param {string} suspend_data\n   */\n  set suspend_data(suspend_data) {\n    if (check12ValidFormat(suspend_data, scorm12_regex.CMIString4096, true)) {\n      this.#suspend_data = suspend_data;\n    }\n  }\n\n  /**\n   * Adds the current session time to the existing total time.\n   * @param {Number} start_time\n   * @return {string}\n   */\n  getCurrentTotalTime(start_time: Number) {\n    let sessionTime = this.#session_time;\n    const startTime = start_time;\n\n    if (typeof startTime !== 'undefined' && startTime !== null) {\n      const seconds = new Date().getTime() - startTime;\n      sessionTime = Util.getSecondsAsHHMMSS(seconds / 1000);\n    }\n\n    return Utilities.addHHMMSSTimeStrings(\n        this.#total_time,\n        sessionTime,\n        new RegExp(scorm12_regex.CMITimespan),\n    );\n  }\n\n  /**\n   * toJSON for cmi.core\n   *\n   * @return {\n   *    {\n   *      student_name: string,\n   *      entry: string,\n   *      exit: string,\n   *      score: CMIScore,\n   *      student_id: string,\n   *      lesson_mode: string,\n   *      lesson_location: string,\n   *      lesson_status: string,\n   *      credit: string,\n   *      session_time: *\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'student_id': this.student_id,\n      'student_name': this.student_name,\n      'lesson_location': this.lesson_location,\n      'credit': this.credit,\n      'lesson_status': this.lesson_status,\n      'entry': this.entry,\n      'lesson_mode': this.lesson_mode,\n      'exit': this.exit,\n      'session_time': this.session_time,\n      'score': this.score,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.objectives object\n * @extends CMIArray\n */\nclass CMIObjectives extends CMIArray {\n  /**\n   * Constructor for cmi.objectives\n   */\n  constructor() {\n    super({\n      children: scorm12_constants.objectives_children,\n      errorCode: scorm12_error_codes.INVALID_SET_VALUE,\n      errorClass: Scorm12ValidationError,\n    });\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.student_data object\n * @extends BaseCMI\n */\nexport class CMIStudentData extends BaseCMI {\n  #_children;\n  #mastery_score = '';\n  #max_time_allowed = '';\n  #time_limit_action = '';\n\n  /**\n   * Constructor for cmi.student_data\n   * @param {string} student_data_children\n   */\n  constructor(student_data_children) {\n    super();\n\n    this.#_children = student_data_children ?\n        student_data_children :\n        scorm12_constants.student_data_children;\n  }\n\n  /**\n   * Getter for #_children\n   * @return {*}\n   * @private\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for #_children. Just throws an error.\n   * @param {string} _children\n   * @private\n   */\n  set _children(_children) {\n    throwInvalidValueError();\n  }\n\n  /**\n   * Getter for #master_score\n   * @return {string}\n   */\n  get mastery_score() {\n    return this.#mastery_score;\n  }\n\n  /**\n   * Setter for #master_score. Can only be called before  initialization.\n   * @param {string} mastery_score\n   */\n  set mastery_score(mastery_score) {\n    !this.initialized ?\n        this.#mastery_score = mastery_score :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #max_time_allowed\n   * @return {string}\n   */\n  get max_time_allowed() {\n    return this.#max_time_allowed;\n  }\n\n  /**\n   * Setter for #max_time_allowed. Can only be called before  initialization.\n   * @param {string} max_time_allowed\n   */\n  set max_time_allowed(max_time_allowed) {\n    !this.initialized ?\n        this.#max_time_allowed = max_time_allowed :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #time_limit_action\n   * @return {string}\n   */\n  get time_limit_action() {\n    return this.#time_limit_action;\n  }\n\n  /**\n   * Setter for #time_limit_action. Can only be called before  initialization.\n   * @param {string} time_limit_action\n   */\n  set time_limit_action(time_limit_action) {\n    !this.initialized ?\n        this.#time_limit_action = time_limit_action :\n        throwReadOnlyError();\n  }\n\n  /**\n   * toJSON for cmi.student_data\n   *\n   * @return {\n   *    {\n   *      max_time_allowed: string,\n   *      time_limit_action: string,\n   *      mastery_score: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'mastery_score': this.mastery_score,\n      'max_time_allowed': this.max_time_allowed,\n      'time_limit_action': this.time_limit_action,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.student_preference object\n * @extends BaseCMI\n */\nexport class CMIStudentPreference extends BaseCMI {\n  #_children;\n\n  /**\n   * Constructor for cmi.student_preference\n   * @param {string} student_preference_children\n   */\n  constructor(student_preference_children) {\n    super();\n\n    this.#_children = student_preference_children ?\n        student_preference_children :\n        scorm12_constants.student_preference_children;\n  }\n\n  #audio = '';\n  #language = '';\n  #speed = '';\n  #text = '';\n\n  /**\n   * Getter for #_children\n   * @return {string}\n   * @private\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for #_children. Just throws an error.\n   * @param {string} _children\n   * @private\n   */\n  set _children(_children) {\n    throwInvalidValueError();\n  }\n\n  /**\n   * Getter for #audio\n   * @return {string}\n   */\n  get audio() {\n    return this.#audio;\n  }\n\n  /**\n   * Setter for #audio\n   * @param {string} audio\n   */\n  set audio(audio) {\n    if (check12ValidFormat(audio, scorm12_regex.CMISInteger) &&\n        check12ValidRange(audio, scorm12_regex.audio_range)) {\n      this.#audio = audio;\n    }\n  }\n\n  /**\n   * Getter for #language\n   * @return {string}\n   */\n  get language() {\n    return this.#language;\n  }\n\n  /**\n   * Setter for #language\n   * @param {string} language\n   */\n  set language(language) {\n    if (check12ValidFormat(language, scorm12_regex.CMIString256)) {\n      this.#language = language;\n    }\n  }\n\n  /**\n   * Getter for #speed\n   * @return {string}\n   */\n  get speed() {\n    return this.#speed;\n  }\n\n  /**\n   * Setter for #speed\n   * @param {string} speed\n   */\n  set speed(speed) {\n    if (check12ValidFormat(speed, scorm12_regex.CMISInteger) &&\n        check12ValidRange(speed, scorm12_regex.speed_range)) {\n      this.#speed = speed;\n    }\n  }\n\n  /**\n   * Getter for #text\n   * @return {string}\n   */\n  get text() {\n    return this.#text;\n  }\n\n  /**\n   * Setter for #text\n   * @param {string} text\n   */\n  set text(text) {\n    if (check12ValidFormat(text, scorm12_regex.CMISInteger) &&\n        check12ValidRange(text, scorm12_regex.text_range)) {\n      this.#text = text;\n    }\n  }\n\n  /**\n   * toJSON for cmi.student_preference\n   *\n   * @return {\n   *    {\n   *      audio: string,\n   *      language: string,\n   *      speed: string,\n   *      text: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'audio': this.audio,\n      'language': this.language,\n      'speed': this.speed,\n      'text': this.text,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.interactions object\n * @extends BaseCMI\n */\nclass CMIInteractions extends CMIArray {\n  /**\n   * Constructor for cmi.interactions\n   */\n  constructor() {\n    super({\n      children: scorm12_constants.interactions_children,\n      errorCode: scorm12_error_codes.INVALID_SET_VALUE,\n      errorClass: Scorm12ValidationError,\n    });\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.interactions.n object\n * @extends BaseCMI\n */\nexport class CMIInteractionsObject extends BaseCMI {\n  /**\n   * Constructor for cmi.interactions.n object\n   */\n  constructor() {\n    super();\n\n    this.objectives = new CMIArray({\n      errorCode: scorm12_error_codes.INVALID_SET_VALUE,\n      errorClass: Scorm12ValidationError,\n      children: scorm12_constants.objectives_children,\n    });\n    this.correct_responses = new CMIArray({\n      errorCode: scorm12_error_codes.INVALID_SET_VALUE,\n      errorClass: Scorm12ValidationError,\n      children: scorm12_constants.correct_responses_children,\n    });\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.objectives?.initialize();\n    this.correct_responses?.initialize();\n  }\n\n  #id = '';\n  #time = '';\n  #type = '';\n  #weighting = '';\n  #student_response = '';\n  #result = '';\n  #latency = '';\n\n  /**\n   * Getter for #id. Should only be called during JSON export.\n   * @return {*}\n   */\n  get id() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#id;\n  }\n\n  /**\n   * Setter for #id\n   * @param {string} id\n   */\n  set id(id) {\n    if (check12ValidFormat(id, scorm12_regex.CMIIdentifier)) {\n      this.#id = id;\n    }\n  }\n\n  /**\n   * Getter for #time. Should only be called during JSON export.\n   * @return {*}\n   */\n  get time() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#time;\n  }\n\n  /**\n   * Setter for #time\n   * @param {string} time\n   */\n  set time(time) {\n    if (check12ValidFormat(time, scorm12_regex.CMITime)) {\n      this.#time = time;\n    }\n  }\n\n  /**\n   * Getter for #type. Should only be called during JSON export.\n   * @return {*}\n   */\n  get type() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#type;\n  }\n\n  /**\n   * Setter for #type\n   * @param {string} type\n   */\n  set type(type) {\n    if (check12ValidFormat(type, scorm12_regex.CMIType)) {\n      this.#type = type;\n    }\n  }\n\n  /**\n   * Getter for #weighting. Should only be called during JSON export.\n   * @return {*}\n   */\n  get weighting() {\n    return (!this.jsonString) ?\n        throwWriteOnlyError() :\n        this.#weighting;\n  }\n\n  /**\n   * Setter for #weighting\n   * @param {string} weighting\n   */\n  set weighting(weighting) {\n    if (check12ValidFormat(weighting, scorm12_regex.CMIDecimal) &&\n        check12ValidRange(weighting, scorm12_regex.weighting_range)) {\n      this.#weighting = weighting;\n    }\n  }\n\n  /**\n   * Getter for #student_response. Should only be called during JSON export.\n   * @return {*}\n   */\n  get student_response() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#student_response;\n  }\n\n  /**\n   * Setter for #student_response\n   * @param {string} student_response\n   */\n  set student_response(student_response) {\n    if (check12ValidFormat(student_response, scorm12_regex.CMIFeedback, true)) {\n      this.#student_response = student_response;\n    }\n  }\n\n  /**\n   * Getter for #result. Should only be called during JSON export.\n   * @return {*}\n   */\n  get result() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#result;\n  }\n\n  /**\n   * Setter for #result\n   * @param {string} result\n   */\n  set result(result) {\n    if (check12ValidFormat(result, scorm12_regex.CMIResult)) {\n      this.#result = result;\n    }\n  }\n\n  /**\n   * Getter for #latency. Should only be called during JSON export.\n   * @return {*}\n   */\n  get latency() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#latency;\n  }\n\n  /**\n   * Setter for #latency\n   * @param {string} latency\n   */\n  set latency(latency) {\n    if (check12ValidFormat(latency, scorm12_regex.CMITimespan)) {\n      this.#latency = latency;\n    }\n  }\n\n  /**\n   * toJSON for cmi.interactions.n\n   *\n   * @return {\n   *    {\n   *      id: string,\n   *      time: string,\n   *      type: string,\n   *      weighting: string,\n   *      student_response: string,\n   *      result: string,\n   *      latency: string,\n   *      objectives: CMIArray,\n   *      correct_responses: CMIArray\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'id': this.id,\n      'time': this.time,\n      'type': this.type,\n      'weighting': this.weighting,\n      'student_response': this.student_response,\n      'result': this.result,\n      'latency': this.latency,\n      'objectives': this.objectives,\n      'correct_responses': this.correct_responses,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.objectives.n object\n * @extends BaseCMI\n */\nexport class CMIObjectivesObject extends BaseCMI {\n  /**\n   * Constructor for cmi.objectives.n\n   */\n  constructor() {\n    super();\n\n    this.score = new CMIScore(\n        {\n          score_children: scorm12_constants.score_children,\n          score_range: scorm12_regex.score_range,\n          invalidErrorCode: scorm12_error_codes.INVALID_SET_VALUE,\n          invalidTypeCode: scorm12_error_codes.TYPE_MISMATCH,\n          invalidRangeCode: scorm12_error_codes.VALUE_OUT_OF_RANGE,\n          errorClass: Scorm12ValidationError,\n        });\n  }\n\n  #id = '';\n  #status = '';\n\n  /**\n   * Getter for #id\n   * @return {\"\"}\n   */\n  get id() {\n    return this.#id;\n  }\n\n  /**\n   * Setter for #id\n   * @param {string} id\n   */\n  set id(id) {\n    if (check12ValidFormat(id, scorm12_regex.CMIIdentifier)) {\n      this.#id = id;\n    }\n  }\n\n  /**\n   * Getter for #status\n   * @return {\"\"}\n   */\n  get status() {\n    return this.#status;\n  }\n\n  /**\n   * Setter for #status\n   * @param {string} status\n   */\n  set status(status) {\n    if (check12ValidFormat(status, scorm12_regex.CMIStatus2)) {\n      this.#status = status;\n    }\n  }\n\n  /**\n   * toJSON for cmi.objectives.n\n   * @return {\n   *    {\n   *      id: string,\n   *      status: string,\n   *      score: CMIScore\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'id': this.id,\n      'status': this.status,\n      'score': this.score,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.interactions.n.objectives.n object\n * @extends BaseCMI\n */\nexport class CMIInteractionsObjectivesObject extends BaseCMI {\n  /**\n   * Constructor for cmi.interactions.n.objectives.n\n   */\n  constructor() {\n    super();\n  }\n\n  #id = '';\n\n  /**\n   * Getter for #id\n   * @return {\"\"}\n   */\n  get id() {\n    return this.#id;\n  }\n\n  /**\n   * Setter for #id\n   * @param {string} id\n   */\n  set id(id) {\n    if (check12ValidFormat(id, scorm12_regex.CMIIdentifier)) {\n      this.#id = id;\n    }\n  }\n\n  /**\n   * toJSON for cmi.interactions.n.objectives.n\n   * @return {\n   *    {\n   *      id: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'id': this.id,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.interactions.correct_responses.n object\n * @extends BaseCMI\n */\nexport class CMIInteractionsCorrectResponsesObject extends BaseCMI {\n  /**\n   * Constructor for cmi.interactions.correct_responses.n\n   */\n  constructor() {\n    super();\n  }\n\n  #pattern = '';\n\n  /**\n   * Getter for #pattern\n   * @return {string}\n   */\n  get pattern() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#pattern;\n  }\n\n  /**\n   * Setter for #pattern\n   * @param {string} pattern\n   */\n  set pattern(pattern) {\n    if (check12ValidFormat(pattern, scorm12_regex.CMIFeedback, true)) {\n      this.#pattern = pattern;\n    }\n  }\n\n  /**\n   * toJSON for cmi.interactions.correct_responses.n\n   * @return {\n   *    {\n   *      pattern: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'pattern': this.pattern,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class for AICC Navigation object\n */\nexport class NAV extends BaseCMI {\n  /**\n   * Constructor for NAV object\n   */\n  constructor() {\n    super();\n  }\n\n  #event = '';\n\n  /**\n   * Getter for #event\n   * @return {string}\n   */\n  get event() {\n    return this.#event;\n  }\n\n  /**\n   * Setter for #event\n   * @param {string} event\n   */\n  set event(event) {\n    if (check12ValidFormat(event, scorm12_regex.NAVEvent)) {\n      this.#event = event;\n    }\n  }\n\n  /**\n   * toJSON for nav object\n   * @return {\n   *    {\n   *      event: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'event': this.event,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n","// @flow\nimport {\n  BaseCMI,\n  checkValidFormat,\n  checkValidRange,\n  CMIArray,\n  CMIScore,\n} from './common';\nimport APIConstants from '../constants/api_constants';\nimport Regex from '../constants/regex';\nimport ErrorCodes from '../constants/error_codes';\nimport Responses from '../constants/response_constants';\nimport {Scorm2004ValidationError} from '../exceptions';\nimport * as Util from '../utilities';\n\nconst scorm2004_constants = APIConstants.scorm2004;\nconst scorm2004_error_codes = ErrorCodes.scorm2004;\nconst learner_responses = Responses.learner;\n\nconst scorm2004_regex = Regex.scorm2004;\n\n/**\n * Helper method for throwing Read Only error\n */\nfunction throwReadOnlyError() {\n  throw new Scorm2004ValidationError(scorm2004_error_codes.READ_ONLY_ELEMENT);\n}\n\n/**\n * Helper method for throwing Write Only error\n */\nfunction throwWriteOnlyError() {\n  throw new Scorm2004ValidationError(scorm2004_error_codes.WRITE_ONLY_ELEMENT);\n}\n\n/**\n * Helper method for throwing Type Mismatch error\n */\nfunction throwTypeMismatchError() {\n  throw new Scorm2004ValidationError(scorm2004_error_codes.TYPE_MISMATCH);\n}\n\n/**\n * Helper method for throwing Dependency Not Established error\n */\nfunction throwDependencyNotEstablishedError() {\n  throw new Scorm2004ValidationError(scorm2004_error_codes.DEPENDENCY_NOT_ESTABLISHED);\n}\n\n/**\n * Helper method for throwing Dependency Not Established error\n */\nfunction throwGeneralSetError() {\n  throw new Scorm2004ValidationError(scorm2004_error_codes.GENERAL_SET_FAILURE);\n}\n\n/**\n * Helper method, no reason to have to pass the same error codes every time\n * @param {*} value\n * @param {string} regexPattern\n * @param {boolean} allowEmptyString\n * @return {boolean}\n */\nfunction check2004ValidFormat(\n    value: String,\n    regexPattern: String,\n    allowEmptyString?: boolean) {\n  return checkValidFormat(\n      value,\n      regexPattern,\n      scorm2004_error_codes.TYPE_MISMATCH,\n      Scorm2004ValidationError,\n      allowEmptyString,\n  );\n}\n\n/**\n * Helper method, no reason to have to pass the same error codes every time\n * @param {*} value\n * @param {string} rangePattern\n * @return {boolean}\n */\nfunction check2004ValidRange(value: any, rangePattern: String) {\n  return checkValidRange(\n      value,\n      rangePattern,\n      scorm2004_error_codes.VALUE_OUT_OF_RANGE,\n      Scorm2004ValidationError,\n  );\n}\n\n/**\n * Class representing cmi object for SCORM 2004\n */\nexport class CMI extends BaseCMI {\n  /**\n   * Constructor for the SCORM 2004 cmi object\n   * @param {boolean} initialized\n   */\n  constructor(initialized: boolean) {\n    super();\n\n    this.learner_preference = new CMILearnerPreference();\n    this.score = new Scorm2004CMIScore();\n    this.comments_from_learner = new CMICommentsFromLearner();\n    this.comments_from_lms = new CMICommentsFromLMS();\n    this.interactions = new CMIInteractions();\n    this.objectives = new CMIObjectives();\n\n    if (initialized) this.initialize();\n  }\n\n  #_version = '1.0';\n  #_children = scorm2004_constants.cmi_children;\n  #completion_status = 'unknown';\n  #completion_threshold = '';\n  #credit = 'credit';\n  #entry = '';\n  #exit = '';\n  #launch_data = '';\n  #learner_id = '';\n  #learner_name = '';\n  #location = '';\n  #max_time_allowed = '';\n  #mode = 'normal';\n  #progress_measure = '';\n  #scaled_passing_score = '';\n  #session_time = 'PT0H0M0S';\n  #success_status = 'unknown';\n  #suspend_data = '';\n  #time_limit_action = 'continue,no message';\n  #total_time = '';\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.learner_preference?.initialize();\n    this.score?.initialize();\n    this.comments_from_learner?.initialize();\n    this.comments_from_lms?.initialize();\n    this.interactions?.initialize();\n    this.objectives?.initialize();\n  }\n\n  /**\n   * Getter for #_version\n   * @return {string}\n   * @private\n   */\n  get _version() {\n    return this.#_version;\n  }\n\n  /**\n   * Setter for #_version. Just throws an error.\n   * @param {string} _version\n   * @private\n   */\n  set _version(_version) {\n    throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #_children\n   * @return {string}\n   * @private\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for #_children. Just throws an error.\n   * @param {number} _children\n   * @private\n   */\n  set _children(_children) {\n    throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #completion_status\n   * @return {string}\n   */\n  get completion_status() {\n    return this.#completion_status;\n  }\n\n  /**\n   * Setter for #completion_status\n   * @param {string} completion_status\n   */\n  set completion_status(completion_status) {\n    if (check2004ValidFormat(completion_status, scorm2004_regex.CMICStatus)) {\n      this.#completion_status = completion_status;\n    }\n  }\n\n  /**\n   * Getter for #completion_threshold\n   * @return {string}\n   */\n  get completion_threshold() {\n    return this.#completion_threshold;\n  }\n\n  /**\n   * Setter for #completion_threshold. Can only be called before  initialization.\n   * @param {string} completion_threshold\n   */\n  set completion_threshold(completion_threshold) {\n    !this.initialized ?\n      this.#completion_threshold = completion_threshold :\n      throwReadOnlyError();\n  }\n\n  /**\n   * Setter for #credit\n   * @return {string}\n   */\n  get credit() {\n    return this.#credit;\n  }\n\n  /**\n   * Setter for #credit. Can only be called before  initialization.\n   * @param {string} credit\n   */\n  set credit(credit) {\n    !this.initialized ? this.#credit = credit : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #entry\n   * @return {string}\n   */\n  get entry() {\n    return this.#entry;\n  }\n\n  /**\n   * Setter for #entry. Can only be called before  initialization.\n   * @param {string} entry\n   */\n  set entry(entry) {\n    !this.initialized ? this.#entry = entry : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #exit. Should only be called during JSON export.\n   * @return {string}\n   */\n  get exit() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#exit;\n  }\n\n  /**\n   * Getter for #exit\n   * @param {string} exit\n   */\n  set exit(exit) {\n    if (check2004ValidFormat(exit, scorm2004_regex.CMIExit, true)) {\n      this.#exit = exit;\n    }\n  }\n\n  /**\n   * Getter for #launch_data\n   * @return {string}\n   */\n  get launch_data() {\n    return this.#launch_data;\n  }\n\n  /**\n   * Setter for #launch_data. Can only be called before  initialization.\n   * @param {string} launch_data\n   */\n  set launch_data(launch_data) {\n    !this.initialized ? this.#launch_data = launch_data : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #learner_id\n   * @return {string}\n   */\n  get learner_id() {\n    return this.#learner_id;\n  }\n\n  /**\n   * Setter for #learner_id. Can only be called before  initialization.\n   * @param {string} learner_id\n   */\n  set learner_id(learner_id) {\n    !this.initialized ? this.#learner_id = learner_id : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #learner_name\n   * @return {string}\n   */\n  get learner_name() {\n    return this.#learner_name;\n  }\n\n  /**\n   * Setter for #learner_name. Can only be called before  initialization.\n   * @param {string} learner_name\n   */\n  set learner_name(learner_name) {\n    !this.initialized ?\n      this.#learner_name = learner_name :\n      throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #location\n   * @return {string}\n   */\n  get location() {\n    return this.#location;\n  }\n\n  /**\n   * Setter for #location\n   * @param {string} location\n   */\n  set location(location) {\n    if (check2004ValidFormat(location, scorm2004_regex.CMIString1000)) {\n      this.#location = location;\n    }\n  }\n\n  /**\n   * Getter for #max_time_allowed\n   * @return {string}\n   */\n  get max_time_allowed() {\n    return this.#max_time_allowed;\n  }\n\n  /**\n   * Setter for #max_time_allowed. Can only be called before  initialization.\n   * @param {string} max_time_allowed\n   */\n  set max_time_allowed(max_time_allowed) {\n    !this.initialized ?\n      this.#max_time_allowed = max_time_allowed :\n      throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #mode\n   * @return {string}\n   */\n  get mode() {\n    return this.#mode;\n  }\n\n  /**\n   * Setter for #mode. Can only be called before  initialization.\n   * @param {string} mode\n   */\n  set mode(mode) {\n    !this.initialized ? this.#mode = mode : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #progress_measure\n   * @return {string}\n   */\n  get progress_measure() {\n    return this.#progress_measure;\n  }\n\n  /**\n   * Setter for #progress_measure\n   * @param {string} progress_measure\n   */\n  set progress_measure(progress_measure) {\n    if (check2004ValidFormat(progress_measure, scorm2004_regex.CMIDecimal) &&\n      check2004ValidRange(progress_measure, scorm2004_regex.progress_range)) {\n      this.#progress_measure = progress_measure;\n    }\n  }\n\n  /**\n   * Getter for #scaled_passing_score\n   * @return {string}\n   */\n  get scaled_passing_score() {\n    return this.#scaled_passing_score;\n  }\n\n  /**\n   * Setter for #scaled_passing_score. Can only be called before  initialization.\n   * @param {string} scaled_passing_score\n   */\n  set scaled_passing_score(scaled_passing_score) {\n    !this.initialized ?\n      this.#scaled_passing_score = scaled_passing_score :\n      throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #session_time. Should only be called during JSON export.\n   * @return {string}\n   */\n  get session_time() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#session_time;\n  }\n\n  /**\n   * Setter for #session_time\n   * @param {string} session_time\n   */\n  set session_time(session_time) {\n    if (check2004ValidFormat(session_time, scorm2004_regex.CMITimespan)) {\n      this.#session_time = session_time;\n    }\n  }\n\n  /**\n   * Getter for #success_status\n   * @return {string}\n   */\n  get success_status() {\n    return this.#success_status;\n  }\n\n  /**\n   * Setter for #success_status\n   * @param {string} success_status\n   */\n  set success_status(success_status) {\n    if (check2004ValidFormat(success_status, scorm2004_regex.CMISStatus)) {\n      this.#success_status = success_status;\n    }\n  }\n\n  /**\n   * Getter for #suspend_data\n   * @return {string}\n   */\n  get suspend_data() {\n    return this.#suspend_data;\n  }\n\n  /**\n   * Setter for #suspend_data\n   * @param {string} suspend_data\n   */\n  set suspend_data(suspend_data) {\n    if (check2004ValidFormat(suspend_data, scorm2004_regex.CMIString64000,\n        true)) {\n      this.#suspend_data = suspend_data;\n    }\n  }\n\n  /**\n   * Getter for #time_limit_action\n   * @return {string}\n   */\n  get time_limit_action() {\n    return this.#time_limit_action;\n  }\n\n  /**\n   * Setter for #time_limit_action. Can only be called before  initialization.\n   * @param {string} time_limit_action\n   */\n  set time_limit_action(time_limit_action) {\n    !this.initialized ?\n      this.#time_limit_action = time_limit_action :\n      throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #total_time\n   * @return {string}\n   */\n  get total_time() {\n    return this.#total_time;\n  }\n\n  /**\n   * Setter for #total_time. Can only be called before  initialization.\n   * @param {string} total_time\n   */\n  set total_time(total_time) {\n    !this.initialized ? this.#total_time = total_time : throwReadOnlyError();\n  }\n\n  /**\n   * Adds the current session time to the existing total time.\n   *\n   * @return {string} ISO8601 Duration\n   */\n  getCurrentTotalTime() {\n    let sessionTime = this.#session_time;\n    const startTime = this.start_time;\n\n    if (typeof startTime !== 'undefined' && startTime !== null) {\n      const seconds = new Date().getTime() - startTime;\n      sessionTime = Util.getSecondsAsISODuration(seconds / 1000);\n    }\n\n    return Util.addTwoDurations(\n        this.#total_time,\n        sessionTime,\n        scorm2004_regex.CMITimespan,\n    );\n  }\n\n  /**\n   * toJSON for cmi\n   *\n   * @return {\n   *    {\n   *      comments_from_learner: CMICommentsFromLearner,\n   *      comments_from_lms: CMICommentsFromLMS,\n   *      completion_status: string,\n   *      completion_threshold: string,\n   *      credit: string,\n   *      entry: string,\n   *      exit: string,\n   *      interactions: CMIInteractions,\n   *      launch_data: string,\n   *      learner_id: string,\n   *      learner_name: string,\n   *      learner_preference: CMILearnerPreference,\n   *      location: string,\n   *      max_time_allowed: string,\n   *      mode: string,\n   *      objectives: CMIObjectives,\n   *      progress_measure: string,\n   *      scaled_passing_score: string,\n   *      score: Scorm2004CMIScore,\n   *      session_time: string,\n   *      success_status: string,\n   *      suspend_data: string,\n   *      time_limit_action: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'comments_from_learner': this.comments_from_learner,\n      'comments_from_lms': this.comments_from_lms,\n      'completion_status': this.completion_status,\n      'completion_threshold': this.completion_threshold,\n      'credit': this.credit,\n      'entry': this.entry,\n      'exit': this.exit,\n      'interactions': this.interactions,\n      'launch_data': this.launch_data,\n      'learner_id': this.learner_id,\n      'learner_name': this.learner_name,\n      'learner_preference': this.learner_preference,\n      'location': this.location,\n      'max_time_allowed': this.max_time_allowed,\n      'mode': this.mode,\n      'objectives': this.objectives,\n      'progress_measure': this.progress_measure,\n      'scaled_passing_score': this.scaled_passing_score,\n      'score': this.score,\n      'session_time': this.session_time,\n      'success_status': this.success_status,\n      'suspend_data': this.suspend_data,\n      'time_limit_action': this.time_limit_action,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class for SCORM 2004's cmi.learner_preference object\n */\nclass CMILearnerPreference extends BaseCMI {\n  #_children = scorm2004_constants.student_preference_children;\n  #audio_level = '1';\n  #language = '';\n  #delivery_speed = '1';\n  #audio_captioning = '0';\n\n  /**\n   * Constructor for cmi.learner_preference\n   */\n  constructor() {\n    super();\n  }\n\n  /**\n   * Getter for #_children\n   * @return {string}\n   * @private\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for #_children. Just throws an error.\n   * @param {string} _children\n   * @private\n   */\n  set _children(_children) {\n    throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #audio_level\n   * @return {string}\n   */\n  get audio_level() {\n    return this.#audio_level;\n  }\n\n  /**\n   * Setter for #audio_level\n   * @param {string} audio_level\n   */\n  set audio_level(audio_level) {\n    if (check2004ValidFormat(audio_level, scorm2004_regex.CMIDecimal) &&\n      check2004ValidRange(audio_level, scorm2004_regex.audio_range)) {\n      this.#audio_level = audio_level;\n    }\n  }\n\n  /**\n   * Getter for #language\n   * @return {string}\n   */\n  get language() {\n    return this.#language;\n  }\n\n  /**\n   * Setter for #language\n   * @param {string} language\n   */\n  set language(language) {\n    if (check2004ValidFormat(language, scorm2004_regex.CMILang)) {\n      this.#language = language;\n    }\n  }\n\n  /**\n   * Getter for #delivery_speed\n   * @return {string}\n   */\n  get delivery_speed() {\n    return this.#delivery_speed;\n  }\n\n  /**\n   * Setter for #delivery_speed\n   * @param {string} delivery_speed\n   */\n  set delivery_speed(delivery_speed) {\n    if (check2004ValidFormat(delivery_speed, scorm2004_regex.CMIDecimal) &&\n      check2004ValidRange(delivery_speed, scorm2004_regex.speed_range)) {\n      this.#delivery_speed = delivery_speed;\n    }\n  }\n\n  /**\n   * Getter for #audio_captioning\n   * @return {string}\n   */\n  get audio_captioning() {\n    return this.#audio_captioning;\n  }\n\n  /**\n   * Setter for #audio_captioning\n   * @param {string} audio_captioning\n   */\n  set audio_captioning(audio_captioning) {\n    if (check2004ValidFormat(audio_captioning, scorm2004_regex.CMISInteger) &&\n      check2004ValidRange(audio_captioning, scorm2004_regex.text_range)) {\n      this.#audio_captioning = audio_captioning;\n    }\n  }\n\n  /**\n   * toJSON for cmi.learner_preference\n   *\n   * @return {\n   *    {\n   *      audio_level: string,\n   *      language: string,\n   *      delivery_speed: string,\n   *      audio_captioning: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'audio_level': this.audio_level,\n      'language': this.language,\n      'delivery_speed': this.delivery_speed,\n      'audio_captioning': this.audio_captioning,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 2004's cmi.interactions object\n */\nclass CMIInteractions extends CMIArray {\n  /**\n   * Constructor for cmi.objectives Array\n   */\n  constructor() {\n    super({\n      children: scorm2004_constants.interactions_children,\n      errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n      errorClass: Scorm2004ValidationError,\n    });\n  }\n}\n\n/**\n * Class representing SCORM 2004's cmi.objectives object\n */\nclass CMIObjectives extends CMIArray {\n  /**\n   * Constructor for cmi.objectives Array\n   */\n  constructor() {\n    super({\n      children: scorm2004_constants.objectives_children,\n      errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n      errorClass: Scorm2004ValidationError,\n    });\n  }\n}\n\n/**\n * Class representing SCORM 2004's cmi.comments_from_lms object\n */\nclass CMICommentsFromLMS extends CMIArray {\n  /**\n   * Constructor for cmi.comments_from_lms Array\n   */\n  constructor() {\n    super({\n      children: scorm2004_constants.comments_children,\n      errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n      errorClass: Scorm2004ValidationError,\n    });\n  }\n}\n\n/**\n * Class representing SCORM 2004's cmi.comments_from_learner object\n */\nclass CMICommentsFromLearner extends CMIArray {\n  /**\n   * Constructor for cmi.comments_from_learner Array\n   */\n  constructor() {\n    super({\n      children: scorm2004_constants.comments_children,\n      errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n      errorClass: Scorm2004ValidationError,\n    });\n  }\n}\n\n/**\n * Class for SCORM 2004's cmi.interaction.n object\n */\nexport class CMIInteractionsObject extends BaseCMI {\n  #id = '';\n  #type = '';\n  #timestamp = '';\n  #weighting = '';\n  #learner_response = '';\n  #result = '';\n  #latency = '';\n  #description = '';\n\n  /**\n   * Constructor for cmi.interaction.n\n   */\n  constructor() {\n    super();\n\n    this.objectives = new CMIArray({\n      errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n      errorClass: Scorm2004ValidationError,\n      children: scorm2004_constants.objectives_children,\n    });\n    this.correct_responses = new CMIArray({\n      errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n      errorClass: Scorm2004ValidationError,\n      children: scorm2004_constants.correct_responses_children,\n    });\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.objectives?.initialize();\n    this.correct_responses?.initialize();\n  }\n\n  /**\n   * Getter for #id\n   * @return {string}\n   */\n  get id() {\n    return this.#id;\n  }\n\n  /**\n   * Setter for #id\n   * @param {string} id\n   */\n  set id(id) {\n    if (check2004ValidFormat(id, scorm2004_regex.CMILongIdentifier)) {\n      this.#id = id;\n    }\n  }\n\n  /**\n   * Getter for #type\n   * @return {string}\n   */\n  get type() {\n    return this.#type;\n  }\n\n  /**\n   * Setter for #type\n   * @param {string} type\n   */\n  set type(type) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(type, scorm2004_regex.CMIType)) {\n        this.#type = type;\n      }\n    }\n  }\n\n  /**\n   * Getter for #timestamp\n   * @return {string}\n   */\n  get timestamp() {\n    return this.#timestamp;\n  }\n\n  /**\n   * Setter for #timestamp\n   * @param {string} timestamp\n   */\n  set timestamp(timestamp) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(timestamp, scorm2004_regex.CMITime)) {\n        this.#timestamp = timestamp;\n      }\n    }\n  }\n\n  /**\n   * Getter for #weighting\n   * @return {string}\n   */\n  get weighting() {\n    return this.#weighting;\n  }\n\n  /**\n   * Setter for #weighting\n   * @param {string} weighting\n   */\n  set weighting(weighting) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(weighting, scorm2004_regex.CMIDecimal)) {\n        this.#weighting = weighting;\n      }\n    }\n  }\n\n  /**\n   * Getter for #learner_response\n   * @return {string}\n   */\n  get learner_response() {\n    return this.#learner_response;\n  }\n\n  /**\n   * Setter for #learner_response. Does type validation to make sure response\n   * matches SCORM 2004's spec\n   * @param {string} learner_response\n   */\n  set learner_response(learner_response) {\n    if (this.initialized && (this.#type === '' || this.#id === '')) {\n      throwDependencyNotEstablishedError();\n    } else {\n      let nodes = [];\n      const response_type = learner_responses[this.type];\n      if (response_type) {\n        if (response_type?.delimiter) {\n          nodes = learner_response.split(response_type.delimiter);\n        } else {\n          nodes[0] = learner_response;\n        }\n\n        if ((nodes.length > 0) && (nodes.length <= response_type.max)) {\n          const formatRegex = new RegExp(response_type.format);\n          for (let i = 0; i < nodes.length; i++) {\n            if (response_type?.delimiter2) {\n              const values = nodes[i].split(response_type.delimiter2);\n              if (values.length === 2) {\n                if (!values[0].match(formatRegex)) {\n                  throwTypeMismatchError();\n                } else {\n                  if (!values[1].match(new RegExp(response_type.format2))) {\n                    throwTypeMismatchError();\n                  }\n                }\n              } else {\n                throwTypeMismatchError();\n              }\n            } else {\n              if (!nodes[i].match(formatRegex)) {\n                throwTypeMismatchError();\n              } else {\n                if (nodes[i] !== '' && response_type.unique) {\n                  for (let j = 0; j < i; j++) {\n                    if (nodes[i] === nodes[j]) {\n                      throwTypeMismatchError();\n                    }\n                  }\n                }\n              }\n            }\n          }\n        } else {\n          throwGeneralSetError();\n        }\n\n        this.#learner_response = learner_response;\n      } else {\n        throwTypeMismatchError();\n      }\n    }\n  }\n\n  /**\n   * Getter for #result\n   * @return {string}\n   */\n  get result() {\n    return this.#result;\n  }\n\n  /**\n   * Setter for #result\n   * @param {string} result\n   */\n  set result(result) {\n    if (check2004ValidFormat(result, scorm2004_regex.CMIResult)) {\n      this.#result = result;\n    }\n  }\n\n  /**\n   * Getter for #latency\n   * @return {string}\n   */\n  get latency() {\n    return this.#latency;\n  }\n\n  /**\n   * Setter for #latency\n   * @param {string} latency\n   */\n  set latency(latency) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(latency, scorm2004_regex.CMITimespan)) {\n        this.#latency = latency;\n      }\n    }\n  }\n\n  /**\n   * Getter for #description\n   * @return {string}\n   */\n  get description() {\n    return this.#description;\n  }\n\n  /**\n   * Setter for #description\n   * @param {string} description\n   */\n  set description(description) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(description, scorm2004_regex.CMILangString250,\n          true)) {\n        this.#description = description;\n      }\n    }\n  }\n\n  /**\n   * toJSON for cmi.interactions.n\n   *\n   * @return {\n   *    {\n   *      id: string,\n   *      type: string,\n   *      objectives: CMIArray,\n   *      timestamp: string,\n   *      correct_responses: CMIArray,\n   *      weighting: string,\n   *      learner_response: string,\n   *      result: string,\n   *      latency: string,\n   *      description: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'id': this.id,\n      'type': this.type,\n      'objectives': this.objectives,\n      'timestamp': this.timestamp,\n      'weighting': this.weighting,\n      'learner_response': this.learner_response,\n      'result': this.result,\n      'latency': this.latency,\n      'description': this.description,\n      'correct_responses': this.correct_responses,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class for SCORM 2004's cmi.objectives.n object\n */\nexport class CMIObjectivesObject extends BaseCMI {\n  #id = '';\n  #success_status = 'unknown';\n  #completion_status = 'unknown';\n  #progress_measure = '';\n  #description = '';\n\n  /**\n   * Constructor for cmi.objectives.n\n   */\n  constructor() {\n    super();\n\n    this.score = new Scorm2004CMIScore();\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.score?.initialize();\n  }\n\n  /**\n   * Getter for #id\n   * @return {string}\n   */\n  get id() {\n    return this.#id;\n  }\n\n  /**\n   * Setter for #id\n   * @param {string} id\n   */\n  set id(id) {\n    if (check2004ValidFormat(id, scorm2004_regex.CMILongIdentifier)) {\n      this.#id = id;\n    }\n  }\n\n  /**\n   * Getter for #success_status\n   * @return {string}\n   */\n  get success_status() {\n    return this.#success_status;\n  }\n\n  /**\n   * Setter for #success_status\n   * @param {string} success_status\n   */\n  set success_status(success_status) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(success_status, scorm2004_regex.CMISStatus)) {\n        this.#success_status = success_status;\n      }\n    }\n  }\n\n  /**\n   * Getter for #completion_status\n   * @return {string}\n   */\n  get completion_status() {\n    return this.#completion_status;\n  }\n\n  /**\n   * Setter for #completion_status\n   * @param {string} completion_status\n   */\n  set completion_status(completion_status) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(completion_status, scorm2004_regex.CMICStatus)) {\n        this.#completion_status = completion_status;\n      }\n    }\n  }\n\n  /**\n   * Getter for #progress_measure\n   * @return {string}\n   */\n  get progress_measure() {\n    return this.#progress_measure;\n  }\n\n  /**\n   * Setter for #progress_measure\n   * @param {string} progress_measure\n   */\n  set progress_measure(progress_measure) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(progress_measure, scorm2004_regex.CMIDecimal) &&\n        check2004ValidRange(progress_measure,\n            scorm2004_regex.progress_range)) {\n        this.#progress_measure = progress_measure;\n      }\n    }\n  }\n\n  /**\n   * Getter for #description\n   * @return {string}\n   */\n  get description() {\n    return this.#description;\n  }\n\n  /**\n   * Setter for #description\n   * @param {string} description\n   */\n  set description(description) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(description, scorm2004_regex.CMILangString250,\n          true)) {\n        this.#description = description;\n      }\n    }\n  }\n\n  /**\n   * toJSON for cmi.objectives.n\n   *\n   * @return {\n   *    {\n   *      id: string,\n   *      success_status: string,\n   *      completion_status: string,\n   *      progress_measure: string,\n   *      description: string,\n   *      score: Scorm2004CMIScore\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'id': this.id,\n      'success_status': this.success_status,\n      'completion_status': this.completion_status,\n      'progress_measure': this.progress_measure,\n      'description': this.description,\n      'score': this.score,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class for SCORM 2004's cmi *.score object\n */\nclass Scorm2004CMIScore extends CMIScore {\n  #scaled = '';\n\n  /**\n   * Constructor for cmi *.score\n   */\n  constructor() {\n    super(\n        {\n          score_children: scorm2004_constants.score_children,\n          max: '',\n          invalidErrorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n          invalidTypeCode: scorm2004_error_codes.TYPE_MISMATCH,\n          invalidRangeCode: scorm2004_error_codes.VALUE_OUT_OF_RANGE,\n          decimalRegex: scorm2004_regex.CMIDecimal,\n          errorClass: Scorm2004ValidationError,\n        });\n  }\n\n  /**\n   * Getter for #scaled\n   * @return {string}\n   */\n  get scaled() {\n    return this.#scaled;\n  }\n\n  /**\n   * Setter for #scaled\n   * @param {string} scaled\n   */\n  set scaled(scaled) {\n    if (check2004ValidFormat(scaled, scorm2004_regex.CMIDecimal) &&\n      check2004ValidRange(scaled, scorm2004_regex.scaled_range)) {\n      this.#scaled = scaled;\n    }\n  }\n\n  /**\n   * toJSON for cmi *.score\n   *\n   * @return {\n   *    {\n   *      scaled: string,\n   *      raw: string,\n   *      min: string,\n   *      max: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'scaled': this.scaled,\n      'raw': super.raw,\n      'min': super.min,\n      'max': super.max,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 2004's cmi.comments_from_learner.n and cmi.comments_from_lms.n object\n */\nexport class CMICommentsObject extends BaseCMI {\n  #comment = '';\n  #location = '';\n  #timestamp = '';\n  #readOnlyAfterInit;\n\n  /**\n   * Constructor for cmi.comments_from_learner.n and cmi.comments_from_lms.n\n   * @param {boolean} readOnlyAfterInit\n   */\n  constructor(readOnlyAfterInit = false) {\n    super();\n    this.#comment = '';\n    this.#location = '';\n    this.#timestamp = '';\n    this.#readOnlyAfterInit = readOnlyAfterInit;\n  }\n\n  /**\n   * Getter for #comment\n   * @return {string}\n   */\n  get comment() {\n    return this.#comment;\n  }\n\n  /**\n   * Setter for #comment\n   * @param {string} comment\n   */\n  set comment(comment) {\n    if (this.initialized && this.#readOnlyAfterInit) {\n      throwReadOnlyError();\n    } else {\n      if (check2004ValidFormat(comment, scorm2004_regex.CMILangString4000,\n          true)) {\n        this.#comment = comment;\n      }\n    }\n  }\n\n  /**\n   * Getter for #location\n   * @return {string}\n   */\n  get location() {\n    return this.#location;\n  }\n\n  /**\n   * Setter for #location\n   * @param {string} location\n   */\n  set location(location) {\n    if (this.initialized && this.#readOnlyAfterInit) {\n      throwReadOnlyError();\n    } else {\n      if (check2004ValidFormat(location, scorm2004_regex.CMIString250)) {\n        this.#location = location;\n      }\n    }\n  }\n\n  /**\n   * Getter for #timestamp\n   * @return {string}\n   */\n  get timestamp() {\n    return this.#timestamp;\n  }\n\n  /**\n   * Setter for #timestamp\n   * @param {string} timestamp\n   */\n  set timestamp(timestamp) {\n    if (this.initialized && this.#readOnlyAfterInit) {\n      throwReadOnlyError();\n    } else {\n      if (check2004ValidFormat(timestamp, scorm2004_regex.CMITime)) {\n        this.#timestamp = timestamp;\n      }\n    }\n  }\n\n  /**\n   * toJSON for cmi.comments_from_learner.n object\n   * @return {\n   *    {\n   *      comment: string,\n   *      location: string,\n   *      timestamp: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'comment': this.comment,\n      'location': this.location,\n      'timestamp': this.timestamp,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 2004's cmi.interactions.n.objectives.n object\n */\nexport class CMIInteractionsObjectivesObject extends BaseCMI {\n  #id = '';\n\n  /**\n   * Constructor for cmi.interactions.n.objectives.n\n   */\n  constructor() {\n    super();\n  }\n\n  /**\n   * Getter for #id\n   * @return {string}\n   */\n  get id() {\n    return this.#id;\n  }\n\n  /**\n   * Setter for #id\n   * @param {string} id\n   */\n  set id(id) {\n    if (check2004ValidFormat(id, scorm2004_regex.CMILongIdentifier)) {\n      this.#id = id;\n    }\n  }\n\n  /**\n   * toJSON for cmi.interactions.n.objectives.n\n   * @return {\n   *    {\n   *      id: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'id': this.id,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 2004's cmi.interactions.n.correct_responses.n object\n */\nexport class CMIInteractionsCorrectResponsesObject extends BaseCMI {\n  #pattern = '';\n\n  /**\n   * Constructor for cmi.interactions.n.correct_responses.n\n   */\n  constructor() {\n    super();\n  }\n\n  /**\n   * Getter for #pattern\n   * @return {string}\n   */\n  get pattern() {\n    return this.#pattern;\n  }\n\n  /**\n   * Setter for #pattern\n   * @param {string} pattern\n   */\n  set pattern(pattern) {\n    if (check2004ValidFormat(pattern, scorm2004_regex.CMIFeedback)) {\n      this.#pattern = pattern;\n    }\n  }\n\n  /**\n   * toJSON cmi.interactions.n.correct_responses.n object\n   * @return {\n   *    {\n   *      pattern: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'pattern': this.pattern,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 2004's adl object\n */\nexport class ADL extends BaseCMI {\n  /**\n   * Constructor for adl\n   */\n  constructor() {\n    super();\n\n    this.nav = new ADLNav();\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.nav?.initialize();\n  }\n\n  /**\n   * toJSON for adl\n   * @return {\n   *    {\n   *      nav: {\n   *        request: string\n   *      }\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'nav': this.nav,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 2004's adl.nav object\n */\nclass ADLNav extends BaseCMI {\n  #request = '_none_';\n\n  /**\n   * Constructor for adl.nav\n   */\n  constructor() {\n    super();\n\n    this.request_valid = new ADLNavRequestValid();\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.request_valid?.initialize();\n  }\n\n  /**\n   * Getter for #request\n   * @return {string}\n   */\n  get request() {\n    return this.#request;\n  }\n\n  /**\n   * Setter for #request\n   * @param {string} request\n   */\n  set request(request) {\n    if (check2004ValidFormat(request, scorm2004_regex.NAVEvent)) {\n      this.#request = request;\n    }\n  }\n\n  /**\n   * toJSON for adl.nav\n   *\n   * @return {\n   *    {\n   *      request: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'request': this.request,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 2004's adl.nav.request_valid object\n */\nclass ADLNavRequestValid extends BaseCMI {\n  #continue = 'unknown';\n  #previous = 'unknown';\n  choice = class {\n    /**\n     * Check if target is valid\n     * @param {*} _target\n     * @return {string}\n     */\n    _isTargetValid = (_target) => 'unknown';\n  };\n  jump = class {\n    /**\n     * Check if target is valid\n     * @param {*} _target\n     * @return {string}\n     */\n    _isTargetValid = (_target) => 'unknown';\n  };\n\n  /**\n   * Constructor for adl.nav.request_valid\n   */\n  constructor() {\n    super();\n  }\n\n  /**\n   * Getter for #continue\n   * @return {string}\n   */\n  get continue() {\n    return this.#continue;\n  }\n\n  /**\n   * Setter for #continue. Just throws an error.\n   * @param {*} _\n   */\n  set continue(_) {\n    throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #previous\n   * @return {string}\n   */\n  get previous() {\n    return this.#previous;\n  }\n\n  /**\n   * Setter for #previous. Just throws an error.\n   * @param {*} _\n   */\n  set previous(_) {\n    throwReadOnlyError();\n  }\n\n  /**\n   * toJSON for adl.nav.request_valid\n   *\n   * @return {\n   *    {\n   *      previous: string,\n   *      continue: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'previous': this.previous,\n      'continue': this.continue,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n","// @flow\n\nconst global = {\n  SCORM_TRUE: 'true',\n  SCORM_FALSE: 'false',\n  STATE_NOT_INITIALIZED: 0,\n  STATE_INITIALIZED: 1,\n  STATE_TERMINATED: 2,\n  LOG_LEVEL_DEBUG: 1,\n  LOG_LEVEL_INFO: 2,\n  LOG_LEVEL_WARNING: 3,\n  LOG_LEVEL_ERROR: 4,\n  LOG_LEVEL_NONE: 5,\n};\n\nconst scorm12 = {\n  // Children lists\n  cmi_children: 'core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions',\n  core_children: 'student_id,student_name,lesson_location,credit,lesson_status,entry,score,total_time,lesson_mode,exit,session_time',\n  score_children: 'raw,min,max',\n  comments_children: 'content,location,time',\n  objectives_children: 'id,score,status',\n  correct_responses_children: 'pattern',\n  student_data_children: 'mastery_score,max_time_allowed,time_limit_action',\n  student_preference_children: 'audio,language,speed,text',\n  interactions_children: 'id,objectives,time,type,correct_responses,weighting,student_response,result,latency',\n\n  error_descriptions: {\n    '101': {\n      basicMessage: 'General Exception',\n      detailMessage: 'No specific error code exists to describe the error. Use LMSGetDiagnostic for more information',\n    },\n    '201': {\n      basicMessage: 'Invalid argument error',\n      detailMessage: 'Indicates that an argument represents an invalid data model element or is otherwise incorrect.',\n    },\n    '202': {\n      basicMessage: 'Element cannot have children',\n      detailMessage: 'Indicates that LMSGetValue was called with a data model element name that ends in \"_children\" for a data model element that does not support the \"_children\" suffix.',\n    },\n    '203': {\n      basicMessage: 'Element not an array - cannot have count',\n      detailMessage: 'Indicates that LMSGetValue was called with a data model element name that ends in \"_count\" for a data model element that does not support the \"_count\" suffix.',\n    },\n    '301': {\n      basicMessage: 'Not initialized',\n      detailMessage: 'Indicates that an API call was made before the call to lmsInitialize.',\n    },\n    '401': {\n      basicMessage: 'Not implemented error',\n      detailMessage: 'The data model element indicated in a call to LMSGetValue or LMSSetValue is valid, but was not implemented by this LMS. SCORM 1.2 defines a set of data model elements as being optional for an LMS to implement.',\n    },\n    '402': {\n      basicMessage: 'Invalid set value, element is a keyword',\n      detailMessage: 'Indicates that LMSSetValue was called on a data model element that represents a keyword (elements that end in \"_children\" and \"_count\").',\n    },\n    '403': {\n      basicMessage: 'Element is read only',\n      detailMessage: 'LMSSetValue was called with a data model element that can only be read.',\n    },\n    '404': {\n      basicMessage: 'Element is write only',\n      detailMessage: 'LMSGetValue was called on a data model element that can only be written to.',\n    },\n    '405': {\n      basicMessage: 'Incorrect Data Type',\n      detailMessage: 'LMSSetValue was called with a value that is not consistent with the data format of the supplied data model element.',\n    },\n    '407': {\n      basicMessage: 'Element Value Out Of Range',\n      detailMessage: 'The numeric value supplied to a LMSSetValue call is outside of the numeric range allowed for the supplied data model element.',\n    },\n    '408': {\n      basicMessage: 'Data Model Dependency Not Established',\n      detailMessage: 'Some data model elements cannot be set until another data model element was set. This error condition indicates that the prerequisite element was not set before the dependent element.',\n    },\n  },\n};\n\nconst aicc = {\n  ...scorm12, ...{\n    cmi_children: 'core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions,evaluation',\n    student_preference_children: 'audio,language,lesson_type,speed,text,text_color,text_location,text_size,video,windows',\n    student_data_children: 'attempt_number,tries,mastery_score,max_time_allowed,time_limit_action',\n    student_demographics_children: 'city,class,company,country,experience,familiar_name,instructor_name,title,native_language,state,street_address,telephone,years_experience',\n    tries_children: 'time,status,score',\n    attempt_records_children: 'score,lesson_status',\n    paths_children: 'location_id,date,time,status,why_left,time_in_element',\n  },\n};\n\nconst scorm2004 = {\n  // Children lists\n  cmi_children: '_version,comments_from_learner,comments_from_lms,completion_status,credit,entry,exit,interactions,launch_data,learner_id,learner_name,learner_preference,location,max_time_allowed,mode,objectives,progress_measure,scaled_passing_score,score,session_time,success_status,suspend_data,time_limit_action,total_time',\n  comments_children: 'comment,timestamp,location',\n  score_children: 'max,raw,scaled,min',\n  objectives_children: 'progress_measure,completion_status,success_status,description,score,id',\n  correct_responses_children: 'pattern',\n  student_data_children: 'mastery_score,max_time_allowed,time_limit_action',\n  student_preference_children: 'audio_level,audio_captioning,delivery_speed,language',\n  interactions_children: 'id,type,objectives,timestamp,correct_responses,weighting,learner_response,result,latency,description',\n\n  error_descriptions: {\n    '0': {\n      basicMessage: 'No Error',\n      detailMessage: 'No error occurred, the previous API call was successful.',\n    },\n    '101': {\n      basicMessage: 'General Exception',\n      detailMessage: 'No specific error code exists to describe the error. Use GetDiagnostic for more information.',\n    },\n    '102': {\n      basicMessage: 'General Initialization Failure',\n      detailMessage: 'Call to Initialize failed for an unknown reason.',\n    },\n    '103': {\n      basicMessage: 'Already Initialized',\n      detailMessage: 'Call to Initialize failed because Initialize was already called.',\n    },\n    '104': {\n      basicMessage: 'Content Instance Terminated',\n      detailMessage: 'Call to Initialize failed because Terminate was already called.',\n    },\n    '111': {\n      basicMessage: 'General Termination Failure',\n      detailMessage: 'Call to Terminate failed for an unknown reason.',\n    },\n    '112': {\n      basicMessage: 'Termination Before Initialization',\n      detailMessage: 'Call to Terminate failed because it was made before the call to Initialize.',\n    },\n    '113': {\n      basicMessage: 'Termination After Termination',\n      detailMessage: 'Call to Terminate failed because Terminate was already called.',\n    },\n    '122': {\n      basicMessage: 'Retrieve Data Before Initialization',\n      detailMessage: 'Call to GetValue failed because it was made before the call to Initialize.',\n    },\n    '123': {\n      basicMessage: 'Retrieve Data After Termination',\n      detailMessage: 'Call to GetValue failed because it was made after the call to Terminate.',\n    },\n    '132': {\n      basicMessage: 'Store Data Before Initialization',\n      detailMessage: 'Call to SetValue failed because it was made before the call to Initialize.',\n    },\n    '133': {\n      basicMessage: 'Store Data After Termination',\n      detailMessage: 'Call to SetValue failed because it was made after the call to Terminate.',\n    },\n    '142': {\n      basicMessage: 'Commit Before Initialization',\n      detailMessage: 'Call to Commit failed because it was made before the call to Initialize.',\n    },\n    '143': {\n      basicMessage: 'Commit After Termination',\n      detailMessage: 'Call to Commit failed because it was made after the call to Terminate.',\n    },\n    '201': {\n      basicMessage: 'General Argument Error',\n      detailMessage: 'An invalid argument was passed to an API method (usually indicates that Initialize, Commit or Terminate did not receive the expected empty string argument.',\n    },\n    '301': {\n      basicMessage: 'General Get Failure',\n      detailMessage: 'Indicates a failed GetValue call where no other specific error code is applicable. Use GetDiagnostic for more information.',\n    },\n    '351': {\n      basicMessage: 'General Set Failure',\n      detailMessage: 'Indicates a failed SetValue call where no other specific error code is applicable. Use GetDiagnostic for more information.',\n    },\n    '391': {\n      basicMessage: 'General Commit Failure',\n      detailMessage: 'Indicates a failed Commit call where no other specific error code is applicable. Use GetDiagnostic for more information.',\n    },\n    '401': {\n      basicMessage: 'Undefined Data Model Element',\n      detailMessage: 'The data model element name passed to GetValue or SetValue is not a valid SCORM data model element.',\n    },\n    '402': {\n      basicMessage: 'Unimplemented Data Model Element',\n      detailMessage: 'The data model element indicated in a call to GetValue or SetValue is valid, but was not implemented by this LMS. In SCORM 2004, this error would indicate an LMS that is not fully SCORM conformant.',\n    },\n    '403': {\n      basicMessage: 'Data Model Element Value Not Initialized',\n      detailMessage: 'Attempt to read a data model element that has not been initialized by the LMS or through a SetValue call. This error condition is often reached during normal execution of a SCO.',\n    },\n    '404': {\n      basicMessage: 'Data Model Element Is Read Only',\n      detailMessage: 'SetValue was called with a data model element that can only be read.',\n    },\n    '405': {\n      basicMessage: 'Data Model Element Is Write Only',\n      detailMessage: 'GetValue was called on a data model element that can only be written to.',\n    },\n    '406': {\n      basicMessage: 'Data Model Element Type Mismatch',\n      detailMessage: 'SetValue was called with a value that is not consistent with the data format of the supplied data model element.',\n    },\n    '407': {\n      basicMessage: 'Data Model Element Value Out Of Range',\n      detailMessage: 'The numeric value supplied to a SetValue call is outside of the numeric range allowed for the supplied data model element.',\n    },\n    '408': {\n      basicMessage: 'Data Model Dependency Not Established',\n      detailMessage: 'Some data model elements cannot be set until another data model element was set. This error condition indicates that the prerequisite element was not set before the dependent element.',\n    },\n  },\n};\n\nconst APIConstants = {\n  global: global,\n  scorm12: scorm12,\n  aicc: aicc,\n  scorm2004: scorm2004,\n};\n\nexport default APIConstants;\n","// @flow\nconst global = {\n  GENERAL: 101,\n  INITIALIZATION_FAILED: 101,\n  INITIALIZED: 101,\n  TERMINATED: 101,\n  TERMINATION_FAILURE: 101,\n  TERMINATION_BEFORE_INIT: 101,\n  MULTIPLE_TERMINATION: 101,\n  RETRIEVE_BEFORE_INIT: 101,\n  RETRIEVE_AFTER_TERM: 101,\n  STORE_BEFORE_INIT: 101,\n  STORE_AFTER_TERM: 101,\n  COMMIT_BEFORE_INIT: 101,\n  COMMIT_AFTER_TERM: 101,\n  ARGUMENT_ERROR: 101,\n  CHILDREN_ERROR: 101,\n  COUNT_ERROR: 101,\n  GENERAL_GET_FAILURE: 101,\n  GENERAL_SET_FAILURE: 101,\n  GENERAL_COMMIT_FAILURE: 101,\n  UNDEFINED_DATA_MODEL: 101,\n  UNIMPLEMENTED_ELEMENT: 101,\n  VALUE_NOT_INITIALIZED: 101,\n  INVALID_SET_VALUE: 101,\n  READ_ONLY_ELEMENT: 101,\n  WRITE_ONLY_ELEMENT: 101,\n  TYPE_MISMATCH: 101,\n  VALUE_OUT_OF_RANGE: 101,\n  DEPENDENCY_NOT_ESTABLISHED: 101,\n};\n\nconst scorm12 = {\n  ...global, ...{\n    RETRIEVE_BEFORE_INIT: 301,\n    STORE_BEFORE_INIT: 301,\n    COMMIT_BEFORE_INIT: 301,\n    ARGUMENT_ERROR: 201,\n    CHILDREN_ERROR: 202,\n    COUNT_ERROR: 203,\n    UNDEFINED_DATA_MODEL: 401,\n    UNIMPLEMENTED_ELEMENT: 401,\n    VALUE_NOT_INITIALIZED: 301,\n    INVALID_SET_VALUE: 402,\n    READ_ONLY_ELEMENT: 403,\n    WRITE_ONLY_ELEMENT: 404,\n    TYPE_MISMATCH: 405,\n    VALUE_OUT_OF_RANGE: 407,\n    DEPENDENCY_NOT_ESTABLISHED: 408,\n  },\n};\n\nconst scorm2004 = {\n  ...global, ...{\n    INITIALIZATION_FAILED: 102,\n    INITIALIZED: 103,\n    TERMINATED: 104,\n    TERMINATION_FAILURE: 111,\n    TERMINATION_BEFORE_INIT: 112,\n    MULTIPLE_TERMINATIONS: 113,\n    RETRIEVE_BEFORE_INIT: 122,\n    RETRIEVE_AFTER_TERM: 123,\n    STORE_BEFORE_INIT: 132,\n    STORE_AFTER_TERM: 133,\n    COMMIT_BEFORE_INIT: 142,\n    COMMIT_AFTER_TERM: 143,\n    ARGUMENT_ERROR: 201,\n    GENERAL_GET_FAILURE: 301,\n    GENERAL_SET_FAILURE: 351,\n    GENERAL_COMMIT_FAILURE: 391,\n    UNDEFINED_DATA_MODEL: 401,\n    UNIMPLEMENTED_ELEMENT: 402,\n    VALUE_NOT_INITIALIZED: 403,\n    READ_ONLY_ELEMENT: 404,\n    WRITE_ONLY_ELEMENT: 405,\n    TYPE_MISMATCH: 406,\n    VALUE_OUT_OF_RANGE: 407,\n    DEPENDENCY_NOT_ESTABLISHED: 408,\n  },\n};\n\nconst ErrorCodes = {\n  scorm12: scorm12,\n  scorm2004: scorm2004,\n};\n\nexport default ErrorCodes;\n","const ValidLanguages = {\n  'aa': 'aa', 'ab': 'ab', 'ae': 'ae', 'af': 'af', 'ak': 'ak', 'am': 'am',\n  'an': 'an', 'ar': 'ar', 'as': 'as', 'av': 'av', 'ay': 'ay', 'az': 'az',\n  'ba': 'ba', 'be': 'be', 'bg': 'bg', 'bh': 'bh', 'bi': 'bi', 'bm': 'bm',\n  'bn': 'bn', 'bo': 'bo', 'br': 'br', 'bs': 'bs', 'ca': 'ca', 'ce': 'ce',\n  'ch': 'ch', 'co': 'co', 'cr': 'cr', 'cs': 'cs', 'cu': 'cu', 'cv': 'cv',\n  'cy': 'cy', 'da': 'da', 'de': 'de', 'dv': 'dv', 'dz': 'dz', 'ee': 'ee',\n  'el': 'el', 'en': 'en', 'eo': 'eo', 'es': 'es', 'et': 'et', 'eu': 'eu',\n  'fa': 'fa', 'ff': 'ff', 'fi': 'fi', 'fj': 'fj', 'fo': 'fo', 'fr': 'fr',\n  'fy': 'fy', 'ga': 'ga', 'gd': 'gd', 'gl': 'gl', 'gn': 'gn', 'gu': 'gu',\n  'gv': 'gv', 'ha': 'ha', 'he': 'he', 'hi': 'hi', 'ho': 'ho', 'hr': 'hr',\n  'ht': 'ht', 'hu': 'hu', 'hy': 'hy', 'hz': 'hz', 'ia': 'ia', 'id': 'id',\n  'ie': 'ie', 'ig': 'ig', 'ii': 'ii', 'ik': 'ik', 'io': 'io', 'is': 'is',\n  'it': 'it', 'iu': 'iu', 'ja': 'ja', 'jv': 'jv', 'ka': 'ka', 'kg': 'kg',\n  'ki': 'ki', 'kj': 'kj', 'kk': 'kk', 'kl': 'kl', 'km': 'km', 'kn': 'kn',\n  'ko': 'ko', 'kr': 'kr', 'ks': 'ks', 'ku': 'ku', 'kv': 'kv', 'kw': 'kw',\n  'ky': 'ky', 'la': 'la', 'lb': 'lb', 'lg': 'lg', 'li': 'li', 'ln': 'ln',\n  'lo': 'lo', 'lt': 'lt', 'lu': 'lu', 'lv': 'lv', 'mg': 'mg', 'mh': 'mh',\n  'mi': 'mi', 'mk': 'mk', 'ml': 'ml', 'mn': 'mn', 'mo': 'mo', 'mr': 'mr',\n  'ms': 'ms', 'mt': 'mt', 'my': 'my', 'na': 'na', 'nb': 'nb', 'nd': 'nd',\n  'ne': 'ne', 'ng': 'ng', 'nl': 'nl', 'nn': 'nn', 'no': 'no', 'nr': 'nr',\n  'nv': 'nv', 'ny': 'ny', 'oc': 'oc', 'oj': 'oj', 'om': 'om', 'or': 'or',\n  'os': 'os', 'pa': 'pa', 'pi': 'pi', 'pl': 'pl', 'ps': 'ps', 'pt': 'pt',\n  'qu': 'qu', 'rm': 'rm', 'rn': 'rn', 'ro': 'ro', 'ru': 'ru', 'rw': 'rw',\n  'sa': 'sa', 'sc': 'sc', 'sd': 'sd', 'se': 'se', 'sg': 'sg', 'sh': 'sh',\n  'si': 'si', 'sk': 'sk', 'sl': 'sl', 'sm': 'sm', 'sn': 'sn', 'so': 'so',\n  'sq': 'sq', 'sr': 'sr', 'ss': 'ss', 'st': 'st', 'su': 'su', 'sv': 'sv',\n  'sw': 'sw', 'ta': 'ta', 'te': 'te', 'tg': 'tg', 'th': 'th', 'ti': 'ti',\n  'tk': 'tk', 'tl': 'tl', 'tn': 'tn', 'to': 'to', 'tr': 'tr', 'ts': 'ts',\n  'tt': 'tt', 'tw': 'tw', 'ty': 'ty', 'ug': 'ug', 'uk': 'uk', 'ur': 'ur',\n  'uz': 'uz', 've': 've', 'vi': 'vi', 'vo': 'vo', 'wa': 'wa', 'wo': 'wo',\n  'xh': 'xh', 'yi': 'yi', 'yo': 'yo', 'za': 'za', 'zh': 'zh', 'zu': 'zu',\n  'aar': 'aar', 'abk': 'abk', 'ave': 'ave', 'afr': 'afr', 'aka': 'aka',\n  'amh': 'amh', 'arg': 'arg', 'ara': 'ara', 'asm': 'asm', 'ava': 'ava',\n  'aym': 'aym', 'aze': 'aze', 'bak': 'bak', 'bel': 'bel', 'bul': 'bul',\n  'bih': 'bih', 'bis': 'bis', 'bam': 'bam', 'ben': 'ben', 'tib': 'tib',\n  'bod': 'bod', 'bre': 'bre', 'bos': 'bos', 'cat': 'cat', 'che': 'che',\n  'cha': 'cha', 'cos': 'cos', 'cre': 'cre', 'cze': 'cze', 'ces': 'ces',\n  'chu': 'chu', 'chv': 'chv', 'wel': 'wel', 'cym': 'cym', 'dan': 'dan',\n  'ger': 'ger', 'deu': 'deu', 'div': 'div', 'dzo': 'dzo', 'ewe': 'ewe',\n  'gre': 'gre', 'ell': 'ell', 'eng': 'eng', 'epo': 'epo', 'spa': 'spa',\n  'est': 'est', 'baq': 'baq', 'eus': 'eus', 'per': 'per', 'fas': 'fas',\n  'ful': 'ful', 'fin': 'fin', 'fij': 'fij', 'fao': 'fao', 'fre': 'fre',\n  'fra': 'fra', 'fry': 'fry', 'gle': 'gle', 'gla': 'gla', 'glg': 'glg',\n  'grn': 'grn', 'guj': 'guj', 'glv': 'glv', 'hau': 'hau', 'heb': 'heb',\n  'hin': 'hin', 'hmo': 'hmo', 'hrv': 'hrv', 'hat': 'hat', 'hun': 'hun',\n  'arm': 'arm', 'hye': 'hye', 'her': 'her', 'ina': 'ina', 'ind': 'ind',\n  'ile': 'ile', 'ibo': 'ibo', 'iii': 'iii', 'ipk': 'ipk', 'ido': 'ido',\n  'ice': 'ice', 'isl': 'isl', 'ita': 'ita', 'iku': 'iku', 'jpn': 'jpn',\n  'jav': 'jav', 'geo': 'geo', 'kat': 'kat', 'kon': 'kon', 'kik': 'kik',\n  'kua': 'kua', 'kaz': 'kaz', 'kal': 'kal', 'khm': 'khm', 'kan': 'kan',\n  'kor': 'kor', 'kau': 'kau', 'kas': 'kas', 'kur': 'kur', 'kom': 'kom',\n  'cor': 'cor', 'kir': 'kir', 'lat': 'lat', 'ltz': 'ltz', 'lug': 'lug',\n  'lim': 'lim', 'lin': 'lin', 'lao': 'lao', 'lit': 'lit', 'lub': 'lub',\n  'lav': 'lav', 'mlg': 'mlg', 'mah': 'mah', 'mao': 'mao', 'mri': 'mri',\n  'mac': 'mac', 'mkd': 'mkd', 'mal': 'mal', 'mon': 'mon', 'mol': 'mol',\n  'mar': 'mar', 'may': 'may', 'msa': 'msa', 'mlt': 'mlt', 'bur': 'bur',\n  'mya': 'mya', 'nau': 'nau', 'nob': 'nob', 'nde': 'nde', 'nep': 'nep',\n  'ndo': 'ndo', 'dut': 'dut', 'nld': 'nld', 'nno': 'nno', 'nor': 'nor',\n  'nbl': 'nbl', 'nav': 'nav', 'nya': 'nya', 'oci': 'oci', 'oji': 'oji',\n  'orm': 'orm', 'ori': 'ori', 'oss': 'oss', 'pan': 'pan', 'pli': 'pli',\n  'pol': 'pol', 'pus': 'pus', 'por': 'por', 'que': 'que', 'roh': 'roh',\n  'run': 'run', 'rum': 'rum', 'ron': 'ron', 'rus': 'rus', 'kin': 'kin',\n  'san': 'san', 'srd': 'srd', 'snd': 'snd', 'sme': 'sme', 'sag': 'sag',\n  'slo': 'slo', 'sin': 'sin', 'slk': 'slk', 'slv': 'slv', 'smo': 'smo',\n  'sna': 'sna', 'som': 'som', 'alb': 'alb', 'sqi': 'sqi', 'srp': 'srp',\n  'ssw': 'ssw', 'sot': 'sot', 'sun': 'sun', 'swe': 'swe', 'swa': 'swa',\n  'tam': 'tam', 'tel': 'tel', 'tgk': 'tgk', 'tha': 'tha', 'tir': 'tir',\n  'tuk': 'tuk', 'tgl': 'tgl', 'tsn': 'tsn', 'ton': 'ton', 'tur': 'tur',\n  'tso': 'tso', 'tat': 'tat', 'twi': 'twi', 'tah': 'tah', 'uig': 'uig',\n  'ukr': 'ukr', 'urd': 'urd', 'uzb': 'uzb', 'ven': 'ven', 'vie': 'vie',\n  'vol': 'vol', 'wln': 'wln', 'wol': 'wol', 'xho': 'xho', 'yid': 'yid',\n  'yor': 'yor', 'zha': 'zha', 'chi': 'chi', 'zho': 'zho', 'zul': 'zul',\n};\n\nexport default ValidLanguages;\n","// @flow\n\nconst scorm12 = {\n  CMIString256: '^.{0,255}$',\n  CMIString4096: '^.{0,4096}$',\n  CMITime: '^(?:[01]\\\\d|2[0123]):(?:[012345]\\\\d):(?:[012345]\\\\d)$', // eslint-disable-line\n  CMITimespan: '^([0-9]{2,}):([0-9]{2}):([0-9]{2})(\\.[0-9]{1,2})?$', // eslint-disable-line\n  CMIInteger: '^\\\\d+$',\n  CMISInteger: '^-?([0-9]+)$',\n  CMIDecimal: '^-?([0-9]{0,3})(\\.[0-9]*)?$', // eslint-disable-line\n  CMIIdentifier: '^[\\\\u0021-\\\\u007E\\\\s]{0,255}$',\n  CMIFeedback: '^.{0,255}$', // This must be redefined\n  CMIIndex: '[._](\\\\d+).',\n\n  // Vocabulary Data Type Definition\n  CMIStatus: '^(passed|completed|failed|incomplete|browsed)$',\n  CMIStatus2: '^(passed|completed|failed|incomplete|browsed|not attempted)$',\n  CMIExit: '^(time-out|suspend|logout|)$',\n  CMIType: '^(true-false|choice|fill-in|matching|performance|sequencing|likert|numeric)$',\n  CMIResult: '^(correct|wrong|unanticipated|neutral|([0-9]{0,3})?(\\\\.[0-9]*)?)$', // eslint-disable-line\n  NAVEvent: '^(previous|continue)$',\n\n  // Data ranges\n  score_range: '0#100',\n  audio_range: '-1#100',\n  speed_range: '-100#100',\n  weighting_range: '-100#100',\n  text_range: '-1#1',\n};\n\nconst aicc = {\n  ...scorm12, ...{\n    CMIIdentifier: '^\\\\w{1,255}$',\n  },\n};\n\nconst scorm2004 = {\n  CMIString200: '^[\\\\u0000-\\\\uFFFF]{0,200}$',\n  CMIString250: '^[\\\\u0000-\\\\uFFFF]{0,250}$',\n  CMIString1000: '^[\\\\u0000-\\\\uFFFF]{0,1000}$',\n  CMIString4000: '^[\\\\u0000-\\\\uFFFF]{0,4000}$',\n  CMIString64000: '^[\\\\u0000-\\\\uFFFF]{0,64000}$',\n  CMILang: '^([a-zA-Z]{2,3}|i|x)(\\-[a-zA-Z0-9\\-]{2,8})?$|^$', // eslint-disable-line\n  CMILangString250: '^(\\{lang=([a-zA-Z]{2,3}|i|x)(\\-[a-zA-Z0-9\\-]{2,8})?\\})?((?!\\{.*$).{0,250}$)?$', // eslint-disable-line\n  CMILangcr: '^((\\{lang=([a-zA-Z]{2,3}|i|x)?(\\-[a-zA-Z0-9\\-]{2,8})?\\}))(.*?)$', // eslint-disable-line\n  CMILangString250cr: '^((\\{lang=([a-zA-Z]{2,3}|i|x)?(\\-[a-zA-Z0-9\\-]{2,8})?\\})?(.{0,250})?)?$', // eslint-disable-line\n  CMILangString4000: '^(\\{lang=([a-zA-Z]{2,3}|i|x)(\\-[a-zA-Z0-9\\-]{2,8})?\\})?((?!\\{.*$).{0,4000}$)?$', // eslint-disable-line\n  CMITime: '^(19[7-9]{1}[0-9]{1}|20[0-2]{1}[0-9]{1}|203[0-8]{1})((-(0[1-9]{1}|1[0-2]{1}))((-(0[1-9]{1}|[1-2]{1}[0-9]{1}|3[0-1]{1}))(T([0-1]{1}[0-9]{1}|2[0-3]{1})((:[0-5]{1}[0-9]{1})((:[0-5]{1}[0-9]{1})((\\\\.[0-9]{1,2})((Z|([+|-]([0-1]{1}[0-9]{1}|2[0-3]{1})))(:[0-5]{1}[0-9]{1})?)?)?)?)?)?)?)?$',\n  CMITimespan: '^P(?:([.,\\\\d]+)Y)?(?:([.,\\\\d]+)M)?(?:([.,\\\\d]+)W)?(?:([.,\\\\d]+)D)?(?:T?(?:([.,\\\\d]+)H)?(?:([.,\\\\d]+)M)?(?:([.,\\\\d]+)S)?)?$',\n  CMIInteger: '^\\\\d+$',\n  CMISInteger: '^-?([0-9]+)$',\n  CMIDecimal: '^-?([0-9]{1,5})(\\\\.[0-9]{1,18})?$',\n  CMIIdentifier: '^\\\\S{1,250}[a-zA-Z0-9]$',\n  CMIShortIdentifier: '^[\\\\w\\\\.\\\\-\\\\_]{1,250}$', // eslint-disable-line\n  CMILongIdentifier: '^(?:(?!urn:)\\\\S{1,4000}|urn:[A-Za-z0-9-]{1,31}:\\\\S{1,4000}|.{1,4000})$', // need to re-examine this\n  CMIFeedback: '^.*$', // This must be redefined\n  CMIIndex: '[._](\\\\d+).',\n  CMIIndexStore: '.N(\\\\d+).',\n\n  // Vocabulary Data Type Definition\n  CMICStatus: '^(completed|incomplete|not attempted|unknown)$',\n  CMISStatus: '^(passed|failed|unknown)$',\n  CMIExit: '^(time-out|suspend|logout|normal)$',\n  CMIType: '^(true-false|choice|fill-in|long-fill-in|matching|performance|sequencing|likert|numeric|other)$',\n  CMIResult: '^(correct|incorrect|unanticipated|neutral|-?([0-9]{1,4})(\\\\.[0-9]{1,18})?)$',\n  NAVEvent: '^(previous|continue|exit|exitAll|abandon|abandonAll|suspendAll|\\{target=\\\\S{0,200}[a-zA-Z0-9]\\}choice|jump)$', // eslint-disable-line\n  NAVBoolean: '^(unknown|true|false$)',\n  NAVTarget: '^(previous|continue|choice.{target=\\\\S{0,200}[a-zA-Z0-9]})$',\n\n  // Data ranges\n  scaled_range: '-1#1',\n  audio_range: '0#*',\n  speed_range: '0#*',\n  text_range: '-1#1',\n  progress_range: '0#1',\n};\n\nconst Regex = {\n  aicc: aicc,\n  scorm12: scorm12,\n  scorm2004: scorm2004,\n};\n\nexport default Regex;\n","// @flow\nimport Regex from './regex';\n\nconst scorm2004_regex = Regex.scorm2004;\n\nconst learner = {\n  'true-false': {\n    format: '^true$|^false$',\n    max: 1,\n    delimiter: '',\n    unique: false,\n  },\n  'choice': {\n    format: scorm2004_regex.CMIShortIdentifier,\n    max: 36,\n    delimiter: '[,]',\n    unique: true,\n  },\n  'fill-in': {\n    format: scorm2004_regex.CMILangString250,\n    max: 10,\n    delimiter: '[,]',\n    unique: false,\n  },\n  'long-fill-in': {\n    format: scorm2004_regex.CMILangString4000,\n    max: 1,\n    delimiter: '',\n    unique: false,\n  },\n  'matching': {\n    format: scorm2004_regex.CMIShortIdentifier,\n    format2: scorm2004_regex.CMIShortIdentifier,\n    max: 36,\n    delimiter: '[,]',\n    delimiter2: '[.]',\n    unique: false,\n  },\n  'performance': {\n    format: '^$|' + scorm2004_regex.CMIShortIdentifier,\n    format2: scorm2004_regex.CMIDecimal + '|^$|' +\n        scorm2004_regex.CMIShortIdentifier,\n    max: 250,\n    delimiter: '[,]',\n    delimiter2: '[.]',\n    unique: false,\n  },\n  'sequencing': {\n    format: scorm2004_regex.CMIShortIdentifier,\n    max: 36,\n    delimiter: '[,]',\n    unique: false,\n  },\n  'likert': {\n    format: scorm2004_regex.CMIShortIdentifier,\n    max: 1,\n    delimiter: '',\n    unique: false,\n  },\n  'numeric': {\n    format: scorm2004_regex.CMIDecimal,\n    max: 1,\n    delimiter: '',\n    unique: false,\n  },\n  'other': {\n    format: scorm2004_regex.CMIString4000,\n    max: 1,\n    delimiter: '',\n    unique: false,\n  },\n};\n\nconst correct = {\n  'true-false': {\n    max: 1,\n    delimiter: '',\n    unique: false,\n    duplicate: false,\n    format: '^true$|^false$',\n    limit: 1,\n  },\n  'choice': {\n    max: 36,\n    delimiter: '[,]',\n    unique: true,\n    duplicate: false,\n    format: scorm2004_regex.CMIShortIdentifier,\n  },\n  'fill-in': {\n    max: 10,\n    delimiter: '[,]',\n    unique: false,\n    duplicate: false,\n    format: scorm2004_regex.CMILangString250cr,\n  },\n  'long-fill-in': {\n    max: 1,\n    delimiter: '',\n    unique: false,\n    duplicate: true,\n    format: scorm2004_regex.CMILangString4000,\n  },\n  'matching': {\n    max: 36,\n    delimiter: '[,]',\n    delimiter2: '[.]',\n    unique: false,\n    duplicate: false,\n    format: scorm2004_regex.CMIShortIdentifier,\n    format2: scorm2004_regex.CMIShortIdentifier,\n  },\n  'performance': {\n    max: 250,\n    delimiter: '[,]',\n    delimiter2: '[.]',\n    unique: false,\n    duplicate: false,\n    format: '^$|' + scorm2004_regex.CMIShortIdentifier,\n    format2: scorm2004_regex.CMIDecimal + '|^$|' +\n        scorm2004_regex.CMIShortIdentifier,\n  },\n  'sequencing': {\n    max: 36,\n    delimiter: '[,]',\n    unique: false,\n    duplicate: false,\n    format: scorm2004_regex.CMIShortIdentifier,\n  },\n  'likert': {\n    max: 1,\n    delimiter: '',\n    unique: false,\n    duplicate: false,\n    format: scorm2004_regex.CMIShortIdentifier,\n    limit: 1,\n  },\n  'numeric': {\n    max: 2,\n    delimiter: '[:]',\n    unique: false,\n    duplicate: false,\n    format: scorm2004_regex.CMIDecimal,\n    limit: 1,\n  },\n  'other': {\n    max: 1,\n    delimiter: '',\n    unique: false,\n    duplicate: false,\n    format: scorm2004_regex.CMIString4000,\n    limit: 1,\n  },\n};\n\nconst Responses = {\n  learner: learner,\n  correct: correct,\n};\n\nexport default Responses;\n","// @flow\n\nimport APIConstants from './constants/api_constants';\n\nconst scorm12_errors = APIConstants.scorm12.error_descriptions;\nconst aicc_errors = APIConstants.aicc.error_descriptions;\nconst scorm2004_errors = APIConstants.scorm2004.error_descriptions;\n\n/**\n * Base Validation Exception\n */\nexport class ValidationError extends Error {\n  /**\n   * Constructor to take in an error message and code\n   * @param {number} errorCode\n   * @param {string} errorMessage\n   * @param {string} detailedMessage\n   */\n  constructor(errorCode: number, errorMessage: String, detailedMessage: String) {\n    super(errorMessage);\n    this.#errorCode = errorCode;\n    this.#errorMessage = errorMessage;\n    this.#detailedMessage = detailedMessage;\n  }\n\n  #errorCode;\n  #errorMessage;\n  #detailedMessage;\n\n  /**\n   * Getter for #errorCode\n   * @return {number}\n   */\n  get errorCode() {\n    return this.#errorCode;\n  }\n\n  /**\n   * Getter for #errorMessage\n   * @return {string}\n   */\n  get errorMessage() {\n    return this.#errorMessage;\n  }\n\n  /**\n   * Getter for #detailedMessage\n   * @return {string}\n   */\n  get detailedMessage() {\n    return this.#detailedMessage;\n  }\n}\n\n/**\n * SCORM 1.2 Validation Error\n */\nexport class Scorm12ValidationError extends ValidationError {\n  /**\n   * Constructor to take in an error code\n   * @param {number} errorCode\n   */\n  constructor(errorCode: number) {\n    if ({}.hasOwnProperty.call(scorm12_errors, String(errorCode))) {\n      super(errorCode, scorm12_errors[String(errorCode)].basicMessage, scorm12_errors[String(errorCode)].detailMessage);\n    } else {\n      super(101, scorm12_errors['101'].basicMessage, scorm12_errors['101'].detailMessage);\n    }\n  }\n}\n\n/**\n * AICC Validation Error\n */\nexport class AICCValidationError extends ValidationError {\n  /**\n   * Constructor to take in an error code\n   * @param {number} errorCode\n   */\n  constructor(errorCode: number) {\n    if ({}.hasOwnProperty.call(aicc_errors, String(errorCode))) {\n      super(errorCode, aicc_errors[String(errorCode)].basicMessage, aicc_errors[String(errorCode)].detailMessage);\n    } else {\n      super(101, aicc_errors['101'].basicMessage, aicc_errors['101'].detailMessage);\n    }\n  }\n}\n\n/**\n * SCORM 2004 Validation Error\n */\nexport class Scorm2004ValidationError extends ValidationError {\n  /**\n   * Constructor to take in an error code\n   * @param {number} errorCode\n   */\n  constructor(errorCode: number) {\n    if ({}.hasOwnProperty.call(scorm2004_errors, String(errorCode))) {\n      super(errorCode, scorm2004_errors[String(errorCode)].basicMessage, scorm2004_errors[String(errorCode)].detailMessage);\n    } else {\n      super(101, scorm2004_errors['101'].basicMessage, scorm2004_errors['101'].detailMessage);\n    }\n  }\n}\n","import Scorm2004API from './Scorm2004API';\nimport Scorm12API from './Scorm12API';\nimport AICC from './AICC';\n\nwindow.Scorm12API = Scorm12API;\nwindow.Scorm2004API = Scorm2004API;\nwindow.AICC = AICC;\n","// @flow\nexport const SECONDS_PER_SECOND = 1.0;\nexport const SECONDS_PER_MINUTE = 60;\nexport const SECONDS_PER_HOUR = 60 * SECONDS_PER_MINUTE;\nexport const SECONDS_PER_DAY = 24 * SECONDS_PER_HOUR;\n\nconst designations = [\n  ['D', SECONDS_PER_DAY],\n  ['H', SECONDS_PER_HOUR],\n  ['M', SECONDS_PER_MINUTE],\n  ['S', SECONDS_PER_SECOND],\n];\n\n/**\n * Converts a Number to a String of HH:MM:SS\n *\n * @param {Number} totalSeconds\n * @return {string}\n */\nexport function getSecondsAsHHMMSS(totalSeconds: Number) {\n  // SCORM spec does not deal with negative durations, give zero back\n  if (!totalSeconds || totalSeconds <= 0) {\n    return '00:00:00';\n  }\n\n  const hours = Math.floor(totalSeconds / SECONDS_PER_HOUR);\n\n  const dateObj = new Date(totalSeconds * 1000);\n  const minutes = dateObj.getUTCMinutes();\n  // make sure we add any possible decimal value\n  const seconds = dateObj.getSeconds();\n  const ms = totalSeconds % 1.0;\n  let msStr = '';\n  if (countDecimals(ms) > 0) {\n    if (countDecimals(ms) > 2) {\n      msStr = ms.toFixed(2);\n    } else {\n      msStr = String(ms);\n    }\n    msStr = '.' + msStr.split('.')[1];\n  }\n\n  return (hours + ':' + minutes + ':' + seconds).replace(/\\b\\d\\b/g,\n      '0$&') + msStr;\n}\n\n/**\n * Calculate the number of seconds from ISO 8601 Duration\n *\n * @param {Number} seconds\n * @return {String}\n */\nexport function getSecondsAsISODuration(seconds: Number) {\n  // SCORM spec does not deal with negative durations, give zero back\n  if (!seconds || seconds <= 0) {\n    return 'PT0S';\n  }\n\n  let duration = 'P';\n  let remainder = seconds;\n\n  designations.forEach(([sign, current_seconds]) => {\n    let value = Math.floor(remainder / current_seconds);\n\n    remainder = remainder % current_seconds;\n    if (countDecimals(remainder) > 2) {\n      remainder = Number(Number(remainder).toFixed(2));\n    }\n    // If we have anything left in the remainder, and we're currently adding\n    // seconds to the duration, go ahead and add the decimal to the seconds\n    if (sign === 'S' && remainder > 0) {\n      value += remainder;\n    }\n\n    if (value) {\n      if ((duration.indexOf('D') > 0 ||\n          sign === 'H' || sign === 'M' || sign === 'S') &&\n          duration.indexOf('T') === -1) {\n        duration += 'T';\n      }\n      duration += `${value}${sign}`;\n    }\n  });\n\n  return duration;\n}\n\n/**\n * Calculate the number of seconds from HH:MM:SS.DDDDDD\n *\n * @param {string} timeString\n * @param {RegExp} timeRegex\n * @return {number}\n */\nexport function getTimeAsSeconds(timeString: String, timeRegex: RegExp) {\n  if (!timeString || typeof timeString !== 'string' ||\n      !timeString.match(timeRegex)) {\n    return 0;\n  }\n  const parts = timeString.split(':');\n  const hours = Number(parts[0]);\n  const minutes = Number(parts[1]);\n  const seconds = Number(parts[2]);\n  return (hours * 3600) + (minutes * 60) + seconds;\n}\n\n/**\n * Calculate the number of seconds from ISO 8601 Duration\n *\n * @param {string} duration\n * @param {RegExp} durationRegex\n * @return {number}\n */\nexport function getDurationAsSeconds(duration: String, durationRegex: RegExp) {\n  if (!duration || !duration.match(durationRegex)) {\n    return 0;\n  }\n\n  const [, years, months, , days, hours, minutes, seconds] = new RegExp(\n      durationRegex).exec(duration) || [];\n\n  let result = 0.0;\n\n  result += (Number(seconds) * 1.0 || 0.0);\n  result += (Number(minutes) * 60.0 || 0.0);\n  result += (Number(hours) * 3600.0 || 0.0);\n  result += (Number(days) * (60 * 60 * 24.0) || 0.0);\n  result += (Number(years) * (60 * 60 * 24 * 365.0) || 0.0);\n\n  return result;\n}\n\n/**\n * Adds together two ISO8601 Duration strings\n *\n * @param {string} first\n * @param {string} second\n * @param {RegExp} durationRegex\n * @return {string}\n */\nexport function addTwoDurations(\n    first: String,\n    second: String,\n    durationRegex: RegExp) {\n  return getSecondsAsISODuration(\n      getDurationAsSeconds(first, durationRegex) +\n      getDurationAsSeconds(second, durationRegex),\n  );\n}\n\n/**\n * Add together two HH:MM:SS.DD strings\n *\n * @param {string} first\n * @param {string} second\n * @param {RegExp} timeRegex\n * @return {string}\n */\nexport function addHHMMSSTimeStrings(\n    first: String,\n    second: String,\n    timeRegex: RegExp) {\n  return getSecondsAsHHMMSS(\n      getTimeAsSeconds(first, timeRegex) +\n      getTimeAsSeconds(\n          second, timeRegex),\n  );\n}\n\n/**\n * Flatten a JSON object down to string paths for each values\n * @param {object} data\n * @return {object}\n */\nexport function flatten(data) {\n  const result = {};\n\n  /**\n   * Recurse through the object\n   * @param {*} cur\n   * @param {*} prop\n   */\n  function recurse(cur, prop) {\n    if (Object(cur) !== cur) {\n      result[prop] = cur;\n    } else if (Array.isArray(cur)) {\n      for (let i = 0, l = cur.length; i < l; i++) {\n        recurse(cur[i], prop + '[' + i + ']');\n        if (l === 0) result[prop] = [];\n      }\n    } else {\n      let isEmpty = true;\n      for (const p in cur) {\n        if ({}.hasOwnProperty.call(cur, p)) {\n          isEmpty = false;\n          recurse(cur[p], prop ? prop + '.' + p : p);\n        }\n      }\n      if (isEmpty && prop) result[prop] = {};\n    }\n  }\n\n  recurse(data, '');\n  return result;\n}\n\n/**\n * Un-flatten a flat JSON object\n * @param {object} data\n * @return {object}\n */\nexport function unflatten(data) {\n  'use strict';\n  if (Object(data) !== data || Array.isArray(data)) return data;\n  const regex = /\\.?([^.[\\]]+)|\\[(\\d+)]/g;\n  const result = {};\n  for (const p in data) {\n    if ({}.hasOwnProperty.call(data, p)) {\n      let cur = result;\n      let prop = '';\n      let m = regex.exec(p);\n      while (m) {\n        cur = cur[prop] || (cur[prop] = (m[2] ? [] : {}));\n        prop = m[2] || m[1];\n        m = regex.exec(p);\n      }\n      cur[prop] = data[p];\n    }\n  }\n  return result[''] || result;\n}\n\n/**\n * Counts the number of decimal places\n * @param {number} num\n * @return {number}\n */\nexport function countDecimals(num: number) {\n  if (Math.floor(num) === num || String(num).indexOf('.') < 0) return 0;\n  const parts = num.toString().split('.')[1];\n  return parts.length || 0;\n}\n"]} +},{}]},{},[16]) +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","node_modules/lodash.debounce/index.js","src/AICC.js","src/BaseAPI.js","src/Scorm12API.js","src/Scorm2004API.js","src/cmi/aicc_cmi.js","src/cmi/common.js","src/cmi/scorm12_cmi.js","src/cmi/scorm2004_cmi.js","src/constants/api_constants.js","src/constants/error_codes.js","src/constants/language_constants.js","src/constants/regex.js","src/constants/response_constants.js","src/exceptions.js","src/exports/scorm-again.js","src/utilities.js"],"names":[],"mappings":"AAAA;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACxXA;;AACA;;AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA;AACA;AACA;IACqB,I;;;;;AACnB;AACF;AACA;AACA;AACE,gBAAY,QAAZ,EAA0B;AAAA;;AAAA;;AACxB,QAAM,aAAa,mCACd;AACD,MAAA,gBAAgB,EAAE;AADjB,KADc,GAGX,QAHW,CAAnB;;AAMA,8BAAM,aAAN;AAEA,UAAK,GAAL,GAAW,IAAI,aAAJ,EAAX;AACA,UAAK,GAAL,GAAW,IAAI,gBAAJ,EAAX;AAVwB;AAWzB;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;;;;;WACE,yBAAgB,UAAhB,EAA4B,KAA5B,EAAmC,eAAnC,EAAoD;AAClD,UAAI,QAAQ,6EAAyB,UAAzB,EAAqC,KAArC,EAA4C,eAA5C,CAAZ;;AAEA,UAAI,CAAC,QAAL,EAAe;AACb,YAAI,KAAK,aAAL,CAAmB,UAAnB,EAA+B,oCAA/B,CAAJ,EAA0E;AACxE,UAAA,QAAQ,GAAG,IAAI,qCAAJ,EAAX;AACD,SAFD,MAEO,IAAI,KAAK,aAAL,CAAmB,UAAnB,EACP,mCADO,CAAJ,EACmC;AACxC,UAAA,QAAQ,GAAG,IAAI,wBAAJ,EAAX;AACD,SAHM,MAGA,IAAI,KAAK,aAAL,CAAmB,UAAnB,EACP,6CADO,CAAJ,EAC6C;AAClD,UAAA,QAAQ,GAAG,IAAI,iCAAJ,EAAX;AACD;AACF;;AAED,aAAO,QAAP;AACD;AAED;AACF;AACA;AACA;AACA;;;;WACE,oCAA2B,MAA3B,EAAmC;AACjC;AACA,WAAK,GAAL,GAAW,MAAM,CAAC,GAAlB;AACA,WAAK,GAAL,GAAW,MAAM,CAAC,GAAlB;AACD;;;;EArD+B,uB;;;;;;;;;;;;ACZlC;;AACA;;AACA;;AACA;;AACA;;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,IAAM,gBAAgB,GAAG,0BAAa,MAAtC;AACA,IAAM,mBAAmB,GAAG,yBAAW,OAAvC;AAEA;AACA;AACA;AACA;;;;;;;;IACqB,O;AAqCnB;AACF;AACA;AACA;AACA;AACA;AACE,mBAAY,WAAZ,EAAyB,QAAzB,EAAmC;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA,aAxCvB;AACV,QAAA,UAAU,EAAE,KADF;AAEV,QAAA,iBAAiB,EAAE,EAFT;AAGV,QAAA,WAAW,EAAE,KAHH;AAIV,QAAA,gBAAgB,EAAE,KAJR;AAKV,QAAA,YAAY,EAAE,KALJ;AAMV,QAAA,gBAAgB,EAAE,MANR;AAMgB;AAC1B,QAAA,qBAAqB,EAAE,gCAPb;AAQV,QAAA,YAAY,EAAE,KARJ;AASV,QAAA,QAAQ,EAAE,gBAAgB,CAAC,eATjB;AAUV,QAAA,qBAAqB,EAAE,KAVb;AAWV,QAAA,mBAAmB,EAAE,KAXX;AAYV,QAAA,aAAa,EAAE,IAZL;AAaV,QAAA,eAAe,EAAE,yBAAS,GAAT,EAAc;AAC7B,cAAI,MAAJ;;AACA,cAAI,OAAO,GAAP,KAAe,WAAnB,EAAgC;AAC9B,YAAA,MAAM,GAAG,IAAI,CAAC,KAAL,CAAW,GAAG,CAAC,YAAf,CAAT;;AACA,gBAAI,MAAM,KAAK,IAAX,IAAmB,CAAC,GAAG,cAAH,CAAkB,IAAlB,CAAuB,MAAvB,EAA+B,QAA/B,CAAxB,EAAkE;AAChE,cAAA,MAAM,GAAG,EAAT;;AACA,kBAAI,GAAG,CAAC,MAAJ,KAAe,GAAnB,EAAwB;AACtB,gBAAA,MAAM,CAAC,MAAP,GAAgB,gBAAgB,CAAC,UAAjC;AACA,gBAAA,MAAM,CAAC,SAAP,GAAmB,CAAnB;AACD,eAHD,MAGO;AACL,gBAAA,MAAM,CAAC,MAAP,GAAgB,gBAAgB,CAAC,WAAjC;AACA,gBAAA,MAAM,CAAC,SAAP,GAAmB,GAAnB;AACD;AACF;AACF;;AACD,iBAAO,MAAP;AACD;AA7BS;AAwCuB;;AAAA;;AAAA;;AACjC,QAAI,0DAAe,OAAnB,EAA4B;AAC1B,YAAM,IAAI,SAAJ,CAAc,6CAAd,CAAN;AACD;;AACD,SAAK,YAAL,GAAoB,gBAAgB,CAAC,qBAArC;AACA,SAAK,aAAL,GAAqB,CAArB;AACA,SAAK,aAAL,GAAqB,EAArB;;AAEA,0CAAgB,IAAhB;;AACA,8CAAoB,WAApB;;AAEA,SAAK,QAAL,GAAgB,QAAhB;AACA,SAAK,WAAL,GAAmB,KAAK,QAAL,CAAc,QAAjC;AACA,SAAK,qBAAL,GAA6B,KAAK,QAAL,CAAc,qBAA3C;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;;;;;WACE,oBACI,YADJ,EAEI,iBAFJ,EAGI,kBAHJ,EAGiC;AAC/B,UAAI,WAAW,GAAG,gBAAgB,CAAC,WAAnC;;AAEA,UAAI,KAAK,aAAL,EAAJ,EAA0B;AACxB,aAAK,eAAL,CAAqB,0CAAkB,WAAvC,EAAoD,iBAApD;AACD,OAFD,MAEO,IAAI,KAAK,YAAL,EAAJ,EAAyB;AAC9B,aAAK,eAAL,CAAqB,0CAAkB,UAAvC,EAAmD,kBAAnD;AACD,OAFM,MAEA;AACL,YAAI,KAAK,qBAAT,EAAgC;AAC9B,eAAK,GAAL,CAAS,YAAT;AACD;;AAED,aAAK,YAAL,GAAoB,gBAAgB,CAAC,iBAArC;AACA,aAAK,aAAL,GAAqB,CAArB;AACA,QAAA,WAAW,GAAG,gBAAgB,CAAC,UAA/B;AACA,aAAK,gBAAL,CAAsB,YAAtB;AACD;;AAED,WAAK,MAAL,CAAY,YAAZ,EAA0B,IAA1B,EAAgC,eAAe,WAA/C,EACI,gBAAgB,CAAC,cADrB;AAEA,WAAK,eAAL,CAAqB,WAArB;AAEA,aAAO,WAAP;AACD;AAED;AACF;AACA;AACA;;;;SACE,eAAkB;AAChB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;;;SACE,eAAe;AACb,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAa,QAAb,EAA+B;AAC7B,mGAAqB,IAArB,eAAwC,QAAxC;AACD;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,mBACI,YADJ,EAEI,eAFJ,EAE8B;AAC5B,UAAI,WAAW,GAAG,gBAAgB,CAAC,WAAnC;;AAEA,UAAI,KAAK,UAAL,CAAgB,eAAhB,EACA,0CAAkB,uBADlB,EAEA,0CAAkB,oBAFlB,CAAJ,EAE6C;AAC3C,aAAK,YAAL,GAAoB,gBAAgB,CAAC,gBAArC;AAEA,YAAM,MAAM,GAAG,KAAK,SAAL,CAAe,IAAf,CAAf;;AACA,YAAI,CAAC,KAAK,QAAL,CAAc,gBAAf,IAAmC,CAAC,KAAK,QAAL,CAAc,WAAlD,IACA,OAAO,MAAM,CAAC,SAAd,KAA4B,WAD5B,IAC2C,MAAM,CAAC,SAAP,GAAmB,CADlE,EACqE;AACnE,eAAK,eAAL,CAAqB,MAAM,CAAC,SAA5B;AACD;;AACD,QAAA,WAAW,GAAI,OAAO,MAAP,KAAkB,WAAlB,IAAiC,MAAM,CAAC,MAAzC,GACV,MAAM,CAAC,MADG,GACM,gBAAgB,CAAC,WADrC;AAGA,YAAI,eAAJ,EAAqB,KAAK,aAAL,GAAqB,CAArB;AAErB,QAAA,WAAW,GAAG,gBAAgB,CAAC,UAA/B;AACA,aAAK,gBAAL,CAAsB,YAAtB;AACD;;AAED,WAAK,MAAL,CAAY,YAAZ,EAA0B,IAA1B,EAAgC,eAAe,WAA/C,EACI,gBAAgB,CAAC,cADrB;AAEA,WAAK,eAAL,CAAqB,WAArB;AAEA,aAAO,WAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,kBACI,YADJ,EAEI,eAFJ,EAGI,UAHJ,EAGwB;AACtB,UAAI,WAAJ;;AAEA,UAAI,KAAK,UAAL,CAAgB,eAAhB,EACA,0CAAkB,oBADlB,EAEA,0CAAkB,mBAFlB,CAAJ,EAE4C;AAC1C,YAAI,eAAJ,EAAqB,KAAK,aAAL,GAAqB,CAArB;;AACrB,YAAI;AACF,UAAA,WAAW,GAAG,KAAK,WAAL,CAAiB,UAAjB,CAAd;AACD,SAFD,CAEE,OAAO,CAAP,EAAU;AACV,cAAI,CAAC,YAAY,2BAAjB,EAAkC;AAChC,iBAAK,aAAL,GAAqB,CAAC,CAAC,SAAvB;AACA,YAAA,WAAW,GAAG,gBAAgB,CAAC,WAA/B;AACD,WAHD,MAGO;AACL,gBAAI,CAAC,CAAC,OAAN,EAAe;AACb,cAAA,OAAO,CAAC,KAAR,CAAc,CAAC,CAAC,OAAhB;AACD,aAFD,MAEO;AACL,cAAA,OAAO,CAAC,KAAR,CAAc,CAAd;AACD;;AACD,iBAAK,eAAL,CAAqB,0CAAkB,OAAvC;AACD;AACF;;AACD,aAAK,gBAAL,CAAsB,YAAtB,EAAoC,UAApC;AACD;;AAED,WAAK,MAAL,CAAY,YAAZ,EAA0B,UAA1B,EAAsC,iBAAiB,WAAvD,EACI,gBAAgB,CAAC,cADrB;AAEA,WAAK,eAAL,CAAqB,WAArB;AAEA,aAAO,WAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,kBACI,YADJ,EAEI,cAFJ,EAGI,eAHJ,EAII,UAJJ,EAKI,KALJ,EAKW;AACT,UAAI,KAAK,KAAK,SAAd,EAAyB;AACvB,QAAA,KAAK,GAAG,MAAM,CAAC,KAAD,CAAd;AACD;;AACD,UAAI,WAAW,GAAG,gBAAgB,CAAC,WAAnC;;AAEA,UAAI,KAAK,UAAL,CAAgB,eAAhB,EAAiC,0CAAkB,iBAAnD,EACA,0CAAkB,gBADlB,CAAJ,EACyC;AACvC,YAAI,eAAJ,EAAqB,KAAK,aAAL,GAAqB,CAArB;;AACrB,YAAI;AACF,UAAA,WAAW,GAAG,KAAK,WAAL,CAAiB,UAAjB,EAA6B,KAA7B,CAAd;AACD,SAFD,CAEE,OAAO,CAAP,EAAU;AACV,cAAI,CAAC,YAAY,2BAAjB,EAAkC;AAChC,iBAAK,aAAL,GAAqB,CAAC,CAAC,SAAvB;AACA,YAAA,WAAW,GAAG,gBAAgB,CAAC,WAA/B;AACD,WAHD,MAGO;AACL,gBAAI,CAAC,CAAC,OAAN,EAAe;AACb,cAAA,OAAO,CAAC,KAAR,CAAc,CAAC,CAAC,OAAhB;AACD,aAFD,MAEO;AACL,cAAA,OAAO,CAAC,KAAR,CAAc,CAAd;AACD;;AACD,iBAAK,eAAL,CAAqB,0CAAkB,OAAvC;AACD;AACF;;AACD,aAAK,gBAAL,CAAsB,YAAtB,EAAoC,UAApC,EAAgD,KAAhD;AACD;;AAED,UAAI,WAAW,KAAK,SAApB,EAA+B;AAC7B,QAAA,WAAW,GAAG,gBAAgB,CAAC,WAA/B;AACD,OA7BQ,CA+BT;AACA;;;AACA,UAAI,MAAM,CAAC,KAAK,aAAN,CAAN,KAA+B,GAAnC,EAAwC;AACtC,YAAI,KAAK,QAAL,CAAc,UAAd,IAA4B,uBAAC,IAAD,WAAhC,EAAgD;AAC9C,eAAK,cAAL,CAAoB,KAAK,QAAL,CAAc,iBAAd,GAAkC,IAAtD,EAA4D,cAA5D;AACD;AACF;;AAED,WAAK,MAAL,CAAY,YAAZ,EAA0B,UAA1B,EACI,OAAO,KAAP,GAAe,YAAf,GAA8B,WADlC,EAEI,gBAAgB,CAAC,cAFrB;AAGA,WAAK,eAAL,CAAqB,WAArB;AAEA,aAAO,WAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,gBACI,YADJ,EAEI,eAFJ,EAE8B;AAC5B,WAAK,oBAAL;AAEA,UAAI,WAAW,GAAG,gBAAgB,CAAC,WAAnC;;AAEA,UAAI,KAAK,UAAL,CAAgB,eAAhB,EAAiC,0CAAkB,kBAAnD,EACA,0CAAkB,iBADlB,CAAJ,EAC0C;AACxC,YAAM,MAAM,GAAG,KAAK,SAAL,CAAe,KAAf,CAAf;;AACA,YAAI,CAAC,KAAK,QAAL,CAAc,gBAAf,IAAmC,CAAC,KAAK,QAAL,CAAc,WAAlD,IACA,MAAM,CAAC,SADP,IACoB,MAAM,CAAC,SAAP,GAAmB,CAD3C,EAC8C;AAC5C,eAAK,eAAL,CAAqB,MAAM,CAAC,SAA5B;AACD;;AACD,QAAA,WAAW,GAAI,OAAO,MAAP,KAAkB,WAAlB,IAAiC,MAAM,CAAC,MAAzC,GACV,MAAM,CAAC,MADG,GACM,gBAAgB,CAAC,WADrC;AAGA,aAAK,MAAL,CAAY,YAAZ,EAA0B,aAA1B,EAAyC,cAAc,WAAvD,EACI,gBAAgB,CAAC,eADrB;AAGA,YAAI,eAAJ,EAAqB,KAAK,aAAL,GAAqB,CAArB;AAErB,aAAK,gBAAL,CAAsB,YAAtB;AACD;;AAED,WAAK,MAAL,CAAY,YAAZ,EAA0B,IAA1B,EAAgC,eAAe,WAA/C,EACI,gBAAgB,CAAC,cADrB;AAEA,WAAK,eAAL,CAAqB,WAArB;AAEA,aAAO,WAAP;AACD;AAED;AACF;AACA;AACA;AACA;;;;WACE,sBAAa,YAAb,EAAmC;AACjC,UAAM,WAAW,GAAG,MAAM,CAAC,KAAK,aAAN,CAA1B;AAEA,WAAK,gBAAL,CAAsB,YAAtB;AAEA,WAAK,MAAL,CAAY,YAAZ,EAA0B,IAA1B,EAAgC,eAAe,WAA/C,EACI,gBAAgB,CAAC,cADrB;AAGA,aAAO,WAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;;;;WACE,wBAAe,YAAf,EAAqC,YAArC,EAAmD;AACjD,UAAI,WAAW,GAAG,EAAlB;;AAEA,UAAI,YAAY,KAAK,IAAjB,IAAyB,YAAY,KAAK,EAA9C,EAAkD;AAChD,QAAA,WAAW,GAAG,KAAK,yBAAL,CAA+B,YAA/B,CAAd;AACA,aAAK,gBAAL,CAAsB,YAAtB;AACD;;AAED,WAAK,MAAL,CAAY,YAAZ,EAA0B,IAA1B,EAAgC,eAAe,WAA/C,EACI,gBAAgB,CAAC,cADrB;AAGA,aAAO,WAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;;;;WACE,uBAAc,YAAd,EAAoC,YAApC,EAAkD;AAChD,UAAI,WAAW,GAAG,EAAlB;;AAEA,UAAI,YAAY,KAAK,IAAjB,IAAyB,YAAY,KAAK,EAA9C,EAAkD;AAChD,QAAA,WAAW,GAAG,KAAK,yBAAL,CAA+B,YAA/B,EAA6C,IAA7C,CAAd;AACA,aAAK,gBAAL,CAAsB,YAAtB;AACD;;AAED,WAAK,MAAL,CAAY,YAAZ,EAA0B,IAA1B,EAAgC,eAAe,WAA/C,EACI,gBAAgB,CAAC,cADrB;AAGA,aAAO,WAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,oBACI,eADJ,EAEI,eAFJ,EAGI,cAHJ,EAG6B;AAC3B,UAAI,KAAK,gBAAL,EAAJ,EAA6B;AAC3B,aAAK,eAAL,CAAqB,eAArB;AACA,eAAO,KAAP;AACD,OAHD,MAGO,IAAI,eAAe,IAAI,KAAK,YAAL,EAAvB,EAA4C;AACjD,aAAK,eAAL,CAAqB,cAArB;AACA,eAAO,KAAP;AACD;;AAED,aAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,gBACI,YADJ,EAEI,UAFJ,EAGI,UAHJ,EAII,YAJJ,EAI0B;AACxB,MAAA,UAAU,GAAG,KAAK,aAAL,CAAmB,YAAnB,EAAiC,UAAjC,EAA6C,UAA7C,CAAb;;AAEA,UAAI,YAAY,IAAI,KAAK,WAAzB,EAAsC;AACpC,gBAAQ,YAAR;AACE,eAAK,gBAAgB,CAAC,eAAtB;AACE,YAAA,OAAO,CAAC,KAAR,CAAc,UAAd;AACA;;AACF,eAAK,gBAAgB,CAAC,iBAAtB;AACE,YAAA,OAAO,CAAC,IAAR,CAAa,UAAb;AACA;;AACF,eAAK,gBAAgB,CAAC,cAAtB;AACE,YAAA,OAAO,CAAC,IAAR,CAAa,UAAb;AACA;;AACF,eAAK,gBAAgB,CAAC,eAAtB;AACE,gBAAI,OAAO,CAAC,KAAZ,EAAmB;AACjB,cAAA,OAAO,CAAC,KAAR,CAAc,UAAd;AACD,aAFD,MAEO;AACL,cAAA,OAAO,CAAC,GAAR,CAAY,UAAZ;AACD;;AACD;AAhBJ;AAkBD;AACF;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,uBAAc,YAAd,EAAoC,UAApC,EAAwD,OAAxD,EAAyE;AACvE,UAAM,UAAU,GAAG,EAAnB;AACA,UAAI,aAAa,GAAG,EAApB;AAEA,MAAA,aAAa,IAAI,YAAjB;AAEA,UAAI,SAAS,GAAG,UAAU,GAAG,aAAa,CAAC,MAA3C;;AAEA,WAAK,IAAI,CAAC,GAAG,CAAb,EAAgB,CAAC,GAAG,SAApB,EAA+B,CAAC,EAAhC,EAAoC;AAClC,QAAA,aAAa,IAAI,GAAjB;AACD;;AAED,MAAA,aAAa,IAAI,IAAjB;;AAEA,UAAI,UAAJ,EAAgB;AACd,YAAM,oBAAoB,GAAG,EAA7B;AAEA,QAAA,aAAa,IAAI,UAAjB;AAEA,QAAA,SAAS,GAAG,oBAAoB,GAAG,aAAa,CAAC,MAAjD;;AAEA,aAAK,IAAI,CAAC,GAAG,CAAb,EAAgB,CAAC,GAAG,SAApB,EAA+B,CAAC,EAAhC,EAAoC;AAClC,UAAA,aAAa,IAAI,GAAjB;AACD;AACF;;AAED,UAAI,OAAJ,EAAa;AACX,QAAA,aAAa,IAAI,OAAjB;AACD;;AAED,aAAO,aAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;;;;WACE,uBAAc,GAAd,EAA2B,MAA3B,EAA2C;AACzC,aAAO,GAAG,IAAI,MAAP,IAAiB,GAAG,CAAC,KAAJ,CAAU,MAAV,CAAxB;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;;;;WACE,iCAAwB,SAAxB,EAAmC,SAAnC,EAAsD;AACpD,aAAO,MAAM,CAAC,cAAP,CAAsB,IAAtB,CAA2B,SAA3B,EAAsC,SAAtC,KACH,MAAM,CAAC,wBAAP,CACI,MAAM,CAAC,cAAP,CAAsB,SAAtB,CADJ,EACsC,SADtC,CADG,IAGF,SAAS,IAAI,SAHlB;AAID;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,mCAA0B,YAA1B,EAAwC,OAAxC,EAAiD;AAC/C,YAAM,IAAI,KAAJ,CACF,+DADE,CAAN;AAED;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,qBAAY,WAAZ,EAAyB;AACvB,YAAM,IAAI,KAAJ,CAAU,iDAAV,CAAN;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,qBAAY,WAAZ,EAAyB,MAAzB,EAAiC;AAC/B,YAAM,IAAI,KAAJ,CAAU,iDAAV,CAAN;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,4BACI,UADJ,EACwB,SADxB,EAC4C,UAD5C,EACwD,KADxD,EAC+D;AAC7D,UAAI,CAAC,UAAD,IAAe,UAAU,KAAK,EAAlC,EAAsC;AACpC,eAAO,gBAAgB,CAAC,WAAxB;AACD;;AAED,UAAM,SAAS,GAAG,UAAU,CAAC,KAAX,CAAiB,GAAjB,CAAlB;AACA,UAAI,SAAS,GAAG,IAAhB;AACA,UAAI,WAAW,GAAG,gBAAgB,CAAC,WAAnC;AACA,UAAI,eAAe,GAAG,KAAtB;AAEA,UAAM,mBAAmB,8CAAuC,UAAvC,eAAsD,UAAtD,+CAAzB;AACA,UAAM,gBAAgB,GAAG,SAAS,GAC9B,0CAAkB,oBADY,GAE9B,0CAAkB,OAFtB;;AAIA,WAAK,IAAI,CAAC,GAAG,CAAb,EAAgB,CAAC,GAAG,SAAS,CAAC,MAA9B,EAAsC,CAAC,EAAvC,EAA2C;AACzC,YAAM,SAAS,GAAG,SAAS,CAAC,CAAD,CAA3B;;AAEA,YAAI,CAAC,KAAK,SAAS,CAAC,MAAV,GAAmB,CAA7B,EAAgC;AAC9B,cAAI,SAAS,IAAK,SAAS,CAAC,MAAV,CAAiB,CAAjB,EAAoB,CAApB,MAA2B,UAAzC,IACC,OAAO,SAAS,CAAC,cAAjB,IAAmC,UADxC,EACqD;AACnD,iBAAK,eAAL,CAAqB,0CAAkB,iBAAvC;AACD,WAHD,MAGO,IAAI,CAAC,KAAK,uBAAL,CAA6B,SAA7B,EAAwC,SAAxC,CAAL,EAAyD;AAC9D,iBAAK,eAAL,CAAqB,gBAArB,EAAuC,mBAAvC;AACD,WAFM,MAEA;AACL,gBAAI,KAAK,aAAL,MACA,KAAK,aAAL,CAAmB,UAAnB,EAA+B,6BAA/B,CADJ,EACmE;AACjE,mBAAK,uBAAL,CAA6B,UAA7B,EAAyC,KAAzC;AACD;;AAED,gBAAI,CAAC,SAAD,IAAc,KAAK,aAAL,KAAuB,CAAzC,EAA4C;AAC1C,cAAA,SAAS,CAAC,SAAD,CAAT,GAAuB,KAAvB;AACA,cAAA,WAAW,GAAG,gBAAgB,CAAC,UAA/B;AACD;AACF;AACF,SAjBD,MAiBO;AACL,UAAA,SAAS,GAAG,SAAS,CAAC,SAAD,CAArB;;AACA,cAAI,CAAC,SAAL,EAAgB;AACd,iBAAK,eAAL,CAAqB,gBAArB,EAAuC,mBAAvC;AACA;AACD;;AAED,cAAI,SAAS,YAAY,gBAAzB,EAAmC;AACjC,gBAAM,KAAK,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC,GAAG,CAAL,CAAV,EAAmB,EAAnB,CAAtB,CADiC,CAGjC;;AACA,gBAAI,CAAC,KAAK,CAAC,KAAD,CAAV,EAAmB;AACjB,kBAAM,IAAI,GAAG,SAAS,CAAC,UAAV,CAAqB,KAArB,CAAb;;AAEA,kBAAI,IAAJ,EAAU;AACR,gBAAA,SAAS,GAAG,IAAZ;AACA,gBAAA,eAAe,GAAG,IAAlB;AACD,eAHD,MAGO;AACL,oBAAM,QAAQ,GAAG,KAAK,eAAL,CAAqB,UAArB,EAAiC,KAAjC,EACb,eADa,CAAjB;AAEA,gBAAA,eAAe,GAAG,IAAlB;;AAEA,oBAAI,CAAC,QAAL,EAAe;AACb,uBAAK,eAAL,CAAqB,gBAArB,EAAuC,mBAAvC;AACD,iBAFD,MAEO;AACL,sBAAI,SAAS,CAAC,WAAd,EAA2B,QAAQ,CAAC,UAAT;AAE3B,kBAAA,SAAS,CAAC,UAAV,CAAqB,IAArB,CAA0B,QAA1B;AACA,kBAAA,SAAS,GAAG,QAAZ;AACD;AACF,eAnBgB,CAqBjB;;;AACA,cAAA,CAAC;AACF;AACF;AACF;AACF;;AAED,UAAI,WAAW,KAAK,gBAAgB,CAAC,WAArC,EAAkD;AAChD,aAAK,MAAL,CAAY,UAAZ,EAAwB,IAAxB,sDACiD,UADjD,yBAC0E,KAD1E,GAEI,gBAAgB,CAAC,iBAFrB;AAGD;;AAED,aAAO,WAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,iCAAwB,WAAxB,EAAqC,MAArC,EAA6C,CAC3C;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,yBAAgB,WAAhB,EAA6B,MAA7B,EAAqC,gBAArC,EAAuD;AACrD,YAAM,IAAI,KAAJ,CAAU,qDAAV,CAAN;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,4BAAmB,UAAnB,EAAuC,SAAvC,EAA2D,UAA3D,EAAuE;AACrE,UAAI,CAAC,UAAD,IAAe,UAAU,KAAK,EAAlC,EAAsC;AACpC,eAAO,EAAP;AACD;;AAED,UAAM,SAAS,GAAG,UAAU,CAAC,KAAX,CAAiB,GAAjB,CAAlB;AACA,UAAI,SAAS,GAAG,IAAhB;AACA,UAAI,SAAS,GAAG,IAAhB;AAEA,UAAM,yBAAyB,8CAAuC,UAAvC,eAAsD,UAAtD,gCAA/B;AACA,UAAM,mBAAmB,8CAAuC,UAAvC,eAAsD,UAAtD,+CAAzB;AACA,UAAM,gBAAgB,GAAG,SAAS,GAC9B,0CAAkB,oBADY,GAE9B,0CAAkB,OAFtB;;AAIA,WAAK,IAAI,CAAC,GAAG,CAAb,EAAgB,CAAC,GAAG,SAAS,CAAC,MAA9B,EAAsC,CAAC,EAAvC,EAA2C;AACzC,QAAA,SAAS,GAAG,SAAS,CAAC,CAAD,CAArB;;AAEA,YAAI,CAAC,SAAL,EAAgB;AACd,cAAI,CAAC,KAAK,SAAS,CAAC,MAAV,GAAmB,CAA7B,EAAgC;AAC9B,gBAAI,CAAC,KAAK,uBAAL,CAA6B,SAA7B,EAAwC,SAAxC,CAAL,EAAyD;AACvD,mBAAK,eAAL,CAAqB,gBAArB,EAAuC,mBAAvC;AACA;AACD;AACF;AACF,SAPD,MAOO;AACL,cAAK,MAAM,CAAC,SAAD,CAAN,CAAkB,MAAlB,CAAyB,CAAzB,EAA4B,CAA5B,MAAmC,UAApC,IACC,OAAO,SAAS,CAAC,cAAjB,IAAmC,UADxC,EACqD;AACnD,gBAAM,MAAM,GAAG,MAAM,CAAC,SAAD,CAAN,CACX,MADW,CACJ,CADI,EACD,MAAM,CAAC,SAAD,CAAN,CAAkB,MAAlB,GAA2B,CAD1B,CAAf;AAEA,mBAAO,SAAS,CAAC,cAAV,CAAyB,MAAzB,CAAP;AACD,WALD,MAKO,IAAI,CAAC,KAAK,uBAAL,CAA6B,SAA7B,EAAwC,SAAxC,CAAL,EAAyD;AAC9D,iBAAK,eAAL,CAAqB,gBAArB,EAAuC,mBAAvC;AACA;AACD;AACF;;AAED,QAAA,SAAS,GAAG,SAAS,CAAC,SAAD,CAArB;;AACA,YAAI,SAAS,KAAK,SAAlB,EAA6B;AAC3B,eAAK,eAAL,CAAqB,gBAArB,EAAuC,mBAAvC;AACA;AACD;;AAED,YAAI,SAAS,YAAY,gBAAzB,EAAmC;AACjC,cAAM,KAAK,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC,GAAG,CAAL,CAAV,EAAmB,EAAnB,CAAtB,CADiC,CAGjC;;AACA,cAAI,CAAC,KAAK,CAAC,KAAD,CAAV,EAAmB;AACjB,gBAAM,IAAI,GAAG,SAAS,CAAC,UAAV,CAAqB,KAArB,CAAb;;AAEA,gBAAI,IAAJ,EAAU;AACR,cAAA,SAAS,GAAG,IAAZ;AACD,aAFD,MAEO;AACL,mBAAK,eAAL,CAAqB,0CAAkB,qBAAvC,EACI,yBADJ;AAEA;AACD,aATgB,CAWjB;;;AACA,YAAA,CAAC;AACF;AACF;AACF;;AAED,UAAI,SAAS,KAAK,IAAd,IAAsB,SAAS,KAAK,SAAxC,EAAmD;AACjD,YAAI,CAAC,SAAL,EAAgB;AACd,cAAI,SAAS,KAAK,WAAlB,EAA+B;AAC7B,iBAAK,eAAL,CAAqB,mBAAmB,CAAC,cAAzC;AACD,WAFD,MAEO,IAAI,SAAS,KAAK,QAAlB,EAA4B;AACjC,iBAAK,eAAL,CAAqB,mBAAmB,CAAC,WAAzC;AACD;AACF;AACF,OARD,MAQO;AACL,eAAO,SAAP;AACD;AACF;AAED;AACF;AACA;AACA;AACA;;;;WACE,yBAAgB;AACd,aAAO,KAAK,YAAL,KAAsB,gBAAgB,CAAC,iBAA9C;AACD;AAED;AACF;AACA;AACA;AACA;;;;WACE,4BAAmB;AACjB,aAAO,KAAK,YAAL,KAAsB,gBAAgB,CAAC,qBAA9C;AACD;AAED;AACF;AACA;AACA;AACA;;;;WACE,wBAAe;AACb,aAAO,KAAK,YAAL,KAAsB,gBAAgB,CAAC,gBAA9C;AACD;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,YAAG,YAAH,EAAyB,QAAzB,EAA6C;AAC3C,UAAI,CAAC,QAAL,EAAe;AAEf,UAAM,iBAAiB,GAAG,YAAY,CAAC,KAAb,CAAmB,GAAnB,CAA1B;;AACA,WAAK,IAAI,CAAC,GAAG,CAAb,EAAgB,CAAC,GAAG,iBAAiB,CAAC,MAAtC,EAA8C,CAAC,EAA/C,EAAmD;AACjD,YAAM,aAAa,GAAG,iBAAiB,CAAC,CAAD,CAAjB,CAAqB,KAArB,CAA2B,GAA3B,CAAtB;AACA,YAAI,aAAa,CAAC,MAAd,KAAyB,CAA7B,EAAgC;AAEhC,YAAM,YAAY,GAAG,aAAa,CAAC,CAAD,CAAlC;AAEA,YAAI,UAAU,GAAG,IAAjB;;AACA,YAAI,aAAa,CAAC,MAAd,GAAuB,CAA3B,EAA8B;AAC5B,UAAA,UAAU,GAAG,YAAY,CAAC,OAAb,CAAqB,YAAY,GAAG,GAApC,EAAyC,EAAzC,CAAb;AACD;;AAED,aAAK,aAAL,CAAmB,IAAnB,CAAwB;AACtB,UAAA,YAAY,EAAE,YADQ;AAEtB,UAAA,UAAU,EAAE,UAFU;AAGtB,UAAA,QAAQ,EAAE;AAHY,SAAxB;AAMA,aAAK,MAAL,CAAY,IAAZ,EAAkB,YAAlB,kCAAyD,KAAK,aAAL,CAAmB,MAA5E,GAAsF,gBAAgB,CAAC,cAAvG;AACD;AACF;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,aAAI,YAAJ,EAA0B,QAA1B,EAA8C;AAAA;;AAC5C,UAAI,CAAC,QAAL,EAAe;AAEf,UAAM,iBAAiB,GAAG,YAAY,CAAC,KAAb,CAAmB,GAAnB,CAA1B;;AAH4C,iCAInC,CAJmC;AAK1C,YAAM,aAAa,GAAG,iBAAiB,CAAC,CAAD,CAAjB,CAAqB,KAArB,CAA2B,GAA3B,CAAtB;AACA,YAAI,aAAa,CAAC,MAAd,KAAyB,CAA7B,EAAgC;AAAA;AAAA;AAEhC,YAAM,YAAY,GAAG,aAAa,CAAC,CAAD,CAAlC;AAEA,YAAI,UAAU,GAAG,IAAjB;;AACA,YAAI,aAAa,CAAC,MAAd,GAAuB,CAA3B,EAA8B;AAC5B,UAAA,UAAU,GAAG,YAAY,CAAC,OAAb,CAAqB,YAAY,GAAG,GAApC,EAAyC,EAAzC,CAAb;AACD;;AAED,YAAM,WAAW,GAAG,KAAI,CAAC,aAAL,CAAmB,SAAnB,CAA6B,UAAC,GAAD;AAAA,iBAC/C,GAAG,CAAC,YAAJ,KAAqB,YAArB,IACA,GAAG,CAAC,UAAJ,KAAmB,UADnB,IAEA,GAAG,CAAC,QAAJ,KAAiB,QAH8B;AAAA,SAA7B,CAApB;;AAKA,YAAI,WAAW,KAAK,CAAC,CAArB,EAAwB;AACtB,UAAA,KAAI,CAAC,aAAL,CAAmB,MAAnB,CAA0B,WAA1B,EAAuC,CAAvC;;AACA,UAAA,KAAI,CAAC,MAAL,CAAY,KAAZ,EAAmB,YAAnB,oCAA4D,KAAI,CAAC,aAAL,CAAmB,MAA/E,GAAyF,gBAAgB,CAAC,cAA1G;AACD;AAvByC;;AAI5C,WAAK,IAAI,CAAC,GAAG,CAAb,EAAgB,CAAC,GAAG,iBAAiB,CAAC,MAAtC,EAA8C,CAAC,EAA/C,EAAmD;AAAA,yBAA1C,CAA0C;;AAAA;AAoBlD;AACF;AAED;AACF;AACA;AACA;AACA;;;;WACE,eAAM,YAAN,EAA4B;AAAA;;AAC1B,UAAM,iBAAiB,GAAG,YAAY,CAAC,KAAb,CAAmB,GAAnB,CAA1B;;AAD0B,mCAEjB,CAFiB;AAGxB,YAAM,aAAa,GAAG,iBAAiB,CAAC,CAAD,CAAjB,CAAqB,KAArB,CAA2B,GAA3B,CAAtB;AACA,YAAI,aAAa,CAAC,MAAd,KAAyB,CAA7B,EAAgC;AAAA;AAAA;AAEhC,YAAM,YAAY,GAAG,aAAa,CAAC,CAAD,CAAlC;AAEA,YAAI,UAAU,GAAG,IAAjB;;AACA,YAAI,aAAa,CAAC,MAAd,GAAuB,CAA3B,EAA8B;AAC5B,UAAA,UAAU,GAAG,YAAY,CAAC,OAAb,CAAqB,YAAY,GAAG,GAApC,EAAyC,EAAzC,CAAb;AACD;;AAED,QAAA,MAAI,CAAC,aAAL,GAAqB,MAAI,CAAC,aAAL,CAAmB,MAAnB,CAA0B,UAAC,GAAD;AAAA,iBAC7C,GAAG,CAAC,YAAJ,KAAqB,YAArB,IACA,GAAG,CAAC,UAAJ,KAAmB,UAF0B;AAAA,SAA1B,CAArB;AAbwB;;AAE1B,WAAK,IAAI,CAAC,GAAG,CAAb,EAAgB,CAAC,GAAG,iBAAiB,CAAC,MAAtC,EAA8C,CAAC,EAA/C,EAAmD;AAAA,2BAA1C,CAA0C;;AAAA;AAelD;AACF;AAED;AACF;AACA;AACA;AACA;AACA;AACA;;;;WACE,0BAAiB,YAAjB,EAAuC,UAAvC,EAA2D,KAA3D,EAAuE;AACrE,WAAK,MAAL,CAAY,YAAZ,EAA0B,UAA1B,EAAsC,KAAtC;;AACA,WAAK,IAAI,CAAC,GAAG,CAAb,EAAgB,CAAC,GAAG,KAAK,aAAL,CAAmB,MAAvC,EAA+C,CAAC,EAAhD,EAAoD;AAClD,YAAM,QAAQ,GAAG,KAAK,aAAL,CAAmB,CAAnB,CAAjB;AACA,YAAM,cAAc,GAAG,QAAQ,CAAC,YAAT,KAA0B,YAAjD;AACA,YAAM,qBAAqB,GAAG,CAAC,CAAC,QAAQ,CAAC,UAAzC;AACA,YAAI,gBAAgB,GAAG,KAAvB;;AACA,YAAI,UAAU,IAAI,QAAQ,CAAC,UAAvB,IACA,QAAQ,CAAC,UAAT,CAAoB,SAApB,CAA8B,QAAQ,CAAC,UAAT,CAAoB,MAApB,GAA6B,CAA3D,MACA,GAFJ,EAES;AACP,UAAA,gBAAgB,GAAG,UAAU,CAAC,OAAX,CAAmB,QAAQ,CAAC,UAAT,CAAoB,SAApB,CAA8B,CAA9B,EAClC,QAAQ,CAAC,UAAT,CAAoB,MAApB,GAA6B,CADK,CAAnB,MACsB,CADzC;AAED,SALD,MAKO;AACL,UAAA,gBAAgB,GAAG,QAAQ,CAAC,UAAT,KAAwB,UAA3C;AACD;;AAED,YAAI,cAAc,KAAK,CAAC,qBAAD,IAA0B,gBAA/B,CAAlB,EAAoE;AAClE,UAAA,QAAQ,CAAC,QAAT,CAAkB,UAAlB,EAA8B,KAA9B;AACD;AACF;AACF;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,yBAAgB,WAAhB,EAAqC,OAArC,EAAsD;AACpD,UAAI,CAAC,OAAL,EAAc;AACZ,QAAA,OAAO,GAAG,KAAK,yBAAL,CAA+B,WAA/B,CAAV;AACD;;AAED,WAAK,MAAL,CAAY,iBAAZ,EAA+B,IAA/B,EAAqC,WAAW,GAAG,IAAd,GAAqB,OAA1D,EACI,gBAAgB,CAAC,eADrB;AAGA,WAAK,aAAL,GAAqB,MAAM,CAAC,WAAD,CAA3B;AACD;AAED;AACF;AACA;AACA;AACA;;;;WACE,yBAAgB,OAAhB,EAAiC;AAC/B,UAAI,OAAO,KAAK,SAAZ,IAAyB,OAAO,KAAK,gBAAgB,CAAC,WAA1D,EAAuE;AACrE,aAAK,aAAL,GAAqB,CAArB;AACD;AACF;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,mBAAU,mBAAV,EAA+B;AAC7B,YAAM,IAAI,KAAJ,CACF,+CADE,CAAN;AAED;AAED;AACF;AACA;AACA;AACA;;;;WACE,+BAAsB,IAAtB,EAA4B,UAA5B,EAAwC;AAAA;;AACtC,UAAI,CAAC,KAAK,gBAAL,EAAL,EAA8B;AAC5B,QAAA,OAAO,CAAC,KAAR,CACI,4EADJ;AAEA;AACD;AAED;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;;;AACI,eAAS,WAAT,CAAqB,CAArB,EAAwB,CAAxB,EAA2B,SAA3B,EAAsC;AACpC,YAAM,OAAO,GAAG,CAAC,CAAC,KAAF,CAAQ,SAAR,CAAhB;AAEA,YAAI,OAAJ;;AACA,YAAI,OAAO,KAAK,IAAZ,IAAoB,CAAC,OAAO,GAAG,CAAC,CAAC,KAAF,CAAQ,SAAR,CAAX,MAAmC,IAA3D,EAAiE;AAC/D,cAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,CAAD,CAAR,CAApB;AACA,cAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,CAAD,CAAR,CAApB;;AACA,cAAI,KAAK,KAAK,KAAd,EAAqB;AACnB,gBAAI,OAAO,CAAC,CAAD,CAAP,KAAe,IAAnB,EAAyB;AACvB,qBAAO,CAAC,CAAR;AACD,aAFD,MAEO,IAAI,OAAO,CAAC,CAAD,CAAP,KAAe,MAAnB,EAA2B;AAChC,kBAAI,OAAO,CAAC,CAAD,CAAP,KAAe,IAAnB,EAAyB;AACvB,uBAAO,CAAP;AACD,eAFD,MAEO;AACL,uBAAO,CAAC,CAAR;AACD;AACF,aANM,MAMA;AACL,qBAAO,CAAP;AACD;AACF;;AACD,iBAAO,KAAK,GAAG,KAAf;AACD;;AAED,eAAO,IAAP;AACD;;AAED,UAAM,WAAW,GAAG,oCAApB;AACA,UAAM,WAAW,GAAG,kCAApB;AAEA,UAAM,MAAM,GAAG,MAAM,CAAC,IAAP,CAAY,IAAZ,EAAkB,GAAlB,CAAsB,UAAS,GAAT,EAAc;AACjD,eAAO,CAAC,MAAM,CAAC,GAAD,CAAP,EAAc,IAAI,CAAC,GAAD,CAAlB,CAAP;AACD,OAFc,CAAf,CA5CsC,CAgDtC;;AACA,MAAA,MAAM,CAAC,IAAP,CAAY,uBAAyB;AAAA;AAAA,YAAf,CAAe;AAAA,YAAZ,CAAY;;AAAA;AAAA,YAAP,CAAO;AAAA,YAAJ,CAAI;;AACnC,YAAI,IAAJ;;AACA,YAAI,CAAC,IAAI,GAAG,WAAW,CAAC,CAAD,EAAI,CAAJ,EAAO,WAAP,CAAnB,MAA4C,IAAhD,EAAsD;AACpD,iBAAO,IAAP;AACD;;AACD,YAAI,CAAC,IAAI,GAAG,WAAW,CAAC,CAAD,EAAI,CAAJ,EAAO,WAAP,CAAnB,MAA4C,IAAhD,EAAsD;AACpD,iBAAO,IAAP;AACD;;AAED,YAAI,CAAC,GAAG,CAAR,EAAW;AACT,iBAAO,CAAC,CAAR;AACD;;AACD,YAAI,CAAC,GAAG,CAAR,EAAW;AACT,iBAAO,CAAP;AACD;;AACD,eAAO,CAAP;AACD,OAhBD;AAkBA,UAAI,GAAJ;AACA,MAAA,MAAM,CAAC,OAAP,CAAe,UAAC,OAAD,EAAa;AAC1B,QAAA,GAAG,GAAG,EAAN;AACA,QAAA,GAAG,CAAC,OAAO,CAAC,CAAD,CAAR,CAAH,GAAkB,OAAO,CAAC,CAAD,CAAzB;;AACA,QAAA,MAAI,CAAC,YAAL,CAAkB,0BAAU,GAAV,CAAlB,EAAkC,UAAlC;AACD,OAJD;AAKD;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,sBAAa,IAAb,EAAmB,UAAnB,EAA+B;AAC7B,UAAI,CAAC,KAAK,gBAAL,EAAL,EAA8B;AAC5B,QAAA,OAAO,CAAC,KAAR,CACI,mEADJ;AAEA;AACD;;AAED,MAAA,UAAU,GAAG,UAAU,KAAK,SAAf,GAA2B,UAA3B,GAAwC,KAArD;AAEA,WAAK,YAAL,GAAoB,IAApB,CAT6B,CAW7B;;AACA,WAAK,IAAM,GAAX,IAAkB,IAAlB,EAAwB;AACtB,YAAI,GAAG,cAAH,CAAkB,IAAlB,CAAuB,IAAvB,EAA6B,GAA7B,KAAqC,IAAI,CAAC,GAAD,CAA7C,EAAoD;AAClD,cAAM,iBAAiB,GAAG,CAAC,UAAU,GAAG,UAAU,GAAG,GAAhB,GAAsB,EAAjC,IAAuC,GAAjE;AACA,cAAM,KAAK,GAAG,IAAI,CAAC,GAAD,CAAlB;;AAEA,cAAI,KAAK,CAAC,YAAD,CAAT,EAAyB;AACvB,iBAAK,IAAI,CAAC,GAAG,CAAb,EAAgB,CAAC,GAAG,KAAK,CAAC,YAAD,CAAL,CAAoB,MAAxC,EAAgD,CAAC,EAAjD,EAAqD;AACnD,mBAAK,YAAL,CAAkB,KAAK,CAAC,YAAD,CAAL,CAAoB,CAApB,CAAlB,EACI,iBAAiB,GAAG,GAApB,GAA0B,CAD9B;AAED;AACF,WALD,MAKO,IAAI,KAAK,CAAC,WAAN,KAAsB,MAA1B,EAAkC;AACvC,iBAAK,YAAL,CAAkB,KAAlB,EAAyB,iBAAzB;AACD,WAFM,MAEA;AACL,iBAAK,WAAL,CAAiB,iBAAjB,EAAoC,KAApC;AACD;AACF;AACF;AACF;AAED;AACF;AACA;AACA;AACA;;;;WACE,iCAAwB;AACtB,UAAM,GAAG,GAAG,KAAK,GAAjB,CADsB,CAEtB;AACA;;AACA,aAAO,IAAI,CAAC,SAAL,CAAe;AAAC,QAAA,GAAG,EAAH;AAAD,OAAf,CAAP;AACD;AAED;AACF;AACA;AACA;;;;WACE,iCAAwB;AACtB;AACA;AACA,aAAO,IAAI,CAAC,KAAL,CAAW,KAAK,qBAAL,EAAX,CAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,yBAAgB,gBAAhB,EAAkC;AAChC,YAAM,IAAI,KAAJ,CACF,+CADE,CAAN;AAED;AAED;AACF;AACA;AACA;AACA;AACA;AACA;;;;WACE,4BAAmB,GAAnB,EAAgC,MAAhC,EAA2D;AAAA,UAAnB,SAAmB,uEAAP,KAAO;AACzD,UAAM,GAAG,GAAG,IAAZ;;AACA,UAAM,OAAO,GAAG,SAAV,OAAU,CAAS,GAAT,EAAc,MAAd,EAAsB,QAAtB,EAAgC,WAAhC,EAA6C;AAC3D,YAAM,YAAY,GAAG;AACnB,oBAAU,gBAAgB,CAAC,WADR;AAEnB,uBAAa,WAAW,CAAC;AAFN,SAArB;AAKA,YAAI,MAAJ;;AACA,YAAI,CAAC,QAAQ,CAAC,gBAAd,EAAgC;AAC9B,cAAM,OAAO,GAAG,IAAI,cAAJ,EAAhB;AACA,UAAA,OAAO,CAAC,IAAR,CAAa,MAAb,EAAqB,GAArB,EAA0B,QAAQ,CAAC,WAAnC;;AACA,cAAI,QAAQ,CAAC,WAAb,EAA0B;AACxB,YAAA,OAAO,CAAC,MAAR,GAAiB,UAAS,CAAT,EAAY;AAC3B,kBAAI,OAAO,QAAQ,CAAC,eAAhB,KAAoC,UAAxC,EAAoD;AAClD,gBAAA,MAAM,GAAG,QAAQ,CAAC,eAAT,CAAyB,OAAzB,CAAT;AACD,eAFD,MAEO;AACL,gBAAA,MAAM,GAAG,IAAI,CAAC,KAAL,CAAW,OAAO,CAAC,YAAnB,CAAT;AACD;AACF,aAND;AAOD;;AACD,cAAI;AACF,gBAAI,MAAM,YAAY,KAAtB,EAA6B;AAC3B,cAAA,OAAO,CAAC,gBAAR,CAAyB,cAAzB,EACI,mCADJ;AAEA,cAAA,OAAO,CAAC,IAAR,CAAa,MAAM,CAAC,IAAP,CAAY,GAAZ,CAAb;AACD,aAJD,MAIO;AACL,cAAA,OAAO,CAAC,gBAAR,CAAyB,cAAzB,EACI,QAAQ,CAAC,qBADb;AAEA,cAAA,OAAO,CAAC,IAAR,CAAa,IAAI,CAAC,SAAL,CAAe,MAAf,CAAb;AACD;;AAED,gBAAI,CAAC,QAAQ,CAAC,WAAd,EAA2B;AACzB,kBAAI,OAAO,QAAQ,CAAC,eAAhB,KAAoC,UAAxC,EAAoD;AAClD,gBAAA,MAAM,GAAG,QAAQ,CAAC,eAAT,CAAyB,OAAzB,CAAT;AACD,eAFD,MAEO;AACL,gBAAA,MAAM,GAAG,IAAI,CAAC,KAAL,CAAW,OAAO,CAAC,YAAnB,CAAT;AACD;AACF,aAND,MAMO;AACL,cAAA,MAAM,GAAG,EAAT;AACA,cAAA,MAAM,CAAC,MAAP,GAAgB,gBAAgB,CAAC,UAAjC;AACA,cAAA,MAAM,CAAC,SAAP,GAAmB,CAAnB;AACA,cAAA,GAAG,CAAC,gBAAJ,CAAqB,eAArB;AACA,qBAAO,MAAP;AACD;AACF,WAxBD,CAwBE,OAAO,CAAP,EAAU;AACV,YAAA,OAAO,CAAC,KAAR,CAAc,CAAd;AACA,YAAA,GAAG,CAAC,gBAAJ,CAAqB,aAArB;AACA,mBAAO,YAAP;AACD;AACF,SAzCD,MAyCO;AACL,cAAI;AACF,gBAAM,OAAO,GAAG;AACd,cAAA,IAAI,EAAE,QAAQ,CAAC;AADD,aAAhB;AAGA,gBAAI,IAAJ;;AACA,gBAAI,MAAM,YAAY,KAAtB,EAA6B;AAC3B,cAAA,IAAI,GAAG,IAAI,IAAJ,CAAS,CAAC,MAAM,CAAC,IAAP,CAAY,GAAZ,CAAD,CAAT,EAA6B,OAA7B,CAAP;AACD,aAFD,MAEO;AACL,cAAA,IAAI,GAAG,IAAI,IAAJ,CAAS,CAAC,IAAI,CAAC,SAAL,CAAe,MAAf,CAAD,CAAT,EAAmC,OAAnC,CAAP;AACD;;AAED,YAAA,MAAM,GAAG,EAAT;;AACA,gBAAI,SAAS,CAAC,UAAV,CAAqB,GAArB,EAA0B,IAA1B,CAAJ,EAAqC;AACnC,cAAA,MAAM,CAAC,MAAP,GAAgB,gBAAgB,CAAC,UAAjC;AACA,cAAA,MAAM,CAAC,SAAP,GAAmB,CAAnB;AACD,aAHD,MAGO;AACL,cAAA,MAAM,CAAC,MAAP,GAAgB,gBAAgB,CAAC,WAAjC;AACA,cAAA,MAAM,CAAC,SAAP,GAAmB,GAAnB;AACD;AACF,WAnBD,CAmBE,OAAO,CAAP,EAAU;AACV,YAAA,OAAO,CAAC,KAAR,CAAc,CAAd;AACA,YAAA,GAAG,CAAC,gBAAJ,CAAqB,aAArB;AACA,mBAAO,YAAP;AACD;AACF;;AAED,YAAI,OAAO,MAAP,KAAkB,WAAtB,EAAmC;AACjC,UAAA,GAAG,CAAC,gBAAJ,CAAqB,aAArB;AACA,iBAAO,YAAP;AACD;;AAED,YAAI,MAAM,CAAC,MAAP,KAAkB,IAAlB,IACA,MAAM,CAAC,MAAP,KAAkB,gBAAgB,CAAC,UADvC,EACmD;AACjD,UAAA,GAAG,CAAC,gBAAJ,CAAqB,eAArB;AACD,SAHD,MAGO;AACL,UAAA,GAAG,CAAC,gBAAJ,CAAqB,aAArB;AACD;;AAED,eAAO,MAAP;AACD,OAxFD;;AA0FA,UAAI,OAAO,kBAAP,KAAoB,WAAxB,EAAqC;AACnC,YAAM,SAAS,GAAG,wBAAS,OAAT,EAAkB,GAAlB,CAAlB;AACA,QAAA,SAAS,CAAC,GAAD,EAAM,MAAN,EAAc,KAAK,QAAnB,EAA6B,KAAK,WAAlC,CAAT,CAFmC,CAInC;;AACA,YAAI,SAAJ,EAAe;AACb,UAAA,SAAS,CAAC,KAAV;AACD;;AAED,eAAO;AACL,UAAA,MAAM,EAAE,gBAAgB,CAAC,UADpB;AAEL,UAAA,SAAS,EAAE;AAFN,SAAP;AAID,OAbD,MAaO;AACL,eAAO,OAAO,CAAC,GAAD,EAAM,MAAN,EAAc,KAAK,QAAnB,EAA6B,KAAK,WAAlC,CAAd;AACD;AACF;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,wBAAe,IAAf,EAA6B,QAA7B,EAA+C;AAC7C,4CAAgB,IAAI,eAAJ,CAAoB,IAApB,EAA0B,IAA1B,EAAgC,QAAhC,CAAhB;;AACA,WAAK,MAAL,CAAY,gBAAZ,EAA8B,EAA9B,EAAkC,WAAlC,EACI,gBAAgB,CAAC,eADrB;AAED;AAED;AACF;AACA;;;;WACE,gCAAuB;AACrB,gCAAI,IAAJ,aAAmB;AACjB,8CAAc,MAAd;;AACA,8CAAgB,IAAhB;;AACA,aAAK,MAAL,CAAY,sBAAZ,EAAoC,EAApC,EAAwC,SAAxC,EACI,gBAAgB,CAAC,eADrB;AAED;AACF;;;;;AAGH;AACA;AACA;;;;;;;;;;;;;IACM,e;AAMJ;AACF;AACA;AACA;AACA;AACA;AACE,2BAAY,GAAZ,EAAsB,IAAtB,EAAoC,QAApC,EAAsD;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA,aAVzC;AAUyC;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AACpD,sCAAY,GAAZ;;AACA,2CAAgB,UAAU,CAAC,KAAK,OAAL,CAAa,IAAb,CAAkB,IAAlB,CAAD,EAA0B,IAA1B,CAA1B;;AACA,2CAAiB,QAAjB;AACD;AAED;AACF;AACA;;;;;WACE,kBAAS;AACP,8CAAkB,IAAlB;;AACA,gCAAI,IAAJ,cAAmB;AACjB,QAAA,YAAY,uBAAC,IAAD,aAAZ;AACD;AACF;AAED;AACF;AACA;;;;WACE,mBAAU;AACR,UAAI,uBAAC,IAAD,aAAJ,EAAsB;AACpB,0CAAU,MAAV,uBAAiB,IAAjB;AACD;AACF;;;;;;;;;;;;;;;;ACvuCH;;AACA;;AAOA;;AACA;;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,IAAM,iBAAiB,GAAG,0BAAa,OAAvC;AACA,IAAM,gBAAgB,GAAG,0BAAa,MAAtC;AACA,IAAM,mBAAmB,GAAG,wBAAW,OAAvC;AAEA;AACA;AACA;;IACqB,U;;;;;AACnB;AACF;AACA;AACA;AACE,sBAAY,QAAZ,EAA0B;AAAA;;AAAA;;AACxB,QAAM,aAAa,mCACd;AACD,MAAA,gBAAgB,EAAE;AADjB,KADc,GAGX,QAHW,CAAnB;;AAMA,8BAAM,mBAAN,EAA2B,aAA3B;AAEA,UAAK,GAAL,GAAW,IAAI,gBAAJ,EAAX;AACA,UAAK,GAAL,GAAW,IAAI,gBAAJ,EAAX,CAVwB,CAYxB;;AACA,UAAK,aAAL,GAAqB,MAAK,aAA1B;AACA,UAAK,SAAL,GAAiB,MAAK,SAAtB;AACA,UAAK,WAAL,GAAmB,MAAK,WAAxB;AACA,UAAK,WAAL,GAAmB,MAAK,WAAxB;AACA,UAAK,SAAL,GAAiB,MAAK,SAAtB;AACA,UAAK,eAAL,GAAuB,MAAK,eAA5B;AACA,UAAK,iBAAL,GAAyB,MAAK,iBAA9B;AACA,UAAK,gBAAL,GAAwB,MAAK,gBAA7B;AApBwB;AAqBzB;AAED;AACF;AACA;AACA;AACA;;;;;WACE,yBAAgB;AACd,WAAK,GAAL,CAAS,UAAT;AACA,aAAO,KAAK,UAAL,CAAgB,eAAhB,EAAiC,8BAAjC,EACH,0BADG,CAAP;AAED;AAED;AACF;AACA;AACA;AACA;;;;WACE,qBAAY;AACV,UAAM,MAAM,GAAG,KAAK,SAAL,CAAe,WAAf,EAA4B,IAA5B,CAAf;;AAEA,UAAI,MAAM,KAAK,gBAAgB,CAAC,UAAhC,EAA4C;AAC1C,YAAI,KAAK,GAAL,CAAS,KAAT,KAAmB,EAAvB,EAA2B;AACzB,cAAI,KAAK,GAAL,CAAS,KAAT,KAAmB,UAAvB,EAAmC;AACjC,iBAAK,gBAAL,CAAsB,cAAtB;AACD,WAFD,MAEO;AACL,iBAAK,gBAAL,CAAsB,kBAAtB;AACD;AACF,SAND,MAMO,IAAI,KAAK,QAAL,CAAc,YAAlB,EAAgC;AACrC,eAAK,gBAAL,CAAsB,cAAtB;AACD;AACF;;AAED,aAAO,MAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,qBAAY,UAAZ,EAAwB;AACtB,aAAO,KAAK,QAAL,CAAc,aAAd,EAA6B,KAA7B,EAAoC,UAApC,CAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;;;;WACE,qBAAY,UAAZ,EAAwB,KAAxB,EAA+B;AAC7B,aAAO,KAAK,QAAL,CAAc,aAAd,EAA6B,WAA7B,EAA0C,KAA1C,EAAiD,UAAjD,EAA6D,KAA7D,CAAP;AACD;AAED;AACF;AACA;AACA;AACA;;;;WACE,qBAAY;AACV,aAAO,KAAK,MAAL,CAAY,WAAZ,EAAyB,KAAzB,CAAP;AACD;AAED;AACF;AACA;AACA;AACA;;;;WACE,2BAAkB;AAChB,aAAO,KAAK,YAAL,CAAkB,iBAAlB,CAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,2BAAkB,YAAlB,EAAgC;AAC9B,aAAO,KAAK,cAAL,CAAoB,mBAApB,EAAyC,YAAzC,CAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,0BAAiB,YAAjB,EAA+B;AAC7B,aAAO,KAAK,aAAL,CAAmB,kBAAnB,EAAuC,YAAvC,CAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;;;;WACE,qBAAY,UAAZ,EAAwB,KAAxB,EAA+B;AAC7B,aAAO,KAAK,kBAAL,CAAwB,aAAxB,EAAuC,KAAvC,EAA8C,UAA9C,EAA0D,KAA1D,CAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,qBAAY,UAAZ,EAAwB;AACtB,aAAO,KAAK,kBAAL,CAAwB,aAAxB,EAAuC,KAAvC,EAA8C,UAA9C,CAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,yBAAgB,UAAhB,EAA4B,KAA5B,EAAmC,eAAnC,EAAoD;AAClD,UAAI,QAAJ;;AAEA,UAAI,KAAK,aAAL,CAAmB,UAAnB,EAA+B,yBAA/B,CAAJ,EAA+D;AAC7D,QAAA,QAAQ,GAAG,IAAI,gCAAJ,EAAX;AACD,OAFD,MAEO,IAAI,eAAe,IAAI,KAAK,aAAL,CAAmB,UAAnB,EAC1B,sDAD0B,CAAvB,EACsD;AAC3D,QAAA,QAAQ,GAAG,IAAI,kDAAJ,EAAX;AACD,OAHM,MAGA,IAAI,eAAe,IAAI,KAAK,aAAL,CAAmB,UAAnB,EAC1B,+CAD0B,CAAvB,EAC+C;AACpD,QAAA,QAAQ,GAAG,IAAI,4CAAJ,EAAX;AACD,OAHM,MAGA,IAAI,CAAC,eAAD,IACP,KAAK,aAAL,CAAmB,UAAnB,EAA+B,2BAA/B,CADG,EAC0D;AAC/D,QAAA,QAAQ,GAAG,IAAI,kCAAJ,EAAX;AACD;;AAED,aAAO,QAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;;;;WACE,iCAAwB,UAAxB,EAAoC,KAApC,EAA2C;AACzC,aAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;;;;WACE,mCAA0B,WAA1B,EAAuC,MAAvC,EAA+C;AAC7C,UAAI,YAAY,GAAG,UAAnB;AACA,UAAI,aAAa,GAAG,UAApB,CAF6C,CAI7C;;AACA,MAAA,WAAW,GAAG,MAAM,CAAC,WAAD,CAApB;;AACA,UAAI,iBAAiB,CAAC,kBAAlB,CAAqC,WAArC,CAAJ,EAAuD;AACrD,QAAA,YAAY,GAAG,iBAAiB,CAAC,kBAAlB,CAAqC,WAArC,EAAkD,YAAjE;AACA,QAAA,aAAa,GAAG,iBAAiB,CAAC,kBAAlB,CAAqC,WAArC,EAAkD,aAAlE;AACD;;AAED,aAAO,MAAM,GAAG,aAAH,GAAmB,YAAhC;AACD;AAED;AACF;AACA;AACA;AACA;;;;WACE,oCAA2B,MAA3B,EAAmC;AACjC;AACA,WAAK,GAAL,GAAW,MAAM,CAAC,GAAlB;AACD;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,yBAAgB,eAAhB,EAA0C;AACxC,UAAM,SAAS,GAAG,KAAK,qBAAL,EAAlB;;AAEA,UAAI,eAAJ,EAAqB;AACnB,QAAA,SAAS,CAAC,GAAV,CAAc,IAAd,CAAmB,UAAnB,GAAgC,KAAK,GAAL,CAAS,mBAAT,EAAhC;AACD;;AAED,UAAM,MAAM,GAAG,EAAf;AACA,UAAM,SAAS,GAAG,SAAS,CAAC,OAAV,CAAkB,SAAlB,CAAlB;;AACA,cAAQ,KAAK,QAAL,CAAc,gBAAtB;AACE,aAAK,WAAL;AACE,iBAAO,SAAS,CAAC,OAAV,CAAkB,SAAlB,CAAP;;AACF,aAAK,QAAL;AACE,eAAK,IAAM,IAAX,IAAmB,SAAnB,EAA8B;AAC5B,gBAAI,GAAG,cAAH,CAAkB,IAAlB,CAAuB,SAAvB,EAAkC,IAAlC,CAAJ,EAA6C;AAC3C,cAAA,MAAM,CAAC,IAAP,WAAe,IAAf,cAAuB,SAAS,CAAC,IAAD,CAAhC;AACD;AACF;;AACD,iBAAO,MAAP;;AACF,aAAK,MAAL;AACA;AACE,iBAAO,SAAP;AAZJ;AAcD;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,mBAAU,eAAV,EAAoC;AAClC,UAAI,eAAJ,EAAqB;AACnB,YAAM,cAAc,GAAG,KAAK,GAAL,CAAS,IAAT,CAAc,aAArC;;AACA,YAAI,cAAc,KAAK,eAAvB,EAAwC;AACtC,eAAK,GAAL,CAAS,IAAT,CAAc,aAAd,GAA8B,WAA9B;AACD;;AAED,YAAI,KAAK,GAAL,CAAS,IAAT,CAAc,WAAd,KAA8B,QAAlC,EAA4C;AAC1C,cAAI,KAAK,GAAL,CAAS,IAAT,CAAc,MAAd,KAAyB,QAA7B,EAAuC;AACrC,gBAAI,KAAK,QAAL,CAAc,gBAAd,IACA,KAAK,GAAL,CAAS,YAAT,CAAsB,aAAtB,KAAwC,EADxC,IAEA,KAAK,GAAL,CAAS,IAAT,CAAc,KAAd,CAAoB,GAApB,KAA4B,EAFhC,EAEoC;AAClC,kBAAI,UAAU,CAAC,KAAK,GAAL,CAAS,IAAT,CAAc,KAAd,CAAoB,GAArB,CAAV,IAAuC,UAAU,CAAC,KAAK,GAAL,CAAS,YAAT,CAAsB,aAAvB,CAArD,EAA4F;AAC1F,qBAAK,GAAL,CAAS,IAAT,CAAc,aAAd,GAA8B,QAA9B;AACD,eAFD,MAEO;AACL,qBAAK,GAAL,CAAS,IAAT,CAAc,aAAd,GAA8B,QAA9B;AACD;AACF;AACF;AACF,SAZD,MAYO,IAAI,KAAK,GAAL,CAAS,IAAT,CAAc,WAAd,KAA8B,QAAlC,EAA4C;AAAA;;AACjD,cAAI,CAAC,4BAAK,YAAL,mGAAmB,GAAnB,0GAAwB,IAAxB,kFAA8B,aAA9B,KAA+C,EAAhD,MAAwD,EAAxD,IAA8D,cAAc,KAAK,eAArF,EAAsG;AACpG,iBAAK,GAAL,CAAS,IAAT,CAAc,aAAd,GAA8B,SAA9B;AACD;AACF;AACF;;AAED,UAAM,YAAY,GAAG,KAAK,eAAL,CAAqB,eAAe,IACrD,KAAK,QAAL,CAAc,mBADG,CAArB;;AAGA,UAAI,KAAK,WAAL,KAAqB,gBAAgB,CAAC,eAA1C,EAA2D;AACzD,QAAA,OAAO,CAAC,KAAR,CAAc,0BAA0B,eAAe,GAAG,KAAH,GAAW,IAApD,IAA4D,KAA1E;AACA,QAAA,OAAO,CAAC,KAAR,CAAc,YAAd;AACD;;AACD,UAAI,KAAK,QAAL,CAAc,YAAlB,EAAgC;AAC9B,eAAO,KAAK,kBAAL,CAAwB,KAAK,QAAL,CAAc,YAAtC,EAAoD,YAApD,EAAkE,eAAlE,CAAP;AACD,OAFD,MAEO;AACL,eAAO,gBAAgB,CAAC,UAAxB;AACD;AACF;;;;EA9RqC,oB;;;;;;;;;;;;;;ACnBxC;;AACA;;AASA;;AACA;;AACA;;AACA;;AACA;;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,IAAM,mBAAmB,GAAG,0BAAa,SAAzC;AACA,IAAM,gBAAgB,GAAG,0BAAa,MAAtC;AACA,IAAM,qBAAqB,GAAG,wBAAW,SAAzC;AACA,IAAM,iBAAiB,GAAG,+BAAU,OAApC;AACA,IAAM,eAAe,GAAG,kBAAM,SAA9B;AAEA;AACA;AACA;;;;IACqB,Y;;;;;AAGnB;AACF;AACA;AACA;AACE,wBAAY,QAAZ,EAA0B;AAAA;;AAAA;;AACxB,QAAM,aAAa,mCACd;AACD,MAAA,gBAAgB,EAAE;AADjB,KADc,GAGX,QAHW,CAAnB;;AAMA,8BAAM,qBAAN,EAA6B,aAA7B;;AAPwB;AAAA;AAAA;AAAA;;AAAA,6EAyTD,UAAC,gBAAD,EAAmB,aAAnB,EAAkC,KAAlC,EAA4C;AACnE,UAAI,KAAK,GAAG,KAAZ;AACA,UAAM,KAAK,GAAG,gBAAgB,CAAC,MAA/B;;AACA,WAAK,IAAI,CAAC,GAAG,CAAb,EAAgB,CAAC,GAAG,KAAJ,IAAa,CAAC,KAA9B,EAAqC,CAAC,EAAtC,EAA0C;AACxC,YAAI,CAAC,KAAK,aAAN,IAAuB,gBAAgB,CAAC,UAAjB,CAA4B,CAA5B,MAAmC,KAA9D,EAAqE;AACnE,UAAA,KAAK,GAAG,IAAR;AACD;AACF;;AACD,aAAO,KAAP;AACD,KAlUyB;;AASxB,UAAK,GAAL,GAAW,IAAI,kBAAJ,EAAX;AACA,UAAK,GAAL,GAAW,IAAI,kBAAJ,EAAX,CAVwB,CAYxB;;AACA,UAAK,UAAL,GAAkB,MAAK,aAAvB;AACA,UAAK,SAAL,GAAiB,MAAK,YAAtB;AACA,UAAK,QAAL,GAAgB,MAAK,WAArB;AACA,UAAK,QAAL,GAAgB,MAAK,WAArB;AACA,UAAK,MAAL,GAAc,MAAK,SAAnB;AACA,UAAK,YAAL,GAAoB,MAAK,eAAzB;AACA,UAAK,cAAL,GAAsB,MAAK,iBAA3B;AACA,UAAK,aAAL,GAAqB,MAAK,gBAA1B;AApBwB;AAqBzB;AAED;AACF;AACA;AACA;;;;;SACE,eAAc;AACZ,mCAAO,IAAP;AACD;AAED;AACF;AACA;;;;WACE,yBAAgB;AACd,WAAK,GAAL,CAAS,UAAT;AACA,aAAO,KAAK,UAAL,CAAgB,YAAhB,CAAP;AACD;AAED;AACF;AACA;;;;WACE,wBAAe;AACb,UAAM,MAAM,GAAG,KAAK,SAAL,CAAe,WAAf,EAA4B,IAA5B,CAAf;;AAEA,UAAI,MAAM,KAAK,gBAAgB,CAAC,UAAhC,EAA4C;AAC1C,YAAI,KAAK,GAAL,CAAS,GAAT,CAAa,OAAb,KAAyB,QAA7B,EAAuC;AACrC,kBAAQ,KAAK,GAAL,CAAS,GAAT,CAAa,OAArB;AACE,iBAAK,UAAL;AACE,mBAAK,gBAAL,CAAsB,cAAtB;AACA;;AACF,iBAAK,UAAL;AACE,mBAAK,gBAAL,CAAsB,kBAAtB;AACA;;AACF,iBAAK,QAAL;AACE,mBAAK,gBAAL,CAAsB,gBAAtB;AACA;;AACF,iBAAK,MAAL;AACE,mBAAK,gBAAL,CAAsB,cAAtB;AACA;;AACF,iBAAK,SAAL;AACE,mBAAK,gBAAL,CAAsB,iBAAtB;AACA;;AACF,iBAAK,SAAL;AACE,mBAAK,gBAAL,CAAsB,iBAAtB;AACA;;AACF,iBAAK,YAAL;AACE,mBAAK,gBAAL,CAAsB,oBAAtB;AACA;AArBJ;AAuBD,SAxBD,MAwBO,IAAI,KAAK,QAAL,CAAc,YAAlB,EAAgC;AACrC,eAAK,gBAAL,CAAsB,cAAtB;AACD;AACF;;AAED,aAAO,MAAP;AACD;AAED;AACF;AACA;AACA;;;;WACE,qBAAY,UAAZ,EAAwB;AACtB,aAAO,KAAK,QAAL,CAAc,UAAd,EAA0B,IAA1B,EAAgC,UAAhC,CAAP;AACD;AAED;AACF;AACA;AACA;AACA;;;;WACE,qBAAY,UAAZ,EAAwB,KAAxB,EAA+B;AAC7B,aAAO,KAAK,QAAL,CAAc,UAAd,EAA0B,QAA1B,EAAoC,IAApC,EAA0C,UAA1C,EAAsD,KAAtD,CAAP;AACD;AAED;AACF;AACA;AACA;AACA;;;;WACE,qBAAY;AACV,aAAO,KAAK,MAAL,CAAY,QAAZ,CAAP;AACD;AAED;AACF;AACA;AACA;AACA;;;;WACE,2BAAkB;AAChB,aAAO,KAAK,YAAL,CAAkB,cAAlB,CAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,2BAAkB,YAAlB,EAAgC;AAC9B,aAAO,KAAK,cAAL,CAAoB,gBAApB,EAAsC,YAAtC,CAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,0BAAiB,YAAjB,EAA+B;AAC7B,aAAO,KAAK,aAAL,CAAmB,eAAnB,EAAoC,YAApC,CAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;;;;WACE,qBAAY,UAAZ,EAAwB,KAAxB,EAA+B;AAC7B,aAAO,KAAK,kBAAL,CAAwB,UAAxB,EAAoC,IAApC,EAA0C,UAA1C,EAAsD,KAAtD,CAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,yBAAgB,UAAhB,EAA4B,KAA5B,EAAmC,eAAnC,EAAoD;AAClD,UAAI,QAAJ;;AAEA,UAAI,KAAK,aAAL,CAAmB,UAAnB,EAA+B,yBAA/B,CAAJ,EAA+D;AAC7D,QAAA,QAAQ,GAAG,IAAI,kCAAJ,EAAX;AACD,OAFD,MAEO,IAAI,eAAe,IAAI,KAAK,aAAL,CAAmB,UAAnB,EAC1B,sDAD0B,CAAvB,EACsD;AAC3D,YAAM,KAAK,GAAG,UAAU,CAAC,KAAX,CAAiB,GAAjB,CAAd;AACA,YAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,CAAD,CAAN,CAApB;AACA,YAAM,WAAW,GAAG,KAAK,GAAL,CAAS,YAAT,CAAsB,UAAtB,CAAiC,KAAjC,CAApB;;AACA,YAAI,KAAK,aAAL,EAAJ,EAA0B;AACxB,cAAI,CAAC,WAAW,CAAC,IAAjB,EAAuB;AACrB,iBAAK,eAAL,CACI,qBAAqB,CAAC,0BAD1B;AAED,WAHD,MAGO;AACL,iBAAK,4BAAL,CAAkC,WAAlC,EAA+C,KAA/C;AAEA,gBAAM,aAAa,GAAG,iBAAiB,CAAC,WAAW,CAAC,IAAb,CAAvC;;AACA,gBAAI,aAAJ,EAAmB;AACjB,mBAAK,sBAAL,CAA4B,aAA5B,EAA2C,KAA3C,EAAkD,WAAW,CAAC,IAA9D;AACD,aAFD,MAEO;AACL,mBAAK,eAAL,CAAqB,qBAAqB,CAAC,mBAA3C,EACI,8BAA8B,WAAW,CAAC,IAD9C;AAED;AACF;AACF;;AACD,YAAI,KAAK,aAAL,KAAuB,CAA3B,EAA8B;AAC5B,UAAA,QAAQ,GAAG,IAAI,oDAAJ,EAAX;AACD;AACF,OAxBM,MAwBA,IAAI,eAAe,IAAI,KAAK,aAAL,CAAmB,UAAnB,EAC1B,+CAD0B,CAAvB,EAC+C;AACpD,QAAA,QAAQ,GAAG,IAAI,8CAAJ,EAAX;AACD,OAHM,MAGA,IAAI,CAAC,eAAD,IACP,KAAK,aAAL,CAAmB,UAAnB,EAA+B,2BAA/B,CADG,EAC0D;AAC/D,QAAA,QAAQ,GAAG,IAAI,oCAAJ,EAAX;AACD,OAHM,MAGA,IAAI,KAAK,aAAL,CAAmB,UAAnB,EACP,oCADO,CAAJ,EACoC;AACzC,QAAA,QAAQ,GAAG,IAAI,gCAAJ,EAAX;AACD,OAHM,MAGA,IAAI,KAAK,aAAL,CAAmB,UAAnB,EACP,gCADO,CAAJ,EACgC;AACrC,QAAA,QAAQ,GAAG,IAAI,gCAAJ,CAAsB,IAAtB,CAAX;AACD;;AAED,aAAO,QAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,gCAAuB,aAAvB,EAAsC,KAAtC,EAA6C,gBAA7C,EAA+D;AAC7D,UAAI,KAAK,GAAG,EAAZ;;AACA,UAAI,aAAJ,aAAI,aAAJ,eAAI,aAAa,CAAE,SAAnB,EAA8B;AAC5B,QAAA,KAAK,GAAG,MAAM,CAAC,KAAD,CAAN,CAAc,KAAd,CAAoB,aAAa,CAAC,SAAlC,CAAR;AACD,OAFD,MAEO;AACL,QAAA,KAAK,CAAC,CAAD,CAAL,GAAW,KAAX;AACD;;AAED,UAAI,KAAK,CAAC,MAAN,GAAe,CAAf,IAAoB,KAAK,CAAC,MAAN,IAAgB,aAAa,CAAC,GAAtD,EAA2D;AACzD,aAAK,yBAAL,CAA+B,gBAA/B,EAAiD,KAAjD,EAAwD,KAAxD;AACD,OAFD,MAEO,IAAI,KAAK,CAAC,MAAN,GAAe,aAAa,CAAC,GAAjC,EAAsC;AAC3C,aAAK,eAAL,CAAqB,qBAAqB,CAAC,mBAA3C,EACI,qCADJ;AAED;AACF;AAED;AACF;AACA;AACA;AACA;;;;WACE,sCAA6B,WAA7B,EAA0C,KAA1C,EAAiD;AAC/C,UAAM,iBAAiB,GAAG,WAAW,CAAC,iBAAZ,CAA8B,MAAxD;;AACA,UAAI,WAAW,CAAC,IAAZ,KAAqB,QAAzB,EAAmC;AACjC,aAAK,IAAI,CAAC,GAAG,CAAb,EAAgB,CAAC,GAAG,iBAAJ,IAAyB,KAAK,aAAL,KACzC,CADA,EACG,CAAC,EADJ,EACQ;AACN,cAAM,QAAQ,GAAG,WAAW,CAAC,iBAAZ,CAA8B,UAA9B,CAAyC,CAAzC,CAAjB;;AACA,cAAI,QAAQ,CAAC,OAAT,KAAqB,KAAzB,EAAgC;AAC9B,iBAAK,eAAL,CAAqB,qBAAqB,CAAC,mBAA3C;AACD;AACF;AACF;AACF;AAED;AACF;AACA;AACA;AACA;;;;WACE,iCAAwB,UAAxB,EAAoC,KAApC,EAA2C;AACzC,UAAM,KAAK,GAAG,UAAU,CAAC,KAAX,CAAiB,GAAjB,CAAd;AACA,UAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,CAAD,CAAN,CAApB;AACA,UAAM,aAAa,GAAG,MAAM,CAAC,KAAK,CAAC,CAAD,CAAN,CAA5B;AACA,UAAM,WAAW,GAAG,KAAK,GAAL,CAAS,YAAT,CAAsB,UAAtB,CAAiC,KAAjC,CAApB;AAEA,UAAM,iBAAiB,GAAG,WAAW,CAAC,iBAAZ,CAA8B,MAAxD;AACA,WAAK,4BAAL,CAAkC,WAAlC,EAA+C,KAA/C;AAEA,UAAM,aAAa,GAAG,iBAAiB,CAAC,WAAW,CAAC,IAAb,CAAvC;;AACA,UAAI,OAAO,aAAa,CAAC,KAArB,KAA+B,WAA/B,IAA8C,iBAAiB,IAC/D,aAAa,CAAC,KADlB,EACyB;AACvB,aAAK,sBAAL,CAA4B,aAA5B,EAA2C,KAA3C,EAAkD,WAAW,CAAC,IAA9D;;AAEA,YAAI,KAAK,aAAL,KAAuB,CAAvB,KACC,CAAC,aAAa,CAAC,SAAf,IACG,CAAC,KAAK,sBAAL,CAA4B,WAAW,CAAC,iBAAxC,EACG,aADH,EACkB,KADlB,CAFL,KAIC,KAAK,aAAL,KAAuB,CAAvB,IAA4B,KAAK,KAAK,EAJ3C,EAIgD,CAC9C;AACD,SAND,MAMO;AACL,cAAI,KAAK,aAAL,KAAuB,CAA3B,EAA8B;AAC5B,iBAAK,eAAL,CAAqB,qBAAqB,CAAC,mBAA3C,EACI,2CADJ;AAED;AACF;AACF,OAhBD,MAgBO;AACL,aAAK,eAAL,CAAqB,qBAAqB,CAAC,mBAA3C,EACI,6CADJ;AAED;AACF;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,qBAAY,UAAZ,EAAwB;AACtB,aAAO,KAAK,kBAAL,CAAwB,UAAxB,EAAoC,IAApC,EAA0C,UAA1C,CAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;;;;WACE,mCAA0B,WAA1B,EAAuC,MAAvC,EAA+C;AAC7C,UAAI,YAAY,GAAG,EAAnB;AACA,UAAI,aAAa,GAAG,EAApB,CAF6C,CAI7C;;AACA,MAAA,WAAW,GAAG,MAAM,CAAC,WAAD,CAApB;;AACA,UAAI,mBAAmB,CAAC,kBAApB,CAAuC,WAAvC,CAAJ,EAAyD;AACvD,QAAA,YAAY,GAAG,mBAAmB,CAAC,kBAApB,CAAuC,WAAvC,EAAoD,YAAnE;AACA,QAAA,aAAa,GAAG,mBAAmB,CAAC,kBAApB,CAAuC,WAAvC,EAAoD,aAApE;AACD;;AAED,aAAO,MAAM,GAAG,aAAH,GAAmB,YAAhC;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;;;;;AAYE;AACF;AACA;AACA;AACA;AACA;AACE,uCAA0B,gBAA1B,EAA4C,KAA5C,EAAmD,KAAnD,EAA0D;AACxD,UAAM,QAAQ,GAAG,iBAAiB,CAAC,gBAAD,CAAlC;AACA,UAAM,WAAW,GAAG,IAAI,MAAJ,CAAW,QAAQ,CAAC,MAApB,CAApB;;AACA,WAAK,IAAI,CAAC,GAAG,CAAb,EAAgB,CAAC,GAAG,KAAK,CAAC,MAAV,IAAoB,KAAK,aAAL,KAAuB,CAA3D,EAA8D,CAAC,EAA/D,EAAmE;AACjE,YAAI,gBAAgB,CAAC,KAAjB,CACA,0DADA,CAAJ,EACiE;AAC/D,UAAA,KAAK,CAAC,CAAD,CAAL,GAAW,KAAK,6BAAL,CAAmC,KAAK,CAAC,CAAD,CAAxC,CAAX;AACD;;AAED,YAAI,QAAJ,aAAI,QAAJ,eAAI,QAAQ,CAAE,UAAd,EAA0B;AACxB,cAAM,MAAM,GAAG,KAAK,CAAC,CAAD,CAAL,CAAS,KAAT,CAAe,QAAQ,CAAC,UAAxB,CAAf;;AACA,cAAI,MAAM,CAAC,MAAP,KAAkB,CAAtB,EAAyB;AACvB,gBAAM,OAAO,GAAG,MAAM,CAAC,CAAD,CAAN,CAAU,KAAV,CAAgB,WAAhB,CAAhB;;AACA,gBAAI,CAAC,OAAL,EAAc;AACZ,mBAAK,eAAL,CAAqB,qBAAqB,CAAC,aAA3C;AACD,aAFD,MAEO;AACL,kBAAI,CAAC,MAAM,CAAC,CAAD,CAAN,CAAU,KAAV,CAAgB,IAAI,MAAJ,CAAW,QAAQ,CAAC,OAApB,CAAhB,CAAL,EAAoD;AAClD,qBAAK,eAAL,CAAqB,qBAAqB,CAAC,aAA3C;AACD;AACF;AACF,WATD,MASO;AACL,iBAAK,eAAL,CAAqB,qBAAqB,CAAC,aAA3C;AACD;AACF,SAdD,MAcO;AACL,cAAM,QAAO,GAAG,KAAK,CAAC,CAAD,CAAL,CAAS,KAAT,CAAe,WAAf,CAAhB;;AACA,cAAK,CAAC,QAAD,IAAY,KAAK,KAAK,EAAvB,IACC,CAAC,QAAD,IAAY,gBAAgB,KAAK,YADtC,EACqD;AACnD,iBAAK,eAAL,CAAqB,qBAAqB,CAAC,aAA3C;AACD,WAHD,MAGO;AACL,gBAAI,gBAAgB,KAAK,SAArB,IAAkC,KAAK,CAAC,MAAN,GAAe,CAArD,EAAwD;AACtD,kBAAI,MAAM,CAAC,KAAK,CAAC,CAAD,CAAN,CAAN,GAAmB,MAAM,CAAC,KAAK,CAAC,CAAD,CAAN,CAA7B,EAAyC;AACvC,qBAAK,eAAL,CAAqB,qBAAqB,CAAC,aAA3C;AACD;AACF,aAJD,MAIO;AACL,kBAAI,KAAK,CAAC,CAAD,CAAL,KAAa,EAAb,IAAmB,QAAQ,CAAC,MAAhC,EAAwC;AACtC,qBAAK,IAAI,CAAC,GAAG,CAAb,EAAgB,CAAC,GAAG,CAAJ,IAAS,KAAK,aAAL,KAAuB,CAAhD,EAAmD,CAAC,EAApD,EAAwD;AACtD,sBAAI,KAAK,CAAC,CAAD,CAAL,KAAa,KAAK,CAAC,CAAD,CAAtB,EAA2B;AACzB,yBAAK,eAAL,CAAqB,qBAAqB,CAAC,aAA3C;AACD;AACF;AACF;AACF;AACF;AACF;AACF;AACF;AAED;AACF;AACA;AACA;AACA;;;;WACE,uCAA8B,IAA9B,EAAoC;AAClC,UAAI,SAAS,GAAG,KAAhB;AACA,UAAI,QAAQ,GAAG,KAAf;AACA,UAAI,QAAQ,GAAG,KAAf;AAEA,UAAM,WAAW,GAAG,IAAI,MAAJ,CAChB,gDADgB,CAApB;AAEA,UAAI,OAAO,GAAG,IAAI,CAAC,KAAL,CAAW,WAAX,CAAd;AACA,UAAI,WAAW,GAAG,IAAlB;;AACA,aAAO,OAAP,EAAgB;AACd,gBAAQ,OAAO,CAAC,CAAD,CAAf;AACE,eAAK,MAAL;AACE,YAAA,WAAW,GAAG,IAAI,CAAC,KAAL,CAAW,eAAe,CAAC,SAA3B,CAAd;;AACA,gBAAI,WAAJ,EAAiB;AACf,kBAAM,IAAI,GAAG,WAAW,CAAC,CAAD,CAAxB;;AACA,kBAAI,IAAI,KAAK,SAAT,IAAsB,IAAI,CAAC,MAAL,GAAc,CAAxC,EAA2C;AACzC,oBAAI,+BAAe,IAAI,CAAC,WAAL,EAAf,MAAuC,SAA3C,EAAsD;AACpD,uBAAK,eAAL,CAAqB,qBAAqB,CAAC,aAA3C;AACD;AACF;AACF;;AACD,YAAA,QAAQ,GAAG,IAAX;AACA;;AACF,eAAK,cAAL;AACE,gBAAI,CAAC,QAAD,IAAa,CAAC,SAAd,IAA2B,CAAC,QAAhC,EAA0C;AACxC,kBAAI,OAAO,CAAC,CAAD,CAAP,KAAe,MAAf,IAAyB,OAAO,CAAC,CAAD,CAAP,KAAe,OAA5C,EAAqD;AACnD,qBAAK,eAAL,CAAqB,qBAAqB,CAAC,aAA3C;AACD;AACF;;AAED,YAAA,QAAQ,GAAG,IAAX;AACA;;AACF,eAAK,eAAL;AACE,gBAAI,CAAC,QAAD,IAAa,CAAC,QAAd,IAA0B,CAAC,SAA/B,EAA0C;AACxC,kBAAI,OAAO,CAAC,CAAD,CAAP,KAAe,MAAf,IAAyB,OAAO,CAAC,CAAD,CAAP,KAAe,OAA5C,EAAqD;AACnD,qBAAK,eAAL,CAAqB,qBAAqB,CAAC,aAA3C;AACD;AACF;;AAED,YAAA,SAAS,GAAG,IAAZ;AACA;;AACF;AACE;AAhCJ;;AAkCA,QAAA,IAAI,GAAG,IAAI,CAAC,MAAL,CAAY,OAAO,CAAC,CAAD,CAAP,CAAW,MAAvB,CAAP;AACA,QAAA,OAAO,GAAG,IAAI,CAAC,KAAL,CAAW,WAAX,CAAV;AACD;;AAED,aAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;;;WACE,oCAA2B,MAA3B,EAAmC;AACjC;AACA,WAAK,GAAL,GAAW,MAAM,CAAC,GAAlB;AACA,WAAK,GAAL,GAAW,MAAM,CAAC,GAAlB;AACD;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,yBAAgB,eAAhB,EAA0C;AACxC,UAAM,SAAS,GAAG,KAAK,qBAAL,EAAlB;;AAEA,UAAI,eAAJ,EAAqB;AACnB,QAAA,SAAS,CAAC,GAAV,CAAc,UAAd,GAA2B,KAAK,GAAL,CAAS,mBAAT,EAA3B;AACD;;AAED,UAAM,MAAM,GAAG,EAAf;AACA,UAAM,SAAS,GAAG,SAAS,CAAC,OAAV,CAAkB,SAAlB,CAAlB;;AACA,cAAQ,KAAK,QAAL,CAAc,gBAAtB;AACE,aAAK,WAAL;AACE,iBAAO,SAAS,CAAC,OAAV,CAAkB,SAAlB,CAAP;;AACF,aAAK,QAAL;AACE,eAAK,IAAM,IAAX,IAAmB,SAAnB,EAA8B;AAC5B,gBAAI,GAAG,cAAH,CAAkB,IAAlB,CAAuB,SAAvB,EAAkC,IAAlC,CAAJ,EAA6C;AAC3C,cAAA,MAAM,CAAC,IAAP,WAAe,IAAf,cAAuB,SAAS,CAAC,IAAD,CAAhC;AACD;AACF;;AACD,iBAAO,MAAP;;AACF,aAAK,MAAL;AACA;AACE,iBAAO,SAAP;AAZJ;AAcD;AAED;AACF;AACA;AACA;AACA;AACA;;;;WACE,mBAAU,eAAV,EAAoC;AAAA;;AAClC,UAAI,eAAJ,EAAqB;AACnB,YAAI,KAAK,GAAL,CAAS,IAAT,KAAkB,QAAtB,EAAgC;AAC9B,cAAI,KAAK,GAAL,CAAS,MAAT,KAAoB,QAAxB,EAAkC;AAChC,gBAAI,KAAK,GAAL,CAAS,oBAAT,IAAiC,KAAK,GAAL,CAAS,gBAA9C,EAAgE;AAC9D,kBAAI,KAAK,GAAL,CAAS,gBAAT,IAA6B,KAAK,GAAL,CAAS,oBAA1C,EAAgE;AAC9D,gBAAA,OAAO,CAAC,KAAR,CAAc,sCAAd;AACA,qBAAK,GAAL,CAAS,iBAAT,GAA6B,WAA7B;AACD,eAHD,MAGO;AACL,gBAAA,OAAO,CAAC,KAAR,CAAc,uCAAd;AACA,qBAAK,GAAL,CAAS,iBAAT,GAA6B,YAA7B;AACD;AACF;;AACD,gBAAI,KAAK,GAAL,CAAS,oBAAT,IAAiC,KAAK,GAAL,CAAS,KAAT,CAAe,MAApD,EAA4D;AAC1D,kBAAI,KAAK,GAAL,CAAS,KAAT,CAAe,MAAf,IAAyB,KAAK,GAAL,CAAS,oBAAtC,EAA4D;AAC1D,gBAAA,OAAO,CAAC,KAAR,CAAc,gCAAd;AACA,qBAAK,GAAL,CAAS,cAAT,GAA0B,QAA1B;AACD,eAHD,MAGO;AACL,gBAAA,OAAO,CAAC,KAAR,CAAc,gCAAd;AACA,qBAAK,GAAL,CAAS,cAAT,GAA0B,QAA1B;AACD;AACF;AACF;AACF;AACF;;AAED,UAAI,UAAU,GAAG,KAAjB;;AACA,UAAI,KAAK,GAAL,CAAS,GAAT,CAAa,OAAb,4BAA0B,KAAK,YAA/B,gFAA0B,mBAAmB,GAA7C,oFAA0B,sBAAwB,GAAlD,2DAA0B,uBAA6B,OAAvD,KACA,KAAK,GAAL,CAAS,GAAT,CAAa,OAAb,KAAyB,QAD7B,EACuC;AACrC,aAAK,GAAL,CAAS,GAAT,CAAa,OAAb,GAAuB,kBAAkB,CAAC,KAAK,GAAL,CAAS,GAAT,CAAa,OAAd,CAAzC;AACA,QAAA,UAAU,GAAG,IAAb;AACD;;AAED,UAAM,YAAY,GAAG,KAAK,eAAL,CAAqB,eAAe,IACrD,KAAK,QAAL,CAAc,mBADG,CAArB;;AAGA,UAAI,KAAK,WAAL,KAAqB,gBAAgB,CAAC,eAA1C,EAA2D;AACzD,QAAA,OAAO,CAAC,KAAR,CAAc,0BACP,eAAe,GAAG,KAAH,GAAW,IADnB,IAC2B,KADzC;AAEA,QAAA,OAAO,CAAC,KAAR,CAAc,YAAd;AACD;;AACD,UAAI,KAAK,QAAL,CAAc,YAAlB,EAAgC;AAC9B,YAAM,MAAM,GAAG,KAAK,kBAAL,CAAwB,KAAK,QAAL,CAAc,YAAtC,EACX,YADW,EACG,eADH,CAAf,CAD8B,CAI9B;;AACA;AACE,cAAI,UAAU,IAAI,MAAM,CAAC,UAAP,KAAsB,SAApC,IACA,MAAM,CAAC,UAAP,KAAsB,EAD1B,EAC8B;AAC5B,YAAA,QAAQ,mCAA0B,MAAM,CAAC,UAAjC,WAAR;AACD;AACF;AACD,eAAO,MAAP;AACD,OAZD,MAYO;AACL,eAAO,gBAAgB,CAAC,UAAxB;AACD;AACF;;;;EA/hBuC,oB;;;;;;;;;;;;;;AC3B1C;;AACA;;AACA;;AACA;;AACA;;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,IAAM,cAAc,GAAG,0BAAa,IAApC;AACA,IAAM,UAAU,GAAG,kBAAM,IAAzB;AACA,IAAM,gBAAgB,GAAG,wBAAW,OAApC;AAEA;AACA;AACA;;AACA,SAAS,kBAAT,GAA8B;AAC5B,QAAM,IAAI,+BAAJ,CAAwB,gBAAgB,CAAC,iBAAzC,CAAN;AACD;AAED;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA,SAAS,oBAAT,CACI,KADJ,EAEI,YAFJ,EAGI,gBAHJ,EAGgC;AAC9B,SAAO,8BACH,KADG,EAEH,YAFG,EAGH,gBAAgB,CAAC,aAHd,EAIH,+BAJG,EAKH,gBALG,CAAP;AAOD;AAED;AACA;AACA;;;IACa,G;;;;;AACX;AACF;AACA;AACA;AACE,eAAY,WAAZ,EAAkC;AAAA;;AAAA;;AAChC,8BAAM,cAAc,CAAC,YAArB;AAEA,QAAI,WAAJ,EAAiB,MAAK,UAAL;AAEjB,UAAK,kBAAL,GAA0B,IAAI,sBAAJ,EAA1B;AACA,UAAK,YAAL,GAAoB,IAAI,kBAAJ,EAApB;AACA,UAAK,oBAAL,GAA4B,IAAI,sBAAJ,EAA5B;AACA,UAAK,UAAL,GAAkB,IAAI,aAAJ,EAAlB;AACA,UAAK,KAAL,GAAa,IAAI,QAAJ,EAAb;AATgC;AAUjC;AAED;AACF;AACA;;;;;WACE,sBAAa;AAAA;;AACX;;AACA,oCAAK,kBAAL,gFAAyB,UAAzB;AACA,iCAAK,YAAL,0EAAmB,UAAnB;AACA,oCAAK,oBAAL,gFAA2B,UAA3B;AACA,+BAAK,UAAL,sEAAiB,UAAjB;AACA,0BAAK,KAAL,4DAAY,UAAZ;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,kBAAS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,wBAAgB,KAAK,YADR;AAEb,uBAAe,KAAK,WAFP;AAGb,oBAAY,KAAK,QAHJ;AAIb,6BAAqB,KAAK,iBAJb;AAKb,gBAAQ,KAAK,IALA;AAMb,sBAAc,KAAK,UANN;AAOb,wBAAgB,KAAK,YAPR;AAQb,8BAAsB,KAAK,kBARd;AASb,gCAAwB,KAAK,oBAThB;AAUb,wBAAgB,KAAK,YAVR;AAWb,sBAAc,KAAK,UAXN;AAYb,iBAAS,KAAK;AAZD,OAAf;AAcA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;;EAjEsB,UAAU,CAAC,G;AAoEpC;AACA;AACA;;;;;IACM,a;;;;;AACJ;AACF;AACA;AACE,2BAAc;AAAA;;AAAA;;AACZ;AAEA,WAAK,QAAL,GAAgB,IAAI,qBAAJ,EAAhB;AAHY;AAIb;AAED;AACF;AACA;;;;;WACE,sBAAa;AAAA;;AACX;;AACA,6BAAK,QAAL,kEAAe,UAAf;AACD;AAED;AACF;AACA;AACA;;;;WACE,kBAAS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,oBAAY,KAAK;AADJ,OAAf;AAGA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;;EA7ByB,e;AAgC5B;AACA;AACA;;;IACM,qB;;;;;AACJ;AACF;AACA;AACE,mCAAc;AAAA;;AAAA,8BACN;AACJ,MAAA,QAAQ,EAAE,cAAc,CAAC,iBADrB;AAEJ,MAAA,SAAS,EAAE,gBAAgB,CAAC,iBAFxB;AAGJ,MAAA,UAAU,EAAE;AAHR,KADM;AAMb;;;EAViC,gB;AAapC;AACA;AACA;;;;;;;;;;;;;IACM,sB;;;;;AACJ;AACF;AACA;AACE,oCAAc;AAAA;;AAAA;;AACZ,gCAAM,cAAc,CAAC,2BAArB;;AADY;AAAA;AAAA,aAkBC;AAlBD;;AAAA;AAAA;AAAA,aAmBA;AAnBA;;AAAA;AAAA;AAAA,aAoBG;AApBH;;AAAA;AAAA;AAAA,aAqBD;AArBC;;AAAA;AAAA;AAAA,aAsBL;AAtBK;;AAGZ,WAAK,OAAL,GAAe,IAAI,gBAAJ,CAAa;AAC1B,MAAA,SAAS,EAAE,gBAAgB,CAAC,iBADF;AAE1B,MAAA,UAAU,EAAE,+BAFc;AAG1B,MAAA,QAAQ,EAAE;AAHgB,KAAb,CAAf;AAHY;AAQb;AAED;AACF;AACA;;;;;WACE,sBAAa;AAAA;;AACX;;AACA,4BAAK,OAAL,gEAAc,UAAd;AACD;;;;AAQD;AACF;AACA;AACA;AACE,mBAA0B;AACxB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAgB,WAAhB,EAAqC;AACnC,UAAI,oBAAoB,CAAC,WAAD,EAAc,UAAU,CAAC,YAAzB,CAAxB,EAAgE;AAC9D,kDAAoB,WAApB;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAAyB;AACvB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAe,UAAf,EAAmC;AACjC,UAAI,oBAAoB,CAAC,UAAD,EAAa,UAAU,CAAC,YAAxB,CAAxB,EAA+D;AAC7D,iDAAmB,UAAnB;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAA4B;AAC1B,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAkB,aAAlB,EAAyC;AACvC,UAAI,oBAAoB,CAAC,aAAD,EAAgB,UAAU,CAAC,YAA3B,CAAxB,EAAkE;AAChE,oDAAsB,aAAtB;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAAwB;AACtB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAc,SAAd,EAAiC;AAC/B,UAAI,oBAAoB,CAAC,SAAD,EAAY,UAAU,CAAC,YAAvB,CAAxB,EAA8D;AAC5D,gDAAkB,SAAlB;AACD;AACF;AAED;AACF;AACA;AACA;;;;SACE,eAAoB;AAClB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;SACE,aAAU,KAAV,EAAyB;AACvB,UAAI,oBAAoB,CAAC,KAAD,EAAQ,UAAU,CAAC,YAAnB,CAAxB,EAA0D;AACxD,4CAAc,KAAd;AACD;AACF;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,kBAAS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,iBAAS,KAAK,KADD;AAEb,oBAAY,KAAK,QAFJ;AAGb,uBAAe,KAAK,WAHP;AAIb,iBAAS,KAAK,KAJD;AAKb,gBAAQ,KAAK,IALA;AAMb,sBAAc,KAAK,UANN;AAOb,yBAAiB,KAAK,aAPT;AAQb,qBAAa,KAAK,SARL;AASb,iBAAS,KAAK,KATD;AAUb,mBAAW,KAAK;AAVH,OAAf;AAYA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;;EAlJkC,UAAU,CAAC,oB;AAqJhD;AACA;AACA;;;;;IACM,kB;;;;;AACJ;AACF;AACA;AACE,gCAAc;AAAA;;AAAA;;AACZ,gCAAM,cAAc,CAAC,qBAArB;;AADY;AAAA;AAAA,aAcS;AAdT;;AAGZ,WAAK,KAAL,GAAa,IAAI,QAAJ,EAAb;AAHY;AAIb;AAED;AACF;AACA;;;;;WACE,sBAAa;AAAA;;AACX;;AACA,0BAAK,KAAL,4DAAY,UAAZ;AACD;;;;AAID;AACF;AACA;AACA;AACE,mBAA0B;AACxB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAwB,mBAAxB,EAA6C;AAC3C,OAAC,KAAK,WAAN,yBACI,IADJ,wBACgC,mBADhC,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;WACE,kBAAS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,yBAAiB,KAAK,aADT;AAEb,4BAAoB,KAAK,gBAFZ;AAGb,6BAAqB,KAAK,iBAHb;AAIb,iBAAS,KAAK;AAJD,OAAf;AAMA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;;EA5D8B,UAAU,CAAC,c;AA+D5C;AACA;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IACa,sB;;;;;AACX;AACF;AACA;AACE,oCAAc;AAAA;;AAAA;;AACZ;;AADY;AAAA;AAAA,aAID,cAAc,CAAC;AAJd;;AAAA;AAAA;AAAA,aAKN;AALM;;AAAA;AAAA;AAAA,aAML;AANK;;AAAA;AAAA;AAAA,aAOH;AAPG;;AAAA;AAAA;AAAA,aAQH;AARG;;AAAA;AAAA;AAAA,aASA;AATA;;AAAA;AAAA;AAAA,aAUG;AAVH;;AAAA;AAAA;AAAA,aAWK;AAXL;;AAAA;AAAA;AAAA,aAYL;AAZK;;AAAA;AAAA;AAAA,aAaK;AAbL;;AAAA;AAAA;AAAA,aAcL;AAdK;;AAAA;AAAA;AAAA,aAeI;AAfJ;;AAAA;AAAA;AAAA,aAgBD;AAhBC;;AAAA;AAAA;AAAA,aAiBM;AAjBN;;AAAA;AAEb;;;;;AAiBD;AACF;AACA;AACA;AACE,mBAAgB;AACd,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;;;;SACE,eAAW;AACT,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAS,IAAT,EAAe;AACb,OAAC,KAAK,WAAN,yBACI,IADJ,SACiB,IADjB,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAY;AACV,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAU,KAAV,EAAiB;AACf,OAAC,KAAK,WAAN,yBACI,IADJ,UACkB,KADlB,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAc;AACZ,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAY,OAAZ,EAAqB;AACnB,OAAC,KAAK,WAAN,yBACI,IADJ,YACoB,OADpB,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAc;AACZ,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAY,OAAZ,EAAqB;AACnB,OAAC,KAAK,WAAN,yBACI,IADJ,YACoB,OADpB,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAiB;AACf,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAe,UAAf,EAA2B;AACzB,OAAC,KAAK,WAAN,yBACI,IADJ,eACuB,UADvB,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAoB;AAClB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAkB,aAAlB,EAAiC;AAC/B,OAAC,KAAK,WAAN,yBACI,IADJ,kBAC0B,aAD1B,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAsB;AACpB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAoB,eAApB,EAAqC;AACnC,OAAC,KAAK,WAAN,yBACI,IADJ,oBAC4B,eAD5B,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAY;AACV,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAU,KAAV,EAAiB;AACf,OAAC,KAAK,WAAN,yBACI,IADJ,UACkB,KADlB,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAsB;AACpB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAoB,eAApB,EAAqC;AACnC,OAAC,KAAK,WAAN,yBACI,IADJ,oBAC4B,eAD5B,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAY;AACV,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAU,KAAV,EAAiB;AACf,OAAC,KAAK,WAAN,yBACI,IADJ,UACkB,KADlB,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAqB;AACnB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAmB,cAAnB,EAAmC;AACjC,OAAC,KAAK,WAAN,yBACI,IADJ,mBAC2B,cAD3B,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAgB;AACd,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAc,SAAd,EAAyB;AACvB,OAAC,KAAK,WAAN,yBACI,IADJ,cACsB,SADtB,IAEI,kBAAkB,EAFtB;AAGD;AAED;AACF;AACA;AACA;;;;SACE,eAAuB;AACrB,mCAAO,IAAP;AACD;AAED;AACF;AACA;AACA;AACA;;SACE,aAAqB,gBAArB,EAAuC;AACrC,OAAC,KAAK,WAAN,yBACI,IADJ,qBAC6B,gBAD7B,IAEI,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","file":"generated.js","sourceRoot":"","sourcesContent":["(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()","/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the `TypeError` message for \"Functions\" methods. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n  return root.Date.now();\n};\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        result = wait - timeSinceLastCall;\n\n    return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && objectToString.call(value) == symbolTag);\n}\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = value.replace(reTrim, '');\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = debounce;\n","// @flow\nimport Scorm12API from './Scorm12API';\nimport {\n  CMI,\n  CMIAttemptRecordsObject,\n  CMIEvaluationCommentsObject,\n  CMITriesObject,\n} from './cmi/aicc_cmi';\nimport {NAV} from './cmi/scorm12_cmi';\n\n/**\n * The AICC API class\n */\nexport default class AICC extends Scorm12API {\n  /**\n   * Constructor to create AICC API object\n   * @param {object} settings\n   */\n  constructor(settings: {}) {\n    const finalSettings = {\n      ...{\n        mastery_override: false,\n      }, ...settings,\n    };\n\n    super(finalSettings);\n\n    this.cmi = new CMI();\n    this.nav = new NAV();\n  }\n\n  /**\n   * Gets or builds a new child element to add to the array.\n   *\n   * @param {string} CMIElement\n   * @param {any} value\n   * @param {boolean} foundFirstIndex\n   * @return {object}\n   */\n  getChildElement(CMIElement, value, foundFirstIndex) {\n    let newChild = super.getChildElement(CMIElement, value, foundFirstIndex);\n\n    if (!newChild) {\n      if (this.stringMatches(CMIElement, 'cmi\\\\.evaluation\\\\.comments\\\\.\\\\d+')) {\n        newChild = new CMIEvaluationCommentsObject();\n      } else if (this.stringMatches(CMIElement,\n          'cmi\\\\.student_data\\\\.tries\\\\.\\\\d+')) {\n        newChild = new CMITriesObject();\n      } else if (this.stringMatches(CMIElement,\n          'cmi\\\\.student_data\\\\.attempt_records\\\\.\\\\d+')) {\n        newChild = new CMIAttemptRecordsObject();\n      }\n    }\n\n    return newChild;\n  }\n\n  /**\n   * Replace the whole API with another\n   *\n   * @param {AICC} newAPI\n   */\n  replaceWithAnotherScormAPI(newAPI) {\n    // Data Model\n    this.cmi = newAPI.cmi;\n    this.nav = newAPI.nav;\n  }\n}\n","// @flow\nimport {CMIArray} from './cmi/common';\nimport {ValidationError} from './exceptions';\nimport ErrorCodes from './constants/error_codes';\nimport APIConstants from './constants/api_constants';\nimport {unflatten} from './utilities';\nimport debounce from 'lodash.debounce';\n\nconst global_constants = APIConstants.global;\nconst scorm12_error_codes = ErrorCodes.scorm12;\n\n/**\n * Base API class for AICC, SCORM 1.2, and SCORM 2004. Should be considered\n * abstract, and never initialized on it's own.\n */\nexport default class BaseAPI {\n  #timeout;\n  #error_codes;\n  #settings = {\n    autocommit: false,\n    autocommitSeconds: 10,\n    asyncCommit: false,\n    sendBeaconCommit: false,\n    lmsCommitUrl: false,\n    dataCommitFormat: 'json', // valid formats are 'json' or 'flattened', 'params'\n    commitRequestDataType: 'application/json;charset=UTF-8',\n    autoProgress: false,\n    logLevel: global_constants.LOG_LEVEL_ERROR,\n    selfReportSessionTime: false,\n    alwaysSendTotalTime: false,\n    strict_errors: true,\n    responseHandler: function(xhr) {\n      let result;\n      if (typeof xhr !== 'undefined') {\n        result = JSON.parse(xhr.responseText);\n        if (result === null || !{}.hasOwnProperty.call(result, 'result')) {\n          result = {};\n          if (xhr.status === 200) {\n            result.result = global_constants.SCORM_TRUE;\n            result.errorCode = 0;\n          } else {\n            result.result = global_constants.SCORM_FALSE;\n            result.errorCode = 101;\n          }\n        }\n      }\n      return result;\n    },\n  };\n  cmi;\n  startingData: {};\n\n  /**\n   * Constructor for Base API class. Sets some shared API fields, as well as\n   * sets up options for the API.\n   * @param {object} error_codes\n   * @param {object} settings\n   */\n  constructor(error_codes, settings) {\n    if (new.target === BaseAPI) {\n      throw new TypeError('Cannot construct BaseAPI instances directly');\n    }\n    this.currentState = global_constants.STATE_NOT_INITIALIZED;\n    this.lastErrorCode = 0;\n    this.listenerArray = [];\n\n    this.#timeout = null;\n    this.#error_codes = error_codes;\n\n    this.settings = settings;\n    this.apiLogLevel = this.settings.logLevel;\n    this.selfReportSessionTime = this.settings.selfReportSessionTime;\n  }\n\n  /**\n   * Initialize the API\n   * @param {string} callbackName\n   * @param {string} initializeMessage\n   * @param {string} terminationMessage\n   * @return {string}\n   */\n  initialize(\n      callbackName: String,\n      initializeMessage?: String,\n      terminationMessage?: String) {\n    let returnValue = global_constants.SCORM_FALSE;\n\n    if (this.isInitialized()) {\n      this.throwSCORMError(this.#error_codes.INITIALIZED, initializeMessage);\n    } else if (this.isTerminated()) {\n      this.throwSCORMError(this.#error_codes.TERMINATED, terminationMessage);\n    } else {\n      if (this.selfReportSessionTime) {\n        this.cmi.setStartTime();\n      }\n\n      this.currentState = global_constants.STATE_INITIALIZED;\n      this.lastErrorCode = 0;\n      returnValue = global_constants.SCORM_TRUE;\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n    this.clearSCORMError(returnValue);\n\n    return returnValue;\n  }\n\n  /**\n   * Getter for #error_codes\n   * @return {object}\n   */\n  get error_codes() {\n    return this.#error_codes;\n  }\n\n  /**\n   * Getter for #settings\n   * @return {object}\n   */\n  get settings() {\n    return this.#settings;\n  }\n\n  /**\n   * Setter for #settings\n   * @param {object} settings\n   */\n  set settings(settings: Object) {\n    this.#settings = {...this.#settings, ...settings};\n  }\n\n  /**\n   * Terminates the current run of the API\n   * @param {string} callbackName\n   * @param {boolean} checkTerminated\n   * @return {string}\n   */\n  terminate(\n      callbackName: String,\n      checkTerminated: boolean) {\n    let returnValue = global_constants.SCORM_FALSE;\n\n    if (this.checkState(checkTerminated,\n        this.#error_codes.TERMINATION_BEFORE_INIT,\n        this.#error_codes.MULTIPLE_TERMINATION)) {\n      this.currentState = global_constants.STATE_TERMINATED;\n\n      const result = this.storeData(true);\n      if (!this.settings.sendBeaconCommit && !this.settings.asyncCommit &&\n          typeof result.errorCode !== 'undefined' && result.errorCode > 0) {\n        this.throwSCORMError(result.errorCode);\n      }\n      returnValue = (typeof result !== 'undefined' && result.result) ?\n          result.result : global_constants.SCORM_FALSE;\n\n      if (checkTerminated) this.lastErrorCode = 0;\n\n      returnValue = global_constants.SCORM_TRUE;\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n    this.clearSCORMError(returnValue);\n\n    return returnValue;\n  }\n\n  /**\n   * Get the value of the CMIElement.\n   *\n   * @param {string} callbackName\n   * @param {boolean} checkTerminated\n   * @param {string} CMIElement\n   * @return {string}\n   */\n  getValue(\n      callbackName: String,\n      checkTerminated: boolean,\n      CMIElement: String) {\n    let returnValue;\n\n    if (this.checkState(checkTerminated,\n        this.#error_codes.RETRIEVE_BEFORE_INIT,\n        this.#error_codes.RETRIEVE_AFTER_TERM)) {\n      if (checkTerminated) this.lastErrorCode = 0;\n      try {\n        returnValue = this.getCMIValue(CMIElement);\n      } catch (e) {\n        if (e instanceof ValidationError) {\n          this.lastErrorCode = e.errorCode;\n          returnValue = global_constants.SCORM_FALSE;\n        } else {\n          if (e.message) {\n            console.error(e.message);\n          } else {\n            console.error(e);\n          }\n          this.throwSCORMError(this.#error_codes.GENERAL);\n        }\n      }\n      this.processListeners(callbackName, CMIElement);\n    }\n\n    this.apiLog(callbackName, CMIElement, ': returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n    this.clearSCORMError(returnValue);\n\n    return returnValue;\n  }\n\n  /**\n   * Sets the value of the CMIElement.\n   *\n   * @param {string} callbackName\n   * @param {string} commitCallback\n   * @param {boolean} checkTerminated\n   * @param {string} CMIElement\n   * @param {*} value\n   * @return {string}\n   */\n  setValue(\n      callbackName: String,\n      commitCallback: String,\n      checkTerminated: boolean,\n      CMIElement,\n      value) {\n    if (value !== undefined) {\n      value = String(value);\n    }\n    let returnValue = global_constants.SCORM_FALSE;\n\n    if (this.checkState(checkTerminated, this.#error_codes.STORE_BEFORE_INIT,\n        this.#error_codes.STORE_AFTER_TERM)) {\n      if (checkTerminated) this.lastErrorCode = 0;\n      try {\n        returnValue = this.setCMIValue(CMIElement, value);\n      } catch (e) {\n        if (e instanceof ValidationError) {\n          this.lastErrorCode = e.errorCode;\n          returnValue = global_constants.SCORM_FALSE;\n        } else {\n          if (e.message) {\n            console.error(e.message);\n          } else {\n            console.error(e);\n          }\n          this.throwSCORMError(this.#error_codes.GENERAL);\n        }\n      }\n      this.processListeners(callbackName, CMIElement, value);\n    }\n\n    if (returnValue === undefined) {\n      returnValue = global_constants.SCORM_FALSE;\n    }\n\n    // If we didn't have any errors while setting the data, go ahead and\n    // schedule a commit, if autocommit is turned on\n    if (String(this.lastErrorCode) === '0') {\n      if (this.settings.autocommit && !this.#timeout) {\n        this.scheduleCommit(this.settings.autocommitSeconds * 1000, commitCallback);\n      }\n    }\n\n    this.apiLog(callbackName, CMIElement,\n        ': ' + value + ': result: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n    this.clearSCORMError(returnValue);\n\n    return returnValue;\n  }\n\n  /**\n   * Orders LMS to store all content parameters\n   * @param {string} callbackName\n   * @param {boolean} checkTerminated\n   * @return {string}\n   */\n  commit(\n      callbackName: String,\n      checkTerminated: boolean) {\n    this.clearScheduledCommit();\n\n    let returnValue = global_constants.SCORM_FALSE;\n\n    if (this.checkState(checkTerminated, this.#error_codes.COMMIT_BEFORE_INIT,\n        this.#error_codes.COMMIT_AFTER_TERM)) {\n      const result = this.storeData(false);\n      if (!this.settings.sendBeaconCommit && !this.settings.asyncCommit &&\n          result.errorCode && result.errorCode > 0) {\n        this.throwSCORMError(result.errorCode);\n      }\n      returnValue = (typeof result !== 'undefined' && result.result) ?\n          result.result : global_constants.SCORM_FALSE;\n\n      this.apiLog(callbackName, 'HttpRequest', ' Result: ' + returnValue,\n          global_constants.LOG_LEVEL_DEBUG);\n\n      if (checkTerminated) this.lastErrorCode = 0;\n\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n    this.clearSCORMError(returnValue);\n\n    return returnValue;\n  }\n\n  /**\n   * Returns last error code\n   * @param {string} callbackName\n   * @return {string}\n   */\n  getLastError(callbackName: String) {\n    const returnValue = String(this.lastErrorCode);\n\n    this.processListeners(callbackName);\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n\n    return returnValue;\n  }\n\n  /**\n   * Returns the errorNumber error description\n   *\n   * @param {string} callbackName\n   * @param {(string|number)} CMIErrorCode\n   * @return {string}\n   */\n  getErrorString(callbackName: String, CMIErrorCode) {\n    let returnValue = '';\n\n    if (CMIErrorCode !== null && CMIErrorCode !== '') {\n      returnValue = this.getLmsErrorMessageDetails(CMIErrorCode);\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n\n    return returnValue;\n  }\n\n  /**\n   * Returns a comprehensive description of the errorNumber error.\n   *\n   * @param {string} callbackName\n   * @param {(string|number)} CMIErrorCode\n   * @return {string}\n   */\n  getDiagnostic(callbackName: String, CMIErrorCode) {\n    let returnValue = '';\n\n    if (CMIErrorCode !== null && CMIErrorCode !== '') {\n      returnValue = this.getLmsErrorMessageDetails(CMIErrorCode, true);\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n\n    return returnValue;\n  }\n\n  /**\n   * Checks the LMS state and ensures it has been initialized.\n   *\n   * @param {boolean} checkTerminated\n   * @param {number} beforeInitError\n   * @param {number} afterTermError\n   * @return {boolean}\n   */\n  checkState(\n      checkTerminated: boolean,\n      beforeInitError: number,\n      afterTermError?: number) {\n    if (this.isNotInitialized()) {\n      this.throwSCORMError(beforeInitError);\n      return false;\n    } else if (checkTerminated && this.isTerminated()) {\n      this.throwSCORMError(afterTermError);\n      return false;\n    }\n\n    return true;\n  }\n\n  /**\n   * Logging for all SCORM actions\n   *\n   * @param {string} functionName\n   * @param {string} CMIElement\n   * @param {string} logMessage\n   * @param {number}messageLevel\n   */\n  apiLog(\n      functionName: String,\n      CMIElement: String,\n      logMessage: String,\n      messageLevel: number) {\n    logMessage = this.formatMessage(functionName, CMIElement, logMessage);\n\n    if (messageLevel >= this.apiLogLevel) {\n      switch (messageLevel) {\n        case global_constants.LOG_LEVEL_ERROR:\n          console.error(logMessage);\n          break;\n        case global_constants.LOG_LEVEL_WARNING:\n          console.warn(logMessage);\n          break;\n        case global_constants.LOG_LEVEL_INFO:\n          console.info(logMessage);\n          break;\n        case global_constants.LOG_LEVEL_DEBUG:\n          if (console.debug) {\n            console.debug(logMessage);\n          } else {\n            console.log(logMessage);\n          }\n          break;\n      }\n    }\n  }\n\n  /**\n   * Formats the SCORM messages for easy reading\n   *\n   * @param {string} functionName\n   * @param {string} CMIElement\n   * @param {string} message\n   * @return {string}\n   */\n  formatMessage(functionName: String, CMIElement: String, message: String) {\n    const baseLength = 20;\n    let messageString = '';\n\n    messageString += functionName;\n\n    let fillChars = baseLength - messageString.length;\n\n    for (let i = 0; i < fillChars; i++) {\n      messageString += ' ';\n    }\n\n    messageString += ': ';\n\n    if (CMIElement) {\n      const CMIElementBaseLength = 70;\n\n      messageString += CMIElement;\n\n      fillChars = CMIElementBaseLength - messageString.length;\n\n      for (let j = 0; j < fillChars; j++) {\n        messageString += ' ';\n      }\n    }\n\n    if (message) {\n      messageString += message;\n    }\n\n    return messageString;\n  }\n\n  /**\n   * Checks to see if {str} contains {tester}\n   *\n   * @param {string} str String to check against\n   * @param {string} tester String to check for\n   * @return {boolean}\n   */\n  stringMatches(str: String, tester: String) {\n    return str && tester && str.match(tester);\n  }\n\n  /**\n   * Check to see if the specific object has the given property\n   * @param {*} refObject\n   * @param {string} attribute\n   * @return {boolean}\n   * @private\n   */\n  _checkObjectHasProperty(refObject, attribute: String) {\n    return Object.hasOwnProperty.call(refObject, attribute) ||\n        Object.getOwnPropertyDescriptor(\n            Object.getPrototypeOf(refObject), attribute) ||\n        (attribute in refObject);\n  }\n\n  /**\n   * Returns the message that corresponds to errorNumber\n   * APIs that inherit BaseAPI should override this function\n   *\n   * @param {(string|number)} _errorNumber\n   * @param {boolean} _detail\n   * @return {string}\n   * @abstract\n   */\n  getLmsErrorMessageDetails(_errorNumber, _detail) {\n    throw new Error(\n        'The getLmsErrorMessageDetails method has not been implemented');\n  }\n\n  /**\n   * Gets the value for the specific element.\n   * APIs that inherit BaseAPI should override this function\n   *\n   * @param {string} _CMIElement\n   * @return {string}\n   * @abstract\n   */\n  getCMIValue(_CMIElement) {\n    throw new Error('The getCMIValue method has not been implemented');\n  }\n\n  /**\n   * Sets the value for the specific element.\n   * APIs that inherit BaseAPI should override this function\n   *\n   * @param {string} _CMIElement\n   * @param {any} _value\n   * @return {string}\n   * @abstract\n   */\n  setCMIValue(_CMIElement, _value) {\n    throw new Error('The setCMIValue method has not been implemented');\n  }\n\n  /**\n   * Shared API method to set a valid for a given element.\n   *\n   * @param {string} methodName\n   * @param {boolean} scorm2004\n   * @param {string} CMIElement\n   * @param {*} value\n   * @return {string}\n   */\n  _commonSetCMIValue(\n      methodName: String, scorm2004: boolean, CMIElement, value) {\n    if (!CMIElement || CMIElement === '') {\n      return global_constants.SCORM_FALSE;\n    }\n\n    const structure = CMIElement.split('.');\n    let refObject = this;\n    let returnValue = global_constants.SCORM_FALSE;\n    let foundFirstIndex = false;\n\n    const invalidErrorMessage = `The data model element passed to ${methodName} (${CMIElement}) is not a valid SCORM data model element.`;\n    const invalidErrorCode = scorm2004 ?\n        this.#error_codes.UNDEFINED_DATA_MODEL :\n        this.#error_codes.GENERAL;\n\n    for (let i = 0; i < structure.length; i++) {\n      const attribute = structure[i];\n\n      if (i === structure.length - 1) {\n        if (scorm2004 && (attribute.substr(0, 8) === '{target=') &&\n            (typeof refObject._isTargetValid == 'function')) {\n          this.throwSCORMError(this.#error_codes.READ_ONLY_ELEMENT);\n        } else if (!this._checkObjectHasProperty(refObject, attribute)) {\n          this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n        } else {\n          if (this.isInitialized() &&\n              this.stringMatches(CMIElement, '\\\\.correct_responses\\\\.\\\\d+')) {\n            this.validateCorrectResponse(CMIElement, value);\n          }\n\n          if (!scorm2004 || this.lastErrorCode === 0) {\n            refObject[attribute] = value;\n            returnValue = global_constants.SCORM_TRUE;\n          }\n        }\n      } else {\n        refObject = refObject[attribute];\n        if (!refObject) {\n          this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n          break;\n        }\n\n        if (refObject instanceof CMIArray) {\n          const index = parseInt(structure[i + 1], 10);\n\n          // SCO is trying to set an item on an array\n          if (!isNaN(index)) {\n            const item = refObject.childArray[index];\n\n            if (item) {\n              refObject = item;\n              foundFirstIndex = true;\n            } else {\n              const newChild = this.getChildElement(CMIElement, value,\n                  foundFirstIndex);\n              foundFirstIndex = true;\n\n              if (!newChild) {\n                this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n              } else {\n                if (refObject.initialized) newChild.initialize();\n\n                refObject.childArray.push(newChild);\n                refObject = newChild;\n              }\n            }\n\n            // Have to update i value to skip the array position\n            i++;\n          }\n        }\n      }\n    }\n\n    if (returnValue === global_constants.SCORM_FALSE) {\n      this.apiLog(methodName, null,\n          `There was an error setting the value for: ${CMIElement}, value of: ${value}`,\n          global_constants.LOG_LEVEL_WARNING);\n    }\n\n    return returnValue;\n  }\n\n  /**\n   * Abstract method for validating that a response is correct.\n   *\n   * @param {string} _CMIElement\n   * @param {*} _value\n   */\n  validateCorrectResponse(_CMIElement, _value) {\n    // just a stub method\n  }\n\n  /**\n   * Gets or builds a new child element to add to the array.\n   * APIs that inherit BaseAPI should override this method.\n   *\n   * @param {string} _CMIElement - unused\n   * @param {*} _value - unused\n   * @param {boolean} _foundFirstIndex - unused\n   * @return {*}\n   * @abstract\n   */\n  getChildElement(_CMIElement, _value, _foundFirstIndex) {\n    throw new Error('The getChildElement method has not been implemented');\n  }\n\n  /**\n   * Gets a value from the CMI Object\n   *\n   * @param {string} methodName\n   * @param {boolean} scorm2004\n   * @param {string} CMIElement\n   * @return {*}\n   */\n  _commonGetCMIValue(methodName: String, scorm2004: boolean, CMIElement) {\n    if (!CMIElement || CMIElement === '') {\n      return '';\n    }\n\n    const structure = CMIElement.split('.');\n    let refObject = this;\n    let attribute = null;\n\n    const uninitializedErrorMessage = `The data model element passed to ${methodName} (${CMIElement}) has not been initialized.`;\n    const invalidErrorMessage = `The data model element passed to ${methodName} (${CMIElement}) is not a valid SCORM data model element.`;\n    const invalidErrorCode = scorm2004 ?\n        this.#error_codes.UNDEFINED_DATA_MODEL :\n        this.#error_codes.GENERAL;\n\n    for (let i = 0; i < structure.length; i++) {\n      attribute = structure[i];\n\n      if (!scorm2004) {\n        if (i === structure.length - 1) {\n          if (!this._checkObjectHasProperty(refObject, attribute)) {\n            this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n            return;\n          }\n        }\n      } else {\n        if ((String(attribute).substr(0, 8) === '{target=') &&\n            (typeof refObject._isTargetValid == 'function')) {\n          const target = String(attribute).\n              substr(8, String(attribute).length - 9);\n          return refObject._isTargetValid(target);\n        } else if (!this._checkObjectHasProperty(refObject, attribute)) {\n          this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n          return;\n        }\n      }\n\n      refObject = refObject[attribute];\n      if (refObject === undefined) {\n        this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n        break;\n      }\n\n      if (refObject instanceof CMIArray) {\n        const index = parseInt(structure[i + 1], 10);\n\n        // SCO is trying to set an item on an array\n        if (!isNaN(index)) {\n          const item = refObject.childArray[index];\n\n          if (item) {\n            refObject = item;\n          } else {\n            this.throwSCORMError(this.#error_codes.VALUE_NOT_INITIALIZED,\n                uninitializedErrorMessage);\n            break;\n          }\n\n          // Have to update i value to skip the array position\n          i++;\n        }\n      }\n    }\n\n    if (refObject === null || refObject === undefined) {\n      if (!scorm2004) {\n        if (attribute === '_children') {\n          this.throwSCORMError(scorm12_error_codes.CHILDREN_ERROR);\n        } else if (attribute === '_count') {\n          this.throwSCORMError(scorm12_error_codes.COUNT_ERROR);\n        }\n      }\n    } else {\n      return refObject;\n    }\n  }\n\n  /**\n   * Returns true if the API's current state is STATE_INITIALIZED\n   *\n   * @return {boolean}\n   */\n  isInitialized() {\n    return this.currentState === global_constants.STATE_INITIALIZED;\n  }\n\n  /**\n   * Returns true if the API's current state is STATE_NOT_INITIALIZED\n   *\n   * @return {boolean}\n   */\n  isNotInitialized() {\n    return this.currentState === global_constants.STATE_NOT_INITIALIZED;\n  }\n\n  /**\n   * Returns true if the API's current state is STATE_TERMINATED\n   *\n   * @return {boolean}\n   */\n  isTerminated() {\n    return this.currentState === global_constants.STATE_TERMINATED;\n  }\n\n  /**\n   * Provides a mechanism for attaching to a specific SCORM event\n   *\n   * @param {string} listenerName\n   * @param {function} callback\n   */\n  on(listenerName: String, callback: function) {\n    if (!callback) return;\n\n    const listenerFunctions = listenerName.split(' ');\n    for (let i = 0; i < listenerFunctions.length; i++) {\n      const listenerSplit = listenerFunctions[i].split('.');\n      if (listenerSplit.length === 0) return;\n\n      const functionName = listenerSplit[0];\n\n      let CMIElement = null;\n      if (listenerSplit.length > 1) {\n        CMIElement = listenerName.replace(functionName + '.', '');\n      }\n\n      this.listenerArray.push({\n        functionName: functionName,\n        CMIElement: CMIElement,\n        callback: callback,\n      });\n\n      this.apiLog('on', functionName, `Added event listener: ${this.listenerArray.length}`, global_constants.LOG_LEVEL_INFO);\n    }\n  }\n\n  /**\n   * Provides a mechanism for detaching a specific SCORM event listener\n   *\n   * @param {string} listenerName\n   * @param {function} callback\n   */\n  off(listenerName: String, callback: function) {\n    if (!callback) return;\n\n    const listenerFunctions = listenerName.split(' ');\n    for (let i = 0; i < listenerFunctions.length; i++) {\n      const listenerSplit = listenerFunctions[i].split('.');\n      if (listenerSplit.length === 0) return;\n\n      const functionName = listenerSplit[0];\n\n      let CMIElement = null;\n      if (listenerSplit.length > 1) {\n        CMIElement = listenerName.replace(functionName + '.', '');\n      }\n\n      const removeIndex = this.listenerArray.findIndex((obj) =>\n        obj.functionName === functionName &&\n        obj.CMIElement === CMIElement &&\n        obj.callback === callback\n      );\n      if (removeIndex !== -1) {\n        this.listenerArray.splice(removeIndex, 1);\n        this.apiLog('off', functionName, `Removed event listener: ${this.listenerArray.length}`, global_constants.LOG_LEVEL_INFO);\n      }\n    }\n  }\n\n  /**\n   * Provides a mechanism for clearing all listeners from a specific SCORM event\n   *\n   * @param {string} listenerName\n   */\n  clear(listenerName: String) {\n    const listenerFunctions = listenerName.split(' ');\n    for (let i = 0; i < listenerFunctions.length; i++) {\n      const listenerSplit = listenerFunctions[i].split('.');\n      if (listenerSplit.length === 0) return;\n\n      const functionName = listenerSplit[0];\n\n      let CMIElement = null;\n      if (listenerSplit.length > 1) {\n        CMIElement = listenerName.replace(functionName + '.', '');\n      }\n\n      this.listenerArray = this.listenerArray.filter((obj) =>\n        obj.functionName !== functionName &&\n        obj.CMIElement !== CMIElement,\n      );\n    }\n  }\n\n  /**\n   * Processes any 'on' listeners that have been created\n   *\n   * @param {string} functionName\n   * @param {string} CMIElement\n   * @param {*} value\n   */\n  processListeners(functionName: String, CMIElement: String, value: any) {\n    this.apiLog(functionName, CMIElement, value);\n    for (let i = 0; i < this.listenerArray.length; i++) {\n      const listener = this.listenerArray[i];\n      const functionsMatch = listener.functionName === functionName;\n      const listenerHasCMIElement = !!listener.CMIElement;\n      let CMIElementsMatch = false;\n      if (CMIElement && listener.CMIElement &&\n          listener.CMIElement.substring(listener.CMIElement.length - 1) ===\n          '*') {\n        CMIElementsMatch = CMIElement.indexOf(listener.CMIElement.substring(0,\n            listener.CMIElement.length - 1)) === 0;\n      } else {\n        CMIElementsMatch = listener.CMIElement === CMIElement;\n      }\n\n      if (functionsMatch && (!listenerHasCMIElement || CMIElementsMatch)) {\n        listener.callback(CMIElement, value);\n      }\n    }\n  }\n\n  /**\n   * Throws a SCORM error\n   *\n   * @param {number} errorNumber\n   * @param {string} message\n   */\n  throwSCORMError(errorNumber: number, message: String) {\n    if (!message) {\n      message = this.getLmsErrorMessageDetails(errorNumber);\n    }\n\n    this.apiLog('throwSCORMError', null, errorNumber + ': ' + message,\n        global_constants.LOG_LEVEL_ERROR);\n\n    this.lastErrorCode = String(errorNumber);\n  }\n\n  /**\n   * Clears the last SCORM error code on success.\n   *\n   * @param {string} success\n   */\n  clearSCORMError(success: String) {\n    if (success !== undefined && success !== global_constants.SCORM_FALSE) {\n      this.lastErrorCode = 0;\n    }\n  }\n\n  /**\n   * Attempts to store the data to the LMS, logs data if no LMS configured\n   * APIs that inherit BaseAPI should override this function\n   *\n   * @param {boolean} _calculateTotalTime\n   * @return {string}\n   * @abstract\n   */\n  storeData(_calculateTotalTime) {\n    throw new Error(\n        'The storeData method has not been implemented');\n  }\n\n  /**\n   * Load the CMI from a flattened JSON object\n   * @param {object} json\n   * @param {string} CMIElement\n   */\n  loadFromFlattenedJSON(json, CMIElement) {\n    if (!this.isNotInitialized()) {\n      console.error(\n          'loadFromFlattenedJSON can only be called before the call to lmsInitialize.');\n      return;\n    }\n\n    /**\n     * Test match pattern.\n     *\n     * @param {string} a\n     * @param {string} c\n     * @param {RegExp} a_pattern\n     * @return {number}\n     */\n    function testPattern(a, c, a_pattern) {\n      const a_match = a.match(a_pattern);\n\n      let c_match;\n      if (a_match !== null && (c_match = c.match(a_pattern)) !== null) {\n        const a_num = Number(a_match[2]);\n        const c_num = Number(c_match[2]);\n        if (a_num === c_num) {\n          if (a_match[3] === 'id') {\n            return -1;\n          } else if (a_match[3] === 'type') {\n            if (c_match[3] === 'id') {\n              return 1;\n            } else {\n              return -1;\n            }\n          } else {\n            return 1;\n          }\n        }\n        return a_num - c_num;\n      }\n\n      return null;\n    }\n\n    const int_pattern = /^(cmi\\.interactions\\.)(\\d+)\\.(.*)$/;\n    const obj_pattern = /^(cmi\\.objectives\\.)(\\d+)\\.(.*)$/;\n\n    const result = Object.keys(json).map(function(key) {\n      return [String(key), json[key]];\n    });\n\n    // CMI interactions need to have id and type loaded before any other fields\n    result.sort(function([a, b], [c, d]) {\n      let test;\n      if ((test = testPattern(a, c, int_pattern)) !== null) {\n        return test;\n      }\n      if ((test = testPattern(a, c, obj_pattern)) !== null) {\n        return test;\n      }\n\n      if (a < c) {\n        return -1;\n      }\n      if (a > c) {\n        return 1;\n      }\n      return 0;\n    });\n\n    let obj;\n    result.forEach((element) => {\n      obj = {};\n      obj[element[0]] = element[1];\n      this.loadFromJSON(unflatten(obj), CMIElement);\n    });\n  }\n\n  /**\n   * Loads CMI data from a JSON object.\n   *\n   * @param {object} json\n   * @param {string} CMIElement\n   */\n  loadFromJSON(json, CMIElement) {\n    if (!this.isNotInitialized()) {\n      console.error(\n          'loadFromJSON can only be called before the call to lmsInitialize.');\n      return;\n    }\n\n    CMIElement = CMIElement !== undefined ? CMIElement : 'cmi';\n\n    this.startingData = json;\n\n    // could this be refactored down to flatten(json) then setCMIValue on each?\n    for (const key in json) {\n      if ({}.hasOwnProperty.call(json, key) && json[key]) {\n        const currentCMIElement = (CMIElement ? CMIElement + '.' : '') + key;\n        const value = json[key];\n\n        if (value['childArray']) {\n          for (let i = 0; i < value['childArray'].length; i++) {\n            this.loadFromJSON(value['childArray'][i],\n                currentCMIElement + '.' + i);\n          }\n        } else if (value.constructor === Object) {\n          this.loadFromJSON(value, currentCMIElement);\n        } else {\n          this.setCMIValue(currentCMIElement, value);\n        }\n      }\n    }\n  }\n\n  /**\n   * Render the CMI object to JSON for sending to an LMS.\n   *\n   * @return {string}\n   */\n  renderCMIToJSONString() {\n    const cmi = this.cmi;\n    // Do we want/need to return fields that have no set value?\n    // return JSON.stringify({ cmi }, (k, v) => v === undefined ? null : v, 2);\n    return JSON.stringify({cmi});\n  }\n\n  /**\n   * Returns a JS object representing the current cmi\n   * @return {object}\n   */\n  renderCMIToJSONObject() {\n    // Do we want/need to return fields that have no set value?\n    // return JSON.stringify({ cmi }, (k, v) => v === undefined ? null : v, 2);\n    return JSON.parse(this.renderCMIToJSONString());\n  }\n\n  /**\n   * Render the cmi object to the proper format for LMS commit\n   * APIs that inherit BaseAPI should override this function\n   *\n   * @param {boolean} _terminateCommit\n   * @return {*}\n   * @abstract\n   */\n  renderCommitCMI(_terminateCommit) {\n    throw new Error(\n        'The storeData method has not been implemented');\n  }\n\n  /**\n   * Send the request to the LMS\n   * @param {string} url\n   * @param {object|Array} params\n   * @param {boolean} immediate\n   * @return {object}\n   */\n  processHttpRequest(url: String, params, immediate = false) {\n    const api = this;\n    const process = function(url, params, settings, error_codes) {\n      const genericError = {\n        'result': global_constants.SCORM_FALSE,\n        'errorCode': error_codes.GENERAL,\n      };\n\n      let result;\n      if (!settings.sendBeaconCommit) {\n        const httpReq = new XMLHttpRequest();\n        httpReq.open('POST', url, settings.asyncCommit);\n        if (settings.asyncCommit) {\n          httpReq.onload = function(e) {\n            if (typeof settings.responseHandler === 'function') {\n              result = settings.responseHandler(httpReq);\n            } else {\n              result = JSON.parse(httpReq.responseText);\n            }\n          };\n        }\n        try {\n          if (params instanceof Array) {\n            httpReq.setRequestHeader('Content-Type',\n                'application/x-www-form-urlencoded');\n            httpReq.send(params.join('&'));\n          } else {\n            httpReq.setRequestHeader('Content-Type',\n                settings.commitRequestDataType);\n            httpReq.send(JSON.stringify(params));\n          }\n\n          if (!settings.asyncCommit) {\n            if (typeof settings.responseHandler === 'function') {\n              result = settings.responseHandler(httpReq);\n            } else {\n              result = JSON.parse(httpReq.responseText);\n            }\n          } else {\n            result = {};\n            result.result = global_constants.SCORM_TRUE;\n            result.errorCode = 0;\n            api.processListeners('CommitSuccess');\n            return result;\n          }\n        } catch (e) {\n          console.error(e);\n          api.processListeners('CommitError');\n          return genericError;\n        }\n      } else {\n        try {\n          const headers = {\n            type: settings.commitRequestDataType,\n          };\n          let blob;\n          if (params instanceof Array) {\n            blob = new Blob([params.join('&')], headers);\n          } else {\n            blob = new Blob([JSON.stringify(params)], headers);\n          }\n\n          result = {};\n          if (navigator.sendBeacon(url, blob)) {\n            result.result = global_constants.SCORM_TRUE;\n            result.errorCode = 0;\n          } else {\n            result.result = global_constants.SCORM_FALSE;\n            result.errorCode = 101;\n          }\n        } catch (e) {\n          console.error(e);\n          api.processListeners('CommitError');\n          return genericError;\n        }\n      }\n\n      if (typeof result === 'undefined') {\n        api.processListeners('CommitError');\n        return genericError;\n      }\n\n      if (result.result === true ||\n          result.result === global_constants.SCORM_TRUE) {\n        api.processListeners('CommitSuccess');\n      } else {\n        api.processListeners('CommitError');\n      }\n\n      return result;\n    };\n\n    if (typeof debounce !== 'undefined') {\n      const debounced = debounce(process, 500);\n      debounced(url, params, this.settings, this.error_codes);\n\n      // if we're terminating, go ahead and commit immediately\n      if (immediate) {\n        debounced.flush();\n      }\n\n      return {\n        result: global_constants.SCORM_TRUE,\n        errorCode: 0,\n      };\n    } else {\n      return process(url, params, this.settings, this.error_codes);\n    }\n  }\n\n  /**\n   * Throws a SCORM error\n   *\n   * @param {number} when - the number of milliseconds to wait before committing\n   * @param {string} callback - the name of the commit event callback\n   */\n  scheduleCommit(when: number, callback: string) {\n    this.#timeout = new ScheduledCommit(this, when, callback);\n    this.apiLog('scheduleCommit', '', 'scheduled',\n        global_constants.LOG_LEVEL_DEBUG);\n  }\n\n  /**\n   * Clears and cancels any currently scheduled commits\n   */\n  clearScheduledCommit() {\n    if (this.#timeout) {\n      this.#timeout.cancel();\n      this.#timeout = null;\n      this.apiLog('clearScheduledCommit', '', 'cleared',\n          global_constants.LOG_LEVEL_DEBUG);\n    }\n  }\n}\n\n/**\n * Private class that wraps a timeout call to the commit() function\n */\nclass ScheduledCommit {\n  #API;\n  #cancelled = false;\n  #timeout;\n  #callback;\n\n  /**\n   * Constructor for ScheduledCommit\n   * @param {BaseAPI} API\n   * @param {number} when\n   * @param {string} callback\n   */\n  constructor(API: any, when: number, callback: string) {\n    this.#API = API;\n    this.#timeout = setTimeout(this.wrapper.bind(this), when);\n    this.#callback = callback;\n  }\n\n  /**\n   * Cancel any currently scheduled commit\n   */\n  cancel() {\n    this.#cancelled = true;\n    if (this.#timeout) {\n      clearTimeout(this.#timeout);\n    }\n  }\n\n  /**\n   * Wrap the API commit call to check if the call has already been cancelled\n   */\n  wrapper() {\n    if (!this.#cancelled) {\n      this.#API.commit(this.#callback);\n    }\n  }\n}\n","// @flow\nimport BaseAPI from './BaseAPI';\nimport {\n  CMI,\n  CMIInteractionsCorrectResponsesObject,\n  CMIInteractionsObject,\n  CMIInteractionsObjectivesObject,\n  CMIObjectivesObject, NAV,\n} from './cmi/scorm12_cmi';\nimport * as Utilities from './utilities';\nimport APIConstants from './constants/api_constants';\nimport ErrorCodes from './constants/error_codes';\n\nconst scorm12_constants = APIConstants.scorm12;\nconst global_constants = APIConstants.global;\nconst scorm12_error_codes = ErrorCodes.scorm12;\n\n/**\n * API class for SCORM 1.2\n */\nexport default class Scorm12API extends BaseAPI {\n  /**\n   * Constructor for SCORM 1.2 API\n   * @param {object} settings\n   */\n  constructor(settings: {}) {\n    const finalSettings = {\n      ...{\n        mastery_override: false,\n      }, ...settings,\n    };\n\n    super(scorm12_error_codes, finalSettings);\n\n    this.cmi = new CMI();\n    this.nav = new NAV();\n\n    // Rename functions to match 1.2 Spec and expose to modules\n    this.LMSInitialize = this.lmsInitialize;\n    this.LMSFinish = this.lmsFinish;\n    this.LMSGetValue = this.lmsGetValue;\n    this.LMSSetValue = this.lmsSetValue;\n    this.LMSCommit = this.lmsCommit;\n    this.LMSGetLastError = this.lmsGetLastError;\n    this.LMSGetErrorString = this.lmsGetErrorString;\n    this.LMSGetDiagnostic = this.lmsGetDiagnostic;\n  }\n\n  /**\n   * lmsInitialize function from SCORM 1.2 Spec\n   *\n   * @return {string} bool\n   */\n  lmsInitialize() {\n    this.cmi.initialize();\n    return this.initialize('LMSInitialize', 'LMS was already initialized!',\n        'LMS is already finished!');\n  }\n\n  /**\n   * LMSFinish function from SCORM 1.2 Spec\n   *\n   * @return {string} bool\n   */\n  lmsFinish() {\n    const result = this.terminate('LMSFinish', true);\n\n    if (result === global_constants.SCORM_TRUE) {\n      if (this.nav.event !== '') {\n        if (this.nav.event === 'continue') {\n          this.processListeners('SequenceNext');\n        } else {\n          this.processListeners('SequencePrevious');\n        }\n      } else if (this.settings.autoProgress) {\n        this.processListeners('SequenceNext');\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * LMSGetValue function from SCORM 1.2 Spec\n   *\n   * @param {string} CMIElement\n   * @return {string}\n   */\n  lmsGetValue(CMIElement) {\n    return this.getValue('LMSGetValue', false, CMIElement);\n  }\n\n  /**\n   * LMSSetValue function from SCORM 1.2 Spec\n   *\n   * @param {string} CMIElement\n   * @param {*} value\n   * @return {string}\n   */\n  lmsSetValue(CMIElement, value) {\n    return this.setValue('LMSSetValue', 'LMSCommit', false, CMIElement, value);\n  }\n\n  /**\n   * LMSCommit function from SCORM 1.2 Spec\n   *\n   * @return {string} bool\n   */\n  lmsCommit() {\n    return this.commit('LMSCommit', false);\n  }\n\n  /**\n   * LMSGetLastError function from SCORM 1.2 Spec\n   *\n   * @return {string}\n   */\n  lmsGetLastError() {\n    return this.getLastError('LMSGetLastError');\n  }\n\n  /**\n   * LMSGetErrorString function from SCORM 1.2 Spec\n   *\n   * @param {string} CMIErrorCode\n   * @return {string}\n   */\n  lmsGetErrorString(CMIErrorCode) {\n    return this.getErrorString('LMSGetErrorString', CMIErrorCode);\n  }\n\n  /**\n   * LMSGetDiagnostic function from SCORM 1.2 Spec\n   *\n   * @param {string} CMIErrorCode\n   * @return {string}\n   */\n  lmsGetDiagnostic(CMIErrorCode) {\n    return this.getDiagnostic('LMSGetDiagnostic', CMIErrorCode);\n  }\n\n  /**\n   * Sets a value on the CMI Object\n   *\n   * @param {string} CMIElement\n   * @param {*} value\n   * @return {string}\n   */\n  setCMIValue(CMIElement, value) {\n    return this._commonSetCMIValue('LMSSetValue', false, CMIElement, value);\n  }\n\n  /**\n   * Gets a value from the CMI Object\n   *\n   * @param {string} CMIElement\n   * @return {*}\n   */\n  getCMIValue(CMIElement) {\n    return this._commonGetCMIValue('getCMIValue', false, CMIElement);\n  }\n\n  /**\n   * Gets or builds a new child element to add to the array.\n   *\n   * @param {string} CMIElement\n   * @param {*} value\n   * @param {boolean} foundFirstIndex\n   * @return {object}\n   */\n  getChildElement(CMIElement, value, foundFirstIndex) {\n    let newChild;\n\n    if (this.stringMatches(CMIElement, 'cmi\\\\.objectives\\\\.\\\\d+')) {\n      newChild = new CMIObjectivesObject();\n    } else if (foundFirstIndex && this.stringMatches(CMIElement,\n        'cmi\\\\.interactions\\\\.\\\\d+\\\\.correct_responses\\\\.\\\\d+')) {\n      newChild = new CMIInteractionsCorrectResponsesObject();\n    } else if (foundFirstIndex && this.stringMatches(CMIElement,\n        'cmi\\\\.interactions\\\\.\\\\d+\\\\.objectives\\\\.\\\\d+')) {\n      newChild = new CMIInteractionsObjectivesObject();\n    } else if (!foundFirstIndex &&\n        this.stringMatches(CMIElement, 'cmi\\\\.interactions\\\\.\\\\d+')) {\n      newChild = new CMIInteractionsObject();\n    }\n\n    return newChild;\n  }\n\n  /**\n   * Validates Correct Response values\n   *\n   * @param {string} CMIElement\n   * @param {*} value\n   * @return {boolean}\n   */\n  validateCorrectResponse(CMIElement, value) {\n    return true;\n  }\n\n  /**\n   * Returns the message that corresponds to errorNumber.\n   *\n   * @param {*} errorNumber\n   * @param {boolean} detail\n   * @return {string}\n   */\n  getLmsErrorMessageDetails(errorNumber, detail) {\n    let basicMessage = 'No Error';\n    let detailMessage = 'No Error';\n\n    // Set error number to string since inconsistent from modules if string or number\n    errorNumber = String(errorNumber);\n    if (scorm12_constants.error_descriptions[errorNumber]) {\n      basicMessage = scorm12_constants.error_descriptions[errorNumber].basicMessage;\n      detailMessage = scorm12_constants.error_descriptions[errorNumber].detailMessage;\n    }\n\n    return detail ? detailMessage : basicMessage;\n  }\n\n  /**\n   * Replace the whole API with another\n   *\n   * @param {Scorm12API} newAPI\n   */\n  replaceWithAnotherScormAPI(newAPI) {\n    // Data Model\n    this.cmi = newAPI.cmi;\n  }\n\n  /**\n   * Render the cmi object to the proper format for LMS commit\n   *\n   * @param {boolean} terminateCommit\n   * @return {object|Array}\n   */\n  renderCommitCMI(terminateCommit: boolean) {\n    const cmiExport = this.renderCMIToJSONObject();\n\n    if (terminateCommit) {\n      cmiExport.cmi.core.total_time = this.cmi.getCurrentTotalTime();\n    }\n\n    const result = [];\n    const flattened = Utilities.flatten(cmiExport);\n    switch (this.settings.dataCommitFormat) {\n      case 'flattened':\n        return Utilities.flatten(cmiExport);\n      case 'params':\n        for (const item in flattened) {\n          if ({}.hasOwnProperty.call(flattened, item)) {\n            result.push(`${item}=${flattened[item]}`);\n          }\n        }\n        return result;\n      case 'json':\n      default:\n        return cmiExport;\n    }\n  }\n\n  /**\n   * Attempts to store the data to the LMS\n   *\n   * @param {boolean} terminateCommit\n   * @return {string}\n   */\n  storeData(terminateCommit: boolean) {\n    if (terminateCommit) {\n      const originalStatus = this.cmi.core.lesson_status;\n      if (originalStatus === 'not attempted') {\n        this.cmi.core.lesson_status = 'completed';\n      }\n\n      if (this.cmi.core.lesson_mode === 'normal') {\n        if (this.cmi.core.credit === 'credit') {\n          if (this.settings.mastery_override &&\n              this.cmi.student_data.mastery_score !== '' &&\n              this.cmi.core.score.raw !== '') {\n            if (parseFloat(this.cmi.core.score.raw) >= parseFloat(this.cmi.student_data.mastery_score)) {\n              this.cmi.core.lesson_status = 'passed';\n            } else {\n              this.cmi.core.lesson_status = 'failed';\n            }\n          }\n        }\n      } else if (this.cmi.core.lesson_mode === 'browse') {\n        if ((this.startingData?.cmi?.core?.lesson_status || '') === '' && originalStatus === 'not attempted') {\n          this.cmi.core.lesson_status = 'browsed';\n        }\n      }\n    }\n\n    const commitObject = this.renderCommitCMI(terminateCommit ||\n        this.settings.alwaysSendTotalTime);\n\n    if (this.apiLogLevel === global_constants.LOG_LEVEL_DEBUG) {\n      console.debug('Commit (terminated: ' + (terminateCommit ? 'yes' : 'no') + '): ');\n      console.debug(commitObject);\n    }\n    if (this.settings.lmsCommitUrl) {\n      return this.processHttpRequest(this.settings.lmsCommitUrl, commitObject, terminateCommit);\n    } else {\n      return global_constants.SCORM_TRUE;\n    }\n  }\n}\n","// @flow\nimport BaseAPI from './BaseAPI';\nimport {\n  ADL,\n  CMI,\n  CMICommentsObject,\n  CMIInteractionsCorrectResponsesObject,\n  CMIInteractionsObject,\n  CMIInteractionsObjectivesObject,\n  CMIObjectivesObject,\n} from './cmi/scorm2004_cmi';\nimport * as Utilities from './utilities';\nimport APIConstants from './constants/api_constants';\nimport ErrorCodes from './constants/error_codes';\nimport Responses from './constants/response_constants';\nimport ValidLanguages from './constants/language_constants';\nimport Regex from './constants/regex';\n\nconst scorm2004_constants = APIConstants.scorm2004;\nconst global_constants = APIConstants.global;\nconst scorm2004_error_codes = ErrorCodes.scorm2004;\nconst correct_responses = Responses.correct;\nconst scorm2004_regex = Regex.scorm2004;\n\n/**\n * API class for SCORM 2004\n */\nexport default class Scorm2004API extends BaseAPI {\n  #version: '1.0';\n\n  /**\n   * Constructor for SCORM 2004 API\n   * @param {object} settings\n   */\n  constructor(settings: {}) {\n    const finalSettings = {\n      ...{\n        mastery_override: false,\n      }, ...settings,\n    };\n\n    super(scorm2004_error_codes, finalSettings);\n\n    this.cmi = new CMI();\n    this.adl = new ADL();\n\n    // Rename functions to match 2004 Spec and expose to modules\n    this.Initialize = this.lmsInitialize;\n    this.Terminate = this.lmsTerminate;\n    this.GetValue = this.lmsGetValue;\n    this.SetValue = this.lmsSetValue;\n    this.Commit = this.lmsCommit;\n    this.GetLastError = this.lmsGetLastError;\n    this.GetErrorString = this.lmsGetErrorString;\n    this.GetDiagnostic = this.lmsGetDiagnostic;\n  }\n\n  /**\n   * Getter for #version\n   * @return {string}\n   */\n  get version() {\n    return this.#version;\n  }\n\n  /**\n   * @return {string} bool\n   */\n  lmsInitialize() {\n    this.cmi.initialize();\n    return this.initialize('Initialize');\n  }\n\n  /**\n   * @return {string} bool\n   */\n  lmsTerminate() {\n    const result = this.terminate('Terminate', true);\n\n    if (result === global_constants.SCORM_TRUE) {\n      if (this.adl.nav.request !== '_none_') {\n        switch (this.adl.nav.request) {\n          case 'continue':\n            this.processListeners('SequenceNext');\n            break;\n          case 'previous':\n            this.processListeners('SequencePrevious');\n            break;\n          case 'choice':\n            this.processListeners('SequenceChoice');\n            break;\n          case 'exit':\n            this.processListeners('SequenceExit');\n            break;\n          case 'exitAll':\n            this.processListeners('SequenceExitAll');\n            break;\n          case 'abandon':\n            this.processListeners('SequenceAbandon');\n            break;\n          case 'abandonAll':\n            this.processListeners('SequenceAbandonAll');\n            break;\n        }\n      } else if (this.settings.autoProgress) {\n        this.processListeners('SequenceNext');\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * @param {string} CMIElement\n   * @return {string}\n   */\n  lmsGetValue(CMIElement) {\n    return this.getValue('GetValue', true, CMIElement);\n  }\n\n  /**\n   * @param {string} CMIElement\n   * @param {any} value\n   * @return {string}\n   */\n  lmsSetValue(CMIElement, value) {\n    return this.setValue('SetValue', 'Commit', true, CMIElement, value);\n  }\n\n  /**\n   * Orders LMS to store all content parameters\n   *\n   * @return {string} bool\n   */\n  lmsCommit() {\n    return this.commit('Commit');\n  }\n\n  /**\n   * Returns last error code\n   *\n   * @return {string}\n   */\n  lmsGetLastError() {\n    return this.getLastError('GetLastError');\n  }\n\n  /**\n   * Returns the errorNumber error description\n   *\n   * @param {(string|number)} CMIErrorCode\n   * @return {string}\n   */\n  lmsGetErrorString(CMIErrorCode) {\n    return this.getErrorString('GetErrorString', CMIErrorCode);\n  }\n\n  /**\n   * Returns a comprehensive description of the errorNumber error.\n   *\n   * @param {(string|number)} CMIErrorCode\n   * @return {string}\n   */\n  lmsGetDiagnostic(CMIErrorCode) {\n    return this.getDiagnostic('GetDiagnostic', CMIErrorCode);\n  }\n\n  /**\n   * Sets a value on the CMI Object\n   *\n   * @param {string} CMIElement\n   * @param {any} value\n   * @return {string}\n   */\n  setCMIValue(CMIElement, value) {\n    return this._commonSetCMIValue('SetValue', true, CMIElement, value);\n  }\n\n  /**\n   * Gets or builds a new child element to add to the array.\n   *\n   * @param {string} CMIElement\n   * @param {any} value\n   * @param {boolean} foundFirstIndex\n   * @return {any}\n   */\n  getChildElement(CMIElement, value, foundFirstIndex) {\n    let newChild;\n\n    if (this.stringMatches(CMIElement, 'cmi\\\\.objectives\\\\.\\\\d+')) {\n      newChild = new CMIObjectivesObject();\n    } else if (foundFirstIndex && this.stringMatches(CMIElement,\n        'cmi\\\\.interactions\\\\.\\\\d+\\\\.correct_responses\\\\.\\\\d+')) {\n      const parts = CMIElement.split('.');\n      const index = Number(parts[2]);\n      const interaction = this.cmi.interactions.childArray[index];\n      if (this.isInitialized()) {\n        if (!interaction.type) {\n          this.throwSCORMError(\n              scorm2004_error_codes.DEPENDENCY_NOT_ESTABLISHED);\n        } else {\n          this.checkDuplicateChoiceResponse(interaction, value);\n\n          const response_type = correct_responses[interaction.type];\n          if (response_type) {\n            this.checkValidResponseType(response_type, value, interaction.type);\n          } else {\n            this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE,\n                'Incorrect Response Type: ' + interaction.type);\n          }\n        }\n      }\n      if (this.lastErrorCode === 0) {\n        newChild = new CMIInteractionsCorrectResponsesObject();\n      }\n    } else if (foundFirstIndex && this.stringMatches(CMIElement,\n        'cmi\\\\.interactions\\\\.\\\\d+\\\\.objectives\\\\.\\\\d+')) {\n      newChild = new CMIInteractionsObjectivesObject();\n    } else if (!foundFirstIndex &&\n        this.stringMatches(CMIElement, 'cmi\\\\.interactions\\\\.\\\\d+')) {\n      newChild = new CMIInteractionsObject();\n    } else if (this.stringMatches(CMIElement,\n        'cmi\\\\.comments_from_learner\\\\.\\\\d+')) {\n      newChild = new CMICommentsObject();\n    } else if (this.stringMatches(CMIElement,\n        'cmi\\\\.comments_from_lms\\\\.\\\\d+')) {\n      newChild = new CMICommentsObject(true);\n    }\n\n    return newChild;\n  }\n\n  /**\n   * Checks for valid response types\n   * @param {object} response_type\n   * @param {any} value\n   * @param {string} interaction_type\n   */\n  checkValidResponseType(response_type, value, interaction_type) {\n    let nodes = [];\n    if (response_type?.delimiter) {\n      nodes = String(value).split(response_type.delimiter);\n    } else {\n      nodes[0] = value;\n    }\n\n    if (nodes.length > 0 && nodes.length <= response_type.max) {\n      this.checkCorrectResponseValue(interaction_type, nodes, value);\n    } else if (nodes.length > response_type.max) {\n      this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE,\n          'Data Model Element Pattern Too Long');\n    }\n  }\n\n  /**\n   * Checks for duplicate 'choice' responses.\n   * @param {CMIInteractionsObject} interaction\n   * @param {any} value\n   */\n  checkDuplicateChoiceResponse(interaction, value) {\n    const interaction_count = interaction.correct_responses._count;\n    if (interaction.type === 'choice') {\n      for (let i = 0; i < interaction_count && this.lastErrorCode ===\n      0; i++) {\n        const response = interaction.correct_responses.childArray[i];\n        if (response.pattern === value) {\n          this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE);\n        }\n      }\n    }\n  }\n\n  /**\n   * Validate correct response.\n   * @param {string} CMIElement\n   * @param {*} value\n   */\n  validateCorrectResponse(CMIElement, value) {\n    const parts = CMIElement.split('.');\n    const index = Number(parts[2]);\n    const pattern_index = Number(parts[4]);\n    const interaction = this.cmi.interactions.childArray[index];\n\n    const interaction_count = interaction.correct_responses._count;\n    this.checkDuplicateChoiceResponse(interaction, value);\n\n    const response_type = correct_responses[interaction.type];\n    if (typeof response_type.limit === 'undefined' || interaction_count <=\n        response_type.limit) {\n      this.checkValidResponseType(response_type, value, interaction.type);\n\n      if (this.lastErrorCode === 0 &&\n          (!response_type.duplicate ||\n              !this.checkDuplicatedPattern(interaction.correct_responses,\n                  pattern_index, value)) ||\n          (this.lastErrorCode === 0 && value === '')) {\n        // do nothing, we want the inverse\n      } else {\n        if (this.lastErrorCode === 0) {\n          this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE,\n              'Data Model Element Pattern Already Exists');\n        }\n      }\n    } else {\n      this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE,\n          'Data Model Element Collection Limit Reached');\n    }\n  }\n\n  /**\n   * Gets a value from the CMI Object\n   *\n   * @param {string} CMIElement\n   * @return {*}\n   */\n  getCMIValue(CMIElement) {\n    return this._commonGetCMIValue('GetValue', true, CMIElement);\n  }\n\n  /**\n   * Returns the message that corresponds to errorNumber.\n   *\n   * @param {(string|number)} errorNumber\n   * @param {boolean} detail\n   * @return {string}\n   */\n  getLmsErrorMessageDetails(errorNumber, detail) {\n    let basicMessage = '';\n    let detailMessage = '';\n\n    // Set error number to string since inconsistent from modules if string or number\n    errorNumber = String(errorNumber);\n    if (scorm2004_constants.error_descriptions[errorNumber]) {\n      basicMessage = scorm2004_constants.error_descriptions[errorNumber].basicMessage;\n      detailMessage = scorm2004_constants.error_descriptions[errorNumber].detailMessage;\n    }\n\n    return detail ? detailMessage : basicMessage;\n  }\n\n  /**\n   * Check to see if a correct_response value has been duplicated\n   * @param {CMIArray} correct_response\n   * @param {number} current_index\n   * @param {*} value\n   * @return {boolean}\n   */\n  checkDuplicatedPattern = (correct_response, current_index, value) => {\n    let found = false;\n    const count = correct_response._count;\n    for (let i = 0; i < count && !found; i++) {\n      if (i !== current_index && correct_response.childArray[i] === value) {\n        found = true;\n      }\n    }\n    return found;\n  };\n\n  /**\n   * Checks for a valid correct_response value\n   * @param {string} interaction_type\n   * @param {Array} nodes\n   * @param {*} value\n   */\n  checkCorrectResponseValue(interaction_type, nodes, value) {\n    const response = correct_responses[interaction_type];\n    const formatRegex = new RegExp(response.format);\n    for (let i = 0; i < nodes.length && this.lastErrorCode === 0; i++) {\n      if (interaction_type.match(\n          '^(fill-in|long-fill-in|matching|performance|sequencing)$')) {\n        nodes[i] = this.removeCorrectResponsePrefixes(nodes[i]);\n      }\n\n      if (response?.delimiter2) {\n        const values = nodes[i].split(response.delimiter2);\n        if (values.length === 2) {\n          const matches = values[0].match(formatRegex);\n          if (!matches) {\n            this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n          } else {\n            if (!values[1].match(new RegExp(response.format2))) {\n              this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n            }\n          }\n        } else {\n          this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n        }\n      } else {\n        const matches = nodes[i].match(formatRegex);\n        if ((!matches && value !== '') ||\n            (!matches && interaction_type === 'true-false')) {\n          this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n        } else {\n          if (interaction_type === 'numeric' && nodes.length > 1) {\n            if (Number(nodes[0]) > Number(nodes[1])) {\n              this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n            }\n          } else {\n            if (nodes[i] !== '' && response.unique) {\n              for (let j = 0; j < i && this.lastErrorCode === 0; j++) {\n                if (nodes[i] === nodes[j]) {\n                  this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n                }\n              }\n            }\n          }\n        }\n      }\n    }\n  }\n\n  /**\n   * Remove prefixes from correct_response\n   * @param {string} node\n   * @return {*}\n   */\n  removeCorrectResponsePrefixes(node) {\n    let seenOrder = false;\n    let seenCase = false;\n    let seenLang = false;\n\n    const prefixRegex = new RegExp(\n        '^({(lang|case_matters|order_matters)=([^}]+)})');\n    let matches = node.match(prefixRegex);\n    let langMatches = null;\n    while (matches) {\n      switch (matches[2]) {\n        case 'lang':\n          langMatches = node.match(scorm2004_regex.CMILangcr);\n          if (langMatches) {\n            const lang = langMatches[3];\n            if (lang !== undefined && lang.length > 0) {\n              if (ValidLanguages[lang.toLowerCase()] === undefined) {\n                this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n              }\n            }\n          }\n          seenLang = true;\n          break;\n        case 'case_matters':\n          if (!seenLang && !seenOrder && !seenCase) {\n            if (matches[3] !== 'true' && matches[3] !== 'false') {\n              this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n            }\n          }\n\n          seenCase = true;\n          break;\n        case 'order_matters':\n          if (!seenCase && !seenLang && !seenOrder) {\n            if (matches[3] !== 'true' && matches[3] !== 'false') {\n              this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n            }\n          }\n\n          seenOrder = true;\n          break;\n        default:\n          break;\n      }\n      node = node.substr(matches[1].length);\n      matches = node.match(prefixRegex);\n    }\n\n    return node;\n  }\n\n  /**\n   * Replace the whole API with another\n   * @param {Scorm2004API} newAPI\n   */\n  replaceWithAnotherScormAPI(newAPI) {\n    // Data Model\n    this.cmi = newAPI.cmi;\n    this.adl = newAPI.adl;\n  }\n\n  /**\n   * Render the cmi object to the proper format for LMS commit\n   *\n   * @param {boolean} terminateCommit\n   * @return {object|Array}\n   */\n  renderCommitCMI(terminateCommit: boolean) {\n    const cmiExport = this.renderCMIToJSONObject();\n\n    if (terminateCommit) {\n      cmiExport.cmi.total_time = this.cmi.getCurrentTotalTime();\n    }\n\n    const result = [];\n    const flattened = Utilities.flatten(cmiExport);\n    switch (this.settings.dataCommitFormat) {\n      case 'flattened':\n        return Utilities.flatten(cmiExport);\n      case 'params':\n        for (const item in flattened) {\n          if ({}.hasOwnProperty.call(flattened, item)) {\n            result.push(`${item}=${flattened[item]}`);\n          }\n        }\n        return result;\n      case 'json':\n      default:\n        return cmiExport;\n    }\n  }\n\n  /**\n   * Attempts to store the data to the LMS\n   *\n   * @param {boolean} terminateCommit\n   * @return {string}\n   */\n  storeData(terminateCommit: boolean) {\n    if (terminateCommit) {\n      if (this.cmi.mode === 'normal') {\n        if (this.cmi.credit === 'credit') {\n          if (this.cmi.completion_threshold && this.cmi.progress_measure) {\n            if (this.cmi.progress_measure >= this.cmi.completion_threshold) {\n              console.debug('Setting Completion Status: Completed');\n              this.cmi.completion_status = 'completed';\n            } else {\n              console.debug('Setting Completion Status: Incomplete');\n              this.cmi.completion_status = 'incomplete';\n            }\n          }\n          if (this.cmi.scaled_passing_score && this.cmi.score.scaled) {\n            if (this.cmi.score.scaled >= this.cmi.scaled_passing_score) {\n              console.debug('Setting Success Status: Passed');\n              this.cmi.success_status = 'passed';\n            } else {\n              console.debug('Setting Success Status: Failed');\n              this.cmi.success_status = 'failed';\n            }\n          }\n        }\n      }\n    }\n\n    let navRequest = false;\n    if (this.adl.nav.request !== (this.startingData?.adl?.nav?.request) &&\n        this.adl.nav.request !== '_none_') {\n      this.adl.nav.request = encodeURIComponent(this.adl.nav.request);\n      navRequest = true;\n    }\n\n    const commitObject = this.renderCommitCMI(terminateCommit ||\n        this.settings.alwaysSendTotalTime);\n\n    if (this.apiLogLevel === global_constants.LOG_LEVEL_DEBUG) {\n      console.debug('Commit (terminated: ' +\n            (terminateCommit ? 'yes' : 'no') + '): ');\n      console.debug(commitObject);\n    }\n    if (this.settings.lmsCommitUrl) {\n      const result = this.processHttpRequest(this.settings.lmsCommitUrl,\n          commitObject, terminateCommit);\n\n      // check if this is a sequencing call, and then call the necessary JS\n      {\n        if (navRequest && result.navRequest !== undefined &&\n            result.navRequest !== '') {\n          Function(`\"use strict\";(() => { ${result.navRequest} })()`)();\n        }\n      }\n      return result;\n    } else {\n      return global_constants.SCORM_TRUE;\n    }\n  }\n}\n","import * as Scorm12CMI from './scorm12_cmi';\nimport {BaseCMI, checkValidFormat, CMIArray, CMIScore} from './common';\nimport APIConstants from '../constants/api_constants';\nimport Regex from '../constants/regex';\nimport ErrorCodes from '../constants/error_codes';\nimport {AICCValidationError} from '../exceptions';\n\nconst aicc_constants = APIConstants.aicc;\nconst aicc_regex = Regex.aicc;\nconst aicc_error_codes = ErrorCodes.scorm12;\n\n/**\n * Helper method for throwing Read Only error\n */\nfunction throwReadOnlyError() {\n  throw new AICCValidationError(aicc_error_codes.READ_ONLY_ELEMENT);\n}\n\n/**\n * Helper method, no reason to have to pass the same error codes every time\n * @param {*} value\n * @param {string} regexPattern\n * @param {boolean} allowEmptyString\n * @return {boolean}\n */\nfunction checkAICCValidFormat(\n    value: String,\n    regexPattern: String,\n    allowEmptyString?: boolean) {\n  return checkValidFormat(\n      value,\n      regexPattern,\n      aicc_error_codes.TYPE_MISMATCH,\n      AICCValidationError,\n      allowEmptyString\n  );\n}\n\n/**\n * CMI Class for AICC\n */\nexport class CMI extends Scorm12CMI.CMI {\n  /**\n   * Constructor for AICC CMI object\n   * @param {boolean} initialized\n   */\n  constructor(initialized: boolean) {\n    super(aicc_constants.cmi_children);\n\n    if (initialized) this.initialize();\n\n    this.student_preference = new AICCStudentPreferences();\n    this.student_data = new AICCCMIStudentData();\n    this.student_demographics = new CMIStudentDemographics();\n    this.evaluation = new CMIEvaluation();\n    this.paths = new CMIPaths();\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.student_preference?.initialize();\n    this.student_data?.initialize();\n    this.student_demographics?.initialize();\n    this.evaluation?.initialize();\n    this.paths?.initialize();\n  }\n\n  /**\n   * toJSON for cmi\n   *\n   * @return {\n   *    {\n   *      suspend_data: string,\n   *      launch_data: string,\n   *      comments: string,\n   *      comments_from_lms: string,\n   *      core: CMICore,\n   *      objectives: CMIObjectives,\n   *      student_data: CMIStudentData,\n   *      student_preference: CMIStudentPreference,\n   *      interactions: CMIInteractions,\n   *      paths: CMIPaths\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'suspend_data': this.suspend_data,\n      'launch_data': this.launch_data,\n      'comments': this.comments,\n      'comments_from_lms': this.comments_from_lms,\n      'core': this.core,\n      'objectives': this.objectives,\n      'student_data': this.student_data,\n      'student_preference': this.student_preference,\n      'student_demographics': this.student_demographics,\n      'interactions': this.interactions,\n      'evaluation': this.evaluation,\n      'paths': this.paths,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * AICC Evaluation object\n */\nclass CMIEvaluation extends BaseCMI {\n  /**\n   * Constructor for AICC Evaluation object\n   */\n  constructor() {\n    super();\n\n    this.comments = new CMIEvaluationComments();\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.comments?.initialize();\n  }\n\n  /**\n   * toJSON for cmi.evaluation object\n   * @return {{comments: CMIEvaluationComments}}\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'comments': this.comments,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing AICC's cmi.evaluation.comments object\n */\nclass CMIEvaluationComments extends CMIArray {\n  /**\n   * Constructor for AICC Evaluation Comments object\n   */\n  constructor() {\n    super({\n      children: aicc_constants.comments_children,\n      errorCode: aicc_error_codes.INVALID_SET_VALUE,\n      errorClass: AICCValidationError,\n    });\n  }\n}\n\n/**\n * StudentPreferences class for AICC\n */\nclass AICCStudentPreferences extends Scorm12CMI.CMIStudentPreference {\n  /**\n   * Constructor for AICC Student Preferences object\n   */\n  constructor() {\n    super(aicc_constants.student_preference_children);\n\n    this.windows = new CMIArray({\n      errorCode: aicc_error_codes.INVALID_SET_VALUE,\n      errorClass: AICCValidationError,\n      children: '',\n    });\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.windows?.initialize();\n  }\n\n  #lesson_type = '';\n  #text_color = '';\n  #text_location = '';\n  #text_size = '';\n  #video = '';\n\n  /**\n   * Getter for #lesson_type\n   * @return {string}\n   */\n  get lesson_type(): string {\n    return this.#lesson_type;\n  }\n\n  /**\n   * Setter for #lesson_type\n   * @param {string} lesson_type\n   */\n  set lesson_type(lesson_type: string) {\n    if (checkAICCValidFormat(lesson_type, aicc_regex.CMIString256)) {\n      this.#lesson_type = lesson_type;\n    }\n  }\n\n  /**\n   * Getter for #text_color\n   * @return {string}\n   */\n  get text_color(): string {\n    return this.#text_color;\n  }\n\n  /**\n   * Setter for #text_color\n   * @param {string} text_color\n   */\n  set text_color(text_color: string) {\n    if (checkAICCValidFormat(text_color, aicc_regex.CMIString256)) {\n      this.#text_color = text_color;\n    }\n  }\n\n  /**\n   * Getter for #text_location\n   * @return {string}\n   */\n  get text_location(): string {\n    return this.#text_location;\n  }\n\n  /**\n   * Setter for #text_location\n   * @param {string} text_location\n   */\n  set text_location(text_location: string) {\n    if (checkAICCValidFormat(text_location, aicc_regex.CMIString256)) {\n      this.#text_location = text_location;\n    }\n  }\n\n  /**\n   * Getter for #text_size\n   * @return {string}\n   */\n  get text_size(): string {\n    return this.#text_size;\n  }\n\n  /**\n   * Setter for #text_size\n   * @param {string} text_size\n   */\n  set text_size(text_size: string) {\n    if (checkAICCValidFormat(text_size, aicc_regex.CMIString256)) {\n      this.#text_size = text_size;\n    }\n  }\n\n  /**\n   * Getter for #video\n   * @return {string}\n   */\n  get video(): string {\n    return this.#video;\n  }\n\n  /**\n   * Setter for #video\n   * @param {string} video\n   */\n  set video(video: string) {\n    if (checkAICCValidFormat(video, aicc_regex.CMIString256)) {\n      this.#video = video;\n    }\n  }\n\n  /**\n   * toJSON for cmi.student_preference\n   *\n   * @return {\n   *    {\n   *      audio: string,\n   *      language: string,\n   *      speed: string,\n   *      text: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'audio': this.audio,\n      'language': this.language,\n      'lesson_type': this.lesson_type,\n      'speed': this.speed,\n      'text': this.text,\n      'text_color': this.text_color,\n      'text_location': this.text_location,\n      'text_size': this.text_size,\n      'video': this.video,\n      'windows': this.windows,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * StudentData class for AICC\n */\nclass AICCCMIStudentData extends Scorm12CMI.CMIStudentData {\n  /**\n   * Constructor for AICC StudentData object\n   */\n  constructor() {\n    super(aicc_constants.student_data_children);\n\n    this.tries = new CMITries();\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.tries?.initialize();\n  }\n\n  #tries_during_lesson = '';\n\n  /**\n   * Getter for tries_during_lesson\n   * @return {string}\n   */\n  get tries_during_lesson() {\n    return this.#tries_during_lesson;\n  }\n\n  /**\n   * Setter for #tries_during_lesson. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} tries_during_lesson\n   */\n  set tries_during_lesson(tries_during_lesson) {\n    !this.initialized ?\n        this.#tries_during_lesson = tries_during_lesson :\n        throwReadOnlyError();\n  }\n\n  /**\n   * toJSON for cmi.student_data object\n   * @return {\n   *    {\n   *      mastery_score: string,\n   *      max_time_allowed: string,\n   *      time_limit_action: string,\n   *      tries: CMITries\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'mastery_score': this.mastery_score,\n      'max_time_allowed': this.max_time_allowed,\n      'time_limit_action': this.time_limit_action,\n      'tries': this.tries,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing the AICC cmi.student_demographics object\n */\nexport class CMIStudentDemographics extends BaseCMI {\n  /**\n   * Constructor for AICC StudentDemographics object\n   */\n  constructor() {\n    super();\n  }\n\n  #_children = aicc_constants.student_demographics_children;\n  #city = '';\n  #class = '';\n  #company = '';\n  #country = '';\n  #experience = '';\n  #familiar_name = '';\n  #instructor_name = '';\n  #title = '';\n  #native_language = '';\n  #state = '';\n  #street_address = '';\n  #telephone = '';\n  #years_experience = '';\n\n  /**\n   * Getter for _children\n   * @return {string}\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Getter for city\n   * @return {string}\n   */\n  get city() {\n    return this.#city;\n  }\n\n  /**\n   * Setter for #city. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} city\n   */\n  set city(city) {\n    !this.initialized ?\n        this.#city = city :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for class\n   * @return {string}\n   */\n  get class() {\n    return this.#class;\n  }\n\n  /**\n   * Setter for #class. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} clazz\n   */\n  set class(clazz) {\n    !this.initialized ?\n        this.#class = clazz :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for company\n   * @return {string}\n   */\n  get company() {\n    return this.#company;\n  }\n\n  /**\n   * Setter for #company. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} company\n   */\n  set company(company) {\n    !this.initialized ?\n        this.#company = company :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for country\n   * @return {string}\n   */\n  get country() {\n    return this.#country;\n  }\n\n  /**\n   * Setter for #country. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} country\n   */\n  set country(country) {\n    !this.initialized ?\n        this.#country = country :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for experience\n   * @return {string}\n   */\n  get experience() {\n    return this.#experience;\n  }\n\n  /**\n   * Setter for #experience. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} experience\n   */\n  set experience(experience) {\n    !this.initialized ?\n        this.#experience = experience :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for familiar_name\n   * @return {string}\n   */\n  get familiar_name() {\n    return this.#familiar_name;\n  }\n\n  /**\n   * Setter for #familiar_name. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} familiar_name\n   */\n  set familiar_name(familiar_name) {\n    !this.initialized ?\n        this.#familiar_name = familiar_name :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for instructor_name\n   * @return {string}\n   */\n  get instructor_name() {\n    return this.#instructor_name;\n  }\n\n  /**\n   * Setter for #instructor_name. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} instructor_name\n   */\n  set instructor_name(instructor_name) {\n    !this.initialized ?\n        this.#instructor_name = instructor_name :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for title\n   * @return {string}\n   */\n  get title() {\n    return this.#title;\n  }\n\n  /**\n   * Setter for #title. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} title\n   */\n  set title(title) {\n    !this.initialized ?\n        this.#title = title :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for native_language\n   * @return {string}\n   */\n  get native_language() {\n    return this.#native_language;\n  }\n\n  /**\n   * Setter for #native_language. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} native_language\n   */\n  set native_language(native_language) {\n    !this.initialized ?\n        this.#native_language = native_language :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for state\n   * @return {string}\n   */\n  get state() {\n    return this.#state;\n  }\n\n  /**\n   * Setter for #state. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} state\n   */\n  set state(state) {\n    !this.initialized ?\n        this.#state = state :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for street_address\n   * @return {string}\n   */\n  get street_address() {\n    return this.#street_address;\n  }\n\n  /**\n   * Setter for #street_address. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} street_address\n   */\n  set street_address(street_address) {\n    !this.initialized ?\n        this.#street_address = street_address :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for telephone\n   * @return {string}\n   */\n  get telephone() {\n    return this.#telephone;\n  }\n\n  /**\n   * Setter for #telephone. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} telephone\n   */\n  set telephone(telephone) {\n    !this.initialized ?\n        this.#telephone = telephone :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for years_experience\n   * @return {string}\n   */\n  get years_experience() {\n    return this.#years_experience;\n  }\n\n  /**\n   * Setter for #years_experience. Sets an error if trying to set after\n   *  initialization.\n   * @param {string} years_experience\n   */\n  set years_experience(years_experience) {\n    !this.initialized ?\n        this.#years_experience = years_experience :\n        throwReadOnlyError();\n  }\n\n  /**\n   * toJSON for cmi.student_demographics object\n   * @return {\n   *      {\n   *        city: string,\n   *        class: string,\n   *        company: string,\n   *        country: string,\n   *        experience: string,\n   *        familiar_name: string,\n   *        instructor_name: string,\n   *        title: string,\n   *        native_language: string,\n   *        state: string,\n   *        street_address: string,\n   *        telephone: string,\n   *        years_experience: string\n   *      }\n   *    }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'city': this.city,\n      'class': this.class,\n      'company': this.company,\n      'country': this.country,\n      'experience': this.experience,\n      'familiar_name': this.familiar_name,\n      'instructor_name': this.instructor_name,\n      'title': this.title,\n      'native_language': this.native_language,\n      'state': this.state,\n      'street_address': this.street_address,\n      'telephone': this.telephone,\n      'years_experience': this.years_experience,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing the AICC cmi.paths object\n */\nexport class CMIPaths extends CMIArray {\n  /**\n   * Constructor for inline Paths Array class\n   */\n  constructor() {\n    super({children: aicc_constants.paths_children});\n  }\n}\n\n/**\n * Class for AICC Paths\n */\nexport class CMIPathsObject extends BaseCMI {\n  /**\n   * Constructor for AICC Paths objects\n   */\n  constructor() {\n    super();\n  }\n\n  #location_id = '';\n  #date = '';\n  #time = '';\n  #status = '';\n  #why_left = '';\n  #time_in_element = '';\n\n  /**\n   * Getter for #location_id\n   * @return {string}\n   */\n  get location_id() {\n    return this.#location_id;\n  }\n\n  /**\n   * Setter for #location_id\n   * @param {string} location_id\n   */\n  set location_id(location_id) {\n    if (checkAICCValidFormat(location_id, aicc_regex.CMIString256)) {\n      this.#location_id = location_id;\n    }\n  }\n\n  /**\n   * Getter for #date\n   * @return {string}\n   */\n  get date() {\n    return this.#date;\n  }\n\n  /**\n   * Setter for #date\n   * @param {string} date\n   */\n  set date(date) {\n    if (checkAICCValidFormat(date, aicc_regex.CMIString256)) {\n      this.#date = date;\n    }\n  }\n\n  /**\n   * Getter for #time\n   * @return {string}\n   */\n  get time() {\n    return this.#time;\n  }\n\n  /**\n   * Setter for #time\n   * @param {string} time\n   */\n  set time(time) {\n    if (checkAICCValidFormat(time, aicc_regex.CMITime)) {\n      this.#time = time;\n    }\n  }\n\n  /**\n   * Getter for #status\n   * @return {string}\n   */\n  get status() {\n    return this.#status;\n  }\n\n  /**\n   * Setter for #status\n   * @param {string} status\n   */\n  set status(status) {\n    if (checkAICCValidFormat(status, aicc_regex.CMIStatus2)) {\n      this.#status = status;\n    }\n  }\n\n  /**\n   * Getter for #why_left\n   * @return {string}\n   */\n  get why_left() {\n    return this.#why_left;\n  }\n\n  /**\n   * Setter for #why_left\n   * @param {string} why_left\n   */\n  set why_left(why_left) {\n    if (checkAICCValidFormat(why_left, aicc_regex.CMIString256)) {\n      this.#why_left = why_left;\n    }\n  }\n\n  /**\n   * Getter for #time_in_element\n   * @return {string}\n   */\n  get time_in_element() {\n    return this.#time_in_element;\n  }\n\n  /**\n   * Setter for #time_in_element\n   * @param {string} time_in_element\n   */\n  set time_in_element(time_in_element) {\n    if (checkAICCValidFormat(time_in_element, aicc_regex.CMITime)) {\n      this.#time_in_element = time_in_element;\n    }\n  }\n\n  /**\n   * toJSON for cmi.paths.n object\n   * @return {\n   *    {\n   *      location_id: string,\n   *      date: string,\n   *      time: string,\n   *      status: string,\n   *      why_left: string,\n   *      time_in_element: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'location_id': this.location_id,\n      'date': this.date,\n      'time': this.time,\n      'status': this.status,\n      'why_left': this.why_left,\n      'time_in_element': this.time_in_element,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing the AICC cmi.student_data.tries object\n */\nexport class CMITries extends CMIArray {\n  /**\n   * Constructor for inline Tries Array class\n   */\n  constructor() {\n    super({children: aicc_constants.tries_children});\n  }\n}\n\n/**\n * Class for AICC Tries\n */\nexport class CMITriesObject extends BaseCMI {\n  /**\n   * Constructor for AICC Tries object\n   */\n  constructor() {\n    super();\n\n    this.score = new CMIScore(\n        {\n          score_children: aicc_constants.score_children,\n          score_range: aicc_regex.score_range,\n          invalidErrorCode: aicc_error_codes.INVALID_SET_VALUE,\n          invalidTypeCode: aicc_error_codes.TYPE_MISMATCH,\n          invalidRangeCode: aicc_error_codes.VALUE_OUT_OF_RANGE,\n          errorClass: AICCValidationError,\n        });\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.score?.initialize();\n  }\n\n  #status = '';\n  #time = '';\n\n  /**\n   * Getter for #status\n   * @return {string}\n   */\n  get status() {\n    return this.#status;\n  }\n\n  /**\n   * Setter for #status\n   * @param {string} status\n   */\n  set status(status) {\n    if (checkAICCValidFormat(status, aicc_regex.CMIStatus2)) {\n      this.#status = status;\n    }\n  }\n\n  /**\n   * Getter for #time\n   * @return {string}\n   */\n  get time() {\n    return this.#time;\n  }\n\n  /**\n   * Setter for #time\n   * @param {string} time\n   */\n  set time(time) {\n    if (checkAICCValidFormat(time, aicc_regex.CMITime)) {\n      this.#time = time;\n    }\n  }\n\n  /**\n   * toJSON for cmi.student_data.tries.n object\n   * @return {\n   *    {\n   *      status: string,\n   *      time: string,\n   *      score: CMIScore\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'status': this.status,\n      'time': this.time,\n      'score': this.score,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class for cmi.student_data.attempt_records array\n */\nexport class CMIAttemptRecords extends CMIArray {\n  /**\n   * Constructor for inline Tries Array class\n   */\n  constructor() {\n    super({children: aicc_constants.attempt_records_children});\n  }\n}\n\n/**\n * Class for AICC Attempt Records\n */\nexport class CMIAttemptRecordsObject extends BaseCMI {\n  /**\n   * Constructor for AICC Attempt Records object\n   */\n  constructor() {\n    super();\n\n    this.score = new CMIScore(\n        {\n          score_children: aicc_constants.score_children,\n          score_range: aicc_regex.score_range,\n          invalidErrorCode: aicc_error_codes.INVALID_SET_VALUE,\n          invalidTypeCode: aicc_error_codes.TYPE_MISMATCH,\n          invalidRangeCode: aicc_error_codes.VALUE_OUT_OF_RANGE,\n          errorClass: AICCValidationError,\n        });\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.score?.initialize();\n  }\n\n  #lesson_status = '';\n\n  /**\n   * Getter for #lesson_status\n   * @return {string}\n   */\n  get lesson_status() {\n    return this.#lesson_status;\n  }\n\n  /**\n   * Setter for #lesson_status\n   * @param {string} lesson_status\n   */\n  set lesson_status(lesson_status) {\n    if (checkAICCValidFormat(lesson_status, aicc_regex.CMIStatus2)) {\n      this.#lesson_status = lesson_status;\n    }\n  }\n\n  /**\n   * toJSON for cmi.student_data.attempt_records.n object\n   * @return {\n   *    {\n   *      status: string,\n   *      time: string,\n   *      score: CMIScore\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'lesson_status': this.lesson_status,\n      'score': this.score,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class for AICC Evaluation Comments\n */\nexport class CMIEvaluationCommentsObject extends BaseCMI {\n  /**\n   * Constructor for Evaluation Comments\n   */\n  constructor() {\n    super();\n  }\n\n  #content = '';\n  #location = '';\n  #time = '';\n\n  /**\n   * Getter for #content\n   * @return {string}\n   */\n  get content() {\n    return this.#content;\n  }\n\n  /**\n   * Setter for #content\n   * @param {string} content\n   */\n  set content(content) {\n    if (checkAICCValidFormat(content, aicc_regex.CMIString256)) {\n      this.#content = content;\n    }\n  }\n\n  /**\n   * Getter for #location\n   * @return {string}\n   */\n  get location() {\n    return this.#location;\n  }\n\n  /**\n   * Setter for #location\n   * @param {string} location\n   */\n  set location(location) {\n    if (checkAICCValidFormat(location, aicc_regex.CMIString256)) {\n      this.#location = location;\n    }\n  }\n\n  /**\n   * Getter for #time\n   * @return {string}\n   */\n  get time() {\n    return this.#time;\n  }\n\n  /**\n   * Setting for #time\n   * @param {string} time\n   */\n  set time(time) {\n    if (checkAICCValidFormat(time, aicc_regex.CMITime)) {\n      this.#time = time;\n    }\n  }\n\n  /**\n   * toJSON for cmi.evaulation.comments.n object\n   * @return {\n   *    {\n   *      content: string,\n   *      location: string,\n   *      time: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'content': this.content,\n      'location': this.location,\n      'time': this.time,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n","// @flow\nimport APIConstants from '../constants/api_constants';\nimport ErrorCodes from '../constants/error_codes';\nimport Regex from '../constants/regex';\n\nconst scorm12_constants = APIConstants.scorm12;\nconst scorm12_regex = Regex.scorm12;\nconst scorm12_error_codes = ErrorCodes.scorm12;\n\n/**\n * Check if the value matches the proper format. If not, throw proper error code.\n *\n * @param {string} value\n * @param {string} regexPattern\n * @param {number} errorCode\n * @param {class} errorClass\n * @param {boolean} allowEmptyString\n * @return {boolean}\n */\nexport function checkValidFormat(\n    value: String,\n    regexPattern: String,\n    errorCode: number,\n    errorClass: function,\n    allowEmptyString?: boolean) {\n  const formatRegex = new RegExp(regexPattern);\n  const matches = value.match(formatRegex);\n  if (allowEmptyString && value === '') {\n    return true;\n  }\n  if (value === undefined || !matches || matches[0] === '') {\n    throw new errorClass.prototype.constructor(errorCode);\n  }\n  return true;\n}\n\n/**\n * Check if the value matches the proper range. If not, throw proper error code.\n *\n * @param {*} value\n * @param {string} rangePattern\n * @param {number} errorCode\n * @param {class} errorClass\n * @return {boolean}\n */\nexport function checkValidRange(\n    value: any,\n    rangePattern: String,\n    errorCode: number,\n    errorClass: function) {\n  const ranges = rangePattern.split('#');\n  value = value * 1.0;\n  if (value >= ranges[0]) {\n    if ((ranges[1] === '*') || (value <= ranges[1])) {\n      return true;\n    } else {\n      throw new errorClass.prototype.constructor(errorCode);\n    }\n  } else {\n    throw new errorClass.prototype.constructor(errorCode);\n  }\n}\n\n/**\n * Base class for API cmi objects\n */\nexport class BaseCMI {\n  jsonString = false;\n  #initialized = false;\n  #start_time;\n\n  /**\n   * Constructor for BaseCMI, just marks the class as abstract\n   */\n  constructor() {\n    if (new.target === BaseCMI) {\n      throw new TypeError('Cannot construct BaseCMI instances directly');\n    }\n  }\n\n  /**\n   * Getter for #initialized\n   * @return {boolean}\n   */\n  get initialized() {\n    return this.#initialized;\n  }\n\n  /**\n   * Getter for #start_time\n   * @return {Number}\n   */\n  get start_time() {\n    return this.#start_time;\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    this.#initialized = true;\n  }\n\n  /**\n   * Called when the player should override the 'session_time' provided by\n   * the module\n   */\n  setStartTime() {\n    this.#start_time = new Date().getTime();\n  }\n}\n\n/**\n * Base class for cmi *.score objects\n */\nexport class CMIScore extends BaseCMI {\n  /**\n   * Constructor for *.score\n   * @param {string} score_children\n   * @param {string} score_range\n   * @param {string} max\n   * @param {number} invalidErrorCode\n   * @param {number} invalidTypeCode\n   * @param {number} invalidRangeCode\n   * @param {string} decimalRegex\n   * @param {class} errorClass\n   */\n  constructor(\n      {\n        score_children,\n        score_range,\n        max,\n        invalidErrorCode,\n        invalidTypeCode,\n        invalidRangeCode,\n        decimalRegex,\n        errorClass,\n      }) {\n    super();\n\n    this.#_children = score_children ||\n        scorm12_constants.score_children;\n    this.#_score_range = !score_range ? false : scorm12_regex.score_range;\n    this.#max = (max || max === '') ? max : '100';\n    this.#_invalid_error_code = invalidErrorCode ||\n        scorm12_error_codes.INVALID_SET_VALUE;\n    this.#_invalid_type_code = invalidTypeCode ||\n        scorm12_error_codes.TYPE_MISMATCH;\n    this.#_invalid_range_code = invalidRangeCode ||\n        scorm12_error_codes.VALUE_OUT_OF_RANGE;\n    this.#_decimal_regex = decimalRegex ||\n        scorm12_regex.CMIDecimal;\n    this.#_error_class = errorClass;\n  }\n\n  #_children;\n  #_score_range;\n  #_invalid_error_code;\n  #_invalid_type_code;\n  #_invalid_range_code;\n  #_decimal_regex;\n  #_error_class;\n  #raw = '';\n  #min = '';\n  #max;\n\n  /**\n   * Getter for _children\n   * @return {string}\n   * @private\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for _children. Just throws an error.\n   * @param {string} _children\n   * @private\n   */\n  set _children(_children) {\n    throw new this.#_error_class.prototype.constructor(this.#_invalid_error_code);\n  }\n\n  /**\n   * Getter for #raw\n   * @return {string}\n   */\n  get raw() {\n    return this.#raw;\n  }\n\n  /**\n   * Setter for #raw\n   * @param {string} raw\n   */\n  set raw(raw) {\n    if (checkValidFormat(raw, this.#_decimal_regex, this.#_invalid_type_code, this.#_error_class) &&\n        (!this.#_score_range ||\n            checkValidRange(raw, this.#_score_range, this.#_invalid_range_code, this.#_error_class))) {\n      this.#raw = raw;\n    }\n  }\n\n  /**\n   * Getter for #min\n   * @return {string}\n   */\n  get min() {\n    return this.#min;\n  }\n\n  /**\n   * Setter for #min\n   * @param {string} min\n   */\n  set min(min) {\n    if (checkValidFormat(min, this.#_decimal_regex, this.#_invalid_type_code, this.#_error_class) &&\n        (!this.#_score_range ||\n            checkValidRange(min, this.#_score_range, this.#_invalid_range_code, this.#_error_class))) {\n      this.#min = min;\n    }\n  }\n\n  /**\n   * Getter for #max\n   * @return {string}\n   */\n  get max() {\n    return this.#max;\n  }\n\n  /**\n   * Setter for #max\n   * @param {string} max\n   */\n  set max(max) {\n    if (checkValidFormat(max, this.#_decimal_regex, this.#_invalid_type_code, this.#_error_class) &&\n        (!this.#_score_range ||\n            checkValidRange(max, this.#_score_range, this.#_invalid_range_code, this.#_error_class))) {\n      this.#max = max;\n    }\n  }\n\n  /**\n   * toJSON for *.score\n   * @return {{min: string, max: string, raw: string}}\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'raw': this.raw,\n      'min': this.min,\n      'max': this.max,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Base class for cmi *.n objects\n */\nexport class CMIArray extends BaseCMI {\n  /**\n   * Constructor cmi *.n arrays\n   * @param {string} children\n   * @param {number} errorCode\n   * @param {class} errorClass\n   */\n  constructor({children, errorCode, errorClass}) {\n    super();\n    this.#_children = children;\n    this.#errorCode = errorCode;\n    this.#errorClass = errorClass;\n    this.childArray = [];\n  }\n\n  #errorCode;\n  #errorClass;\n  #_children;\n\n  /**\n   * Getter for _children\n   * @return {*}\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for _children. Just throws an error.\n   * @param {string} _children\n   */\n  set _children(_children) {\n    throw new this.#errorClass.prototype.constructor(this.#errorCode);\n  }\n\n  /**\n   * Getter for _count\n   * @return {number}\n   */\n  get _count() {\n    return this.childArray.length;\n  }\n\n  /**\n   * Setter for _count. Just throws an error.\n   * @param {number} _count\n   */\n  set _count(_count) {\n    throw new this.#errorClass.prototype.constructor(this.#errorCode);\n  }\n\n  /**\n   * toJSON for *.n arrays\n   * @return {object}\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {};\n    for (let i = 0; i < this.childArray.length; i++) {\n      result[i + ''] = this.childArray[i];\n    }\n    delete this.jsonString;\n    return result;\n  }\n}\n","// @flow\nimport {\n  BaseCMI,\n  checkValidFormat,\n  checkValidRange,\n  CMIArray,\n  CMIScore,\n} from './common';\nimport APIConstants from '../constants/api_constants';\nimport ErrorCodes from '../constants/error_codes';\nimport Regex from '../constants/regex';\nimport {Scorm12ValidationError} from '../exceptions';\nimport * as Utilities from '../utilities';\nimport * as Util from '../utilities';\n\nconst scorm12_constants = APIConstants.scorm12;\nconst scorm12_regex = Regex.scorm12;\nconst scorm12_error_codes = ErrorCodes.scorm12;\n\n/**\n * Helper method for throwing Read Only error\n */\nexport function throwReadOnlyError() {\n  throw new Scorm12ValidationError(scorm12_error_codes.READ_ONLY_ELEMENT);\n}\n\n/**\n * Helper method for throwing Write Only error\n */\nexport function throwWriteOnlyError() {\n  throw new Scorm12ValidationError(scorm12_error_codes.WRITE_ONLY_ELEMENT);\n}\n\n/**\n * Helper method for throwing Invalid Set error\n */\nfunction throwInvalidValueError() {\n  throw new Scorm12ValidationError(scorm12_error_codes.INVALID_SET_VALUE);\n}\n\n/**\n * Helper method, no reason to have to pass the same error codes every time\n * @param {*} value\n * @param {string} regexPattern\n * @param {boolean} allowEmptyString\n * @return {boolean}\n */\nexport function check12ValidFormat(\n    value: String,\n    regexPattern: String,\n    allowEmptyString?: boolean) {\n  return checkValidFormat(\n      value,\n      regexPattern,\n      scorm12_error_codes.TYPE_MISMATCH,\n      Scorm12ValidationError,\n      allowEmptyString\n  );\n}\n\n/**\n * Helper method, no reason to have to pass the same error codes every time\n * @param {*} value\n * @param {string} rangePattern\n * @param {boolean} allowEmptyString\n * @return {boolean}\n */\nexport function check12ValidRange(\n    value: any,\n    rangePattern: String,\n    allowEmptyString?: boolean) {\n  return checkValidRange(\n      value,\n      rangePattern,\n      scorm12_error_codes.VALUE_OUT_OF_RANGE,\n      Scorm12ValidationError,\n      allowEmptyString\n  );\n}\n\n/**\n * Class representing the cmi object for SCORM 1.2\n */\nexport class CMI extends BaseCMI {\n  #_children = '';\n  #_version = '3.4';\n  #launch_data = '';\n  #comments = '';\n  #comments_from_lms = '';\n\n  student_data = null;\n\n  /**\n   * Constructor for the SCORM 1.2 cmi object\n   * @param {string} cmi_children\n   * @param {(CMIStudentData|AICCCMIStudentData)} student_data\n   * @param {boolean} initialized\n   */\n  constructor(cmi_children, student_data, initialized: boolean) {\n    super();\n\n    if (initialized) this.initialize();\n\n    this.#_children = cmi_children ?\n        cmi_children :\n        scorm12_constants.cmi_children;\n    this.core = new CMICore();\n    this.objectives = new CMIObjectives();\n    this.student_data = student_data ? student_data : new CMIStudentData();\n    this.student_preference = new CMIStudentPreference();\n    this.interactions = new CMIInteractions();\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.core?.initialize();\n    this.objectives?.initialize();\n    this.student_data?.initialize();\n    this.student_preference?.initialize();\n    this.interactions?.initialize();\n  }\n\n  /**\n   * toJSON for cmi\n   *\n   * @return {\n   *    {\n   *      suspend_data: string,\n   *      launch_data: string,\n   *      comments: string,\n   *      comments_from_lms: string,\n   *      core: CMICore,\n   *      objectives: CMIObjectives,\n   *      student_data: CMIStudentData,\n   *      student_preference: CMIStudentPreference,\n   *      interactions: CMIInteractions\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'suspend_data': this.suspend_data,\n      'launch_data': this.launch_data,\n      'comments': this.comments,\n      'comments_from_lms': this.comments_from_lms,\n      'core': this.core,\n      'objectives': this.objectives,\n      'student_data': this.student_data,\n      'student_preference': this.student_preference,\n      'interactions': this.interactions,\n    };\n    delete this.jsonString;\n    return result;\n  }\n\n  /**\n   * Getter for #_version\n   * @return {string}\n   */\n  get _version() {\n    return this.#_version;\n  }\n\n  /**\n   * Setter for #_version. Just throws an error.\n   * @param {string} _version\n   */\n  set _version(_version) {\n    throwInvalidValueError();\n  }\n\n  /**\n   * Getter for #_children\n   * @return {string}\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for #_version. Just throws an error.\n   * @param {string} _children\n   */\n  set _children(_children) {\n    throwInvalidValueError();\n  }\n\n  /**\n   * Getter for #suspend_data\n   * @return {string}\n   */\n  get suspend_data() {\n    return this.core?.suspend_data;\n  }\n\n  /**\n   * Setter for #suspend_data\n   * @param {string} suspend_data\n   */\n  set suspend_data(suspend_data) {\n    if (this.core) {\n      this.core.suspend_data = suspend_data;\n    }\n  }\n\n  /**\n   * Getter for #launch_data\n   * @return {string}\n   */\n  get launch_data() {\n    return this.#launch_data;\n  }\n\n  /**\n   * Setter for #launch_data. Can only be called before  initialization.\n   * @param {string} launch_data\n   */\n  set launch_data(launch_data) {\n    !this.initialized ? this.#launch_data = launch_data : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #comments\n   * @return {string}\n   */\n  get comments() {\n    return this.#comments;\n  }\n\n  /**\n   * Setter for #comments\n   * @param {string} comments\n   */\n  set comments(comments) {\n    if (check12ValidFormat(comments, scorm12_regex.CMIString4096, true)) {\n      this.#comments = comments;\n    }\n  }\n\n  /**\n   * Getter for #comments_from_lms\n   * @return {string}\n   */\n  get comments_from_lms() {\n    return this.#comments_from_lms;\n  }\n\n  /**\n   * Setter for #comments_from_lms. Can only be called before  initialization.\n   * @param {string} comments_from_lms\n   */\n  set comments_from_lms(comments_from_lms) {\n    !this.initialized ?\n        this.#comments_from_lms = comments_from_lms :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Adds the current session time to the existing total time.\n   *\n   * @return {string}\n   */\n  getCurrentTotalTime() {\n    return this.core.getCurrentTotalTime(this.start_time);\n  }\n}\n\n/**\n * Class representing the cmi.core object\n * @extends BaseCMI\n */\nclass CMICore extends BaseCMI {\n  /**\n   * Constructor for cmi.core\n   */\n  constructor() {\n    super();\n\n    this.score = new CMIScore(\n        {\n          score_children: scorm12_constants.score_children,\n          score_range: scorm12_regex.score_range,\n          invalidErrorCode: scorm12_error_codes.INVALID_SET_VALUE,\n          invalidTypeCode: scorm12_error_codes.TYPE_MISMATCH,\n          invalidRangeCode: scorm12_error_codes.VALUE_OUT_OF_RANGE,\n          errorClass: Scorm12ValidationError,\n        });\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.score?.initialize();\n  }\n\n  #_children = scorm12_constants.core_children;\n  #student_id = '';\n  #student_name = '';\n  #lesson_location = '';\n  #credit = '';\n  #lesson_status = 'not attempted';\n  #entry = '';\n  #total_time = '';\n  #lesson_mode = 'normal';\n  #exit = '';\n  #session_time = '00:00:00';\n  #suspend_data = '';\n\n  /**\n   * Getter for #_children\n   * @return {string}\n   * @private\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for #_children. Just throws an error.\n   * @param {string} _children\n   * @private\n   */\n  set _children(_children) {\n    throwInvalidValueError();\n  }\n\n  /**\n   * Getter for #student_id\n   * @return {string}\n   */\n  get student_id() {\n    return this.#student_id;\n  }\n\n  /**\n   * Setter for #student_id. Can only be called before  initialization.\n   * @param {string} student_id\n   */\n  set student_id(student_id) {\n    !this.initialized ? this.#student_id = student_id : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #student_name\n   * @return {string}\n   */\n  get student_name() {\n    return this.#student_name;\n  }\n\n  /**\n   * Setter for #student_name. Can only be called before  initialization.\n   * @param {string} student_name\n   */\n  set student_name(student_name) {\n    !this.initialized ?\n        this.#student_name = student_name :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #lesson_location\n   * @return {string}\n   */\n  get lesson_location() {\n    return this.#lesson_location;\n  }\n\n  /**\n   * Setter for #lesson_location\n   * @param {string} lesson_location\n   */\n  set lesson_location(lesson_location) {\n    if (check12ValidFormat(lesson_location, scorm12_regex.CMIString256, true)) {\n      this.#lesson_location = lesson_location;\n    }\n  }\n\n  /**\n   * Getter for #credit\n   * @return {string}\n   */\n  get credit() {\n    return this.#credit;\n  }\n\n  /**\n   * Setter for #credit. Can only be called before  initialization.\n   * @param {string} credit\n   */\n  set credit(credit) {\n    !this.initialized ? this.#credit = credit : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #lesson_status\n   * @return {string}\n   */\n  get lesson_status() {\n    return this.#lesson_status;\n  }\n\n  /**\n   * Setter for #lesson_status\n   * @param {string} lesson_status\n   */\n  set lesson_status(lesson_status) {\n    if (this.initialized) {\n      if (check12ValidFormat(lesson_status, scorm12_regex.CMIStatus)) {\n        this.#lesson_status = lesson_status;\n      }\n    } else {\n      if (check12ValidFormat(lesson_status, scorm12_regex.CMIStatus2)) {\n        this.#lesson_status = lesson_status;\n      }\n    }\n  }\n\n  /**\n   * Getter for #entry\n   * @return {string}\n   */\n  get entry() {\n    return this.#entry;\n  }\n\n  /**\n   * Setter for #entry. Can only be called before  initialization.\n   * @param {string} entry\n   */\n  set entry(entry) {\n    !this.initialized ? this.#entry = entry : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #total_time\n   * @return {string}\n   */\n  get total_time() {\n    return this.#total_time;\n  }\n\n  /**\n   * Setter for #total_time. Can only be called before  initialization.\n   * @param {string} total_time\n   */\n  set total_time(total_time) {\n    !this.initialized ? this.#total_time = total_time : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #lesson_mode\n   * @return {string}\n   */\n  get lesson_mode() {\n    return this.#lesson_mode;\n  }\n\n  /**\n   * Setter for #lesson_mode. Can only be called before  initialization.\n   * @param {string} lesson_mode\n   */\n  set lesson_mode(lesson_mode) {\n    !this.initialized ? this.#lesson_mode = lesson_mode : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #exit. Should only be called during JSON export.\n   * @return {*}\n   */\n  get exit() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#exit;\n  }\n\n  /**\n   * Setter for #exit\n   * @param {string} exit\n   */\n  set exit(exit) {\n    if (check12ValidFormat(exit, scorm12_regex.CMIExit, true)) {\n      this.#exit = exit;\n    }\n  }\n\n  /**\n   * Getter for #session_time. Should only be called during JSON export.\n   * @return {*}\n   */\n  get session_time() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#session_time;\n  }\n\n  /**\n   * Setter for #session_time\n   * @param {string} session_time\n   */\n  set session_time(session_time) {\n    if (check12ValidFormat(session_time, scorm12_regex.CMITimespan)) {\n      this.#session_time = session_time;\n    }\n  }\n\n  /**\n   * Getter for #suspend_data\n   * @return {string}\n   */\n  get suspend_data() {\n    return this.#suspend_data;\n  }\n\n  /**\n   * Setter for #suspend_data\n   * @param {string} suspend_data\n   */\n  set suspend_data(suspend_data) {\n    if (check12ValidFormat(suspend_data, scorm12_regex.CMIString4096, true)) {\n      this.#suspend_data = suspend_data;\n    }\n  }\n\n  /**\n   * Adds the current session time to the existing total time.\n   * @param {Number} start_time\n   * @return {string}\n   */\n  getCurrentTotalTime(start_time: Number) {\n    let sessionTime = this.#session_time;\n    const startTime = start_time;\n\n    if (typeof startTime !== 'undefined' && startTime !== null) {\n      const seconds = new Date().getTime() - startTime;\n      sessionTime = Util.getSecondsAsHHMMSS(seconds / 1000);\n    }\n\n    return Utilities.addHHMMSSTimeStrings(\n        this.#total_time,\n        sessionTime,\n        new RegExp(scorm12_regex.CMITimespan),\n    );\n  }\n\n  /**\n   * toJSON for cmi.core\n   *\n   * @return {\n   *    {\n   *      student_name: string,\n   *      entry: string,\n   *      exit: string,\n   *      score: CMIScore,\n   *      student_id: string,\n   *      lesson_mode: string,\n   *      lesson_location: string,\n   *      lesson_status: string,\n   *      credit: string,\n   *      session_time: *\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'student_id': this.student_id,\n      'student_name': this.student_name,\n      'lesson_location': this.lesson_location,\n      'credit': this.credit,\n      'lesson_status': this.lesson_status,\n      'entry': this.entry,\n      'lesson_mode': this.lesson_mode,\n      'exit': this.exit,\n      'session_time': this.session_time,\n      'score': this.score,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.objectives object\n * @extends CMIArray\n */\nclass CMIObjectives extends CMIArray {\n  /**\n   * Constructor for cmi.objectives\n   */\n  constructor() {\n    super({\n      children: scorm12_constants.objectives_children,\n      errorCode: scorm12_error_codes.INVALID_SET_VALUE,\n      errorClass: Scorm12ValidationError,\n    });\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.student_data object\n * @extends BaseCMI\n */\nexport class CMIStudentData extends BaseCMI {\n  #_children;\n  #mastery_score = '';\n  #max_time_allowed = '';\n  #time_limit_action = '';\n\n  /**\n   * Constructor for cmi.student_data\n   * @param {string} student_data_children\n   */\n  constructor(student_data_children) {\n    super();\n\n    this.#_children = student_data_children ?\n        student_data_children :\n        scorm12_constants.student_data_children;\n  }\n\n  /**\n   * Getter for #_children\n   * @return {*}\n   * @private\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for #_children. Just throws an error.\n   * @param {string} _children\n   * @private\n   */\n  set _children(_children) {\n    throwInvalidValueError();\n  }\n\n  /**\n   * Getter for #master_score\n   * @return {string}\n   */\n  get mastery_score() {\n    return this.#mastery_score;\n  }\n\n  /**\n   * Setter for #master_score. Can only be called before  initialization.\n   * @param {string} mastery_score\n   */\n  set mastery_score(mastery_score) {\n    !this.initialized ?\n        this.#mastery_score = mastery_score :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #max_time_allowed\n   * @return {string}\n   */\n  get max_time_allowed() {\n    return this.#max_time_allowed;\n  }\n\n  /**\n   * Setter for #max_time_allowed. Can only be called before  initialization.\n   * @param {string} max_time_allowed\n   */\n  set max_time_allowed(max_time_allowed) {\n    !this.initialized ?\n        this.#max_time_allowed = max_time_allowed :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #time_limit_action\n   * @return {string}\n   */\n  get time_limit_action() {\n    return this.#time_limit_action;\n  }\n\n  /**\n   * Setter for #time_limit_action. Can only be called before  initialization.\n   * @param {string} time_limit_action\n   */\n  set time_limit_action(time_limit_action) {\n    !this.initialized ?\n        this.#time_limit_action = time_limit_action :\n        throwReadOnlyError();\n  }\n\n  /**\n   * toJSON for cmi.student_data\n   *\n   * @return {\n   *    {\n   *      max_time_allowed: string,\n   *      time_limit_action: string,\n   *      mastery_score: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'mastery_score': this.mastery_score,\n      'max_time_allowed': this.max_time_allowed,\n      'time_limit_action': this.time_limit_action,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.student_preference object\n * @extends BaseCMI\n */\nexport class CMIStudentPreference extends BaseCMI {\n  #_children;\n\n  /**\n   * Constructor for cmi.student_preference\n   * @param {string} student_preference_children\n   */\n  constructor(student_preference_children) {\n    super();\n\n    this.#_children = student_preference_children ?\n        student_preference_children :\n        scorm12_constants.student_preference_children;\n  }\n\n  #audio = '';\n  #language = '';\n  #speed = '';\n  #text = '';\n\n  /**\n   * Getter for #_children\n   * @return {string}\n   * @private\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for #_children. Just throws an error.\n   * @param {string} _children\n   * @private\n   */\n  set _children(_children) {\n    throwInvalidValueError();\n  }\n\n  /**\n   * Getter for #audio\n   * @return {string}\n   */\n  get audio() {\n    return this.#audio;\n  }\n\n  /**\n   * Setter for #audio\n   * @param {string} audio\n   */\n  set audio(audio) {\n    if (check12ValidFormat(audio, scorm12_regex.CMISInteger) &&\n        check12ValidRange(audio, scorm12_regex.audio_range)) {\n      this.#audio = audio;\n    }\n  }\n\n  /**\n   * Getter for #language\n   * @return {string}\n   */\n  get language() {\n    return this.#language;\n  }\n\n  /**\n   * Setter for #language\n   * @param {string} language\n   */\n  set language(language) {\n    if (check12ValidFormat(language, scorm12_regex.CMIString256)) {\n      this.#language = language;\n    }\n  }\n\n  /**\n   * Getter for #speed\n   * @return {string}\n   */\n  get speed() {\n    return this.#speed;\n  }\n\n  /**\n   * Setter for #speed\n   * @param {string} speed\n   */\n  set speed(speed) {\n    if (check12ValidFormat(speed, scorm12_regex.CMISInteger) &&\n        check12ValidRange(speed, scorm12_regex.speed_range)) {\n      this.#speed = speed;\n    }\n  }\n\n  /**\n   * Getter for #text\n   * @return {string}\n   */\n  get text() {\n    return this.#text;\n  }\n\n  /**\n   * Setter for #text\n   * @param {string} text\n   */\n  set text(text) {\n    if (check12ValidFormat(text, scorm12_regex.CMISInteger) &&\n        check12ValidRange(text, scorm12_regex.text_range)) {\n      this.#text = text;\n    }\n  }\n\n  /**\n   * toJSON for cmi.student_preference\n   *\n   * @return {\n   *    {\n   *      audio: string,\n   *      language: string,\n   *      speed: string,\n   *      text: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'audio': this.audio,\n      'language': this.language,\n      'speed': this.speed,\n      'text': this.text,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.interactions object\n * @extends BaseCMI\n */\nclass CMIInteractions extends CMIArray {\n  /**\n   * Constructor for cmi.interactions\n   */\n  constructor() {\n    super({\n      children: scorm12_constants.interactions_children,\n      errorCode: scorm12_error_codes.INVALID_SET_VALUE,\n      errorClass: Scorm12ValidationError,\n    });\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.interactions.n object\n * @extends BaseCMI\n */\nexport class CMIInteractionsObject extends BaseCMI {\n  /**\n   * Constructor for cmi.interactions.n object\n   */\n  constructor() {\n    super();\n\n    this.objectives = new CMIArray({\n      errorCode: scorm12_error_codes.INVALID_SET_VALUE,\n      errorClass: Scorm12ValidationError,\n      children: scorm12_constants.objectives_children,\n    });\n    this.correct_responses = new CMIArray({\n      errorCode: scorm12_error_codes.INVALID_SET_VALUE,\n      errorClass: Scorm12ValidationError,\n      children: scorm12_constants.correct_responses_children,\n    });\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.objectives?.initialize();\n    this.correct_responses?.initialize();\n  }\n\n  #id = '';\n  #time = '';\n  #type = '';\n  #weighting = '';\n  #student_response = '';\n  #result = '';\n  #latency = '';\n\n  /**\n   * Getter for #id. Should only be called during JSON export.\n   * @return {*}\n   */\n  get id() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#id;\n  }\n\n  /**\n   * Setter for #id\n   * @param {string} id\n   */\n  set id(id) {\n    if (check12ValidFormat(id, scorm12_regex.CMIIdentifier)) {\n      this.#id = id;\n    }\n  }\n\n  /**\n   * Getter for #time. Should only be called during JSON export.\n   * @return {*}\n   */\n  get time() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#time;\n  }\n\n  /**\n   * Setter for #time\n   * @param {string} time\n   */\n  set time(time) {\n    if (check12ValidFormat(time, scorm12_regex.CMITime)) {\n      this.#time = time;\n    }\n  }\n\n  /**\n   * Getter for #type. Should only be called during JSON export.\n   * @return {*}\n   */\n  get type() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#type;\n  }\n\n  /**\n   * Setter for #type\n   * @param {string} type\n   */\n  set type(type) {\n    if (check12ValidFormat(type, scorm12_regex.CMIType)) {\n      this.#type = type;\n    }\n  }\n\n  /**\n   * Getter for #weighting. Should only be called during JSON export.\n   * @return {*}\n   */\n  get weighting() {\n    return (!this.jsonString) ?\n        throwWriteOnlyError() :\n        this.#weighting;\n  }\n\n  /**\n   * Setter for #weighting\n   * @param {string} weighting\n   */\n  set weighting(weighting) {\n    if (check12ValidFormat(weighting, scorm12_regex.CMIDecimal) &&\n        check12ValidRange(weighting, scorm12_regex.weighting_range)) {\n      this.#weighting = weighting;\n    }\n  }\n\n  /**\n   * Getter for #student_response. Should only be called during JSON export.\n   * @return {*}\n   */\n  get student_response() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#student_response;\n  }\n\n  /**\n   * Setter for #student_response\n   * @param {string} student_response\n   */\n  set student_response(student_response) {\n    if (check12ValidFormat(student_response, scorm12_regex.CMIFeedback, true)) {\n      this.#student_response = student_response;\n    }\n  }\n\n  /**\n   * Getter for #result. Should only be called during JSON export.\n   * @return {*}\n   */\n  get result() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#result;\n  }\n\n  /**\n   * Setter for #result\n   * @param {string} result\n   */\n  set result(result) {\n    if (check12ValidFormat(result, scorm12_regex.CMIResult)) {\n      this.#result = result;\n    }\n  }\n\n  /**\n   * Getter for #latency. Should only be called during JSON export.\n   * @return {*}\n   */\n  get latency() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#latency;\n  }\n\n  /**\n   * Setter for #latency\n   * @param {string} latency\n   */\n  set latency(latency) {\n    if (check12ValidFormat(latency, scorm12_regex.CMITimespan)) {\n      this.#latency = latency;\n    }\n  }\n\n  /**\n   * toJSON for cmi.interactions.n\n   *\n   * @return {\n   *    {\n   *      id: string,\n   *      time: string,\n   *      type: string,\n   *      weighting: string,\n   *      student_response: string,\n   *      result: string,\n   *      latency: string,\n   *      objectives: CMIArray,\n   *      correct_responses: CMIArray\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'id': this.id,\n      'time': this.time,\n      'type': this.type,\n      'weighting': this.weighting,\n      'student_response': this.student_response,\n      'result': this.result,\n      'latency': this.latency,\n      'objectives': this.objectives,\n      'correct_responses': this.correct_responses,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.objectives.n object\n * @extends BaseCMI\n */\nexport class CMIObjectivesObject extends BaseCMI {\n  /**\n   * Constructor for cmi.objectives.n\n   */\n  constructor() {\n    super();\n\n    this.score = new CMIScore(\n        {\n          score_children: scorm12_constants.score_children,\n          score_range: scorm12_regex.score_range,\n          invalidErrorCode: scorm12_error_codes.INVALID_SET_VALUE,\n          invalidTypeCode: scorm12_error_codes.TYPE_MISMATCH,\n          invalidRangeCode: scorm12_error_codes.VALUE_OUT_OF_RANGE,\n          errorClass: Scorm12ValidationError,\n        });\n  }\n\n  #id = '';\n  #status = '';\n\n  /**\n   * Getter for #id\n   * @return {\"\"}\n   */\n  get id() {\n    return this.#id;\n  }\n\n  /**\n   * Setter for #id\n   * @param {string} id\n   */\n  set id(id) {\n    if (check12ValidFormat(id, scorm12_regex.CMIIdentifier)) {\n      this.#id = id;\n    }\n  }\n\n  /**\n   * Getter for #status\n   * @return {\"\"}\n   */\n  get status() {\n    return this.#status;\n  }\n\n  /**\n   * Setter for #status\n   * @param {string} status\n   */\n  set status(status) {\n    if (check12ValidFormat(status, scorm12_regex.CMIStatus2)) {\n      this.#status = status;\n    }\n  }\n\n  /**\n   * toJSON for cmi.objectives.n\n   * @return {\n   *    {\n   *      id: string,\n   *      status: string,\n   *      score: CMIScore\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'id': this.id,\n      'status': this.status,\n      'score': this.score,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.interactions.n.objectives.n object\n * @extends BaseCMI\n */\nexport class CMIInteractionsObjectivesObject extends BaseCMI {\n  /**\n   * Constructor for cmi.interactions.n.objectives.n\n   */\n  constructor() {\n    super();\n  }\n\n  #id = '';\n\n  /**\n   * Getter for #id\n   * @return {\"\"}\n   */\n  get id() {\n    return this.#id;\n  }\n\n  /**\n   * Setter for #id\n   * @param {string} id\n   */\n  set id(id) {\n    if (check12ValidFormat(id, scorm12_regex.CMIIdentifier)) {\n      this.#id = id;\n    }\n  }\n\n  /**\n   * toJSON for cmi.interactions.n.objectives.n\n   * @return {\n   *    {\n   *      id: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'id': this.id,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.interactions.correct_responses.n object\n * @extends BaseCMI\n */\nexport class CMIInteractionsCorrectResponsesObject extends BaseCMI {\n  /**\n   * Constructor for cmi.interactions.correct_responses.n\n   */\n  constructor() {\n    super();\n  }\n\n  #pattern = '';\n\n  /**\n   * Getter for #pattern\n   * @return {string}\n   */\n  get pattern() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#pattern;\n  }\n\n  /**\n   * Setter for #pattern\n   * @param {string} pattern\n   */\n  set pattern(pattern) {\n    if (check12ValidFormat(pattern, scorm12_regex.CMIFeedback, true)) {\n      this.#pattern = pattern;\n    }\n  }\n\n  /**\n   * toJSON for cmi.interactions.correct_responses.n\n   * @return {\n   *    {\n   *      pattern: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'pattern': this.pattern,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class for AICC Navigation object\n */\nexport class NAV extends BaseCMI {\n  /**\n   * Constructor for NAV object\n   */\n  constructor() {\n    super();\n  }\n\n  #event = '';\n\n  /**\n   * Getter for #event\n   * @return {string}\n   */\n  get event() {\n    return this.#event;\n  }\n\n  /**\n   * Setter for #event\n   * @param {string} event\n   */\n  set event(event) {\n    if (check12ValidFormat(event, scorm12_regex.NAVEvent)) {\n      this.#event = event;\n    }\n  }\n\n  /**\n   * toJSON for nav object\n   * @return {\n   *    {\n   *      event: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'event': this.event,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n","// @flow\nimport {\n  BaseCMI,\n  checkValidFormat,\n  checkValidRange,\n  CMIArray,\n  CMIScore,\n} from './common';\nimport APIConstants from '../constants/api_constants';\nimport Regex from '../constants/regex';\nimport ErrorCodes from '../constants/error_codes';\nimport Responses from '../constants/response_constants';\nimport {Scorm2004ValidationError} from '../exceptions';\nimport * as Util from '../utilities';\n\nconst scorm2004_constants = APIConstants.scorm2004;\nconst scorm2004_error_codes = ErrorCodes.scorm2004;\nconst learner_responses = Responses.learner;\n\nconst scorm2004_regex = Regex.scorm2004;\n\n/**\n * Helper method for throwing Read Only error\n */\nfunction throwReadOnlyError() {\n  throw new Scorm2004ValidationError(scorm2004_error_codes.READ_ONLY_ELEMENT);\n}\n\n/**\n * Helper method for throwing Write Only error\n */\nfunction throwWriteOnlyError() {\n  throw new Scorm2004ValidationError(scorm2004_error_codes.WRITE_ONLY_ELEMENT);\n}\n\n/**\n * Helper method for throwing Type Mismatch error\n */\nfunction throwTypeMismatchError() {\n  throw new Scorm2004ValidationError(scorm2004_error_codes.TYPE_MISMATCH);\n}\n\n/**\n * Helper method for throwing Dependency Not Established error\n */\nfunction throwDependencyNotEstablishedError() {\n  throw new Scorm2004ValidationError(scorm2004_error_codes.DEPENDENCY_NOT_ESTABLISHED);\n}\n\n/**\n * Helper method for throwing Dependency Not Established error\n */\nfunction throwGeneralSetError() {\n  throw new Scorm2004ValidationError(scorm2004_error_codes.GENERAL_SET_FAILURE);\n}\n\n/**\n * Helper method, no reason to have to pass the same error codes every time\n * @param {*} value\n * @param {string} regexPattern\n * @param {boolean} allowEmptyString\n * @return {boolean}\n */\nfunction check2004ValidFormat(\n    value: String,\n    regexPattern: String,\n    allowEmptyString?: boolean) {\n  return checkValidFormat(\n      value,\n      regexPattern,\n      scorm2004_error_codes.TYPE_MISMATCH,\n      Scorm2004ValidationError,\n      allowEmptyString,\n  );\n}\n\n/**\n * Helper method, no reason to have to pass the same error codes every time\n * @param {*} value\n * @param {string} rangePattern\n * @return {boolean}\n */\nfunction check2004ValidRange(value: any, rangePattern: String) {\n  return checkValidRange(\n      value,\n      rangePattern,\n      scorm2004_error_codes.VALUE_OUT_OF_RANGE,\n      Scorm2004ValidationError,\n  );\n}\n\n/**\n * Class representing cmi object for SCORM 2004\n */\nexport class CMI extends BaseCMI {\n  /**\n   * Constructor for the SCORM 2004 cmi object\n   * @param {boolean} initialized\n   */\n  constructor(initialized: boolean) {\n    super();\n\n    this.learner_preference = new CMILearnerPreference();\n    this.score = new Scorm2004CMIScore();\n    this.comments_from_learner = new CMICommentsFromLearner();\n    this.comments_from_lms = new CMICommentsFromLMS();\n    this.interactions = new CMIInteractions();\n    this.objectives = new CMIObjectives();\n\n    if (initialized) this.initialize();\n  }\n\n  #_version = '1.0';\n  #_children = scorm2004_constants.cmi_children;\n  #completion_status = 'unknown';\n  #completion_threshold = '';\n  #credit = 'credit';\n  #entry = '';\n  #exit = '';\n  #launch_data = '';\n  #learner_id = '';\n  #learner_name = '';\n  #location = '';\n  #max_time_allowed = '';\n  #mode = 'normal';\n  #progress_measure = '';\n  #scaled_passing_score = '';\n  #session_time = 'PT0H0M0S';\n  #success_status = 'unknown';\n  #suspend_data = '';\n  #time_limit_action = 'continue,no message';\n  #total_time = '';\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.learner_preference?.initialize();\n    this.score?.initialize();\n    this.comments_from_learner?.initialize();\n    this.comments_from_lms?.initialize();\n    this.interactions?.initialize();\n    this.objectives?.initialize();\n  }\n\n  /**\n   * Getter for #_version\n   * @return {string}\n   * @private\n   */\n  get _version() {\n    return this.#_version;\n  }\n\n  /**\n   * Setter for #_version. Just throws an error.\n   * @param {string} _version\n   * @private\n   */\n  set _version(_version) {\n    throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #_children\n   * @return {string}\n   * @private\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for #_children. Just throws an error.\n   * @param {number} _children\n   * @private\n   */\n  set _children(_children) {\n    throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #completion_status\n   * @return {string}\n   */\n  get completion_status() {\n    return this.#completion_status;\n  }\n\n  /**\n   * Setter for #completion_status\n   * @param {string} completion_status\n   */\n  set completion_status(completion_status) {\n    if (check2004ValidFormat(completion_status, scorm2004_regex.CMICStatus)) {\n      this.#completion_status = completion_status;\n    }\n  }\n\n  /**\n   * Getter for #completion_threshold\n   * @return {string}\n   */\n  get completion_threshold() {\n    return this.#completion_threshold;\n  }\n\n  /**\n   * Setter for #completion_threshold. Can only be called before  initialization.\n   * @param {string} completion_threshold\n   */\n  set completion_threshold(completion_threshold) {\n    !this.initialized ?\n      this.#completion_threshold = completion_threshold :\n      throwReadOnlyError();\n  }\n\n  /**\n   * Setter for #credit\n   * @return {string}\n   */\n  get credit() {\n    return this.#credit;\n  }\n\n  /**\n   * Setter for #credit. Can only be called before  initialization.\n   * @param {string} credit\n   */\n  set credit(credit) {\n    !this.initialized ? this.#credit = credit : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #entry\n   * @return {string}\n   */\n  get entry() {\n    return this.#entry;\n  }\n\n  /**\n   * Setter for #entry. Can only be called before  initialization.\n   * @param {string} entry\n   */\n  set entry(entry) {\n    !this.initialized ? this.#entry = entry : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #exit. Should only be called during JSON export.\n   * @return {string}\n   */\n  get exit() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#exit;\n  }\n\n  /**\n   * Getter for #exit\n   * @param {string} exit\n   */\n  set exit(exit) {\n    if (check2004ValidFormat(exit, scorm2004_regex.CMIExit, true)) {\n      this.#exit = exit;\n    }\n  }\n\n  /**\n   * Getter for #launch_data\n   * @return {string}\n   */\n  get launch_data() {\n    return this.#launch_data;\n  }\n\n  /**\n   * Setter for #launch_data. Can only be called before  initialization.\n   * @param {string} launch_data\n   */\n  set launch_data(launch_data) {\n    !this.initialized ? this.#launch_data = launch_data : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #learner_id\n   * @return {string}\n   */\n  get learner_id() {\n    return this.#learner_id;\n  }\n\n  /**\n   * Setter for #learner_id. Can only be called before  initialization.\n   * @param {string} learner_id\n   */\n  set learner_id(learner_id) {\n    !this.initialized ? this.#learner_id = learner_id : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #learner_name\n   * @return {string}\n   */\n  get learner_name() {\n    return this.#learner_name;\n  }\n\n  /**\n   * Setter for #learner_name. Can only be called before  initialization.\n   * @param {string} learner_name\n   */\n  set learner_name(learner_name) {\n    !this.initialized ?\n      this.#learner_name = learner_name :\n      throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #location\n   * @return {string}\n   */\n  get location() {\n    return this.#location;\n  }\n\n  /**\n   * Setter for #location\n   * @param {string} location\n   */\n  set location(location) {\n    if (check2004ValidFormat(location, scorm2004_regex.CMIString1000)) {\n      this.#location = location;\n    }\n  }\n\n  /**\n   * Getter for #max_time_allowed\n   * @return {string}\n   */\n  get max_time_allowed() {\n    return this.#max_time_allowed;\n  }\n\n  /**\n   * Setter for #max_time_allowed. Can only be called before  initialization.\n   * @param {string} max_time_allowed\n   */\n  set max_time_allowed(max_time_allowed) {\n    !this.initialized ?\n      this.#max_time_allowed = max_time_allowed :\n      throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #mode\n   * @return {string}\n   */\n  get mode() {\n    return this.#mode;\n  }\n\n  /**\n   * Setter for #mode. Can only be called before  initialization.\n   * @param {string} mode\n   */\n  set mode(mode) {\n    !this.initialized ? this.#mode = mode : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #progress_measure\n   * @return {string}\n   */\n  get progress_measure() {\n    return this.#progress_measure;\n  }\n\n  /**\n   * Setter for #progress_measure\n   * @param {string} progress_measure\n   */\n  set progress_measure(progress_measure) {\n    if (check2004ValidFormat(progress_measure, scorm2004_regex.CMIDecimal) &&\n      check2004ValidRange(progress_measure, scorm2004_regex.progress_range)) {\n      this.#progress_measure = progress_measure;\n    }\n  }\n\n  /**\n   * Getter for #scaled_passing_score\n   * @return {string}\n   */\n  get scaled_passing_score() {\n    return this.#scaled_passing_score;\n  }\n\n  /**\n   * Setter for #scaled_passing_score. Can only be called before  initialization.\n   * @param {string} scaled_passing_score\n   */\n  set scaled_passing_score(scaled_passing_score) {\n    !this.initialized ?\n      this.#scaled_passing_score = scaled_passing_score :\n      throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #session_time. Should only be called during JSON export.\n   * @return {string}\n   */\n  get session_time() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#session_time;\n  }\n\n  /**\n   * Setter for #session_time\n   * @param {string} session_time\n   */\n  set session_time(session_time) {\n    if (check2004ValidFormat(session_time, scorm2004_regex.CMITimespan)) {\n      this.#session_time = session_time;\n    }\n  }\n\n  /**\n   * Getter for #success_status\n   * @return {string}\n   */\n  get success_status() {\n    return this.#success_status;\n  }\n\n  /**\n   * Setter for #success_status\n   * @param {string} success_status\n   */\n  set success_status(success_status) {\n    if (check2004ValidFormat(success_status, scorm2004_regex.CMISStatus)) {\n      this.#success_status = success_status;\n    }\n  }\n\n  /**\n   * Getter for #suspend_data\n   * @return {string}\n   */\n  get suspend_data() {\n    return this.#suspend_data;\n  }\n\n  /**\n   * Setter for #suspend_data\n   * @param {string} suspend_data\n   */\n  set suspend_data(suspend_data) {\n    if (check2004ValidFormat(suspend_data, scorm2004_regex.CMIString64000,\n        true)) {\n      this.#suspend_data = suspend_data;\n    }\n  }\n\n  /**\n   * Getter for #time_limit_action\n   * @return {string}\n   */\n  get time_limit_action() {\n    return this.#time_limit_action;\n  }\n\n  /**\n   * Setter for #time_limit_action. Can only be called before  initialization.\n   * @param {string} time_limit_action\n   */\n  set time_limit_action(time_limit_action) {\n    !this.initialized ?\n      this.#time_limit_action = time_limit_action :\n      throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #total_time\n   * @return {string}\n   */\n  get total_time() {\n    return this.#total_time;\n  }\n\n  /**\n   * Setter for #total_time. Can only be called before  initialization.\n   * @param {string} total_time\n   */\n  set total_time(total_time) {\n    !this.initialized ? this.#total_time = total_time : throwReadOnlyError();\n  }\n\n  /**\n   * Adds the current session time to the existing total time.\n   *\n   * @return {string} ISO8601 Duration\n   */\n  getCurrentTotalTime() {\n    let sessionTime = this.#session_time;\n    const startTime = this.start_time;\n\n    if (typeof startTime !== 'undefined' && startTime !== null) {\n      const seconds = new Date().getTime() - startTime;\n      sessionTime = Util.getSecondsAsISODuration(seconds / 1000);\n    }\n\n    return Util.addTwoDurations(\n        this.#total_time,\n        sessionTime,\n        scorm2004_regex.CMITimespan,\n    );\n  }\n\n  /**\n   * toJSON for cmi\n   *\n   * @return {\n   *    {\n   *      comments_from_learner: CMICommentsFromLearner,\n   *      comments_from_lms: CMICommentsFromLMS,\n   *      completion_status: string,\n   *      completion_threshold: string,\n   *      credit: string,\n   *      entry: string,\n   *      exit: string,\n   *      interactions: CMIInteractions,\n   *      launch_data: string,\n   *      learner_id: string,\n   *      learner_name: string,\n   *      learner_preference: CMILearnerPreference,\n   *      location: string,\n   *      max_time_allowed: string,\n   *      mode: string,\n   *      objectives: CMIObjectives,\n   *      progress_measure: string,\n   *      scaled_passing_score: string,\n   *      score: Scorm2004CMIScore,\n   *      session_time: string,\n   *      success_status: string,\n   *      suspend_data: string,\n   *      time_limit_action: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'comments_from_learner': this.comments_from_learner,\n      'comments_from_lms': this.comments_from_lms,\n      'completion_status': this.completion_status,\n      'completion_threshold': this.completion_threshold,\n      'credit': this.credit,\n      'entry': this.entry,\n      'exit': this.exit,\n      'interactions': this.interactions,\n      'launch_data': this.launch_data,\n      'learner_id': this.learner_id,\n      'learner_name': this.learner_name,\n      'learner_preference': this.learner_preference,\n      'location': this.location,\n      'max_time_allowed': this.max_time_allowed,\n      'mode': this.mode,\n      'objectives': this.objectives,\n      'progress_measure': this.progress_measure,\n      'scaled_passing_score': this.scaled_passing_score,\n      'score': this.score,\n      'session_time': this.session_time,\n      'success_status': this.success_status,\n      'suspend_data': this.suspend_data,\n      'time_limit_action': this.time_limit_action,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class for SCORM 2004's cmi.learner_preference object\n */\nclass CMILearnerPreference extends BaseCMI {\n  #_children = scorm2004_constants.student_preference_children;\n  #audio_level = '1';\n  #language = '';\n  #delivery_speed = '1';\n  #audio_captioning = '0';\n\n  /**\n   * Constructor for cmi.learner_preference\n   */\n  constructor() {\n    super();\n  }\n\n  /**\n   * Getter for #_children\n   * @return {string}\n   * @private\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for #_children. Just throws an error.\n   * @param {string} _children\n   * @private\n   */\n  set _children(_children) {\n    throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #audio_level\n   * @return {string}\n   */\n  get audio_level() {\n    return this.#audio_level;\n  }\n\n  /**\n   * Setter for #audio_level\n   * @param {string} audio_level\n   */\n  set audio_level(audio_level) {\n    if (check2004ValidFormat(audio_level, scorm2004_regex.CMIDecimal) &&\n      check2004ValidRange(audio_level, scorm2004_regex.audio_range)) {\n      this.#audio_level = audio_level;\n    }\n  }\n\n  /**\n   * Getter for #language\n   * @return {string}\n   */\n  get language() {\n    return this.#language;\n  }\n\n  /**\n   * Setter for #language\n   * @param {string} language\n   */\n  set language(language) {\n    if (check2004ValidFormat(language, scorm2004_regex.CMILang)) {\n      this.#language = language;\n    }\n  }\n\n  /**\n   * Getter for #delivery_speed\n   * @return {string}\n   */\n  get delivery_speed() {\n    return this.#delivery_speed;\n  }\n\n  /**\n   * Setter for #delivery_speed\n   * @param {string} delivery_speed\n   */\n  set delivery_speed(delivery_speed) {\n    if (check2004ValidFormat(delivery_speed, scorm2004_regex.CMIDecimal) &&\n      check2004ValidRange(delivery_speed, scorm2004_regex.speed_range)) {\n      this.#delivery_speed = delivery_speed;\n    }\n  }\n\n  /**\n   * Getter for #audio_captioning\n   * @return {string}\n   */\n  get audio_captioning() {\n    return this.#audio_captioning;\n  }\n\n  /**\n   * Setter for #audio_captioning\n   * @param {string} audio_captioning\n   */\n  set audio_captioning(audio_captioning) {\n    if (check2004ValidFormat(audio_captioning, scorm2004_regex.CMISInteger) &&\n      check2004ValidRange(audio_captioning, scorm2004_regex.text_range)) {\n      this.#audio_captioning = audio_captioning;\n    }\n  }\n\n  /**\n   * toJSON for cmi.learner_preference\n   *\n   * @return {\n   *    {\n   *      audio_level: string,\n   *      language: string,\n   *      delivery_speed: string,\n   *      audio_captioning: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'audio_level': this.audio_level,\n      'language': this.language,\n      'delivery_speed': this.delivery_speed,\n      'audio_captioning': this.audio_captioning,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 2004's cmi.interactions object\n */\nclass CMIInteractions extends CMIArray {\n  /**\n   * Constructor for cmi.objectives Array\n   */\n  constructor() {\n    super({\n      children: scorm2004_constants.interactions_children,\n      errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n      errorClass: Scorm2004ValidationError,\n    });\n  }\n}\n\n/**\n * Class representing SCORM 2004's cmi.objectives object\n */\nclass CMIObjectives extends CMIArray {\n  /**\n   * Constructor for cmi.objectives Array\n   */\n  constructor() {\n    super({\n      children: scorm2004_constants.objectives_children,\n      errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n      errorClass: Scorm2004ValidationError,\n    });\n  }\n}\n\n/**\n * Class representing SCORM 2004's cmi.comments_from_lms object\n */\nclass CMICommentsFromLMS extends CMIArray {\n  /**\n   * Constructor for cmi.comments_from_lms Array\n   */\n  constructor() {\n    super({\n      children: scorm2004_constants.comments_children,\n      errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n      errorClass: Scorm2004ValidationError,\n    });\n  }\n}\n\n/**\n * Class representing SCORM 2004's cmi.comments_from_learner object\n */\nclass CMICommentsFromLearner extends CMIArray {\n  /**\n   * Constructor for cmi.comments_from_learner Array\n   */\n  constructor() {\n    super({\n      children: scorm2004_constants.comments_children,\n      errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n      errorClass: Scorm2004ValidationError,\n    });\n  }\n}\n\n/**\n * Class for SCORM 2004's cmi.interaction.n object\n */\nexport class CMIInteractionsObject extends BaseCMI {\n  #id = '';\n  #type = '';\n  #timestamp = '';\n  #weighting = '';\n  #learner_response = '';\n  #result = '';\n  #latency = '';\n  #description = '';\n\n  /**\n   * Constructor for cmi.interaction.n\n   */\n  constructor() {\n    super();\n\n    this.objectives = new CMIArray({\n      errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n      errorClass: Scorm2004ValidationError,\n      children: scorm2004_constants.objectives_children,\n    });\n    this.correct_responses = new CMIArray({\n      errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n      errorClass: Scorm2004ValidationError,\n      children: scorm2004_constants.correct_responses_children,\n    });\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.objectives?.initialize();\n    this.correct_responses?.initialize();\n  }\n\n  /**\n   * Getter for #id\n   * @return {string}\n   */\n  get id() {\n    return this.#id;\n  }\n\n  /**\n   * Setter for #id\n   * @param {string} id\n   */\n  set id(id) {\n    if (check2004ValidFormat(id, scorm2004_regex.CMILongIdentifier)) {\n      this.#id = id;\n    }\n  }\n\n  /**\n   * Getter for #type\n   * @return {string}\n   */\n  get type() {\n    return this.#type;\n  }\n\n  /**\n   * Setter for #type\n   * @param {string} type\n   */\n  set type(type) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(type, scorm2004_regex.CMIType)) {\n        this.#type = type;\n      }\n    }\n  }\n\n  /**\n   * Getter for #timestamp\n   * @return {string}\n   */\n  get timestamp() {\n    return this.#timestamp;\n  }\n\n  /**\n   * Setter for #timestamp\n   * @param {string} timestamp\n   */\n  set timestamp(timestamp) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(timestamp, scorm2004_regex.CMITime)) {\n        this.#timestamp = timestamp;\n      }\n    }\n  }\n\n  /**\n   * Getter for #weighting\n   * @return {string}\n   */\n  get weighting() {\n    return this.#weighting;\n  }\n\n  /**\n   * Setter for #weighting\n   * @param {string} weighting\n   */\n  set weighting(weighting) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(weighting, scorm2004_regex.CMIDecimal)) {\n        this.#weighting = weighting;\n      }\n    }\n  }\n\n  /**\n   * Getter for #learner_response\n   * @return {string}\n   */\n  get learner_response() {\n    return this.#learner_response;\n  }\n\n  /**\n   * Setter for #learner_response. Does type validation to make sure response\n   * matches SCORM 2004's spec\n   * @param {string} learner_response\n   */\n  set learner_response(learner_response) {\n    if (this.initialized && (this.#type === '' || this.#id === '')) {\n      throwDependencyNotEstablishedError();\n    } else {\n      let nodes = [];\n      const response_type = learner_responses[this.type];\n      if (response_type) {\n        if (response_type?.delimiter) {\n          nodes = learner_response.split(response_type.delimiter);\n        } else {\n          nodes[0] = learner_response;\n        }\n\n        if ((nodes.length > 0) && (nodes.length <= response_type.max)) {\n          const formatRegex = new RegExp(response_type.format);\n          for (let i = 0; i < nodes.length; i++) {\n            if (response_type?.delimiter2) {\n              const values = nodes[i].split(response_type.delimiter2);\n              if (values.length === 2) {\n                if (!values[0].match(formatRegex)) {\n                  throwTypeMismatchError();\n                } else {\n                  if (!values[1].match(new RegExp(response_type.format2))) {\n                    throwTypeMismatchError();\n                  }\n                }\n              } else {\n                throwTypeMismatchError();\n              }\n            } else {\n              if (!nodes[i].match(formatRegex)) {\n                throwTypeMismatchError();\n              } else {\n                if (nodes[i] !== '' && response_type.unique) {\n                  for (let j = 0; j < i; j++) {\n                    if (nodes[i] === nodes[j]) {\n                      throwTypeMismatchError();\n                    }\n                  }\n                }\n              }\n            }\n          }\n        } else {\n          throwGeneralSetError();\n        }\n\n        this.#learner_response = learner_response;\n      } else {\n        throwTypeMismatchError();\n      }\n    }\n  }\n\n  /**\n   * Getter for #result\n   * @return {string}\n   */\n  get result() {\n    return this.#result;\n  }\n\n  /**\n   * Setter for #result\n   * @param {string} result\n   */\n  set result(result) {\n    if (check2004ValidFormat(result, scorm2004_regex.CMIResult)) {\n      this.#result = result;\n    }\n  }\n\n  /**\n   * Getter for #latency\n   * @return {string}\n   */\n  get latency() {\n    return this.#latency;\n  }\n\n  /**\n   * Setter for #latency\n   * @param {string} latency\n   */\n  set latency(latency) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(latency, scorm2004_regex.CMITimespan)) {\n        this.#latency = latency;\n      }\n    }\n  }\n\n  /**\n   * Getter for #description\n   * @return {string}\n   */\n  get description() {\n    return this.#description;\n  }\n\n  /**\n   * Setter for #description\n   * @param {string} description\n   */\n  set description(description) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(description, scorm2004_regex.CMILangString250,\n          true)) {\n        this.#description = description;\n      }\n    }\n  }\n\n  /**\n   * toJSON for cmi.interactions.n\n   *\n   * @return {\n   *    {\n   *      id: string,\n   *      type: string,\n   *      objectives: CMIArray,\n   *      timestamp: string,\n   *      correct_responses: CMIArray,\n   *      weighting: string,\n   *      learner_response: string,\n   *      result: string,\n   *      latency: string,\n   *      description: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'id': this.id,\n      'type': this.type,\n      'objectives': this.objectives,\n      'timestamp': this.timestamp,\n      'weighting': this.weighting,\n      'learner_response': this.learner_response,\n      'result': this.result,\n      'latency': this.latency,\n      'description': this.description,\n      'correct_responses': this.correct_responses,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class for SCORM 2004's cmi.objectives.n object\n */\nexport class CMIObjectivesObject extends BaseCMI {\n  #id = '';\n  #success_status = 'unknown';\n  #completion_status = 'unknown';\n  #progress_measure = '';\n  #description = '';\n\n  /**\n   * Constructor for cmi.objectives.n\n   */\n  constructor() {\n    super();\n\n    this.score = new Scorm2004CMIScore();\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.score?.initialize();\n  }\n\n  /**\n   * Getter for #id\n   * @return {string}\n   */\n  get id() {\n    return this.#id;\n  }\n\n  /**\n   * Setter for #id\n   * @param {string} id\n   */\n  set id(id) {\n    if (check2004ValidFormat(id, scorm2004_regex.CMILongIdentifier)) {\n      this.#id = id;\n    }\n  }\n\n  /**\n   * Getter for #success_status\n   * @return {string}\n   */\n  get success_status() {\n    return this.#success_status;\n  }\n\n  /**\n   * Setter for #success_status\n   * @param {string} success_status\n   */\n  set success_status(success_status) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(success_status, scorm2004_regex.CMISStatus)) {\n        this.#success_status = success_status;\n      }\n    }\n  }\n\n  /**\n   * Getter for #completion_status\n   * @return {string}\n   */\n  get completion_status() {\n    return this.#completion_status;\n  }\n\n  /**\n   * Setter for #completion_status\n   * @param {string} completion_status\n   */\n  set completion_status(completion_status) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(completion_status, scorm2004_regex.CMICStatus)) {\n        this.#completion_status = completion_status;\n      }\n    }\n  }\n\n  /**\n   * Getter for #progress_measure\n   * @return {string}\n   */\n  get progress_measure() {\n    return this.#progress_measure;\n  }\n\n  /**\n   * Setter for #progress_measure\n   * @param {string} progress_measure\n   */\n  set progress_measure(progress_measure) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(progress_measure, scorm2004_regex.CMIDecimal) &&\n        check2004ValidRange(progress_measure,\n            scorm2004_regex.progress_range)) {\n        this.#progress_measure = progress_measure;\n      }\n    }\n  }\n\n  /**\n   * Getter for #description\n   * @return {string}\n   */\n  get description() {\n    return this.#description;\n  }\n\n  /**\n   * Setter for #description\n   * @param {string} description\n   */\n  set description(description) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(description, scorm2004_regex.CMILangString250,\n          true)) {\n        this.#description = description;\n      }\n    }\n  }\n\n  /**\n   * toJSON for cmi.objectives.n\n   *\n   * @return {\n   *    {\n   *      id: string,\n   *      success_status: string,\n   *      completion_status: string,\n   *      progress_measure: string,\n   *      description: string,\n   *      score: Scorm2004CMIScore\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'id': this.id,\n      'success_status': this.success_status,\n      'completion_status': this.completion_status,\n      'progress_measure': this.progress_measure,\n      'description': this.description,\n      'score': this.score,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class for SCORM 2004's cmi *.score object\n */\nclass Scorm2004CMIScore extends CMIScore {\n  #scaled = '';\n\n  /**\n   * Constructor for cmi *.score\n   */\n  constructor() {\n    super(\n        {\n          score_children: scorm2004_constants.score_children,\n          max: '',\n          invalidErrorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n          invalidTypeCode: scorm2004_error_codes.TYPE_MISMATCH,\n          invalidRangeCode: scorm2004_error_codes.VALUE_OUT_OF_RANGE,\n          decimalRegex: scorm2004_regex.CMIDecimal,\n          errorClass: Scorm2004ValidationError,\n        });\n  }\n\n  /**\n   * Getter for #scaled\n   * @return {string}\n   */\n  get scaled() {\n    return this.#scaled;\n  }\n\n  /**\n   * Setter for #scaled\n   * @param {string} scaled\n   */\n  set scaled(scaled) {\n    if (check2004ValidFormat(scaled, scorm2004_regex.CMIDecimal) &&\n      check2004ValidRange(scaled, scorm2004_regex.scaled_range)) {\n      this.#scaled = scaled;\n    }\n  }\n\n  /**\n   * toJSON for cmi *.score\n   *\n   * @return {\n   *    {\n   *      scaled: string,\n   *      raw: string,\n   *      min: string,\n   *      max: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'scaled': this.scaled,\n      'raw': super.raw,\n      'min': super.min,\n      'max': super.max,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 2004's cmi.comments_from_learner.n and cmi.comments_from_lms.n object\n */\nexport class CMICommentsObject extends BaseCMI {\n  #comment = '';\n  #location = '';\n  #timestamp = '';\n  #readOnlyAfterInit;\n\n  /**\n   * Constructor for cmi.comments_from_learner.n and cmi.comments_from_lms.n\n   * @param {boolean} readOnlyAfterInit\n   */\n  constructor(readOnlyAfterInit = false) {\n    super();\n    this.#comment = '';\n    this.#location = '';\n    this.#timestamp = '';\n    this.#readOnlyAfterInit = readOnlyAfterInit;\n  }\n\n  /**\n   * Getter for #comment\n   * @return {string}\n   */\n  get comment() {\n    return this.#comment;\n  }\n\n  /**\n   * Setter for #comment\n   * @param {string} comment\n   */\n  set comment(comment) {\n    if (this.initialized && this.#readOnlyAfterInit) {\n      throwReadOnlyError();\n    } else {\n      if (check2004ValidFormat(comment, scorm2004_regex.CMILangString4000,\n          true)) {\n        this.#comment = comment;\n      }\n    }\n  }\n\n  /**\n   * Getter for #location\n   * @return {string}\n   */\n  get location() {\n    return this.#location;\n  }\n\n  /**\n   * Setter for #location\n   * @param {string} location\n   */\n  set location(location) {\n    if (this.initialized && this.#readOnlyAfterInit) {\n      throwReadOnlyError();\n    } else {\n      if (check2004ValidFormat(location, scorm2004_regex.CMIString250)) {\n        this.#location = location;\n      }\n    }\n  }\n\n  /**\n   * Getter for #timestamp\n   * @return {string}\n   */\n  get timestamp() {\n    return this.#timestamp;\n  }\n\n  /**\n   * Setter for #timestamp\n   * @param {string} timestamp\n   */\n  set timestamp(timestamp) {\n    if (this.initialized && this.#readOnlyAfterInit) {\n      throwReadOnlyError();\n    } else {\n      if (check2004ValidFormat(timestamp, scorm2004_regex.CMITime)) {\n        this.#timestamp = timestamp;\n      }\n    }\n  }\n\n  /**\n   * toJSON for cmi.comments_from_learner.n object\n   * @return {\n   *    {\n   *      comment: string,\n   *      location: string,\n   *      timestamp: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'comment': this.comment,\n      'location': this.location,\n      'timestamp': this.timestamp,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 2004's cmi.interactions.n.objectives.n object\n */\nexport class CMIInteractionsObjectivesObject extends BaseCMI {\n  #id = '';\n\n  /**\n   * Constructor for cmi.interactions.n.objectives.n\n   */\n  constructor() {\n    super();\n  }\n\n  /**\n   * Getter for #id\n   * @return {string}\n   */\n  get id() {\n    return this.#id;\n  }\n\n  /**\n   * Setter for #id\n   * @param {string} id\n   */\n  set id(id) {\n    if (check2004ValidFormat(id, scorm2004_regex.CMILongIdentifier)) {\n      this.#id = id;\n    }\n  }\n\n  /**\n   * toJSON for cmi.interactions.n.objectives.n\n   * @return {\n   *    {\n   *      id: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'id': this.id,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 2004's cmi.interactions.n.correct_responses.n object\n */\nexport class CMIInteractionsCorrectResponsesObject extends BaseCMI {\n  #pattern = '';\n\n  /**\n   * Constructor for cmi.interactions.n.correct_responses.n\n   */\n  constructor() {\n    super();\n  }\n\n  /**\n   * Getter for #pattern\n   * @return {string}\n   */\n  get pattern() {\n    return this.#pattern;\n  }\n\n  /**\n   * Setter for #pattern\n   * @param {string} pattern\n   */\n  set pattern(pattern) {\n    if (check2004ValidFormat(pattern, scorm2004_regex.CMIFeedback)) {\n      this.#pattern = pattern;\n    }\n  }\n\n  /**\n   * toJSON cmi.interactions.n.correct_responses.n object\n   * @return {\n   *    {\n   *      pattern: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'pattern': this.pattern,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 2004's adl object\n */\nexport class ADL extends BaseCMI {\n  /**\n   * Constructor for adl\n   */\n  constructor() {\n    super();\n\n    this.nav = new ADLNav();\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.nav?.initialize();\n  }\n\n  /**\n   * toJSON for adl\n   * @return {\n   *    {\n   *      nav: {\n   *        request: string\n   *      }\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'nav': this.nav,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 2004's adl.nav object\n */\nclass ADLNav extends BaseCMI {\n  #request = '_none_';\n\n  /**\n   * Constructor for adl.nav\n   */\n  constructor() {\n    super();\n\n    this.request_valid = new ADLNavRequestValid();\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.request_valid?.initialize();\n  }\n\n  /**\n   * Getter for #request\n   * @return {string}\n   */\n  get request() {\n    return this.#request;\n  }\n\n  /**\n   * Setter for #request\n   * @param {string} request\n   */\n  set request(request) {\n    if (check2004ValidFormat(request, scorm2004_regex.NAVEvent)) {\n      this.#request = request;\n    }\n  }\n\n  /**\n   * toJSON for adl.nav\n   *\n   * @return {\n   *    {\n   *      request: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'request': this.request,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 2004's adl.nav.request_valid object\n */\nclass ADLNavRequestValid extends BaseCMI {\n  #continue = 'unknown';\n  #previous = 'unknown';\n  choice = class {\n    /**\n     * Check if target is valid\n     * @param {*} _target\n     * @return {string}\n     */\n    _isTargetValid = (_target) => 'unknown';\n  };\n  jump = class {\n    /**\n     * Check if target is valid\n     * @param {*} _target\n     * @return {string}\n     */\n    _isTargetValid = (_target) => 'unknown';\n  };\n\n  /**\n   * Constructor for adl.nav.request_valid\n   */\n  constructor() {\n    super();\n  }\n\n  /**\n   * Getter for #continue\n   * @return {string}\n   */\n  get continue() {\n    return this.#continue;\n  }\n\n  /**\n   * Setter for #continue. Just throws an error.\n   * @param {*} _\n   */\n  set continue(_) {\n    throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #previous\n   * @return {string}\n   */\n  get previous() {\n    return this.#previous;\n  }\n\n  /**\n   * Setter for #previous. Just throws an error.\n   * @param {*} _\n   */\n  set previous(_) {\n    throwReadOnlyError();\n  }\n\n  /**\n   * toJSON for adl.nav.request_valid\n   *\n   * @return {\n   *    {\n   *      previous: string,\n   *      continue: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'previous': this.previous,\n      'continue': this.continue,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n","// @flow\n\nconst global = {\n  SCORM_TRUE: 'true',\n  SCORM_FALSE: 'false',\n  STATE_NOT_INITIALIZED: 0,\n  STATE_INITIALIZED: 1,\n  STATE_TERMINATED: 2,\n  LOG_LEVEL_DEBUG: 1,\n  LOG_LEVEL_INFO: 2,\n  LOG_LEVEL_WARNING: 3,\n  LOG_LEVEL_ERROR: 4,\n  LOG_LEVEL_NONE: 5,\n};\n\nconst scorm12 = {\n  // Children lists\n  cmi_children: 'core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions',\n  core_children: 'student_id,student_name,lesson_location,credit,lesson_status,entry,score,total_time,lesson_mode,exit,session_time',\n  score_children: 'raw,min,max',\n  comments_children: 'content,location,time',\n  objectives_children: 'id,score,status',\n  correct_responses_children: 'pattern',\n  student_data_children: 'mastery_score,max_time_allowed,time_limit_action',\n  student_preference_children: 'audio,language,speed,text',\n  interactions_children: 'id,objectives,time,type,correct_responses,weighting,student_response,result,latency',\n\n  error_descriptions: {\n    '101': {\n      basicMessage: 'General Exception',\n      detailMessage: 'No specific error code exists to describe the error. Use LMSGetDiagnostic for more information',\n    },\n    '201': {\n      basicMessage: 'Invalid argument error',\n      detailMessage: 'Indicates that an argument represents an invalid data model element or is otherwise incorrect.',\n    },\n    '202': {\n      basicMessage: 'Element cannot have children',\n      detailMessage: 'Indicates that LMSGetValue was called with a data model element name that ends in \"_children\" for a data model element that does not support the \"_children\" suffix.',\n    },\n    '203': {\n      basicMessage: 'Element not an array - cannot have count',\n      detailMessage: 'Indicates that LMSGetValue was called with a data model element name that ends in \"_count\" for a data model element that does not support the \"_count\" suffix.',\n    },\n    '301': {\n      basicMessage: 'Not initialized',\n      detailMessage: 'Indicates that an API call was made before the call to lmsInitialize.',\n    },\n    '401': {\n      basicMessage: 'Not implemented error',\n      detailMessage: 'The data model element indicated in a call to LMSGetValue or LMSSetValue is valid, but was not implemented by this LMS. SCORM 1.2 defines a set of data model elements as being optional for an LMS to implement.',\n    },\n    '402': {\n      basicMessage: 'Invalid set value, element is a keyword',\n      detailMessage: 'Indicates that LMSSetValue was called on a data model element that represents a keyword (elements that end in \"_children\" and \"_count\").',\n    },\n    '403': {\n      basicMessage: 'Element is read only',\n      detailMessage: 'LMSSetValue was called with a data model element that can only be read.',\n    },\n    '404': {\n      basicMessage: 'Element is write only',\n      detailMessage: 'LMSGetValue was called on a data model element that can only be written to.',\n    },\n    '405': {\n      basicMessage: 'Incorrect Data Type',\n      detailMessage: 'LMSSetValue was called with a value that is not consistent with the data format of the supplied data model element.',\n    },\n    '407': {\n      basicMessage: 'Element Value Out Of Range',\n      detailMessage: 'The numeric value supplied to a LMSSetValue call is outside of the numeric range allowed for the supplied data model element.',\n    },\n    '408': {\n      basicMessage: 'Data Model Dependency Not Established',\n      detailMessage: 'Some data model elements cannot be set until another data model element was set. This error condition indicates that the prerequisite element was not set before the dependent element.',\n    },\n  },\n};\n\nconst aicc = {\n  ...scorm12, ...{\n    cmi_children: 'core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions,evaluation',\n    student_preference_children: 'audio,language,lesson_type,speed,text,text_color,text_location,text_size,video,windows',\n    student_data_children: 'attempt_number,tries,mastery_score,max_time_allowed,time_limit_action',\n    student_demographics_children: 'city,class,company,country,experience,familiar_name,instructor_name,title,native_language,state,street_address,telephone,years_experience',\n    tries_children: 'time,status,score',\n    attempt_records_children: 'score,lesson_status',\n    paths_children: 'location_id,date,time,status,why_left,time_in_element',\n  },\n};\n\nconst scorm2004 = {\n  // Children lists\n  cmi_children: '_version,comments_from_learner,comments_from_lms,completion_status,credit,entry,exit,interactions,launch_data,learner_id,learner_name,learner_preference,location,max_time_allowed,mode,objectives,progress_measure,scaled_passing_score,score,session_time,success_status,suspend_data,time_limit_action,total_time',\n  comments_children: 'comment,timestamp,location',\n  score_children: 'max,raw,scaled,min',\n  objectives_children: 'progress_measure,completion_status,success_status,description,score,id',\n  correct_responses_children: 'pattern',\n  student_data_children: 'mastery_score,max_time_allowed,time_limit_action',\n  student_preference_children: 'audio_level,audio_captioning,delivery_speed,language',\n  interactions_children: 'id,type,objectives,timestamp,correct_responses,weighting,learner_response,result,latency,description',\n\n  error_descriptions: {\n    '0': {\n      basicMessage: 'No Error',\n      detailMessage: 'No error occurred, the previous API call was successful.',\n    },\n    '101': {\n      basicMessage: 'General Exception',\n      detailMessage: 'No specific error code exists to describe the error. Use GetDiagnostic for more information.',\n    },\n    '102': {\n      basicMessage: 'General Initialization Failure',\n      detailMessage: 'Call to Initialize failed for an unknown reason.',\n    },\n    '103': {\n      basicMessage: 'Already Initialized',\n      detailMessage: 'Call to Initialize failed because Initialize was already called.',\n    },\n    '104': {\n      basicMessage: 'Content Instance Terminated',\n      detailMessage: 'Call to Initialize failed because Terminate was already called.',\n    },\n    '111': {\n      basicMessage: 'General Termination Failure',\n      detailMessage: 'Call to Terminate failed for an unknown reason.',\n    },\n    '112': {\n      basicMessage: 'Termination Before Initialization',\n      detailMessage: 'Call to Terminate failed because it was made before the call to Initialize.',\n    },\n    '113': {\n      basicMessage: 'Termination After Termination',\n      detailMessage: 'Call to Terminate failed because Terminate was already called.',\n    },\n    '122': {\n      basicMessage: 'Retrieve Data Before Initialization',\n      detailMessage: 'Call to GetValue failed because it was made before the call to Initialize.',\n    },\n    '123': {\n      basicMessage: 'Retrieve Data After Termination',\n      detailMessage: 'Call to GetValue failed because it was made after the call to Terminate.',\n    },\n    '132': {\n      basicMessage: 'Store Data Before Initialization',\n      detailMessage: 'Call to SetValue failed because it was made before the call to Initialize.',\n    },\n    '133': {\n      basicMessage: 'Store Data After Termination',\n      detailMessage: 'Call to SetValue failed because it was made after the call to Terminate.',\n    },\n    '142': {\n      basicMessage: 'Commit Before Initialization',\n      detailMessage: 'Call to Commit failed because it was made before the call to Initialize.',\n    },\n    '143': {\n      basicMessage: 'Commit After Termination',\n      detailMessage: 'Call to Commit failed because it was made after the call to Terminate.',\n    },\n    '201': {\n      basicMessage: 'General Argument Error',\n      detailMessage: 'An invalid argument was passed to an API method (usually indicates that Initialize, Commit or Terminate did not receive the expected empty string argument.',\n    },\n    '301': {\n      basicMessage: 'General Get Failure',\n      detailMessage: 'Indicates a failed GetValue call where no other specific error code is applicable. Use GetDiagnostic for more information.',\n    },\n    '351': {\n      basicMessage: 'General Set Failure',\n      detailMessage: 'Indicates a failed SetValue call where no other specific error code is applicable. Use GetDiagnostic for more information.',\n    },\n    '391': {\n      basicMessage: 'General Commit Failure',\n      detailMessage: 'Indicates a failed Commit call where no other specific error code is applicable. Use GetDiagnostic for more information.',\n    },\n    '401': {\n      basicMessage: 'Undefined Data Model Element',\n      detailMessage: 'The data model element name passed to GetValue or SetValue is not a valid SCORM data model element.',\n    },\n    '402': {\n      basicMessage: 'Unimplemented Data Model Element',\n      detailMessage: 'The data model element indicated in a call to GetValue or SetValue is valid, but was not implemented by this LMS. In SCORM 2004, this error would indicate an LMS that is not fully SCORM conformant.',\n    },\n    '403': {\n      basicMessage: 'Data Model Element Value Not Initialized',\n      detailMessage: 'Attempt to read a data model element that has not been initialized by the LMS or through a SetValue call. This error condition is often reached during normal execution of a SCO.',\n    },\n    '404': {\n      basicMessage: 'Data Model Element Is Read Only',\n      detailMessage: 'SetValue was called with a data model element that can only be read.',\n    },\n    '405': {\n      basicMessage: 'Data Model Element Is Write Only',\n      detailMessage: 'GetValue was called on a data model element that can only be written to.',\n    },\n    '406': {\n      basicMessage: 'Data Model Element Type Mismatch',\n      detailMessage: 'SetValue was called with a value that is not consistent with the data format of the supplied data model element.',\n    },\n    '407': {\n      basicMessage: 'Data Model Element Value Out Of Range',\n      detailMessage: 'The numeric value supplied to a SetValue call is outside of the numeric range allowed for the supplied data model element.',\n    },\n    '408': {\n      basicMessage: 'Data Model Dependency Not Established',\n      detailMessage: 'Some data model elements cannot be set until another data model element was set. This error condition indicates that the prerequisite element was not set before the dependent element.',\n    },\n  },\n};\n\nconst APIConstants = {\n  global: global,\n  scorm12: scorm12,\n  aicc: aicc,\n  scorm2004: scorm2004,\n};\n\nexport default APIConstants;\n","// @flow\nconst global = {\n  GENERAL: 101,\n  INITIALIZATION_FAILED: 101,\n  INITIALIZED: 101,\n  TERMINATED: 101,\n  TERMINATION_FAILURE: 101,\n  TERMINATION_BEFORE_INIT: 101,\n  MULTIPLE_TERMINATION: 101,\n  RETRIEVE_BEFORE_INIT: 101,\n  RETRIEVE_AFTER_TERM: 101,\n  STORE_BEFORE_INIT: 101,\n  STORE_AFTER_TERM: 101,\n  COMMIT_BEFORE_INIT: 101,\n  COMMIT_AFTER_TERM: 101,\n  ARGUMENT_ERROR: 101,\n  CHILDREN_ERROR: 101,\n  COUNT_ERROR: 101,\n  GENERAL_GET_FAILURE: 101,\n  GENERAL_SET_FAILURE: 101,\n  GENERAL_COMMIT_FAILURE: 101,\n  UNDEFINED_DATA_MODEL: 101,\n  UNIMPLEMENTED_ELEMENT: 101,\n  VALUE_NOT_INITIALIZED: 101,\n  INVALID_SET_VALUE: 101,\n  READ_ONLY_ELEMENT: 101,\n  WRITE_ONLY_ELEMENT: 101,\n  TYPE_MISMATCH: 101,\n  VALUE_OUT_OF_RANGE: 101,\n  DEPENDENCY_NOT_ESTABLISHED: 101,\n};\n\nconst scorm12 = {\n  ...global, ...{\n    RETRIEVE_BEFORE_INIT: 301,\n    STORE_BEFORE_INIT: 301,\n    COMMIT_BEFORE_INIT: 301,\n    ARGUMENT_ERROR: 201,\n    CHILDREN_ERROR: 202,\n    COUNT_ERROR: 203,\n    UNDEFINED_DATA_MODEL: 401,\n    UNIMPLEMENTED_ELEMENT: 401,\n    VALUE_NOT_INITIALIZED: 301,\n    INVALID_SET_VALUE: 402,\n    READ_ONLY_ELEMENT: 403,\n    WRITE_ONLY_ELEMENT: 404,\n    TYPE_MISMATCH: 405,\n    VALUE_OUT_OF_RANGE: 407,\n    DEPENDENCY_NOT_ESTABLISHED: 408,\n  },\n};\n\nconst scorm2004 = {\n  ...global, ...{\n    INITIALIZATION_FAILED: 102,\n    INITIALIZED: 103,\n    TERMINATED: 104,\n    TERMINATION_FAILURE: 111,\n    TERMINATION_BEFORE_INIT: 112,\n    MULTIPLE_TERMINATIONS: 113,\n    RETRIEVE_BEFORE_INIT: 122,\n    RETRIEVE_AFTER_TERM: 123,\n    STORE_BEFORE_INIT: 132,\n    STORE_AFTER_TERM: 133,\n    COMMIT_BEFORE_INIT: 142,\n    COMMIT_AFTER_TERM: 143,\n    ARGUMENT_ERROR: 201,\n    GENERAL_GET_FAILURE: 301,\n    GENERAL_SET_FAILURE: 351,\n    GENERAL_COMMIT_FAILURE: 391,\n    UNDEFINED_DATA_MODEL: 401,\n    UNIMPLEMENTED_ELEMENT: 402,\n    VALUE_NOT_INITIALIZED: 403,\n    READ_ONLY_ELEMENT: 404,\n    WRITE_ONLY_ELEMENT: 405,\n    TYPE_MISMATCH: 406,\n    VALUE_OUT_OF_RANGE: 407,\n    DEPENDENCY_NOT_ESTABLISHED: 408,\n  },\n};\n\nconst ErrorCodes = {\n  scorm12: scorm12,\n  scorm2004: scorm2004,\n};\n\nexport default ErrorCodes;\n","const ValidLanguages = {\n  'aa': 'aa', 'ab': 'ab', 'ae': 'ae', 'af': 'af', 'ak': 'ak', 'am': 'am',\n  'an': 'an', 'ar': 'ar', 'as': 'as', 'av': 'av', 'ay': 'ay', 'az': 'az',\n  'ba': 'ba', 'be': 'be', 'bg': 'bg', 'bh': 'bh', 'bi': 'bi', 'bm': 'bm',\n  'bn': 'bn', 'bo': 'bo', 'br': 'br', 'bs': 'bs', 'ca': 'ca', 'ce': 'ce',\n  'ch': 'ch', 'co': 'co', 'cr': 'cr', 'cs': 'cs', 'cu': 'cu', 'cv': 'cv',\n  'cy': 'cy', 'da': 'da', 'de': 'de', 'dv': 'dv', 'dz': 'dz', 'ee': 'ee',\n  'el': 'el', 'en': 'en', 'eo': 'eo', 'es': 'es', 'et': 'et', 'eu': 'eu',\n  'fa': 'fa', 'ff': 'ff', 'fi': 'fi', 'fj': 'fj', 'fo': 'fo', 'fr': 'fr',\n  'fy': 'fy', 'ga': 'ga', 'gd': 'gd', 'gl': 'gl', 'gn': 'gn', 'gu': 'gu',\n  'gv': 'gv', 'ha': 'ha', 'he': 'he', 'hi': 'hi', 'ho': 'ho', 'hr': 'hr',\n  'ht': 'ht', 'hu': 'hu', 'hy': 'hy', 'hz': 'hz', 'ia': 'ia', 'id': 'id',\n  'ie': 'ie', 'ig': 'ig', 'ii': 'ii', 'ik': 'ik', 'io': 'io', 'is': 'is',\n  'it': 'it', 'iu': 'iu', 'ja': 'ja', 'jv': 'jv', 'ka': 'ka', 'kg': 'kg',\n  'ki': 'ki', 'kj': 'kj', 'kk': 'kk', 'kl': 'kl', 'km': 'km', 'kn': 'kn',\n  'ko': 'ko', 'kr': 'kr', 'ks': 'ks', 'ku': 'ku', 'kv': 'kv', 'kw': 'kw',\n  'ky': 'ky', 'la': 'la', 'lb': 'lb', 'lg': 'lg', 'li': 'li', 'ln': 'ln',\n  'lo': 'lo', 'lt': 'lt', 'lu': 'lu', 'lv': 'lv', 'mg': 'mg', 'mh': 'mh',\n  'mi': 'mi', 'mk': 'mk', 'ml': 'ml', 'mn': 'mn', 'mo': 'mo', 'mr': 'mr',\n  'ms': 'ms', 'mt': 'mt', 'my': 'my', 'na': 'na', 'nb': 'nb', 'nd': 'nd',\n  'ne': 'ne', 'ng': 'ng', 'nl': 'nl', 'nn': 'nn', 'no': 'no', 'nr': 'nr',\n  'nv': 'nv', 'ny': 'ny', 'oc': 'oc', 'oj': 'oj', 'om': 'om', 'or': 'or',\n  'os': 'os', 'pa': 'pa', 'pi': 'pi', 'pl': 'pl', 'ps': 'ps', 'pt': 'pt',\n  'qu': 'qu', 'rm': 'rm', 'rn': 'rn', 'ro': 'ro', 'ru': 'ru', 'rw': 'rw',\n  'sa': 'sa', 'sc': 'sc', 'sd': 'sd', 'se': 'se', 'sg': 'sg', 'sh': 'sh',\n  'si': 'si', 'sk': 'sk', 'sl': 'sl', 'sm': 'sm', 'sn': 'sn', 'so': 'so',\n  'sq': 'sq', 'sr': 'sr', 'ss': 'ss', 'st': 'st', 'su': 'su', 'sv': 'sv',\n  'sw': 'sw', 'ta': 'ta', 'te': 'te', 'tg': 'tg', 'th': 'th', 'ti': 'ti',\n  'tk': 'tk', 'tl': 'tl', 'tn': 'tn', 'to': 'to', 'tr': 'tr', 'ts': 'ts',\n  'tt': 'tt', 'tw': 'tw', 'ty': 'ty', 'ug': 'ug', 'uk': 'uk', 'ur': 'ur',\n  'uz': 'uz', 've': 've', 'vi': 'vi', 'vo': 'vo', 'wa': 'wa', 'wo': 'wo',\n  'xh': 'xh', 'yi': 'yi', 'yo': 'yo', 'za': 'za', 'zh': 'zh', 'zu': 'zu',\n  'aar': 'aar', 'abk': 'abk', 'ave': 'ave', 'afr': 'afr', 'aka': 'aka',\n  'amh': 'amh', 'arg': 'arg', 'ara': 'ara', 'asm': 'asm', 'ava': 'ava',\n  'aym': 'aym', 'aze': 'aze', 'bak': 'bak', 'bel': 'bel', 'bul': 'bul',\n  'bih': 'bih', 'bis': 'bis', 'bam': 'bam', 'ben': 'ben', 'tib': 'tib',\n  'bod': 'bod', 'bre': 'bre', 'bos': 'bos', 'cat': 'cat', 'che': 'che',\n  'cha': 'cha', 'cos': 'cos', 'cre': 'cre', 'cze': 'cze', 'ces': 'ces',\n  'chu': 'chu', 'chv': 'chv', 'wel': 'wel', 'cym': 'cym', 'dan': 'dan',\n  'ger': 'ger', 'deu': 'deu', 'div': 'div', 'dzo': 'dzo', 'ewe': 'ewe',\n  'gre': 'gre', 'ell': 'ell', 'eng': 'eng', 'epo': 'epo', 'spa': 'spa',\n  'est': 'est', 'baq': 'baq', 'eus': 'eus', 'per': 'per', 'fas': 'fas',\n  'ful': 'ful', 'fin': 'fin', 'fij': 'fij', 'fao': 'fao', 'fre': 'fre',\n  'fra': 'fra', 'fry': 'fry', 'gle': 'gle', 'gla': 'gla', 'glg': 'glg',\n  'grn': 'grn', 'guj': 'guj', 'glv': 'glv', 'hau': 'hau', 'heb': 'heb',\n  'hin': 'hin', 'hmo': 'hmo', 'hrv': 'hrv', 'hat': 'hat', 'hun': 'hun',\n  'arm': 'arm', 'hye': 'hye', 'her': 'her', 'ina': 'ina', 'ind': 'ind',\n  'ile': 'ile', 'ibo': 'ibo', 'iii': 'iii', 'ipk': 'ipk', 'ido': 'ido',\n  'ice': 'ice', 'isl': 'isl', 'ita': 'ita', 'iku': 'iku', 'jpn': 'jpn',\n  'jav': 'jav', 'geo': 'geo', 'kat': 'kat', 'kon': 'kon', 'kik': 'kik',\n  'kua': 'kua', 'kaz': 'kaz', 'kal': 'kal', 'khm': 'khm', 'kan': 'kan',\n  'kor': 'kor', 'kau': 'kau', 'kas': 'kas', 'kur': 'kur', 'kom': 'kom',\n  'cor': 'cor', 'kir': 'kir', 'lat': 'lat', 'ltz': 'ltz', 'lug': 'lug',\n  'lim': 'lim', 'lin': 'lin', 'lao': 'lao', 'lit': 'lit', 'lub': 'lub',\n  'lav': 'lav', 'mlg': 'mlg', 'mah': 'mah', 'mao': 'mao', 'mri': 'mri',\n  'mac': 'mac', 'mkd': 'mkd', 'mal': 'mal', 'mon': 'mon', 'mol': 'mol',\n  'mar': 'mar', 'may': 'may', 'msa': 'msa', 'mlt': 'mlt', 'bur': 'bur',\n  'mya': 'mya', 'nau': 'nau', 'nob': 'nob', 'nde': 'nde', 'nep': 'nep',\n  'ndo': 'ndo', 'dut': 'dut', 'nld': 'nld', 'nno': 'nno', 'nor': 'nor',\n  'nbl': 'nbl', 'nav': 'nav', 'nya': 'nya', 'oci': 'oci', 'oji': 'oji',\n  'orm': 'orm', 'ori': 'ori', 'oss': 'oss', 'pan': 'pan', 'pli': 'pli',\n  'pol': 'pol', 'pus': 'pus', 'por': 'por', 'que': 'que', 'roh': 'roh',\n  'run': 'run', 'rum': 'rum', 'ron': 'ron', 'rus': 'rus', 'kin': 'kin',\n  'san': 'san', 'srd': 'srd', 'snd': 'snd', 'sme': 'sme', 'sag': 'sag',\n  'slo': 'slo', 'sin': 'sin', 'slk': 'slk', 'slv': 'slv', 'smo': 'smo',\n  'sna': 'sna', 'som': 'som', 'alb': 'alb', 'sqi': 'sqi', 'srp': 'srp',\n  'ssw': 'ssw', 'sot': 'sot', 'sun': 'sun', 'swe': 'swe', 'swa': 'swa',\n  'tam': 'tam', 'tel': 'tel', 'tgk': 'tgk', 'tha': 'tha', 'tir': 'tir',\n  'tuk': 'tuk', 'tgl': 'tgl', 'tsn': 'tsn', 'ton': 'ton', 'tur': 'tur',\n  'tso': 'tso', 'tat': 'tat', 'twi': 'twi', 'tah': 'tah', 'uig': 'uig',\n  'ukr': 'ukr', 'urd': 'urd', 'uzb': 'uzb', 'ven': 'ven', 'vie': 'vie',\n  'vol': 'vol', 'wln': 'wln', 'wol': 'wol', 'xho': 'xho', 'yid': 'yid',\n  'yor': 'yor', 'zha': 'zha', 'chi': 'chi', 'zho': 'zho', 'zul': 'zul',\n};\n\nexport default ValidLanguages;\n","// @flow\n\nconst scorm12 = {\n  CMIString256: '^.{0,255}$',\n  CMIString4096: '^.{0,4096}$',\n  CMITime: '^(?:[01]\\\\d|2[0123]):(?:[012345]\\\\d):(?:[012345]\\\\d)$', // eslint-disable-line\n  CMITimespan: '^([0-9]{2,}):([0-9]{2}):([0-9]{2})(\\.[0-9]{1,2})?$', // eslint-disable-line\n  CMIInteger: '^\\\\d+$',\n  CMISInteger: '^-?([0-9]+)$',\n  CMIDecimal: '^-?([0-9]{0,3})(\\.[0-9]*)?$', // eslint-disable-line\n  CMIIdentifier: '^[\\\\u0021-\\\\u007E\\\\s]{0,255}$',\n  CMIFeedback: '^.{0,255}$', // This must be redefined\n  CMIIndex: '[._](\\\\d+).',\n\n  // Vocabulary Data Type Definition\n  CMIStatus: '^(passed|completed|failed|incomplete|browsed)$',\n  CMIStatus2: '^(passed|completed|failed|incomplete|browsed|not attempted)$',\n  CMIExit: '^(time-out|suspend|logout|)$',\n  CMIType: '^(true-false|choice|fill-in|matching|performance|sequencing|likert|numeric)$',\n  CMIResult: '^(correct|wrong|unanticipated|neutral|([0-9]{0,3})?(\\\\.[0-9]*)?)$', // eslint-disable-line\n  NAVEvent: '^(previous|continue)$',\n\n  // Data ranges\n  score_range: '0#100',\n  audio_range: '-1#100',\n  speed_range: '-100#100',\n  weighting_range: '-100#100',\n  text_range: '-1#1',\n};\n\nconst aicc = {\n  ...scorm12, ...{\n    CMIIdentifier: '^\\\\w{1,255}$',\n  },\n};\n\nconst scorm2004 = {\n  CMIString200: '^[\\\\u0000-\\\\uFFFF]{0,200}$',\n  CMIString250: '^[\\\\u0000-\\\\uFFFF]{0,250}$',\n  CMIString1000: '^[\\\\u0000-\\\\uFFFF]{0,1000}$',\n  CMIString4000: '^[\\\\u0000-\\\\uFFFF]{0,4000}$',\n  CMIString64000: '^[\\\\u0000-\\\\uFFFF]{0,64000}$',\n  CMILang: '^([a-zA-Z]{2,3}|i|x)(\\-[a-zA-Z0-9\\-]{2,8})?$|^$', // eslint-disable-line\n  CMILangString250: '^(\\{lang=([a-zA-Z]{2,3}|i|x)(\\-[a-zA-Z0-9\\-]{2,8})?\\})?((?!\\{.*$).{0,250}$)?$', // eslint-disable-line\n  CMILangcr: '^((\\{lang=([a-zA-Z]{2,3}|i|x)?(\\-[a-zA-Z0-9\\-]{2,8})?\\}))(.*?)$', // eslint-disable-line\n  CMILangString250cr: '^((\\{lang=([a-zA-Z]{2,3}|i|x)?(\\-[a-zA-Z0-9\\-]{2,8})?\\})?(.{0,250})?)?$', // eslint-disable-line\n  CMILangString4000: '^(\\{lang=([a-zA-Z]{2,3}|i|x)(\\-[a-zA-Z0-9\\-]{2,8})?\\})?((?!\\{.*$).{0,4000}$)?$', // eslint-disable-line\n  CMITime: '^(19[7-9]{1}[0-9]{1}|20[0-2]{1}[0-9]{1}|203[0-8]{1})((-(0[1-9]{1}|1[0-2]{1}))((-(0[1-9]{1}|[1-2]{1}[0-9]{1}|3[0-1]{1}))(T([0-1]{1}[0-9]{1}|2[0-3]{1})((:[0-5]{1}[0-9]{1})((:[0-5]{1}[0-9]{1})((\\\\.[0-9]{1,2})((Z|([+|-]([0-1]{1}[0-9]{1}|2[0-3]{1})))(:[0-5]{1}[0-9]{1})?)?)?)?)?)?)?)?$',\n  CMITimespan: '^P(?:([.,\\\\d]+)Y)?(?:([.,\\\\d]+)M)?(?:([.,\\\\d]+)W)?(?:([.,\\\\d]+)D)?(?:T?(?:([.,\\\\d]+)H)?(?:([.,\\\\d]+)M)?(?:([.,\\\\d]+)S)?)?$',\n  CMIInteger: '^\\\\d+$',\n  CMISInteger: '^-?([0-9]+)$',\n  CMIDecimal: '^-?([0-9]{1,5})(\\\\.[0-9]{1,18})?$',\n  CMIIdentifier: '^\\\\S{1,250}[a-zA-Z0-9]$',\n  CMIShortIdentifier: '^[\\\\w\\\\.\\\\-\\\\_]{1,250}$', // eslint-disable-line\n  CMILongIdentifier: '^(?:(?!urn:)\\\\S{1,4000}|urn:[A-Za-z0-9-]{1,31}:\\\\S{1,4000}|.{1,4000})$', // need to re-examine this\n  CMIFeedback: '^.*$', // This must be redefined\n  CMIIndex: '[._](\\\\d+).',\n  CMIIndexStore: '.N(\\\\d+).',\n\n  // Vocabulary Data Type Definition\n  CMICStatus: '^(completed|incomplete|not attempted|unknown)$',\n  CMISStatus: '^(passed|failed|unknown)$',\n  CMIExit: '^(time-out|suspend|logout|normal)$',\n  CMIType: '^(true-false|choice|fill-in|long-fill-in|matching|performance|sequencing|likert|numeric|other)$',\n  CMIResult: '^(correct|incorrect|unanticipated|neutral|-?([0-9]{1,4})(\\\\.[0-9]{1,18})?)$',\n  NAVEvent: '^(previous|continue|exit|exitAll|abandon|abandonAll|suspendAll|\\{target=\\\\S{0,200}[a-zA-Z0-9]\\}choice|jump)$', // eslint-disable-line\n  NAVBoolean: '^(unknown|true|false$)',\n  NAVTarget: '^(previous|continue|choice.{target=\\\\S{0,200}[a-zA-Z0-9]})$',\n\n  // Data ranges\n  scaled_range: '-1#1',\n  audio_range: '0#*',\n  speed_range: '0#*',\n  text_range: '-1#1',\n  progress_range: '0#1',\n};\n\nconst Regex = {\n  aicc: aicc,\n  scorm12: scorm12,\n  scorm2004: scorm2004,\n};\n\nexport default Regex;\n","// @flow\nimport Regex from './regex';\n\nconst scorm2004_regex = Regex.scorm2004;\n\nconst learner = {\n  'true-false': {\n    format: '^true$|^false$',\n    max: 1,\n    delimiter: '',\n    unique: false,\n  },\n  'choice': {\n    format: scorm2004_regex.CMIShortIdentifier,\n    max: 36,\n    delimiter: '[,]',\n    unique: true,\n  },\n  'fill-in': {\n    format: scorm2004_regex.CMILangString250,\n    max: 10,\n    delimiter: '[,]',\n    unique: false,\n  },\n  'long-fill-in': {\n    format: scorm2004_regex.CMILangString4000,\n    max: 1,\n    delimiter: '',\n    unique: false,\n  },\n  'matching': {\n    format: scorm2004_regex.CMIShortIdentifier,\n    format2: scorm2004_regex.CMIShortIdentifier,\n    max: 36,\n    delimiter: '[,]',\n    delimiter2: '[.]',\n    unique: false,\n  },\n  'performance': {\n    format: '^$|' + scorm2004_regex.CMIShortIdentifier,\n    format2: scorm2004_regex.CMIDecimal + '|^$|' +\n        scorm2004_regex.CMIShortIdentifier,\n    max: 250,\n    delimiter: '[,]',\n    delimiter2: '[.]',\n    unique: false,\n  },\n  'sequencing': {\n    format: scorm2004_regex.CMIShortIdentifier,\n    max: 36,\n    delimiter: '[,]',\n    unique: false,\n  },\n  'likert': {\n    format: scorm2004_regex.CMIShortIdentifier,\n    max: 1,\n    delimiter: '',\n    unique: false,\n  },\n  'numeric': {\n    format: scorm2004_regex.CMIDecimal,\n    max: 1,\n    delimiter: '',\n    unique: false,\n  },\n  'other': {\n    format: scorm2004_regex.CMIString4000,\n    max: 1,\n    delimiter: '',\n    unique: false,\n  },\n};\n\nconst correct = {\n  'true-false': {\n    max: 1,\n    delimiter: '',\n    unique: false,\n    duplicate: false,\n    format: '^true$|^false$',\n    limit: 1,\n  },\n  'choice': {\n    max: 36,\n    delimiter: '[,]',\n    unique: true,\n    duplicate: false,\n    format: scorm2004_regex.CMIShortIdentifier,\n  },\n  'fill-in': {\n    max: 10,\n    delimiter: '[,]',\n    unique: false,\n    duplicate: false,\n    format: scorm2004_regex.CMILangString250cr,\n  },\n  'long-fill-in': {\n    max: 1,\n    delimiter: '',\n    unique: false,\n    duplicate: true,\n    format: scorm2004_regex.CMILangString4000,\n  },\n  'matching': {\n    max: 36,\n    delimiter: '[,]',\n    delimiter2: '[.]',\n    unique: false,\n    duplicate: false,\n    format: scorm2004_regex.CMIShortIdentifier,\n    format2: scorm2004_regex.CMIShortIdentifier,\n  },\n  'performance': {\n    max: 250,\n    delimiter: '[,]',\n    delimiter2: '[.]',\n    unique: false,\n    duplicate: false,\n    format: '^$|' + scorm2004_regex.CMIShortIdentifier,\n    format2: scorm2004_regex.CMIDecimal + '|^$|' +\n        scorm2004_regex.CMIShortIdentifier,\n  },\n  'sequencing': {\n    max: 36,\n    delimiter: '[,]',\n    unique: false,\n    duplicate: false,\n    format: scorm2004_regex.CMIShortIdentifier,\n  },\n  'likert': {\n    max: 1,\n    delimiter: '',\n    unique: false,\n    duplicate: false,\n    format: scorm2004_regex.CMIShortIdentifier,\n    limit: 1,\n  },\n  'numeric': {\n    max: 2,\n    delimiter: '[:]',\n    unique: false,\n    duplicate: false,\n    format: scorm2004_regex.CMIDecimal,\n    limit: 1,\n  },\n  'other': {\n    max: 1,\n    delimiter: '',\n    unique: false,\n    duplicate: false,\n    format: scorm2004_regex.CMIString4000,\n    limit: 1,\n  },\n};\n\nconst Responses = {\n  learner: learner,\n  correct: correct,\n};\n\nexport default Responses;\n","// @flow\n\nimport APIConstants from './constants/api_constants';\n\nconst scorm12_errors = APIConstants.scorm12.error_descriptions;\nconst aicc_errors = APIConstants.aicc.error_descriptions;\nconst scorm2004_errors = APIConstants.scorm2004.error_descriptions;\n\n/**\n * Base Validation Exception\n */\nexport class ValidationError extends Error {\n  /**\n   * Constructor to take in an error message and code\n   * @param {number} errorCode\n   * @param {string} errorMessage\n   * @param {string} detailedMessage\n   */\n  constructor(errorCode: number, errorMessage: String, detailedMessage: String) {\n    super(errorMessage);\n    this.#errorCode = errorCode;\n    this.#errorMessage = errorMessage;\n    this.#detailedMessage = detailedMessage;\n  }\n\n  #errorCode;\n  #errorMessage;\n  #detailedMessage;\n\n  /**\n   * Getter for #errorCode\n   * @return {number}\n   */\n  get errorCode() {\n    return this.#errorCode;\n  }\n\n  /**\n   * Getter for #errorMessage\n   * @return {string}\n   */\n  get errorMessage() {\n    return this.#errorMessage;\n  }\n\n  /**\n   * Getter for #detailedMessage\n   * @return {string}\n   */\n  get detailedMessage() {\n    return this.#detailedMessage;\n  }\n}\n\n/**\n * SCORM 1.2 Validation Error\n */\nexport class Scorm12ValidationError extends ValidationError {\n  /**\n   * Constructor to take in an error code\n   * @param {number} errorCode\n   */\n  constructor(errorCode: number) {\n    if ({}.hasOwnProperty.call(scorm12_errors, String(errorCode))) {\n      super(errorCode, scorm12_errors[String(errorCode)].basicMessage, scorm12_errors[String(errorCode)].detailMessage);\n    } else {\n      super(101, scorm12_errors['101'].basicMessage, scorm12_errors['101'].detailMessage);\n    }\n  }\n}\n\n/**\n * AICC Validation Error\n */\nexport class AICCValidationError extends ValidationError {\n  /**\n   * Constructor to take in an error code\n   * @param {number} errorCode\n   */\n  constructor(errorCode: number) {\n    if ({}.hasOwnProperty.call(aicc_errors, String(errorCode))) {\n      super(errorCode, aicc_errors[String(errorCode)].basicMessage, aicc_errors[String(errorCode)].detailMessage);\n    } else {\n      super(101, aicc_errors['101'].basicMessage, aicc_errors['101'].detailMessage);\n    }\n  }\n}\n\n/**\n * SCORM 2004 Validation Error\n */\nexport class Scorm2004ValidationError extends ValidationError {\n  /**\n   * Constructor to take in an error code\n   * @param {number} errorCode\n   */\n  constructor(errorCode: number) {\n    if ({}.hasOwnProperty.call(scorm2004_errors, String(errorCode))) {\n      super(errorCode, scorm2004_errors[String(errorCode)].basicMessage, scorm2004_errors[String(errorCode)].detailMessage);\n    } else {\n      super(101, scorm2004_errors['101'].basicMessage, scorm2004_errors['101'].detailMessage);\n    }\n  }\n}\n","import Scorm2004API from '../Scorm2004API';\nimport Scorm12API from '../Scorm12API';\nimport AICC from '../AICC';\n\nwindow.Scorm12API = Scorm12API;\nwindow.Scorm2004API = Scorm2004API;\nwindow.AICC = AICC;\n","// @flow\nexport const SECONDS_PER_SECOND = 1.0;\nexport const SECONDS_PER_MINUTE = 60;\nexport const SECONDS_PER_HOUR = 60 * SECONDS_PER_MINUTE;\nexport const SECONDS_PER_DAY = 24 * SECONDS_PER_HOUR;\n\nconst designations = [\n  ['D', SECONDS_PER_DAY],\n  ['H', SECONDS_PER_HOUR],\n  ['M', SECONDS_PER_MINUTE],\n  ['S', SECONDS_PER_SECOND],\n];\n\n/**\n * Converts a Number to a String of HH:MM:SS\n *\n * @param {Number} totalSeconds\n * @return {string}\n */\nexport function getSecondsAsHHMMSS(totalSeconds: Number) {\n  // SCORM spec does not deal with negative durations, give zero back\n  if (!totalSeconds || totalSeconds <= 0) {\n    return '00:00:00';\n  }\n\n  const hours = Math.floor(totalSeconds / SECONDS_PER_HOUR);\n\n  const dateObj = new Date(totalSeconds * 1000);\n  const minutes = dateObj.getUTCMinutes();\n  // make sure we add any possible decimal value\n  const seconds = dateObj.getSeconds();\n  const ms = totalSeconds % 1.0;\n  let msStr = '';\n  if (countDecimals(ms) > 0) {\n    if (countDecimals(ms) > 2) {\n      msStr = ms.toFixed(2);\n    } else {\n      msStr = String(ms);\n    }\n    msStr = '.' + msStr.split('.')[1];\n  }\n\n  return (hours + ':' + minutes + ':' + seconds).replace(/\\b\\d\\b/g,\n      '0$&') + msStr;\n}\n\n/**\n * Calculate the number of seconds from ISO 8601 Duration\n *\n * @param {Number} seconds\n * @return {String}\n */\nexport function getSecondsAsISODuration(seconds: Number) {\n  // SCORM spec does not deal with negative durations, give zero back\n  if (!seconds || seconds <= 0) {\n    return 'PT0S';\n  }\n\n  let duration = 'P';\n  let remainder = seconds;\n\n  designations.forEach(([sign, current_seconds]) => {\n    let value = Math.floor(remainder / current_seconds);\n\n    remainder = remainder % current_seconds;\n    if (countDecimals(remainder) > 2) {\n      remainder = Number(Number(remainder).toFixed(2));\n    }\n    // If we have anything left in the remainder, and we're currently adding\n    // seconds to the duration, go ahead and add the decimal to the seconds\n    if (sign === 'S' && remainder > 0) {\n      value += remainder;\n    }\n\n    if (value) {\n      if ((duration.indexOf('D') > 0 ||\n          sign === 'H' || sign === 'M' || sign === 'S') &&\n          duration.indexOf('T') === -1) {\n        duration += 'T';\n      }\n      duration += `${value}${sign}`;\n    }\n  });\n\n  return duration;\n}\n\n/**\n * Calculate the number of seconds from HH:MM:SS.DDDDDD\n *\n * @param {string} timeString\n * @param {RegExp} timeRegex\n * @return {number}\n */\nexport function getTimeAsSeconds(timeString: String, timeRegex: RegExp) {\n  if (!timeString || typeof timeString !== 'string' ||\n      !timeString.match(timeRegex)) {\n    return 0;\n  }\n  const parts = timeString.split(':');\n  const hours = Number(parts[0]);\n  const minutes = Number(parts[1]);\n  const seconds = Number(parts[2]);\n  return (hours * 3600) + (minutes * 60) + seconds;\n}\n\n/**\n * Calculate the number of seconds from ISO 8601 Duration\n *\n * @param {string} duration\n * @param {RegExp} durationRegex\n * @return {number}\n */\nexport function getDurationAsSeconds(duration: String, durationRegex: RegExp) {\n  if (!duration || !duration.match(durationRegex)) {\n    return 0;\n  }\n\n  const [, years, months, , days, hours, minutes, seconds] = new RegExp(\n      durationRegex).exec(duration) || [];\n\n  let result = 0.0;\n\n  result += (Number(seconds) * 1.0 || 0.0);\n  result += (Number(minutes) * 60.0 || 0.0);\n  result += (Number(hours) * 3600.0 || 0.0);\n  result += (Number(days) * (60 * 60 * 24.0) || 0.0);\n  result += (Number(years) * (60 * 60 * 24 * 365.0) || 0.0);\n\n  return result;\n}\n\n/**\n * Adds together two ISO8601 Duration strings\n *\n * @param {string} first\n * @param {string} second\n * @param {RegExp} durationRegex\n * @return {string}\n */\nexport function addTwoDurations(\n    first: String,\n    second: String,\n    durationRegex: RegExp) {\n  return getSecondsAsISODuration(\n      getDurationAsSeconds(first, durationRegex) +\n      getDurationAsSeconds(second, durationRegex),\n  );\n}\n\n/**\n * Add together two HH:MM:SS.DD strings\n *\n * @param {string} first\n * @param {string} second\n * @param {RegExp} timeRegex\n * @return {string}\n */\nexport function addHHMMSSTimeStrings(\n    first: String,\n    second: String,\n    timeRegex: RegExp) {\n  return getSecondsAsHHMMSS(\n      getTimeAsSeconds(first, timeRegex) +\n      getTimeAsSeconds(\n          second, timeRegex),\n  );\n}\n\n/**\n * Flatten a JSON object down to string paths for each values\n * @param {object} data\n * @return {object}\n */\nexport function flatten(data) {\n  const result = {};\n\n  /**\n   * Recurse through the object\n   * @param {*} cur\n   * @param {*} prop\n   */\n  function recurse(cur, prop) {\n    if (Object(cur) !== cur) {\n      result[prop] = cur;\n    } else if (Array.isArray(cur)) {\n      for (let i = 0, l = cur.length; i < l; i++) {\n        recurse(cur[i], prop + '[' + i + ']');\n        if (l === 0) result[prop] = [];\n      }\n    } else {\n      let isEmpty = true;\n      for (const p in cur) {\n        if ({}.hasOwnProperty.call(cur, p)) {\n          isEmpty = false;\n          recurse(cur[p], prop ? prop + '.' + p : p);\n        }\n      }\n      if (isEmpty && prop) result[prop] = {};\n    }\n  }\n\n  recurse(data, '');\n  return result;\n}\n\n/**\n * Un-flatten a flat JSON object\n * @param {object} data\n * @return {object}\n */\nexport function unflatten(data) {\n  'use strict';\n  if (Object(data) !== data || Array.isArray(data)) return data;\n  const regex = /\\.?([^.[\\]]+)|\\[(\\d+)]/g;\n  const result = {};\n  for (const p in data) {\n    if ({}.hasOwnProperty.call(data, p)) {\n      let cur = result;\n      let prop = '';\n      let m = regex.exec(p);\n      while (m) {\n        cur = cur[prop] || (cur[prop] = (m[2] ? [] : {}));\n        prop = m[2] || m[1];\n        m = regex.exec(p);\n      }\n      cur[prop] = data[p];\n    }\n  }\n  return result[''] || result;\n}\n\n/**\n * Counts the number of decimal places\n * @param {number} num\n * @return {number}\n */\nexport function countDecimals(num: number) {\n  if (Math.floor(num) === num || String(num).indexOf('.') < 0) return 0;\n  const parts = num.toString().split('.')[1];\n  return parts.length || 0;\n}\n"]} diff --git a/dist/scorm-again.js.map b/dist/scorm-again.js.map deleted file mode 100644 index fd81f9c..0000000 --- a/dist/scorm-again.js.map +++ /dev/null @@ -1 +0,0 @@ -{"version":3,"sources":["node_modules/browser-pack/_prelude.js","node_modules/lodash.debounce/index.js","src/AICC.js","src/BaseAPI.js","src/Scorm12API.js","src/Scorm2004API.js","src/cmi/aicc_cmi.js","src/cmi/common.js","src/cmi/scorm12_cmi.js","src/cmi/scorm2004_cmi.js","src/constants/api_constants.js","src/constants/error_codes.js","src/constants/language_constants.js","src/constants/regex.js","src/constants/response_constants.js","src/exceptions.js","src/exports.js","src/utilities.js"],"names":["debounce","func","wait","options","invokeFunc","time","args","lastArgs","thisArg","lastThis","undefined","lastInvokeTime","result","apply","leadingEdge","timerId","setTimeout","timerExpired","leading","remainingWait","timeSinceLastCall","lastCallTime","timeSinceLastInvoke","maxing","nativeMin","maxWait","shouldInvoke","now","trailingEdge","trailing","cancel","clearTimeout","flush","debounced","isInvoking","arguments","this","TypeError","FUNC_ERROR_TEXT","toNumber","isObject","nativeMax","value","type","isObjectLike","isSymbol","objectToString","call","symbolTag","NAN","other","valueOf","replace","reTrim","isBinary","reIsBinary","test","reIsOctal","freeParseInt","slice","reIsBadHex","parseInt","freeGlobal","global","Object","freeSelf","self","root","Function","objectProto","prototype","toString","Math","max","min","Date","module","exports","_Scorm12API2","_interopRequireDefault","require","_aicc_cmi","_scorm12_cmi","AICC","settings","_this","_classCallCheck","finalSettings","_objectSpread","mastery_override","_super","cmi","CMI","nav","NAV","CMIElement","foundFirstIndex","newChild","_get","_getPrototypeOf","stringMatches","CMIEvaluationCommentsObject","CMITriesObject","CMIAttemptRecordsObject","newAPI","Scorm12API","_common","_exceptions","_error_codes2","_api_constants","_utilities","_lodash","global_constants","APIConstants","scorm12_error_codes","ErrorCodes","scorm12","BaseAPI","error_codes","_timeout","set","writable","_error_codes","_settings","autocommit","autocommitSeconds","asyncCommit","sendBeaconCommit","lmsCommitUrl","dataCommitFormat","commitRequestDataType","autoProgress","logLevel","LOG_LEVEL_ERROR","selfReportSessionTime","alwaysSendTotalTime","strict_errors","responseHandler","xhr","JSON","parse","responseText","hasOwnProperty","status","SCORM_TRUE","errorCode","SCORM_FALSE","_defineProperty","constructor","currentState","STATE_NOT_INITIALIZED","lastErrorCode","listenerArray","_classPrivateFieldSet","apiLogLevel","callbackName","initializeMessage","terminationMessage","returnValue","isInitialized","throwSCORMError","_classPrivateFieldGet","INITIALIZED","isTerminated","TERMINATED","setStartTime","STATE_INITIALIZED","processListeners","apiLog","LOG_LEVEL_INFO","clearSCORMError","checkTerminated","checkState","TERMINATION_BEFORE_INIT","MULTIPLE_TERMINATION","STATE_TERMINATED","storeData","RETRIEVE_BEFORE_INIT","RETRIEVE_AFTER_TERM","getCMIValue","e","ValidationError","message","console","error","GENERAL","commitCallback","String","STORE_BEFORE_INIT","STORE_AFTER_TERM","setCMIValue","scheduleCommit","clearScheduledCommit","COMMIT_BEFORE_INIT","COMMIT_AFTER_TERM","LOG_LEVEL_DEBUG","CMIErrorCode","getLmsErrorMessageDetails","beforeInitError","afterTermError","isNotInitialized","functionName","logMessage","messageLevel","formatMessage","LOG_LEVEL_WARNING","warn","info","debug","log","messageString","fillChars","length","i","j","str","tester","match","refObject","attribute","getOwnPropertyDescriptor","getPrototypeOf","_errorNumber","_detail","Error","_CMIElement","_value","methodName","scorm2004","structure","split","invalidErrorMessage","concat","invalidErrorCode","UNDEFINED_DATA_MODEL","substr","_isTargetValid","READ_ONLY_ELEMENT","_checkObjectHasProperty","validateCorrectResponse","CMIArray","index","isNaN","item","childArray","getChildElement","initialized","initialize","push","_foundFirstIndex","uninitializedErrorMessage","target","VALUE_NOT_INITIALIZED","CHILDREN_ERROR","COUNT_ERROR","listenerName","callback","listenerFunctions","listenerSplit","_ret","v","removeIndex","findIndex","obj","splice","_typeof","_this2","_ret2","filter","listener","functionsMatch","listenerHasCMIElement","CMIElementsMatch","substring","indexOf","errorNumber","success","_calculateTotalTime","json","testPattern","a","c","a_pattern","c_match","a_match","a_num","Number","c_num","_this3","int_pattern","obj_pattern","keys","map","key","sort","_ref","_ref2","_ref3","_slicedToArray","_ref4","forEach","element","loadFromJSON","unflatten","startingData","currentCMIElement","stringify","renderCMIToJSONString","_terminateCommit","url","params","immediate","api","process","genericError","blob","headers","Array","Blob","join","navigator","sendBeacon","httpReq","XMLHttpRequest","open","onload","setRequestHeader","send","when","ScheduledCommit","API","_API","_cancelled","_timeout2","_callback","wrapper","bind","commit","_BaseAPI2","Utilities","_interopRequireWildcard","scorm12_constants","LMSInitialize","lmsInitialize","LMSFinish","lmsFinish","LMSGetValue","lmsGetValue","LMSSetValue","lmsSetValue","LMSCommit","lmsCommit","LMSGetLastError","lmsGetLastError","LMSGetErrorString","lmsGetErrorString","LMSGetDiagnostic","lmsGetDiagnostic","terminate","event","getValue","setValue","getLastError","getErrorString","getDiagnostic","_commonSetCMIValue","_commonGetCMIValue","CMIObjectivesObject","CMIInteractionsCorrectResponsesObject","CMIInteractionsObjectivesObject","CMIInteractionsObject","detail","basicMessage","detailMessage","error_descriptions","terminateCommit","cmiExport","renderCMIToJSONObject","core","total_time","getCurrentTotalTime","flattened","flatten","originalStatus","lesson_status","lesson_mode","credit","student_data","mastery_score","score","raw","parseFloat","_this$startingData","_this$startingData$cm","_this$startingData$cm2","commitObject","renderCommitCMI","processHttpRequest","_scorm2004_cmi","_response_constants","_language_constants","_regex","scorm2004_constants","scorm2004_error_codes","correct_responses","Responses","correct","scorm2004_regex","Regex","Scorm2004API","_version","_assertThisInitialized","correct_response","current_index","found","count","_count","adl","ADL","Initialize","Terminate","lmsTerminate","GetValue","SetValue","Commit","GetLastError","GetErrorString","GetDiagnostic","request","parts","interaction","interactions","checkDuplicateChoiceResponse","response_type","checkValidResponseType","GENERAL_SET_FAILURE","DEPENDENCY_NOT_ESTABLISHED","CMICommentsObject","interaction_type","nodes","delimiter","checkCorrectResponseValue","interaction_count","response","pattern","pattern_index","limit","duplicate","checkDuplicatedPattern","formatRegex","RegExp","format","removeCorrectResponsePrefixes","delimiter2","values","matches","format2","TYPE_MISMATCH","unique","node","seenOrder","seenCase","seenLang","prefixRegex","langMatches","CMILangcr","lang","ValidLanguages","toLowerCase","_this$startingData$ad","_this$startingData$ad2","mode","completion_threshold","progress_measure","completion_status","scaled_passing_score","scaled","success_status","navRequest","encodeURIComponent","throwReadOnlyError","AICCValidationError","aicc_error_codes","checkAICCValidFormat","regexPattern","allowEmptyString","checkValidFormat","Scorm12CMI","aicc_constants","aicc","aicc_regex","cmi_children","student_preference","AICCStudentPreferences","AICCCMIStudentData","student_demographics","CMIStudentDemographics","evaluation","CMIEvaluation","paths","CMIPaths","_this$student_prefere","_this$student_data","_this$student_demogra","_this$evaluation","_this$paths","jsonString","suspend_data","launch_data","comments","comments_from_lms","objectives","_super2","CMIEvaluationComments","_this$comments","BaseCMI","_super3","children","comments_children","INVALID_SET_VALUE","errorClass","_super4","student_preference_children","_lesson_type","_text_color","_text_location","_text_size","_video","windows","_this$windows","lesson_type","CMIString256","text_color","text_location","text_size","video","audio","language","speed","text","CMIStudentPreference","_this4","_super5","student_data_children","_tries_during_lesson","tries","CMITries","_this$tries","tries_during_lesson","max_time_allowed","time_limit_action","CMIStudentData","_this5","_super6","_children","student_demographics_children","_city","_class","_company","_country","_experience","_familiar_name","_instructor_name","_title","_native_language","_state","_street_address","_telephone","_years_experience","city","clazz","company","country","experience","familiar_name","instructor_name","title","native_language","state","street_address","telephone","years_experience","class","_super7","paths_children","CMIPathsObject","_this6","_super8","_location_id","_date","_time","_status","_why_left","_time_in_element","location_id","date","CMITime","CMIStatus2","why_left","time_in_element","_super9","tries_children","_this7","_super10","_status2","_time2","CMIScore","score_children","score_range","invalidTypeCode","invalidRangeCode","VALUE_OUT_OF_RANGE","_this$score","CMIAttemptRecords","_super11","attempt_records_children","_this8","_super12","_lesson_status","_this$score2","_this9","_super13","_content","_location","_time3","content","location","checkValidRange","rangePattern","ranges","scorm12_regex","_initialized","_start_time","getTime","decimalRegex","_children2","_score_range","_invalid_error_code","_invalid_type_code","_invalid_range_code","_decimal_regex","_error_class","_raw","_min","_max","CMIDecimal","_errorCode","_errorClass","_children3","Scorm12ValidationError","throwWriteOnlyError","WRITE_ONLY_ELEMENT","throwInvalidValueError","check12ValidFormat","check12ValidRange","_version2","_launch_data","_comments","_comments_from_lms","CMICore","CMIObjectives","CMIInteractions","_this$core","_this$objectives","_this$interactions","_this$core2","CMIString4096","start_time","core_children","_student_id","_student_name","_lesson_location","_credit","_entry","_total_time","_lesson_mode","_exit","_session_time","_suspend_data","student_id","student_name","lesson_location","CMIStatus","entry","exit","CMIExit","session_time","CMITimespan","sessionTime","startTime","seconds","Util","getSecondsAsHHMMSS","addHHMMSSTimeStrings","objectives_children","_children4","_mastery_score","_max_time_allowed","_time_limit_action","_children5","_audio","_language","_speed","_text","CMISInteger","audio_range","speed_range","text_range","interactions_children","_id","_type","_weighting","_student_response","_result","_latency","correct_responses_children","_this$objectives2","_this$correct_respons","id","CMIIdentifier","CMIType","weighting","weighting_range","student_response","CMIFeedback","CMIResult","latency","_id2","_id3","_pattern","_event","NAVEvent","Scorm2004ValidationError","throwTypeMismatchError","throwDependencyNotEstablishedError","throwGeneralSetError","check2004ValidFormat","check2004ValidRange","learner_responses","learner","_completion_status","_completion_threshold","_learner_id","_learner_name","_mode","_progress_measure","_scaled_passing_score","_success_status","learner_preference","CMILearnerPreference","Scorm2004CMIScore","comments_from_learner","CMICommentsFromLearner","CMICommentsFromLMS","_this$learner_prefere","_this$comments_from_l","_this$comments_from_l2","CMICStatus","learner_id","learner_name","CMIString1000","progress_range","CMISStatus","CMIString64000","getSecondsAsISODuration","addTwoDurations","_audio_level","_delivery_speed","_audio_captioning","audio_level","CMILang","delivery_speed","audio_captioning","_timestamp","_learner_response","_description","CMILongIdentifier","timestamp","learner_response","description","CMILangString250","_success_status2","_completion_status2","_progress_measure2","_description2","_scaled","scaled_range","readOnlyAfterInit","_comment","_location2","_timestamp2","_readOnlyAfterInit","comment","CMILangString4000","CMIString250","ADLNav","_this$nav","_this10","_super14","_request","request_valid","ADLNavRequestValid","_this$request_valid","_this11","_super15","_continue","_previous","_class2","_target","_class4","_","previous","continue","LOG_LEVEL_NONE","101","201","202","203","301","401","402","403","404","405","407","408","0","102","103","104","111","112","113","122","123","132","133","142","143","351","391","406","INITIALIZATION_FAILED","TERMINATION_FAILURE","ARGUMENT_ERROR","GENERAL_GET_FAILURE","GENERAL_COMMIT_FAILURE","UNIMPLEMENTED_ELEMENT","MULTIPLE_TERMINATIONS","aa","ab","ae","af","ak","am","an","ar","as","av","ay","az","ba","be","bg","bh","bi","bm","bn","bo","br","bs","ca","ce","ch","co","cr","cs","cu","cv","cy","da","de","dv","dz","ee","el","en","eo","es","et","eu","fa","ff","fi","fj","fo","fr","fy","ga","gd","gl","gn","gu","gv","ha","he","hi","ho","hr","ht","hu","hy","hz","ia","ie","ig","ii","ik","io","is","it","iu","ja","jv","ka","kg","ki","kj","kk","kl","km","kn","ko","kr","ks","ku","kv","kw","ky","la","lb","lg","li","ln","lo","lt","lu","lv","mg","mh","mi","mk","ml","mn","mo","mr","ms","mt","my","na","nb","nd","ne","ng","nl","nn","no","nr","nv","ny","oc","oj","om","or","os","pa","pi","pl","ps","pt","qu","rm","rn","ro","ru","rw","sa","sc","sd","se","sg","sh","si","sk","sl","sm","sn","so","sq","sr","ss","st","su","sv","sw","ta","te","tg","th","ti","tk","tl","tn","to","tr","ts","tt","tw","ty","ug","uk","ur","uz","ve","vi","vo","wa","wo","xh","yi","yo","za","zh","zu","aar","abk","ave","afr","aka","amh","arg","ara","asm","ava","aym","aze","bak","bel","bul","bih","bis","bam","ben","tib","bod","bre","bos","cat","che","cha","cos","cre","cze","ces","chu","chv","wel","cym","dan","ger","deu","div","dzo","ewe","gre","ell","eng","epo","spa","est","baq","eus","per","fas","ful","fin","fij","fao","fre","fra","fry","gle","gla","glg","grn","guj","glv","hau","heb","hin","hmo","hrv","hat","hun","arm","hye","her","ina","ind","ile","ibo","iii","ipk","ido","ice","isl","ita","iku","jpn","jav","geo","kat","kon","kik","kua","kaz","kal","khm","kan","kor","kau","kas","kur","kom","cor","kir","lat","ltz","lug","lim","lin","lao","lit","lub","lav","mlg","mah","mao","mri","mac","mkd","mal","mon","mol","mar","may","msa","mlt","bur","mya","nau","nob","nde","nep","ndo","dut","nld","nno","nor","nbl","nya","oci","oji","orm","ori","oss","pan","pli","pol","pus","por","que","roh","run","rum","ron","rus","kin","san","srd","snd","sme","sag","slo","sin","slk","slv","smo","sna","som","alb","sqi","srp","ssw","sot","sun","swe","swa","tam","tel","tgk","tha","tir","tuk","tgl","tsn","ton","tur","tso","tat","twi","tah","uig","ukr","urd","uzb","ven","vie","vol","wln","wol","xho","yid","yor","zha","chi","zho","zul","CMIInteger","CMIIndex","CMIString200","CMIString4000","CMILangString250cr","CMIShortIdentifier","CMIIndexStore","NAVBoolean","NAVTarget","true-false","choice","fill-in","long-fill-in","matching","performance","sequencing","likert","numeric","scorm12_errors","aicc_errors","scorm2004_errors","errorMessage","detailedMessage","_errorMessage","_detailedMessage","_possibleConstructorReturn","_Scorm2004API","_Scorm12API","_AICC","window","totalSeconds","hours","floor","SECONDS_PER_HOUR","dateObj","minutes","getUTCMinutes","getSeconds","msStr","countDecimals","toFixed","duration","remainder","designations","sign","current_seconds","getTimeAsSeconds","timeString","timeRegex","getDurationAsSeconds","durationRegex","exec","years","days","first","second","data","recurse","cur","prop","isArray","l","isEmpty","p","regex","m","num","SECONDS_PER_SECOND","SECONDS_PER_MINUTE","SECONDS_PER_DAY"],"mappings":"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AAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAClEC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAClEC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAClEC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAClEC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMnM,GAAM,KAClEoM,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAClEC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAClEC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAClEC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAClEC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAClEC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAClEC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAClEC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAClEC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAClEC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAClEC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAClEC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAClEC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAClEC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAClEC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAClEC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAClEC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAClEC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAClEC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAClEC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAAMC,GAAM,KAClEC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOpjC,IAAO,MAAOqjC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAAOC,IAAO,MAC/DC,IAAO,MAAOC,IAAO,MAAOC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","file":"bundle.js","sourcesContent":["(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors \n * Released under MIT license \n * Based on Underscore.js 1.8.3 \n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the `TypeError` message for \"Functions\" methods. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n nativeMin = Math.min;\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n * console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n return root.Date.now();\n};\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n * Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n * The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n * Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n * 'leading': true,\n * 'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n var lastArgs,\n lastThis,\n maxWait,\n result,\n timerId,\n lastCallTime,\n lastInvokeTime = 0,\n leading = false,\n maxing = false,\n trailing = true;\n\n if (typeof func != 'function') {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n wait = toNumber(wait) || 0;\n if (isObject(options)) {\n leading = !!options.leading;\n maxing = 'maxWait' in options;\n maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n trailing = 'trailing' in options ? !!options.trailing : trailing;\n }\n\n function invokeFunc(time) {\n var args = lastArgs,\n thisArg = lastThis;\n\n lastArgs = lastThis = undefined;\n lastInvokeTime = time;\n result = func.apply(thisArg, args);\n return result;\n }\n\n function leadingEdge(time) {\n // Reset any `maxWait` timer.\n lastInvokeTime = time;\n // Start the timer for the trailing edge.\n timerId = setTimeout(timerExpired, wait);\n // Invoke the leading edge.\n return leading ? invokeFunc(time) : result;\n }\n\n function remainingWait(time) {\n var timeSinceLastCall = time - lastCallTime,\n timeSinceLastInvoke = time - lastInvokeTime,\n result = wait - timeSinceLastCall;\n\n return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;\n }\n\n function shouldInvoke(time) {\n var timeSinceLastCall = time - lastCallTime,\n timeSinceLastInvoke = time - lastInvokeTime;\n\n // Either this is the first call, activity has stopped and we're at the\n // trailing edge, the system time has gone backwards and we're treating\n // it as the trailing edge, or we've hit the `maxWait` limit.\n return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n }\n\n function timerExpired() {\n var time = now();\n if (shouldInvoke(time)) {\n return trailingEdge(time);\n }\n // Restart the timer.\n timerId = setTimeout(timerExpired, remainingWait(time));\n }\n\n function trailingEdge(time) {\n timerId = undefined;\n\n // Only invoke if we have `lastArgs` which means `func` has been\n // debounced at least once.\n if (trailing && lastArgs) {\n return invokeFunc(time);\n }\n lastArgs = lastThis = undefined;\n return result;\n }\n\n function cancel() {\n if (timerId !== undefined) {\n clearTimeout(timerId);\n }\n lastInvokeTime = 0;\n lastArgs = lastCallTime = lastThis = timerId = undefined;\n }\n\n function flush() {\n return timerId === undefined ? result : trailingEdge(now());\n }\n\n function debounced() {\n var time = now(),\n isInvoking = shouldInvoke(time);\n\n lastArgs = arguments;\n lastThis = this;\n lastCallTime = time;\n\n if (isInvoking) {\n if (timerId === undefined) {\n return leadingEdge(lastCallTime);\n }\n if (maxing) {\n // Handle invocations in a tight loop.\n timerId = setTimeout(timerExpired, wait);\n return invokeFunc(lastCallTime);\n }\n }\n if (timerId === undefined) {\n timerId = setTimeout(timerExpired, wait);\n }\n return result;\n }\n debounced.cancel = cancel;\n debounced.flush = flush;\n return debounced;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n var type = typeof value;\n return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n return typeof value == 'symbol' ||\n (isObjectLike(value) && objectToString.call(value) == symbolTag);\n}\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n if (typeof value == 'number') {\n return value;\n }\n if (isSymbol(value)) {\n return NAN;\n }\n if (isObject(value)) {\n var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n value = isObject(other) ? (other + '') : other;\n }\n if (typeof value != 'string') {\n return value === 0 ? value : +value;\n }\n value = value.replace(reTrim, '');\n var isBinary = reIsBinary.test(value);\n return (isBinary || reIsOctal.test(value))\n ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = debounce;\n","// @flow\nimport Scorm12API from './Scorm12API';\nimport {\n CMI,\n CMIAttemptRecordsObject,\n CMIEvaluationCommentsObject,\n CMITriesObject,\n} from './cmi/aicc_cmi';\nimport {NAV} from './cmi/scorm12_cmi';\n\n/**\n * The AICC API class\n */\nexport default class AICC extends Scorm12API {\n /**\n * Constructor to create AICC API object\n * @param {object} settings\n */\n constructor(settings: {}) {\n const finalSettings = {\n ...{\n mastery_override: false,\n }, ...settings,\n };\n\n super(finalSettings);\n\n this.cmi = new CMI();\n this.nav = new NAV();\n }\n\n /**\n * Gets or builds a new child element to add to the array.\n *\n * @param {string} CMIElement\n * @param {any} value\n * @param {boolean} foundFirstIndex\n * @return {object}\n */\n getChildElement(CMIElement, value, foundFirstIndex) {\n let newChild = super.getChildElement(CMIElement, value, foundFirstIndex);\n\n if (!newChild) {\n if (this.stringMatches(CMIElement, 'cmi\\\\.evaluation\\\\.comments\\\\.\\\\d+')) {\n newChild = new CMIEvaluationCommentsObject();\n } else if (this.stringMatches(CMIElement,\n 'cmi\\\\.student_data\\\\.tries\\\\.\\\\d+')) {\n newChild = new CMITriesObject();\n } else if (this.stringMatches(CMIElement,\n 'cmi\\\\.student_data\\\\.attempt_records\\\\.\\\\d+')) {\n newChild = new CMIAttemptRecordsObject();\n }\n }\n\n return newChild;\n }\n\n /**\n * Replace the whole API with another\n *\n * @param {AICC} newAPI\n */\n replaceWithAnotherScormAPI(newAPI) {\n // Data Model\n this.cmi = newAPI.cmi;\n this.nav = newAPI.nav;\n }\n}\n","// @flow\nimport {CMIArray} from './cmi/common';\nimport {ValidationError} from './exceptions';\nimport ErrorCodes from './constants/error_codes';\nimport APIConstants from './constants/api_constants';\nimport {unflatten} from './utilities';\nimport debounce from 'lodash.debounce';\n\nconst global_constants = APIConstants.global;\nconst scorm12_error_codes = ErrorCodes.scorm12;\n\n/**\n * Base API class for AICC, SCORM 1.2, and SCORM 2004. Should be considered\n * abstract, and never initialized on it's own.\n */\nexport default class BaseAPI {\n #timeout;\n #error_codes;\n #settings = {\n autocommit: false,\n autocommitSeconds: 10,\n asyncCommit: false,\n sendBeaconCommit: false,\n lmsCommitUrl: false,\n dataCommitFormat: 'json', // valid formats are 'json' or 'flattened', 'params'\n commitRequestDataType: 'application/json;charset=UTF-8',\n autoProgress: false,\n logLevel: global_constants.LOG_LEVEL_ERROR,\n selfReportSessionTime: false,\n alwaysSendTotalTime: false,\n strict_errors: true,\n responseHandler: function(xhr) {\n let result;\n if (typeof xhr !== 'undefined') {\n result = JSON.parse(xhr.responseText);\n if (result === null || !{}.hasOwnProperty.call(result, 'result')) {\n result = {};\n if (xhr.status === 200) {\n result.result = global_constants.SCORM_TRUE;\n result.errorCode = 0;\n } else {\n result.result = global_constants.SCORM_FALSE;\n result.errorCode = 101;\n }\n }\n }\n return result;\n },\n };\n cmi;\n startingData: {};\n\n /**\n * Constructor for Base API class. Sets some shared API fields, as well as\n * sets up options for the API.\n * @param {object} error_codes\n * @param {object} settings\n */\n constructor(error_codes, settings) {\n if (new.target === BaseAPI) {\n throw new TypeError('Cannot construct BaseAPI instances directly');\n }\n this.currentState = global_constants.STATE_NOT_INITIALIZED;\n this.lastErrorCode = 0;\n this.listenerArray = [];\n\n this.#timeout = null;\n this.#error_codes = error_codes;\n\n this.settings = settings;\n this.apiLogLevel = this.settings.logLevel;\n this.selfReportSessionTime = this.settings.selfReportSessionTime;\n }\n\n /**\n * Initialize the API\n * @param {string} callbackName\n * @param {string} initializeMessage\n * @param {string} terminationMessage\n * @return {string}\n */\n initialize(\n callbackName: String,\n initializeMessage?: String,\n terminationMessage?: String) {\n let returnValue = global_constants.SCORM_FALSE;\n\n if (this.isInitialized()) {\n this.throwSCORMError(this.#error_codes.INITIALIZED, initializeMessage);\n } else if (this.isTerminated()) {\n this.throwSCORMError(this.#error_codes.TERMINATED, terminationMessage);\n } else {\n if (this.selfReportSessionTime) {\n this.cmi.setStartTime();\n }\n\n this.currentState = global_constants.STATE_INITIALIZED;\n this.lastErrorCode = 0;\n returnValue = global_constants.SCORM_TRUE;\n this.processListeners(callbackName);\n }\n\n this.apiLog(callbackName, null, 'returned: ' + returnValue,\n global_constants.LOG_LEVEL_INFO);\n this.clearSCORMError(returnValue);\n\n return returnValue;\n }\n\n /**\n * Getter for #error_codes\n * @return {object}\n */\n get error_codes() {\n return this.#error_codes;\n }\n\n /**\n * Getter for #settings\n * @return {object}\n */\n get settings() {\n return this.#settings;\n }\n\n /**\n * Setter for #settings\n * @param {object} settings\n */\n set settings(settings: Object) {\n this.#settings = {...this.#settings, ...settings};\n }\n\n /**\n * Terminates the current run of the API\n * @param {string} callbackName\n * @param {boolean} checkTerminated\n * @return {string}\n */\n terminate(\n callbackName: String,\n checkTerminated: boolean) {\n let returnValue = global_constants.SCORM_FALSE;\n\n if (this.checkState(checkTerminated,\n this.#error_codes.TERMINATION_BEFORE_INIT,\n this.#error_codes.MULTIPLE_TERMINATION)) {\n this.currentState = global_constants.STATE_TERMINATED;\n\n const result = this.storeData(true);\n if (!this.settings.sendBeaconCommit && !this.settings.asyncCommit &&\n typeof result.errorCode !== 'undefined' && result.errorCode > 0) {\n this.throwSCORMError(result.errorCode);\n }\n returnValue = (typeof result !== 'undefined' && result.result) ?\n result.result : global_constants.SCORM_FALSE;\n\n if (checkTerminated) this.lastErrorCode = 0;\n\n returnValue = global_constants.SCORM_TRUE;\n this.processListeners(callbackName);\n }\n\n this.apiLog(callbackName, null, 'returned: ' + returnValue,\n global_constants.LOG_LEVEL_INFO);\n this.clearSCORMError(returnValue);\n\n return returnValue;\n }\n\n /**\n * Get the value of the CMIElement.\n *\n * @param {string} callbackName\n * @param {boolean} checkTerminated\n * @param {string} CMIElement\n * @return {string}\n */\n getValue(\n callbackName: String,\n checkTerminated: boolean,\n CMIElement: String) {\n let returnValue;\n\n if (this.checkState(checkTerminated,\n this.#error_codes.RETRIEVE_BEFORE_INIT,\n this.#error_codes.RETRIEVE_AFTER_TERM)) {\n if (checkTerminated) this.lastErrorCode = 0;\n try {\n returnValue = this.getCMIValue(CMIElement);\n } catch (e) {\n if (e instanceof ValidationError) {\n this.lastErrorCode = e.errorCode;\n returnValue = global_constants.SCORM_FALSE;\n } else {\n if (e.message) {\n console.error(e.message);\n } else {\n console.error(e);\n }\n this.throwSCORMError(this.#error_codes.GENERAL);\n }\n }\n this.processListeners(callbackName, CMIElement);\n }\n\n this.apiLog(callbackName, CMIElement, ': returned: ' + returnValue,\n global_constants.LOG_LEVEL_INFO);\n this.clearSCORMError(returnValue);\n\n return returnValue;\n }\n\n /**\n * Sets the value of the CMIElement.\n *\n * @param {string} callbackName\n * @param {string} commitCallback\n * @param {boolean} checkTerminated\n * @param {string} CMIElement\n * @param {*} value\n * @return {string}\n */\n setValue(\n callbackName: String,\n commitCallback: String,\n checkTerminated: boolean,\n CMIElement,\n value) {\n if (value !== undefined) {\n value = String(value);\n }\n let returnValue = global_constants.SCORM_FALSE;\n\n if (this.checkState(checkTerminated, this.#error_codes.STORE_BEFORE_INIT,\n this.#error_codes.STORE_AFTER_TERM)) {\n if (checkTerminated) this.lastErrorCode = 0;\n try {\n returnValue = this.setCMIValue(CMIElement, value);\n } catch (e) {\n if (e instanceof ValidationError) {\n this.lastErrorCode = e.errorCode;\n returnValue = global_constants.SCORM_FALSE;\n } else {\n if (e.message) {\n console.error(e.message);\n } else {\n console.error(e);\n }\n this.throwSCORMError(this.#error_codes.GENERAL);\n }\n }\n this.processListeners(callbackName, CMIElement, value);\n }\n\n if (returnValue === undefined) {\n returnValue = global_constants.SCORM_FALSE;\n }\n\n // If we didn't have any errors while setting the data, go ahead and\n // schedule a commit, if autocommit is turned on\n if (String(this.lastErrorCode) === '0') {\n if (this.settings.autocommit && !this.#timeout) {\n this.scheduleCommit(this.settings.autocommitSeconds * 1000, commitCallback);\n }\n }\n\n this.apiLog(callbackName, CMIElement,\n ': ' + value + ': result: ' + returnValue,\n global_constants.LOG_LEVEL_INFO);\n this.clearSCORMError(returnValue);\n\n return returnValue;\n }\n\n /**\n * Orders LMS to store all content parameters\n * @param {string} callbackName\n * @param {boolean} checkTerminated\n * @return {string}\n */\n commit(\n callbackName: String,\n checkTerminated: boolean) {\n this.clearScheduledCommit();\n\n let returnValue = global_constants.SCORM_FALSE;\n\n if (this.checkState(checkTerminated, this.#error_codes.COMMIT_BEFORE_INIT,\n this.#error_codes.COMMIT_AFTER_TERM)) {\n const result = this.storeData(false);\n if (!this.settings.sendBeaconCommit && !this.settings.asyncCommit &&\n result.errorCode && result.errorCode > 0) {\n this.throwSCORMError(result.errorCode);\n }\n returnValue = (typeof result !== 'undefined' && result.result) ?\n result.result : global_constants.SCORM_FALSE;\n\n this.apiLog(callbackName, 'HttpRequest', ' Result: ' + returnValue,\n global_constants.LOG_LEVEL_DEBUG);\n\n if (checkTerminated) this.lastErrorCode = 0;\n\n this.processListeners(callbackName);\n }\n\n this.apiLog(callbackName, null, 'returned: ' + returnValue,\n global_constants.LOG_LEVEL_INFO);\n this.clearSCORMError(returnValue);\n\n return returnValue;\n }\n\n /**\n * Returns last error code\n * @param {string} callbackName\n * @return {string}\n */\n getLastError(callbackName: String) {\n const returnValue = String(this.lastErrorCode);\n\n this.processListeners(callbackName);\n\n this.apiLog(callbackName, null, 'returned: ' + returnValue,\n global_constants.LOG_LEVEL_INFO);\n\n return returnValue;\n }\n\n /**\n * Returns the errorNumber error description\n *\n * @param {string} callbackName\n * @param {(string|number)} CMIErrorCode\n * @return {string}\n */\n getErrorString(callbackName: String, CMIErrorCode) {\n let returnValue = '';\n\n if (CMIErrorCode !== null && CMIErrorCode !== '') {\n returnValue = this.getLmsErrorMessageDetails(CMIErrorCode);\n this.processListeners(callbackName);\n }\n\n this.apiLog(callbackName, null, 'returned: ' + returnValue,\n global_constants.LOG_LEVEL_INFO);\n\n return returnValue;\n }\n\n /**\n * Returns a comprehensive description of the errorNumber error.\n *\n * @param {string} callbackName\n * @param {(string|number)} CMIErrorCode\n * @return {string}\n */\n getDiagnostic(callbackName: String, CMIErrorCode) {\n let returnValue = '';\n\n if (CMIErrorCode !== null && CMIErrorCode !== '') {\n returnValue = this.getLmsErrorMessageDetails(CMIErrorCode, true);\n this.processListeners(callbackName);\n }\n\n this.apiLog(callbackName, null, 'returned: ' + returnValue,\n global_constants.LOG_LEVEL_INFO);\n\n return returnValue;\n }\n\n /**\n * Checks the LMS state and ensures it has been initialized.\n *\n * @param {boolean} checkTerminated\n * @param {number} beforeInitError\n * @param {number} afterTermError\n * @return {boolean}\n */\n checkState(\n checkTerminated: boolean,\n beforeInitError: number,\n afterTermError?: number) {\n if (this.isNotInitialized()) {\n this.throwSCORMError(beforeInitError);\n return false;\n } else if (checkTerminated && this.isTerminated()) {\n this.throwSCORMError(afterTermError);\n return false;\n }\n\n return true;\n }\n\n /**\n * Logging for all SCORM actions\n *\n * @param {string} functionName\n * @param {string} CMIElement\n * @param {string} logMessage\n * @param {number}messageLevel\n */\n apiLog(\n functionName: String,\n CMIElement: String,\n logMessage: String,\n messageLevel: number) {\n logMessage = this.formatMessage(functionName, CMIElement, logMessage);\n\n if (messageLevel >= this.apiLogLevel) {\n switch (messageLevel) {\n case global_constants.LOG_LEVEL_ERROR:\n console.error(logMessage);\n break;\n case global_constants.LOG_LEVEL_WARNING:\n console.warn(logMessage);\n break;\n case global_constants.LOG_LEVEL_INFO:\n console.info(logMessage);\n break;\n case global_constants.LOG_LEVEL_DEBUG:\n if (console.debug) {\n console.debug(logMessage);\n } else {\n console.log(logMessage);\n }\n break;\n }\n }\n }\n\n /**\n * Formats the SCORM messages for easy reading\n *\n * @param {string} functionName\n * @param {string} CMIElement\n * @param {string} message\n * @return {string}\n */\n formatMessage(functionName: String, CMIElement: String, message: String) {\n const baseLength = 20;\n let messageString = '';\n\n messageString += functionName;\n\n let fillChars = baseLength - messageString.length;\n\n for (let i = 0; i < fillChars; i++) {\n messageString += ' ';\n }\n\n messageString += ': ';\n\n if (CMIElement) {\n const CMIElementBaseLength = 70;\n\n messageString += CMIElement;\n\n fillChars = CMIElementBaseLength - messageString.length;\n\n for (let j = 0; j < fillChars; j++) {\n messageString += ' ';\n }\n }\n\n if (message) {\n messageString += message;\n }\n\n return messageString;\n }\n\n /**\n * Checks to see if {str} contains {tester}\n *\n * @param {string} str String to check against\n * @param {string} tester String to check for\n * @return {boolean}\n */\n stringMatches(str: String, tester: String) {\n return str && tester && str.match(tester);\n }\n\n /**\n * Check to see if the specific object has the given property\n * @param {*} refObject\n * @param {string} attribute\n * @return {boolean}\n * @private\n */\n _checkObjectHasProperty(refObject, attribute: String) {\n return Object.hasOwnProperty.call(refObject, attribute) ||\n Object.getOwnPropertyDescriptor(\n Object.getPrototypeOf(refObject), attribute) ||\n (attribute in refObject);\n }\n\n /**\n * Returns the message that corresponds to errorNumber\n * APIs that inherit BaseAPI should override this function\n *\n * @param {(string|number)} _errorNumber\n * @param {boolean} _detail\n * @return {string}\n * @abstract\n */\n getLmsErrorMessageDetails(_errorNumber, _detail) {\n throw new Error(\n 'The getLmsErrorMessageDetails method has not been implemented');\n }\n\n /**\n * Gets the value for the specific element.\n * APIs that inherit BaseAPI should override this function\n *\n * @param {string} _CMIElement\n * @return {string}\n * @abstract\n */\n getCMIValue(_CMIElement) {\n throw new Error('The getCMIValue method has not been implemented');\n }\n\n /**\n * Sets the value for the specific element.\n * APIs that inherit BaseAPI should override this function\n *\n * @param {string} _CMIElement\n * @param {any} _value\n * @return {string}\n * @abstract\n */\n setCMIValue(_CMIElement, _value) {\n throw new Error('The setCMIValue method has not been implemented');\n }\n\n /**\n * Shared API method to set a valid for a given element.\n *\n * @param {string} methodName\n * @param {boolean} scorm2004\n * @param {string} CMIElement\n * @param {*} value\n * @return {string}\n */\n _commonSetCMIValue(\n methodName: String, scorm2004: boolean, CMIElement, value) {\n if (!CMIElement || CMIElement === '') {\n return global_constants.SCORM_FALSE;\n }\n\n const structure = CMIElement.split('.');\n let refObject = this;\n let returnValue = global_constants.SCORM_FALSE;\n let foundFirstIndex = false;\n\n const invalidErrorMessage = `The data model element passed to ${methodName} (${CMIElement}) is not a valid SCORM data model element.`;\n const invalidErrorCode = scorm2004 ?\n this.#error_codes.UNDEFINED_DATA_MODEL :\n this.#error_codes.GENERAL;\n\n for (let i = 0; i < structure.length; i++) {\n const attribute = structure[i];\n\n if (i === structure.length - 1) {\n if (scorm2004 && (attribute.substr(0, 8) === '{target=') &&\n (typeof refObject._isTargetValid == 'function')) {\n this.throwSCORMError(this.#error_codes.READ_ONLY_ELEMENT);\n } else if (!this._checkObjectHasProperty(refObject, attribute)) {\n this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n } else {\n if (this.isInitialized() &&\n this.stringMatches(CMIElement, '\\\\.correct_responses\\\\.\\\\d+')) {\n this.validateCorrectResponse(CMIElement, value);\n }\n\n if (!scorm2004 || this.lastErrorCode === 0) {\n refObject[attribute] = value;\n returnValue = global_constants.SCORM_TRUE;\n }\n }\n } else {\n refObject = refObject[attribute];\n if (!refObject) {\n this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n break;\n }\n\n if (refObject instanceof CMIArray) {\n const index = parseInt(structure[i + 1], 10);\n\n // SCO is trying to set an item on an array\n if (!isNaN(index)) {\n const item = refObject.childArray[index];\n\n if (item) {\n refObject = item;\n foundFirstIndex = true;\n } else {\n const newChild = this.getChildElement(CMIElement, value,\n foundFirstIndex);\n foundFirstIndex = true;\n\n if (!newChild) {\n this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n } else {\n if (refObject.initialized) newChild.initialize();\n\n refObject.childArray.push(newChild);\n refObject = newChild;\n }\n }\n\n // Have to update i value to skip the array position\n i++;\n }\n }\n }\n }\n\n if (returnValue === global_constants.SCORM_FALSE) {\n this.apiLog(methodName, null,\n `There was an error setting the value for: ${CMIElement}, value of: ${value}`,\n global_constants.LOG_LEVEL_WARNING);\n }\n\n return returnValue;\n }\n\n /**\n * Abstract method for validating that a response is correct.\n *\n * @param {string} _CMIElement\n * @param {*} _value\n */\n validateCorrectResponse(_CMIElement, _value) {\n // just a stub method\n }\n\n /**\n * Gets or builds a new child element to add to the array.\n * APIs that inherit BaseAPI should override this method.\n *\n * @param {string} _CMIElement - unused\n * @param {*} _value - unused\n * @param {boolean} _foundFirstIndex - unused\n * @return {*}\n * @abstract\n */\n getChildElement(_CMIElement, _value, _foundFirstIndex) {\n throw new Error('The getChildElement method has not been implemented');\n }\n\n /**\n * Gets a value from the CMI Object\n *\n * @param {string} methodName\n * @param {boolean} scorm2004\n * @param {string} CMIElement\n * @return {*}\n */\n _commonGetCMIValue(methodName: String, scorm2004: boolean, CMIElement) {\n if (!CMIElement || CMIElement === '') {\n return '';\n }\n\n const structure = CMIElement.split('.');\n let refObject = this;\n let attribute = null;\n\n const uninitializedErrorMessage = `The data model element passed to ${methodName} (${CMIElement}) has not been initialized.`;\n const invalidErrorMessage = `The data model element passed to ${methodName} (${CMIElement}) is not a valid SCORM data model element.`;\n const invalidErrorCode = scorm2004 ?\n this.#error_codes.UNDEFINED_DATA_MODEL :\n this.#error_codes.GENERAL;\n\n for (let i = 0; i < structure.length; i++) {\n attribute = structure[i];\n\n if (!scorm2004) {\n if (i === structure.length - 1) {\n if (!this._checkObjectHasProperty(refObject, attribute)) {\n this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n return;\n }\n }\n } else {\n if ((String(attribute).substr(0, 8) === '{target=') &&\n (typeof refObject._isTargetValid == 'function')) {\n const target = String(attribute).\n substr(8, String(attribute).length - 9);\n return refObject._isTargetValid(target);\n } else if (!this._checkObjectHasProperty(refObject, attribute)) {\n this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n return;\n }\n }\n\n refObject = refObject[attribute];\n if (refObject === undefined) {\n this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n break;\n }\n\n if (refObject instanceof CMIArray) {\n const index = parseInt(structure[i + 1], 10);\n\n // SCO is trying to set an item on an array\n if (!isNaN(index)) {\n const item = refObject.childArray[index];\n\n if (item) {\n refObject = item;\n } else {\n this.throwSCORMError(this.#error_codes.VALUE_NOT_INITIALIZED,\n uninitializedErrorMessage);\n break;\n }\n\n // Have to update i value to skip the array position\n i++;\n }\n }\n }\n\n if (refObject === null || refObject === undefined) {\n if (!scorm2004) {\n if (attribute === '_children') {\n this.throwSCORMError(scorm12_error_codes.CHILDREN_ERROR);\n } else if (attribute === '_count') {\n this.throwSCORMError(scorm12_error_codes.COUNT_ERROR);\n }\n }\n } else {\n return refObject;\n }\n }\n\n /**\n * Returns true if the API's current state is STATE_INITIALIZED\n *\n * @return {boolean}\n */\n isInitialized() {\n return this.currentState === global_constants.STATE_INITIALIZED;\n }\n\n /**\n * Returns true if the API's current state is STATE_NOT_INITIALIZED\n *\n * @return {boolean}\n */\n isNotInitialized() {\n return this.currentState === global_constants.STATE_NOT_INITIALIZED;\n }\n\n /**\n * Returns true if the API's current state is STATE_TERMINATED\n *\n * @return {boolean}\n */\n isTerminated() {\n return this.currentState === global_constants.STATE_TERMINATED;\n }\n\n /**\n * Provides a mechanism for attaching to a specific SCORM event\n *\n * @param {string} listenerName\n * @param {function} callback\n */\n on(listenerName: String, callback: function) {\n if (!callback) return;\n\n const listenerFunctions = listenerName.split(' ');\n for (let i = 0; i < listenerFunctions.length; i++) {\n const listenerSplit = listenerFunctions[i].split('.');\n if (listenerSplit.length === 0) return;\n\n const functionName = listenerSplit[0];\n\n let CMIElement = null;\n if (listenerSplit.length > 1) {\n CMIElement = listenerName.replace(functionName + '.', '');\n }\n\n this.listenerArray.push({\n functionName: functionName,\n CMIElement: CMIElement,\n callback: callback,\n });\n\n this.apiLog('on', functionName, `Added event listener: ${this.listenerArray.length}`, global_constants.LOG_LEVEL_INFO);\n }\n }\n\n /**\n * Provides a mechanism for detaching a specific SCORM event listener\n *\n * @param {string} listenerName\n * @param {function} callback\n */\n off(listenerName: String, callback: function) {\n if (!callback) return;\n\n const listenerFunctions = listenerName.split(' ');\n for (let i = 0; i < listenerFunctions.length; i++) {\n const listenerSplit = listenerFunctions[i].split('.');\n if (listenerSplit.length === 0) return;\n\n const functionName = listenerSplit[0];\n\n let CMIElement = null;\n if (listenerSplit.length > 1) {\n CMIElement = listenerName.replace(functionName + '.', '');\n }\n\n const removeIndex = this.listenerArray.findIndex((obj) =>\n obj.functionName === functionName &&\n obj.CMIElement === CMIElement &&\n obj.callback === callback\n );\n if (removeIndex !== -1) {\n this.listenerArray.splice(removeIndex, 1);\n this.apiLog('off', functionName, `Removed event listener: ${this.listenerArray.length}`, global_constants.LOG_LEVEL_INFO);\n }\n }\n }\n\n /**\n * Provides a mechanism for clearing all listeners from a specific SCORM event\n *\n * @param {string} listenerName\n */\n clear(listenerName: String) {\n const listenerFunctions = listenerName.split(' ');\n for (let i = 0; i < listenerFunctions.length; i++) {\n const listenerSplit = listenerFunctions[i].split('.');\n if (listenerSplit.length === 0) return;\n\n const functionName = listenerSplit[0];\n\n let CMIElement = null;\n if (listenerSplit.length > 1) {\n CMIElement = listenerName.replace(functionName + '.', '');\n }\n\n this.listenerArray = this.listenerArray.filter((obj) =>\n obj.functionName !== functionName &&\n obj.CMIElement !== CMIElement,\n );\n }\n }\n\n /**\n * Processes any 'on' listeners that have been created\n *\n * @param {string} functionName\n * @param {string} CMIElement\n * @param {*} value\n */\n processListeners(functionName: String, CMIElement: String, value: any) {\n this.apiLog(functionName, CMIElement, value);\n for (let i = 0; i < this.listenerArray.length; i++) {\n const listener = this.listenerArray[i];\n const functionsMatch = listener.functionName === functionName;\n const listenerHasCMIElement = !!listener.CMIElement;\n let CMIElementsMatch = false;\n if (CMIElement && listener.CMIElement &&\n listener.CMIElement.substring(listener.CMIElement.length - 1) ===\n '*') {\n CMIElementsMatch = CMIElement.indexOf(listener.CMIElement.substring(0,\n listener.CMIElement.length - 1)) === 0;\n } else {\n CMIElementsMatch = listener.CMIElement === CMIElement;\n }\n\n if (functionsMatch && (!listenerHasCMIElement || CMIElementsMatch)) {\n listener.callback(CMIElement, value);\n }\n }\n }\n\n /**\n * Throws a SCORM error\n *\n * @param {number} errorNumber\n * @param {string} message\n */\n throwSCORMError(errorNumber: number, message: String) {\n if (!message) {\n message = this.getLmsErrorMessageDetails(errorNumber);\n }\n\n this.apiLog('throwSCORMError', null, errorNumber + ': ' + message,\n global_constants.LOG_LEVEL_ERROR);\n\n this.lastErrorCode = String(errorNumber);\n }\n\n /**\n * Clears the last SCORM error code on success.\n *\n * @param {string} success\n */\n clearSCORMError(success: String) {\n if (success !== undefined && success !== global_constants.SCORM_FALSE) {\n this.lastErrorCode = 0;\n }\n }\n\n /**\n * Attempts to store the data to the LMS, logs data if no LMS configured\n * APIs that inherit BaseAPI should override this function\n *\n * @param {boolean} _calculateTotalTime\n * @return {string}\n * @abstract\n */\n storeData(_calculateTotalTime) {\n throw new Error(\n 'The storeData method has not been implemented');\n }\n\n /**\n * Load the CMI from a flattened JSON object\n * @param {object} json\n * @param {string} CMIElement\n */\n loadFromFlattenedJSON(json, CMIElement) {\n if (!this.isNotInitialized()) {\n console.error(\n 'loadFromFlattenedJSON can only be called before the call to lmsInitialize.');\n return;\n }\n\n /**\n * Test match pattern.\n *\n * @param {string} a\n * @param {string} c\n * @param {RegExp} a_pattern\n * @return {number}\n */\n function testPattern(a, c, a_pattern) {\n const a_match = a.match(a_pattern);\n\n let c_match;\n if (a_match !== null && (c_match = c.match(a_pattern)) !== null) {\n const a_num = Number(a_match[2]);\n const c_num = Number(c_match[2]);\n if (a_num === c_num) {\n if (a_match[3] === 'id') {\n return -1;\n } else if (a_match[3] === 'type') {\n if (c_match[3] === 'id') {\n return 1;\n } else {\n return -1;\n }\n } else {\n return 1;\n }\n }\n return a_num - c_num;\n }\n\n return null;\n }\n\n const int_pattern = /^(cmi\\.interactions\\.)(\\d+)\\.(.*)$/;\n const obj_pattern = /^(cmi\\.objectives\\.)(\\d+)\\.(.*)$/;\n\n const result = Object.keys(json).map(function(key) {\n return [String(key), json[key]];\n });\n\n // CMI interactions need to have id and type loaded before any other fields\n result.sort(function([a, b], [c, d]) {\n let test;\n if ((test = testPattern(a, c, int_pattern)) !== null) {\n return test;\n }\n if ((test = testPattern(a, c, obj_pattern)) !== null) {\n return test;\n }\n\n if (a < c) {\n return -1;\n }\n if (a > c) {\n return 1;\n }\n return 0;\n });\n\n let obj;\n result.forEach((element) => {\n obj = {};\n obj[element[0]] = element[1];\n this.loadFromJSON(unflatten(obj), CMIElement);\n });\n }\n\n /**\n * Loads CMI data from a JSON object.\n *\n * @param {object} json\n * @param {string} CMIElement\n */\n loadFromJSON(json, CMIElement) {\n if (!this.isNotInitialized()) {\n console.error(\n 'loadFromJSON can only be called before the call to lmsInitialize.');\n return;\n }\n\n CMIElement = CMIElement !== undefined ? CMIElement : 'cmi';\n\n this.startingData = json;\n\n // could this be refactored down to flatten(json) then setCMIValue on each?\n for (const key in json) {\n if ({}.hasOwnProperty.call(json, key) && json[key]) {\n const currentCMIElement = (CMIElement ? CMIElement + '.' : '') + key;\n const value = json[key];\n\n if (value['childArray']) {\n for (let i = 0; i < value['childArray'].length; i++) {\n this.loadFromJSON(value['childArray'][i],\n currentCMIElement + '.' + i);\n }\n } else if (value.constructor === Object) {\n this.loadFromJSON(value, currentCMIElement);\n } else {\n this.setCMIValue(currentCMIElement, value);\n }\n }\n }\n }\n\n /**\n * Render the CMI object to JSON for sending to an LMS.\n *\n * @return {string}\n */\n renderCMIToJSONString() {\n const cmi = this.cmi;\n // Do we want/need to return fields that have no set value?\n // return JSON.stringify({ cmi }, (k, v) => v === undefined ? null : v, 2);\n return JSON.stringify({cmi});\n }\n\n /**\n * Returns a JS object representing the current cmi\n * @return {object}\n */\n renderCMIToJSONObject() {\n // Do we want/need to return fields that have no set value?\n // return JSON.stringify({ cmi }, (k, v) => v === undefined ? null : v, 2);\n return JSON.parse(this.renderCMIToJSONString());\n }\n\n /**\n * Render the cmi object to the proper format for LMS commit\n * APIs that inherit BaseAPI should override this function\n *\n * @param {boolean} _terminateCommit\n * @return {*}\n * @abstract\n */\n renderCommitCMI(_terminateCommit) {\n throw new Error(\n 'The storeData method has not been implemented');\n }\n\n /**\n * Send the request to the LMS\n * @param {string} url\n * @param {object|Array} params\n * @param {boolean} immediate\n * @return {object}\n */\n processHttpRequest(url: String, params, immediate = false) {\n const api = this;\n const process = function(url, params, settings, error_codes) {\n const genericError = {\n 'result': global_constants.SCORM_FALSE,\n 'errorCode': error_codes.GENERAL,\n };\n\n let result;\n if (!settings.sendBeaconCommit) {\n const httpReq = new XMLHttpRequest();\n httpReq.open('POST', url, settings.asyncCommit);\n if (settings.asyncCommit) {\n httpReq.onload = function(e) {\n if (typeof settings.responseHandler === 'function') {\n result = settings.responseHandler(httpReq);\n } else {\n result = JSON.parse(httpReq.responseText);\n }\n };\n }\n try {\n if (params instanceof Array) {\n httpReq.setRequestHeader('Content-Type',\n 'application/x-www-form-urlencoded');\n httpReq.send(params.join('&'));\n } else {\n httpReq.setRequestHeader('Content-Type',\n settings.commitRequestDataType);\n httpReq.send(JSON.stringify(params));\n }\n\n if (!settings.asyncCommit) {\n if (typeof settings.responseHandler === 'function') {\n result = settings.responseHandler(httpReq);\n } else {\n result = JSON.parse(httpReq.responseText);\n }\n } else {\n result = {};\n result.result = global_constants.SCORM_TRUE;\n result.errorCode = 0;\n api.processListeners('CommitSuccess');\n return result;\n }\n } catch (e) {\n console.error(e);\n api.processListeners('CommitError');\n return genericError;\n }\n } else {\n try {\n const headers = {\n type: settings.commitRequestDataType,\n };\n let blob;\n if (params instanceof Array) {\n blob = new Blob([params.join('&')], headers);\n } else {\n blob = new Blob([JSON.stringify(params)], headers);\n }\n\n result = {};\n if (navigator.sendBeacon(url, blob)) {\n result.result = global_constants.SCORM_TRUE;\n result.errorCode = 0;\n } else {\n result.result = global_constants.SCORM_FALSE;\n result.errorCode = 101;\n }\n } catch (e) {\n console.error(e);\n api.processListeners('CommitError');\n return genericError;\n }\n }\n\n if (typeof result === 'undefined') {\n api.processListeners('CommitError');\n return genericError;\n }\n\n if (result.result === true ||\n result.result === global_constants.SCORM_TRUE) {\n api.processListeners('CommitSuccess');\n } else {\n api.processListeners('CommitError');\n }\n\n return result;\n };\n\n if (typeof debounce !== 'undefined') {\n const debounced = debounce(process, 500);\n debounced(url, params, this.settings, this.error_codes);\n\n // if we're terminating, go ahead and commit immediately\n if (immediate) {\n debounced.flush();\n }\n\n return {\n result: global_constants.SCORM_TRUE,\n errorCode: 0,\n };\n } else {\n return process(url, params, this.settings, this.error_codes);\n }\n }\n\n /**\n * Throws a SCORM error\n *\n * @param {number} when - the number of milliseconds to wait before committing\n * @param {string} callback - the name of the commit event callback\n */\n scheduleCommit(when: number, callback: string) {\n this.#timeout = new ScheduledCommit(this, when, callback);\n this.apiLog('scheduleCommit', '', 'scheduled',\n global_constants.LOG_LEVEL_DEBUG);\n }\n\n /**\n * Clears and cancels any currently scheduled commits\n */\n clearScheduledCommit() {\n if (this.#timeout) {\n this.#timeout.cancel();\n this.#timeout = null;\n this.apiLog('clearScheduledCommit', '', 'cleared',\n global_constants.LOG_LEVEL_DEBUG);\n }\n }\n}\n\n/**\n * Private class that wraps a timeout call to the commit() function\n */\nclass ScheduledCommit {\n #API;\n #cancelled = false;\n #timeout;\n #callback;\n\n /**\n * Constructor for ScheduledCommit\n * @param {BaseAPI} API\n * @param {number} when\n * @param {string} callback\n */\n constructor(API: any, when: number, callback: string) {\n this.#API = API;\n this.#timeout = setTimeout(this.wrapper.bind(this), when);\n this.#callback = callback;\n }\n\n /**\n * Cancel any currently scheduled commit\n */\n cancel() {\n this.#cancelled = true;\n if (this.#timeout) {\n clearTimeout(this.#timeout);\n }\n }\n\n /**\n * Wrap the API commit call to check if the call has already been cancelled\n */\n wrapper() {\n if (!this.#cancelled) {\n this.#API.commit(this.#callback);\n }\n }\n}\n","// @flow\nimport BaseAPI from './BaseAPI';\nimport {\n CMI,\n CMIInteractionsCorrectResponsesObject,\n CMIInteractionsObject,\n CMIInteractionsObjectivesObject,\n CMIObjectivesObject, NAV,\n} from './cmi/scorm12_cmi';\nimport * as Utilities from './utilities';\nimport APIConstants from './constants/api_constants';\nimport ErrorCodes from './constants/error_codes';\n\nconst scorm12_constants = APIConstants.scorm12;\nconst global_constants = APIConstants.global;\nconst scorm12_error_codes = ErrorCodes.scorm12;\n\n/**\n * API class for SCORM 1.2\n */\nexport default class Scorm12API extends BaseAPI {\n /**\n * Constructor for SCORM 1.2 API\n * @param {object} settings\n */\n constructor(settings: {}) {\n const finalSettings = {\n ...{\n mastery_override: false,\n }, ...settings,\n };\n\n super(scorm12_error_codes, finalSettings);\n\n this.cmi = new CMI();\n this.nav = new NAV();\n\n // Rename functions to match 1.2 Spec and expose to modules\n this.LMSInitialize = this.lmsInitialize;\n this.LMSFinish = this.lmsFinish;\n this.LMSGetValue = this.lmsGetValue;\n this.LMSSetValue = this.lmsSetValue;\n this.LMSCommit = this.lmsCommit;\n this.LMSGetLastError = this.lmsGetLastError;\n this.LMSGetErrorString = this.lmsGetErrorString;\n this.LMSGetDiagnostic = this.lmsGetDiagnostic;\n }\n\n /**\n * lmsInitialize function from SCORM 1.2 Spec\n *\n * @return {string} bool\n */\n lmsInitialize() {\n this.cmi.initialize();\n return this.initialize('LMSInitialize', 'LMS was already initialized!',\n 'LMS is already finished!');\n }\n\n /**\n * LMSFinish function from SCORM 1.2 Spec\n *\n * @return {string} bool\n */\n lmsFinish() {\n const result = this.terminate('LMSFinish', true);\n\n if (result === global_constants.SCORM_TRUE) {\n if (this.nav.event !== '') {\n if (this.nav.event === 'continue') {\n this.processListeners('SequenceNext');\n } else {\n this.processListeners('SequencePrevious');\n }\n } else if (this.settings.autoProgress) {\n this.processListeners('SequenceNext');\n }\n }\n\n return result;\n }\n\n /**\n * LMSGetValue function from SCORM 1.2 Spec\n *\n * @param {string} CMIElement\n * @return {string}\n */\n lmsGetValue(CMIElement) {\n return this.getValue('LMSGetValue', false, CMIElement);\n }\n\n /**\n * LMSSetValue function from SCORM 1.2 Spec\n *\n * @param {string} CMIElement\n * @param {*} value\n * @return {string}\n */\n lmsSetValue(CMIElement, value) {\n return this.setValue('LMSSetValue', 'LMSCommit', false, CMIElement, value);\n }\n\n /**\n * LMSCommit function from SCORM 1.2 Spec\n *\n * @return {string} bool\n */\n lmsCommit() {\n return this.commit('LMSCommit', false);\n }\n\n /**\n * LMSGetLastError function from SCORM 1.2 Spec\n *\n * @return {string}\n */\n lmsGetLastError() {\n return this.getLastError('LMSGetLastError');\n }\n\n /**\n * LMSGetErrorString function from SCORM 1.2 Spec\n *\n * @param {string} CMIErrorCode\n * @return {string}\n */\n lmsGetErrorString(CMIErrorCode) {\n return this.getErrorString('LMSGetErrorString', CMIErrorCode);\n }\n\n /**\n * LMSGetDiagnostic function from SCORM 1.2 Spec\n *\n * @param {string} CMIErrorCode\n * @return {string}\n */\n lmsGetDiagnostic(CMIErrorCode) {\n return this.getDiagnostic('LMSGetDiagnostic', CMIErrorCode);\n }\n\n /**\n * Sets a value on the CMI Object\n *\n * @param {string} CMIElement\n * @param {*} value\n * @return {string}\n */\n setCMIValue(CMIElement, value) {\n return this._commonSetCMIValue('LMSSetValue', false, CMIElement, value);\n }\n\n /**\n * Gets a value from the CMI Object\n *\n * @param {string} CMIElement\n * @return {*}\n */\n getCMIValue(CMIElement) {\n return this._commonGetCMIValue('getCMIValue', false, CMIElement);\n }\n\n /**\n * Gets or builds a new child element to add to the array.\n *\n * @param {string} CMIElement\n * @param {*} value\n * @param {boolean} foundFirstIndex\n * @return {object}\n */\n getChildElement(CMIElement, value, foundFirstIndex) {\n let newChild;\n\n if (this.stringMatches(CMIElement, 'cmi\\\\.objectives\\\\.\\\\d+')) {\n newChild = new CMIObjectivesObject();\n } else if (foundFirstIndex && this.stringMatches(CMIElement,\n 'cmi\\\\.interactions\\\\.\\\\d+\\\\.correct_responses\\\\.\\\\d+')) {\n newChild = new CMIInteractionsCorrectResponsesObject();\n } else if (foundFirstIndex && this.stringMatches(CMIElement,\n 'cmi\\\\.interactions\\\\.\\\\d+\\\\.objectives\\\\.\\\\d+')) {\n newChild = new CMIInteractionsObjectivesObject();\n } else if (!foundFirstIndex &&\n this.stringMatches(CMIElement, 'cmi\\\\.interactions\\\\.\\\\d+')) {\n newChild = new CMIInteractionsObject();\n }\n\n return newChild;\n }\n\n /**\n * Validates Correct Response values\n *\n * @param {string} CMIElement\n * @param {*} value\n * @return {boolean}\n */\n validateCorrectResponse(CMIElement, value) {\n return true;\n }\n\n /**\n * Returns the message that corresponds to errorNumber.\n *\n * @param {*} errorNumber\n * @param {boolean} detail\n * @return {string}\n */\n getLmsErrorMessageDetails(errorNumber, detail) {\n let basicMessage = 'No Error';\n let detailMessage = 'No Error';\n\n // Set error number to string since inconsistent from modules if string or number\n errorNumber = String(errorNumber);\n if (scorm12_constants.error_descriptions[errorNumber]) {\n basicMessage = scorm12_constants.error_descriptions[errorNumber].basicMessage;\n detailMessage = scorm12_constants.error_descriptions[errorNumber].detailMessage;\n }\n\n return detail ? detailMessage : basicMessage;\n }\n\n /**\n * Replace the whole API with another\n *\n * @param {Scorm12API} newAPI\n */\n replaceWithAnotherScormAPI(newAPI) {\n // Data Model\n this.cmi = newAPI.cmi;\n }\n\n /**\n * Render the cmi object to the proper format for LMS commit\n *\n * @param {boolean} terminateCommit\n * @return {object|Array}\n */\n renderCommitCMI(terminateCommit: boolean) {\n const cmiExport = this.renderCMIToJSONObject();\n\n if (terminateCommit) {\n cmiExport.cmi.core.total_time = this.cmi.getCurrentTotalTime();\n }\n\n const result = [];\n const flattened = Utilities.flatten(cmiExport);\n switch (this.settings.dataCommitFormat) {\n case 'flattened':\n return Utilities.flatten(cmiExport);\n case 'params':\n for (const item in flattened) {\n if ({}.hasOwnProperty.call(flattened, item)) {\n result.push(`${item}=${flattened[item]}`);\n }\n }\n return result;\n case 'json':\n default:\n return cmiExport;\n }\n }\n\n /**\n * Attempts to store the data to the LMS\n *\n * @param {boolean} terminateCommit\n * @return {string}\n */\n storeData(terminateCommit: boolean) {\n if (terminateCommit) {\n const originalStatus = this.cmi.core.lesson_status;\n if (originalStatus === 'not attempted') {\n this.cmi.core.lesson_status = 'completed';\n }\n\n if (this.cmi.core.lesson_mode === 'normal') {\n if (this.cmi.core.credit === 'credit') {\n if (this.settings.mastery_override &&\n this.cmi.student_data.mastery_score !== '' &&\n this.cmi.core.score.raw !== '') {\n if (parseFloat(this.cmi.core.score.raw) >= parseFloat(this.cmi.student_data.mastery_score)) {\n this.cmi.core.lesson_status = 'passed';\n } else {\n this.cmi.core.lesson_status = 'failed';\n }\n }\n }\n } else if (this.cmi.core.lesson_mode === 'browse') {\n if ((this.startingData?.cmi?.core?.lesson_status || '') === '' && originalStatus === 'not attempted') {\n this.cmi.core.lesson_status = 'browsed';\n }\n }\n }\n\n const commitObject = this.renderCommitCMI(terminateCommit ||\n this.settings.alwaysSendTotalTime);\n\n if (this.apiLogLevel === global_constants.LOG_LEVEL_DEBUG) {\n console.debug('Commit (terminated: ' + (terminateCommit ? 'yes' : 'no') + '): ');\n console.debug(commitObject);\n }\n if (this.settings.lmsCommitUrl) {\n return this.processHttpRequest(this.settings.lmsCommitUrl, commitObject, terminateCommit);\n } else {\n return global_constants.SCORM_TRUE;\n }\n }\n}\n","// @flow\nimport BaseAPI from './BaseAPI';\nimport {\n ADL,\n CMI,\n CMICommentsObject,\n CMIInteractionsCorrectResponsesObject,\n CMIInteractionsObject,\n CMIInteractionsObjectivesObject,\n CMIObjectivesObject,\n} from './cmi/scorm2004_cmi';\nimport * as Utilities from './utilities';\nimport APIConstants from './constants/api_constants';\nimport ErrorCodes from './constants/error_codes';\nimport Responses from './constants/response_constants';\nimport ValidLanguages from './constants/language_constants';\nimport Regex from './constants/regex';\n\nconst scorm2004_constants = APIConstants.scorm2004;\nconst global_constants = APIConstants.global;\nconst scorm2004_error_codes = ErrorCodes.scorm2004;\nconst correct_responses = Responses.correct;\nconst scorm2004_regex = Regex.scorm2004;\n\n/**\n * API class for SCORM 2004\n */\nexport default class Scorm2004API extends BaseAPI {\n #version: '1.0';\n\n /**\n * Constructor for SCORM 2004 API\n * @param {object} settings\n */\n constructor(settings: {}) {\n const finalSettings = {\n ...{\n mastery_override: false,\n }, ...settings,\n };\n\n super(scorm2004_error_codes, finalSettings);\n\n this.cmi = new CMI();\n this.adl = new ADL();\n\n // Rename functions to match 2004 Spec and expose to modules\n this.Initialize = this.lmsInitialize;\n this.Terminate = this.lmsTerminate;\n this.GetValue = this.lmsGetValue;\n this.SetValue = this.lmsSetValue;\n this.Commit = this.lmsCommit;\n this.GetLastError = this.lmsGetLastError;\n this.GetErrorString = this.lmsGetErrorString;\n this.GetDiagnostic = this.lmsGetDiagnostic;\n }\n\n /**\n * Getter for #version\n * @return {string}\n */\n get version() {\n return this.#version;\n }\n\n /**\n * @return {string} bool\n */\n lmsInitialize() {\n this.cmi.initialize();\n return this.initialize('Initialize');\n }\n\n /**\n * @return {string} bool\n */\n lmsTerminate() {\n const result = this.terminate('Terminate', true);\n\n if (result === global_constants.SCORM_TRUE) {\n if (this.adl.nav.request !== '_none_') {\n switch (this.adl.nav.request) {\n case 'continue':\n this.processListeners('SequenceNext');\n break;\n case 'previous':\n this.processListeners('SequencePrevious');\n break;\n case 'choice':\n this.processListeners('SequenceChoice');\n break;\n case 'exit':\n this.processListeners('SequenceExit');\n break;\n case 'exitAll':\n this.processListeners('SequenceExitAll');\n break;\n case 'abandon':\n this.processListeners('SequenceAbandon');\n break;\n case 'abandonAll':\n this.processListeners('SequenceAbandonAll');\n break;\n }\n } else if (this.settings.autoProgress) {\n this.processListeners('SequenceNext');\n }\n }\n\n return result;\n }\n\n /**\n * @param {string} CMIElement\n * @return {string}\n */\n lmsGetValue(CMIElement) {\n return this.getValue('GetValue', true, CMIElement);\n }\n\n /**\n * @param {string} CMIElement\n * @param {any} value\n * @return {string}\n */\n lmsSetValue(CMIElement, value) {\n return this.setValue('SetValue', 'Commit', true, CMIElement, value);\n }\n\n /**\n * Orders LMS to store all content parameters\n *\n * @return {string} bool\n */\n lmsCommit() {\n return this.commit('Commit');\n }\n\n /**\n * Returns last error code\n *\n * @return {string}\n */\n lmsGetLastError() {\n return this.getLastError('GetLastError');\n }\n\n /**\n * Returns the errorNumber error description\n *\n * @param {(string|number)} CMIErrorCode\n * @return {string}\n */\n lmsGetErrorString(CMIErrorCode) {\n return this.getErrorString('GetErrorString', CMIErrorCode);\n }\n\n /**\n * Returns a comprehensive description of the errorNumber error.\n *\n * @param {(string|number)} CMIErrorCode\n * @return {string}\n */\n lmsGetDiagnostic(CMIErrorCode) {\n return this.getDiagnostic('GetDiagnostic', CMIErrorCode);\n }\n\n /**\n * Sets a value on the CMI Object\n *\n * @param {string} CMIElement\n * @param {any} value\n * @return {string}\n */\n setCMIValue(CMIElement, value) {\n return this._commonSetCMIValue('SetValue', true, CMIElement, value);\n }\n\n /**\n * Gets or builds a new child element to add to the array.\n *\n * @param {string} CMIElement\n * @param {any} value\n * @param {boolean} foundFirstIndex\n * @return {any}\n */\n getChildElement(CMIElement, value, foundFirstIndex) {\n let newChild;\n\n if (this.stringMatches(CMIElement, 'cmi\\\\.objectives\\\\.\\\\d+')) {\n newChild = new CMIObjectivesObject();\n } else if (foundFirstIndex && this.stringMatches(CMIElement,\n 'cmi\\\\.interactions\\\\.\\\\d+\\\\.correct_responses\\\\.\\\\d+')) {\n const parts = CMIElement.split('.');\n const index = Number(parts[2]);\n const interaction = this.cmi.interactions.childArray[index];\n if (this.isInitialized()) {\n if (!interaction.type) {\n this.throwSCORMError(\n scorm2004_error_codes.DEPENDENCY_NOT_ESTABLISHED);\n } else {\n this.checkDuplicateChoiceResponse(interaction, value);\n\n const response_type = correct_responses[interaction.type];\n if (response_type) {\n this.checkValidResponseType(response_type, value, interaction.type);\n } else {\n this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE,\n 'Incorrect Response Type: ' + interaction.type);\n }\n }\n }\n if (this.lastErrorCode === 0) {\n newChild = new CMIInteractionsCorrectResponsesObject();\n }\n } else if (foundFirstIndex && this.stringMatches(CMIElement,\n 'cmi\\\\.interactions\\\\.\\\\d+\\\\.objectives\\\\.\\\\d+')) {\n newChild = new CMIInteractionsObjectivesObject();\n } else if (!foundFirstIndex &&\n this.stringMatches(CMIElement, 'cmi\\\\.interactions\\\\.\\\\d+')) {\n newChild = new CMIInteractionsObject();\n } else if (this.stringMatches(CMIElement,\n 'cmi\\\\.comments_from_learner\\\\.\\\\d+')) {\n newChild = new CMICommentsObject();\n } else if (this.stringMatches(CMIElement,\n 'cmi\\\\.comments_from_lms\\\\.\\\\d+')) {\n newChild = new CMICommentsObject(true);\n }\n\n return newChild;\n }\n\n /**\n * Checks for valid response types\n * @param {object} response_type\n * @param {any} value\n * @param {string} interaction_type\n */\n checkValidResponseType(response_type, value, interaction_type) {\n let nodes = [];\n if (response_type?.delimiter) {\n nodes = String(value).split(response_type.delimiter);\n } else {\n nodes[0] = value;\n }\n\n if (nodes.length > 0 && nodes.length <= response_type.max) {\n this.checkCorrectResponseValue(interaction_type, nodes, value);\n } else if (nodes.length > response_type.max) {\n this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE,\n 'Data Model Element Pattern Too Long');\n }\n }\n\n /**\n * Checks for duplicate 'choice' responses.\n * @param {CMIInteractionsObject} interaction\n * @param {any} value\n */\n checkDuplicateChoiceResponse(interaction, value) {\n const interaction_count = interaction.correct_responses._count;\n if (interaction.type === 'choice') {\n for (let i = 0; i < interaction_count && this.lastErrorCode ===\n 0; i++) {\n const response = interaction.correct_responses.childArray[i];\n if (response.pattern === value) {\n this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE);\n }\n }\n }\n }\n\n /**\n * Validate correct response.\n * @param {string} CMIElement\n * @param {*} value\n */\n validateCorrectResponse(CMIElement, value) {\n const parts = CMIElement.split('.');\n const index = Number(parts[2]);\n const pattern_index = Number(parts[4]);\n const interaction = this.cmi.interactions.childArray[index];\n\n const interaction_count = interaction.correct_responses._count;\n this.checkDuplicateChoiceResponse(interaction, value);\n\n const response_type = correct_responses[interaction.type];\n if (typeof response_type.limit === 'undefined' || interaction_count <=\n response_type.limit) {\n this.checkValidResponseType(response_type, value, interaction.type);\n\n if (this.lastErrorCode === 0 &&\n (!response_type.duplicate ||\n !this.checkDuplicatedPattern(interaction.correct_responses,\n pattern_index, value)) ||\n (this.lastErrorCode === 0 && value === '')) {\n // do nothing, we want the inverse\n } else {\n if (this.lastErrorCode === 0) {\n this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE,\n 'Data Model Element Pattern Already Exists');\n }\n }\n } else {\n this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE,\n 'Data Model Element Collection Limit Reached');\n }\n }\n\n /**\n * Gets a value from the CMI Object\n *\n * @param {string} CMIElement\n * @return {*}\n */\n getCMIValue(CMIElement) {\n return this._commonGetCMIValue('GetValue', true, CMIElement);\n }\n\n /**\n * Returns the message that corresponds to errorNumber.\n *\n * @param {(string|number)} errorNumber\n * @param {boolean} detail\n * @return {string}\n */\n getLmsErrorMessageDetails(errorNumber, detail) {\n let basicMessage = '';\n let detailMessage = '';\n\n // Set error number to string since inconsistent from modules if string or number\n errorNumber = String(errorNumber);\n if (scorm2004_constants.error_descriptions[errorNumber]) {\n basicMessage = scorm2004_constants.error_descriptions[errorNumber].basicMessage;\n detailMessage = scorm2004_constants.error_descriptions[errorNumber].detailMessage;\n }\n\n return detail ? detailMessage : basicMessage;\n }\n\n /**\n * Check to see if a correct_response value has been duplicated\n * @param {CMIArray} correct_response\n * @param {number} current_index\n * @param {*} value\n * @return {boolean}\n */\n checkDuplicatedPattern = (correct_response, current_index, value) => {\n let found = false;\n const count = correct_response._count;\n for (let i = 0; i < count && !found; i++) {\n if (i !== current_index && correct_response.childArray[i] === value) {\n found = true;\n }\n }\n return found;\n };\n\n /**\n * Checks for a valid correct_response value\n * @param {string} interaction_type\n * @param {Array} nodes\n * @param {*} value\n */\n checkCorrectResponseValue(interaction_type, nodes, value) {\n const response = correct_responses[interaction_type];\n const formatRegex = new RegExp(response.format);\n for (let i = 0; i < nodes.length && this.lastErrorCode === 0; i++) {\n if (interaction_type.match(\n '^(fill-in|long-fill-in|matching|performance|sequencing)$')) {\n nodes[i] = this.removeCorrectResponsePrefixes(nodes[i]);\n }\n\n if (response?.delimiter2) {\n const values = nodes[i].split(response.delimiter2);\n if (values.length === 2) {\n const matches = values[0].match(formatRegex);\n if (!matches) {\n this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n } else {\n if (!values[1].match(new RegExp(response.format2))) {\n this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n }\n }\n } else {\n this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n }\n } else {\n const matches = nodes[i].match(formatRegex);\n if ((!matches && value !== '') ||\n (!matches && interaction_type === 'true-false')) {\n this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n } else {\n if (interaction_type === 'numeric' && nodes.length > 1) {\n if (Number(nodes[0]) > Number(nodes[1])) {\n this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n }\n } else {\n if (nodes[i] !== '' && response.unique) {\n for (let j = 0; j < i && this.lastErrorCode === 0; j++) {\n if (nodes[i] === nodes[j]) {\n this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n }\n }\n }\n }\n }\n }\n }\n }\n\n /**\n * Remove prefixes from correct_response\n * @param {string} node\n * @return {*}\n */\n removeCorrectResponsePrefixes(node) {\n let seenOrder = false;\n let seenCase = false;\n let seenLang = false;\n\n const prefixRegex = new RegExp(\n '^({(lang|case_matters|order_matters)=([^}]+)})');\n let matches = node.match(prefixRegex);\n let langMatches = null;\n while (matches) {\n switch (matches[2]) {\n case 'lang':\n langMatches = node.match(scorm2004_regex.CMILangcr);\n if (langMatches) {\n const lang = langMatches[3];\n if (lang !== undefined && lang.length > 0) {\n if (ValidLanguages[lang.toLowerCase()] === undefined) {\n this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n }\n }\n }\n seenLang = true;\n break;\n case 'case_matters':\n if (!seenLang && !seenOrder && !seenCase) {\n if (matches[3] !== 'true' && matches[3] !== 'false') {\n this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n }\n }\n\n seenCase = true;\n break;\n case 'order_matters':\n if (!seenCase && !seenLang && !seenOrder) {\n if (matches[3] !== 'true' && matches[3] !== 'false') {\n this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n }\n }\n\n seenOrder = true;\n break;\n default:\n break;\n }\n node = node.substr(matches[1].length);\n matches = node.match(prefixRegex);\n }\n\n return node;\n }\n\n /**\n * Replace the whole API with another\n * @param {Scorm2004API} newAPI\n */\n replaceWithAnotherScormAPI(newAPI) {\n // Data Model\n this.cmi = newAPI.cmi;\n this.adl = newAPI.adl;\n }\n\n /**\n * Render the cmi object to the proper format for LMS commit\n *\n * @param {boolean} terminateCommit\n * @return {object|Array}\n */\n renderCommitCMI(terminateCommit: boolean) {\n const cmiExport = this.renderCMIToJSONObject();\n\n if (terminateCommit) {\n cmiExport.cmi.total_time = this.cmi.getCurrentTotalTime();\n }\n\n const result = [];\n const flattened = Utilities.flatten(cmiExport);\n switch (this.settings.dataCommitFormat) {\n case 'flattened':\n return Utilities.flatten(cmiExport);\n case 'params':\n for (const item in flattened) {\n if ({}.hasOwnProperty.call(flattened, item)) {\n result.push(`${item}=${flattened[item]}`);\n }\n }\n return result;\n case 'json':\n default:\n return cmiExport;\n }\n }\n\n /**\n * Attempts to store the data to the LMS\n *\n * @param {boolean} terminateCommit\n * @return {string}\n */\n storeData(terminateCommit: boolean) {\n if (terminateCommit) {\n if (this.cmi.mode === 'normal') {\n if (this.cmi.credit === 'credit') {\n if (this.cmi.completion_threshold && this.cmi.progress_measure) {\n if (this.cmi.progress_measure >= this.cmi.completion_threshold) {\n console.debug('Setting Completion Status: Completed');\n this.cmi.completion_status = 'completed';\n } else {\n console.debug('Setting Completion Status: Incomplete');\n this.cmi.completion_status = 'incomplete';\n }\n }\n if (this.cmi.scaled_passing_score && this.cmi.score.scaled) {\n if (this.cmi.score.scaled >= this.cmi.scaled_passing_score) {\n console.debug('Setting Success Status: Passed');\n this.cmi.success_status = 'passed';\n } else {\n console.debug('Setting Success Status: Failed');\n this.cmi.success_status = 'failed';\n }\n }\n }\n }\n }\n\n let navRequest = false;\n if (this.adl.nav.request !== (this.startingData?.adl?.nav?.request) &&\n this.adl.nav.request !== '_none_') {\n this.adl.nav.request = encodeURIComponent(this.adl.nav.request);\n navRequest = true;\n }\n\n const commitObject = this.renderCommitCMI(terminateCommit ||\n this.settings.alwaysSendTotalTime);\n\n if (this.apiLogLevel === global_constants.LOG_LEVEL_DEBUG) {\n console.debug('Commit (terminated: ' +\n (terminateCommit ? 'yes' : 'no') + '): ');\n console.debug(commitObject);\n }\n if (this.settings.lmsCommitUrl) {\n const result = this.processHttpRequest(this.settings.lmsCommitUrl,\n commitObject, terminateCommit);\n\n // check if this is a sequencing call, and then call the necessary JS\n {\n if (navRequest && result.navRequest !== undefined &&\n result.navRequest !== '') {\n Function(`\"use strict\";(() => { ${result.navRequest} })()`)();\n }\n }\n return result;\n } else {\n return global_constants.SCORM_TRUE;\n }\n }\n}\n","import * as Scorm12CMI from './scorm12_cmi';\nimport {BaseCMI, checkValidFormat, CMIArray, CMIScore} from './common';\nimport APIConstants from '../constants/api_constants';\nimport Regex from '../constants/regex';\nimport ErrorCodes from '../constants/error_codes';\nimport {AICCValidationError} from '../exceptions';\n\nconst aicc_constants = APIConstants.aicc;\nconst aicc_regex = Regex.aicc;\nconst aicc_error_codes = ErrorCodes.scorm12;\n\n/**\n * Helper method for throwing Read Only error\n */\nfunction throwReadOnlyError() {\n throw new AICCValidationError(aicc_error_codes.READ_ONLY_ELEMENT);\n}\n\n/**\n * Helper method, no reason to have to pass the same error codes every time\n * @param {*} value\n * @param {string} regexPattern\n * @param {boolean} allowEmptyString\n * @return {boolean}\n */\nfunction checkAICCValidFormat(\n value: String,\n regexPattern: String,\n allowEmptyString?: boolean) {\n return checkValidFormat(\n value,\n regexPattern,\n aicc_error_codes.TYPE_MISMATCH,\n AICCValidationError,\n allowEmptyString\n );\n}\n\n/**\n * CMI Class for AICC\n */\nexport class CMI extends Scorm12CMI.CMI {\n /**\n * Constructor for AICC CMI object\n * @param {boolean} initialized\n */\n constructor(initialized: boolean) {\n super(aicc_constants.cmi_children);\n\n if (initialized) this.initialize();\n\n this.student_preference = new AICCStudentPreferences();\n this.student_data = new AICCCMIStudentData();\n this.student_demographics = new CMIStudentDemographics();\n this.evaluation = new CMIEvaluation();\n this.paths = new CMIPaths();\n }\n\n /**\n * Called when the API has been initialized after the CMI has been created\n */\n initialize() {\n super.initialize();\n this.student_preference?.initialize();\n this.student_data?.initialize();\n this.student_demographics?.initialize();\n this.evaluation?.initialize();\n this.paths?.initialize();\n }\n\n /**\n * toJSON for cmi\n *\n * @return {\n * {\n * suspend_data: string,\n * launch_data: string,\n * comments: string,\n * comments_from_lms: string,\n * core: CMICore,\n * objectives: CMIObjectives,\n * student_data: CMIStudentData,\n * student_preference: CMIStudentPreference,\n * interactions: CMIInteractions,\n * paths: CMIPaths\n * }\n * }\n */\n toJSON() {\n this.jsonString = true;\n const result = {\n 'suspend_data': this.suspend_data,\n 'launch_data': this.launch_data,\n 'comments': this.comments,\n 'comments_from_lms': this.comments_from_lms,\n 'core': this.core,\n 'objectives': this.objectives,\n 'student_data': this.student_data,\n 'student_preference': this.student_preference,\n 'student_demographics': this.student_demographics,\n 'interactions': this.interactions,\n 'evaluation': this.evaluation,\n 'paths': this.paths,\n };\n delete this.jsonString;\n return result;\n }\n}\n\n/**\n * AICC Evaluation object\n */\nclass CMIEvaluation extends BaseCMI {\n /**\n * Constructor for AICC Evaluation object\n */\n constructor() {\n super();\n\n this.comments = new CMIEvaluationComments();\n }\n\n /**\n * Called when the API has been initialized after the CMI has been created\n */\n initialize() {\n super.initialize();\n this.comments?.initialize();\n }\n\n /**\n * toJSON for cmi.evaluation object\n * @return {{comments: CMIEvaluationComments}}\n */\n toJSON() {\n this.jsonString = true;\n const result = {\n 'comments': this.comments,\n };\n delete this.jsonString;\n return result;\n }\n}\n\n/**\n * Class representing AICC's cmi.evaluation.comments object\n */\nclass CMIEvaluationComments extends CMIArray {\n /**\n * Constructor for AICC Evaluation Comments object\n */\n constructor() {\n super({\n children: aicc_constants.comments_children,\n errorCode: aicc_error_codes.INVALID_SET_VALUE,\n errorClass: AICCValidationError,\n });\n }\n}\n\n/**\n * StudentPreferences class for AICC\n */\nclass AICCStudentPreferences extends Scorm12CMI.CMIStudentPreference {\n /**\n * Constructor for AICC Student Preferences object\n */\n constructor() {\n super(aicc_constants.student_preference_children);\n\n this.windows = new CMIArray({\n errorCode: aicc_error_codes.INVALID_SET_VALUE,\n errorClass: AICCValidationError,\n children: '',\n });\n }\n\n /**\n * Called when the API has been initialized after the CMI has been created\n */\n initialize() {\n super.initialize();\n this.windows?.initialize();\n }\n\n #lesson_type = '';\n #text_color = '';\n #text_location = '';\n #text_size = '';\n #video = '';\n\n /**\n * Getter for #lesson_type\n * @return {string}\n */\n get lesson_type(): string {\n return this.#lesson_type;\n }\n\n /**\n * Setter for #lesson_type\n * @param {string} lesson_type\n */\n set lesson_type(lesson_type: string) {\n if (checkAICCValidFormat(lesson_type, aicc_regex.CMIString256)) {\n this.#lesson_type = lesson_type;\n }\n }\n\n /**\n * Getter for #text_color\n * @return {string}\n */\n get text_color(): string {\n return this.#text_color;\n }\n\n /**\n * Setter for #text_color\n * @param {string} text_color\n */\n set text_color(text_color: string) {\n if (checkAICCValidFormat(text_color, aicc_regex.CMIString256)) {\n this.#text_color = text_color;\n }\n }\n\n /**\n * Getter for #text_location\n * @return {string}\n */\n get text_location(): string {\n return this.#text_location;\n }\n\n /**\n * Setter for #text_location\n * @param {string} text_location\n */\n set text_location(text_location: string) {\n if (checkAICCValidFormat(text_location, aicc_regex.CMIString256)) {\n this.#text_location = text_location;\n }\n }\n\n /**\n * Getter for #text_size\n * @return {string}\n */\n get text_size(): string {\n return this.#text_size;\n }\n\n /**\n * Setter for #text_size\n * @param {string} text_size\n */\n set text_size(text_size: string) {\n if (checkAICCValidFormat(text_size, aicc_regex.CMIString256)) {\n this.#text_size = text_size;\n }\n }\n\n /**\n * Getter for #video\n * @return {string}\n */\n get video(): string {\n return this.#video;\n }\n\n /**\n * Setter for #video\n * @param {string} video\n */\n set video(video: string) {\n if (checkAICCValidFormat(video, aicc_regex.CMIString256)) {\n this.#video = video;\n }\n }\n\n /**\n * toJSON for cmi.student_preference\n *\n * @return {\n * {\n * audio: string,\n * language: string,\n * speed: string,\n * text: string\n * }\n * }\n */\n toJSON() {\n this.jsonString = true;\n const result = {\n 'audio': this.audio,\n 'language': this.language,\n 'lesson_type': this.lesson_type,\n 'speed': this.speed,\n 'text': this.text,\n 'text_color': this.text_color,\n 'text_location': this.text_location,\n 'text_size': this.text_size,\n 'video': this.video,\n 'windows': this.windows,\n };\n delete this.jsonString;\n return result;\n }\n}\n\n/**\n * StudentData class for AICC\n */\nclass AICCCMIStudentData extends Scorm12CMI.CMIStudentData {\n /**\n * Constructor for AICC StudentData object\n */\n constructor() {\n super(aicc_constants.student_data_children);\n\n this.tries = new CMITries();\n }\n\n /**\n * Called when the API has been initialized after the CMI has been created\n */\n initialize() {\n super.initialize();\n this.tries?.initialize();\n }\n\n #tries_during_lesson = '';\n\n /**\n * Getter for tries_during_lesson\n * @return {string}\n */\n get tries_during_lesson() {\n return this.#tries_during_lesson;\n }\n\n /**\n * Setter for #tries_during_lesson. Sets an error if trying to set after\n * initialization.\n * @param {string} tries_during_lesson\n */\n set tries_during_lesson(tries_during_lesson) {\n !this.initialized ?\n this.#tries_during_lesson = tries_during_lesson :\n throwReadOnlyError();\n }\n\n /**\n * toJSON for cmi.student_data object\n * @return {\n * {\n * mastery_score: string,\n * max_time_allowed: string,\n * time_limit_action: string,\n * tries: CMITries\n * }\n * }\n */\n toJSON() {\n this.jsonString = true;\n const result = {\n 'mastery_score': this.mastery_score,\n 'max_time_allowed': this.max_time_allowed,\n 'time_limit_action': this.time_limit_action,\n 'tries': this.tries,\n };\n delete this.jsonString;\n return result;\n }\n}\n\n/**\n * Class representing the AICC cmi.student_demographics object\n */\nexport class CMIStudentDemographics extends BaseCMI {\n /**\n * Constructor for AICC StudentDemographics object\n */\n constructor() {\n super();\n }\n\n #_children = aicc_constants.student_demographics_children;\n #city = '';\n #class = '';\n #company = '';\n #country = '';\n #experience = '';\n #familiar_name = '';\n #instructor_name = '';\n #title = '';\n #native_language = '';\n #state = '';\n #street_address = '';\n #telephone = '';\n #years_experience = '';\n\n /**\n * Getter for _children\n * @return {string}\n */\n get _children() {\n return this.#_children;\n }\n\n /**\n * Getter for city\n * @return {string}\n */\n get city() {\n return this.#city;\n }\n\n /**\n * Setter for #city. Sets an error if trying to set after\n * initialization.\n * @param {string} city\n */\n set city(city) {\n !this.initialized ?\n this.#city = city :\n throwReadOnlyError();\n }\n\n /**\n * Getter for class\n * @return {string}\n */\n get class() {\n return this.#class;\n }\n\n /**\n * Setter for #class. Sets an error if trying to set after\n * initialization.\n * @param {string} clazz\n */\n set class(clazz) {\n !this.initialized ?\n this.#class = clazz :\n throwReadOnlyError();\n }\n\n /**\n * Getter for company\n * @return {string}\n */\n get company() {\n return this.#company;\n }\n\n /**\n * Setter for #company. Sets an error if trying to set after\n * initialization.\n * @param {string} company\n */\n set company(company) {\n !this.initialized ?\n this.#company = company :\n throwReadOnlyError();\n }\n\n /**\n * Getter for country\n * @return {string}\n */\n get country() {\n return this.#country;\n }\n\n /**\n * Setter for #country. Sets an error if trying to set after\n * initialization.\n * @param {string} country\n */\n set country(country) {\n !this.initialized ?\n this.#country = country :\n throwReadOnlyError();\n }\n\n /**\n * Getter for experience\n * @return {string}\n */\n get experience() {\n return this.#experience;\n }\n\n /**\n * Setter for #experience. Sets an error if trying to set after\n * initialization.\n * @param {string} experience\n */\n set experience(experience) {\n !this.initialized ?\n this.#experience = experience :\n throwReadOnlyError();\n }\n\n /**\n * Getter for familiar_name\n * @return {string}\n */\n get familiar_name() {\n return this.#familiar_name;\n }\n\n /**\n * Setter for #familiar_name. Sets an error if trying to set after\n * initialization.\n * @param {string} familiar_name\n */\n set familiar_name(familiar_name) {\n !this.initialized ?\n this.#familiar_name = familiar_name :\n throwReadOnlyError();\n }\n\n /**\n * Getter for instructor_name\n * @return {string}\n */\n get instructor_name() {\n return this.#instructor_name;\n }\n\n /**\n * Setter for #instructor_name. Sets an error if trying to set after\n * initialization.\n * @param {string} instructor_name\n */\n set instructor_name(instructor_name) {\n !this.initialized ?\n this.#instructor_name = instructor_name :\n throwReadOnlyError();\n }\n\n /**\n * Getter for title\n * @return {string}\n */\n get title() {\n return this.#title;\n }\n\n /**\n * Setter for #title. Sets an error if trying to set after\n * initialization.\n * @param {string} title\n */\n set title(title) {\n !this.initialized ?\n this.#title = title :\n throwReadOnlyError();\n }\n\n /**\n * Getter for native_language\n * @return {string}\n */\n get native_language() {\n return this.#native_language;\n }\n\n /**\n * Setter for #native_language. Sets an error if trying to set after\n * initialization.\n * @param {string} native_language\n */\n set native_language(native_language) {\n !this.initialized ?\n this.#native_language = native_language :\n throwReadOnlyError();\n }\n\n /**\n * Getter for state\n * @return {string}\n */\n get state() {\n return this.#state;\n }\n\n /**\n * Setter for #state. Sets an error if trying to set after\n * initialization.\n * @param {string} state\n */\n set state(state) {\n !this.initialized ?\n this.#state = state :\n throwReadOnlyError();\n }\n\n /**\n * Getter for street_address\n * @return {string}\n */\n get street_address() {\n return this.#street_address;\n }\n\n /**\n * Setter for #street_address. Sets an error if trying to set after\n * initialization.\n * @param {string} street_address\n */\n set street_address(street_address) {\n !this.initialized ?\n this.#street_address = street_address :\n throwReadOnlyError();\n }\n\n /**\n * Getter for telephone\n * @return {string}\n */\n get telephone() {\n return this.#telephone;\n }\n\n /**\n * Setter for #telephone. Sets an error if trying to set after\n * initialization.\n * @param {string} telephone\n */\n set telephone(telephone) {\n !this.initialized ?\n this.#telephone = telephone :\n throwReadOnlyError();\n }\n\n /**\n * Getter for years_experience\n * @return {string}\n */\n get years_experience() {\n return this.#years_experience;\n }\n\n /**\n * Setter for #years_experience. Sets an error if trying to set after\n * initialization.\n * @param {string} years_experience\n */\n set years_experience(years_experience) {\n !this.initialized ?\n this.#years_experience = years_experience :\n throwReadOnlyError();\n }\n\n /**\n * toJSON for cmi.student_demographics object\n * @return {\n * {\n * city: string,\n * class: string,\n * company: string,\n * country: string,\n * experience: string,\n * familiar_name: string,\n * instructor_name: string,\n * title: string,\n * native_language: string,\n * state: string,\n * street_address: string,\n * telephone: string,\n * years_experience: string\n * }\n * }\n */\n toJSON() {\n this.jsonString = true;\n const result = {\n 'city': this.city,\n 'class': this.class,\n 'company': this.company,\n 'country': this.country,\n 'experience': this.experience,\n 'familiar_name': this.familiar_name,\n 'instructor_name': this.instructor_name,\n 'title': this.title,\n 'native_language': this.native_language,\n 'state': this.state,\n 'street_address': this.street_address,\n 'telephone': this.telephone,\n 'years_experience': this.years_experience,\n };\n delete this.jsonString;\n return result;\n }\n}\n\n/**\n * Class representing the AICC cmi.paths object\n */\nexport class CMIPaths extends CMIArray {\n /**\n * Constructor for inline Paths Array class\n */\n constructor() {\n super({children: aicc_constants.paths_children});\n }\n}\n\n/**\n * Class for AICC Paths\n */\nexport class CMIPathsObject extends BaseCMI {\n /**\n * Constructor for AICC Paths objects\n */\n constructor() {\n super();\n }\n\n #location_id = '';\n #date = '';\n #time = '';\n #status = '';\n #why_left = '';\n #time_in_element = '';\n\n /**\n * Getter for #location_id\n * @return {string}\n */\n get location_id() {\n return this.#location_id;\n }\n\n /**\n * Setter for #location_id\n * @param {string} location_id\n */\n set location_id(location_id) {\n if (checkAICCValidFormat(location_id, aicc_regex.CMIString256)) {\n this.#location_id = location_id;\n }\n }\n\n /**\n * Getter for #date\n * @return {string}\n */\n get date() {\n return this.#date;\n }\n\n /**\n * Setter for #date\n * @param {string} date\n */\n set date(date) {\n if (checkAICCValidFormat(date, aicc_regex.CMIString256)) {\n this.#date = date;\n }\n }\n\n /**\n * Getter for #time\n * @return {string}\n */\n get time() {\n return this.#time;\n }\n\n /**\n * Setter for #time\n * @param {string} time\n */\n set time(time) {\n if (checkAICCValidFormat(time, aicc_regex.CMITime)) {\n this.#time = time;\n }\n }\n\n /**\n * Getter for #status\n * @return {string}\n */\n get status() {\n return this.#status;\n }\n\n /**\n * Setter for #status\n * @param {string} status\n */\n set status(status) {\n if (checkAICCValidFormat(status, aicc_regex.CMIStatus2)) {\n this.#status = status;\n }\n }\n\n /**\n * Getter for #why_left\n * @return {string}\n */\n get why_left() {\n return this.#why_left;\n }\n\n /**\n * Setter for #why_left\n * @param {string} why_left\n */\n set why_left(why_left) {\n if (checkAICCValidFormat(why_left, aicc_regex.CMIString256)) {\n this.#why_left = why_left;\n }\n }\n\n /**\n * Getter for #time_in_element\n * @return {string}\n */\n get time_in_element() {\n return this.#time_in_element;\n }\n\n /**\n * Setter for #time_in_element\n * @param {string} time_in_element\n */\n set time_in_element(time_in_element) {\n if (checkAICCValidFormat(time_in_element, aicc_regex.CMITime)) {\n this.#time_in_element = time_in_element;\n }\n }\n\n /**\n * toJSON for cmi.paths.n object\n * @return {\n * {\n * location_id: string,\n * date: string,\n * time: string,\n * status: string,\n * why_left: string,\n * time_in_element: string\n * }\n * }\n */\n toJSON() {\n this.jsonString = true;\n const result = {\n 'location_id': this.location_id,\n 'date': this.date,\n 'time': this.time,\n 'status': this.status,\n 'why_left': this.why_left,\n 'time_in_element': this.time_in_element,\n };\n delete this.jsonString;\n return result;\n }\n}\n\n/**\n * Class representing the AICC cmi.student_data.tries object\n */\nexport class CMITries extends CMIArray {\n /**\n * Constructor for inline Tries Array class\n */\n constructor() {\n super({children: aicc_constants.tries_children});\n }\n}\n\n/**\n * Class for AICC Tries\n */\nexport class CMITriesObject extends BaseCMI {\n /**\n * Constructor for AICC Tries object\n */\n constructor() {\n super();\n\n this.score = new CMIScore(\n {\n score_children: aicc_constants.score_children,\n score_range: aicc_regex.score_range,\n invalidErrorCode: aicc_error_codes.INVALID_SET_VALUE,\n invalidTypeCode: aicc_error_codes.TYPE_MISMATCH,\n invalidRangeCode: aicc_error_codes.VALUE_OUT_OF_RANGE,\n errorClass: AICCValidationError,\n });\n }\n\n /**\n * Called when the API has been initialized after the CMI has been created\n */\n initialize() {\n super.initialize();\n this.score?.initialize();\n }\n\n #status = '';\n #time = '';\n\n /**\n * Getter for #status\n * @return {string}\n */\n get status() {\n return this.#status;\n }\n\n /**\n * Setter for #status\n * @param {string} status\n */\n set status(status) {\n if (checkAICCValidFormat(status, aicc_regex.CMIStatus2)) {\n this.#status = status;\n }\n }\n\n /**\n * Getter for #time\n * @return {string}\n */\n get time() {\n return this.#time;\n }\n\n /**\n * Setter for #time\n * @param {string} time\n */\n set time(time) {\n if (checkAICCValidFormat(time, aicc_regex.CMITime)) {\n this.#time = time;\n }\n }\n\n /**\n * toJSON for cmi.student_data.tries.n object\n * @return {\n * {\n * status: string,\n * time: string,\n * score: CMIScore\n * }\n * }\n */\n toJSON() {\n this.jsonString = true;\n const result = {\n 'status': this.status,\n 'time': this.time,\n 'score': this.score,\n };\n delete this.jsonString;\n return result;\n }\n}\n\n/**\n * Class for cmi.student_data.attempt_records array\n */\nexport class CMIAttemptRecords extends CMIArray {\n /**\n * Constructor for inline Tries Array class\n */\n constructor() {\n super({children: aicc_constants.attempt_records_children});\n }\n}\n\n/**\n * Class for AICC Attempt Records\n */\nexport class CMIAttemptRecordsObject extends BaseCMI {\n /**\n * Constructor for AICC Attempt Records object\n */\n constructor() {\n super();\n\n this.score = new CMIScore(\n {\n score_children: aicc_constants.score_children,\n score_range: aicc_regex.score_range,\n invalidErrorCode: aicc_error_codes.INVALID_SET_VALUE,\n invalidTypeCode: aicc_error_codes.TYPE_MISMATCH,\n invalidRangeCode: aicc_error_codes.VALUE_OUT_OF_RANGE,\n errorClass: AICCValidationError,\n });\n }\n\n /**\n * Called when the API has been initialized after the CMI has been created\n */\n initialize() {\n super.initialize();\n this.score?.initialize();\n }\n\n #lesson_status = '';\n\n /**\n * Getter for #lesson_status\n * @return {string}\n */\n get lesson_status() {\n return this.#lesson_status;\n }\n\n /**\n * Setter for #lesson_status\n * @param {string} lesson_status\n */\n set lesson_status(lesson_status) {\n if (checkAICCValidFormat(lesson_status, aicc_regex.CMIStatus2)) {\n this.#lesson_status = lesson_status;\n }\n }\n\n /**\n * toJSON for cmi.student_data.attempt_records.n object\n * @return {\n * {\n * status: string,\n * time: string,\n * score: CMIScore\n * }\n * }\n */\n toJSON() {\n this.jsonString = true;\n const result = {\n 'lesson_status': this.lesson_status,\n 'score': this.score,\n };\n delete this.jsonString;\n return result;\n }\n}\n\n/**\n * Class for AICC Evaluation Comments\n */\nexport class CMIEvaluationCommentsObject extends BaseCMI {\n /**\n * Constructor for Evaluation Comments\n */\n constructor() {\n super();\n }\n\n #content = '';\n #location = '';\n #time = '';\n\n /**\n * Getter for #content\n * @return {string}\n */\n get content() {\n return this.#content;\n }\n\n /**\n * Setter for #content\n * @param {string} content\n */\n set content(content) {\n if (checkAICCValidFormat(content, aicc_regex.CMIString256)) {\n this.#content = content;\n }\n }\n\n /**\n * Getter for #location\n * @return {string}\n */\n get location() {\n return this.#location;\n }\n\n /**\n * Setter for #location\n * @param {string} location\n */\n set location(location) {\n if (checkAICCValidFormat(location, aicc_regex.CMIString256)) {\n this.#location = location;\n }\n }\n\n /**\n * Getter for #time\n * @return {string}\n */\n get time() {\n return this.#time;\n }\n\n /**\n * Setting for #time\n * @param {string} time\n */\n set time(time) {\n if (checkAICCValidFormat(time, aicc_regex.CMITime)) {\n this.#time = time;\n }\n }\n\n /**\n * toJSON for cmi.evaulation.comments.n object\n * @return {\n * {\n * content: string,\n * location: string,\n * time: string\n * }\n * }\n */\n toJSON() {\n this.jsonString = true;\n const result = {\n 'content': this.content,\n 'location': this.location,\n 'time': this.time,\n };\n delete this.jsonString;\n return result;\n }\n}\n","// @flow\nimport APIConstants from '../constants/api_constants';\nimport ErrorCodes from '../constants/error_codes';\nimport Regex from '../constants/regex';\n\nconst scorm12_constants = APIConstants.scorm12;\nconst scorm12_regex = Regex.scorm12;\nconst scorm12_error_codes = ErrorCodes.scorm12;\n\n/**\n * Check if the value matches the proper format. If not, throw proper error code.\n *\n * @param {string} value\n * @param {string} regexPattern\n * @param {number} errorCode\n * @param {class} errorClass\n * @param {boolean} allowEmptyString\n * @return {boolean}\n */\nexport function checkValidFormat(\n value: String,\n regexPattern: String,\n errorCode: number,\n errorClass: function,\n allowEmptyString?: boolean) {\n const formatRegex = new RegExp(regexPattern);\n const matches = value.match(formatRegex);\n if (allowEmptyString && value === '') {\n return true;\n }\n if (value === undefined || !matches || matches[0] === '') {\n throw new errorClass.prototype.constructor(errorCode);\n }\n return true;\n}\n\n/**\n * Check if the value matches the proper range. If not, throw proper error code.\n *\n * @param {*} value\n * @param {string} rangePattern\n * @param {number} errorCode\n * @param {class} errorClass\n * @return {boolean}\n */\nexport function checkValidRange(\n value: any,\n rangePattern: String,\n errorCode: number,\n errorClass: function) {\n const ranges = rangePattern.split('#');\n value = value * 1.0;\n if (value >= ranges[0]) {\n if ((ranges[1] === '*') || (value <= ranges[1])) {\n return true;\n } else {\n throw new errorClass.prototype.constructor(errorCode);\n }\n } else {\n throw new errorClass.prototype.constructor(errorCode);\n }\n}\n\n/**\n * Base class for API cmi objects\n */\nexport class BaseCMI {\n jsonString = false;\n #initialized = false;\n #start_time;\n\n /**\n * Constructor for BaseCMI, just marks the class as abstract\n */\n constructor() {\n if (new.target === BaseCMI) {\n throw new TypeError('Cannot construct BaseCMI instances directly');\n }\n }\n\n /**\n * Getter for #initialized\n * @return {boolean}\n */\n get initialized() {\n return this.#initialized;\n }\n\n /**\n * Getter for #start_time\n * @return {Number}\n */\n get start_time() {\n return this.#start_time;\n }\n\n /**\n * Called when the API has been initialized after the CMI has been created\n */\n initialize() {\n this.#initialized = true;\n }\n\n /**\n * Called when the player should override the 'session_time' provided by\n * the module\n */\n setStartTime() {\n this.#start_time = new Date().getTime();\n }\n}\n\n/**\n * Base class for cmi *.score objects\n */\nexport class CMIScore extends BaseCMI {\n /**\n * Constructor for *.score\n * @param {string} score_children\n * @param {string} score_range\n * @param {string} max\n * @param {number} invalidErrorCode\n * @param {number} invalidTypeCode\n * @param {number} invalidRangeCode\n * @param {string} decimalRegex\n * @param {class} errorClass\n */\n constructor(\n {\n score_children,\n score_range,\n max,\n invalidErrorCode,\n invalidTypeCode,\n invalidRangeCode,\n decimalRegex,\n errorClass,\n }) {\n super();\n\n this.#_children = score_children ||\n scorm12_constants.score_children;\n this.#_score_range = !score_range ? false : scorm12_regex.score_range;\n this.#max = (max || max === '') ? max : '100';\n this.#_invalid_error_code = invalidErrorCode ||\n scorm12_error_codes.INVALID_SET_VALUE;\n this.#_invalid_type_code = invalidTypeCode ||\n scorm12_error_codes.TYPE_MISMATCH;\n this.#_invalid_range_code = invalidRangeCode ||\n scorm12_error_codes.VALUE_OUT_OF_RANGE;\n this.#_decimal_regex = decimalRegex ||\n scorm12_regex.CMIDecimal;\n this.#_error_class = errorClass;\n }\n\n #_children;\n #_score_range;\n #_invalid_error_code;\n #_invalid_type_code;\n #_invalid_range_code;\n #_decimal_regex;\n #_error_class;\n #raw = '';\n #min = '';\n #max;\n\n /**\n * Getter for _children\n * @return {string}\n * @private\n */\n get _children() {\n return this.#_children;\n }\n\n /**\n * Setter for _children. Just throws an error.\n * @param {string} _children\n * @private\n */\n set _children(_children) {\n throw new this.#_error_class.prototype.constructor(this.#_invalid_error_code);\n }\n\n /**\n * Getter for #raw\n * @return {string}\n */\n get raw() {\n return this.#raw;\n }\n\n /**\n * Setter for #raw\n * @param {string} raw\n */\n set raw(raw) {\n if (checkValidFormat(raw, this.#_decimal_regex, this.#_invalid_type_code, this.#_error_class) &&\n (!this.#_score_range ||\n checkValidRange(raw, this.#_score_range, this.#_invalid_range_code, this.#_error_class))) {\n this.#raw = raw;\n }\n }\n\n /**\n * Getter for #min\n * @return {string}\n */\n get min() {\n return this.#min;\n }\n\n /**\n * Setter for #min\n * @param {string} min\n */\n set min(min) {\n if (checkValidFormat(min, this.#_decimal_regex, this.#_invalid_type_code, this.#_error_class) &&\n (!this.#_score_range ||\n checkValidRange(min, this.#_score_range, this.#_invalid_range_code, this.#_error_class))) {\n this.#min = min;\n }\n }\n\n /**\n * Getter for #max\n * @return {string}\n */\n get max() {\n return this.#max;\n }\n\n /**\n * Setter for #max\n * @param {string} max\n */\n set max(max) {\n if (checkValidFormat(max, this.#_decimal_regex, this.#_invalid_type_code, this.#_error_class) &&\n (!this.#_score_range ||\n checkValidRange(max, this.#_score_range, this.#_invalid_range_code, this.#_error_class))) {\n this.#max = max;\n }\n }\n\n /**\n * toJSON for *.score\n * @return {{min: string, max: string, raw: string}}\n */\n toJSON() {\n this.jsonString = true;\n const result = {\n 'raw': this.raw,\n 'min': this.min,\n 'max': this.max,\n };\n delete this.jsonString;\n return result;\n }\n}\n\n/**\n * Base class for cmi *.n objects\n */\nexport class CMIArray extends BaseCMI {\n /**\n * Constructor cmi *.n arrays\n * @param {string} children\n * @param {number} errorCode\n * @param {class} errorClass\n */\n constructor({children, errorCode, errorClass}) {\n super();\n this.#_children = children;\n this.#errorCode = errorCode;\n this.#errorClass = errorClass;\n this.childArray = [];\n }\n\n #errorCode;\n #errorClass;\n #_children;\n\n /**\n * Getter for _children\n * @return {*}\n */\n get _children() {\n return this.#_children;\n }\n\n /**\n * Setter for _children. Just throws an error.\n * @param {string} _children\n */\n set _children(_children) {\n throw new this.#errorClass.prototype.constructor(this.#errorCode);\n }\n\n /**\n * Getter for _count\n * @return {number}\n */\n get _count() {\n return this.childArray.length;\n }\n\n /**\n * Setter for _count. Just throws an error.\n * @param {number} _count\n */\n set _count(_count) {\n throw new this.#errorClass.prototype.constructor(this.#errorCode);\n }\n\n /**\n * toJSON for *.n arrays\n * @return {object}\n */\n toJSON() {\n this.jsonString = true;\n const result = {};\n for (let i = 0; i < this.childArray.length; i++) {\n result[i + ''] = this.childArray[i];\n }\n delete this.jsonString;\n return result;\n }\n}\n","// @flow\nimport {\n BaseCMI,\n checkValidFormat,\n checkValidRange,\n CMIArray,\n CMIScore,\n} from './common';\nimport APIConstants from '../constants/api_constants';\nimport ErrorCodes from '../constants/error_codes';\nimport Regex from '../constants/regex';\nimport {Scorm12ValidationError} from '../exceptions';\nimport * as Utilities from '../utilities';\nimport * as Util from '../utilities';\n\nconst scorm12_constants = APIConstants.scorm12;\nconst scorm12_regex = Regex.scorm12;\nconst scorm12_error_codes = ErrorCodes.scorm12;\n\n/**\n * Helper method for throwing Read Only error\n */\nexport function throwReadOnlyError() {\n throw new Scorm12ValidationError(scorm12_error_codes.READ_ONLY_ELEMENT);\n}\n\n/**\n * Helper method for throwing Write Only error\n */\nexport function throwWriteOnlyError() {\n throw new Scorm12ValidationError(scorm12_error_codes.WRITE_ONLY_ELEMENT);\n}\n\n/**\n * Helper method for throwing Invalid Set error\n */\nfunction throwInvalidValueError() {\n throw new Scorm12ValidationError(scorm12_error_codes.INVALID_SET_VALUE);\n}\n\n/**\n * Helper method, no reason to have to pass the same error codes every time\n * @param {*} value\n * @param {string} regexPattern\n * @param {boolean} allowEmptyString\n * @return {boolean}\n */\nexport function check12ValidFormat(\n value: String,\n regexPattern: String,\n allowEmptyString?: boolean) {\n return checkValidFormat(\n value,\n regexPattern,\n scorm12_error_codes.TYPE_MISMATCH,\n Scorm12ValidationError,\n allowEmptyString\n );\n}\n\n/**\n * Helper method, no reason to have to pass the same error codes every time\n * @param {*} value\n * @param {string} rangePattern\n * @param {boolean} allowEmptyString\n * @return {boolean}\n */\nexport function check12ValidRange(\n value: any,\n rangePattern: String,\n allowEmptyString?: boolean) {\n return checkValidRange(\n value,\n rangePattern,\n scorm12_error_codes.VALUE_OUT_OF_RANGE,\n Scorm12ValidationError,\n allowEmptyString\n );\n}\n\n/**\n * Class representing the cmi object for SCORM 1.2\n */\nexport class CMI extends BaseCMI {\n #_children = '';\n #_version = '3.4';\n #launch_data = '';\n #comments = '';\n #comments_from_lms = '';\n\n student_data = null;\n\n /**\n * Constructor for the SCORM 1.2 cmi object\n * @param {string} cmi_children\n * @param {(CMIStudentData|AICCCMIStudentData)} student_data\n * @param {boolean} initialized\n */\n constructor(cmi_children, student_data, initialized: boolean) {\n super();\n\n if (initialized) this.initialize();\n\n this.#_children = cmi_children ?\n cmi_children :\n scorm12_constants.cmi_children;\n this.core = new CMICore();\n this.objectives = new CMIObjectives();\n this.student_data = student_data ? student_data : new CMIStudentData();\n this.student_preference = new CMIStudentPreference();\n this.interactions = new CMIInteractions();\n }\n\n /**\n * Called when the API has been initialized after the CMI has been created\n */\n initialize() {\n super.initialize();\n this.core?.initialize();\n this.objectives?.initialize();\n this.student_data?.initialize();\n this.student_preference?.initialize();\n this.interactions?.initialize();\n }\n\n /**\n * toJSON for cmi\n *\n * @return {\n * {\n * suspend_data: string,\n * launch_data: string,\n * comments: string,\n * comments_from_lms: string,\n * core: CMICore,\n * objectives: CMIObjectives,\n * student_data: CMIStudentData,\n * student_preference: CMIStudentPreference,\n * interactions: CMIInteractions\n * }\n * }\n */\n toJSON() {\n this.jsonString = true;\n const result = {\n 'suspend_data': this.suspend_data,\n 'launch_data': this.launch_data,\n 'comments': this.comments,\n 'comments_from_lms': this.comments_from_lms,\n 'core': this.core,\n 'objectives': this.objectives,\n 'student_data': this.student_data,\n 'student_preference': this.student_preference,\n 'interactions': this.interactions,\n };\n delete this.jsonString;\n return result;\n }\n\n /**\n * Getter for #_version\n * @return {string}\n */\n get _version() {\n return this.#_version;\n }\n\n /**\n * Setter for #_version. Just throws an error.\n * @param {string} _version\n */\n set _version(_version) {\n throwInvalidValueError();\n }\n\n /**\n * Getter for #_children\n * @return {string}\n */\n get _children() {\n return this.#_children;\n }\n\n /**\n * Setter for #_version. Just throws an error.\n * @param {string} _children\n */\n set _children(_children) {\n throwInvalidValueError();\n }\n\n /**\n * Getter for #suspend_data\n * @return {string}\n */\n get suspend_data() {\n return this.core?.suspend_data;\n }\n\n /**\n * Setter for #suspend_data\n * @param {string} suspend_data\n */\n set suspend_data(suspend_data) {\n if (this.core) {\n this.core.suspend_data = suspend_data;\n }\n }\n\n /**\n * Getter for #launch_data\n * @return {string}\n */\n get launch_data() {\n return this.#launch_data;\n }\n\n /**\n * Setter for #launch_data. Can only be called before initialization.\n * @param {string} launch_data\n */\n set launch_data(launch_data) {\n !this.initialized ? this.#launch_data = launch_data : throwReadOnlyError();\n }\n\n /**\n * Getter for #comments\n * @return {string}\n */\n get comments() {\n return this.#comments;\n }\n\n /**\n * Setter for #comments\n * @param {string} comments\n */\n set comments(comments) {\n if (check12ValidFormat(comments, scorm12_regex.CMIString4096, true)) {\n this.#comments = comments;\n }\n }\n\n /**\n * Getter for #comments_from_lms\n * @return {string}\n */\n get comments_from_lms() {\n return this.#comments_from_lms;\n }\n\n /**\n * Setter for #comments_from_lms. Can only be called before initialization.\n * @param {string} comments_from_lms\n */\n set comments_from_lms(comments_from_lms) {\n !this.initialized ?\n this.#comments_from_lms = comments_from_lms :\n throwReadOnlyError();\n }\n\n /**\n * Adds the current session time to the existing total time.\n *\n * @return {string}\n */\n getCurrentTotalTime() {\n return this.core.getCurrentTotalTime(this.start_time);\n }\n}\n\n/**\n * Class representing the cmi.core object\n * @extends BaseCMI\n */\nclass CMICore extends BaseCMI {\n /**\n * Constructor for cmi.core\n */\n constructor() {\n super();\n\n this.score = new CMIScore(\n {\n score_children: scorm12_constants.score_children,\n score_range: scorm12_regex.score_range,\n invalidErrorCode: scorm12_error_codes.INVALID_SET_VALUE,\n invalidTypeCode: scorm12_error_codes.TYPE_MISMATCH,\n invalidRangeCode: scorm12_error_codes.VALUE_OUT_OF_RANGE,\n errorClass: Scorm12ValidationError,\n });\n }\n\n /**\n * Called when the API has been initialized after the CMI has been created\n */\n initialize() {\n super.initialize();\n this.score?.initialize();\n }\n\n #_children = scorm12_constants.core_children;\n #student_id = '';\n #student_name = '';\n #lesson_location = '';\n #credit = '';\n #lesson_status = 'not attempted';\n #entry = '';\n #total_time = '';\n #lesson_mode = 'normal';\n #exit = '';\n #session_time = '00:00:00';\n #suspend_data = '';\n\n /**\n * Getter for #_children\n * @return {string}\n * @private\n */\n get _children() {\n return this.#_children;\n }\n\n /**\n * Setter for #_children. Just throws an error.\n * @param {string} _children\n * @private\n */\n set _children(_children) {\n throwInvalidValueError();\n }\n\n /**\n * Getter for #student_id\n * @return {string}\n */\n get student_id() {\n return this.#student_id;\n }\n\n /**\n * Setter for #student_id. Can only be called before initialization.\n * @param {string} student_id\n */\n set student_id(student_id) {\n !this.initialized ? this.#student_id = student_id : throwReadOnlyError();\n }\n\n /**\n * Getter for #student_name\n * @return {string}\n */\n get student_name() {\n return this.#student_name;\n }\n\n /**\n * Setter for #student_name. Can only be called before initialization.\n * @param {string} student_name\n */\n set student_name(student_name) {\n !this.initialized ?\n this.#student_name = student_name :\n throwReadOnlyError();\n }\n\n /**\n * Getter for #lesson_location\n * @return {string}\n */\n get lesson_location() {\n return this.#lesson_location;\n }\n\n /**\n * Setter for #lesson_location\n * @param {string} lesson_location\n */\n set lesson_location(lesson_location) {\n if (check12ValidFormat(lesson_location, scorm12_regex.CMIString256, true)) {\n this.#lesson_location = lesson_location;\n }\n }\n\n /**\n * Getter for #credit\n * @return {string}\n */\n get credit() {\n return this.#credit;\n }\n\n /**\n * Setter for #credit. Can only be called before initialization.\n * @param {string} credit\n */\n set credit(credit) {\n !this.initialized ? this.#credit = credit : throwReadOnlyError();\n }\n\n /**\n * Getter for #lesson_status\n * @return {string}\n */\n get lesson_status() {\n return this.#lesson_status;\n }\n\n /**\n * Setter for #lesson_status\n * @param {string} lesson_status\n */\n set lesson_status(lesson_status) {\n if (this.initialized) {\n if (check12ValidFormat(lesson_status, scorm12_regex.CMIStatus)) {\n this.#lesson_status = lesson_status;\n }\n } else {\n if (check12ValidFormat(lesson_status, scorm12_regex.CMIStatus2)) {\n this.#lesson_status = lesson_status;\n }\n }\n }\n\n /**\n * Getter for #entry\n * @return {string}\n */\n get entry() {\n return this.#entry;\n }\n\n /**\n * Setter for #entry. Can only be called before initialization.\n * @param {string} entry\n */\n set entry(entry) {\n !this.initialized ? this.#entry = entry : throwReadOnlyError();\n }\n\n /**\n * Getter for #total_time\n * @return {string}\n */\n get total_time() {\n return this.#total_time;\n }\n\n /**\n * Setter for #total_time. Can only be called before initialization.\n * @param {string} total_time\n */\n set total_time(total_time) {\n !this.initialized ? this.#total_time = total_time : throwReadOnlyError();\n }\n\n /**\n * Getter for #lesson_mode\n * @return {string}\n */\n get lesson_mode() {\n return this.#lesson_mode;\n }\n\n /**\n * Setter for #lesson_mode. Can only be called before initialization.\n * @param {string} lesson_mode\n */\n set lesson_mode(lesson_mode) {\n !this.initialized ? this.#lesson_mode = lesson_mode : throwReadOnlyError();\n }\n\n /**\n * Getter for #exit. Should only be called during JSON export.\n * @return {*}\n */\n get exit() {\n return (!this.jsonString) ? throwWriteOnlyError() : this.#exit;\n }\n\n /**\n * Setter for #exit\n * @param {string} exit\n */\n set exit(exit) {\n if (check12ValidFormat(exit, scorm12_regex.CMIExit, true)) {\n this.#exit = exit;\n }\n }\n\n /**\n * Getter for #session_time. Should only be called during JSON export.\n * @return {*}\n */\n get session_time() {\n return (!this.jsonString) ? throwWriteOnlyError() : this.#session_time;\n }\n\n /**\n * Setter for #session_time\n * @param {string} session_time\n */\n set session_time(session_time) {\n if (check12ValidFormat(session_time, scorm12_regex.CMITimespan)) {\n this.#session_time = session_time;\n }\n }\n\n /**\n * Getter for #suspend_data\n * @return {string}\n */\n get suspend_data() {\n return this.#suspend_data;\n }\n\n /**\n * Setter for #suspend_data\n * @param {string} suspend_data\n */\n set suspend_data(suspend_data) {\n if (check12ValidFormat(suspend_data, scorm12_regex.CMIString4096, true)) {\n this.#suspend_data = suspend_data;\n }\n }\n\n /**\n * Adds the current session time to the existing total time.\n * @param {Number} start_time\n * @return {string}\n */\n getCurrentTotalTime(start_time: Number) {\n let sessionTime = this.#session_time;\n const startTime = start_time;\n\n if (typeof startTime !== 'undefined' && startTime !== null) {\n const seconds = new Date().getTime() - startTime;\n sessionTime = Util.getSecondsAsHHMMSS(seconds / 1000);\n }\n\n return Utilities.addHHMMSSTimeStrings(\n this.#total_time,\n sessionTime,\n new RegExp(scorm12_regex.CMITimespan),\n );\n }\n\n /**\n * toJSON for cmi.core\n *\n * @return {\n * {\n * student_name: string,\n * entry: string,\n * exit: string,\n * score: CMIScore,\n * student_id: string,\n * lesson_mode: string,\n * lesson_location: string,\n * lesson_status: string,\n * credit: string,\n * session_time: *\n * }\n * }\n */\n toJSON() {\n this.jsonString = true;\n const result = {\n 'student_id': this.student_id,\n 'student_name': this.student_name,\n 'lesson_location': this.lesson_location,\n 'credit': this.credit,\n 'lesson_status': this.lesson_status,\n 'entry': this.entry,\n 'lesson_mode': this.lesson_mode,\n 'exit': this.exit,\n 'session_time': this.session_time,\n 'score': this.score,\n };\n delete this.jsonString;\n return result;\n }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.objectives object\n * @extends CMIArray\n */\nclass CMIObjectives extends CMIArray {\n /**\n * Constructor for cmi.objectives\n */\n constructor() {\n super({\n children: scorm12_constants.objectives_children,\n errorCode: scorm12_error_codes.INVALID_SET_VALUE,\n errorClass: Scorm12ValidationError,\n });\n }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.student_data object\n * @extends BaseCMI\n */\nexport class CMIStudentData extends BaseCMI {\n #_children;\n #mastery_score = '';\n #max_time_allowed = '';\n #time_limit_action = '';\n\n /**\n * Constructor for cmi.student_data\n * @param {string} student_data_children\n */\n constructor(student_data_children) {\n super();\n\n this.#_children = student_data_children ?\n student_data_children :\n scorm12_constants.student_data_children;\n }\n\n /**\n * Getter for #_children\n * @return {*}\n * @private\n */\n get _children() {\n return this.#_children;\n }\n\n /**\n * Setter for #_children. Just throws an error.\n * @param {string} _children\n * @private\n */\n set _children(_children) {\n throwInvalidValueError();\n }\n\n /**\n * Getter for #master_score\n * @return {string}\n */\n get mastery_score() {\n return this.#mastery_score;\n }\n\n /**\n * Setter for #master_score. Can only be called before initialization.\n * @param {string} mastery_score\n */\n set mastery_score(mastery_score) {\n !this.initialized ?\n this.#mastery_score = mastery_score :\n throwReadOnlyError();\n }\n\n /**\n * Getter for #max_time_allowed\n * @return {string}\n */\n get max_time_allowed() {\n return this.#max_time_allowed;\n }\n\n /**\n * Setter for #max_time_allowed. Can only be called before initialization.\n * @param {string} max_time_allowed\n */\n set max_time_allowed(max_time_allowed) {\n !this.initialized ?\n this.#max_time_allowed = max_time_allowed :\n throwReadOnlyError();\n }\n\n /**\n * Getter for #time_limit_action\n * @return {string}\n */\n get time_limit_action() {\n return this.#time_limit_action;\n }\n\n /**\n * Setter for #time_limit_action. Can only be called before initialization.\n * @param {string} time_limit_action\n */\n set time_limit_action(time_limit_action) {\n !this.initialized ?\n this.#time_limit_action = time_limit_action :\n throwReadOnlyError();\n }\n\n /**\n * toJSON for cmi.student_data\n *\n * @return {\n * {\n * max_time_allowed: string,\n * time_limit_action: string,\n * mastery_score: string\n * }\n * }\n */\n toJSON() {\n this.jsonString = true;\n const result = {\n 'mastery_score': this.mastery_score,\n 'max_time_allowed': this.max_time_allowed,\n 'time_limit_action': this.time_limit_action,\n };\n delete this.jsonString;\n return result;\n }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.student_preference object\n * @extends BaseCMI\n */\nexport class CMIStudentPreference extends BaseCMI {\n #_children;\n\n /**\n * Constructor for cmi.student_preference\n * @param {string} student_preference_children\n */\n constructor(student_preference_children) {\n super();\n\n this.#_children = student_preference_children ?\n student_preference_children :\n scorm12_constants.student_preference_children;\n }\n\n #audio = '';\n #language = '';\n #speed = '';\n #text = '';\n\n /**\n * Getter for #_children\n * @return {string}\n * @private\n */\n get _children() {\n return this.#_children;\n }\n\n /**\n * Setter for #_children. Just throws an error.\n * @param {string} _children\n * @private\n */\n set _children(_children) {\n throwInvalidValueError();\n }\n\n /**\n * Getter for #audio\n * @return {string}\n */\n get audio() {\n return this.#audio;\n }\n\n /**\n * Setter for #audio\n * @param {string} audio\n */\n set audio(audio) {\n if (check12ValidFormat(audio, scorm12_regex.CMISInteger) &&\n check12ValidRange(audio, scorm12_regex.audio_range)) {\n this.#audio = audio;\n }\n }\n\n /**\n * Getter for #language\n * @return {string}\n */\n get language() {\n return this.#language;\n }\n\n /**\n * Setter for #language\n * @param {string} language\n */\n set language(language) {\n if (check12ValidFormat(language, scorm12_regex.CMIString256)) {\n this.#language = language;\n }\n }\n\n /**\n * Getter for #speed\n * @return {string}\n */\n get speed() {\n return this.#speed;\n }\n\n /**\n * Setter for #speed\n * @param {string} speed\n */\n set speed(speed) {\n if (check12ValidFormat(speed, scorm12_regex.CMISInteger) &&\n check12ValidRange(speed, scorm12_regex.speed_range)) {\n this.#speed = speed;\n }\n }\n\n /**\n * Getter for #text\n * @return {string}\n */\n get text() {\n return this.#text;\n }\n\n /**\n * Setter for #text\n * @param {string} text\n */\n set text(text) {\n if (check12ValidFormat(text, scorm12_regex.CMISInteger) &&\n check12ValidRange(text, scorm12_regex.text_range)) {\n this.#text = text;\n }\n }\n\n /**\n * toJSON for cmi.student_preference\n *\n * @return {\n * {\n * audio: string,\n * language: string,\n * speed: string,\n * text: string\n * }\n * }\n */\n toJSON() {\n this.jsonString = true;\n const result = {\n 'audio': this.audio,\n 'language': this.language,\n 'speed': this.speed,\n 'text': this.text,\n };\n delete this.jsonString;\n return result;\n }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.interactions object\n * @extends BaseCMI\n */\nclass CMIInteractions extends CMIArray {\n /**\n * Constructor for cmi.interactions\n */\n constructor() {\n super({\n children: scorm12_constants.interactions_children,\n errorCode: scorm12_error_codes.INVALID_SET_VALUE,\n errorClass: Scorm12ValidationError,\n });\n }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.interactions.n object\n * @extends BaseCMI\n */\nexport class CMIInteractionsObject extends BaseCMI {\n /**\n * Constructor for cmi.interactions.n object\n */\n constructor() {\n super();\n\n this.objectives = new CMIArray({\n errorCode: scorm12_error_codes.INVALID_SET_VALUE,\n errorClass: Scorm12ValidationError,\n children: scorm12_constants.objectives_children,\n });\n this.correct_responses = new CMIArray({\n errorCode: scorm12_error_codes.INVALID_SET_VALUE,\n errorClass: Scorm12ValidationError,\n children: scorm12_constants.correct_responses_children,\n });\n }\n\n /**\n * Called when the API has been initialized after the CMI has been created\n */\n initialize() {\n super.initialize();\n this.objectives?.initialize();\n this.correct_responses?.initialize();\n }\n\n #id = '';\n #time = '';\n #type = '';\n #weighting = '';\n #student_response = '';\n #result = '';\n #latency = '';\n\n /**\n * Getter for #id. Should only be called during JSON export.\n * @return {*}\n */\n get id() {\n return (!this.jsonString) ? throwWriteOnlyError() : this.#id;\n }\n\n /**\n * Setter for #id\n * @param {string} id\n */\n set id(id) {\n if (check12ValidFormat(id, scorm12_regex.CMIIdentifier)) {\n this.#id = id;\n }\n }\n\n /**\n * Getter for #time. Should only be called during JSON export.\n * @return {*}\n */\n get time() {\n return (!this.jsonString) ? throwWriteOnlyError() : this.#time;\n }\n\n /**\n * Setter for #time\n * @param {string} time\n */\n set time(time) {\n if (check12ValidFormat(time, scorm12_regex.CMITime)) {\n this.#time = time;\n }\n }\n\n /**\n * Getter for #type. Should only be called during JSON export.\n * @return {*}\n */\n get type() {\n return (!this.jsonString) ? throwWriteOnlyError() : this.#type;\n }\n\n /**\n * Setter for #type\n * @param {string} type\n */\n set type(type) {\n if (check12ValidFormat(type, scorm12_regex.CMIType)) {\n this.#type = type;\n }\n }\n\n /**\n * Getter for #weighting. Should only be called during JSON export.\n * @return {*}\n */\n get weighting() {\n return (!this.jsonString) ?\n throwWriteOnlyError() :\n this.#weighting;\n }\n\n /**\n * Setter for #weighting\n * @param {string} weighting\n */\n set weighting(weighting) {\n if (check12ValidFormat(weighting, scorm12_regex.CMIDecimal) &&\n check12ValidRange(weighting, scorm12_regex.weighting_range)) {\n this.#weighting = weighting;\n }\n }\n\n /**\n * Getter for #student_response. Should only be called during JSON export.\n * @return {*}\n */\n get student_response() {\n return (!this.jsonString) ? throwWriteOnlyError() : this.#student_response;\n }\n\n /**\n * Setter for #student_response\n * @param {string} student_response\n */\n set student_response(student_response) {\n if (check12ValidFormat(student_response, scorm12_regex.CMIFeedback, true)) {\n this.#student_response = student_response;\n }\n }\n\n /**\n * Getter for #result. Should only be called during JSON export.\n * @return {*}\n */\n get result() {\n return (!this.jsonString) ? throwWriteOnlyError() : this.#result;\n }\n\n /**\n * Setter for #result\n * @param {string} result\n */\n set result(result) {\n if (check12ValidFormat(result, scorm12_regex.CMIResult)) {\n this.#result = result;\n }\n }\n\n /**\n * Getter for #latency. Should only be called during JSON export.\n * @return {*}\n */\n get latency() {\n return (!this.jsonString) ? throwWriteOnlyError() : this.#latency;\n }\n\n /**\n * Setter for #latency\n * @param {string} latency\n */\n set latency(latency) {\n if (check12ValidFormat(latency, scorm12_regex.CMITimespan)) {\n this.#latency = latency;\n }\n }\n\n /**\n * toJSON for cmi.interactions.n\n *\n * @return {\n * {\n * id: string,\n * time: string,\n * type: string,\n * weighting: string,\n * student_response: string,\n * result: string,\n * latency: string,\n * objectives: CMIArray,\n * correct_responses: CMIArray\n * }\n * }\n */\n toJSON() {\n this.jsonString = true;\n const result = {\n 'id': this.id,\n 'time': this.time,\n 'type': this.type,\n 'weighting': this.weighting,\n 'student_response': this.student_response,\n 'result': this.result,\n 'latency': this.latency,\n 'objectives': this.objectives,\n 'correct_responses': this.correct_responses,\n };\n delete this.jsonString;\n return result;\n }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.objectives.n object\n * @extends BaseCMI\n */\nexport class CMIObjectivesObject extends BaseCMI {\n /**\n * Constructor for cmi.objectives.n\n */\n constructor() {\n super();\n\n this.score = new CMIScore(\n {\n score_children: scorm12_constants.score_children,\n score_range: scorm12_regex.score_range,\n invalidErrorCode: scorm12_error_codes.INVALID_SET_VALUE,\n invalidTypeCode: scorm12_error_codes.TYPE_MISMATCH,\n invalidRangeCode: scorm12_error_codes.VALUE_OUT_OF_RANGE,\n errorClass: Scorm12ValidationError,\n });\n }\n\n #id = '';\n #status = '';\n\n /**\n * Getter for #id\n * @return {\"\"}\n */\n get id() {\n return this.#id;\n }\n\n /**\n * Setter for #id\n * @param {string} id\n */\n set id(id) {\n if (check12ValidFormat(id, scorm12_regex.CMIIdentifier)) {\n this.#id = id;\n }\n }\n\n /**\n * Getter for #status\n * @return {\"\"}\n */\n get status() {\n return this.#status;\n }\n\n /**\n * Setter for #status\n * @param {string} status\n */\n set status(status) {\n if (check12ValidFormat(status, scorm12_regex.CMIStatus2)) {\n this.#status = status;\n }\n }\n\n /**\n * toJSON for cmi.objectives.n\n * @return {\n * {\n * id: string,\n * status: string,\n * score: CMIScore\n * }\n * }\n */\n toJSON() {\n this.jsonString = true;\n const result = {\n 'id': this.id,\n 'status': this.status,\n 'score': this.score,\n };\n delete this.jsonString;\n return result;\n }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.interactions.n.objectives.n object\n * @extends BaseCMI\n */\nexport class CMIInteractionsObjectivesObject extends BaseCMI {\n /**\n * Constructor for cmi.interactions.n.objectives.n\n */\n constructor() {\n super();\n }\n\n #id = '';\n\n /**\n * Getter for #id\n * @return {\"\"}\n */\n get id() {\n return this.#id;\n }\n\n /**\n * Setter for #id\n * @param {string} id\n */\n set id(id) {\n if (check12ValidFormat(id, scorm12_regex.CMIIdentifier)) {\n this.#id = id;\n }\n }\n\n /**\n * toJSON for cmi.interactions.n.objectives.n\n * @return {\n * {\n * id: string\n * }\n * }\n */\n toJSON() {\n this.jsonString = true;\n const result = {\n 'id': this.id,\n };\n delete this.jsonString;\n return result;\n }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.interactions.correct_responses.n object\n * @extends BaseCMI\n */\nexport class CMIInteractionsCorrectResponsesObject extends BaseCMI {\n /**\n * Constructor for cmi.interactions.correct_responses.n\n */\n constructor() {\n super();\n }\n\n #pattern = '';\n\n /**\n * Getter for #pattern\n * @return {string}\n */\n get pattern() {\n return (!this.jsonString) ? throwWriteOnlyError() : this.#pattern;\n }\n\n /**\n * Setter for #pattern\n * @param {string} pattern\n */\n set pattern(pattern) {\n if (check12ValidFormat(pattern, scorm12_regex.CMIFeedback, true)) {\n this.#pattern = pattern;\n }\n }\n\n /**\n * toJSON for cmi.interactions.correct_responses.n\n * @return {\n * {\n * pattern: string\n * }\n * }\n */\n toJSON() {\n this.jsonString = true;\n const result = {\n 'pattern': this.pattern,\n };\n delete this.jsonString;\n return result;\n }\n}\n\n/**\n * Class for AICC Navigation object\n */\nexport class NAV extends BaseCMI {\n /**\n * Constructor for NAV object\n */\n constructor() {\n super();\n }\n\n #event = '';\n\n /**\n * Getter for #event\n * @return {string}\n */\n get event() {\n return this.#event;\n }\n\n /**\n * Setter for #event\n * @param {string} event\n */\n set event(event) {\n if (check12ValidFormat(event, scorm12_regex.NAVEvent)) {\n this.#event = event;\n }\n }\n\n /**\n * toJSON for nav object\n * @return {\n * {\n * event: string\n * }\n * }\n */\n toJSON() {\n this.jsonString = true;\n const result = {\n 'event': this.event,\n };\n delete this.jsonString;\n return result;\n }\n}\n","// @flow\nimport {\n BaseCMI,\n checkValidFormat,\n checkValidRange,\n CMIArray,\n CMIScore,\n} from './common';\nimport APIConstants from '../constants/api_constants';\nimport Regex from '../constants/regex';\nimport ErrorCodes from '../constants/error_codes';\nimport Responses from '../constants/response_constants';\nimport {Scorm2004ValidationError} from '../exceptions';\nimport * as Util from '../utilities';\n\nconst scorm2004_constants = APIConstants.scorm2004;\nconst scorm2004_error_codes = ErrorCodes.scorm2004;\nconst learner_responses = Responses.learner;\n\nconst scorm2004_regex = Regex.scorm2004;\n\n/**\n * Helper method for throwing Read Only error\n */\nfunction throwReadOnlyError() {\n throw new Scorm2004ValidationError(scorm2004_error_codes.READ_ONLY_ELEMENT);\n}\n\n/**\n * Helper method for throwing Write Only error\n */\nfunction throwWriteOnlyError() {\n throw new Scorm2004ValidationError(scorm2004_error_codes.WRITE_ONLY_ELEMENT);\n}\n\n/**\n * Helper method for throwing Type Mismatch error\n */\nfunction throwTypeMismatchError() {\n throw new Scorm2004ValidationError(scorm2004_error_codes.TYPE_MISMATCH);\n}\n\n/**\n * Helper method for throwing Dependency Not Established error\n */\nfunction throwDependencyNotEstablishedError() {\n throw new Scorm2004ValidationError(scorm2004_error_codes.DEPENDENCY_NOT_ESTABLISHED);\n}\n\n/**\n * Helper method for throwing Dependency Not Established error\n */\nfunction throwGeneralSetError() {\n throw new Scorm2004ValidationError(scorm2004_error_codes.GENERAL_SET_FAILURE);\n}\n\n/**\n * Helper method, no reason to have to pass the same error codes every time\n * @param {*} value\n * @param {string} regexPattern\n * @param {boolean} allowEmptyString\n * @return {boolean}\n */\nfunction check2004ValidFormat(\n value: String,\n regexPattern: String,\n allowEmptyString?: boolean) {\n return checkValidFormat(\n value,\n regexPattern,\n scorm2004_error_codes.TYPE_MISMATCH,\n Scorm2004ValidationError,\n allowEmptyString,\n );\n}\n\n/**\n * Helper method, no reason to have to pass the same error codes every time\n * @param {*} value\n * @param {string} rangePattern\n * @return {boolean}\n */\nfunction check2004ValidRange(value: any, rangePattern: String) {\n return checkValidRange(\n value,\n rangePattern,\n scorm2004_error_codes.VALUE_OUT_OF_RANGE,\n Scorm2004ValidationError,\n );\n}\n\n/**\n * Class representing cmi object for SCORM 2004\n */\nexport class CMI extends BaseCMI {\n /**\n * Constructor for the SCORM 2004 cmi object\n * @param {boolean} initialized\n */\n constructor(initialized: boolean) {\n super();\n\n this.learner_preference = new CMILearnerPreference();\n this.score = new Scorm2004CMIScore();\n this.comments_from_learner = new CMICommentsFromLearner();\n this.comments_from_lms = new CMICommentsFromLMS();\n this.interactions = new CMIInteractions();\n this.objectives = new CMIObjectives();\n\n if (initialized) this.initialize();\n }\n\n #_version = '1.0';\n #_children = scorm2004_constants.cmi_children;\n #completion_status = 'unknown';\n #completion_threshold = '';\n #credit = 'credit';\n #entry = '';\n #exit = '';\n #launch_data = '';\n #learner_id = '';\n #learner_name = '';\n #location = '';\n #max_time_allowed = '';\n #mode = 'normal';\n #progress_measure = '';\n #scaled_passing_score = '';\n #session_time = 'PT0H0M0S';\n #success_status = 'unknown';\n #suspend_data = '';\n #time_limit_action = 'continue,no message';\n #total_time = '';\n\n /**\n * Called when the API has been initialized after the CMI has been created\n */\n initialize() {\n super.initialize();\n this.learner_preference?.initialize();\n this.score?.initialize();\n this.comments_from_learner?.initialize();\n this.comments_from_lms?.initialize();\n this.interactions?.initialize();\n this.objectives?.initialize();\n }\n\n /**\n * Getter for #_version\n * @return {string}\n * @private\n */\n get _version() {\n return this.#_version;\n }\n\n /**\n * Setter for #_version. Just throws an error.\n * @param {string} _version\n * @private\n */\n set _version(_version) {\n throwReadOnlyError();\n }\n\n /**\n * Getter for #_children\n * @return {string}\n * @private\n */\n get _children() {\n return this.#_children;\n }\n\n /**\n * Setter for #_children. Just throws an error.\n * @param {number} _children\n * @private\n */\n set _children(_children) {\n throwReadOnlyError();\n }\n\n /**\n * Getter for #completion_status\n * @return {string}\n */\n get completion_status() {\n return this.#completion_status;\n }\n\n /**\n * Setter for #completion_status\n * @param {string} completion_status\n */\n set completion_status(completion_status) {\n if (check2004ValidFormat(completion_status, scorm2004_regex.CMICStatus)) {\n this.#completion_status = completion_status;\n }\n }\n\n /**\n * Getter for #completion_threshold\n * @return {string}\n */\n get completion_threshold() {\n return this.#completion_threshold;\n }\n\n /**\n * Setter for #completion_threshold. Can only be called before initialization.\n * @param {string} completion_threshold\n */\n set completion_threshold(completion_threshold) {\n !this.initialized ?\n this.#completion_threshold = completion_threshold :\n throwReadOnlyError();\n }\n\n /**\n * Setter for #credit\n * @return {string}\n */\n get credit() {\n return this.#credit;\n }\n\n /**\n * Setter for #credit. Can only be called before initialization.\n * @param {string} credit\n */\n set credit(credit) {\n !this.initialized ? this.#credit = credit : throwReadOnlyError();\n }\n\n /**\n * Getter for #entry\n * @return {string}\n */\n get entry() {\n return this.#entry;\n }\n\n /**\n * Setter for #entry. Can only be called before initialization.\n * @param {string} entry\n */\n set entry(entry) {\n !this.initialized ? this.#entry = entry : throwReadOnlyError();\n }\n\n /**\n * Getter for #exit. Should only be called during JSON export.\n * @return {string}\n */\n get exit() {\n return (!this.jsonString) ? throwWriteOnlyError() : this.#exit;\n }\n\n /**\n * Getter for #exit\n * @param {string} exit\n */\n set exit(exit) {\n if (check2004ValidFormat(exit, scorm2004_regex.CMIExit, true)) {\n this.#exit = exit;\n }\n }\n\n /**\n * Getter for #launch_data\n * @return {string}\n */\n get launch_data() {\n return this.#launch_data;\n }\n\n /**\n * Setter for #launch_data. Can only be called before initialization.\n * @param {string} launch_data\n */\n set launch_data(launch_data) {\n !this.initialized ? this.#launch_data = launch_data : throwReadOnlyError();\n }\n\n /**\n * Getter for #learner_id\n * @return {string}\n */\n get learner_id() {\n return this.#learner_id;\n }\n\n /**\n * Setter for #learner_id. Can only be called before initialization.\n * @param {string} learner_id\n */\n set learner_id(learner_id) {\n !this.initialized ? this.#learner_id = learner_id : throwReadOnlyError();\n }\n\n /**\n * Getter for #learner_name\n * @return {string}\n */\n get learner_name() {\n return this.#learner_name;\n }\n\n /**\n * Setter for #learner_name. Can only be called before initialization.\n * @param {string} learner_name\n */\n set learner_name(learner_name) {\n !this.initialized ?\n this.#learner_name = learner_name :\n throwReadOnlyError();\n }\n\n /**\n * Getter for #location\n * @return {string}\n */\n get location() {\n return this.#location;\n }\n\n /**\n * Setter for #location\n * @param {string} location\n */\n set location(location) {\n if (check2004ValidFormat(location, scorm2004_regex.CMIString1000)) {\n this.#location = location;\n }\n }\n\n /**\n * Getter for #max_time_allowed\n * @return {string}\n */\n get max_time_allowed() {\n return this.#max_time_allowed;\n }\n\n /**\n * Setter for #max_time_allowed. Can only be called before initialization.\n * @param {string} max_time_allowed\n */\n set max_time_allowed(max_time_allowed) {\n !this.initialized ?\n this.#max_time_allowed = max_time_allowed :\n throwReadOnlyError();\n }\n\n /**\n * Getter for #mode\n * @return {string}\n */\n get mode() {\n return this.#mode;\n }\n\n /**\n * Setter for #mode. Can only be called before initialization.\n * @param {string} mode\n */\n set mode(mode) {\n !this.initialized ? this.#mode = mode : throwReadOnlyError();\n }\n\n /**\n * Getter for #progress_measure\n * @return {string}\n */\n get progress_measure() {\n return this.#progress_measure;\n }\n\n /**\n * Setter for #progress_measure\n * @param {string} progress_measure\n */\n set progress_measure(progress_measure) {\n if (check2004ValidFormat(progress_measure, scorm2004_regex.CMIDecimal) &&\n check2004ValidRange(progress_measure, scorm2004_regex.progress_range)) {\n this.#progress_measure = progress_measure;\n }\n }\n\n /**\n * Getter for #scaled_passing_score\n * @return {string}\n */\n get scaled_passing_score() {\n return this.#scaled_passing_score;\n }\n\n /**\n * Setter for #scaled_passing_score. Can only be called before initialization.\n * @param {string} scaled_passing_score\n */\n set scaled_passing_score(scaled_passing_score) {\n !this.initialized ?\n this.#scaled_passing_score = scaled_passing_score :\n throwReadOnlyError();\n }\n\n /**\n * Getter for #session_time. Should only be called during JSON export.\n * @return {string}\n */\n get session_time() {\n return (!this.jsonString) ? throwWriteOnlyError() : this.#session_time;\n }\n\n /**\n * Setter for #session_time\n * @param {string} session_time\n */\n set session_time(session_time) {\n if (check2004ValidFormat(session_time, scorm2004_regex.CMITimespan)) {\n this.#session_time = session_time;\n }\n }\n\n /**\n * Getter for #success_status\n * @return {string}\n */\n get success_status() {\n return this.#success_status;\n }\n\n /**\n * Setter for #success_status\n * @param {string} success_status\n */\n set success_status(success_status) {\n if (check2004ValidFormat(success_status, scorm2004_regex.CMISStatus)) {\n this.#success_status = success_status;\n }\n }\n\n /**\n * Getter for #suspend_data\n * @return {string}\n */\n get suspend_data() {\n return this.#suspend_data;\n }\n\n /**\n * Setter for #suspend_data\n * @param {string} suspend_data\n */\n set suspend_data(suspend_data) {\n if (check2004ValidFormat(suspend_data, scorm2004_regex.CMIString64000,\n true)) {\n this.#suspend_data = suspend_data;\n }\n }\n\n /**\n * Getter for #time_limit_action\n * @return {string}\n */\n get time_limit_action() {\n return this.#time_limit_action;\n }\n\n /**\n * Setter for #time_limit_action. Can only be called before initialization.\n * @param {string} time_limit_action\n */\n set time_limit_action(time_limit_action) {\n !this.initialized ?\n this.#time_limit_action = time_limit_action :\n throwReadOnlyError();\n }\n\n /**\n * Getter for #total_time\n * @return {string}\n */\n get total_time() {\n return this.#total_time;\n }\n\n /**\n * Setter for #total_time. Can only be called before initialization.\n * @param {string} total_time\n */\n set total_time(total_time) {\n !this.initialized ? this.#total_time = total_time : throwReadOnlyError();\n }\n\n /**\n * Adds the current session time to the existing total time.\n *\n * @return {string} ISO8601 Duration\n */\n getCurrentTotalTime() {\n let sessionTime = this.#session_time;\n const startTime = this.start_time;\n\n if (typeof startTime !== 'undefined' && startTime !== null) {\n const seconds = new Date().getTime() - startTime;\n sessionTime = Util.getSecondsAsISODuration(seconds / 1000);\n }\n\n return Util.addTwoDurations(\n this.#total_time,\n sessionTime,\n scorm2004_regex.CMITimespan,\n );\n }\n\n /**\n * toJSON for cmi\n *\n * @return {\n * {\n * comments_from_learner: CMICommentsFromLearner,\n * comments_from_lms: CMICommentsFromLMS,\n * completion_status: string,\n * completion_threshold: string,\n * credit: string,\n * entry: string,\n * exit: string,\n * interactions: CMIInteractions,\n * launch_data: string,\n * learner_id: string,\n * learner_name: string,\n * learner_preference: CMILearnerPreference,\n * location: string,\n * max_time_allowed: string,\n * mode: string,\n * objectives: CMIObjectives,\n * progress_measure: string,\n * scaled_passing_score: string,\n * score: Scorm2004CMIScore,\n * session_time: string,\n * success_status: string,\n * suspend_data: string,\n * time_limit_action: string\n * }\n * }\n */\n toJSON() {\n this.jsonString = true;\n const result = {\n 'comments_from_learner': this.comments_from_learner,\n 'comments_from_lms': this.comments_from_lms,\n 'completion_status': this.completion_status,\n 'completion_threshold': this.completion_threshold,\n 'credit': this.credit,\n 'entry': this.entry,\n 'exit': this.exit,\n 'interactions': this.interactions,\n 'launch_data': this.launch_data,\n 'learner_id': this.learner_id,\n 'learner_name': this.learner_name,\n 'learner_preference': this.learner_preference,\n 'location': this.location,\n 'max_time_allowed': this.max_time_allowed,\n 'mode': this.mode,\n 'objectives': this.objectives,\n 'progress_measure': this.progress_measure,\n 'scaled_passing_score': this.scaled_passing_score,\n 'score': this.score,\n 'session_time': this.session_time,\n 'success_status': this.success_status,\n 'suspend_data': this.suspend_data,\n 'time_limit_action': this.time_limit_action,\n };\n delete this.jsonString;\n return result;\n }\n}\n\n/**\n * Class for SCORM 2004's cmi.learner_preference object\n */\nclass CMILearnerPreference extends BaseCMI {\n #_children = scorm2004_constants.student_preference_children;\n #audio_level = '1';\n #language = '';\n #delivery_speed = '1';\n #audio_captioning = '0';\n\n /**\n * Constructor for cmi.learner_preference\n */\n constructor() {\n super();\n }\n\n /**\n * Getter for #_children\n * @return {string}\n * @private\n */\n get _children() {\n return this.#_children;\n }\n\n /**\n * Setter for #_children. Just throws an error.\n * @param {string} _children\n * @private\n */\n set _children(_children) {\n throwReadOnlyError();\n }\n\n /**\n * Getter for #audio_level\n * @return {string}\n */\n get audio_level() {\n return this.#audio_level;\n }\n\n /**\n * Setter for #audio_level\n * @param {string} audio_level\n */\n set audio_level(audio_level) {\n if (check2004ValidFormat(audio_level, scorm2004_regex.CMIDecimal) &&\n check2004ValidRange(audio_level, scorm2004_regex.audio_range)) {\n this.#audio_level = audio_level;\n }\n }\n\n /**\n * Getter for #language\n * @return {string}\n */\n get language() {\n return this.#language;\n }\n\n /**\n * Setter for #language\n * @param {string} language\n */\n set language(language) {\n if (check2004ValidFormat(language, scorm2004_regex.CMILang)) {\n this.#language = language;\n }\n }\n\n /**\n * Getter for #delivery_speed\n * @return {string}\n */\n get delivery_speed() {\n return this.#delivery_speed;\n }\n\n /**\n * Setter for #delivery_speed\n * @param {string} delivery_speed\n */\n set delivery_speed(delivery_speed) {\n if (check2004ValidFormat(delivery_speed, scorm2004_regex.CMIDecimal) &&\n check2004ValidRange(delivery_speed, scorm2004_regex.speed_range)) {\n this.#delivery_speed = delivery_speed;\n }\n }\n\n /**\n * Getter for #audio_captioning\n * @return {string}\n */\n get audio_captioning() {\n return this.#audio_captioning;\n }\n\n /**\n * Setter for #audio_captioning\n * @param {string} audio_captioning\n */\n set audio_captioning(audio_captioning) {\n if (check2004ValidFormat(audio_captioning, scorm2004_regex.CMISInteger) &&\n check2004ValidRange(audio_captioning, scorm2004_regex.text_range)) {\n this.#audio_captioning = audio_captioning;\n }\n }\n\n /**\n * toJSON for cmi.learner_preference\n *\n * @return {\n * {\n * audio_level: string,\n * language: string,\n * delivery_speed: string,\n * audio_captioning: string\n * }\n * }\n */\n toJSON() {\n this.jsonString = true;\n const result = {\n 'audio_level': this.audio_level,\n 'language': this.language,\n 'delivery_speed': this.delivery_speed,\n 'audio_captioning': this.audio_captioning,\n };\n delete this.jsonString;\n return result;\n }\n}\n\n/**\n * Class representing SCORM 2004's cmi.interactions object\n */\nclass CMIInteractions extends CMIArray {\n /**\n * Constructor for cmi.objectives Array\n */\n constructor() {\n super({\n children: scorm2004_constants.interactions_children,\n errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n errorClass: Scorm2004ValidationError,\n });\n }\n}\n\n/**\n * Class representing SCORM 2004's cmi.objectives object\n */\nclass CMIObjectives extends CMIArray {\n /**\n * Constructor for cmi.objectives Array\n */\n constructor() {\n super({\n children: scorm2004_constants.objectives_children,\n errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n errorClass: Scorm2004ValidationError,\n });\n }\n}\n\n/**\n * Class representing SCORM 2004's cmi.comments_from_lms object\n */\nclass CMICommentsFromLMS extends CMIArray {\n /**\n * Constructor for cmi.comments_from_lms Array\n */\n constructor() {\n super({\n children: scorm2004_constants.comments_children,\n errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n errorClass: Scorm2004ValidationError,\n });\n }\n}\n\n/**\n * Class representing SCORM 2004's cmi.comments_from_learner object\n */\nclass CMICommentsFromLearner extends CMIArray {\n /**\n * Constructor for cmi.comments_from_learner Array\n */\n constructor() {\n super({\n children: scorm2004_constants.comments_children,\n errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n errorClass: Scorm2004ValidationError,\n });\n }\n}\n\n/**\n * Class for SCORM 2004's cmi.interaction.n object\n */\nexport class CMIInteractionsObject extends BaseCMI {\n #id = '';\n #type = '';\n #timestamp = '';\n #weighting = '';\n #learner_response = '';\n #result = '';\n #latency = '';\n #description = '';\n\n /**\n * Constructor for cmi.interaction.n\n */\n constructor() {\n super();\n\n this.objectives = new CMIArray({\n errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n errorClass: Scorm2004ValidationError,\n children: scorm2004_constants.objectives_children,\n });\n this.correct_responses = new CMIArray({\n errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n errorClass: Scorm2004ValidationError,\n children: scorm2004_constants.correct_responses_children,\n });\n }\n\n /**\n * Called when the API has been initialized after the CMI has been created\n */\n initialize() {\n super.initialize();\n this.objectives?.initialize();\n this.correct_responses?.initialize();\n }\n\n /**\n * Getter for #id\n * @return {string}\n */\n get id() {\n return this.#id;\n }\n\n /**\n * Setter for #id\n * @param {string} id\n */\n set id(id) {\n if (check2004ValidFormat(id, scorm2004_regex.CMILongIdentifier)) {\n this.#id = id;\n }\n }\n\n /**\n * Getter for #type\n * @return {string}\n */\n get type() {\n return this.#type;\n }\n\n /**\n * Setter for #type\n * @param {string} type\n */\n set type(type) {\n if (this.initialized && this.#id === '') {\n throwDependencyNotEstablishedError();\n } else {\n if (check2004ValidFormat(type, scorm2004_regex.CMIType)) {\n this.#type = type;\n }\n }\n }\n\n /**\n * Getter for #timestamp\n * @return {string}\n */\n get timestamp() {\n return this.#timestamp;\n }\n\n /**\n * Setter for #timestamp\n * @param {string} timestamp\n */\n set timestamp(timestamp) {\n if (this.initialized && this.#id === '') {\n throwDependencyNotEstablishedError();\n } else {\n if (check2004ValidFormat(timestamp, scorm2004_regex.CMITime)) {\n this.#timestamp = timestamp;\n }\n }\n }\n\n /**\n * Getter for #weighting\n * @return {string}\n */\n get weighting() {\n return this.#weighting;\n }\n\n /**\n * Setter for #weighting\n * @param {string} weighting\n */\n set weighting(weighting) {\n if (this.initialized && this.#id === '') {\n throwDependencyNotEstablishedError();\n } else {\n if (check2004ValidFormat(weighting, scorm2004_regex.CMIDecimal)) {\n this.#weighting = weighting;\n }\n }\n }\n\n /**\n * Getter for #learner_response\n * @return {string}\n */\n get learner_response() {\n return this.#learner_response;\n }\n\n /**\n * Setter for #learner_response. Does type validation to make sure response\n * matches SCORM 2004's spec\n * @param {string} learner_response\n */\n set learner_response(learner_response) {\n if (this.initialized && (this.#type === '' || this.#id === '')) {\n throwDependencyNotEstablishedError();\n } else {\n let nodes = [];\n const response_type = learner_responses[this.type];\n if (response_type) {\n if (response_type?.delimiter) {\n nodes = learner_response.split(response_type.delimiter);\n } else {\n nodes[0] = learner_response;\n }\n\n if ((nodes.length > 0) && (nodes.length <= response_type.max)) {\n const formatRegex = new RegExp(response_type.format);\n for (let i = 0; i < nodes.length; i++) {\n if (response_type?.delimiter2) {\n const values = nodes[i].split(response_type.delimiter2);\n if (values.length === 2) {\n if (!values[0].match(formatRegex)) {\n throwTypeMismatchError();\n } else {\n if (!values[1].match(new RegExp(response_type.format2))) {\n throwTypeMismatchError();\n }\n }\n } else {\n throwTypeMismatchError();\n }\n } else {\n if (!nodes[i].match(formatRegex)) {\n throwTypeMismatchError();\n } else {\n if (nodes[i] !== '' && response_type.unique) {\n for (let j = 0; j < i; j++) {\n if (nodes[i] === nodes[j]) {\n throwTypeMismatchError();\n }\n }\n }\n }\n }\n }\n } else {\n throwGeneralSetError();\n }\n\n this.#learner_response = learner_response;\n } else {\n throwTypeMismatchError();\n }\n }\n }\n\n /**\n * Getter for #result\n * @return {string}\n */\n get result() {\n return this.#result;\n }\n\n /**\n * Setter for #result\n * @param {string} result\n */\n set result(result) {\n if (check2004ValidFormat(result, scorm2004_regex.CMIResult)) {\n this.#result = result;\n }\n }\n\n /**\n * Getter for #latency\n * @return {string}\n */\n get latency() {\n return this.#latency;\n }\n\n /**\n * Setter for #latency\n * @param {string} latency\n */\n set latency(latency) {\n if (this.initialized && this.#id === '') {\n throwDependencyNotEstablishedError();\n } else {\n if (check2004ValidFormat(latency, scorm2004_regex.CMITimespan)) {\n this.#latency = latency;\n }\n }\n }\n\n /**\n * Getter for #description\n * @return {string}\n */\n get description() {\n return this.#description;\n }\n\n /**\n * Setter for #description\n * @param {string} description\n */\n set description(description) {\n if (this.initialized && this.#id === '') {\n throwDependencyNotEstablishedError();\n } else {\n if (check2004ValidFormat(description, scorm2004_regex.CMILangString250,\n true)) {\n this.#description = description;\n }\n }\n }\n\n /**\n * toJSON for cmi.interactions.n\n *\n * @return {\n * {\n * id: string,\n * type: string,\n * objectives: CMIArray,\n * timestamp: string,\n * correct_responses: CMIArray,\n * weighting: string,\n * learner_response: string,\n * result: string,\n * latency: string,\n * description: string\n * }\n * }\n */\n toJSON() {\n this.jsonString = true;\n const result = {\n 'id': this.id,\n 'type': this.type,\n 'objectives': this.objectives,\n 'timestamp': this.timestamp,\n 'weighting': this.weighting,\n 'learner_response': this.learner_response,\n 'result': this.result,\n 'latency': this.latency,\n 'description': this.description,\n 'correct_responses': this.correct_responses,\n };\n delete this.jsonString;\n return result;\n }\n}\n\n/**\n * Class for SCORM 2004's cmi.objectives.n object\n */\nexport class CMIObjectivesObject extends BaseCMI {\n #id = '';\n #success_status = 'unknown';\n #completion_status = 'unknown';\n #progress_measure = '';\n #description = '';\n\n /**\n * Constructor for cmi.objectives.n\n */\n constructor() {\n super();\n\n this.score = new Scorm2004CMIScore();\n }\n\n /**\n * Called when the API has been initialized after the CMI has been created\n */\n initialize() {\n super.initialize();\n this.score?.initialize();\n }\n\n /**\n * Getter for #id\n * @return {string}\n */\n get id() {\n return this.#id;\n }\n\n /**\n * Setter for #id\n * @param {string} id\n */\n set id(id) {\n if (check2004ValidFormat(id, scorm2004_regex.CMILongIdentifier)) {\n this.#id = id;\n }\n }\n\n /**\n * Getter for #success_status\n * @return {string}\n */\n get success_status() {\n return this.#success_status;\n }\n\n /**\n * Setter for #success_status\n * @param {string} success_status\n */\n set success_status(success_status) {\n if (this.initialized && this.#id === '') {\n throwDependencyNotEstablishedError();\n } else {\n if (check2004ValidFormat(success_status, scorm2004_regex.CMISStatus)) {\n this.#success_status = success_status;\n }\n }\n }\n\n /**\n * Getter for #completion_status\n * @return {string}\n */\n get completion_status() {\n return this.#completion_status;\n }\n\n /**\n * Setter for #completion_status\n * @param {string} completion_status\n */\n set completion_status(completion_status) {\n if (this.initialized && this.#id === '') {\n throwDependencyNotEstablishedError();\n } else {\n if (check2004ValidFormat(completion_status, scorm2004_regex.CMICStatus)) {\n this.#completion_status = completion_status;\n }\n }\n }\n\n /**\n * Getter for #progress_measure\n * @return {string}\n */\n get progress_measure() {\n return this.#progress_measure;\n }\n\n /**\n * Setter for #progress_measure\n * @param {string} progress_measure\n */\n set progress_measure(progress_measure) {\n if (this.initialized && this.#id === '') {\n throwDependencyNotEstablishedError();\n } else {\n if (check2004ValidFormat(progress_measure, scorm2004_regex.CMIDecimal) &&\n check2004ValidRange(progress_measure,\n scorm2004_regex.progress_range)) {\n this.#progress_measure = progress_measure;\n }\n }\n }\n\n /**\n * Getter for #description\n * @return {string}\n */\n get description() {\n return this.#description;\n }\n\n /**\n * Setter for #description\n * @param {string} description\n */\n set description(description) {\n if (this.initialized && this.#id === '') {\n throwDependencyNotEstablishedError();\n } else {\n if (check2004ValidFormat(description, scorm2004_regex.CMILangString250,\n true)) {\n this.#description = description;\n }\n }\n }\n\n /**\n * toJSON for cmi.objectives.n\n *\n * @return {\n * {\n * id: string,\n * success_status: string,\n * completion_status: string,\n * progress_measure: string,\n * description: string,\n * score: Scorm2004CMIScore\n * }\n * }\n */\n toJSON() {\n this.jsonString = true;\n const result = {\n 'id': this.id,\n 'success_status': this.success_status,\n 'completion_status': this.completion_status,\n 'progress_measure': this.progress_measure,\n 'description': this.description,\n 'score': this.score,\n };\n delete this.jsonString;\n return result;\n }\n}\n\n/**\n * Class for SCORM 2004's cmi *.score object\n */\nclass Scorm2004CMIScore extends CMIScore {\n #scaled = '';\n\n /**\n * Constructor for cmi *.score\n */\n constructor() {\n super(\n {\n score_children: scorm2004_constants.score_children,\n max: '',\n invalidErrorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n invalidTypeCode: scorm2004_error_codes.TYPE_MISMATCH,\n invalidRangeCode: scorm2004_error_codes.VALUE_OUT_OF_RANGE,\n decimalRegex: scorm2004_regex.CMIDecimal,\n errorClass: Scorm2004ValidationError,\n });\n }\n\n /**\n * Getter for #scaled\n * @return {string}\n */\n get scaled() {\n return this.#scaled;\n }\n\n /**\n * Setter for #scaled\n * @param {string} scaled\n */\n set scaled(scaled) {\n if (check2004ValidFormat(scaled, scorm2004_regex.CMIDecimal) &&\n check2004ValidRange(scaled, scorm2004_regex.scaled_range)) {\n this.#scaled = scaled;\n }\n }\n\n /**\n * toJSON for cmi *.score\n *\n * @return {\n * {\n * scaled: string,\n * raw: string,\n * min: string,\n * max: string\n * }\n * }\n */\n toJSON() {\n this.jsonString = true;\n const result = {\n 'scaled': this.scaled,\n 'raw': super.raw,\n 'min': super.min,\n 'max': super.max,\n };\n delete this.jsonString;\n return result;\n }\n}\n\n/**\n * Class representing SCORM 2004's cmi.comments_from_learner.n and cmi.comments_from_lms.n object\n */\nexport class CMICommentsObject extends BaseCMI {\n #comment = '';\n #location = '';\n #timestamp = '';\n #readOnlyAfterInit;\n\n /**\n * Constructor for cmi.comments_from_learner.n and cmi.comments_from_lms.n\n * @param {boolean} readOnlyAfterInit\n */\n constructor(readOnlyAfterInit = false) {\n super();\n this.#comment = '';\n this.#location = '';\n this.#timestamp = '';\n this.#readOnlyAfterInit = readOnlyAfterInit;\n }\n\n /**\n * Getter for #comment\n * @return {string}\n */\n get comment() {\n return this.#comment;\n }\n\n /**\n * Setter for #comment\n * @param {string} comment\n */\n set comment(comment) {\n if (this.initialized && this.#readOnlyAfterInit) {\n throwReadOnlyError();\n } else {\n if (check2004ValidFormat(comment, scorm2004_regex.CMILangString4000,\n true)) {\n this.#comment = comment;\n }\n }\n }\n\n /**\n * Getter for #location\n * @return {string}\n */\n get location() {\n return this.#location;\n }\n\n /**\n * Setter for #location\n * @param {string} location\n */\n set location(location) {\n if (this.initialized && this.#readOnlyAfterInit) {\n throwReadOnlyError();\n } else {\n if (check2004ValidFormat(location, scorm2004_regex.CMIString250)) {\n this.#location = location;\n }\n }\n }\n\n /**\n * Getter for #timestamp\n * @return {string}\n */\n get timestamp() {\n return this.#timestamp;\n }\n\n /**\n * Setter for #timestamp\n * @param {string} timestamp\n */\n set timestamp(timestamp) {\n if (this.initialized && this.#readOnlyAfterInit) {\n throwReadOnlyError();\n } else {\n if (check2004ValidFormat(timestamp, scorm2004_regex.CMITime)) {\n this.#timestamp = timestamp;\n }\n }\n }\n\n /**\n * toJSON for cmi.comments_from_learner.n object\n * @return {\n * {\n * comment: string,\n * location: string,\n * timestamp: string\n * }\n * }\n */\n toJSON() {\n this.jsonString = true;\n const result = {\n 'comment': this.comment,\n 'location': this.location,\n 'timestamp': this.timestamp,\n };\n delete this.jsonString;\n return result;\n }\n}\n\n/**\n * Class representing SCORM 2004's cmi.interactions.n.objectives.n object\n */\nexport class CMIInteractionsObjectivesObject extends BaseCMI {\n #id = '';\n\n /**\n * Constructor for cmi.interactions.n.objectives.n\n */\n constructor() {\n super();\n }\n\n /**\n * Getter for #id\n * @return {string}\n */\n get id() {\n return this.#id;\n }\n\n /**\n * Setter for #id\n * @param {string} id\n */\n set id(id) {\n if (check2004ValidFormat(id, scorm2004_regex.CMILongIdentifier)) {\n this.#id = id;\n }\n }\n\n /**\n * toJSON for cmi.interactions.n.objectives.n\n * @return {\n * {\n * id: string\n * }\n * }\n */\n toJSON() {\n this.jsonString = true;\n const result = {\n 'id': this.id,\n };\n delete this.jsonString;\n return result;\n }\n}\n\n/**\n * Class representing SCORM 2004's cmi.interactions.n.correct_responses.n object\n */\nexport class CMIInteractionsCorrectResponsesObject extends BaseCMI {\n #pattern = '';\n\n /**\n * Constructor for cmi.interactions.n.correct_responses.n\n */\n constructor() {\n super();\n }\n\n /**\n * Getter for #pattern\n * @return {string}\n */\n get pattern() {\n return this.#pattern;\n }\n\n /**\n * Setter for #pattern\n * @param {string} pattern\n */\n set pattern(pattern) {\n if (check2004ValidFormat(pattern, scorm2004_regex.CMIFeedback)) {\n this.#pattern = pattern;\n }\n }\n\n /**\n * toJSON cmi.interactions.n.correct_responses.n object\n * @return {\n * {\n * pattern: string\n * }\n * }\n */\n toJSON() {\n this.jsonString = true;\n const result = {\n 'pattern': this.pattern,\n };\n delete this.jsonString;\n return result;\n }\n}\n\n/**\n * Class representing SCORM 2004's adl object\n */\nexport class ADL extends BaseCMI {\n /**\n * Constructor for adl\n */\n constructor() {\n super();\n\n this.nav = new ADLNav();\n }\n\n /**\n * Called when the API has been initialized after the CMI has been created\n */\n initialize() {\n super.initialize();\n this.nav?.initialize();\n }\n\n /**\n * toJSON for adl\n * @return {\n * {\n * nav: {\n * request: string\n * }\n * }\n * }\n */\n toJSON() {\n this.jsonString = true;\n const result = {\n 'nav': this.nav,\n };\n delete this.jsonString;\n return result;\n }\n}\n\n/**\n * Class representing SCORM 2004's adl.nav object\n */\nclass ADLNav extends BaseCMI {\n #request = '_none_';\n\n /**\n * Constructor for adl.nav\n */\n constructor() {\n super();\n\n this.request_valid = new ADLNavRequestValid();\n }\n\n /**\n * Called when the API has been initialized after the CMI has been created\n */\n initialize() {\n super.initialize();\n this.request_valid?.initialize();\n }\n\n /**\n * Getter for #request\n * @return {string}\n */\n get request() {\n return this.#request;\n }\n\n /**\n * Setter for #request\n * @param {string} request\n */\n set request(request) {\n if (check2004ValidFormat(request, scorm2004_regex.NAVEvent)) {\n this.#request = request;\n }\n }\n\n /**\n * toJSON for adl.nav\n *\n * @return {\n * {\n * request: string\n * }\n * }\n */\n toJSON() {\n this.jsonString = true;\n const result = {\n 'request': this.request,\n };\n delete this.jsonString;\n return result;\n }\n}\n\n/**\n * Class representing SCORM 2004's adl.nav.request_valid object\n */\nclass ADLNavRequestValid extends BaseCMI {\n #continue = 'unknown';\n #previous = 'unknown';\n choice = class {\n /**\n * Check if target is valid\n * @param {*} _target\n * @return {string}\n */\n _isTargetValid = (_target) => 'unknown';\n };\n jump = class {\n /**\n * Check if target is valid\n * @param {*} _target\n * @return {string}\n */\n _isTargetValid = (_target) => 'unknown';\n };\n\n /**\n * Constructor for adl.nav.request_valid\n */\n constructor() {\n super();\n }\n\n /**\n * Getter for #continue\n * @return {string}\n */\n get continue() {\n return this.#continue;\n }\n\n /**\n * Setter for #continue. Just throws an error.\n * @param {*} _\n */\n set continue(_) {\n throwReadOnlyError();\n }\n\n /**\n * Getter for #previous\n * @return {string}\n */\n get previous() {\n return this.#previous;\n }\n\n /**\n * Setter for #previous. Just throws an error.\n * @param {*} _\n */\n set previous(_) {\n throwReadOnlyError();\n }\n\n /**\n * toJSON for adl.nav.request_valid\n *\n * @return {\n * {\n * previous: string,\n * continue: string\n * }\n * }\n */\n toJSON() {\n this.jsonString = true;\n const result = {\n 'previous': this.previous,\n 'continue': this.continue,\n };\n delete this.jsonString;\n return result;\n }\n}\n","// @flow\n\nconst global = {\n SCORM_TRUE: 'true',\n SCORM_FALSE: 'false',\n STATE_NOT_INITIALIZED: 0,\n STATE_INITIALIZED: 1,\n STATE_TERMINATED: 2,\n LOG_LEVEL_DEBUG: 1,\n LOG_LEVEL_INFO: 2,\n LOG_LEVEL_WARNING: 3,\n LOG_LEVEL_ERROR: 4,\n LOG_LEVEL_NONE: 5,\n};\n\nconst scorm12 = {\n // Children lists\n cmi_children: 'core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions',\n core_children: 'student_id,student_name,lesson_location,credit,lesson_status,entry,score,total_time,lesson_mode,exit,session_time',\n score_children: 'raw,min,max',\n comments_children: 'content,location,time',\n objectives_children: 'id,score,status',\n correct_responses_children: 'pattern',\n student_data_children: 'mastery_score,max_time_allowed,time_limit_action',\n student_preference_children: 'audio,language,speed,text',\n interactions_children: 'id,objectives,time,type,correct_responses,weighting,student_response,result,latency',\n\n error_descriptions: {\n '101': {\n basicMessage: 'General Exception',\n detailMessage: 'No specific error code exists to describe the error. Use LMSGetDiagnostic for more information',\n },\n '201': {\n basicMessage: 'Invalid argument error',\n detailMessage: 'Indicates that an argument represents an invalid data model element or is otherwise incorrect.',\n },\n '202': {\n basicMessage: 'Element cannot have children',\n detailMessage: 'Indicates that LMSGetValue was called with a data model element name that ends in \"_children\" for a data model element that does not support the \"_children\" suffix.',\n },\n '203': {\n basicMessage: 'Element not an array - cannot have count',\n detailMessage: 'Indicates that LMSGetValue was called with a data model element name that ends in \"_count\" for a data model element that does not support the \"_count\" suffix.',\n },\n '301': {\n basicMessage: 'Not initialized',\n detailMessage: 'Indicates that an API call was made before the call to lmsInitialize.',\n },\n '401': {\n basicMessage: 'Not implemented error',\n detailMessage: 'The data model element indicated in a call to LMSGetValue or LMSSetValue is valid, but was not implemented by this LMS. SCORM 1.2 defines a set of data model elements as being optional for an LMS to implement.',\n },\n '402': {\n basicMessage: 'Invalid set value, element is a keyword',\n detailMessage: 'Indicates that LMSSetValue was called on a data model element that represents a keyword (elements that end in \"_children\" and \"_count\").',\n },\n '403': {\n basicMessage: 'Element is read only',\n detailMessage: 'LMSSetValue was called with a data model element that can only be read.',\n },\n '404': {\n basicMessage: 'Element is write only',\n detailMessage: 'LMSGetValue was called on a data model element that can only be written to.',\n },\n '405': {\n basicMessage: 'Incorrect Data Type',\n detailMessage: 'LMSSetValue was called with a value that is not consistent with the data format of the supplied data model element.',\n },\n '407': {\n basicMessage: 'Element Value Out Of Range',\n detailMessage: 'The numeric value supplied to a LMSSetValue call is outside of the numeric range allowed for the supplied data model element.',\n },\n '408': {\n basicMessage: 'Data Model Dependency Not Established',\n detailMessage: 'Some data model elements cannot be set until another data model element was set. This error condition indicates that the prerequisite element was not set before the dependent element.',\n },\n },\n};\n\nconst aicc = {\n ...scorm12, ...{\n cmi_children: 'core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions,evaluation',\n student_preference_children: 'audio,language,lesson_type,speed,text,text_color,text_location,text_size,video,windows',\n student_data_children: 'attempt_number,tries,mastery_score,max_time_allowed,time_limit_action',\n student_demographics_children: 'city,class,company,country,experience,familiar_name,instructor_name,title,native_language,state,street_address,telephone,years_experience',\n tries_children: 'time,status,score',\n attempt_records_children: 'score,lesson_status',\n paths_children: 'location_id,date,time,status,why_left,time_in_element',\n },\n};\n\nconst scorm2004 = {\n // Children lists\n cmi_children: '_version,comments_from_learner,comments_from_lms,completion_status,credit,entry,exit,interactions,launch_data,learner_id,learner_name,learner_preference,location,max_time_allowed,mode,objectives,progress_measure,scaled_passing_score,score,session_time,success_status,suspend_data,time_limit_action,total_time',\n comments_children: 'comment,timestamp,location',\n score_children: 'max,raw,scaled,min',\n objectives_children: 'progress_measure,completion_status,success_status,description,score,id',\n correct_responses_children: 'pattern',\n student_data_children: 'mastery_score,max_time_allowed,time_limit_action',\n student_preference_children: 'audio_level,audio_captioning,delivery_speed,language',\n interactions_children: 'id,type,objectives,timestamp,correct_responses,weighting,learner_response,result,latency,description',\n\n error_descriptions: {\n '0': {\n basicMessage: 'No Error',\n detailMessage: 'No error occurred, the previous API call was successful.',\n },\n '101': {\n basicMessage: 'General Exception',\n detailMessage: 'No specific error code exists to describe the error. Use GetDiagnostic for more information.',\n },\n '102': {\n basicMessage: 'General Initialization Failure',\n detailMessage: 'Call to Initialize failed for an unknown reason.',\n },\n '103': {\n basicMessage: 'Already Initialized',\n detailMessage: 'Call to Initialize failed because Initialize was already called.',\n },\n '104': {\n basicMessage: 'Content Instance Terminated',\n detailMessage: 'Call to Initialize failed because Terminate was already called.',\n },\n '111': {\n basicMessage: 'General Termination Failure',\n detailMessage: 'Call to Terminate failed for an unknown reason.',\n },\n '112': {\n basicMessage: 'Termination Before Initialization',\n detailMessage: 'Call to Terminate failed because it was made before the call to Initialize.',\n },\n '113': {\n basicMessage: 'Termination After Termination',\n detailMessage: 'Call to Terminate failed because Terminate was already called.',\n },\n '122': {\n basicMessage: 'Retrieve Data Before Initialization',\n detailMessage: 'Call to GetValue failed because it was made before the call to Initialize.',\n },\n '123': {\n basicMessage: 'Retrieve Data After Termination',\n detailMessage: 'Call to GetValue failed because it was made after the call to Terminate.',\n },\n '132': {\n basicMessage: 'Store Data Before Initialization',\n detailMessage: 'Call to SetValue failed because it was made before the call to Initialize.',\n },\n '133': {\n basicMessage: 'Store Data After Termination',\n detailMessage: 'Call to SetValue failed because it was made after the call to Terminate.',\n },\n '142': {\n basicMessage: 'Commit Before Initialization',\n detailMessage: 'Call to Commit failed because it was made before the call to Initialize.',\n },\n '143': {\n basicMessage: 'Commit After Termination',\n detailMessage: 'Call to Commit failed because it was made after the call to Terminate.',\n },\n '201': {\n basicMessage: 'General Argument Error',\n detailMessage: 'An invalid argument was passed to an API method (usually indicates that Initialize, Commit or Terminate did not receive the expected empty string argument.',\n },\n '301': {\n basicMessage: 'General Get Failure',\n detailMessage: 'Indicates a failed GetValue call where no other specific error code is applicable. Use GetDiagnostic for more information.',\n },\n '351': {\n basicMessage: 'General Set Failure',\n detailMessage: 'Indicates a failed SetValue call where no other specific error code is applicable. Use GetDiagnostic for more information.',\n },\n '391': {\n basicMessage: 'General Commit Failure',\n detailMessage: 'Indicates a failed Commit call where no other specific error code is applicable. Use GetDiagnostic for more information.',\n },\n '401': {\n basicMessage: 'Undefined Data Model Element',\n detailMessage: 'The data model element name passed to GetValue or SetValue is not a valid SCORM data model element.',\n },\n '402': {\n basicMessage: 'Unimplemented Data Model Element',\n detailMessage: 'The data model element indicated in a call to GetValue or SetValue is valid, but was not implemented by this LMS. In SCORM 2004, this error would indicate an LMS that is not fully SCORM conformant.',\n },\n '403': {\n basicMessage: 'Data Model Element Value Not Initialized',\n detailMessage: 'Attempt to read a data model element that has not been initialized by the LMS or through a SetValue call. This error condition is often reached during normal execution of a SCO.',\n },\n '404': {\n basicMessage: 'Data Model Element Is Read Only',\n detailMessage: 'SetValue was called with a data model element that can only be read.',\n },\n '405': {\n basicMessage: 'Data Model Element Is Write Only',\n detailMessage: 'GetValue was called on a data model element that can only be written to.',\n },\n '406': {\n basicMessage: 'Data Model Element Type Mismatch',\n detailMessage: 'SetValue was called with a value that is not consistent with the data format of the supplied data model element.',\n },\n '407': {\n basicMessage: 'Data Model Element Value Out Of Range',\n detailMessage: 'The numeric value supplied to a SetValue call is outside of the numeric range allowed for the supplied data model element.',\n },\n '408': {\n basicMessage: 'Data Model Dependency Not Established',\n detailMessage: 'Some data model elements cannot be set until another data model element was set. This error condition indicates that the prerequisite element was not set before the dependent element.',\n },\n },\n};\n\nconst APIConstants = {\n global: global,\n scorm12: scorm12,\n aicc: aicc,\n scorm2004: scorm2004,\n};\n\nexport default APIConstants;\n","// @flow\nconst global = {\n GENERAL: 101,\n INITIALIZATION_FAILED: 101,\n INITIALIZED: 101,\n TERMINATED: 101,\n TERMINATION_FAILURE: 101,\n TERMINATION_BEFORE_INIT: 101,\n MULTIPLE_TERMINATION: 101,\n RETRIEVE_BEFORE_INIT: 101,\n RETRIEVE_AFTER_TERM: 101,\n STORE_BEFORE_INIT: 101,\n STORE_AFTER_TERM: 101,\n COMMIT_BEFORE_INIT: 101,\n COMMIT_AFTER_TERM: 101,\n ARGUMENT_ERROR: 101,\n CHILDREN_ERROR: 101,\n COUNT_ERROR: 101,\n GENERAL_GET_FAILURE: 101,\n GENERAL_SET_FAILURE: 101,\n GENERAL_COMMIT_FAILURE: 101,\n UNDEFINED_DATA_MODEL: 101,\n UNIMPLEMENTED_ELEMENT: 101,\n VALUE_NOT_INITIALIZED: 101,\n INVALID_SET_VALUE: 101,\n READ_ONLY_ELEMENT: 101,\n WRITE_ONLY_ELEMENT: 101,\n TYPE_MISMATCH: 101,\n VALUE_OUT_OF_RANGE: 101,\n DEPENDENCY_NOT_ESTABLISHED: 101,\n};\n\nconst scorm12 = {\n ...global, ...{\n RETRIEVE_BEFORE_INIT: 301,\n STORE_BEFORE_INIT: 301,\n COMMIT_BEFORE_INIT: 301,\n ARGUMENT_ERROR: 201,\n CHILDREN_ERROR: 202,\n COUNT_ERROR: 203,\n UNDEFINED_DATA_MODEL: 401,\n UNIMPLEMENTED_ELEMENT: 401,\n VALUE_NOT_INITIALIZED: 301,\n INVALID_SET_VALUE: 402,\n READ_ONLY_ELEMENT: 403,\n WRITE_ONLY_ELEMENT: 404,\n TYPE_MISMATCH: 405,\n VALUE_OUT_OF_RANGE: 407,\n DEPENDENCY_NOT_ESTABLISHED: 408,\n },\n};\n\nconst scorm2004 = {\n ...global, ...{\n INITIALIZATION_FAILED: 102,\n INITIALIZED: 103,\n TERMINATED: 104,\n TERMINATION_FAILURE: 111,\n TERMINATION_BEFORE_INIT: 112,\n MULTIPLE_TERMINATIONS: 113,\n RETRIEVE_BEFORE_INIT: 122,\n RETRIEVE_AFTER_TERM: 123,\n STORE_BEFORE_INIT: 132,\n STORE_AFTER_TERM: 133,\n COMMIT_BEFORE_INIT: 142,\n COMMIT_AFTER_TERM: 143,\n ARGUMENT_ERROR: 201,\n GENERAL_GET_FAILURE: 301,\n GENERAL_SET_FAILURE: 351,\n GENERAL_COMMIT_FAILURE: 391,\n UNDEFINED_DATA_MODEL: 401,\n UNIMPLEMENTED_ELEMENT: 402,\n VALUE_NOT_INITIALIZED: 403,\n READ_ONLY_ELEMENT: 404,\n WRITE_ONLY_ELEMENT: 405,\n TYPE_MISMATCH: 406,\n VALUE_OUT_OF_RANGE: 407,\n DEPENDENCY_NOT_ESTABLISHED: 408,\n },\n};\n\nconst ErrorCodes = {\n scorm12: scorm12,\n scorm2004: scorm2004,\n};\n\nexport default ErrorCodes;\n","const ValidLanguages = {\n 'aa': 'aa', 'ab': 'ab', 'ae': 'ae', 'af': 'af', 'ak': 'ak', 'am': 'am',\n 'an': 'an', 'ar': 'ar', 'as': 'as', 'av': 'av', 'ay': 'ay', 'az': 'az',\n 'ba': 'ba', 'be': 'be', 'bg': 'bg', 'bh': 'bh', 'bi': 'bi', 'bm': 'bm',\n 'bn': 'bn', 'bo': 'bo', 'br': 'br', 'bs': 'bs', 'ca': 'ca', 'ce': 'ce',\n 'ch': 'ch', 'co': 'co', 'cr': 'cr', 'cs': 'cs', 'cu': 'cu', 'cv': 'cv',\n 'cy': 'cy', 'da': 'da', 'de': 'de', 'dv': 'dv', 'dz': 'dz', 'ee': 'ee',\n 'el': 'el', 'en': 'en', 'eo': 'eo', 'es': 'es', 'et': 'et', 'eu': 'eu',\n 'fa': 'fa', 'ff': 'ff', 'fi': 'fi', 'fj': 'fj', 'fo': 'fo', 'fr': 'fr',\n 'fy': 'fy', 'ga': 'ga', 'gd': 'gd', 'gl': 'gl', 'gn': 'gn', 'gu': 'gu',\n 'gv': 'gv', 'ha': 'ha', 'he': 'he', 'hi': 'hi', 'ho': 'ho', 'hr': 'hr',\n 'ht': 'ht', 'hu': 'hu', 'hy': 'hy', 'hz': 'hz', 'ia': 'ia', 'id': 'id',\n 'ie': 'ie', 'ig': 'ig', 'ii': 'ii', 'ik': 'ik', 'io': 'io', 'is': 'is',\n 'it': 'it', 'iu': 'iu', 'ja': 'ja', 'jv': 'jv', 'ka': 'ka', 'kg': 'kg',\n 'ki': 'ki', 'kj': 'kj', 'kk': 'kk', 'kl': 'kl', 'km': 'km', 'kn': 'kn',\n 'ko': 'ko', 'kr': 'kr', 'ks': 'ks', 'ku': 'ku', 'kv': 'kv', 'kw': 'kw',\n 'ky': 'ky', 'la': 'la', 'lb': 'lb', 'lg': 'lg', 'li': 'li', 'ln': 'ln',\n 'lo': 'lo', 'lt': 'lt', 'lu': 'lu', 'lv': 'lv', 'mg': 'mg', 'mh': 'mh',\n 'mi': 'mi', 'mk': 'mk', 'ml': 'ml', 'mn': 'mn', 'mo': 'mo', 'mr': 'mr',\n 'ms': 'ms', 'mt': 'mt', 'my': 'my', 'na': 'na', 'nb': 'nb', 'nd': 'nd',\n 'ne': 'ne', 'ng': 'ng', 'nl': 'nl', 'nn': 'nn', 'no': 'no', 'nr': 'nr',\n 'nv': 'nv', 'ny': 'ny', 'oc': 'oc', 'oj': 'oj', 'om': 'om', 'or': 'or',\n 'os': 'os', 'pa': 'pa', 'pi': 'pi', 'pl': 'pl', 'ps': 'ps', 'pt': 'pt',\n 'qu': 'qu', 'rm': 'rm', 'rn': 'rn', 'ro': 'ro', 'ru': 'ru', 'rw': 'rw',\n 'sa': 'sa', 'sc': 'sc', 'sd': 'sd', 'se': 'se', 'sg': 'sg', 'sh': 'sh',\n 'si': 'si', 'sk': 'sk', 'sl': 'sl', 'sm': 'sm', 'sn': 'sn', 'so': 'so',\n 'sq': 'sq', 'sr': 'sr', 'ss': 'ss', 'st': 'st', 'su': 'su', 'sv': 'sv',\n 'sw': 'sw', 'ta': 'ta', 'te': 'te', 'tg': 'tg', 'th': 'th', 'ti': 'ti',\n 'tk': 'tk', 'tl': 'tl', 'tn': 'tn', 'to': 'to', 'tr': 'tr', 'ts': 'ts',\n 'tt': 'tt', 'tw': 'tw', 'ty': 'ty', 'ug': 'ug', 'uk': 'uk', 'ur': 'ur',\n 'uz': 'uz', 've': 've', 'vi': 'vi', 'vo': 'vo', 'wa': 'wa', 'wo': 'wo',\n 'xh': 'xh', 'yi': 'yi', 'yo': 'yo', 'za': 'za', 'zh': 'zh', 'zu': 'zu',\n 'aar': 'aar', 'abk': 'abk', 'ave': 'ave', 'afr': 'afr', 'aka': 'aka',\n 'amh': 'amh', 'arg': 'arg', 'ara': 'ara', 'asm': 'asm', 'ava': 'ava',\n 'aym': 'aym', 'aze': 'aze', 'bak': 'bak', 'bel': 'bel', 'bul': 'bul',\n 'bih': 'bih', 'bis': 'bis', 'bam': 'bam', 'ben': 'ben', 'tib': 'tib',\n 'bod': 'bod', 'bre': 'bre', 'bos': 'bos', 'cat': 'cat', 'che': 'che',\n 'cha': 'cha', 'cos': 'cos', 'cre': 'cre', 'cze': 'cze', 'ces': 'ces',\n 'chu': 'chu', 'chv': 'chv', 'wel': 'wel', 'cym': 'cym', 'dan': 'dan',\n 'ger': 'ger', 'deu': 'deu', 'div': 'div', 'dzo': 'dzo', 'ewe': 'ewe',\n 'gre': 'gre', 'ell': 'ell', 'eng': 'eng', 'epo': 'epo', 'spa': 'spa',\n 'est': 'est', 'baq': 'baq', 'eus': 'eus', 'per': 'per', 'fas': 'fas',\n 'ful': 'ful', 'fin': 'fin', 'fij': 'fij', 'fao': 'fao', 'fre': 'fre',\n 'fra': 'fra', 'fry': 'fry', 'gle': 'gle', 'gla': 'gla', 'glg': 'glg',\n 'grn': 'grn', 'guj': 'guj', 'glv': 'glv', 'hau': 'hau', 'heb': 'heb',\n 'hin': 'hin', 'hmo': 'hmo', 'hrv': 'hrv', 'hat': 'hat', 'hun': 'hun',\n 'arm': 'arm', 'hye': 'hye', 'her': 'her', 'ina': 'ina', 'ind': 'ind',\n 'ile': 'ile', 'ibo': 'ibo', 'iii': 'iii', 'ipk': 'ipk', 'ido': 'ido',\n 'ice': 'ice', 'isl': 'isl', 'ita': 'ita', 'iku': 'iku', 'jpn': 'jpn',\n 'jav': 'jav', 'geo': 'geo', 'kat': 'kat', 'kon': 'kon', 'kik': 'kik',\n 'kua': 'kua', 'kaz': 'kaz', 'kal': 'kal', 'khm': 'khm', 'kan': 'kan',\n 'kor': 'kor', 'kau': 'kau', 'kas': 'kas', 'kur': 'kur', 'kom': 'kom',\n 'cor': 'cor', 'kir': 'kir', 'lat': 'lat', 'ltz': 'ltz', 'lug': 'lug',\n 'lim': 'lim', 'lin': 'lin', 'lao': 'lao', 'lit': 'lit', 'lub': 'lub',\n 'lav': 'lav', 'mlg': 'mlg', 'mah': 'mah', 'mao': 'mao', 'mri': 'mri',\n 'mac': 'mac', 'mkd': 'mkd', 'mal': 'mal', 'mon': 'mon', 'mol': 'mol',\n 'mar': 'mar', 'may': 'may', 'msa': 'msa', 'mlt': 'mlt', 'bur': 'bur',\n 'mya': 'mya', 'nau': 'nau', 'nob': 'nob', 'nde': 'nde', 'nep': 'nep',\n 'ndo': 'ndo', 'dut': 'dut', 'nld': 'nld', 'nno': 'nno', 'nor': 'nor',\n 'nbl': 'nbl', 'nav': 'nav', 'nya': 'nya', 'oci': 'oci', 'oji': 'oji',\n 'orm': 'orm', 'ori': 'ori', 'oss': 'oss', 'pan': 'pan', 'pli': 'pli',\n 'pol': 'pol', 'pus': 'pus', 'por': 'por', 'que': 'que', 'roh': 'roh',\n 'run': 'run', 'rum': 'rum', 'ron': 'ron', 'rus': 'rus', 'kin': 'kin',\n 'san': 'san', 'srd': 'srd', 'snd': 'snd', 'sme': 'sme', 'sag': 'sag',\n 'slo': 'slo', 'sin': 'sin', 'slk': 'slk', 'slv': 'slv', 'smo': 'smo',\n 'sna': 'sna', 'som': 'som', 'alb': 'alb', 'sqi': 'sqi', 'srp': 'srp',\n 'ssw': 'ssw', 'sot': 'sot', 'sun': 'sun', 'swe': 'swe', 'swa': 'swa',\n 'tam': 'tam', 'tel': 'tel', 'tgk': 'tgk', 'tha': 'tha', 'tir': 'tir',\n 'tuk': 'tuk', 'tgl': 'tgl', 'tsn': 'tsn', 'ton': 'ton', 'tur': 'tur',\n 'tso': 'tso', 'tat': 'tat', 'twi': 'twi', 'tah': 'tah', 'uig': 'uig',\n 'ukr': 'ukr', 'urd': 'urd', 'uzb': 'uzb', 'ven': 'ven', 'vie': 'vie',\n 'vol': 'vol', 'wln': 'wln', 'wol': 'wol', 'xho': 'xho', 'yid': 'yid',\n 'yor': 'yor', 'zha': 'zha', 'chi': 'chi', 'zho': 'zho', 'zul': 'zul',\n};\n\nexport default ValidLanguages;\n","// @flow\n\nconst scorm12 = {\n CMIString256: '^.{0,255}$',\n CMIString4096: '^.{0,4096}$',\n CMITime: '^(?:[01]\\\\d|2[0123]):(?:[012345]\\\\d):(?:[012345]\\\\d)$', // eslint-disable-line\n CMITimespan: '^([0-9]{2,}):([0-9]{2}):([0-9]{2})(\\.[0-9]{1,2})?$', // eslint-disable-line\n CMIInteger: '^\\\\d+$',\n CMISInteger: '^-?([0-9]+)$',\n CMIDecimal: '^-?([0-9]{0,3})(\\.[0-9]*)?$', // eslint-disable-line\n CMIIdentifier: '^[\\\\u0021-\\\\u007E\\\\s]{0,255}$',\n CMIFeedback: '^.{0,255}$', // This must be redefined\n CMIIndex: '[._](\\\\d+).',\n\n // Vocabulary Data Type Definition\n CMIStatus: '^(passed|completed|failed|incomplete|browsed)$',\n CMIStatus2: '^(passed|completed|failed|incomplete|browsed|not attempted)$',\n CMIExit: '^(time-out|suspend|logout|)$',\n CMIType: '^(true-false|choice|fill-in|matching|performance|sequencing|likert|numeric)$',\n CMIResult: '^(correct|wrong|unanticipated|neutral|([0-9]{0,3})?(\\\\.[0-9]*)?)$', // eslint-disable-line\n NAVEvent: '^(previous|continue)$',\n\n // Data ranges\n score_range: '0#100',\n audio_range: '-1#100',\n speed_range: '-100#100',\n weighting_range: '-100#100',\n text_range: '-1#1',\n};\n\nconst aicc = {\n ...scorm12, ...{\n CMIIdentifier: '^\\\\w{1,255}$',\n },\n};\n\nconst scorm2004 = {\n CMIString200: '^[\\\\u0000-\\\\uFFFF]{0,200}$',\n CMIString250: '^[\\\\u0000-\\\\uFFFF]{0,250}$',\n CMIString1000: '^[\\\\u0000-\\\\uFFFF]{0,1000}$',\n CMIString4000: '^[\\\\u0000-\\\\uFFFF]{0,4000}$',\n CMIString64000: '^[\\\\u0000-\\\\uFFFF]{0,64000}$',\n CMILang: '^([a-zA-Z]{2,3}|i|x)(\\-[a-zA-Z0-9\\-]{2,8})?$|^$', // eslint-disable-line\n CMILangString250: '^(\\{lang=([a-zA-Z]{2,3}|i|x)(\\-[a-zA-Z0-9\\-]{2,8})?\\})?((?!\\{.*$).{0,250}$)?$', // eslint-disable-line\n CMILangcr: '^((\\{lang=([a-zA-Z]{2,3}|i|x)?(\\-[a-zA-Z0-9\\-]{2,8})?\\}))(.*?)$', // eslint-disable-line\n CMILangString250cr: '^((\\{lang=([a-zA-Z]{2,3}|i|x)?(\\-[a-zA-Z0-9\\-]{2,8})?\\})?(.{0,250})?)?$', // eslint-disable-line\n CMILangString4000: '^(\\{lang=([a-zA-Z]{2,3}|i|x)(\\-[a-zA-Z0-9\\-]{2,8})?\\})?((?!\\{.*$).{0,4000}$)?$', // eslint-disable-line\n CMITime: '^(19[7-9]{1}[0-9]{1}|20[0-2]{1}[0-9]{1}|203[0-8]{1})((-(0[1-9]{1}|1[0-2]{1}))((-(0[1-9]{1}|[1-2]{1}[0-9]{1}|3[0-1]{1}))(T([0-1]{1}[0-9]{1}|2[0-3]{1})((:[0-5]{1}[0-9]{1})((:[0-5]{1}[0-9]{1})((\\\\.[0-9]{1,2})((Z|([+|-]([0-1]{1}[0-9]{1}|2[0-3]{1})))(:[0-5]{1}[0-9]{1})?)?)?)?)?)?)?)?$',\n CMITimespan: '^P(?:([.,\\\\d]+)Y)?(?:([.,\\\\d]+)M)?(?:([.,\\\\d]+)W)?(?:([.,\\\\d]+)D)?(?:T?(?:([.,\\\\d]+)H)?(?:([.,\\\\d]+)M)?(?:([.,\\\\d]+)S)?)?$',\n CMIInteger: '^\\\\d+$',\n CMISInteger: '^-?([0-9]+)$',\n CMIDecimal: '^-?([0-9]{1,5})(\\\\.[0-9]{1,18})?$',\n CMIIdentifier: '^\\\\S{1,250}[a-zA-Z0-9]$',\n CMIShortIdentifier: '^[\\\\w\\\\.\\\\-\\\\_]{1,250}$', // eslint-disable-line\n CMILongIdentifier: '^(?:(?!urn:)\\\\S{1,4000}|urn:[A-Za-z0-9-]{1,31}:\\\\S{1,4000}|.{1,4000})$', // need to re-examine this\n CMIFeedback: '^.*$', // This must be redefined\n CMIIndex: '[._](\\\\d+).',\n CMIIndexStore: '.N(\\\\d+).',\n\n // Vocabulary Data Type Definition\n CMICStatus: '^(completed|incomplete|not attempted|unknown)$',\n CMISStatus: '^(passed|failed|unknown)$',\n CMIExit: '^(time-out|suspend|logout|normal)$',\n CMIType: '^(true-false|choice|fill-in|long-fill-in|matching|performance|sequencing|likert|numeric|other)$',\n CMIResult: '^(correct|incorrect|unanticipated|neutral|-?([0-9]{1,4})(\\\\.[0-9]{1,18})?)$',\n NAVEvent: '^(previous|continue|exit|exitAll|abandon|abandonAll|suspendAll|\\{target=\\\\S{0,200}[a-zA-Z0-9]\\}choice|jump)$', // eslint-disable-line\n NAVBoolean: '^(unknown|true|false$)',\n NAVTarget: '^(previous|continue|choice.{target=\\\\S{0,200}[a-zA-Z0-9]})$',\n\n // Data ranges\n scaled_range: '-1#1',\n audio_range: '0#*',\n speed_range: '0#*',\n text_range: '-1#1',\n progress_range: '0#1',\n};\n\nconst Regex = {\n aicc: aicc,\n scorm12: scorm12,\n scorm2004: scorm2004,\n};\n\nexport default Regex;\n","// @flow\nimport Regex from './regex';\n\nconst scorm2004_regex = Regex.scorm2004;\n\nconst learner = {\n 'true-false': {\n format: '^true$|^false$',\n max: 1,\n delimiter: '',\n unique: false,\n },\n 'choice': {\n format: scorm2004_regex.CMIShortIdentifier,\n max: 36,\n delimiter: '[,]',\n unique: true,\n },\n 'fill-in': {\n format: scorm2004_regex.CMILangString250,\n max: 10,\n delimiter: '[,]',\n unique: false,\n },\n 'long-fill-in': {\n format: scorm2004_regex.CMILangString4000,\n max: 1,\n delimiter: '',\n unique: false,\n },\n 'matching': {\n format: scorm2004_regex.CMIShortIdentifier,\n format2: scorm2004_regex.CMIShortIdentifier,\n max: 36,\n delimiter: '[,]',\n delimiter2: '[.]',\n unique: false,\n },\n 'performance': {\n format: '^$|' + scorm2004_regex.CMIShortIdentifier,\n format2: scorm2004_regex.CMIDecimal + '|^$|' +\n scorm2004_regex.CMIShortIdentifier,\n max: 250,\n delimiter: '[,]',\n delimiter2: '[.]',\n unique: false,\n },\n 'sequencing': {\n format: scorm2004_regex.CMIShortIdentifier,\n max: 36,\n delimiter: '[,]',\n unique: false,\n },\n 'likert': {\n format: scorm2004_regex.CMIShortIdentifier,\n max: 1,\n delimiter: '',\n unique: false,\n },\n 'numeric': {\n format: scorm2004_regex.CMIDecimal,\n max: 1,\n delimiter: '',\n unique: false,\n },\n 'other': {\n format: scorm2004_regex.CMIString4000,\n max: 1,\n delimiter: '',\n unique: false,\n },\n};\n\nconst correct = {\n 'true-false': {\n max: 1,\n delimiter: '',\n unique: false,\n duplicate: false,\n format: '^true$|^false$',\n limit: 1,\n },\n 'choice': {\n max: 36,\n delimiter: '[,]',\n unique: true,\n duplicate: false,\n format: scorm2004_regex.CMIShortIdentifier,\n },\n 'fill-in': {\n max: 10,\n delimiter: '[,]',\n unique: false,\n duplicate: false,\n format: scorm2004_regex.CMILangString250cr,\n },\n 'long-fill-in': {\n max: 1,\n delimiter: '',\n unique: false,\n duplicate: true,\n format: scorm2004_regex.CMILangString4000,\n },\n 'matching': {\n max: 36,\n delimiter: '[,]',\n delimiter2: '[.]',\n unique: false,\n duplicate: false,\n format: scorm2004_regex.CMIShortIdentifier,\n format2: scorm2004_regex.CMIShortIdentifier,\n },\n 'performance': {\n max: 250,\n delimiter: '[,]',\n delimiter2: '[.]',\n unique: false,\n duplicate: false,\n format: '^$|' + scorm2004_regex.CMIShortIdentifier,\n format2: scorm2004_regex.CMIDecimal + '|^$|' +\n scorm2004_regex.CMIShortIdentifier,\n },\n 'sequencing': {\n max: 36,\n delimiter: '[,]',\n unique: false,\n duplicate: false,\n format: scorm2004_regex.CMIShortIdentifier,\n },\n 'likert': {\n max: 1,\n delimiter: '',\n unique: false,\n duplicate: false,\n format: scorm2004_regex.CMIShortIdentifier,\n limit: 1,\n },\n 'numeric': {\n max: 2,\n delimiter: '[:]',\n unique: false,\n duplicate: false,\n format: scorm2004_regex.CMIDecimal,\n limit: 1,\n },\n 'other': {\n max: 1,\n delimiter: '',\n unique: false,\n duplicate: false,\n format: scorm2004_regex.CMIString4000,\n limit: 1,\n },\n};\n\nconst Responses = {\n learner: learner,\n correct: correct,\n};\n\nexport default Responses;\n","// @flow\n\nimport APIConstants from './constants/api_constants';\n\nconst scorm12_errors = APIConstants.scorm12.error_descriptions;\nconst aicc_errors = APIConstants.aicc.error_descriptions;\nconst scorm2004_errors = APIConstants.scorm2004.error_descriptions;\n\n/**\n * Base Validation Exception\n */\nexport class ValidationError extends Error {\n /**\n * Constructor to take in an error message and code\n * @param {number} errorCode\n * @param {string} errorMessage\n * @param {string} detailedMessage\n */\n constructor(errorCode: number, errorMessage: String, detailedMessage: String) {\n super(errorMessage);\n this.#errorCode = errorCode;\n this.#errorMessage = errorMessage;\n this.#detailedMessage = detailedMessage;\n }\n\n #errorCode;\n #errorMessage;\n #detailedMessage;\n\n /**\n * Getter for #errorCode\n * @return {number}\n */\n get errorCode() {\n return this.#errorCode;\n }\n\n /**\n * Getter for #errorMessage\n * @return {string}\n */\n get errorMessage() {\n return this.#errorMessage;\n }\n\n /**\n * Getter for #detailedMessage\n * @return {string}\n */\n get detailedMessage() {\n return this.#detailedMessage;\n }\n}\n\n/**\n * SCORM 1.2 Validation Error\n */\nexport class Scorm12ValidationError extends ValidationError {\n /**\n * Constructor to take in an error code\n * @param {number} errorCode\n */\n constructor(errorCode: number) {\n if ({}.hasOwnProperty.call(scorm12_errors, String(errorCode))) {\n super(errorCode, scorm12_errors[String(errorCode)].basicMessage, scorm12_errors[String(errorCode)].detailMessage);\n } else {\n super(101, scorm12_errors['101'].basicMessage, scorm12_errors['101'].detailMessage);\n }\n }\n}\n\n/**\n * AICC Validation Error\n */\nexport class AICCValidationError extends ValidationError {\n /**\n * Constructor to take in an error code\n * @param {number} errorCode\n */\n constructor(errorCode: number) {\n if ({}.hasOwnProperty.call(aicc_errors, String(errorCode))) {\n super(errorCode, aicc_errors[String(errorCode)].basicMessage, aicc_errors[String(errorCode)].detailMessage);\n } else {\n super(101, aicc_errors['101'].basicMessage, aicc_errors['101'].detailMessage);\n }\n }\n}\n\n/**\n * SCORM 2004 Validation Error\n */\nexport class Scorm2004ValidationError extends ValidationError {\n /**\n * Constructor to take in an error code\n * @param {number} errorCode\n */\n constructor(errorCode: number) {\n if ({}.hasOwnProperty.call(scorm2004_errors, String(errorCode))) {\n super(errorCode, scorm2004_errors[String(errorCode)].basicMessage, scorm2004_errors[String(errorCode)].detailMessage);\n } else {\n super(101, scorm2004_errors['101'].basicMessage, scorm2004_errors['101'].detailMessage);\n }\n }\n}\n","import Scorm2004API from './Scorm2004API';\nimport Scorm12API from './Scorm12API';\nimport AICC from './AICC';\n\nwindow.Scorm12API = Scorm12API;\nwindow.Scorm2004API = Scorm2004API;\nwindow.AICC = AICC;\n","// @flow\nexport const SECONDS_PER_SECOND = 1.0;\nexport const SECONDS_PER_MINUTE = 60;\nexport const SECONDS_PER_HOUR = 60 * SECONDS_PER_MINUTE;\nexport const SECONDS_PER_DAY = 24 * SECONDS_PER_HOUR;\n\nconst designations = [\n ['D', SECONDS_PER_DAY],\n ['H', SECONDS_PER_HOUR],\n ['M', SECONDS_PER_MINUTE],\n ['S', SECONDS_PER_SECOND],\n];\n\n/**\n * Converts a Number to a String of HH:MM:SS\n *\n * @param {Number} totalSeconds\n * @return {string}\n */\nexport function getSecondsAsHHMMSS(totalSeconds: Number) {\n // SCORM spec does not deal with negative durations, give zero back\n if (!totalSeconds || totalSeconds <= 0) {\n return '00:00:00';\n }\n\n const hours = Math.floor(totalSeconds / SECONDS_PER_HOUR);\n\n const dateObj = new Date(totalSeconds * 1000);\n const minutes = dateObj.getUTCMinutes();\n // make sure we add any possible decimal value\n const seconds = dateObj.getSeconds();\n const ms = totalSeconds % 1.0;\n let msStr = '';\n if (countDecimals(ms) > 0) {\n if (countDecimals(ms) > 2) {\n msStr = ms.toFixed(2);\n } else {\n msStr = String(ms);\n }\n msStr = '.' + msStr.split('.')[1];\n }\n\n return (hours + ':' + minutes + ':' + seconds).replace(/\\b\\d\\b/g,\n '0$&') + msStr;\n}\n\n/**\n * Calculate the number of seconds from ISO 8601 Duration\n *\n * @param {Number} seconds\n * @return {String}\n */\nexport function getSecondsAsISODuration(seconds: Number) {\n // SCORM spec does not deal with negative durations, give zero back\n if (!seconds || seconds <= 0) {\n return 'PT0S';\n }\n\n let duration = 'P';\n let remainder = seconds;\n\n designations.forEach(([sign, current_seconds]) => {\n let value = Math.floor(remainder / current_seconds);\n\n remainder = remainder % current_seconds;\n if (countDecimals(remainder) > 2) {\n remainder = Number(Number(remainder).toFixed(2));\n }\n // If we have anything left in the remainder, and we're currently adding\n // seconds to the duration, go ahead and add the decimal to the seconds\n if (sign === 'S' && remainder > 0) {\n value += remainder;\n }\n\n if (value) {\n if ((duration.indexOf('D') > 0 ||\n sign === 'H' || sign === 'M' || sign === 'S') &&\n duration.indexOf('T') === -1) {\n duration += 'T';\n }\n duration += `${value}${sign}`;\n }\n });\n\n return duration;\n}\n\n/**\n * Calculate the number of seconds from HH:MM:SS.DDDDDD\n *\n * @param {string} timeString\n * @param {RegExp} timeRegex\n * @return {number}\n */\nexport function getTimeAsSeconds(timeString: String, timeRegex: RegExp) {\n if (!timeString || typeof timeString !== 'string' ||\n !timeString.match(timeRegex)) {\n return 0;\n }\n const parts = timeString.split(':');\n const hours = Number(parts[0]);\n const minutes = Number(parts[1]);\n const seconds = Number(parts[2]);\n return (hours * 3600) + (minutes * 60) + seconds;\n}\n\n/**\n * Calculate the number of seconds from ISO 8601 Duration\n *\n * @param {string} duration\n * @param {RegExp} durationRegex\n * @return {number}\n */\nexport function getDurationAsSeconds(duration: String, durationRegex: RegExp) {\n if (!duration || !duration.match(durationRegex)) {\n return 0;\n }\n\n const [, years, months, , days, hours, minutes, seconds] = new RegExp(\n durationRegex).exec(duration) || [];\n\n let result = 0.0;\n\n result += (Number(seconds) * 1.0 || 0.0);\n result += (Number(minutes) * 60.0 || 0.0);\n result += (Number(hours) * 3600.0 || 0.0);\n result += (Number(days) * (60 * 60 * 24.0) || 0.0);\n result += (Number(years) * (60 * 60 * 24 * 365.0) || 0.0);\n\n return result;\n}\n\n/**\n * Adds together two ISO8601 Duration strings\n *\n * @param {string} first\n * @param {string} second\n * @param {RegExp} durationRegex\n * @return {string}\n */\nexport function addTwoDurations(\n first: String,\n second: String,\n durationRegex: RegExp) {\n return getSecondsAsISODuration(\n getDurationAsSeconds(first, durationRegex) +\n getDurationAsSeconds(second, durationRegex),\n );\n}\n\n/**\n * Add together two HH:MM:SS.DD strings\n *\n * @param {string} first\n * @param {string} second\n * @param {RegExp} timeRegex\n * @return {string}\n */\nexport function addHHMMSSTimeStrings(\n first: String,\n second: String,\n timeRegex: RegExp) {\n return getSecondsAsHHMMSS(\n getTimeAsSeconds(first, timeRegex) +\n getTimeAsSeconds(\n second, timeRegex),\n );\n}\n\n/**\n * Flatten a JSON object down to string paths for each values\n * @param {object} data\n * @return {object}\n */\nexport function flatten(data) {\n const result = {};\n\n /**\n * Recurse through the object\n * @param {*} cur\n * @param {*} prop\n */\n function recurse(cur, prop) {\n if (Object(cur) !== cur) {\n result[prop] = cur;\n } else if (Array.isArray(cur)) {\n for (let i = 0, l = cur.length; i < l; i++) {\n recurse(cur[i], prop + '[' + i + ']');\n if (l === 0) result[prop] = [];\n }\n } else {\n let isEmpty = true;\n for (const p in cur) {\n if ({}.hasOwnProperty.call(cur, p)) {\n isEmpty = false;\n recurse(cur[p], prop ? prop + '.' + p : p);\n }\n }\n if (isEmpty && prop) result[prop] = {};\n }\n }\n\n recurse(data, '');\n return result;\n}\n\n/**\n * Un-flatten a flat JSON object\n * @param {object} data\n * @return {object}\n */\nexport function unflatten(data) {\n 'use strict';\n if (Object(data) !== data || Array.isArray(data)) return data;\n const regex = /\\.?([^.[\\]]+)|\\[(\\d+)]/g;\n const result = {};\n for (const p in data) {\n if ({}.hasOwnProperty.call(data, p)) {\n let cur = result;\n let prop = '';\n let m = regex.exec(p);\n while (m) {\n cur = cur[prop] || (cur[prop] = (m[2] ? [] : {}));\n prop = m[2] || m[1];\n m = regex.exec(p);\n }\n cur[prop] = data[p];\n }\n }\n return result[''] || result;\n}\n\n/**\n * Counts the number of decimal places\n * @param {number} num\n * @return {number}\n */\nexport function countDecimals(num: number) {\n if (Math.floor(num) === num || String(num).indexOf('.') < 0) return 0;\n const parts = num.toString().split('.')[1];\n return parts.length || 0;\n}\n"]} \ No newline at end of file diff --git a/dist/scorm-again.min.js b/dist/scorm-again.min.js index fb8fbfa..106ff5a 100644 --- a/dist/scorm-again.min.js +++ b/dist/scorm-again.min.js @@ -1,41 +1,10873 @@ (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i=t||r<0||T&&o>=m}function a(){var e=now();if(u(e))return f(e);y=setTimeout(a,i(e))}function f(e){return y=void 0,g&&s?o(e):(s=v=void 0,j)}function c(){void 0!==y&&clearTimeout(y),O=0,s=p=v=y=void 0}function l(){return void 0===y?j:f(now())}function b(){var e=now(),r=u(e);if(s=arguments,v=this,p=e,r){if(void 0===y)return n(p);if(T)return y=setTimeout(a,t),o(p)}return void 0===y&&(y=setTimeout(a,t)),j}var s,v,m,j,y,p,O=0,d=!1,T=!1,g=!0;if("function"!=typeof e)throw new TypeError(FUNC_ERROR_TEXT);return t=toNumber(t)||0,isObject(r)&&(d=!!r.leading,T="maxWait"in r,m=T?nativeMax(toNumber(r.maxWait)||0,t):m,g="trailing"in r?!!r.trailing:g),b.cancel=c,b.flush=l,b}function isObject(e){var t=typeof e;return!!e&&("object"==t||"function"==t)}function isObjectLike(e){return!!e&&"object"==typeof e}function isSymbol(e){return"symbol"==typeof e||isObjectLike(e)&&objectToString.call(e)==symbolTag}function toNumber(e){if("number"==typeof e)return e;if(isSymbol(e))return NAN;if(isObject(e)){var t="function"==typeof e.valueOf?e.valueOf():e;e=isObject(t)?t+"":t}if("string"!=typeof e)return 0===e?e:+e;e=e.replace(reTrim,"");var r=reIsBinary.test(e);return r||reIsOctal.test(e)?freeParseInt(e.slice(2),r?2:8):reIsBadHex.test(e)?NAN:+e}var FUNC_ERROR_TEXT="Expected a function",NAN=NaN,symbolTag="[object Symbol]",reTrim=/^\s+|\s+$/g,reIsBadHex=/^[-+]0x[0-9a-f]+$/i,reIsBinary=/^0b[01]+$/i,reIsOctal=/^0o[0-7]+$/i,freeParseInt=parseInt,freeGlobal="object"==typeof global&&global&&global.Object===Object&&global,freeSelf="object"==typeof self&&self&&self.Object===Object&&self,root=freeGlobal||freeSelf||Function("return this")(),objectProto=Object.prototype,objectToString=objectProto.toString,nativeMax=Math.max,nativeMin=Math.min,now=function(){return root.Date.now()};module.exports=debounce; +/** + * lodash (Custom Build) + * Build: `lodash modularize exports="npm" -o ./` + * Copyright jQuery Foundation and other contributors + * Released under MIT license + * Based on Underscore.js 1.8.3 + * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + */ + +/** Used as the `TypeError` message for "Functions" methods. */ +var FUNC_ERROR_TEXT = 'Expected a function'; + +/** Used as references for various `Number` constants. */ +var NAN = 0 / 0; + +/** `Object#toString` result references. */ +var symbolTag = '[object Symbol]'; + +/** Used to match leading and trailing whitespace. */ +var reTrim = /^\s+|\s+$/g; + +/** Used to detect bad signed hexadecimal string values. */ +var reIsBadHex = /^[-+]0x[0-9a-f]+$/i; + +/** Used to detect binary string values. */ +var reIsBinary = /^0b[01]+$/i; + +/** Used to detect octal string values. */ +var reIsOctal = /^0o[0-7]+$/i; + +/** Built-in method references without a dependency on `root`. */ +var freeParseInt = parseInt; + +/** Detect free variable `global` from Node.js. */ +var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; + +/** Detect free variable `self`. */ +var freeSelf = typeof self == 'object' && self && self.Object === Object && self; + +/** Used as a reference to the global object. */ +var root = freeGlobal || freeSelf || Function('return this')(); + +/** Used for built-in method references. */ +var objectProto = Object.prototype; + +/** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ +var objectToString = objectProto.toString; + +/* Built-in method references for those with the same name as other `lodash` methods. */ +var nativeMax = Math.max, + nativeMin = Math.min; + +/** + * Gets the timestamp of the number of milliseconds that have elapsed since + * the Unix epoch (1 January 1970 00:00:00 UTC). + * + * @static + * @memberOf _ + * @since 2.4.0 + * @category Date + * @returns {number} Returns the timestamp. + * @example + * + * _.defer(function(stamp) { + * console.log(_.now() - stamp); + * }, _.now()); + * // => Logs the number of milliseconds it took for the deferred invocation. + */ +var now = function() { + return root.Date.now(); +}; + +/** + * Creates a debounced function that delays invoking `func` until after `wait` + * milliseconds have elapsed since the last time the debounced function was + * invoked. The debounced function comes with a `cancel` method to cancel + * delayed `func` invocations and a `flush` method to immediately invoke them. + * Provide `options` to indicate whether `func` should be invoked on the + * leading and/or trailing edge of the `wait` timeout. The `func` is invoked + * with the last arguments provided to the debounced function. Subsequent + * calls to the debounced function return the result of the last `func` + * invocation. + * + * **Note:** If `leading` and `trailing` options are `true`, `func` is + * invoked on the trailing edge of the timeout only if the debounced function + * is invoked more than once during the `wait` timeout. + * + * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred + * until to the next tick, similar to `setTimeout` with a timeout of `0`. + * + * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) + * for details over the differences between `_.debounce` and `_.throttle`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to debounce. + * @param {number} [wait=0] The number of milliseconds to delay. + * @param {Object} [options={}] The options object. + * @param {boolean} [options.leading=false] + * Specify invoking on the leading edge of the timeout. + * @param {number} [options.maxWait] + * The maximum time `func` is allowed to be delayed before it's invoked. + * @param {boolean} [options.trailing=true] + * Specify invoking on the trailing edge of the timeout. + * @returns {Function} Returns the new debounced function. + * @example + * + * // Avoid costly calculations while the window size is in flux. + * jQuery(window).on('resize', _.debounce(calculateLayout, 150)); + * + * // Invoke `sendMail` when clicked, debouncing subsequent calls. + * jQuery(element).on('click', _.debounce(sendMail, 300, { + * 'leading': true, + * 'trailing': false + * })); + * + * // Ensure `batchLog` is invoked once after 1 second of debounced calls. + * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 }); + * var source = new EventSource('/stream'); + * jQuery(source).on('message', debounced); + * + * // Cancel the trailing debounced invocation. + * jQuery(window).on('popstate', debounced.cancel); + */ +function debounce(func, wait, options) { + var lastArgs, + lastThis, + maxWait, + result, + timerId, + lastCallTime, + lastInvokeTime = 0, + leading = false, + maxing = false, + trailing = true; + + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + wait = toNumber(wait) || 0; + if (isObject(options)) { + leading = !!options.leading; + maxing = 'maxWait' in options; + maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait; + trailing = 'trailing' in options ? !!options.trailing : trailing; + } + + function invokeFunc(time) { + var args = lastArgs, + thisArg = lastThis; + + lastArgs = lastThis = undefined; + lastInvokeTime = time; + result = func.apply(thisArg, args); + return result; + } + + function leadingEdge(time) { + // Reset any `maxWait` timer. + lastInvokeTime = time; + // Start the timer for the trailing edge. + timerId = setTimeout(timerExpired, wait); + // Invoke the leading edge. + return leading ? invokeFunc(time) : result; + } + + function remainingWait(time) { + var timeSinceLastCall = time - lastCallTime, + timeSinceLastInvoke = time - lastInvokeTime, + result = wait - timeSinceLastCall; + + return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result; + } + + function shouldInvoke(time) { + var timeSinceLastCall = time - lastCallTime, + timeSinceLastInvoke = time - lastInvokeTime; + + // Either this is the first call, activity has stopped and we're at the + // trailing edge, the system time has gone backwards and we're treating + // it as the trailing edge, or we've hit the `maxWait` limit. + return (lastCallTime === undefined || (timeSinceLastCall >= wait) || + (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait)); + } + + function timerExpired() { + var time = now(); + if (shouldInvoke(time)) { + return trailingEdge(time); + } + // Restart the timer. + timerId = setTimeout(timerExpired, remainingWait(time)); + } + + function trailingEdge(time) { + timerId = undefined; + + // Only invoke if we have `lastArgs` which means `func` has been + // debounced at least once. + if (trailing && lastArgs) { + return invokeFunc(time); + } + lastArgs = lastThis = undefined; + return result; + } + + function cancel() { + if (timerId !== undefined) { + clearTimeout(timerId); + } + lastInvokeTime = 0; + lastArgs = lastCallTime = lastThis = timerId = undefined; + } + + function flush() { + return timerId === undefined ? result : trailingEdge(now()); + } + + function debounced() { + var time = now(), + isInvoking = shouldInvoke(time); + + lastArgs = arguments; + lastThis = this; + lastCallTime = time; + + if (isInvoking) { + if (timerId === undefined) { + return leadingEdge(lastCallTime); + } + if (maxing) { + // Handle invocations in a tight loop. + timerId = setTimeout(timerExpired, wait); + return invokeFunc(lastCallTime); + } + } + if (timerId === undefined) { + timerId = setTimeout(timerExpired, wait); + } + return result; + } + debounced.cancel = cancel; + debounced.flush = flush; + return debounced; +} + +/** + * Checks if `value` is the + * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) + * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an object, else `false`. + * @example + * + * _.isObject({}); + * // => true + * + * _.isObject([1, 2, 3]); + * // => true + * + * _.isObject(_.noop); + * // => true + * + * _.isObject(null); + * // => false + */ +function isObject(value) { + var type = typeof value; + return !!value && (type == 'object' || type == 'function'); +} + +/** + * Checks if `value` is object-like. A value is object-like if it's not `null` + * and has a `typeof` result of "object". + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is object-like, else `false`. + * @example + * + * _.isObjectLike({}); + * // => true + * + * _.isObjectLike([1, 2, 3]); + * // => true + * + * _.isObjectLike(_.noop); + * // => false + * + * _.isObjectLike(null); + * // => false + */ +function isObjectLike(value) { + return !!value && typeof value == 'object'; +} + +/** + * Checks if `value` is classified as a `Symbol` primitive or object. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. + * @example + * + * _.isSymbol(Symbol.iterator); + * // => true + * + * _.isSymbol('abc'); + * // => false + */ +function isSymbol(value) { + return typeof value == 'symbol' || + (isObjectLike(value) && objectToString.call(value) == symbolTag); +} + +/** + * Converts `value` to a number. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to process. + * @returns {number} Returns the number. + * @example + * + * _.toNumber(3.2); + * // => 3.2 + * + * _.toNumber(Number.MIN_VALUE); + * // => 5e-324 + * + * _.toNumber(Infinity); + * // => Infinity + * + * _.toNumber('3.2'); + * // => 3.2 + */ +function toNumber(value) { + if (typeof value == 'number') { + return value; + } + if (isSymbol(value)) { + return NAN; + } + if (isObject(value)) { + var other = typeof value.valueOf == 'function' ? value.valueOf() : value; + value = isObject(other) ? (other + '') : other; + } + if (typeof value != 'string') { + return value === 0 ? value : +value; + } + value = value.replace(reTrim, ''); + var isBinary = reIsBinary.test(value); + return (isBinary || reIsOctal.test(value)) + ? freeParseInt(value.slice(2), isBinary ? 2 : 8) + : (reIsBadHex.test(value) ? NAN : +value); +} + +module.exports = debounce; + }).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) - },{}],2:[function(require,module,exports){ -"use strict";function _typeof(e){"@babel/helpers - typeof";return(_typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function _interopRequireDefault(e){return e&&e.__esModule?e:{default:e}}function ownKeys(e,t){var r=Object.keys(e);if(Object.getOwnPropertySymbols){var o=Object.getOwnPropertySymbols(e);t&&(o=o.filter(function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable})),r.push.apply(r,o)}return r}function _objectSpread(e){for(var t=1;te.length)&&(t=e.length);for(var r=0,s=new Array(t);r0&&this.throwSCORMError(s.errorCode),r=void 0!==s&&s.result?s.result:global_constants.SCORM_FALSE,t&&(this.lastErrorCode=0),r=global_constants.SCORM_TRUE,this.processListeners(e)}return this.apiLog(e,null,"returned: "+r,global_constants.LOG_LEVEL_INFO),this.clearSCORMError(r),r}},{key:"getValue",value:function(e,t,r){var s;if(this.checkState(t,_classPrivateFieldGet(this,_error_codes).RETRIEVE_BEFORE_INIT,_classPrivateFieldGet(this,_error_codes).RETRIEVE_AFTER_TERM)){t&&(this.lastErrorCode=0);try{s=this.getCMIValue(r)}catch(e){e instanceof _exceptions.ValidationError?(this.lastErrorCode=e.errorCode,s=global_constants.SCORM_FALSE):(e.message?console.error(e.message):console.error(e),this.throwSCORMError(_classPrivateFieldGet(this,_error_codes).GENERAL))}this.processListeners(e,r)}return this.apiLog(e,r,": returned: "+s,global_constants.LOG_LEVEL_INFO),this.clearSCORMError(s),s}},{key:"setValue",value:function(e,t,r,s,o){void 0!==o&&(o=String(o));var i=global_constants.SCORM_FALSE;if(this.checkState(r,_classPrivateFieldGet(this,_error_codes).STORE_BEFORE_INIT,_classPrivateFieldGet(this,_error_codes).STORE_AFTER_TERM)){r&&(this.lastErrorCode=0);try{i=this.setCMIValue(s,o)}catch(e){e instanceof _exceptions.ValidationError?(this.lastErrorCode=e.errorCode,i=global_constants.SCORM_FALSE):(e.message?console.error(e.message):console.error(e),this.throwSCORMError(_classPrivateFieldGet(this,_error_codes).GENERAL))}this.processListeners(e,s,o)}return void 0===i&&(i=global_constants.SCORM_FALSE),"0"===String(this.lastErrorCode)&&this.settings.autocommit&&!_classPrivateFieldGet(this,_timeout)&&this.scheduleCommit(1e3*this.settings.autocommitSeconds,t),this.apiLog(e,s,": "+o+": result: "+i,global_constants.LOG_LEVEL_INFO),this.clearSCORMError(i),i}},{key:"commit",value:function(e,t){this.clearScheduledCommit();var r=global_constants.SCORM_FALSE;if(this.checkState(t,_classPrivateFieldGet(this,_error_codes).COMMIT_BEFORE_INIT,_classPrivateFieldGet(this,_error_codes).COMMIT_AFTER_TERM)){var s=this.storeData(!1);!this.settings.sendBeaconCommit&&!this.settings.asyncCommit&&s.errorCode&&s.errorCode>0&&this.throwSCORMError(s.errorCode),r=void 0!==s&&s.result?s.result:global_constants.SCORM_FALSE,this.apiLog(e,"HttpRequest"," Result: "+r,global_constants.LOG_LEVEL_DEBUG),t&&(this.lastErrorCode=0),this.processListeners(e)}return this.apiLog(e,null,"returned: "+r,global_constants.LOG_LEVEL_INFO),this.clearSCORMError(r),r}},{key:"getLastError",value:function(e){var t=String(this.lastErrorCode);return this.processListeners(e),this.apiLog(e,null,"returned: "+t,global_constants.LOG_LEVEL_INFO),t}},{key:"getErrorString",value:function(e,t){var r="";return null!==t&&""!==t&&(r=this.getLmsErrorMessageDetails(t),this.processListeners(e)),this.apiLog(e,null,"returned: "+r,global_constants.LOG_LEVEL_INFO),r}},{key:"getDiagnostic",value:function(e,t){var r="";return null!==t&&""!==t&&(r=this.getLmsErrorMessageDetails(t,!0),this.processListeners(e)),this.apiLog(e,null,"returned: "+r,global_constants.LOG_LEVEL_INFO),r}},{key:"checkState",value:function(e,t,r){return this.isNotInitialized()?(this.throwSCORMError(t),!1):!e||!this.isTerminated()||(this.throwSCORMError(r),!1)}},{key:"apiLog",value:function(e,t,r,s){if(r=this.formatMessage(e,t,r),s>=this.apiLogLevel)switch(s){case global_constants.LOG_LEVEL_ERROR:console.error(r);break;case global_constants.LOG_LEVEL_WARNING:console.warn(r);break;case global_constants.LOG_LEVEL_INFO:console.info(r);break;case global_constants.LOG_LEVEL_DEBUG:console.debug?console.debug(r):console.log(r)}}},{key:"formatMessage",value:function(e,t,r){var s="";s+=e;for(var o=20-s.length,i=0;i1&&(n=e.replace(i+".","")),this.listenerArray.push({functionName:i,CMIElement:n,callback:t}),this.apiLog("on",i,"Added event listener: ".concat(this.listenerArray.length),global_constants.LOG_LEVEL_INFO)}}},{key:"off",value:function(e,t){var r=this;if(t)for(var s=e.split(" "),o=0;o1&&(a=e.replace(n+".",""));var l=r.listenerArray.findIndex(function(e){return e.functionName===n&&e.CMIElement===a&&e.callback===t});-1!==l&&(r.listenerArray.splice(l,1),r.apiLog("off",n,"Removed event listener: ".concat(r.listenerArray.length),global_constants.LOG_LEVEL_INFO))}(o);if("object"===_typeof(i))return i.v}}},{key:"clear",value:function(e){for(var t=this,r=e.split(" "),s=0;s1&&(n=e.replace(i+".","")),t.listenerArray=t.listenerArray.filter(function(e){return e.functionName!==i&&e.CMIElement!==n})}(s);if("object"===_typeof(o))return o.v}}},{key:"processListeners",value:function(e,t,r){this.apiLog(e,t,r);for(var s=0;sc?1:0});var a;n.forEach(function(e){a={},a[e[0]]=e[1],s.loadFromJSON((0,_utilities.unflatten)(a),t)})}},{key:"loadFromJSON",value:function(e,t){if(!this.isNotInitialized())return void console.error("loadFromJSON can only be called before the call to lmsInitialize.");t=void 0!==t?t:"cmi",this.startingData=e;for(var r in e)if({}.hasOwnProperty.call(e,r)&&e[r]){var s=(t?t+".":"")+r,o=e[r];if(o.childArray)for(var i=0;i2&&void 0!==arguments[2]&&arguments[2],s=this,o=function(e,t,r,o){var i,n={result:global_constants.SCORM_FALSE,errorCode:o.GENERAL};if(r.sendBeaconCommit)try{var a,l={type:r.commitRequestDataType};a=t instanceof Array?new Blob([t.join("&")],l):new Blob([JSON.stringify(t)],l),i={},navigator.sendBeacon(e,a)?(i.result=global_constants.SCORM_TRUE,i.errorCode=0):(i.result=global_constants.SCORM_FALSE,i.errorCode=101)}catch(e){return console.error(e),s.processListeners("CommitError"),n}else{var c=new XMLHttpRequest;c.open("POST",e,r.asyncCommit),r.asyncCommit&&(c.onload=function(e){i="function"==typeof r.responseHandler?r.responseHandler(c):JSON.parse(c.responseText)});try{if(t instanceof Array?(c.setRequestHeader("Content-Type","application/x-www-form-urlencoded"),c.send(t.join("&"))):(c.setRequestHeader("Content-Type",r.commitRequestDataType),c.send(JSON.stringify(t))),r.asyncCommit)return i={},i.result=global_constants.SCORM_TRUE,i.errorCode=0,s.processListeners("CommitSuccess"),i;i="function"==typeof r.responseHandler?r.responseHandler(c):JSON.parse(c.responseText)}catch(e){return console.error(e),s.processListeners("CommitError"),n}}return void 0===i?(s.processListeners("CommitError"),n):(!0===i.result||i.result===global_constants.SCORM_TRUE?s.processListeners("CommitSuccess"):s.processListeners("CommitError"),i)};if(void 0!==_lodash.default){var i=(0,_lodash.default)(o,500);return i(e,t,this.settings,this.error_codes),r&&i.flush(),{result:global_constants.SCORM_TRUE,errorCode:0}}return o(e,t,this.settings,this.error_codes)}},{key:"scheduleCommit",value:function(e,t){_classPrivateFieldSet(this,_timeout,new ScheduledCommit(this,e,t)),this.apiLog("scheduleCommit","","scheduled",global_constants.LOG_LEVEL_DEBUG)}},{key:"clearScheduledCommit",value:function(){_classPrivateFieldGet(this,_timeout)&&(_classPrivateFieldGet(this,_timeout).cancel(),_classPrivateFieldSet(this,_timeout,null),this.apiLog("clearScheduledCommit","","cleared",global_constants.LOG_LEVEL_DEBUG))}}]),e}();exports.default=BaseAPI;var _API=new WeakMap,_cancelled=new WeakMap,_timeout2=new WeakMap,_callback=new WeakMap,ScheduledCommit=function(){function e(t,r,s){_classCallCheck(this,e),_API.set(this,{writable:!0,value:void 0}),_cancelled.set(this,{writable:!0,value:!1}),_timeout2.set(this,{writable:!0,value:void 0}),_callback.set(this,{writable:!0,value:void 0}),_classPrivateFieldSet(this,_API,t),_classPrivateFieldSet(this,_timeout2,setTimeout(this.wrapper.bind(this),r)),_classPrivateFieldSet(this,_callback,s)}return _createClass(e,[{key:"cancel",value:function(){_classPrivateFieldSet(this,_cancelled,!0),_classPrivateFieldGet(this,_timeout2)&&clearTimeout(_classPrivateFieldGet(this,_timeout2))}},{key:"wrapper",value:function(){_classPrivateFieldGet(this,_cancelled)||_classPrivateFieldGet(this,_API).commit(_classPrivateFieldGet(this,_callback))}}]),e}(); +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +var _common = require("./cmi/common"); + +var _exceptions = require("./exceptions"); + +var _error_codes2 = _interopRequireDefault(require("./constants/error_codes")); + +var _api_constants = _interopRequireDefault(require("./constants/api_constants")); + +var _utilities = require("./utilities"); + +var _lodash = _interopRequireDefault(require("lodash.debounce")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); } + +function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } + +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit(arr, i) { var _i = arr && (typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]); if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); } + +function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; } + +function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); } + +function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } } + +var global_constants = _api_constants["default"].global; +var scorm12_error_codes = _error_codes2["default"].scorm12; +/** + * Base API class for AICC, SCORM 1.2, and SCORM 2004. Should be considered + * abstract, and never initialized on it's own. + */ + +var _timeout = new WeakMap(); + +var _error_codes = new WeakMap(); + +var _settings = new WeakMap(); + +var BaseAPI = /*#__PURE__*/function () { + /** + * Constructor for Base API class. Sets some shared API fields, as well as + * sets up options for the API. + * @param {object} error_codes + * @param {object} settings + */ + function BaseAPI(error_codes, settings) { + _classCallCheck(this, BaseAPI); + + _timeout.set(this, { + writable: true, + value: void 0 + }); + + _error_codes.set(this, { + writable: true, + value: void 0 + }); + + _settings.set(this, { + writable: true, + value: { + autocommit: false, + autocommitSeconds: 10, + asyncCommit: false, + sendBeaconCommit: false, + lmsCommitUrl: false, + dataCommitFormat: 'json', + // valid formats are 'json' or 'flattened', 'params' + commitRequestDataType: 'application/json;charset=UTF-8', + autoProgress: false, + logLevel: global_constants.LOG_LEVEL_ERROR, + selfReportSessionTime: false, + alwaysSendTotalTime: false, + strict_errors: true, + responseHandler: function responseHandler(xhr) { + var result; + + if (typeof xhr !== 'undefined') { + result = JSON.parse(xhr.responseText); + + if (result === null || !{}.hasOwnProperty.call(result, 'result')) { + result = {}; + + if (xhr.status === 200) { + result.result = global_constants.SCORM_TRUE; + result.errorCode = 0; + } else { + result.result = global_constants.SCORM_FALSE; + result.errorCode = 101; + } + } + } + + return result; + } + } + }); + + _defineProperty(this, "cmi", void 0); + + _defineProperty(this, "startingData", void 0); + + if ((this instanceof BaseAPI ? this.constructor : void 0) === BaseAPI) { + throw new TypeError('Cannot construct BaseAPI instances directly'); + } + + this.currentState = global_constants.STATE_NOT_INITIALIZED; + this.lastErrorCode = 0; + this.listenerArray = []; + + _classPrivateFieldSet(this, _timeout, null); + + _classPrivateFieldSet(this, _error_codes, error_codes); + + this.settings = settings; + this.apiLogLevel = this.settings.logLevel; + this.selfReportSessionTime = this.settings.selfReportSessionTime; + } + /** + * Initialize the API + * @param {string} callbackName + * @param {string} initializeMessage + * @param {string} terminationMessage + * @return {string} + */ + + + _createClass(BaseAPI, [{ + key: "initialize", + value: function initialize(callbackName, initializeMessage, terminationMessage) { + var returnValue = global_constants.SCORM_FALSE; + + if (this.isInitialized()) { + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).INITIALIZED, initializeMessage); + } else if (this.isTerminated()) { + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).TERMINATED, terminationMessage); + } else { + if (this.selfReportSessionTime) { + this.cmi.setStartTime(); + } + + this.currentState = global_constants.STATE_INITIALIZED; + this.lastErrorCode = 0; + returnValue = global_constants.SCORM_TRUE; + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Getter for #error_codes + * @return {object} + */ + + }, { + key: "error_codes", + get: function get() { + return _classPrivateFieldGet(this, _error_codes); + } + /** + * Getter for #settings + * @return {object} + */ + + }, { + key: "settings", + get: function get() { + return _classPrivateFieldGet(this, _settings); + } + /** + * Setter for #settings + * @param {object} settings + */ + , + set: function set(settings) { + _classPrivateFieldSet(this, _settings, _objectSpread(_objectSpread({}, _classPrivateFieldGet(this, _settings)), settings)); + } + /** + * Terminates the current run of the API + * @param {string} callbackName + * @param {boolean} checkTerminated + * @return {string} + */ + + }, { + key: "terminate", + value: function terminate(callbackName, checkTerminated) { + var returnValue = global_constants.SCORM_FALSE; + + if (this.checkState(checkTerminated, _classPrivateFieldGet(this, _error_codes).TERMINATION_BEFORE_INIT, _classPrivateFieldGet(this, _error_codes).MULTIPLE_TERMINATION)) { + this.currentState = global_constants.STATE_TERMINATED; + var result = this.storeData(true); + + if (!this.settings.sendBeaconCommit && !this.settings.asyncCommit && typeof result.errorCode !== 'undefined' && result.errorCode > 0) { + this.throwSCORMError(result.errorCode); + } + + returnValue = typeof result !== 'undefined' && result.result ? result.result : global_constants.SCORM_FALSE; + if (checkTerminated) this.lastErrorCode = 0; + returnValue = global_constants.SCORM_TRUE; + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Get the value of the CMIElement. + * + * @param {string} callbackName + * @param {boolean} checkTerminated + * @param {string} CMIElement + * @return {string} + */ + + }, { + key: "getValue", + value: function getValue(callbackName, checkTerminated, CMIElement) { + var returnValue; + + if (this.checkState(checkTerminated, _classPrivateFieldGet(this, _error_codes).RETRIEVE_BEFORE_INIT, _classPrivateFieldGet(this, _error_codes).RETRIEVE_AFTER_TERM)) { + if (checkTerminated) this.lastErrorCode = 0; + + try { + returnValue = this.getCMIValue(CMIElement); + } catch (e) { + if (e instanceof _exceptions.ValidationError) { + this.lastErrorCode = e.errorCode; + returnValue = global_constants.SCORM_FALSE; + } else { + if (e.message) { + console.error(e.message); + } else { + console.error(e); + } + + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).GENERAL); + } + } + + this.processListeners(callbackName, CMIElement); + } + + this.apiLog(callbackName, CMIElement, ': returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Sets the value of the CMIElement. + * + * @param {string} callbackName + * @param {string} commitCallback + * @param {boolean} checkTerminated + * @param {string} CMIElement + * @param {*} value + * @return {string} + */ + + }, { + key: "setValue", + value: function setValue(callbackName, commitCallback, checkTerminated, CMIElement, value) { + if (value !== undefined) { + value = String(value); + } + + var returnValue = global_constants.SCORM_FALSE; + + if (this.checkState(checkTerminated, _classPrivateFieldGet(this, _error_codes).STORE_BEFORE_INIT, _classPrivateFieldGet(this, _error_codes).STORE_AFTER_TERM)) { + if (checkTerminated) this.lastErrorCode = 0; + + try { + returnValue = this.setCMIValue(CMIElement, value); + } catch (e) { + if (e instanceof _exceptions.ValidationError) { + this.lastErrorCode = e.errorCode; + returnValue = global_constants.SCORM_FALSE; + } else { + if (e.message) { + console.error(e.message); + } else { + console.error(e); + } + + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).GENERAL); + } + } + + this.processListeners(callbackName, CMIElement, value); + } + + if (returnValue === undefined) { + returnValue = global_constants.SCORM_FALSE; + } // If we didn't have any errors while setting the data, go ahead and + // schedule a commit, if autocommit is turned on + + + if (String(this.lastErrorCode) === '0') { + if (this.settings.autocommit && !_classPrivateFieldGet(this, _timeout)) { + this.scheduleCommit(this.settings.autocommitSeconds * 1000, commitCallback); + } + } + + this.apiLog(callbackName, CMIElement, ': ' + value + ': result: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Orders LMS to store all content parameters + * @param {string} callbackName + * @param {boolean} checkTerminated + * @return {string} + */ + + }, { + key: "commit", + value: function commit(callbackName, checkTerminated) { + this.clearScheduledCommit(); + var returnValue = global_constants.SCORM_FALSE; + + if (this.checkState(checkTerminated, _classPrivateFieldGet(this, _error_codes).COMMIT_BEFORE_INIT, _classPrivateFieldGet(this, _error_codes).COMMIT_AFTER_TERM)) { + var result = this.storeData(false); + + if (!this.settings.sendBeaconCommit && !this.settings.asyncCommit && result.errorCode && result.errorCode > 0) { + this.throwSCORMError(result.errorCode); + } + + returnValue = typeof result !== 'undefined' && result.result ? result.result : global_constants.SCORM_FALSE; + this.apiLog(callbackName, 'HttpRequest', ' Result: ' + returnValue, global_constants.LOG_LEVEL_DEBUG); + if (checkTerminated) this.lastErrorCode = 0; + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Returns last error code + * @param {string} callbackName + * @return {string} + */ + + }, { + key: "getLastError", + value: function getLastError(callbackName) { + var returnValue = String(this.lastErrorCode); + this.processListeners(callbackName); + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + return returnValue; + } + /** + * Returns the errorNumber error description + * + * @param {string} callbackName + * @param {(string|number)} CMIErrorCode + * @return {string} + */ + + }, { + key: "getErrorString", + value: function getErrorString(callbackName, CMIErrorCode) { + var returnValue = ''; + + if (CMIErrorCode !== null && CMIErrorCode !== '') { + returnValue = this.getLmsErrorMessageDetails(CMIErrorCode); + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + return returnValue; + } + /** + * Returns a comprehensive description of the errorNumber error. + * + * @param {string} callbackName + * @param {(string|number)} CMIErrorCode + * @return {string} + */ + + }, { + key: "getDiagnostic", + value: function getDiagnostic(callbackName, CMIErrorCode) { + var returnValue = ''; + + if (CMIErrorCode !== null && CMIErrorCode !== '') { + returnValue = this.getLmsErrorMessageDetails(CMIErrorCode, true); + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + return returnValue; + } + /** + * Checks the LMS state and ensures it has been initialized. + * + * @param {boolean} checkTerminated + * @param {number} beforeInitError + * @param {number} afterTermError + * @return {boolean} + */ + + }, { + key: "checkState", + value: function checkState(checkTerminated, beforeInitError, afterTermError) { + if (this.isNotInitialized()) { + this.throwSCORMError(beforeInitError); + return false; + } else if (checkTerminated && this.isTerminated()) { + this.throwSCORMError(afterTermError); + return false; + } + + return true; + } + /** + * Logging for all SCORM actions + * + * @param {string} functionName + * @param {string} CMIElement + * @param {string} logMessage + * @param {number}messageLevel + */ + + }, { + key: "apiLog", + value: function apiLog(functionName, CMIElement, logMessage, messageLevel) { + logMessage = this.formatMessage(functionName, CMIElement, logMessage); + + if (messageLevel >= this.apiLogLevel) { + switch (messageLevel) { + case global_constants.LOG_LEVEL_ERROR: + console.error(logMessage); + break; + + case global_constants.LOG_LEVEL_WARNING: + console.warn(logMessage); + break; + + case global_constants.LOG_LEVEL_INFO: + console.info(logMessage); + break; + + case global_constants.LOG_LEVEL_DEBUG: + if (console.debug) { + console.debug(logMessage); + } else { + console.log(logMessage); + } + + break; + } + } + } + /** + * Formats the SCORM messages for easy reading + * + * @param {string} functionName + * @param {string} CMIElement + * @param {string} message + * @return {string} + */ + + }, { + key: "formatMessage", + value: function formatMessage(functionName, CMIElement, message) { + var baseLength = 20; + var messageString = ''; + messageString += functionName; + var fillChars = baseLength - messageString.length; + + for (var i = 0; i < fillChars; i++) { + messageString += ' '; + } + + messageString += ': '; + + if (CMIElement) { + var CMIElementBaseLength = 70; + messageString += CMIElement; + fillChars = CMIElementBaseLength - messageString.length; + + for (var j = 0; j < fillChars; j++) { + messageString += ' '; + } + } + + if (message) { + messageString += message; + } + + return messageString; + } + /** + * Checks to see if {str} contains {tester} + * + * @param {string} str String to check against + * @param {string} tester String to check for + * @return {boolean} + */ + + }, { + key: "stringMatches", + value: function stringMatches(str, tester) { + return str && tester && str.match(tester); + } + /** + * Check to see if the specific object has the given property + * @param {*} refObject + * @param {string} attribute + * @return {boolean} + * @private + */ + + }, { + key: "_checkObjectHasProperty", + value: function _checkObjectHasProperty(refObject, attribute) { + return Object.hasOwnProperty.call(refObject, attribute) || Object.getOwnPropertyDescriptor(Object.getPrototypeOf(refObject), attribute) || attribute in refObject; + } + /** + * Returns the message that corresponds to errorNumber + * APIs that inherit BaseAPI should override this function + * + * @param {(string|number)} _errorNumber + * @param {boolean} _detail + * @return {string} + * @abstract + */ + + }, { + key: "getLmsErrorMessageDetails", + value: function getLmsErrorMessageDetails(_errorNumber, _detail) { + throw new Error('The getLmsErrorMessageDetails method has not been implemented'); + } + /** + * Gets the value for the specific element. + * APIs that inherit BaseAPI should override this function + * + * @param {string} _CMIElement + * @return {string} + * @abstract + */ + + }, { + key: "getCMIValue", + value: function getCMIValue(_CMIElement) { + throw new Error('The getCMIValue method has not been implemented'); + } + /** + * Sets the value for the specific element. + * APIs that inherit BaseAPI should override this function + * + * @param {string} _CMIElement + * @param {any} _value + * @return {string} + * @abstract + */ + + }, { + key: "setCMIValue", + value: function setCMIValue(_CMIElement, _value) { + throw new Error('The setCMIValue method has not been implemented'); + } + /** + * Shared API method to set a valid for a given element. + * + * @param {string} methodName + * @param {boolean} scorm2004 + * @param {string} CMIElement + * @param {*} value + * @return {string} + */ + + }, { + key: "_commonSetCMIValue", + value: function _commonSetCMIValue(methodName, scorm2004, CMIElement, value) { + if (!CMIElement || CMIElement === '') { + return global_constants.SCORM_FALSE; + } + + var structure = CMIElement.split('.'); + var refObject = this; + var returnValue = global_constants.SCORM_FALSE; + var foundFirstIndex = false; + var invalidErrorMessage = "The data model element passed to ".concat(methodName, " (").concat(CMIElement, ") is not a valid SCORM data model element."); + var invalidErrorCode = scorm2004 ? _classPrivateFieldGet(this, _error_codes).UNDEFINED_DATA_MODEL : _classPrivateFieldGet(this, _error_codes).GENERAL; + + for (var i = 0; i < structure.length; i++) { + var attribute = structure[i]; + + if (i === structure.length - 1) { + if (scorm2004 && attribute.substr(0, 8) === '{target=' && typeof refObject._isTargetValid == 'function') { + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).READ_ONLY_ELEMENT); + } else if (!this._checkObjectHasProperty(refObject, attribute)) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + } else { + if (this.isInitialized() && this.stringMatches(CMIElement, '\\.correct_responses\\.\\d+')) { + this.validateCorrectResponse(CMIElement, value); + } + + if (!scorm2004 || this.lastErrorCode === 0) { + refObject[attribute] = value; + returnValue = global_constants.SCORM_TRUE; + } + } + } else { + refObject = refObject[attribute]; + + if (!refObject) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + break; + } + + if (refObject instanceof _common.CMIArray) { + var index = parseInt(structure[i + 1], 10); // SCO is trying to set an item on an array + + if (!isNaN(index)) { + var item = refObject.childArray[index]; + + if (item) { + refObject = item; + foundFirstIndex = true; + } else { + var newChild = this.getChildElement(CMIElement, value, foundFirstIndex); + foundFirstIndex = true; + + if (!newChild) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + } else { + if (refObject.initialized) newChild.initialize(); + refObject.childArray.push(newChild); + refObject = newChild; + } + } // Have to update i value to skip the array position + + + i++; + } + } + } + } + + if (returnValue === global_constants.SCORM_FALSE) { + this.apiLog(methodName, null, "There was an error setting the value for: ".concat(CMIElement, ", value of: ").concat(value), global_constants.LOG_LEVEL_WARNING); + } + + return returnValue; + } + /** + * Abstract method for validating that a response is correct. + * + * @param {string} _CMIElement + * @param {*} _value + */ + + }, { + key: "validateCorrectResponse", + value: function validateCorrectResponse(_CMIElement, _value) {// just a stub method + } + /** + * Gets or builds a new child element to add to the array. + * APIs that inherit BaseAPI should override this method. + * + * @param {string} _CMIElement - unused + * @param {*} _value - unused + * @param {boolean} _foundFirstIndex - unused + * @return {*} + * @abstract + */ + + }, { + key: "getChildElement", + value: function getChildElement(_CMIElement, _value, _foundFirstIndex) { + throw new Error('The getChildElement method has not been implemented'); + } + /** + * Gets a value from the CMI Object + * + * @param {string} methodName + * @param {boolean} scorm2004 + * @param {string} CMIElement + * @return {*} + */ + + }, { + key: "_commonGetCMIValue", + value: function _commonGetCMIValue(methodName, scorm2004, CMIElement) { + if (!CMIElement || CMIElement === '') { + return ''; + } + + var structure = CMIElement.split('.'); + var refObject = this; + var attribute = null; + var uninitializedErrorMessage = "The data model element passed to ".concat(methodName, " (").concat(CMIElement, ") has not been initialized."); + var invalidErrorMessage = "The data model element passed to ".concat(methodName, " (").concat(CMIElement, ") is not a valid SCORM data model element."); + var invalidErrorCode = scorm2004 ? _classPrivateFieldGet(this, _error_codes).UNDEFINED_DATA_MODEL : _classPrivateFieldGet(this, _error_codes).GENERAL; + + for (var i = 0; i < structure.length; i++) { + attribute = structure[i]; + + if (!scorm2004) { + if (i === structure.length - 1) { + if (!this._checkObjectHasProperty(refObject, attribute)) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + return; + } + } + } else { + if (String(attribute).substr(0, 8) === '{target=' && typeof refObject._isTargetValid == 'function') { + var target = String(attribute).substr(8, String(attribute).length - 9); + return refObject._isTargetValid(target); + } else if (!this._checkObjectHasProperty(refObject, attribute)) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + return; + } + } + + refObject = refObject[attribute]; + + if (refObject === undefined) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + break; + } + + if (refObject instanceof _common.CMIArray) { + var index = parseInt(structure[i + 1], 10); // SCO is trying to set an item on an array + + if (!isNaN(index)) { + var item = refObject.childArray[index]; + + if (item) { + refObject = item; + } else { + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).VALUE_NOT_INITIALIZED, uninitializedErrorMessage); + break; + } // Have to update i value to skip the array position + + + i++; + } + } + } + + if (refObject === null || refObject === undefined) { + if (!scorm2004) { + if (attribute === '_children') { + this.throwSCORMError(scorm12_error_codes.CHILDREN_ERROR); + } else if (attribute === '_count') { + this.throwSCORMError(scorm12_error_codes.COUNT_ERROR); + } + } + } else { + return refObject; + } + } + /** + * Returns true if the API's current state is STATE_INITIALIZED + * + * @return {boolean} + */ + + }, { + key: "isInitialized", + value: function isInitialized() { + return this.currentState === global_constants.STATE_INITIALIZED; + } + /** + * Returns true if the API's current state is STATE_NOT_INITIALIZED + * + * @return {boolean} + */ + + }, { + key: "isNotInitialized", + value: function isNotInitialized() { + return this.currentState === global_constants.STATE_NOT_INITIALIZED; + } + /** + * Returns true if the API's current state is STATE_TERMINATED + * + * @return {boolean} + */ + + }, { + key: "isTerminated", + value: function isTerminated() { + return this.currentState === global_constants.STATE_TERMINATED; + } + /** + * Provides a mechanism for attaching to a specific SCORM event + * + * @param {string} listenerName + * @param {function} callback + */ + + }, { + key: "on", + value: function on(listenerName, callback) { + if (!callback) return; + var listenerFunctions = listenerName.split(' '); + + for (var i = 0; i < listenerFunctions.length; i++) { + var listenerSplit = listenerFunctions[i].split('.'); + if (listenerSplit.length === 0) return; + var functionName = listenerSplit[0]; + var CMIElement = null; + + if (listenerSplit.length > 1) { + CMIElement = listenerName.replace(functionName + '.', ''); + } + + this.listenerArray.push({ + functionName: functionName, + CMIElement: CMIElement, + callback: callback + }); + this.apiLog('on', functionName, "Added event listener: ".concat(this.listenerArray.length), global_constants.LOG_LEVEL_INFO); + } + } + /** + * Provides a mechanism for detaching a specific SCORM event listener + * + * @param {string} listenerName + * @param {function} callback + */ + + }, { + key: "off", + value: function off(listenerName, callback) { + var _this = this; + + if (!callback) return; + var listenerFunctions = listenerName.split(' '); + + var _loop = function _loop(i) { + var listenerSplit = listenerFunctions[i].split('.'); + if (listenerSplit.length === 0) return { + v: void 0 + }; + var functionName = listenerSplit[0]; + var CMIElement = null; + + if (listenerSplit.length > 1) { + CMIElement = listenerName.replace(functionName + '.', ''); + } + + var removeIndex = _this.listenerArray.findIndex(function (obj) { + return obj.functionName === functionName && obj.CMIElement === CMIElement && obj.callback === callback; + }); + + if (removeIndex !== -1) { + _this.listenerArray.splice(removeIndex, 1); + + _this.apiLog('off', functionName, "Removed event listener: ".concat(_this.listenerArray.length), global_constants.LOG_LEVEL_INFO); + } + }; + + for (var i = 0; i < listenerFunctions.length; i++) { + var _ret = _loop(i); + + if (_typeof(_ret) === "object") return _ret.v; + } + } + /** + * Provides a mechanism for clearing all listeners from a specific SCORM event + * + * @param {string} listenerName + */ + + }, { + key: "clear", + value: function clear(listenerName) { + var _this2 = this; + + var listenerFunctions = listenerName.split(' '); + + var _loop2 = function _loop2(i) { + var listenerSplit = listenerFunctions[i].split('.'); + if (listenerSplit.length === 0) return { + v: void 0 + }; + var functionName = listenerSplit[0]; + var CMIElement = null; + + if (listenerSplit.length > 1) { + CMIElement = listenerName.replace(functionName + '.', ''); + } + + _this2.listenerArray = _this2.listenerArray.filter(function (obj) { + return obj.functionName !== functionName && obj.CMIElement !== CMIElement; + }); + }; + + for (var i = 0; i < listenerFunctions.length; i++) { + var _ret2 = _loop2(i); + + if (_typeof(_ret2) === "object") return _ret2.v; + } + } + /** + * Processes any 'on' listeners that have been created + * + * @param {string} functionName + * @param {string} CMIElement + * @param {*} value + */ + + }, { + key: "processListeners", + value: function processListeners(functionName, CMIElement, value) { + this.apiLog(functionName, CMIElement, value); + + for (var i = 0; i < this.listenerArray.length; i++) { + var listener = this.listenerArray[i]; + var functionsMatch = listener.functionName === functionName; + var listenerHasCMIElement = !!listener.CMIElement; + var CMIElementsMatch = false; + + if (CMIElement && listener.CMIElement && listener.CMIElement.substring(listener.CMIElement.length - 1) === '*') { + CMIElementsMatch = CMIElement.indexOf(listener.CMIElement.substring(0, listener.CMIElement.length - 1)) === 0; + } else { + CMIElementsMatch = listener.CMIElement === CMIElement; + } + + if (functionsMatch && (!listenerHasCMIElement || CMIElementsMatch)) { + listener.callback(CMIElement, value); + } + } + } + /** + * Throws a SCORM error + * + * @param {number} errorNumber + * @param {string} message + */ + + }, { + key: "throwSCORMError", + value: function throwSCORMError(errorNumber, message) { + if (!message) { + message = this.getLmsErrorMessageDetails(errorNumber); + } + + this.apiLog('throwSCORMError', null, errorNumber + ': ' + message, global_constants.LOG_LEVEL_ERROR); + this.lastErrorCode = String(errorNumber); + } + /** + * Clears the last SCORM error code on success. + * + * @param {string} success + */ + + }, { + key: "clearSCORMError", + value: function clearSCORMError(success) { + if (success !== undefined && success !== global_constants.SCORM_FALSE) { + this.lastErrorCode = 0; + } + } + /** + * Attempts to store the data to the LMS, logs data if no LMS configured + * APIs that inherit BaseAPI should override this function + * + * @param {boolean} _calculateTotalTime + * @return {string} + * @abstract + */ + + }, { + key: "storeData", + value: function storeData(_calculateTotalTime) { + throw new Error('The storeData method has not been implemented'); + } + /** + * Load the CMI from a flattened JSON object + * @param {object} json + * @param {string} CMIElement + */ + + }, { + key: "loadFromFlattenedJSON", + value: function loadFromFlattenedJSON(json, CMIElement) { + var _this3 = this; + + if (!this.isNotInitialized()) { + console.error('loadFromFlattenedJSON can only be called before the call to lmsInitialize.'); + return; + } + /** + * Test match pattern. + * + * @param {string} a + * @param {string} c + * @param {RegExp} a_pattern + * @return {number} + */ + + + function testPattern(a, c, a_pattern) { + var a_match = a.match(a_pattern); + var c_match; + + if (a_match !== null && (c_match = c.match(a_pattern)) !== null) { + var a_num = Number(a_match[2]); + var c_num = Number(c_match[2]); + + if (a_num === c_num) { + if (a_match[3] === 'id') { + return -1; + } else if (a_match[3] === 'type') { + if (c_match[3] === 'id') { + return 1; + } else { + return -1; + } + } else { + return 1; + } + } + + return a_num - c_num; + } + + return null; + } + + var int_pattern = /^(cmi\.interactions\.)(\d+)\.(.*)$/; + var obj_pattern = /^(cmi\.objectives\.)(\d+)\.(.*)$/; + var result = Object.keys(json).map(function (key) { + return [String(key), json[key]]; + }); // CMI interactions need to have id and type loaded before any other fields + + result.sort(function (_ref, _ref2) { + var _ref3 = _slicedToArray(_ref, 2), + a = _ref3[0], + b = _ref3[1]; + + var _ref4 = _slicedToArray(_ref2, 2), + c = _ref4[0], + d = _ref4[1]; + + var test; + + if ((test = testPattern(a, c, int_pattern)) !== null) { + return test; + } + + if ((test = testPattern(a, c, obj_pattern)) !== null) { + return test; + } + + if (a < c) { + return -1; + } + + if (a > c) { + return 1; + } + + return 0; + }); + var obj; + result.forEach(function (element) { + obj = {}; + obj[element[0]] = element[1]; + + _this3.loadFromJSON((0, _utilities.unflatten)(obj), CMIElement); + }); + } + /** + * Loads CMI data from a JSON object. + * + * @param {object} json + * @param {string} CMIElement + */ + + }, { + key: "loadFromJSON", + value: function loadFromJSON(json, CMIElement) { + if (!this.isNotInitialized()) { + console.error('loadFromJSON can only be called before the call to lmsInitialize.'); + return; + } + + CMIElement = CMIElement !== undefined ? CMIElement : 'cmi'; + this.startingData = json; // could this be refactored down to flatten(json) then setCMIValue on each? + + for (var key in json) { + if ({}.hasOwnProperty.call(json, key) && json[key]) { + var currentCMIElement = (CMIElement ? CMIElement + '.' : '') + key; + var value = json[key]; + + if (value['childArray']) { + for (var i = 0; i < value['childArray'].length; i++) { + this.loadFromJSON(value['childArray'][i], currentCMIElement + '.' + i); + } + } else if (value.constructor === Object) { + this.loadFromJSON(value, currentCMIElement); + } else { + this.setCMIValue(currentCMIElement, value); + } + } + } + } + /** + * Render the CMI object to JSON for sending to an LMS. + * + * @return {string} + */ + + }, { + key: "renderCMIToJSONString", + value: function renderCMIToJSONString() { + var cmi = this.cmi; // Do we want/need to return fields that have no set value? + // return JSON.stringify({ cmi }, (k, v) => v === undefined ? null : v, 2); + + return JSON.stringify({ + cmi: cmi + }); + } + /** + * Returns a JS object representing the current cmi + * @return {object} + */ + + }, { + key: "renderCMIToJSONObject", + value: function renderCMIToJSONObject() { + // Do we want/need to return fields that have no set value? + // return JSON.stringify({ cmi }, (k, v) => v === undefined ? null : v, 2); + return JSON.parse(this.renderCMIToJSONString()); + } + /** + * Render the cmi object to the proper format for LMS commit + * APIs that inherit BaseAPI should override this function + * + * @param {boolean} _terminateCommit + * @return {*} + * @abstract + */ + + }, { + key: "renderCommitCMI", + value: function renderCommitCMI(_terminateCommit) { + throw new Error('The storeData method has not been implemented'); + } + /** + * Send the request to the LMS + * @param {string} url + * @param {object|Array} params + * @param {boolean} immediate + * @return {object} + */ + + }, { + key: "processHttpRequest", + value: function processHttpRequest(url, params) { + var immediate = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + var api = this; + + var process = function process(url, params, settings, error_codes) { + var genericError = { + 'result': global_constants.SCORM_FALSE, + 'errorCode': error_codes.GENERAL + }; + var result; + + if (!settings.sendBeaconCommit) { + var httpReq = new XMLHttpRequest(); + httpReq.open('POST', url, settings.asyncCommit); + + if (settings.asyncCommit) { + httpReq.onload = function (e) { + if (typeof settings.responseHandler === 'function') { + result = settings.responseHandler(httpReq); + } else { + result = JSON.parse(httpReq.responseText); + } + }; + } + + try { + if (params instanceof Array) { + httpReq.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded'); + httpReq.send(params.join('&')); + } else { + httpReq.setRequestHeader('Content-Type', settings.commitRequestDataType); + httpReq.send(JSON.stringify(params)); + } + + if (!settings.asyncCommit) { + if (typeof settings.responseHandler === 'function') { + result = settings.responseHandler(httpReq); + } else { + result = JSON.parse(httpReq.responseText); + } + } else { + result = {}; + result.result = global_constants.SCORM_TRUE; + result.errorCode = 0; + api.processListeners('CommitSuccess'); + return result; + } + } catch (e) { + console.error(e); + api.processListeners('CommitError'); + return genericError; + } + } else { + try { + var headers = { + type: settings.commitRequestDataType + }; + var blob; + + if (params instanceof Array) { + blob = new Blob([params.join('&')], headers); + } else { + blob = new Blob([JSON.stringify(params)], headers); + } + + result = {}; + + if (navigator.sendBeacon(url, blob)) { + result.result = global_constants.SCORM_TRUE; + result.errorCode = 0; + } else { + result.result = global_constants.SCORM_FALSE; + result.errorCode = 101; + } + } catch (e) { + console.error(e); + api.processListeners('CommitError'); + return genericError; + } + } + + if (typeof result === 'undefined') { + api.processListeners('CommitError'); + return genericError; + } + + if (result.result === true || result.result === global_constants.SCORM_TRUE) { + api.processListeners('CommitSuccess'); + } else { + api.processListeners('CommitError'); + } + + return result; + }; + + if (typeof _lodash["default"] !== 'undefined') { + var debounced = (0, _lodash["default"])(process, 500); + debounced(url, params, this.settings, this.error_codes); // if we're terminating, go ahead and commit immediately + + if (immediate) { + debounced.flush(); + } + + return { + result: global_constants.SCORM_TRUE, + errorCode: 0 + }; + } else { + return process(url, params, this.settings, this.error_codes); + } + } + /** + * Throws a SCORM error + * + * @param {number} when - the number of milliseconds to wait before committing + * @param {string} callback - the name of the commit event callback + */ + + }, { + key: "scheduleCommit", + value: function scheduleCommit(when, callback) { + _classPrivateFieldSet(this, _timeout, new ScheduledCommit(this, when, callback)); + + this.apiLog('scheduleCommit', '', 'scheduled', global_constants.LOG_LEVEL_DEBUG); + } + /** + * Clears and cancels any currently scheduled commits + */ + + }, { + key: "clearScheduledCommit", + value: function clearScheduledCommit() { + if (_classPrivateFieldGet(this, _timeout)) { + _classPrivateFieldGet(this, _timeout).cancel(); + + _classPrivateFieldSet(this, _timeout, null); + + this.apiLog('clearScheduledCommit', '', 'cleared', global_constants.LOG_LEVEL_DEBUG); + } + } + }]); + + return BaseAPI; +}(); +/** + * Private class that wraps a timeout call to the commit() function + */ + + +exports["default"] = BaseAPI; + +var _API = new WeakMap(); + +var _cancelled = new WeakMap(); + +var _timeout2 = new WeakMap(); + +var _callback = new WeakMap(); + +var ScheduledCommit = /*#__PURE__*/function () { + /** + * Constructor for ScheduledCommit + * @param {BaseAPI} API + * @param {number} when + * @param {string} callback + */ + function ScheduledCommit(API, when, callback) { + _classCallCheck(this, ScheduledCommit); + + _API.set(this, { + writable: true, + value: void 0 + }); + + _cancelled.set(this, { + writable: true, + value: false + }); + + _timeout2.set(this, { + writable: true, + value: void 0 + }); + + _callback.set(this, { + writable: true, + value: void 0 + }); + + _classPrivateFieldSet(this, _API, API); + + _classPrivateFieldSet(this, _timeout2, setTimeout(this.wrapper.bind(this), when)); + + _classPrivateFieldSet(this, _callback, callback); + } + /** + * Cancel any currently scheduled commit + */ + + + _createClass(ScheduledCommit, [{ + key: "cancel", + value: function cancel() { + _classPrivateFieldSet(this, _cancelled, true); + + if (_classPrivateFieldGet(this, _timeout2)) { + clearTimeout(_classPrivateFieldGet(this, _timeout2)); + } + } + /** + * Wrap the API commit call to check if the call has already been cancelled + */ + + }, { + key: "wrapper", + value: function wrapper() { + if (!_classPrivateFieldGet(this, _cancelled)) { + _classPrivateFieldGet(this, _API).commit(_classPrivateFieldGet(this, _callback)); + } + } + }]); + + return ScheduledCommit; +}(); + },{"./cmi/common":7,"./constants/api_constants":10,"./constants/error_codes":11,"./exceptions":15,"./utilities":17,"lodash.debounce":1}],4:[function(require,module,exports){ -"use strict";function _typeof(e){"@babel/helpers - typeof";return(_typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var t=new WeakMap,r=new WeakMap;return(_getRequireWildcardCache=function(e){return e?r:t})(e)}function _interopRequireWildcard(e,t){if(!t&&e&&e.__esModule)return e;if(null===e||"object"!==_typeof(e)&&"function"!=typeof e)return{default:e};var r=_getRequireWildcardCache(t);if(r&&r.has(e))return r.get(e);var o={},i=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var n in e)if("default"!==n&&Object.prototype.hasOwnProperty.call(e,n)){var s=i?Object.getOwnPropertyDescriptor(e,n):null;s&&(s.get||s.set)?Object.defineProperty(o,n,s):o[n]=e[n]}return o.default=e,r&&r.set(e,o),o}function _interopRequireDefault(e){return e&&e.__esModule?e:{default:e}}function ownKeys(e,t){var r=Object.keys(e);if(Object.getOwnPropertySymbols){var o=Object.getOwnPropertySymbols(e);t&&(o=o.filter(function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable})),r.push.apply(r,o)}return r}function _objectSpread(e){for(var t=1;t=parseFloat(this.cmi.student_data.mastery_score)?this.cmi.core.lesson_status="passed":this.cmi.core.lesson_status="failed");else if("browse"===this.cmi.core.lesson_mode){var r,o,i;""===((null===(r=this.startingData)||void 0===r?void 0:null===(o=r.cmi)||void 0===o?void 0:null===(i=o.core)||void 0===i?void 0:i.lesson_status)||"")&&"not attempted"===t&&(this.cmi.core.lesson_status="browsed")}}var n=this.renderCommitCMI(e||this.settings.alwaysSendTotalTime);return this.apiLogLevel===global_constants.LOG_LEVEL_DEBUG&&(console.debug("Commit (terminated: "+(e?"yes":"no")+"): "),console.debug(n)),this.settings.lmsCommitUrl?this.processHttpRequest(this.settings.lmsCommitUrl,n,e):global_constants.SCORM_TRUE}}]),t}(_BaseAPI2.default);exports.default=Scorm12API; +"use strict"; + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +var _BaseAPI2 = _interopRequireDefault(require("./BaseAPI")); + +var _scorm12_cmi = require("./cmi/scorm12_cmi"); + +var Utilities = _interopRequireWildcard(require("./utilities")); + +var _api_constants = _interopRequireDefault(require("./constants/api_constants")); + +var _error_codes = _interopRequireDefault(require("./constants/error_codes")); + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +var scorm12_constants = _api_constants["default"].scorm12; +var global_constants = _api_constants["default"].global; +var scorm12_error_codes = _error_codes["default"].scorm12; +/** + * API class for SCORM 1.2 + */ + +var Scorm12API = /*#__PURE__*/function (_BaseAPI) { + _inherits(Scorm12API, _BaseAPI); + + var _super = _createSuper(Scorm12API); + + /** + * Constructor for SCORM 1.2 API + * @param {object} settings + */ + function Scorm12API(settings) { + var _this; + + _classCallCheck(this, Scorm12API); + + var finalSettings = _objectSpread(_objectSpread({}, { + mastery_override: false + }), settings); + + _this = _super.call(this, scorm12_error_codes, finalSettings); + _this.cmi = new _scorm12_cmi.CMI(); + _this.nav = new _scorm12_cmi.NAV(); // Rename functions to match 1.2 Spec and expose to modules + + _this.LMSInitialize = _this.lmsInitialize; + _this.LMSFinish = _this.lmsFinish; + _this.LMSGetValue = _this.lmsGetValue; + _this.LMSSetValue = _this.lmsSetValue; + _this.LMSCommit = _this.lmsCommit; + _this.LMSGetLastError = _this.lmsGetLastError; + _this.LMSGetErrorString = _this.lmsGetErrorString; + _this.LMSGetDiagnostic = _this.lmsGetDiagnostic; + return _this; + } + /** + * lmsInitialize function from SCORM 1.2 Spec + * + * @return {string} bool + */ + + + _createClass(Scorm12API, [{ + key: "lmsInitialize", + value: function lmsInitialize() { + this.cmi.initialize(); + return this.initialize('LMSInitialize', 'LMS was already initialized!', 'LMS is already finished!'); + } + /** + * LMSFinish function from SCORM 1.2 Spec + * + * @return {string} bool + */ + + }, { + key: "lmsFinish", + value: function lmsFinish() { + var result = this.terminate('LMSFinish', true); + + if (result === global_constants.SCORM_TRUE) { + if (this.nav.event !== '') { + if (this.nav.event === 'continue') { + this.processListeners('SequenceNext'); + } else { + this.processListeners('SequencePrevious'); + } + } else if (this.settings.autoProgress) { + this.processListeners('SequenceNext'); + } + } + + return result; + } + /** + * LMSGetValue function from SCORM 1.2 Spec + * + * @param {string} CMIElement + * @return {string} + */ + + }, { + key: "lmsGetValue", + value: function lmsGetValue(CMIElement) { + return this.getValue('LMSGetValue', false, CMIElement); + } + /** + * LMSSetValue function from SCORM 1.2 Spec + * + * @param {string} CMIElement + * @param {*} value + * @return {string} + */ + + }, { + key: "lmsSetValue", + value: function lmsSetValue(CMIElement, value) { + return this.setValue('LMSSetValue', 'LMSCommit', false, CMIElement, value); + } + /** + * LMSCommit function from SCORM 1.2 Spec + * + * @return {string} bool + */ + + }, { + key: "lmsCommit", + value: function lmsCommit() { + return this.commit('LMSCommit', false); + } + /** + * LMSGetLastError function from SCORM 1.2 Spec + * + * @return {string} + */ + + }, { + key: "lmsGetLastError", + value: function lmsGetLastError() { + return this.getLastError('LMSGetLastError'); + } + /** + * LMSGetErrorString function from SCORM 1.2 Spec + * + * @param {string} CMIErrorCode + * @return {string} + */ + + }, { + key: "lmsGetErrorString", + value: function lmsGetErrorString(CMIErrorCode) { + return this.getErrorString('LMSGetErrorString', CMIErrorCode); + } + /** + * LMSGetDiagnostic function from SCORM 1.2 Spec + * + * @param {string} CMIErrorCode + * @return {string} + */ + + }, { + key: "lmsGetDiagnostic", + value: function lmsGetDiagnostic(CMIErrorCode) { + return this.getDiagnostic('LMSGetDiagnostic', CMIErrorCode); + } + /** + * Sets a value on the CMI Object + * + * @param {string} CMIElement + * @param {*} value + * @return {string} + */ + + }, { + key: "setCMIValue", + value: function setCMIValue(CMIElement, value) { + return this._commonSetCMIValue('LMSSetValue', false, CMIElement, value); + } + /** + * Gets a value from the CMI Object + * + * @param {string} CMIElement + * @return {*} + */ + + }, { + key: "getCMIValue", + value: function getCMIValue(CMIElement) { + return this._commonGetCMIValue('getCMIValue', false, CMIElement); + } + /** + * Gets or builds a new child element to add to the array. + * + * @param {string} CMIElement + * @param {*} value + * @param {boolean} foundFirstIndex + * @return {object} + */ + + }, { + key: "getChildElement", + value: function getChildElement(CMIElement, value, foundFirstIndex) { + var newChild; + + if (this.stringMatches(CMIElement, 'cmi\\.objectives\\.\\d+')) { + newChild = new _scorm12_cmi.CMIObjectivesObject(); + } else if (foundFirstIndex && this.stringMatches(CMIElement, 'cmi\\.interactions\\.\\d+\\.correct_responses\\.\\d+')) { + newChild = new _scorm12_cmi.CMIInteractionsCorrectResponsesObject(); + } else if (foundFirstIndex && this.stringMatches(CMIElement, 'cmi\\.interactions\\.\\d+\\.objectives\\.\\d+')) { + newChild = new _scorm12_cmi.CMIInteractionsObjectivesObject(); + } else if (!foundFirstIndex && this.stringMatches(CMIElement, 'cmi\\.interactions\\.\\d+')) { + newChild = new _scorm12_cmi.CMIInteractionsObject(); + } + + return newChild; + } + /** + * Validates Correct Response values + * + * @param {string} CMIElement + * @param {*} value + * @return {boolean} + */ + + }, { + key: "validateCorrectResponse", + value: function validateCorrectResponse(CMIElement, value) { + return true; + } + /** + * Returns the message that corresponds to errorNumber. + * + * @param {*} errorNumber + * @param {boolean} detail + * @return {string} + */ + + }, { + key: "getLmsErrorMessageDetails", + value: function getLmsErrorMessageDetails(errorNumber, detail) { + var basicMessage = 'No Error'; + var detailMessage = 'No Error'; // Set error number to string since inconsistent from modules if string or number + + errorNumber = String(errorNumber); + + if (scorm12_constants.error_descriptions[errorNumber]) { + basicMessage = scorm12_constants.error_descriptions[errorNumber].basicMessage; + detailMessage = scorm12_constants.error_descriptions[errorNumber].detailMessage; + } + + return detail ? detailMessage : basicMessage; + } + /** + * Replace the whole API with another + * + * @param {Scorm12API} newAPI + */ + + }, { + key: "replaceWithAnotherScormAPI", + value: function replaceWithAnotherScormAPI(newAPI) { + // Data Model + this.cmi = newAPI.cmi; + } + /** + * Render the cmi object to the proper format for LMS commit + * + * @param {boolean} terminateCommit + * @return {object|Array} + */ + + }, { + key: "renderCommitCMI", + value: function renderCommitCMI(terminateCommit) { + var cmiExport = this.renderCMIToJSONObject(); + + if (terminateCommit) { + cmiExport.cmi.core.total_time = this.cmi.getCurrentTotalTime(); + } + + var result = []; + var flattened = Utilities.flatten(cmiExport); + + switch (this.settings.dataCommitFormat) { + case 'flattened': + return Utilities.flatten(cmiExport); + + case 'params': + for (var item in flattened) { + if ({}.hasOwnProperty.call(flattened, item)) { + result.push("".concat(item, "=").concat(flattened[item])); + } + } + + return result; + + case 'json': + default: + return cmiExport; + } + } + /** + * Attempts to store the data to the LMS + * + * @param {boolean} terminateCommit + * @return {string} + */ + + }, { + key: "storeData", + value: function storeData(terminateCommit) { + if (terminateCommit) { + var originalStatus = this.cmi.core.lesson_status; + + if (originalStatus === 'not attempted') { + this.cmi.core.lesson_status = 'completed'; + } + + if (this.cmi.core.lesson_mode === 'normal') { + if (this.cmi.core.credit === 'credit') { + if (this.settings.mastery_override && this.cmi.student_data.mastery_score !== '' && this.cmi.core.score.raw !== '') { + if (parseFloat(this.cmi.core.score.raw) >= parseFloat(this.cmi.student_data.mastery_score)) { + this.cmi.core.lesson_status = 'passed'; + } else { + this.cmi.core.lesson_status = 'failed'; + } + } + } + } else if (this.cmi.core.lesson_mode === 'browse') { + var _this$startingData, _this$startingData$cm, _this$startingData$cm2; + + if ((((_this$startingData = this.startingData) === null || _this$startingData === void 0 ? void 0 : (_this$startingData$cm = _this$startingData.cmi) === null || _this$startingData$cm === void 0 ? void 0 : (_this$startingData$cm2 = _this$startingData$cm.core) === null || _this$startingData$cm2 === void 0 ? void 0 : _this$startingData$cm2.lesson_status) || '') === '' && originalStatus === 'not attempted') { + this.cmi.core.lesson_status = 'browsed'; + } + } + } + + var commitObject = this.renderCommitCMI(terminateCommit || this.settings.alwaysSendTotalTime); + + if (this.apiLogLevel === global_constants.LOG_LEVEL_DEBUG) { + console.debug('Commit (terminated: ' + (terminateCommit ? 'yes' : 'no') + '): '); + console.debug(commitObject); + } + + if (this.settings.lmsCommitUrl) { + return this.processHttpRequest(this.settings.lmsCommitUrl, commitObject, terminateCommit); + } else { + return global_constants.SCORM_TRUE; + } + } + }]); + + return Scorm12API; +}(_BaseAPI2["default"]); + +exports["default"] = Scorm12API; + },{"./BaseAPI":3,"./cmi/scorm12_cmi":8,"./constants/api_constants":10,"./constants/error_codes":11,"./utilities":17}],5:[function(require,module,exports){ -"use strict";function _typeof(e){"@babel/helpers - typeof";return(_typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var t=new WeakMap,r=new WeakMap;return(_getRequireWildcardCache=function(e){return e?r:t})(e)}function _interopRequireWildcard(e,t){if(!t&&e&&e.__esModule)return e;if(null===e||"object"!==_typeof(e)&&"function"!=typeof e)return{default:e};var r=_getRequireWildcardCache(t);if(r&&r.has(e))return r.get(e);var s={},o=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var i in e)if("default"!==i&&Object.prototype.hasOwnProperty.call(e,i)){var n=o?Object.getOwnPropertyDescriptor(e,i):null;n&&(n.get||n.set)?Object.defineProperty(s,i,n):s[i]=e[i]}return s.default=e,r&&r.set(e,s),s}function _interopRequireDefault(e){return e&&e.__esModule?e:{default:e}}function ownKeys(e,t){var r=Object.keys(e);if(Object.getOwnPropertySymbols){var s=Object.getOwnPropertySymbols(e);t&&(s=s.filter(function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable})),r.push.apply(r,s)}return r}function _objectSpread(e){for(var t=1;t0&&s.length<=e.max?this.checkCorrectResponseValue(r,s,t):s.length>e.max&&this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE,"Data Model Element Pattern Too Long")}},{key:"checkDuplicateChoiceResponse",value:function(e,t){var r=e.correct_responses._count;if("choice"===e.type)for(var s=0;s1)Number(t[0])>Number(t[1])&&this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);else if(""!==t[i]&&s.unique)for(var l=0;l0&&void 0===_language_constants.default[c.toLowerCase()]&&this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH)}s=!0;break;case"case_matters":s||t||r||"true"!==i[3]&&"false"!==i[3]&&this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH),r=!0;break;case"order_matters":r||s||t||"true"!==i[3]&&"false"!==i[3]&&this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH),t=!0}e=e.substr(i[1].length),i=e.match(o)}return e}},{key:"replaceWithAnotherScormAPI",value:function(e){this.cmi=e.cmi,this.adl=e.adl}},{key:"renderCommitCMI",value:function(e){var t=this.renderCMIToJSONObject();e&&(t.cmi.total_time=this.cmi.getCurrentTotalTime());var r=[],s=Utilities.flatten(t);switch(this.settings.dataCommitFormat){case"flattened":return Utilities.flatten(t);case"params":for(var o in s)({}).hasOwnProperty.call(s,o)&&r.push("".concat(o,"=").concat(s[o]));return r;case"json":default:return t}}},{key:"storeData",value:function(e){var t,r,s;e&&"normal"===this.cmi.mode&&"credit"===this.cmi.credit&&(this.cmi.completion_threshold&&this.cmi.progress_measure&&(this.cmi.progress_measure>=this.cmi.completion_threshold?(console.debug("Setting Completion Status: Completed"),this.cmi.completion_status="completed"):(console.debug("Setting Completion Status: Incomplete"),this.cmi.completion_status="incomplete")),this.cmi.scaled_passing_score&&this.cmi.score.scaled&&(this.cmi.score.scaled>=this.cmi.scaled_passing_score?(console.debug("Setting Success Status: Passed"),this.cmi.success_status="passed"):(console.debug("Setting Success Status: Failed"),this.cmi.success_status="failed")));var o=!1;this.adl.nav.request!==(null===(t=this.startingData)||void 0===t?void 0:null===(r=t.adl)||void 0===r?void 0:null===(s=r.nav)||void 0===s?void 0:s.request)&&"_none_"!==this.adl.nav.request&&(this.adl.nav.request=encodeURIComponent(this.adl.nav.request),o=!0);var i=this.renderCommitCMI(e||this.settings.alwaysSendTotalTime);if(this.apiLogLevel===global_constants.LOG_LEVEL_DEBUG&&(console.debug("Commit (terminated: "+(e?"yes":"no")+"): "),console.debug(i)),this.settings.lmsCommitUrl){var n=this.processHttpRequest(this.settings.lmsCommitUrl,i,e);return o&&void 0!==n.navRequest&&""!==n.navRequest&&Function('"use strict";(() => { '.concat(n.navRequest," })()"))(),n}return global_constants.SCORM_TRUE}}]),t}(_BaseAPI2.default);exports.default=Scorm2004API; +"use strict"; + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +var _BaseAPI2 = _interopRequireDefault(require("./BaseAPI")); + +var _scorm2004_cmi = require("./cmi/scorm2004_cmi"); + +var Utilities = _interopRequireWildcard(require("./utilities")); + +var _api_constants = _interopRequireDefault(require("./constants/api_constants")); + +var _error_codes = _interopRequireDefault(require("./constants/error_codes")); + +var _response_constants = _interopRequireDefault(require("./constants/response_constants")); + +var _language_constants = _interopRequireDefault(require("./constants/language_constants")); + +var _regex = _interopRequireDefault(require("./constants/regex")); + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); } + +function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); } + +function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +var scorm2004_constants = _api_constants["default"].scorm2004; +var global_constants = _api_constants["default"].global; +var scorm2004_error_codes = _error_codes["default"].scorm2004; +var correct_responses = _response_constants["default"].correct; +var scorm2004_regex = _regex["default"].scorm2004; +/** + * API class for SCORM 2004 + */ + +var _version = new WeakMap(); + +var Scorm2004API = /*#__PURE__*/function (_BaseAPI) { + _inherits(Scorm2004API, _BaseAPI); + + var _super = _createSuper(Scorm2004API); + + /** + * Constructor for SCORM 2004 API + * @param {object} settings + */ + function Scorm2004API(settings) { + var _this; + + _classCallCheck(this, Scorm2004API); + + var finalSettings = _objectSpread(_objectSpread({}, { + mastery_override: false + }), settings); + + _this = _super.call(this, scorm2004_error_codes, finalSettings); + + _version.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _defineProperty(_assertThisInitialized(_this), "checkDuplicatedPattern", function (correct_response, current_index, value) { + var found = false; + var count = correct_response._count; + + for (var i = 0; i < count && !found; i++) { + if (i !== current_index && correct_response.childArray[i] === value) { + found = true; + } + } + + return found; + }); + + _this.cmi = new _scorm2004_cmi.CMI(); + _this.adl = new _scorm2004_cmi.ADL(); // Rename functions to match 2004 Spec and expose to modules + + _this.Initialize = _this.lmsInitialize; + _this.Terminate = _this.lmsTerminate; + _this.GetValue = _this.lmsGetValue; + _this.SetValue = _this.lmsSetValue; + _this.Commit = _this.lmsCommit; + _this.GetLastError = _this.lmsGetLastError; + _this.GetErrorString = _this.lmsGetErrorString; + _this.GetDiagnostic = _this.lmsGetDiagnostic; + return _this; + } + /** + * Getter for #version + * @return {string} + */ + + + _createClass(Scorm2004API, [{ + key: "version", + get: function get() { + return _classPrivateFieldGet(this, _version); + } + /** + * @return {string} bool + */ + + }, { + key: "lmsInitialize", + value: function lmsInitialize() { + this.cmi.initialize(); + return this.initialize('Initialize'); + } + /** + * @return {string} bool + */ + + }, { + key: "lmsTerminate", + value: function lmsTerminate() { + var result = this.terminate('Terminate', true); + + if (result === global_constants.SCORM_TRUE) { + if (this.adl.nav.request !== '_none_') { + switch (this.adl.nav.request) { + case 'continue': + this.processListeners('SequenceNext'); + break; + + case 'previous': + this.processListeners('SequencePrevious'); + break; + + case 'choice': + this.processListeners('SequenceChoice'); + break; + + case 'exit': + this.processListeners('SequenceExit'); + break; + + case 'exitAll': + this.processListeners('SequenceExitAll'); + break; + + case 'abandon': + this.processListeners('SequenceAbandon'); + break; + + case 'abandonAll': + this.processListeners('SequenceAbandonAll'); + break; + } + } else if (this.settings.autoProgress) { + this.processListeners('SequenceNext'); + } + } + + return result; + } + /** + * @param {string} CMIElement + * @return {string} + */ + + }, { + key: "lmsGetValue", + value: function lmsGetValue(CMIElement) { + return this.getValue('GetValue', true, CMIElement); + } + /** + * @param {string} CMIElement + * @param {any} value + * @return {string} + */ + + }, { + key: "lmsSetValue", + value: function lmsSetValue(CMIElement, value) { + return this.setValue('SetValue', 'Commit', true, CMIElement, value); + } + /** + * Orders LMS to store all content parameters + * + * @return {string} bool + */ + + }, { + key: "lmsCommit", + value: function lmsCommit() { + return this.commit('Commit'); + } + /** + * Returns last error code + * + * @return {string} + */ + + }, { + key: "lmsGetLastError", + value: function lmsGetLastError() { + return this.getLastError('GetLastError'); + } + /** + * Returns the errorNumber error description + * + * @param {(string|number)} CMIErrorCode + * @return {string} + */ + + }, { + key: "lmsGetErrorString", + value: function lmsGetErrorString(CMIErrorCode) { + return this.getErrorString('GetErrorString', CMIErrorCode); + } + /** + * Returns a comprehensive description of the errorNumber error. + * + * @param {(string|number)} CMIErrorCode + * @return {string} + */ + + }, { + key: "lmsGetDiagnostic", + value: function lmsGetDiagnostic(CMIErrorCode) { + return this.getDiagnostic('GetDiagnostic', CMIErrorCode); + } + /** + * Sets a value on the CMI Object + * + * @param {string} CMIElement + * @param {any} value + * @return {string} + */ + + }, { + key: "setCMIValue", + value: function setCMIValue(CMIElement, value) { + return this._commonSetCMIValue('SetValue', true, CMIElement, value); + } + /** + * Gets or builds a new child element to add to the array. + * + * @param {string} CMIElement + * @param {any} value + * @param {boolean} foundFirstIndex + * @return {any} + */ + + }, { + key: "getChildElement", + value: function getChildElement(CMIElement, value, foundFirstIndex) { + var newChild; + + if (this.stringMatches(CMIElement, 'cmi\\.objectives\\.\\d+')) { + newChild = new _scorm2004_cmi.CMIObjectivesObject(); + } else if (foundFirstIndex && this.stringMatches(CMIElement, 'cmi\\.interactions\\.\\d+\\.correct_responses\\.\\d+')) { + var parts = CMIElement.split('.'); + var index = Number(parts[2]); + var interaction = this.cmi.interactions.childArray[index]; + + if (this.isInitialized()) { + if (!interaction.type) { + this.throwSCORMError(scorm2004_error_codes.DEPENDENCY_NOT_ESTABLISHED); + } else { + this.checkDuplicateChoiceResponse(interaction, value); + var response_type = correct_responses[interaction.type]; + + if (response_type) { + this.checkValidResponseType(response_type, value, interaction.type); + } else { + this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE, 'Incorrect Response Type: ' + interaction.type); + } + } + } + + if (this.lastErrorCode === 0) { + newChild = new _scorm2004_cmi.CMIInteractionsCorrectResponsesObject(); + } + } else if (foundFirstIndex && this.stringMatches(CMIElement, 'cmi\\.interactions\\.\\d+\\.objectives\\.\\d+')) { + newChild = new _scorm2004_cmi.CMIInteractionsObjectivesObject(); + } else if (!foundFirstIndex && this.stringMatches(CMIElement, 'cmi\\.interactions\\.\\d+')) { + newChild = new _scorm2004_cmi.CMIInteractionsObject(); + } else if (this.stringMatches(CMIElement, 'cmi\\.comments_from_learner\\.\\d+')) { + newChild = new _scorm2004_cmi.CMICommentsObject(); + } else if (this.stringMatches(CMIElement, 'cmi\\.comments_from_lms\\.\\d+')) { + newChild = new _scorm2004_cmi.CMICommentsObject(true); + } + + return newChild; + } + /** + * Checks for valid response types + * @param {object} response_type + * @param {any} value + * @param {string} interaction_type + */ + + }, { + key: "checkValidResponseType", + value: function checkValidResponseType(response_type, value, interaction_type) { + var nodes = []; + + if (response_type !== null && response_type !== void 0 && response_type.delimiter) { + nodes = String(value).split(response_type.delimiter); + } else { + nodes[0] = value; + } + + if (nodes.length > 0 && nodes.length <= response_type.max) { + this.checkCorrectResponseValue(interaction_type, nodes, value); + } else if (nodes.length > response_type.max) { + this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE, 'Data Model Element Pattern Too Long'); + } + } + /** + * Checks for duplicate 'choice' responses. + * @param {CMIInteractionsObject} interaction + * @param {any} value + */ + + }, { + key: "checkDuplicateChoiceResponse", + value: function checkDuplicateChoiceResponse(interaction, value) { + var interaction_count = interaction.correct_responses._count; + + if (interaction.type === 'choice') { + for (var i = 0; i < interaction_count && this.lastErrorCode === 0; i++) { + var response = interaction.correct_responses.childArray[i]; + + if (response.pattern === value) { + this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE); + } + } + } + } + /** + * Validate correct response. + * @param {string} CMIElement + * @param {*} value + */ + + }, { + key: "validateCorrectResponse", + value: function validateCorrectResponse(CMIElement, value) { + var parts = CMIElement.split('.'); + var index = Number(parts[2]); + var pattern_index = Number(parts[4]); + var interaction = this.cmi.interactions.childArray[index]; + var interaction_count = interaction.correct_responses._count; + this.checkDuplicateChoiceResponse(interaction, value); + var response_type = correct_responses[interaction.type]; + + if (typeof response_type.limit === 'undefined' || interaction_count <= response_type.limit) { + this.checkValidResponseType(response_type, value, interaction.type); + + if (this.lastErrorCode === 0 && (!response_type.duplicate || !this.checkDuplicatedPattern(interaction.correct_responses, pattern_index, value)) || this.lastErrorCode === 0 && value === '') {// do nothing, we want the inverse + } else { + if (this.lastErrorCode === 0) { + this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE, 'Data Model Element Pattern Already Exists'); + } + } + } else { + this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE, 'Data Model Element Collection Limit Reached'); + } + } + /** + * Gets a value from the CMI Object + * + * @param {string} CMIElement + * @return {*} + */ + + }, { + key: "getCMIValue", + value: function getCMIValue(CMIElement) { + return this._commonGetCMIValue('GetValue', true, CMIElement); + } + /** + * Returns the message that corresponds to errorNumber. + * + * @param {(string|number)} errorNumber + * @param {boolean} detail + * @return {string} + */ + + }, { + key: "getLmsErrorMessageDetails", + value: function getLmsErrorMessageDetails(errorNumber, detail) { + var basicMessage = ''; + var detailMessage = ''; // Set error number to string since inconsistent from modules if string or number + + errorNumber = String(errorNumber); + + if (scorm2004_constants.error_descriptions[errorNumber]) { + basicMessage = scorm2004_constants.error_descriptions[errorNumber].basicMessage; + detailMessage = scorm2004_constants.error_descriptions[errorNumber].detailMessage; + } + + return detail ? detailMessage : basicMessage; + } + /** + * Check to see if a correct_response value has been duplicated + * @param {CMIArray} correct_response + * @param {number} current_index + * @param {*} value + * @return {boolean} + */ + + }, { + key: "checkCorrectResponseValue", + value: + /** + * Checks for a valid correct_response value + * @param {string} interaction_type + * @param {Array} nodes + * @param {*} value + */ + function checkCorrectResponseValue(interaction_type, nodes, value) { + var response = correct_responses[interaction_type]; + var formatRegex = new RegExp(response.format); + + for (var i = 0; i < nodes.length && this.lastErrorCode === 0; i++) { + if (interaction_type.match('^(fill-in|long-fill-in|matching|performance|sequencing)$')) { + nodes[i] = this.removeCorrectResponsePrefixes(nodes[i]); + } + + if (response !== null && response !== void 0 && response.delimiter2) { + var values = nodes[i].split(response.delimiter2); + + if (values.length === 2) { + var matches = values[0].match(formatRegex); + + if (!matches) { + this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH); + } else { + if (!values[1].match(new RegExp(response.format2))) { + this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH); + } + } + } else { + this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH); + } + } else { + var _matches = nodes[i].match(formatRegex); + + if (!_matches && value !== '' || !_matches && interaction_type === 'true-false') { + this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH); + } else { + if (interaction_type === 'numeric' && nodes.length > 1) { + if (Number(nodes[0]) > Number(nodes[1])) { + this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH); + } + } else { + if (nodes[i] !== '' && response.unique) { + for (var j = 0; j < i && this.lastErrorCode === 0; j++) { + if (nodes[i] === nodes[j]) { + this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH); + } + } + } + } + } + } + } + } + /** + * Remove prefixes from correct_response + * @param {string} node + * @return {*} + */ + + }, { + key: "removeCorrectResponsePrefixes", + value: function removeCorrectResponsePrefixes(node) { + var seenOrder = false; + var seenCase = false; + var seenLang = false; + var prefixRegex = new RegExp('^({(lang|case_matters|order_matters)=([^}]+)})'); + var matches = node.match(prefixRegex); + var langMatches = null; + + while (matches) { + switch (matches[2]) { + case 'lang': + langMatches = node.match(scorm2004_regex.CMILangcr); + + if (langMatches) { + var lang = langMatches[3]; + + if (lang !== undefined && lang.length > 0) { + if (_language_constants["default"][lang.toLowerCase()] === undefined) { + this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH); + } + } + } + + seenLang = true; + break; + + case 'case_matters': + if (!seenLang && !seenOrder && !seenCase) { + if (matches[3] !== 'true' && matches[3] !== 'false') { + this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH); + } + } + + seenCase = true; + break; + + case 'order_matters': + if (!seenCase && !seenLang && !seenOrder) { + if (matches[3] !== 'true' && matches[3] !== 'false') { + this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH); + } + } + + seenOrder = true; + break; + + default: + break; + } + + node = node.substr(matches[1].length); + matches = node.match(prefixRegex); + } + + return node; + } + /** + * Replace the whole API with another + * @param {Scorm2004API} newAPI + */ + + }, { + key: "replaceWithAnotherScormAPI", + value: function replaceWithAnotherScormAPI(newAPI) { + // Data Model + this.cmi = newAPI.cmi; + this.adl = newAPI.adl; + } + /** + * Render the cmi object to the proper format for LMS commit + * + * @param {boolean} terminateCommit + * @return {object|Array} + */ + + }, { + key: "renderCommitCMI", + value: function renderCommitCMI(terminateCommit) { + var cmiExport = this.renderCMIToJSONObject(); + + if (terminateCommit) { + cmiExport.cmi.total_time = this.cmi.getCurrentTotalTime(); + } + + var result = []; + var flattened = Utilities.flatten(cmiExport); + + switch (this.settings.dataCommitFormat) { + case 'flattened': + return Utilities.flatten(cmiExport); + + case 'params': + for (var item in flattened) { + if ({}.hasOwnProperty.call(flattened, item)) { + result.push("".concat(item, "=").concat(flattened[item])); + } + } + + return result; + + case 'json': + default: + return cmiExport; + } + } + /** + * Attempts to store the data to the LMS + * + * @param {boolean} terminateCommit + * @return {string} + */ + + }, { + key: "storeData", + value: function storeData(terminateCommit) { + var _this$startingData, _this$startingData$ad, _this$startingData$ad2; + + if (terminateCommit) { + if (this.cmi.mode === 'normal') { + if (this.cmi.credit === 'credit') { + if (this.cmi.completion_threshold && this.cmi.progress_measure) { + if (this.cmi.progress_measure >= this.cmi.completion_threshold) { + console.debug('Setting Completion Status: Completed'); + this.cmi.completion_status = 'completed'; + } else { + console.debug('Setting Completion Status: Incomplete'); + this.cmi.completion_status = 'incomplete'; + } + } + + if (this.cmi.scaled_passing_score && this.cmi.score.scaled) { + if (this.cmi.score.scaled >= this.cmi.scaled_passing_score) { + console.debug('Setting Success Status: Passed'); + this.cmi.success_status = 'passed'; + } else { + console.debug('Setting Success Status: Failed'); + this.cmi.success_status = 'failed'; + } + } + } + } + } + + var navRequest = false; + + if (this.adl.nav.request !== ((_this$startingData = this.startingData) === null || _this$startingData === void 0 ? void 0 : (_this$startingData$ad = _this$startingData.adl) === null || _this$startingData$ad === void 0 ? void 0 : (_this$startingData$ad2 = _this$startingData$ad.nav) === null || _this$startingData$ad2 === void 0 ? void 0 : _this$startingData$ad2.request) && this.adl.nav.request !== '_none_') { + this.adl.nav.request = encodeURIComponent(this.adl.nav.request); + navRequest = true; + } + + var commitObject = this.renderCommitCMI(terminateCommit || this.settings.alwaysSendTotalTime); + + if (this.apiLogLevel === global_constants.LOG_LEVEL_DEBUG) { + console.debug('Commit (terminated: ' + (terminateCommit ? 'yes' : 'no') + '): '); + console.debug(commitObject); + } + + if (this.settings.lmsCommitUrl) { + var result = this.processHttpRequest(this.settings.lmsCommitUrl, commitObject, terminateCommit); // check if this is a sequencing call, and then call the necessary JS + + { + if (navRequest && result.navRequest !== undefined && result.navRequest !== '') { + Function("\"use strict\";(() => { ".concat(result.navRequest, " })()"))(); + } + } + return result; + } else { + return global_constants.SCORM_TRUE; + } + } + }]); + + return Scorm2004API; +}(_BaseAPI2["default"]); + +exports["default"] = Scorm2004API; + },{"./BaseAPI":3,"./cmi/scorm2004_cmi":9,"./constants/api_constants":10,"./constants/error_codes":11,"./constants/language_constants":12,"./constants/regex":13,"./constants/response_constants":14,"./utilities":17}],6:[function(require,module,exports){ -"use strict";function _typeof(e){"@babel/helpers - typeof";return(_typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function _interopRequireDefault(e){return e&&e.__esModule?e:{default:e}}function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var t=new WeakMap,i=new WeakMap;return(_getRequireWildcardCache=function(e){return e?i:t})(e)}function _interopRequireWildcard(e,t){if(!t&&e&&e.__esModule)return e;if(null===e||"object"!==_typeof(e)&&"function"!=typeof e)return{default:e};var i=_getRequireWildcardCache(t);if(i&&i.has(e))return i.get(e);var r={},s=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var a in e)if("default"!==a&&Object.prototype.hasOwnProperty.call(e,a)){var n=s?Object.getOwnPropertyDescriptor(e,a):null;n&&(n.get||n.set)?Object.defineProperty(r,a,n):r[a]=e[a]}return r.default=e,i&&i.set(e,r),r}function _classPrivateFieldSet(e,t,i){return _classApplyDescriptorSet(e,_classExtractFieldDescriptor(e,t,"set"),i),i}function _classApplyDescriptorSet(e,t,i){if(t.set)t.set.call(e,i);else{if(!t.writable)throw new TypeError("attempted to set read only private field");t.value=i}}function _classPrivateFieldGet(e,t){return _classApplyDescriptorGet(e,_classExtractFieldDescriptor(e,t,"get"))}function _classExtractFieldDescriptor(e,t,i){if(!t.has(e))throw new TypeError("attempted to "+i+" private field on non-instance");return t.get(e)}function _classApplyDescriptorGet(e,t){return t.get?t.get.call(e):t.value}function _classCallCheck(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function _defineProperties(e,t){for(var i=0;i=s[0]){if("*"===s[1]||e<=s[1])return!0;throw new i.prototype.constructor(r)}throw new i.prototype.constructor(r)}Object.defineProperty(exports,"__esModule",{value:!0}),exports.checkValidFormat=checkValidFormat,exports.checkValidRange=checkValidRange,exports.CMIArray=exports.CMIScore=exports.BaseCMI=void 0;var _api_constants=_interopRequireDefault(require("../constants/api_constants")),_error_codes=_interopRequireDefault(require("../constants/error_codes")),_regex=_interopRequireDefault(require("../constants/regex")),scorm12_constants=_api_constants.default.scorm12,scorm12_regex=_regex.default.scorm12,scorm12_error_codes=_error_codes.default.scorm12,_initialized=new WeakMap,_start_time=new WeakMap,BaseCMI=function(){function e(){if(_classCallCheck(this,e),_defineProperty(this,"jsonString",!1),_initialized.set(this,{writable:!0,value:!1}),_start_time.set(this,{writable:!0,value:void 0}),(this instanceof e?this.constructor:void 0)===e)throw new TypeError("Cannot construct BaseCMI instances directly")}return _createClass(e,[{key:"initialized",get:function(){return _classPrivateFieldGet(this,_initialized)}},{key:"start_time",get:function(){return _classPrivateFieldGet(this,_start_time)}},{key:"initialize",value:function(){_classPrivateFieldSet(this,_initialized,!0)}},{key:"setStartTime",value:function(){_classPrivateFieldSet(this,_start_time,(new Date).getTime())}}]),e}();exports.BaseCMI=BaseCMI;var _children2=new WeakMap,_score_range=new WeakMap,_invalid_error_code=new WeakMap,_invalid_type_code=new WeakMap,_invalid_range_code=new WeakMap,_decimal_regex=new WeakMap,_error_class=new WeakMap,_raw=new WeakMap,_min=new WeakMap,_max=new WeakMap,CMIScore=function(e){function t(e){var i,s=e.score_children,a=e.score_range,n=e.max,o=e.invalidErrorCode,l=e.invalidTypeCode,c=e.invalidRangeCode,_=e.decimalRegex,d=e.errorClass;return _classCallCheck(this,t),i=r.call(this),_children2.set(_assertThisInitialized(i),{writable:!0,value:void 0}),_score_range.set(_assertThisInitialized(i),{writable:!0,value:void 0}),_invalid_error_code.set(_assertThisInitialized(i),{writable:!0,value:void 0}),_invalid_type_code.set(_assertThisInitialized(i),{writable:!0,value:void 0}),_invalid_range_code.set(_assertThisInitialized(i),{writable:!0,value:void 0}),_decimal_regex.set(_assertThisInitialized(i),{writable:!0,value:void 0}),_error_class.set(_assertThisInitialized(i),{writable:!0,value:void 0}),_raw.set(_assertThisInitialized(i),{writable:!0,value:""}),_min.set(_assertThisInitialized(i),{writable:!0,value:""}),_max.set(_assertThisInitialized(i),{writable:!0,value:void 0}),_classPrivateFieldSet(_assertThisInitialized(i),_children2,s||scorm12_constants.score_children),_classPrivateFieldSet(_assertThisInitialized(i),_score_range,!!a&&scorm12_regex.score_range),_classPrivateFieldSet(_assertThisInitialized(i),_max,n||""===n?n:"100"),_classPrivateFieldSet(_assertThisInitialized(i),_invalid_error_code,o||scorm12_error_codes.INVALID_SET_VALUE),_classPrivateFieldSet(_assertThisInitialized(i),_invalid_type_code,l||scorm12_error_codes.TYPE_MISMATCH),_classPrivateFieldSet(_assertThisInitialized(i),_invalid_range_code,c||scorm12_error_codes.VALUE_OUT_OF_RANGE),_classPrivateFieldSet(_assertThisInitialized(i),_decimal_regex,_||scorm12_regex.CMIDecimal),_classPrivateFieldSet(_assertThisInitialized(i),_error_class,d),i}_inherits(t,e);var r=_createSuper(t);return _createClass(t,[{key:"_children",get:function(){return _classPrivateFieldGet(this,_children2)},set:function(e){throw new(_classPrivateFieldGet(this,_error_class).prototype.constructor)(_classPrivateFieldGet(this,_invalid_error_code))}},{key:"raw",get:function(){return _classPrivateFieldGet(this,_raw)},set:function(e){!checkValidFormat(e,_classPrivateFieldGet(this,_decimal_regex),_classPrivateFieldGet(this,_invalid_type_code),_classPrivateFieldGet(this,_error_class))||_classPrivateFieldGet(this,_score_range)&&!checkValidRange(e,_classPrivateFieldGet(this,_score_range),_classPrivateFieldGet(this,_invalid_range_code),_classPrivateFieldGet(this,_error_class))||_classPrivateFieldSet(this,_raw,e)}},{key:"min",get:function(){return _classPrivateFieldGet(this,_min)},set:function(e){!checkValidFormat(e,_classPrivateFieldGet(this,_decimal_regex),_classPrivateFieldGet(this,_invalid_type_code),_classPrivateFieldGet(this,_error_class))||_classPrivateFieldGet(this,_score_range)&&!checkValidRange(e,_classPrivateFieldGet(this,_score_range),_classPrivateFieldGet(this,_invalid_range_code),_classPrivateFieldGet(this,_error_class))||_classPrivateFieldSet(this,_min,e)}},{key:"max",get:function(){return _classPrivateFieldGet(this,_max)},set:function(e){!checkValidFormat(e,_classPrivateFieldGet(this,_decimal_regex),_classPrivateFieldGet(this,_invalid_type_code),_classPrivateFieldGet(this,_error_class))||_classPrivateFieldGet(this,_score_range)&&!checkValidRange(e,_classPrivateFieldGet(this,_score_range),_classPrivateFieldGet(this,_invalid_range_code),_classPrivateFieldGet(this,_error_class))||_classPrivateFieldSet(this,_max,e)}},{key:"toJSON",value:function(){this.jsonString=!0;var e={raw:this.raw,min:this.min,max:this.max};return delete this.jsonString,e}}]),t}(BaseCMI);exports.CMIScore=CMIScore;var _errorCode=new WeakMap,_errorClass=new WeakMap,_children3=new WeakMap,CMIArray=function(e){function t(e){var i,s=e.children,a=e.errorCode,n=e.errorClass;return _classCallCheck(this,t),i=r.call(this),_errorCode.set(_assertThisInitialized(i),{writable:!0,value:void 0}),_errorClass.set(_assertThisInitialized(i),{writable:!0,value:void 0}),_children3.set(_assertThisInitialized(i),{writable:!0,value:void 0}),_classPrivateFieldSet(_assertThisInitialized(i),_children3,s),_classPrivateFieldSet(_assertThisInitialized(i),_errorCode,a),_classPrivateFieldSet(_assertThisInitialized(i),_errorClass,n),i.childArray=[],i}_inherits(t,e);var r=_createSuper(t);return _createClass(t,[{key:"_children",get:function(){return _classPrivateFieldGet(this,_children3)},set:function(e){throw new(_classPrivateFieldGet(this,_errorClass).prototype.constructor)(_classPrivateFieldGet(this,_errorCode))}},{key:"_count",get:function(){return this.childArray.length},set:function(e){throw new(_classPrivateFieldGet(this,_errorClass).prototype.constructor)(_classPrivateFieldGet(this,_errorCode))}},{key:"toJSON",value:function(){this.jsonString=!0;for(var e={},t=0;t= ranges[0]) { + if (ranges[1] === '*' || value <= ranges[1]) { + return true; + } else { + throw new errorClass.prototype.constructor(errorCode); + } + } else { + throw new errorClass.prototype.constructor(errorCode); + } +} +/** + * Base class for API cmi objects + */ + + +var _initialized = new WeakMap(); + +var _start_time = new WeakMap(); + +var BaseCMI = /*#__PURE__*/function () { + /** + * Constructor for BaseCMI, just marks the class as abstract + */ + function BaseCMI() { + _classCallCheck(this, BaseCMI); + + _defineProperty(this, "jsonString", false); + + _initialized.set(this, { + writable: true, + value: false + }); + + _start_time.set(this, { + writable: true, + value: void 0 + }); + + if ((this instanceof BaseCMI ? this.constructor : void 0) === BaseCMI) { + throw new TypeError('Cannot construct BaseCMI instances directly'); + } + } + /** + * Getter for #initialized + * @return {boolean} + */ + + + _createClass(BaseCMI, [{ + key: "initialized", + get: function get() { + return _classPrivateFieldGet(this, _initialized); + } + /** + * Getter for #start_time + * @return {Number} + */ + + }, { + key: "start_time", + get: function get() { + return _classPrivateFieldGet(this, _start_time); + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + }, { + key: "initialize", + value: function initialize() { + _classPrivateFieldSet(this, _initialized, true); + } + /** + * Called when the player should override the 'session_time' provided by + * the module + */ + + }, { + key: "setStartTime", + value: function setStartTime() { + _classPrivateFieldSet(this, _start_time, new Date().getTime()); + } + }]); + + return BaseCMI; +}(); +/** + * Base class for cmi *.score objects + */ + + +exports.BaseCMI = BaseCMI; + +var _children2 = new WeakMap(); + +var _score_range = new WeakMap(); + +var _invalid_error_code = new WeakMap(); + +var _invalid_type_code = new WeakMap(); + +var _invalid_range_code = new WeakMap(); + +var _decimal_regex = new WeakMap(); + +var _error_class = new WeakMap(); + +var _raw = new WeakMap(); + +var _min = new WeakMap(); + +var _max = new WeakMap(); + +var CMIScore = /*#__PURE__*/function (_BaseCMI) { + _inherits(CMIScore, _BaseCMI); + + var _super = _createSuper(CMIScore); + + /** + * Constructor for *.score + * @param {string} score_children + * @param {string} score_range + * @param {string} max + * @param {number} invalidErrorCode + * @param {number} invalidTypeCode + * @param {number} invalidRangeCode + * @param {string} decimalRegex + * @param {class} errorClass + */ + function CMIScore(_ref) { + var _this; + + var score_children = _ref.score_children, + score_range = _ref.score_range, + max = _ref.max, + invalidErrorCode = _ref.invalidErrorCode, + invalidTypeCode = _ref.invalidTypeCode, + invalidRangeCode = _ref.invalidRangeCode, + decimalRegex = _ref.decimalRegex, + errorClass = _ref.errorClass; + + _classCallCheck(this, CMIScore); + + _this = _super.call(this); + + _children2.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _score_range.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _invalid_error_code.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _invalid_type_code.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _invalid_range_code.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _decimal_regex.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _error_class.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _raw.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _min.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _max.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _classPrivateFieldSet(_assertThisInitialized(_this), _children2, score_children || scorm12_constants.score_children); + + _classPrivateFieldSet(_assertThisInitialized(_this), _score_range, !score_range ? false : scorm12_regex.score_range); + + _classPrivateFieldSet(_assertThisInitialized(_this), _max, max || max === '' ? max : '100'); + + _classPrivateFieldSet(_assertThisInitialized(_this), _invalid_error_code, invalidErrorCode || scorm12_error_codes.INVALID_SET_VALUE); + + _classPrivateFieldSet(_assertThisInitialized(_this), _invalid_type_code, invalidTypeCode || scorm12_error_codes.TYPE_MISMATCH); + + _classPrivateFieldSet(_assertThisInitialized(_this), _invalid_range_code, invalidRangeCode || scorm12_error_codes.VALUE_OUT_OF_RANGE); + + _classPrivateFieldSet(_assertThisInitialized(_this), _decimal_regex, decimalRegex || scorm12_regex.CMIDecimal); + + _classPrivateFieldSet(_assertThisInitialized(_this), _error_class, errorClass); + + return _this; + } + + _createClass(CMIScore, [{ + key: "_children", + get: + /** + * Getter for _children + * @return {string} + * @private + */ + function get() { + return _classPrivateFieldGet(this, _children2); + } + /** + * Setter for _children. Just throws an error. + * @param {string} _children + * @private + */ + , + set: function set(_children) { + throw new (_classPrivateFieldGet(this, _error_class).prototype.constructor)(_classPrivateFieldGet(this, _invalid_error_code)); + } + /** + * Getter for #raw + * @return {string} + */ + + }, { + key: "raw", + get: function get() { + return _classPrivateFieldGet(this, _raw); + } + /** + * Setter for #raw + * @param {string} raw + */ + , + set: function set(raw) { + if (checkValidFormat(raw, _classPrivateFieldGet(this, _decimal_regex), _classPrivateFieldGet(this, _invalid_type_code), _classPrivateFieldGet(this, _error_class)) && (!_classPrivateFieldGet(this, _score_range) || checkValidRange(raw, _classPrivateFieldGet(this, _score_range), _classPrivateFieldGet(this, _invalid_range_code), _classPrivateFieldGet(this, _error_class)))) { + _classPrivateFieldSet(this, _raw, raw); + } + } + /** + * Getter for #min + * @return {string} + */ + + }, { + key: "min", + get: function get() { + return _classPrivateFieldGet(this, _min); + } + /** + * Setter for #min + * @param {string} min + */ + , + set: function set(min) { + if (checkValidFormat(min, _classPrivateFieldGet(this, _decimal_regex), _classPrivateFieldGet(this, _invalid_type_code), _classPrivateFieldGet(this, _error_class)) && (!_classPrivateFieldGet(this, _score_range) || checkValidRange(min, _classPrivateFieldGet(this, _score_range), _classPrivateFieldGet(this, _invalid_range_code), _classPrivateFieldGet(this, _error_class)))) { + _classPrivateFieldSet(this, _min, min); + } + } + /** + * Getter for #max + * @return {string} + */ + + }, { + key: "max", + get: function get() { + return _classPrivateFieldGet(this, _max); + } + /** + * Setter for #max + * @param {string} max + */ + , + set: function set(max) { + if (checkValidFormat(max, _classPrivateFieldGet(this, _decimal_regex), _classPrivateFieldGet(this, _invalid_type_code), _classPrivateFieldGet(this, _error_class)) && (!_classPrivateFieldGet(this, _score_range) || checkValidRange(max, _classPrivateFieldGet(this, _score_range), _classPrivateFieldGet(this, _invalid_range_code), _classPrivateFieldGet(this, _error_class)))) { + _classPrivateFieldSet(this, _max, max); + } + } + /** + * toJSON for *.score + * @return {{min: string, max: string, raw: string}} + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'raw': this.raw, + 'min': this.min, + 'max': this.max + }; + delete this.jsonString; + return result; + } + }]); + + return CMIScore; +}(BaseCMI); +/** + * Base class for cmi *.n objects + */ + + +exports.CMIScore = CMIScore; + +var _errorCode = new WeakMap(); + +var _errorClass = new WeakMap(); + +var _children3 = new WeakMap(); + +var CMIArray = /*#__PURE__*/function (_BaseCMI2) { + _inherits(CMIArray, _BaseCMI2); + + var _super2 = _createSuper(CMIArray); + + /** + * Constructor cmi *.n arrays + * @param {string} children + * @param {number} errorCode + * @param {class} errorClass + */ + function CMIArray(_ref2) { + var _this2; + + var children = _ref2.children, + errorCode = _ref2.errorCode, + errorClass = _ref2.errorClass; + + _classCallCheck(this, CMIArray); + + _this2 = _super2.call(this); + + _errorCode.set(_assertThisInitialized(_this2), { + writable: true, + value: void 0 + }); + + _errorClass.set(_assertThisInitialized(_this2), { + writable: true, + value: void 0 + }); + + _children3.set(_assertThisInitialized(_this2), { + writable: true, + value: void 0 + }); + + _classPrivateFieldSet(_assertThisInitialized(_this2), _children3, children); + + _classPrivateFieldSet(_assertThisInitialized(_this2), _errorCode, errorCode); + + _classPrivateFieldSet(_assertThisInitialized(_this2), _errorClass, errorClass); + + _this2.childArray = []; + return _this2; + } + + _createClass(CMIArray, [{ + key: "_children", + get: + /** + * Getter for _children + * @return {*} + */ + function get() { + return _classPrivateFieldGet(this, _children3); + } + /** + * Setter for _children. Just throws an error. + * @param {string} _children + */ + , + set: function set(_children) { + throw new (_classPrivateFieldGet(this, _errorClass).prototype.constructor)(_classPrivateFieldGet(this, _errorCode)); + } + /** + * Getter for _count + * @return {number} + */ + + }, { + key: "_count", + get: function get() { + return this.childArray.length; + } + /** + * Setter for _count. Just throws an error. + * @param {number} _count + */ + , + set: function set(_count) { + throw new (_classPrivateFieldGet(this, _errorClass).prototype.constructor)(_classPrivateFieldGet(this, _errorCode)); + } + /** + * toJSON for *.n arrays + * @return {object} + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = {}; + + for (var i = 0; i < this.childArray.length; i++) { + result[i + ''] = this.childArray[i]; + } + + delete this.jsonString; + return result; + } + }]); + + return CMIArray; +}(BaseCMI); + +exports.CMIArray = CMIArray; + },{"../constants/api_constants":10,"../constants/error_codes":11,"../constants/regex":13}],8:[function(require,module,exports){ -"use strict";function _typeof(e){"@babel/helpers - typeof";return(_typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function _getRequireWildcardCache(e){if("function"!=typeof WeakMap)return null;var t=new WeakMap,i=new WeakMap;return(_getRequireWildcardCache=function(e){return e?i:t})(e)}function _interopRequireWildcard(e,t){if(!t&&e&&e.__esModule)return e;if(null===e||"object"!==_typeof(e)&&"function"!=typeof e)return{default:e};var i=_getRequireWildcardCache(t);if(i&&i.has(e))return i.get(e);var r={},s=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var n in e)if("default"!==n&&Object.prototype.hasOwnProperty.call(e,n)){var a=s?Object.getOwnPropertyDescriptor(e,n):null;a&&(a.get||a.set)?Object.defineProperty(r,n,a):r[n]=e[n]}return r.default=e,i&&i.set(e,r),r}function _interopRequireDefault(e){return e&&e.__esModule?e:{default:e}}function _classCallCheck(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function _defineProperties(e,t){for(var i=0;i0&&t.length<=i.max)for(var r=new RegExp(i.format),s=0;s0&&void 0!==arguments[0]&&arguments[0];return _classCallCheck(this,t),e=i.call(this),_comment.set(_assertThisInitialized(e),{writable:!0,value:""}),_location2.set(_assertThisInitialized(e),{writable:!0,value:""}),_timestamp2.set(_assertThisInitialized(e),{writable:!0,value:""}),_readOnlyAfterInit.set(_assertThisInitialized(e),{writable:!0,value:void 0}),_classPrivateFieldSet(_assertThisInitialized(e),_comment,""),_classPrivateFieldSet(_assertThisInitialized(e),_location2,""),_classPrivateFieldSet(_assertThisInitialized(e),_timestamp2,""),_classPrivateFieldSet(_assertThisInitialized(e),_readOnlyAfterInit,r),e}_inherits(t,e);var i=_createSuper(t);return _createClass(t,[{key:"comment",get:function(){return _classPrivateFieldGet(this,_comment)},set:function(e){this.initialized&&_classPrivateFieldGet(this,_readOnlyAfterInit)?throwReadOnlyError():check2004ValidFormat(e,scorm2004_regex.CMILangString4000,!0)&&_classPrivateFieldSet(this,_comment,e)}},{key:"location",get:function(){return _classPrivateFieldGet(this,_location2)},set:function(e){this.initialized&&_classPrivateFieldGet(this,_readOnlyAfterInit)?throwReadOnlyError():check2004ValidFormat(e,scorm2004_regex.CMIString250)&&_classPrivateFieldSet(this,_location2,e)}},{key:"timestamp",get:function(){return _classPrivateFieldGet(this,_timestamp2)},set:function(e){this.initialized&&_classPrivateFieldGet(this,_readOnlyAfterInit)?throwReadOnlyError():check2004ValidFormat(e,scorm2004_regex.CMITime)&&_classPrivateFieldSet(this,_timestamp2,e)}},{key:"toJSON",value:function(){this.jsonString=!0;var e={comment:this.comment,location:this.location,timestamp:this.timestamp};return delete this.jsonString,e}}]),t}(_common.BaseCMI);exports.CMICommentsObject=CMICommentsObject;var _id3=new WeakMap,CMIInteractionsObjectivesObject=function(e){function t(){var e;return _classCallCheck(this,t),e=i.call(this),_id3.set(_assertThisInitialized(e),{writable:!0,value:""}),e}_inherits(t,e);var i=_createSuper(t);return _createClass(t,[{key:"id",get:function(){return _classPrivateFieldGet(this,_id3)},set:function(e){check2004ValidFormat(e,scorm2004_regex.CMILongIdentifier)&&_classPrivateFieldSet(this,_id3,e)}},{key:"toJSON",value:function(){this.jsonString=!0;var e={id:this.id};return delete this.jsonString,e}}]),t}(_common.BaseCMI);exports.CMIInteractionsObjectivesObject=CMIInteractionsObjectivesObject;var _pattern=new WeakMap,CMIInteractionsCorrectResponsesObject=function(e){function t(){var e;return _classCallCheck(this,t),e=i.call(this),_pattern.set(_assertThisInitialized(e),{writable:!0,value:""}),e}_inherits(t,e);var i=_createSuper(t);return _createClass(t,[{key:"pattern",get:function(){return _classPrivateFieldGet(this,_pattern)},set:function(e){check2004ValidFormat(e,scorm2004_regex.CMIFeedback)&&_classPrivateFieldSet(this,_pattern,e)}},{key:"toJSON",value:function(){this.jsonString=!0;var e={pattern:this.pattern};return delete this.jsonString,e}}]),t}(_common.BaseCMI);exports.CMIInteractionsCorrectResponsesObject=CMIInteractionsCorrectResponsesObject;var ADL=function(e){function t(){var e;return _classCallCheck(this,t),e=i.call(this),e.nav=new ADLNav,e}_inherits(t,e);var i=_createSuper(t);return _createClass(t,[{key:"initialize",value:function(){var e;_get(_getPrototypeOf(t.prototype),"initialize",this).call(this),null===(e=this.nav)||void 0===e||e.initialize()}},{key:"toJSON",value:function(){this.jsonString=!0;var e={nav:this.nav};return delete this.jsonString,e}}]),t}(_common.BaseCMI);exports.ADL=ADL;var _request=new WeakMap,ADLNav=function(e){function t(){var e;return _classCallCheck(this,t),e=i.call(this),_request.set(_assertThisInitialized(e),{writable:!0,value:"_none_"}),e.request_valid=new ADLNavRequestValid,e}_inherits(t,e);var i=_createSuper(t);return _createClass(t,[{key:"initialize",value:function(){var e;_get(_getPrototypeOf(t.prototype),"initialize",this).call(this),null===(e=this.request_valid)||void 0===e||e.initialize()}},{key:"request",get:function(){return _classPrivateFieldGet(this,_request)},set:function(e){check2004ValidFormat(e,scorm2004_regex.NAVEvent)&&_classPrivateFieldSet(this,_request,e)}},{key:"toJSON",value:function(){this.jsonString=!0;var e={request:this.request};return delete this.jsonString,e}}]),t}(_common.BaseCMI),_continue=new WeakMap,_previous=new WeakMap,ADLNavRequestValid=function(e){function t(){var e;return _classCallCheck(this,t),e=i.call(this),_continue.set(_assertThisInitialized(e),{writable:!0,value:"unknown"}),_previous.set(_assertThisInitialized(e),{writable:!0,value:"unknown"}),_defineProperty(_assertThisInitialized(e),"choice",function(){function e(){_classCallCheck(this,e),_defineProperty(this,"_isTargetValid",function(e){return"unknown"})}return e}()),_defineProperty(_assertThisInitialized(e),"jump",function(){function e(){_classCallCheck(this,e),_defineProperty(this,"_isTargetValid",function(e){return"unknown"})}return e}()),e}_inherits(t,e);var i=_createSuper(t);return _createClass(t,[{key:"continue",get:function(){return _classPrivateFieldGet(this,_continue)},set:function(e){throwReadOnlyError()}},{key:"previous",get:function(){return _classPrivateFieldGet(this,_previous)},set:function(e){throwReadOnlyError()}},{key:"toJSON",value:function(){this.jsonString=!0;var e={previous:this.previous,continue:this.continue};return delete this.jsonString,e}}]),t}(_common.BaseCMI); +"use strict"; + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.ADL = exports.CMIInteractionsCorrectResponsesObject = exports.CMIInteractionsObjectivesObject = exports.CMICommentsObject = exports.CMIObjectivesObject = exports.CMIInteractionsObject = exports.CMI = void 0; + +var _common = require("./common"); + +var _api_constants = _interopRequireDefault(require("../constants/api_constants")); + +var _regex = _interopRequireDefault(require("../constants/regex")); + +var _error_codes = _interopRequireDefault(require("../constants/error_codes")); + +var _response_constants = _interopRequireDefault(require("../constants/response_constants")); + +var _exceptions = require("../exceptions"); + +var Util = _interopRequireWildcard(require("../utilities")); + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); } + +function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; } + +function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } } + +function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); } + +function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); } + +function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +var scorm2004_constants = _api_constants["default"].scorm2004; +var scorm2004_error_codes = _error_codes["default"].scorm2004; +var learner_responses = _response_constants["default"].learner; +var scorm2004_regex = _regex["default"].scorm2004; +/** + * Helper method for throwing Read Only error + */ + +function throwReadOnlyError() { + throw new _exceptions.Scorm2004ValidationError(scorm2004_error_codes.READ_ONLY_ELEMENT); +} +/** + * Helper method for throwing Write Only error + */ + + +function throwWriteOnlyError() { + throw new _exceptions.Scorm2004ValidationError(scorm2004_error_codes.WRITE_ONLY_ELEMENT); +} +/** + * Helper method for throwing Type Mismatch error + */ + + +function throwTypeMismatchError() { + throw new _exceptions.Scorm2004ValidationError(scorm2004_error_codes.TYPE_MISMATCH); +} +/** + * Helper method for throwing Dependency Not Established error + */ + + +function throwDependencyNotEstablishedError() { + throw new _exceptions.Scorm2004ValidationError(scorm2004_error_codes.DEPENDENCY_NOT_ESTABLISHED); +} +/** + * Helper method for throwing Dependency Not Established error + */ + + +function throwGeneralSetError() { + throw new _exceptions.Scorm2004ValidationError(scorm2004_error_codes.GENERAL_SET_FAILURE); +} +/** + * Helper method, no reason to have to pass the same error codes every time + * @param {*} value + * @param {string} regexPattern + * @param {boolean} allowEmptyString + * @return {boolean} + */ + + +function check2004ValidFormat(value, regexPattern, allowEmptyString) { + return (0, _common.checkValidFormat)(value, regexPattern, scorm2004_error_codes.TYPE_MISMATCH, _exceptions.Scorm2004ValidationError, allowEmptyString); +} +/** + * Helper method, no reason to have to pass the same error codes every time + * @param {*} value + * @param {string} rangePattern + * @return {boolean} + */ + + +function check2004ValidRange(value, rangePattern) { + return (0, _common.checkValidRange)(value, rangePattern, scorm2004_error_codes.VALUE_OUT_OF_RANGE, _exceptions.Scorm2004ValidationError); +} +/** + * Class representing cmi object for SCORM 2004 + */ + + +var _version2 = new WeakMap(); + +var _children2 = new WeakMap(); + +var _completion_status = new WeakMap(); + +var _completion_threshold = new WeakMap(); + +var _credit = new WeakMap(); + +var _entry = new WeakMap(); + +var _exit = new WeakMap(); + +var _launch_data = new WeakMap(); + +var _learner_id = new WeakMap(); + +var _learner_name = new WeakMap(); + +var _location = new WeakMap(); + +var _max_time_allowed = new WeakMap(); + +var _mode = new WeakMap(); + +var _progress_measure = new WeakMap(); + +var _scaled_passing_score = new WeakMap(); + +var _session_time = new WeakMap(); + +var _success_status = new WeakMap(); + +var _suspend_data = new WeakMap(); + +var _time_limit_action = new WeakMap(); + +var _total_time = new WeakMap(); + +var CMI = /*#__PURE__*/function (_BaseCMI) { + _inherits(CMI, _BaseCMI); + + var _super = _createSuper(CMI); + + /** + * Constructor for the SCORM 2004 cmi object + * @param {boolean} initialized + */ + function CMI(initialized) { + var _this; + + _classCallCheck(this, CMI); + + _this = _super.call(this); + + _version2.set(_assertThisInitialized(_this), { + writable: true, + value: '1.0' + }); + + _children2.set(_assertThisInitialized(_this), { + writable: true, + value: scorm2004_constants.cmi_children + }); + + _completion_status.set(_assertThisInitialized(_this), { + writable: true, + value: 'unknown' + }); + + _completion_threshold.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _credit.set(_assertThisInitialized(_this), { + writable: true, + value: 'credit' + }); + + _entry.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _exit.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _launch_data.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _learner_id.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _learner_name.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _location.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _max_time_allowed.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _mode.set(_assertThisInitialized(_this), { + writable: true, + value: 'normal' + }); + + _progress_measure.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _scaled_passing_score.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _session_time.set(_assertThisInitialized(_this), { + writable: true, + value: 'PT0H0M0S' + }); + + _success_status.set(_assertThisInitialized(_this), { + writable: true, + value: 'unknown' + }); + + _suspend_data.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _time_limit_action.set(_assertThisInitialized(_this), { + writable: true, + value: 'continue,no message' + }); + + _total_time.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _this.learner_preference = new CMILearnerPreference(); + _this.score = new Scorm2004CMIScore(); + _this.comments_from_learner = new CMICommentsFromLearner(); + _this.comments_from_lms = new CMICommentsFromLMS(); + _this.interactions = new CMIInteractions(); + _this.objectives = new CMIObjectives(); + if (initialized) _this.initialize(); + return _this; + } + + _createClass(CMI, [{ + key: "initialize", + value: + /** + * Called when the API has been initialized after the CMI has been created + */ + function initialize() { + var _this$learner_prefere, _this$score, _this$comments_from_l, _this$comments_from_l2, _this$interactions, _this$objectives; + + _get(_getPrototypeOf(CMI.prototype), "initialize", this).call(this); + + (_this$learner_prefere = this.learner_preference) === null || _this$learner_prefere === void 0 ? void 0 : _this$learner_prefere.initialize(); + (_this$score = this.score) === null || _this$score === void 0 ? void 0 : _this$score.initialize(); + (_this$comments_from_l = this.comments_from_learner) === null || _this$comments_from_l === void 0 ? void 0 : _this$comments_from_l.initialize(); + (_this$comments_from_l2 = this.comments_from_lms) === null || _this$comments_from_l2 === void 0 ? void 0 : _this$comments_from_l2.initialize(); + (_this$interactions = this.interactions) === null || _this$interactions === void 0 ? void 0 : _this$interactions.initialize(); + (_this$objectives = this.objectives) === null || _this$objectives === void 0 ? void 0 : _this$objectives.initialize(); + } + /** + * Getter for #_version + * @return {string} + * @private + */ + + }, { + key: "_version", + get: function get() { + return _classPrivateFieldGet(this, _version2); + } + /** + * Setter for #_version. Just throws an error. + * @param {string} _version + * @private + */ + , + set: function set(_version) { + throwReadOnlyError(); + } + /** + * Getter for #_children + * @return {string} + * @private + */ + + }, { + key: "_children", + get: function get() { + return _classPrivateFieldGet(this, _children2); + } + /** + * Setter for #_children. Just throws an error. + * @param {number} _children + * @private + */ + , + set: function set(_children) { + throwReadOnlyError(); + } + /** + * Getter for #completion_status + * @return {string} + */ + + }, { + key: "completion_status", + get: function get() { + return _classPrivateFieldGet(this, _completion_status); + } + /** + * Setter for #completion_status + * @param {string} completion_status + */ + , + set: function set(completion_status) { + if (check2004ValidFormat(completion_status, scorm2004_regex.CMICStatus)) { + _classPrivateFieldSet(this, _completion_status, completion_status); + } + } + /** + * Getter for #completion_threshold + * @return {string} + */ + + }, { + key: "completion_threshold", + get: function get() { + return _classPrivateFieldGet(this, _completion_threshold); + } + /** + * Setter for #completion_threshold. Can only be called before initialization. + * @param {string} completion_threshold + */ + , + set: function set(completion_threshold) { + !this.initialized ? _classPrivateFieldSet(this, _completion_threshold, completion_threshold) : throwReadOnlyError(); + } + /** + * Setter for #credit + * @return {string} + */ + + }, { + key: "credit", + get: function get() { + return _classPrivateFieldGet(this, _credit); + } + /** + * Setter for #credit. Can only be called before initialization. + * @param {string} credit + */ + , + set: function set(credit) { + !this.initialized ? _classPrivateFieldSet(this, _credit, credit) : throwReadOnlyError(); + } + /** + * Getter for #entry + * @return {string} + */ + + }, { + key: "entry", + get: function get() { + return _classPrivateFieldGet(this, _entry); + } + /** + * Setter for #entry. Can only be called before initialization. + * @param {string} entry + */ + , + set: function set(entry) { + !this.initialized ? _classPrivateFieldSet(this, _entry, entry) : throwReadOnlyError(); + } + /** + * Getter for #exit. Should only be called during JSON export. + * @return {string} + */ + + }, { + key: "exit", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _exit); + } + /** + * Getter for #exit + * @param {string} exit + */ + , + set: function set(exit) { + if (check2004ValidFormat(exit, scorm2004_regex.CMIExit, true)) { + _classPrivateFieldSet(this, _exit, exit); + } + } + /** + * Getter for #launch_data + * @return {string} + */ + + }, { + key: "launch_data", + get: function get() { + return _classPrivateFieldGet(this, _launch_data); + } + /** + * Setter for #launch_data. Can only be called before initialization. + * @param {string} launch_data + */ + , + set: function set(launch_data) { + !this.initialized ? _classPrivateFieldSet(this, _launch_data, launch_data) : throwReadOnlyError(); + } + /** + * Getter for #learner_id + * @return {string} + */ + + }, { + key: "learner_id", + get: function get() { + return _classPrivateFieldGet(this, _learner_id); + } + /** + * Setter for #learner_id. Can only be called before initialization. + * @param {string} learner_id + */ + , + set: function set(learner_id) { + !this.initialized ? _classPrivateFieldSet(this, _learner_id, learner_id) : throwReadOnlyError(); + } + /** + * Getter for #learner_name + * @return {string} + */ + + }, { + key: "learner_name", + get: function get() { + return _classPrivateFieldGet(this, _learner_name); + } + /** + * Setter for #learner_name. Can only be called before initialization. + * @param {string} learner_name + */ + , + set: function set(learner_name) { + !this.initialized ? _classPrivateFieldSet(this, _learner_name, learner_name) : throwReadOnlyError(); + } + /** + * Getter for #location + * @return {string} + */ + + }, { + key: "location", + get: function get() { + return _classPrivateFieldGet(this, _location); + } + /** + * Setter for #location + * @param {string} location + */ + , + set: function set(location) { + if (check2004ValidFormat(location, scorm2004_regex.CMIString1000)) { + _classPrivateFieldSet(this, _location, location); + } + } + /** + * Getter for #max_time_allowed + * @return {string} + */ + + }, { + key: "max_time_allowed", + get: function get() { + return _classPrivateFieldGet(this, _max_time_allowed); + } + /** + * Setter for #max_time_allowed. Can only be called before initialization. + * @param {string} max_time_allowed + */ + , + set: function set(max_time_allowed) { + !this.initialized ? _classPrivateFieldSet(this, _max_time_allowed, max_time_allowed) : throwReadOnlyError(); + } + /** + * Getter for #mode + * @return {string} + */ + + }, { + key: "mode", + get: function get() { + return _classPrivateFieldGet(this, _mode); + } + /** + * Setter for #mode. Can only be called before initialization. + * @param {string} mode + */ + , + set: function set(mode) { + !this.initialized ? _classPrivateFieldSet(this, _mode, mode) : throwReadOnlyError(); + } + /** + * Getter for #progress_measure + * @return {string} + */ + + }, { + key: "progress_measure", + get: function get() { + return _classPrivateFieldGet(this, _progress_measure); + } + /** + * Setter for #progress_measure + * @param {string} progress_measure + */ + , + set: function set(progress_measure) { + if (check2004ValidFormat(progress_measure, scorm2004_regex.CMIDecimal) && check2004ValidRange(progress_measure, scorm2004_regex.progress_range)) { + _classPrivateFieldSet(this, _progress_measure, progress_measure); + } + } + /** + * Getter for #scaled_passing_score + * @return {string} + */ + + }, { + key: "scaled_passing_score", + get: function get() { + return _classPrivateFieldGet(this, _scaled_passing_score); + } + /** + * Setter for #scaled_passing_score. Can only be called before initialization. + * @param {string} scaled_passing_score + */ + , + set: function set(scaled_passing_score) { + !this.initialized ? _classPrivateFieldSet(this, _scaled_passing_score, scaled_passing_score) : throwReadOnlyError(); + } + /** + * Getter for #session_time. Should only be called during JSON export. + * @return {string} + */ + + }, { + key: "session_time", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _session_time); + } + /** + * Setter for #session_time + * @param {string} session_time + */ + , + set: function set(session_time) { + if (check2004ValidFormat(session_time, scorm2004_regex.CMITimespan)) { + _classPrivateFieldSet(this, _session_time, session_time); + } + } + /** + * Getter for #success_status + * @return {string} + */ + + }, { + key: "success_status", + get: function get() { + return _classPrivateFieldGet(this, _success_status); + } + /** + * Setter for #success_status + * @param {string} success_status + */ + , + set: function set(success_status) { + if (check2004ValidFormat(success_status, scorm2004_regex.CMISStatus)) { + _classPrivateFieldSet(this, _success_status, success_status); + } + } + /** + * Getter for #suspend_data + * @return {string} + */ + + }, { + key: "suspend_data", + get: function get() { + return _classPrivateFieldGet(this, _suspend_data); + } + /** + * Setter for #suspend_data + * @param {string} suspend_data + */ + , + set: function set(suspend_data) { + if (check2004ValidFormat(suspend_data, scorm2004_regex.CMIString64000, true)) { + _classPrivateFieldSet(this, _suspend_data, suspend_data); + } + } + /** + * Getter for #time_limit_action + * @return {string} + */ + + }, { + key: "time_limit_action", + get: function get() { + return _classPrivateFieldGet(this, _time_limit_action); + } + /** + * Setter for #time_limit_action. Can only be called before initialization. + * @param {string} time_limit_action + */ + , + set: function set(time_limit_action) { + !this.initialized ? _classPrivateFieldSet(this, _time_limit_action, time_limit_action) : throwReadOnlyError(); + } + /** + * Getter for #total_time + * @return {string} + */ + + }, { + key: "total_time", + get: function get() { + return _classPrivateFieldGet(this, _total_time); + } + /** + * Setter for #total_time. Can only be called before initialization. + * @param {string} total_time + */ + , + set: function set(total_time) { + !this.initialized ? _classPrivateFieldSet(this, _total_time, total_time) : throwReadOnlyError(); + } + /** + * Adds the current session time to the existing total time. + * + * @return {string} ISO8601 Duration + */ + + }, { + key: "getCurrentTotalTime", + value: function getCurrentTotalTime() { + var sessionTime = _classPrivateFieldGet(this, _session_time); + + var startTime = this.start_time; + + if (typeof startTime !== 'undefined' && startTime !== null) { + var seconds = new Date().getTime() - startTime; + sessionTime = Util.getSecondsAsISODuration(seconds / 1000); + } + + return Util.addTwoDurations(_classPrivateFieldGet(this, _total_time), sessionTime, scorm2004_regex.CMITimespan); + } + /** + * toJSON for cmi + * + * @return { + * { + * comments_from_learner: CMICommentsFromLearner, + * comments_from_lms: CMICommentsFromLMS, + * completion_status: string, + * completion_threshold: string, + * credit: string, + * entry: string, + * exit: string, + * interactions: CMIInteractions, + * launch_data: string, + * learner_id: string, + * learner_name: string, + * learner_preference: CMILearnerPreference, + * location: string, + * max_time_allowed: string, + * mode: string, + * objectives: CMIObjectives, + * progress_measure: string, + * scaled_passing_score: string, + * score: Scorm2004CMIScore, + * session_time: string, + * success_status: string, + * suspend_data: string, + * time_limit_action: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'comments_from_learner': this.comments_from_learner, + 'comments_from_lms': this.comments_from_lms, + 'completion_status': this.completion_status, + 'completion_threshold': this.completion_threshold, + 'credit': this.credit, + 'entry': this.entry, + 'exit': this.exit, + 'interactions': this.interactions, + 'launch_data': this.launch_data, + 'learner_id': this.learner_id, + 'learner_name': this.learner_name, + 'learner_preference': this.learner_preference, + 'location': this.location, + 'max_time_allowed': this.max_time_allowed, + 'mode': this.mode, + 'objectives': this.objectives, + 'progress_measure': this.progress_measure, + 'scaled_passing_score': this.scaled_passing_score, + 'score': this.score, + 'session_time': this.session_time, + 'success_status': this.success_status, + 'suspend_data': this.suspend_data, + 'time_limit_action': this.time_limit_action + }; + delete this.jsonString; + return result; + } + }]); + + return CMI; +}(_common.BaseCMI); +/** + * Class for SCORM 2004's cmi.learner_preference object + */ + + +exports.CMI = CMI; + +var _children3 = new WeakMap(); + +var _audio_level = new WeakMap(); + +var _language = new WeakMap(); + +var _delivery_speed = new WeakMap(); + +var _audio_captioning = new WeakMap(); + +var CMILearnerPreference = /*#__PURE__*/function (_BaseCMI2) { + _inherits(CMILearnerPreference, _BaseCMI2); + + var _super2 = _createSuper(CMILearnerPreference); + + /** + * Constructor for cmi.learner_preference + */ + function CMILearnerPreference() { + var _this2; + + _classCallCheck(this, CMILearnerPreference); + + _this2 = _super2.call(this); + + _children3.set(_assertThisInitialized(_this2), { + writable: true, + value: scorm2004_constants.student_preference_children + }); + + _audio_level.set(_assertThisInitialized(_this2), { + writable: true, + value: '1' + }); + + _language.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _delivery_speed.set(_assertThisInitialized(_this2), { + writable: true, + value: '1' + }); + + _audio_captioning.set(_assertThisInitialized(_this2), { + writable: true, + value: '0' + }); + + return _this2; + } + /** + * Getter for #_children + * @return {string} + * @private + */ + + + _createClass(CMILearnerPreference, [{ + key: "_children", + get: function get() { + return _classPrivateFieldGet(this, _children3); + } + /** + * Setter for #_children. Just throws an error. + * @param {string} _children + * @private + */ + , + set: function set(_children) { + throwReadOnlyError(); + } + /** + * Getter for #audio_level + * @return {string} + */ + + }, { + key: "audio_level", + get: function get() { + return _classPrivateFieldGet(this, _audio_level); + } + /** + * Setter for #audio_level + * @param {string} audio_level + */ + , + set: function set(audio_level) { + if (check2004ValidFormat(audio_level, scorm2004_regex.CMIDecimal) && check2004ValidRange(audio_level, scorm2004_regex.audio_range)) { + _classPrivateFieldSet(this, _audio_level, audio_level); + } + } + /** + * Getter for #language + * @return {string} + */ + + }, { + key: "language", + get: function get() { + return _classPrivateFieldGet(this, _language); + } + /** + * Setter for #language + * @param {string} language + */ + , + set: function set(language) { + if (check2004ValidFormat(language, scorm2004_regex.CMILang)) { + _classPrivateFieldSet(this, _language, language); + } + } + /** + * Getter for #delivery_speed + * @return {string} + */ + + }, { + key: "delivery_speed", + get: function get() { + return _classPrivateFieldGet(this, _delivery_speed); + } + /** + * Setter for #delivery_speed + * @param {string} delivery_speed + */ + , + set: function set(delivery_speed) { + if (check2004ValidFormat(delivery_speed, scorm2004_regex.CMIDecimal) && check2004ValidRange(delivery_speed, scorm2004_regex.speed_range)) { + _classPrivateFieldSet(this, _delivery_speed, delivery_speed); + } + } + /** + * Getter for #audio_captioning + * @return {string} + */ + + }, { + key: "audio_captioning", + get: function get() { + return _classPrivateFieldGet(this, _audio_captioning); + } + /** + * Setter for #audio_captioning + * @param {string} audio_captioning + */ + , + set: function set(audio_captioning) { + if (check2004ValidFormat(audio_captioning, scorm2004_regex.CMISInteger) && check2004ValidRange(audio_captioning, scorm2004_regex.text_range)) { + _classPrivateFieldSet(this, _audio_captioning, audio_captioning); + } + } + /** + * toJSON for cmi.learner_preference + * + * @return { + * { + * audio_level: string, + * language: string, + * delivery_speed: string, + * audio_captioning: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'audio_level': this.audio_level, + 'language': this.language, + 'delivery_speed': this.delivery_speed, + 'audio_captioning': this.audio_captioning + }; + delete this.jsonString; + return result; + } + }]); + + return CMILearnerPreference; +}(_common.BaseCMI); +/** + * Class representing SCORM 2004's cmi.interactions object + */ + + +var CMIInteractions = /*#__PURE__*/function (_CMIArray) { + _inherits(CMIInteractions, _CMIArray); + + var _super3 = _createSuper(CMIInteractions); + + /** + * Constructor for cmi.objectives Array + */ + function CMIInteractions() { + _classCallCheck(this, CMIInteractions); + + return _super3.call(this, { + children: scorm2004_constants.interactions_children, + errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT, + errorClass: _exceptions.Scorm2004ValidationError + }); + } + + return CMIInteractions; +}(_common.CMIArray); +/** + * Class representing SCORM 2004's cmi.objectives object + */ + + +var CMIObjectives = /*#__PURE__*/function (_CMIArray2) { + _inherits(CMIObjectives, _CMIArray2); + + var _super4 = _createSuper(CMIObjectives); + + /** + * Constructor for cmi.objectives Array + */ + function CMIObjectives() { + _classCallCheck(this, CMIObjectives); + + return _super4.call(this, { + children: scorm2004_constants.objectives_children, + errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT, + errorClass: _exceptions.Scorm2004ValidationError + }); + } + + return CMIObjectives; +}(_common.CMIArray); +/** + * Class representing SCORM 2004's cmi.comments_from_lms object + */ + + +var CMICommentsFromLMS = /*#__PURE__*/function (_CMIArray3) { + _inherits(CMICommentsFromLMS, _CMIArray3); + + var _super5 = _createSuper(CMICommentsFromLMS); + + /** + * Constructor for cmi.comments_from_lms Array + */ + function CMICommentsFromLMS() { + _classCallCheck(this, CMICommentsFromLMS); + + return _super5.call(this, { + children: scorm2004_constants.comments_children, + errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT, + errorClass: _exceptions.Scorm2004ValidationError + }); + } + + return CMICommentsFromLMS; +}(_common.CMIArray); +/** + * Class representing SCORM 2004's cmi.comments_from_learner object + */ + + +var CMICommentsFromLearner = /*#__PURE__*/function (_CMIArray4) { + _inherits(CMICommentsFromLearner, _CMIArray4); + + var _super6 = _createSuper(CMICommentsFromLearner); + + /** + * Constructor for cmi.comments_from_learner Array + */ + function CMICommentsFromLearner() { + _classCallCheck(this, CMICommentsFromLearner); + + return _super6.call(this, { + children: scorm2004_constants.comments_children, + errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT, + errorClass: _exceptions.Scorm2004ValidationError + }); + } + + return CMICommentsFromLearner; +}(_common.CMIArray); +/** + * Class for SCORM 2004's cmi.interaction.n object + */ + + +var _id = new WeakMap(); + +var _type = new WeakMap(); + +var _timestamp = new WeakMap(); + +var _weighting = new WeakMap(); + +var _learner_response = new WeakMap(); + +var _result = new WeakMap(); + +var _latency = new WeakMap(); + +var _description = new WeakMap(); + +var CMIInteractionsObject = /*#__PURE__*/function (_BaseCMI3) { + _inherits(CMIInteractionsObject, _BaseCMI3); + + var _super7 = _createSuper(CMIInteractionsObject); + + /** + * Constructor for cmi.interaction.n + */ + function CMIInteractionsObject() { + var _this3; + + _classCallCheck(this, CMIInteractionsObject); + + _this3 = _super7.call(this); + + _id.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _type.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _timestamp.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _weighting.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _learner_response.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _result.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _latency.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _description.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _this3.objectives = new _common.CMIArray({ + errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT, + errorClass: _exceptions.Scorm2004ValidationError, + children: scorm2004_constants.objectives_children + }); + _this3.correct_responses = new _common.CMIArray({ + errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT, + errorClass: _exceptions.Scorm2004ValidationError, + children: scorm2004_constants.correct_responses_children + }); + return _this3; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(CMIInteractionsObject, [{ + key: "initialize", + value: function initialize() { + var _this$objectives2, _this$correct_respons; + + _get(_getPrototypeOf(CMIInteractionsObject.prototype), "initialize", this).call(this); + + (_this$objectives2 = this.objectives) === null || _this$objectives2 === void 0 ? void 0 : _this$objectives2.initialize(); + (_this$correct_respons = this.correct_responses) === null || _this$correct_respons === void 0 ? void 0 : _this$correct_respons.initialize(); + } + /** + * Getter for #id + * @return {string} + */ + + }, { + key: "id", + get: function get() { + return _classPrivateFieldGet(this, _id); + } + /** + * Setter for #id + * @param {string} id + */ + , + set: function set(id) { + if (check2004ValidFormat(id, scorm2004_regex.CMILongIdentifier)) { + _classPrivateFieldSet(this, _id, id); + } + } + /** + * Getter for #type + * @return {string} + */ + + }, { + key: "type", + get: function get() { + return _classPrivateFieldGet(this, _type); + } + /** + * Setter for #type + * @param {string} type + */ + , + set: function set(type) { + if (this.initialized && _classPrivateFieldGet(this, _id) === '') { + throwDependencyNotEstablishedError(); + } else { + if (check2004ValidFormat(type, scorm2004_regex.CMIType)) { + _classPrivateFieldSet(this, _type, type); + } + } + } + /** + * Getter for #timestamp + * @return {string} + */ + + }, { + key: "timestamp", + get: function get() { + return _classPrivateFieldGet(this, _timestamp); + } + /** + * Setter for #timestamp + * @param {string} timestamp + */ + , + set: function set(timestamp) { + if (this.initialized && _classPrivateFieldGet(this, _id) === '') { + throwDependencyNotEstablishedError(); + } else { + if (check2004ValidFormat(timestamp, scorm2004_regex.CMITime)) { + _classPrivateFieldSet(this, _timestamp, timestamp); + } + } + } + /** + * Getter for #weighting + * @return {string} + */ + + }, { + key: "weighting", + get: function get() { + return _classPrivateFieldGet(this, _weighting); + } + /** + * Setter for #weighting + * @param {string} weighting + */ + , + set: function set(weighting) { + if (this.initialized && _classPrivateFieldGet(this, _id) === '') { + throwDependencyNotEstablishedError(); + } else { + if (check2004ValidFormat(weighting, scorm2004_regex.CMIDecimal)) { + _classPrivateFieldSet(this, _weighting, weighting); + } + } + } + /** + * Getter for #learner_response + * @return {string} + */ + + }, { + key: "learner_response", + get: function get() { + return _classPrivateFieldGet(this, _learner_response); + } + /** + * Setter for #learner_response. Does type validation to make sure response + * matches SCORM 2004's spec + * @param {string} learner_response + */ + , + set: function set(learner_response) { + if (this.initialized && (_classPrivateFieldGet(this, _type) === '' || _classPrivateFieldGet(this, _id) === '')) { + throwDependencyNotEstablishedError(); + } else { + var nodes = []; + var response_type = learner_responses[this.type]; + + if (response_type) { + if (response_type !== null && response_type !== void 0 && response_type.delimiter) { + nodes = learner_response.split(response_type.delimiter); + } else { + nodes[0] = learner_response; + } + + if (nodes.length > 0 && nodes.length <= response_type.max) { + var formatRegex = new RegExp(response_type.format); + + for (var i = 0; i < nodes.length; i++) { + if (response_type !== null && response_type !== void 0 && response_type.delimiter2) { + var values = nodes[i].split(response_type.delimiter2); + + if (values.length === 2) { + if (!values[0].match(formatRegex)) { + throwTypeMismatchError(); + } else { + if (!values[1].match(new RegExp(response_type.format2))) { + throwTypeMismatchError(); + } + } + } else { + throwTypeMismatchError(); + } + } else { + if (!nodes[i].match(formatRegex)) { + throwTypeMismatchError(); + } else { + if (nodes[i] !== '' && response_type.unique) { + for (var j = 0; j < i; j++) { + if (nodes[i] === nodes[j]) { + throwTypeMismatchError(); + } + } + } + } + } + } + } else { + throwGeneralSetError(); + } + + _classPrivateFieldSet(this, _learner_response, learner_response); + } else { + throwTypeMismatchError(); + } + } + } + /** + * Getter for #result + * @return {string} + */ + + }, { + key: "result", + get: function get() { + return _classPrivateFieldGet(this, _result); + } + /** + * Setter for #result + * @param {string} result + */ + , + set: function set(result) { + if (check2004ValidFormat(result, scorm2004_regex.CMIResult)) { + _classPrivateFieldSet(this, _result, result); + } + } + /** + * Getter for #latency + * @return {string} + */ + + }, { + key: "latency", + get: function get() { + return _classPrivateFieldGet(this, _latency); + } + /** + * Setter for #latency + * @param {string} latency + */ + , + set: function set(latency) { + if (this.initialized && _classPrivateFieldGet(this, _id) === '') { + throwDependencyNotEstablishedError(); + } else { + if (check2004ValidFormat(latency, scorm2004_regex.CMITimespan)) { + _classPrivateFieldSet(this, _latency, latency); + } + } + } + /** + * Getter for #description + * @return {string} + */ + + }, { + key: "description", + get: function get() { + return _classPrivateFieldGet(this, _description); + } + /** + * Setter for #description + * @param {string} description + */ + , + set: function set(description) { + if (this.initialized && _classPrivateFieldGet(this, _id) === '') { + throwDependencyNotEstablishedError(); + } else { + if (check2004ValidFormat(description, scorm2004_regex.CMILangString250, true)) { + _classPrivateFieldSet(this, _description, description); + } + } + } + /** + * toJSON for cmi.interactions.n + * + * @return { + * { + * id: string, + * type: string, + * objectives: CMIArray, + * timestamp: string, + * correct_responses: CMIArray, + * weighting: string, + * learner_response: string, + * result: string, + * latency: string, + * description: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'id': this.id, + 'type': this.type, + 'objectives': this.objectives, + 'timestamp': this.timestamp, + 'weighting': this.weighting, + 'learner_response': this.learner_response, + 'result': this.result, + 'latency': this.latency, + 'description': this.description, + 'correct_responses': this.correct_responses + }; + delete this.jsonString; + return result; + } + }]); + + return CMIInteractionsObject; +}(_common.BaseCMI); +/** + * Class for SCORM 2004's cmi.objectives.n object + */ + + +exports.CMIInteractionsObject = CMIInteractionsObject; + +var _id2 = new WeakMap(); + +var _success_status2 = new WeakMap(); + +var _completion_status2 = new WeakMap(); + +var _progress_measure2 = new WeakMap(); + +var _description2 = new WeakMap(); + +var CMIObjectivesObject = /*#__PURE__*/function (_BaseCMI4) { + _inherits(CMIObjectivesObject, _BaseCMI4); + + var _super8 = _createSuper(CMIObjectivesObject); + + /** + * Constructor for cmi.objectives.n + */ + function CMIObjectivesObject() { + var _this4; + + _classCallCheck(this, CMIObjectivesObject); + + _this4 = _super8.call(this); + + _id2.set(_assertThisInitialized(_this4), { + writable: true, + value: '' + }); + + _success_status2.set(_assertThisInitialized(_this4), { + writable: true, + value: 'unknown' + }); + + _completion_status2.set(_assertThisInitialized(_this4), { + writable: true, + value: 'unknown' + }); + + _progress_measure2.set(_assertThisInitialized(_this4), { + writable: true, + value: '' + }); + + _description2.set(_assertThisInitialized(_this4), { + writable: true, + value: '' + }); + + _this4.score = new Scorm2004CMIScore(); + return _this4; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(CMIObjectivesObject, [{ + key: "initialize", + value: function initialize() { + var _this$score2; + + _get(_getPrototypeOf(CMIObjectivesObject.prototype), "initialize", this).call(this); + + (_this$score2 = this.score) === null || _this$score2 === void 0 ? void 0 : _this$score2.initialize(); + } + /** + * Getter for #id + * @return {string} + */ + + }, { + key: "id", + get: function get() { + return _classPrivateFieldGet(this, _id2); + } + /** + * Setter for #id + * @param {string} id + */ + , + set: function set(id) { + if (check2004ValidFormat(id, scorm2004_regex.CMILongIdentifier)) { + _classPrivateFieldSet(this, _id2, id); + } + } + /** + * Getter for #success_status + * @return {string} + */ + + }, { + key: "success_status", + get: function get() { + return _classPrivateFieldGet(this, _success_status2); + } + /** + * Setter for #success_status + * @param {string} success_status + */ + , + set: function set(success_status) { + if (this.initialized && _classPrivateFieldGet(this, _id2) === '') { + throwDependencyNotEstablishedError(); + } else { + if (check2004ValidFormat(success_status, scorm2004_regex.CMISStatus)) { + _classPrivateFieldSet(this, _success_status2, success_status); + } + } + } + /** + * Getter for #completion_status + * @return {string} + */ + + }, { + key: "completion_status", + get: function get() { + return _classPrivateFieldGet(this, _completion_status2); + } + /** + * Setter for #completion_status + * @param {string} completion_status + */ + , + set: function set(completion_status) { + if (this.initialized && _classPrivateFieldGet(this, _id2) === '') { + throwDependencyNotEstablishedError(); + } else { + if (check2004ValidFormat(completion_status, scorm2004_regex.CMICStatus)) { + _classPrivateFieldSet(this, _completion_status2, completion_status); + } + } + } + /** + * Getter for #progress_measure + * @return {string} + */ + + }, { + key: "progress_measure", + get: function get() { + return _classPrivateFieldGet(this, _progress_measure2); + } + /** + * Setter for #progress_measure + * @param {string} progress_measure + */ + , + set: function set(progress_measure) { + if (this.initialized && _classPrivateFieldGet(this, _id2) === '') { + throwDependencyNotEstablishedError(); + } else { + if (check2004ValidFormat(progress_measure, scorm2004_regex.CMIDecimal) && check2004ValidRange(progress_measure, scorm2004_regex.progress_range)) { + _classPrivateFieldSet(this, _progress_measure2, progress_measure); + } + } + } + /** + * Getter for #description + * @return {string} + */ + + }, { + key: "description", + get: function get() { + return _classPrivateFieldGet(this, _description2); + } + /** + * Setter for #description + * @param {string} description + */ + , + set: function set(description) { + if (this.initialized && _classPrivateFieldGet(this, _id2) === '') { + throwDependencyNotEstablishedError(); + } else { + if (check2004ValidFormat(description, scorm2004_regex.CMILangString250, true)) { + _classPrivateFieldSet(this, _description2, description); + } + } + } + /** + * toJSON for cmi.objectives.n + * + * @return { + * { + * id: string, + * success_status: string, + * completion_status: string, + * progress_measure: string, + * description: string, + * score: Scorm2004CMIScore + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'id': this.id, + 'success_status': this.success_status, + 'completion_status': this.completion_status, + 'progress_measure': this.progress_measure, + 'description': this.description, + 'score': this.score + }; + delete this.jsonString; + return result; + } + }]); + + return CMIObjectivesObject; +}(_common.BaseCMI); +/** + * Class for SCORM 2004's cmi *.score object + */ + + +exports.CMIObjectivesObject = CMIObjectivesObject; + +var _scaled = new WeakMap(); + +var Scorm2004CMIScore = /*#__PURE__*/function (_CMIScore) { + _inherits(Scorm2004CMIScore, _CMIScore); + + var _super9 = _createSuper(Scorm2004CMIScore); + + /** + * Constructor for cmi *.score + */ + function Scorm2004CMIScore() { + var _this5; + + _classCallCheck(this, Scorm2004CMIScore); + + _this5 = _super9.call(this, { + score_children: scorm2004_constants.score_children, + max: '', + invalidErrorCode: scorm2004_error_codes.READ_ONLY_ELEMENT, + invalidTypeCode: scorm2004_error_codes.TYPE_MISMATCH, + invalidRangeCode: scorm2004_error_codes.VALUE_OUT_OF_RANGE, + decimalRegex: scorm2004_regex.CMIDecimal, + errorClass: _exceptions.Scorm2004ValidationError + }); + + _scaled.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + return _this5; + } + /** + * Getter for #scaled + * @return {string} + */ + + + _createClass(Scorm2004CMIScore, [{ + key: "scaled", + get: function get() { + return _classPrivateFieldGet(this, _scaled); + } + /** + * Setter for #scaled + * @param {string} scaled + */ + , + set: function set(scaled) { + if (check2004ValidFormat(scaled, scorm2004_regex.CMIDecimal) && check2004ValidRange(scaled, scorm2004_regex.scaled_range)) { + _classPrivateFieldSet(this, _scaled, scaled); + } + } + /** + * toJSON for cmi *.score + * + * @return { + * { + * scaled: string, + * raw: string, + * min: string, + * max: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'scaled': this.scaled, + 'raw': _get(_getPrototypeOf(Scorm2004CMIScore.prototype), "raw", this), + 'min': _get(_getPrototypeOf(Scorm2004CMIScore.prototype), "min", this), + 'max': _get(_getPrototypeOf(Scorm2004CMIScore.prototype), "max", this) + }; + delete this.jsonString; + return result; + } + }]); + + return Scorm2004CMIScore; +}(_common.CMIScore); +/** + * Class representing SCORM 2004's cmi.comments_from_learner.n and cmi.comments_from_lms.n object + */ + + +var _comment = new WeakMap(); + +var _location2 = new WeakMap(); + +var _timestamp2 = new WeakMap(); + +var _readOnlyAfterInit = new WeakMap(); + +var CMICommentsObject = /*#__PURE__*/function (_BaseCMI5) { + _inherits(CMICommentsObject, _BaseCMI5); + + var _super10 = _createSuper(CMICommentsObject); + + /** + * Constructor for cmi.comments_from_learner.n and cmi.comments_from_lms.n + * @param {boolean} readOnlyAfterInit + */ + function CMICommentsObject() { + var _this6; + + var readOnlyAfterInit = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + + _classCallCheck(this, CMICommentsObject); + + _this6 = _super10.call(this); + + _comment.set(_assertThisInitialized(_this6), { + writable: true, + value: '' + }); + + _location2.set(_assertThisInitialized(_this6), { + writable: true, + value: '' + }); + + _timestamp2.set(_assertThisInitialized(_this6), { + writable: true, + value: '' + }); + + _readOnlyAfterInit.set(_assertThisInitialized(_this6), { + writable: true, + value: void 0 + }); + + _classPrivateFieldSet(_assertThisInitialized(_this6), _comment, ''); + + _classPrivateFieldSet(_assertThisInitialized(_this6), _location2, ''); + + _classPrivateFieldSet(_assertThisInitialized(_this6), _timestamp2, ''); + + _classPrivateFieldSet(_assertThisInitialized(_this6), _readOnlyAfterInit, readOnlyAfterInit); + + return _this6; + } + /** + * Getter for #comment + * @return {string} + */ + + + _createClass(CMICommentsObject, [{ + key: "comment", + get: function get() { + return _classPrivateFieldGet(this, _comment); + } + /** + * Setter for #comment + * @param {string} comment + */ + , + set: function set(comment) { + if (this.initialized && _classPrivateFieldGet(this, _readOnlyAfterInit)) { + throwReadOnlyError(); + } else { + if (check2004ValidFormat(comment, scorm2004_regex.CMILangString4000, true)) { + _classPrivateFieldSet(this, _comment, comment); + } + } + } + /** + * Getter for #location + * @return {string} + */ + + }, { + key: "location", + get: function get() { + return _classPrivateFieldGet(this, _location2); + } + /** + * Setter for #location + * @param {string} location + */ + , + set: function set(location) { + if (this.initialized && _classPrivateFieldGet(this, _readOnlyAfterInit)) { + throwReadOnlyError(); + } else { + if (check2004ValidFormat(location, scorm2004_regex.CMIString250)) { + _classPrivateFieldSet(this, _location2, location); + } + } + } + /** + * Getter for #timestamp + * @return {string} + */ + + }, { + key: "timestamp", + get: function get() { + return _classPrivateFieldGet(this, _timestamp2); + } + /** + * Setter for #timestamp + * @param {string} timestamp + */ + , + set: function set(timestamp) { + if (this.initialized && _classPrivateFieldGet(this, _readOnlyAfterInit)) { + throwReadOnlyError(); + } else { + if (check2004ValidFormat(timestamp, scorm2004_regex.CMITime)) { + _classPrivateFieldSet(this, _timestamp2, timestamp); + } + } + } + /** + * toJSON for cmi.comments_from_learner.n object + * @return { + * { + * comment: string, + * location: string, + * timestamp: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'comment': this.comment, + 'location': this.location, + 'timestamp': this.timestamp + }; + delete this.jsonString; + return result; + } + }]); + + return CMICommentsObject; +}(_common.BaseCMI); +/** + * Class representing SCORM 2004's cmi.interactions.n.objectives.n object + */ + + +exports.CMICommentsObject = CMICommentsObject; + +var _id3 = new WeakMap(); + +var CMIInteractionsObjectivesObject = /*#__PURE__*/function (_BaseCMI6) { + _inherits(CMIInteractionsObjectivesObject, _BaseCMI6); + + var _super11 = _createSuper(CMIInteractionsObjectivesObject); + + /** + * Constructor for cmi.interactions.n.objectives.n + */ + function CMIInteractionsObjectivesObject() { + var _this7; + + _classCallCheck(this, CMIInteractionsObjectivesObject); + + _this7 = _super11.call(this); + + _id3.set(_assertThisInitialized(_this7), { + writable: true, + value: '' + }); + + return _this7; + } + /** + * Getter for #id + * @return {string} + */ + + + _createClass(CMIInteractionsObjectivesObject, [{ + key: "id", + get: function get() { + return _classPrivateFieldGet(this, _id3); + } + /** + * Setter for #id + * @param {string} id + */ + , + set: function set(id) { + if (check2004ValidFormat(id, scorm2004_regex.CMILongIdentifier)) { + _classPrivateFieldSet(this, _id3, id); + } + } + /** + * toJSON for cmi.interactions.n.objectives.n + * @return { + * { + * id: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'id': this.id + }; + delete this.jsonString; + return result; + } + }]); + + return CMIInteractionsObjectivesObject; +}(_common.BaseCMI); +/** + * Class representing SCORM 2004's cmi.interactions.n.correct_responses.n object + */ + + +exports.CMIInteractionsObjectivesObject = CMIInteractionsObjectivesObject; + +var _pattern = new WeakMap(); + +var CMIInteractionsCorrectResponsesObject = /*#__PURE__*/function (_BaseCMI7) { + _inherits(CMIInteractionsCorrectResponsesObject, _BaseCMI7); + + var _super12 = _createSuper(CMIInteractionsCorrectResponsesObject); + + /** + * Constructor for cmi.interactions.n.correct_responses.n + */ + function CMIInteractionsCorrectResponsesObject() { + var _this8; + + _classCallCheck(this, CMIInteractionsCorrectResponsesObject); + + _this8 = _super12.call(this); + + _pattern.set(_assertThisInitialized(_this8), { + writable: true, + value: '' + }); + + return _this8; + } + /** + * Getter for #pattern + * @return {string} + */ + + + _createClass(CMIInteractionsCorrectResponsesObject, [{ + key: "pattern", + get: function get() { + return _classPrivateFieldGet(this, _pattern); + } + /** + * Setter for #pattern + * @param {string} pattern + */ + , + set: function set(pattern) { + if (check2004ValidFormat(pattern, scorm2004_regex.CMIFeedback)) { + _classPrivateFieldSet(this, _pattern, pattern); + } + } + /** + * toJSON cmi.interactions.n.correct_responses.n object + * @return { + * { + * pattern: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'pattern': this.pattern + }; + delete this.jsonString; + return result; + } + }]); + + return CMIInteractionsCorrectResponsesObject; +}(_common.BaseCMI); +/** + * Class representing SCORM 2004's adl object + */ + + +exports.CMIInteractionsCorrectResponsesObject = CMIInteractionsCorrectResponsesObject; + +var ADL = /*#__PURE__*/function (_BaseCMI8) { + _inherits(ADL, _BaseCMI8); + + var _super13 = _createSuper(ADL); + + /** + * Constructor for adl + */ + function ADL() { + var _this9; + + _classCallCheck(this, ADL); + + _this9 = _super13.call(this); + _this9.nav = new ADLNav(); + return _this9; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(ADL, [{ + key: "initialize", + value: function initialize() { + var _this$nav; + + _get(_getPrototypeOf(ADL.prototype), "initialize", this).call(this); + + (_this$nav = this.nav) === null || _this$nav === void 0 ? void 0 : _this$nav.initialize(); + } + /** + * toJSON for adl + * @return { + * { + * nav: { + * request: string + * } + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'nav': this.nav + }; + delete this.jsonString; + return result; + } + }]); + + return ADL; +}(_common.BaseCMI); +/** + * Class representing SCORM 2004's adl.nav object + */ + + +exports.ADL = ADL; + +var _request = new WeakMap(); + +var ADLNav = /*#__PURE__*/function (_BaseCMI9) { + _inherits(ADLNav, _BaseCMI9); + + var _super14 = _createSuper(ADLNav); + + /** + * Constructor for adl.nav + */ + function ADLNav() { + var _this10; + + _classCallCheck(this, ADLNav); + + _this10 = _super14.call(this); + + _request.set(_assertThisInitialized(_this10), { + writable: true, + value: '_none_' + }); + + _this10.request_valid = new ADLNavRequestValid(); + return _this10; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(ADLNav, [{ + key: "initialize", + value: function initialize() { + var _this$request_valid; + + _get(_getPrototypeOf(ADLNav.prototype), "initialize", this).call(this); + + (_this$request_valid = this.request_valid) === null || _this$request_valid === void 0 ? void 0 : _this$request_valid.initialize(); + } + /** + * Getter for #request + * @return {string} + */ + + }, { + key: "request", + get: function get() { + return _classPrivateFieldGet(this, _request); + } + /** + * Setter for #request + * @param {string} request + */ + , + set: function set(request) { + if (check2004ValidFormat(request, scorm2004_regex.NAVEvent)) { + _classPrivateFieldSet(this, _request, request); + } + } + /** + * toJSON for adl.nav + * + * @return { + * { + * request: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'request': this.request + }; + delete this.jsonString; + return result; + } + }]); + + return ADLNav; +}(_common.BaseCMI); +/** + * Class representing SCORM 2004's adl.nav.request_valid object + */ + + +var _continue = new WeakMap(); + +var _previous = new WeakMap(); + +var ADLNavRequestValid = /*#__PURE__*/function (_BaseCMI10) { + _inherits(ADLNavRequestValid, _BaseCMI10); + + var _super15 = _createSuper(ADLNavRequestValid); + + /** + * Constructor for adl.nav.request_valid + */ + function ADLNavRequestValid() { + var _temp, _temp2; + + var _this11; + + _classCallCheck(this, ADLNavRequestValid); + + _this11 = _super15.call(this); + + _continue.set(_assertThisInitialized(_this11), { + writable: true, + value: 'unknown' + }); + + _previous.set(_assertThisInitialized(_this11), { + writable: true, + value: 'unknown' + }); + + _defineProperty(_assertThisInitialized(_this11), "choice", (_temp = function _temp() { + _classCallCheck(this, _temp); + + _defineProperty(this, "_isTargetValid", function (_target) { + return 'unknown'; + }); + }, _temp)); + + _defineProperty(_assertThisInitialized(_this11), "jump", (_temp2 = function _temp2() { + _classCallCheck(this, _temp2); + + _defineProperty(this, "_isTargetValid", function (_target) { + return 'unknown'; + }); + }, _temp2)); + + return _this11; + } + /** + * Getter for #continue + * @return {string} + */ + + + _createClass(ADLNavRequestValid, [{ + key: "continue", + get: function get() { + return _classPrivateFieldGet(this, _continue); + } + /** + * Setter for #continue. Just throws an error. + * @param {*} _ + */ + , + set: function set(_) { + throwReadOnlyError(); + } + /** + * Getter for #previous + * @return {string} + */ + + }, { + key: "previous", + get: function get() { + return _classPrivateFieldGet(this, _previous); + } + /** + * Setter for #previous. Just throws an error. + * @param {*} _ + */ + , + set: function set(_) { + throwReadOnlyError(); + } + /** + * toJSON for adl.nav.request_valid + * + * @return { + * { + * previous: string, + * continue: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'previous': this.previous, + 'continue': this["continue"] + }; + delete this.jsonString; + return result; + } + }]); + + return ADLNavRequestValid; +}(_common.BaseCMI); + },{"../constants/api_constants":10,"../constants/error_codes":11,"../constants/regex":13,"../constants/response_constants":14,"../exceptions":15,"../utilities":17,"./common":7}],10:[function(require,module,exports){ -"use strict";function ownKeys(e,a){var t=Object.keys(e);if(Object.getOwnPropertySymbols){var s=Object.getOwnPropertySymbols(e);a&&(s=s.filter(function(a){return Object.getOwnPropertyDescriptor(e,a).enumerable})),t.push.apply(t,s)}return t}function _objectSpread(e){for(var a=1;ar.length)&&(e=r.length);for(var t=0,n=new Array(e);t0&&(i=countDecimals(a)>2?a.toFixed(2):String(a),i="."+i.split(".")[1]),(e+":"+n+":"+o).replace(/\b\d\b/g,"0$&")+i}function getSecondsAsISODuration(r){if(!r||r<=0)return"PT0S";var e="P",t=r;return designations.forEach(function(r){var n=_slicedToArray(r,2),o=n[0],a=n[1],i=Math.floor(t/a);t%=a,countDecimals(t)>2&&(t=Number(Number(t).toFixed(2))),"S"===o&&t>0&&(i+=t),i&&((e.indexOf("D")>0||"H"===o||"M"===o||"S"===o)&&-1===e.indexOf("T")&&(e+="T"),e+="".concat(i).concat(o))}),e}function getTimeAsSeconds(r,e){if(!r||"string"!=typeof r||!r.match(e))return 0;var t=r.split(":");return 3600*Number(t[0])+60*Number(t[1])+Number(t[2])}function getDurationAsSeconds(r,e){if(!r||!r.match(e))return 0;var t=new RegExp(e).exec(r)||[],n=_slicedToArray(t,8),o=n[1],a=(n[2],n[4]),i=n[5],s=n[6],S=n[7],u=0;return u+=1*Number(S)||0,u+=60*Number(s)||0,u+=3600*Number(i)||0,u+=86400*Number(a)||0,u+=31536e3*Number(o)||0}function addTwoDurations(r,e,t){return getSecondsAsISODuration(getDurationAsSeconds(r,t)+getDurationAsSeconds(e,t))}function addHHMMSSTimeStrings(r,e,t){return getSecondsAsHHMMSS(getTimeAsSeconds(r,t)+getTimeAsSeconds(e,t))}function flatten(r){function e(r,n){if(Object(r)!==r)t[n]=r;else if(Array.isArray(r))for(var o=0,a=r.length;o arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit(arr, i) { var _i = arr && (typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]); if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } + +var SECONDS_PER_SECOND = 1.0; +exports.SECONDS_PER_SECOND = SECONDS_PER_SECOND; +var SECONDS_PER_MINUTE = 60; +exports.SECONDS_PER_MINUTE = SECONDS_PER_MINUTE; +var SECONDS_PER_HOUR = 60 * SECONDS_PER_MINUTE; +exports.SECONDS_PER_HOUR = SECONDS_PER_HOUR; +var SECONDS_PER_DAY = 24 * SECONDS_PER_HOUR; +exports.SECONDS_PER_DAY = SECONDS_PER_DAY; +var designations = [['D', SECONDS_PER_DAY], ['H', SECONDS_PER_HOUR], ['M', SECONDS_PER_MINUTE], ['S', SECONDS_PER_SECOND]]; +/** + * Converts a Number to a String of HH:MM:SS + * + * @param {Number} totalSeconds + * @return {string} + */ + +function getSecondsAsHHMMSS(totalSeconds) { + // SCORM spec does not deal with negative durations, give zero back + if (!totalSeconds || totalSeconds <= 0) { + return '00:00:00'; + } + + var hours = Math.floor(totalSeconds / SECONDS_PER_HOUR); + var dateObj = new Date(totalSeconds * 1000); + var minutes = dateObj.getUTCMinutes(); // make sure we add any possible decimal value + + var seconds = dateObj.getSeconds(); + var ms = totalSeconds % 1.0; + var msStr = ''; + + if (countDecimals(ms) > 0) { + if (countDecimals(ms) > 2) { + msStr = ms.toFixed(2); + } else { + msStr = String(ms); + } + + msStr = '.' + msStr.split('.')[1]; + } + + return (hours + ':' + minutes + ':' + seconds).replace(/\b\d\b/g, '0$&') + msStr; +} +/** + * Calculate the number of seconds from ISO 8601 Duration + * + * @param {Number} seconds + * @return {String} + */ -//# sourceMappingURL=scorm-again.js.map \ No newline at end of file +function getSecondsAsISODuration(seconds) { + // SCORM spec does not deal with negative durations, give zero back + if (!seconds || seconds <= 0) { + return 'PT0S'; + } + + var duration = 'P'; + var remainder = seconds; + designations.forEach(function (_ref) { + var _ref2 = _slicedToArray(_ref, 2), + sign = _ref2[0], + current_seconds = _ref2[1]; + + var value = Math.floor(remainder / current_seconds); + remainder = remainder % current_seconds; + + if (countDecimals(remainder) > 2) { + remainder = Number(Number(remainder).toFixed(2)); + } // If we have anything left in the remainder, and we're currently adding + // seconds to the duration, go ahead and add the decimal to the seconds + + + if (sign === 'S' && remainder > 0) { + value += remainder; + } + + if (value) { + if ((duration.indexOf('D') > 0 || sign === 'H' || sign === 'M' || sign === 'S') && duration.indexOf('T') === -1) { + duration += 'T'; + } + + duration += "".concat(value).concat(sign); + } + }); + return duration; +} +/** + * Calculate the number of seconds from HH:MM:SS.DDDDDD + * + * @param {string} timeString + * @param {RegExp} timeRegex + * @return {number} + */ + + +function getTimeAsSeconds(timeString, timeRegex) { + if (!timeString || typeof timeString !== 'string' || !timeString.match(timeRegex)) { + return 0; + } + + var parts = timeString.split(':'); + var hours = Number(parts[0]); + var minutes = Number(parts[1]); + var seconds = Number(parts[2]); + return hours * 3600 + minutes * 60 + seconds; +} +/** + * Calculate the number of seconds from ISO 8601 Duration + * + * @param {string} duration + * @param {RegExp} durationRegex + * @return {number} + */ + + +function getDurationAsSeconds(duration, durationRegex) { + if (!duration || !duration.match(durationRegex)) { + return 0; + } + + var _ref3 = new RegExp(durationRegex).exec(duration) || [], + _ref4 = _slicedToArray(_ref3, 8), + years = _ref4[1], + months = _ref4[2], + days = _ref4[4], + hours = _ref4[5], + minutes = _ref4[6], + seconds = _ref4[7]; + + var result = 0.0; + result += Number(seconds) * 1.0 || 0.0; + result += Number(minutes) * 60.0 || 0.0; + result += Number(hours) * 3600.0 || 0.0; + result += Number(days) * (60 * 60 * 24.0) || 0.0; + result += Number(years) * (60 * 60 * 24 * 365.0) || 0.0; + return result; +} +/** + * Adds together two ISO8601 Duration strings + * + * @param {string} first + * @param {string} second + * @param {RegExp} durationRegex + * @return {string} + */ + + +function addTwoDurations(first, second, durationRegex) { + return getSecondsAsISODuration(getDurationAsSeconds(first, durationRegex) + getDurationAsSeconds(second, durationRegex)); +} +/** + * Add together two HH:MM:SS.DD strings + * + * @param {string} first + * @param {string} second + * @param {RegExp} timeRegex + * @return {string} + */ + + +function addHHMMSSTimeStrings(first, second, timeRegex) { + return getSecondsAsHHMMSS(getTimeAsSeconds(first, timeRegex) + getTimeAsSeconds(second, timeRegex)); +} +/** + * Flatten a JSON object down to string paths for each values + * @param {object} data + * @return {object} + */ + + +function flatten(data) { + var result = {}; + /** + * Recurse through the object + * @param {*} cur + * @param {*} prop + */ + + function recurse(cur, prop) { + if (Object(cur) !== cur) { + result[prop] = cur; + } else if (Array.isArray(cur)) { + for (var i = 0, l = cur.length; i < l; i++) { + recurse(cur[i], prop + '[' + i + ']'); + if (l === 0) result[prop] = []; + } + } else { + var isEmpty = true; + + for (var p in cur) { + if ({}.hasOwnProperty.call(cur, p)) { + isEmpty = false; + recurse(cur[p], prop ? prop + '.' + p : p); + } + } + + if (isEmpty && prop) result[prop] = {}; + } + } + + recurse(data, ''); + return result; +} +/** + * Un-flatten a flat JSON object + * @param {object} data + * @return {object} + */ + + +function unflatten(data) { + 'use strict'; + + if (Object(data) !== data || Array.isArray(data)) return data; + var regex = /\.?([^.[\]]+)|\[(\d+)]/g; + var result = {}; + + for (var p in data) { + if ({}.hasOwnProperty.call(data, p)) { + var cur = result; + var prop = ''; + var m = regex.exec(p); + + while (m) { + cur = cur[prop] || (cur[prop] = m[2] ? [] : {}); + prop = m[2] || m[1]; + m = regex.exec(p); + } + + cur[prop] = data[p]; + } + } + + return result[''] || result; +} +/** + * Counts the number of decimal places + * @param {number} num + * @return {number} + */ + + +function countDecimals(num) { + if (Math.floor(num) === num || String(num).indexOf('.') < 0) return 0; + var parts = num.toString().split('.')[1]; + return parts.length || 0; +} + +},{}]},{},[16]); diff --git a/dist/scorm12.js b/dist/scorm12.js new file mode 100644 index 0000000..d125717 --- /dev/null +++ b/dist/scorm12.js @@ -0,0 +1,5502 @@ +(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i + * Build: `lodash modularize exports="npm" -o ./` + * Copyright jQuery Foundation and other contributors + * Released under MIT license + * Based on Underscore.js 1.8.3 + * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + */ + +/** Used as the `TypeError` message for "Functions" methods. */ +var FUNC_ERROR_TEXT = 'Expected a function'; + +/** Used as references for various `Number` constants. */ +var NAN = 0 / 0; + +/** `Object#toString` result references. */ +var symbolTag = '[object Symbol]'; + +/** Used to match leading and trailing whitespace. */ +var reTrim = /^\s+|\s+$/g; + +/** Used to detect bad signed hexadecimal string values. */ +var reIsBadHex = /^[-+]0x[0-9a-f]+$/i; + +/** Used to detect binary string values. */ +var reIsBinary = /^0b[01]+$/i; + +/** Used to detect octal string values. */ +var reIsOctal = /^0o[0-7]+$/i; + +/** Built-in method references without a dependency on `root`. */ +var freeParseInt = parseInt; + +/** Detect free variable `global` from Node.js. */ +var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; + +/** Detect free variable `self`. */ +var freeSelf = typeof self == 'object' && self && self.Object === Object && self; + +/** Used as a reference to the global object. */ +var root = freeGlobal || freeSelf || Function('return this')(); + +/** Used for built-in method references. */ +var objectProto = Object.prototype; + +/** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ +var objectToString = objectProto.toString; + +/* Built-in method references for those with the same name as other `lodash` methods. */ +var nativeMax = Math.max, + nativeMin = Math.min; + +/** + * Gets the timestamp of the number of milliseconds that have elapsed since + * the Unix epoch (1 January 1970 00:00:00 UTC). + * + * @static + * @memberOf _ + * @since 2.4.0 + * @category Date + * @returns {number} Returns the timestamp. + * @example + * + * _.defer(function(stamp) { + * console.log(_.now() - stamp); + * }, _.now()); + * // => Logs the number of milliseconds it took for the deferred invocation. + */ +var now = function() { + return root.Date.now(); +}; + +/** + * Creates a debounced function that delays invoking `func` until after `wait` + * milliseconds have elapsed since the last time the debounced function was + * invoked. The debounced function comes with a `cancel` method to cancel + * delayed `func` invocations and a `flush` method to immediately invoke them. + * Provide `options` to indicate whether `func` should be invoked on the + * leading and/or trailing edge of the `wait` timeout. The `func` is invoked + * with the last arguments provided to the debounced function. Subsequent + * calls to the debounced function return the result of the last `func` + * invocation. + * + * **Note:** If `leading` and `trailing` options are `true`, `func` is + * invoked on the trailing edge of the timeout only if the debounced function + * is invoked more than once during the `wait` timeout. + * + * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred + * until to the next tick, similar to `setTimeout` with a timeout of `0`. + * + * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) + * for details over the differences between `_.debounce` and `_.throttle`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to debounce. + * @param {number} [wait=0] The number of milliseconds to delay. + * @param {Object} [options={}] The options object. + * @param {boolean} [options.leading=false] + * Specify invoking on the leading edge of the timeout. + * @param {number} [options.maxWait] + * The maximum time `func` is allowed to be delayed before it's invoked. + * @param {boolean} [options.trailing=true] + * Specify invoking on the trailing edge of the timeout. + * @returns {Function} Returns the new debounced function. + * @example + * + * // Avoid costly calculations while the window size is in flux. + * jQuery(window).on('resize', _.debounce(calculateLayout, 150)); + * + * // Invoke `sendMail` when clicked, debouncing subsequent calls. + * jQuery(element).on('click', _.debounce(sendMail, 300, { + * 'leading': true, + * 'trailing': false + * })); + * + * // Ensure `batchLog` is invoked once after 1 second of debounced calls. + * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 }); + * var source = new EventSource('/stream'); + * jQuery(source).on('message', debounced); + * + * // Cancel the trailing debounced invocation. + * jQuery(window).on('popstate', debounced.cancel); + */ +function debounce(func, wait, options) { + var lastArgs, + lastThis, + maxWait, + result, + timerId, + lastCallTime, + lastInvokeTime = 0, + leading = false, + maxing = false, + trailing = true; + + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + wait = toNumber(wait) || 0; + if (isObject(options)) { + leading = !!options.leading; + maxing = 'maxWait' in options; + maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait; + trailing = 'trailing' in options ? !!options.trailing : trailing; + } + + function invokeFunc(time) { + var args = lastArgs, + thisArg = lastThis; + + lastArgs = lastThis = undefined; + lastInvokeTime = time; + result = func.apply(thisArg, args); + return result; + } + + function leadingEdge(time) { + // Reset any `maxWait` timer. + lastInvokeTime = time; + // Start the timer for the trailing edge. + timerId = setTimeout(timerExpired, wait); + // Invoke the leading edge. + return leading ? invokeFunc(time) : result; + } + + function remainingWait(time) { + var timeSinceLastCall = time - lastCallTime, + timeSinceLastInvoke = time - lastInvokeTime, + result = wait - timeSinceLastCall; + + return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result; + } + + function shouldInvoke(time) { + var timeSinceLastCall = time - lastCallTime, + timeSinceLastInvoke = time - lastInvokeTime; + + // Either this is the first call, activity has stopped and we're at the + // trailing edge, the system time has gone backwards and we're treating + // it as the trailing edge, or we've hit the `maxWait` limit. + return (lastCallTime === undefined || (timeSinceLastCall >= wait) || + (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait)); + } + + function timerExpired() { + var time = now(); + if (shouldInvoke(time)) { + return trailingEdge(time); + } + // Restart the timer. + timerId = setTimeout(timerExpired, remainingWait(time)); + } + + function trailingEdge(time) { + timerId = undefined; + + // Only invoke if we have `lastArgs` which means `func` has been + // debounced at least once. + if (trailing && lastArgs) { + return invokeFunc(time); + } + lastArgs = lastThis = undefined; + return result; + } + + function cancel() { + if (timerId !== undefined) { + clearTimeout(timerId); + } + lastInvokeTime = 0; + lastArgs = lastCallTime = lastThis = timerId = undefined; + } + + function flush() { + return timerId === undefined ? result : trailingEdge(now()); + } + + function debounced() { + var time = now(), + isInvoking = shouldInvoke(time); + + lastArgs = arguments; + lastThis = this; + lastCallTime = time; + + if (isInvoking) { + if (timerId === undefined) { + return leadingEdge(lastCallTime); + } + if (maxing) { + // Handle invocations in a tight loop. + timerId = setTimeout(timerExpired, wait); + return invokeFunc(lastCallTime); + } + } + if (timerId === undefined) { + timerId = setTimeout(timerExpired, wait); + } + return result; + } + debounced.cancel = cancel; + debounced.flush = flush; + return debounced; +} + +/** + * Checks if `value` is the + * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) + * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an object, else `false`. + * @example + * + * _.isObject({}); + * // => true + * + * _.isObject([1, 2, 3]); + * // => true + * + * _.isObject(_.noop); + * // => true + * + * _.isObject(null); + * // => false + */ +function isObject(value) { + var type = typeof value; + return !!value && (type == 'object' || type == 'function'); +} + +/** + * Checks if `value` is object-like. A value is object-like if it's not `null` + * and has a `typeof` result of "object". + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is object-like, else `false`. + * @example + * + * _.isObjectLike({}); + * // => true + * + * _.isObjectLike([1, 2, 3]); + * // => true + * + * _.isObjectLike(_.noop); + * // => false + * + * _.isObjectLike(null); + * // => false + */ +function isObjectLike(value) { + return !!value && typeof value == 'object'; +} + +/** + * Checks if `value` is classified as a `Symbol` primitive or object. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. + * @example + * + * _.isSymbol(Symbol.iterator); + * // => true + * + * _.isSymbol('abc'); + * // => false + */ +function isSymbol(value) { + return typeof value == 'symbol' || + (isObjectLike(value) && objectToString.call(value) == symbolTag); +} + +/** + * Converts `value` to a number. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to process. + * @returns {number} Returns the number. + * @example + * + * _.toNumber(3.2); + * // => 3.2 + * + * _.toNumber(Number.MIN_VALUE); + * // => 5e-324 + * + * _.toNumber(Infinity); + * // => Infinity + * + * _.toNumber('3.2'); + * // => 3.2 + */ +function toNumber(value) { + if (typeof value == 'number') { + return value; + } + if (isSymbol(value)) { + return NAN; + } + if (isObject(value)) { + var other = typeof value.valueOf == 'function' ? value.valueOf() : value; + value = isObject(other) ? (other + '') : other; + } + if (typeof value != 'string') { + return value === 0 ? value : +value; + } + value = value.replace(reTrim, ''); + var isBinary = reIsBinary.test(value); + return (isBinary || reIsOctal.test(value)) + ? freeParseInt(value.slice(2), isBinary ? 2 : 8) + : (reIsBadHex.test(value) ? NAN : +value); +} + +module.exports = debounce; + +}).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) + +},{}],2:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +var _common = require("./cmi/common"); + +var _exceptions = require("./exceptions"); + +var _error_codes2 = _interopRequireDefault(require("./constants/error_codes")); + +var _api_constants = _interopRequireDefault(require("./constants/api_constants")); + +var _utilities = require("./utilities"); + +var _lodash = _interopRequireDefault(require("lodash.debounce")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); } + +function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } + +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit(arr, i) { var _i = arr && (typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]); if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); } + +function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; } + +function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); } + +function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } } + +var global_constants = _api_constants["default"].global; +var scorm12_error_codes = _error_codes2["default"].scorm12; +/** + * Base API class for AICC, SCORM 1.2, and SCORM 2004. Should be considered + * abstract, and never initialized on it's own. + */ + +var _timeout = new WeakMap(); + +var _error_codes = new WeakMap(); + +var _settings = new WeakMap(); + +var BaseAPI = /*#__PURE__*/function () { + /** + * Constructor for Base API class. Sets some shared API fields, as well as + * sets up options for the API. + * @param {object} error_codes + * @param {object} settings + */ + function BaseAPI(error_codes, settings) { + _classCallCheck(this, BaseAPI); + + _timeout.set(this, { + writable: true, + value: void 0 + }); + + _error_codes.set(this, { + writable: true, + value: void 0 + }); + + _settings.set(this, { + writable: true, + value: { + autocommit: false, + autocommitSeconds: 10, + asyncCommit: false, + sendBeaconCommit: false, + lmsCommitUrl: false, + dataCommitFormat: 'json', + // valid formats are 'json' or 'flattened', 'params' + commitRequestDataType: 'application/json;charset=UTF-8', + autoProgress: false, + logLevel: global_constants.LOG_LEVEL_ERROR, + selfReportSessionTime: false, + alwaysSendTotalTime: false, + strict_errors: true, + responseHandler: function responseHandler(xhr) { + var result; + + if (typeof xhr !== 'undefined') { + result = JSON.parse(xhr.responseText); + + if (result === null || !{}.hasOwnProperty.call(result, 'result')) { + result = {}; + + if (xhr.status === 200) { + result.result = global_constants.SCORM_TRUE; + result.errorCode = 0; + } else { + result.result = global_constants.SCORM_FALSE; + result.errorCode = 101; + } + } + } + + return result; + } + } + }); + + _defineProperty(this, "cmi", void 0); + + _defineProperty(this, "startingData", void 0); + + if ((this instanceof BaseAPI ? this.constructor : void 0) === BaseAPI) { + throw new TypeError('Cannot construct BaseAPI instances directly'); + } + + this.currentState = global_constants.STATE_NOT_INITIALIZED; + this.lastErrorCode = 0; + this.listenerArray = []; + + _classPrivateFieldSet(this, _timeout, null); + + _classPrivateFieldSet(this, _error_codes, error_codes); + + this.settings = settings; + this.apiLogLevel = this.settings.logLevel; + this.selfReportSessionTime = this.settings.selfReportSessionTime; + } + /** + * Initialize the API + * @param {string} callbackName + * @param {string} initializeMessage + * @param {string} terminationMessage + * @return {string} + */ + + + _createClass(BaseAPI, [{ + key: "initialize", + value: function initialize(callbackName, initializeMessage, terminationMessage) { + var returnValue = global_constants.SCORM_FALSE; + + if (this.isInitialized()) { + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).INITIALIZED, initializeMessage); + } else if (this.isTerminated()) { + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).TERMINATED, terminationMessage); + } else { + if (this.selfReportSessionTime) { + this.cmi.setStartTime(); + } + + this.currentState = global_constants.STATE_INITIALIZED; + this.lastErrorCode = 0; + returnValue = global_constants.SCORM_TRUE; + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Getter for #error_codes + * @return {object} + */ + + }, { + key: "error_codes", + get: function get() { + return _classPrivateFieldGet(this, _error_codes); + } + /** + * Getter for #settings + * @return {object} + */ + + }, { + key: "settings", + get: function get() { + return _classPrivateFieldGet(this, _settings); + } + /** + * Setter for #settings + * @param {object} settings + */ + , + set: function set(settings) { + _classPrivateFieldSet(this, _settings, _objectSpread(_objectSpread({}, _classPrivateFieldGet(this, _settings)), settings)); + } + /** + * Terminates the current run of the API + * @param {string} callbackName + * @param {boolean} checkTerminated + * @return {string} + */ + + }, { + key: "terminate", + value: function terminate(callbackName, checkTerminated) { + var returnValue = global_constants.SCORM_FALSE; + + if (this.checkState(checkTerminated, _classPrivateFieldGet(this, _error_codes).TERMINATION_BEFORE_INIT, _classPrivateFieldGet(this, _error_codes).MULTIPLE_TERMINATION)) { + this.currentState = global_constants.STATE_TERMINATED; + var result = this.storeData(true); + + if (!this.settings.sendBeaconCommit && !this.settings.asyncCommit && typeof result.errorCode !== 'undefined' && result.errorCode > 0) { + this.throwSCORMError(result.errorCode); + } + + returnValue = typeof result !== 'undefined' && result.result ? result.result : global_constants.SCORM_FALSE; + if (checkTerminated) this.lastErrorCode = 0; + returnValue = global_constants.SCORM_TRUE; + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Get the value of the CMIElement. + * + * @param {string} callbackName + * @param {boolean} checkTerminated + * @param {string} CMIElement + * @return {string} + */ + + }, { + key: "getValue", + value: function getValue(callbackName, checkTerminated, CMIElement) { + var returnValue; + + if (this.checkState(checkTerminated, _classPrivateFieldGet(this, _error_codes).RETRIEVE_BEFORE_INIT, _classPrivateFieldGet(this, _error_codes).RETRIEVE_AFTER_TERM)) { + if (checkTerminated) this.lastErrorCode = 0; + + try { + returnValue = this.getCMIValue(CMIElement); + } catch (e) { + if (e instanceof _exceptions.ValidationError) { + this.lastErrorCode = e.errorCode; + returnValue = global_constants.SCORM_FALSE; + } else { + if (e.message) { + console.error(e.message); + } else { + console.error(e); + } + + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).GENERAL); + } + } + + this.processListeners(callbackName, CMIElement); + } + + this.apiLog(callbackName, CMIElement, ': returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Sets the value of the CMIElement. + * + * @param {string} callbackName + * @param {string} commitCallback + * @param {boolean} checkTerminated + * @param {string} CMIElement + * @param {*} value + * @return {string} + */ + + }, { + key: "setValue", + value: function setValue(callbackName, commitCallback, checkTerminated, CMIElement, value) { + if (value !== undefined) { + value = String(value); + } + + var returnValue = global_constants.SCORM_FALSE; + + if (this.checkState(checkTerminated, _classPrivateFieldGet(this, _error_codes).STORE_BEFORE_INIT, _classPrivateFieldGet(this, _error_codes).STORE_AFTER_TERM)) { + if (checkTerminated) this.lastErrorCode = 0; + + try { + returnValue = this.setCMIValue(CMIElement, value); + } catch (e) { + if (e instanceof _exceptions.ValidationError) { + this.lastErrorCode = e.errorCode; + returnValue = global_constants.SCORM_FALSE; + } else { + if (e.message) { + console.error(e.message); + } else { + console.error(e); + } + + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).GENERAL); + } + } + + this.processListeners(callbackName, CMIElement, value); + } + + if (returnValue === undefined) { + returnValue = global_constants.SCORM_FALSE; + } // If we didn't have any errors while setting the data, go ahead and + // schedule a commit, if autocommit is turned on + + + if (String(this.lastErrorCode) === '0') { + if (this.settings.autocommit && !_classPrivateFieldGet(this, _timeout)) { + this.scheduleCommit(this.settings.autocommitSeconds * 1000, commitCallback); + } + } + + this.apiLog(callbackName, CMIElement, ': ' + value + ': result: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Orders LMS to store all content parameters + * @param {string} callbackName + * @param {boolean} checkTerminated + * @return {string} + */ + + }, { + key: "commit", + value: function commit(callbackName, checkTerminated) { + this.clearScheduledCommit(); + var returnValue = global_constants.SCORM_FALSE; + + if (this.checkState(checkTerminated, _classPrivateFieldGet(this, _error_codes).COMMIT_BEFORE_INIT, _classPrivateFieldGet(this, _error_codes).COMMIT_AFTER_TERM)) { + var result = this.storeData(false); + + if (!this.settings.sendBeaconCommit && !this.settings.asyncCommit && result.errorCode && result.errorCode > 0) { + this.throwSCORMError(result.errorCode); + } + + returnValue = typeof result !== 'undefined' && result.result ? result.result : global_constants.SCORM_FALSE; + this.apiLog(callbackName, 'HttpRequest', ' Result: ' + returnValue, global_constants.LOG_LEVEL_DEBUG); + if (checkTerminated) this.lastErrorCode = 0; + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Returns last error code + * @param {string} callbackName + * @return {string} + */ + + }, { + key: "getLastError", + value: function getLastError(callbackName) { + var returnValue = String(this.lastErrorCode); + this.processListeners(callbackName); + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + return returnValue; + } + /** + * Returns the errorNumber error description + * + * @param {string} callbackName + * @param {(string|number)} CMIErrorCode + * @return {string} + */ + + }, { + key: "getErrorString", + value: function getErrorString(callbackName, CMIErrorCode) { + var returnValue = ''; + + if (CMIErrorCode !== null && CMIErrorCode !== '') { + returnValue = this.getLmsErrorMessageDetails(CMIErrorCode); + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + return returnValue; + } + /** + * Returns a comprehensive description of the errorNumber error. + * + * @param {string} callbackName + * @param {(string|number)} CMIErrorCode + * @return {string} + */ + + }, { + key: "getDiagnostic", + value: function getDiagnostic(callbackName, CMIErrorCode) { + var returnValue = ''; + + if (CMIErrorCode !== null && CMIErrorCode !== '') { + returnValue = this.getLmsErrorMessageDetails(CMIErrorCode, true); + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + return returnValue; + } + /** + * Checks the LMS state and ensures it has been initialized. + * + * @param {boolean} checkTerminated + * @param {number} beforeInitError + * @param {number} afterTermError + * @return {boolean} + */ + + }, { + key: "checkState", + value: function checkState(checkTerminated, beforeInitError, afterTermError) { + if (this.isNotInitialized()) { + this.throwSCORMError(beforeInitError); + return false; + } else if (checkTerminated && this.isTerminated()) { + this.throwSCORMError(afterTermError); + return false; + } + + return true; + } + /** + * Logging for all SCORM actions + * + * @param {string} functionName + * @param {string} CMIElement + * @param {string} logMessage + * @param {number}messageLevel + */ + + }, { + key: "apiLog", + value: function apiLog(functionName, CMIElement, logMessage, messageLevel) { + logMessage = this.formatMessage(functionName, CMIElement, logMessage); + + if (messageLevel >= this.apiLogLevel) { + switch (messageLevel) { + case global_constants.LOG_LEVEL_ERROR: + console.error(logMessage); + break; + + case global_constants.LOG_LEVEL_WARNING: + console.warn(logMessage); + break; + + case global_constants.LOG_LEVEL_INFO: + console.info(logMessage); + break; + + case global_constants.LOG_LEVEL_DEBUG: + if (console.debug) { + console.debug(logMessage); + } else { + console.log(logMessage); + } + + break; + } + } + } + /** + * Formats the SCORM messages for easy reading + * + * @param {string} functionName + * @param {string} CMIElement + * @param {string} message + * @return {string} + */ + + }, { + key: "formatMessage", + value: function formatMessage(functionName, CMIElement, message) { + var baseLength = 20; + var messageString = ''; + messageString += functionName; + var fillChars = baseLength - messageString.length; + + for (var i = 0; i < fillChars; i++) { + messageString += ' '; + } + + messageString += ': '; + + if (CMIElement) { + var CMIElementBaseLength = 70; + messageString += CMIElement; + fillChars = CMIElementBaseLength - messageString.length; + + for (var j = 0; j < fillChars; j++) { + messageString += ' '; + } + } + + if (message) { + messageString += message; + } + + return messageString; + } + /** + * Checks to see if {str} contains {tester} + * + * @param {string} str String to check against + * @param {string} tester String to check for + * @return {boolean} + */ + + }, { + key: "stringMatches", + value: function stringMatches(str, tester) { + return str && tester && str.match(tester); + } + /** + * Check to see if the specific object has the given property + * @param {*} refObject + * @param {string} attribute + * @return {boolean} + * @private + */ + + }, { + key: "_checkObjectHasProperty", + value: function _checkObjectHasProperty(refObject, attribute) { + return Object.hasOwnProperty.call(refObject, attribute) || Object.getOwnPropertyDescriptor(Object.getPrototypeOf(refObject), attribute) || attribute in refObject; + } + /** + * Returns the message that corresponds to errorNumber + * APIs that inherit BaseAPI should override this function + * + * @param {(string|number)} _errorNumber + * @param {boolean} _detail + * @return {string} + * @abstract + */ + + }, { + key: "getLmsErrorMessageDetails", + value: function getLmsErrorMessageDetails(_errorNumber, _detail) { + throw new Error('The getLmsErrorMessageDetails method has not been implemented'); + } + /** + * Gets the value for the specific element. + * APIs that inherit BaseAPI should override this function + * + * @param {string} _CMIElement + * @return {string} + * @abstract + */ + + }, { + key: "getCMIValue", + value: function getCMIValue(_CMIElement) { + throw new Error('The getCMIValue method has not been implemented'); + } + /** + * Sets the value for the specific element. + * APIs that inherit BaseAPI should override this function + * + * @param {string} _CMIElement + * @param {any} _value + * @return {string} + * @abstract + */ + + }, { + key: "setCMIValue", + value: function setCMIValue(_CMIElement, _value) { + throw new Error('The setCMIValue method has not been implemented'); + } + /** + * Shared API method to set a valid for a given element. + * + * @param {string} methodName + * @param {boolean} scorm2004 + * @param {string} CMIElement + * @param {*} value + * @return {string} + */ + + }, { + key: "_commonSetCMIValue", + value: function _commonSetCMIValue(methodName, scorm2004, CMIElement, value) { + if (!CMIElement || CMIElement === '') { + return global_constants.SCORM_FALSE; + } + + var structure = CMIElement.split('.'); + var refObject = this; + var returnValue = global_constants.SCORM_FALSE; + var foundFirstIndex = false; + var invalidErrorMessage = "The data model element passed to ".concat(methodName, " (").concat(CMIElement, ") is not a valid SCORM data model element."); + var invalidErrorCode = scorm2004 ? _classPrivateFieldGet(this, _error_codes).UNDEFINED_DATA_MODEL : _classPrivateFieldGet(this, _error_codes).GENERAL; + + for (var i = 0; i < structure.length; i++) { + var attribute = structure[i]; + + if (i === structure.length - 1) { + if (scorm2004 && attribute.substr(0, 8) === '{target=' && typeof refObject._isTargetValid == 'function') { + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).READ_ONLY_ELEMENT); + } else if (!this._checkObjectHasProperty(refObject, attribute)) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + } else { + if (this.isInitialized() && this.stringMatches(CMIElement, '\\.correct_responses\\.\\d+')) { + this.validateCorrectResponse(CMIElement, value); + } + + if (!scorm2004 || this.lastErrorCode === 0) { + refObject[attribute] = value; + returnValue = global_constants.SCORM_TRUE; + } + } + } else { + refObject = refObject[attribute]; + + if (!refObject) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + break; + } + + if (refObject instanceof _common.CMIArray) { + var index = parseInt(structure[i + 1], 10); // SCO is trying to set an item on an array + + if (!isNaN(index)) { + var item = refObject.childArray[index]; + + if (item) { + refObject = item; + foundFirstIndex = true; + } else { + var newChild = this.getChildElement(CMIElement, value, foundFirstIndex); + foundFirstIndex = true; + + if (!newChild) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + } else { + if (refObject.initialized) newChild.initialize(); + refObject.childArray.push(newChild); + refObject = newChild; + } + } // Have to update i value to skip the array position + + + i++; + } + } + } + } + + if (returnValue === global_constants.SCORM_FALSE) { + this.apiLog(methodName, null, "There was an error setting the value for: ".concat(CMIElement, ", value of: ").concat(value), global_constants.LOG_LEVEL_WARNING); + } + + return returnValue; + } + /** + * Abstract method for validating that a response is correct. + * + * @param {string} _CMIElement + * @param {*} _value + */ + + }, { + key: "validateCorrectResponse", + value: function validateCorrectResponse(_CMIElement, _value) {// just a stub method + } + /** + * Gets or builds a new child element to add to the array. + * APIs that inherit BaseAPI should override this method. + * + * @param {string} _CMIElement - unused + * @param {*} _value - unused + * @param {boolean} _foundFirstIndex - unused + * @return {*} + * @abstract + */ + + }, { + key: "getChildElement", + value: function getChildElement(_CMIElement, _value, _foundFirstIndex) { + throw new Error('The getChildElement method has not been implemented'); + } + /** + * Gets a value from the CMI Object + * + * @param {string} methodName + * @param {boolean} scorm2004 + * @param {string} CMIElement + * @return {*} + */ + + }, { + key: "_commonGetCMIValue", + value: function _commonGetCMIValue(methodName, scorm2004, CMIElement) { + if (!CMIElement || CMIElement === '') { + return ''; + } + + var structure = CMIElement.split('.'); + var refObject = this; + var attribute = null; + var uninitializedErrorMessage = "The data model element passed to ".concat(methodName, " (").concat(CMIElement, ") has not been initialized."); + var invalidErrorMessage = "The data model element passed to ".concat(methodName, " (").concat(CMIElement, ") is not a valid SCORM data model element."); + var invalidErrorCode = scorm2004 ? _classPrivateFieldGet(this, _error_codes).UNDEFINED_DATA_MODEL : _classPrivateFieldGet(this, _error_codes).GENERAL; + + for (var i = 0; i < structure.length; i++) { + attribute = structure[i]; + + if (!scorm2004) { + if (i === structure.length - 1) { + if (!this._checkObjectHasProperty(refObject, attribute)) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + return; + } + } + } else { + if (String(attribute).substr(0, 8) === '{target=' && typeof refObject._isTargetValid == 'function') { + var target = String(attribute).substr(8, String(attribute).length - 9); + return refObject._isTargetValid(target); + } else if (!this._checkObjectHasProperty(refObject, attribute)) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + return; + } + } + + refObject = refObject[attribute]; + + if (refObject === undefined) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + break; + } + + if (refObject instanceof _common.CMIArray) { + var index = parseInt(structure[i + 1], 10); // SCO is trying to set an item on an array + + if (!isNaN(index)) { + var item = refObject.childArray[index]; + + if (item) { + refObject = item; + } else { + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).VALUE_NOT_INITIALIZED, uninitializedErrorMessage); + break; + } // Have to update i value to skip the array position + + + i++; + } + } + } + + if (refObject === null || refObject === undefined) { + if (!scorm2004) { + if (attribute === '_children') { + this.throwSCORMError(scorm12_error_codes.CHILDREN_ERROR); + } else if (attribute === '_count') { + this.throwSCORMError(scorm12_error_codes.COUNT_ERROR); + } + } + } else { + return refObject; + } + } + /** + * Returns true if the API's current state is STATE_INITIALIZED + * + * @return {boolean} + */ + + }, { + key: "isInitialized", + value: function isInitialized() { + return this.currentState === global_constants.STATE_INITIALIZED; + } + /** + * Returns true if the API's current state is STATE_NOT_INITIALIZED + * + * @return {boolean} + */ + + }, { + key: "isNotInitialized", + value: function isNotInitialized() { + return this.currentState === global_constants.STATE_NOT_INITIALIZED; + } + /** + * Returns true if the API's current state is STATE_TERMINATED + * + * @return {boolean} + */ + + }, { + key: "isTerminated", + value: function isTerminated() { + return this.currentState === global_constants.STATE_TERMINATED; + } + /** + * Provides a mechanism for attaching to a specific SCORM event + * + * @param {string} listenerName + * @param {function} callback + */ + + }, { + key: "on", + value: function on(listenerName, callback) { + if (!callback) return; + var listenerFunctions = listenerName.split(' '); + + for (var i = 0; i < listenerFunctions.length; i++) { + var listenerSplit = listenerFunctions[i].split('.'); + if (listenerSplit.length === 0) return; + var functionName = listenerSplit[0]; + var CMIElement = null; + + if (listenerSplit.length > 1) { + CMIElement = listenerName.replace(functionName + '.', ''); + } + + this.listenerArray.push({ + functionName: functionName, + CMIElement: CMIElement, + callback: callback + }); + this.apiLog('on', functionName, "Added event listener: ".concat(this.listenerArray.length), global_constants.LOG_LEVEL_INFO); + } + } + /** + * Provides a mechanism for detaching a specific SCORM event listener + * + * @param {string} listenerName + * @param {function} callback + */ + + }, { + key: "off", + value: function off(listenerName, callback) { + var _this = this; + + if (!callback) return; + var listenerFunctions = listenerName.split(' '); + + var _loop = function _loop(i) { + var listenerSplit = listenerFunctions[i].split('.'); + if (listenerSplit.length === 0) return { + v: void 0 + }; + var functionName = listenerSplit[0]; + var CMIElement = null; + + if (listenerSplit.length > 1) { + CMIElement = listenerName.replace(functionName + '.', ''); + } + + var removeIndex = _this.listenerArray.findIndex(function (obj) { + return obj.functionName === functionName && obj.CMIElement === CMIElement && obj.callback === callback; + }); + + if (removeIndex !== -1) { + _this.listenerArray.splice(removeIndex, 1); + + _this.apiLog('off', functionName, "Removed event listener: ".concat(_this.listenerArray.length), global_constants.LOG_LEVEL_INFO); + } + }; + + for (var i = 0; i < listenerFunctions.length; i++) { + var _ret = _loop(i); + + if (_typeof(_ret) === "object") return _ret.v; + } + } + /** + * Provides a mechanism for clearing all listeners from a specific SCORM event + * + * @param {string} listenerName + */ + + }, { + key: "clear", + value: function clear(listenerName) { + var _this2 = this; + + var listenerFunctions = listenerName.split(' '); + + var _loop2 = function _loop2(i) { + var listenerSplit = listenerFunctions[i].split('.'); + if (listenerSplit.length === 0) return { + v: void 0 + }; + var functionName = listenerSplit[0]; + var CMIElement = null; + + if (listenerSplit.length > 1) { + CMIElement = listenerName.replace(functionName + '.', ''); + } + + _this2.listenerArray = _this2.listenerArray.filter(function (obj) { + return obj.functionName !== functionName && obj.CMIElement !== CMIElement; + }); + }; + + for (var i = 0; i < listenerFunctions.length; i++) { + var _ret2 = _loop2(i); + + if (_typeof(_ret2) === "object") return _ret2.v; + } + } + /** + * Processes any 'on' listeners that have been created + * + * @param {string} functionName + * @param {string} CMIElement + * @param {*} value + */ + + }, { + key: "processListeners", + value: function processListeners(functionName, CMIElement, value) { + this.apiLog(functionName, CMIElement, value); + + for (var i = 0; i < this.listenerArray.length; i++) { + var listener = this.listenerArray[i]; + var functionsMatch = listener.functionName === functionName; + var listenerHasCMIElement = !!listener.CMIElement; + var CMIElementsMatch = false; + + if (CMIElement && listener.CMIElement && listener.CMIElement.substring(listener.CMIElement.length - 1) === '*') { + CMIElementsMatch = CMIElement.indexOf(listener.CMIElement.substring(0, listener.CMIElement.length - 1)) === 0; + } else { + CMIElementsMatch = listener.CMIElement === CMIElement; + } + + if (functionsMatch && (!listenerHasCMIElement || CMIElementsMatch)) { + listener.callback(CMIElement, value); + } + } + } + /** + * Throws a SCORM error + * + * @param {number} errorNumber + * @param {string} message + */ + + }, { + key: "throwSCORMError", + value: function throwSCORMError(errorNumber, message) { + if (!message) { + message = this.getLmsErrorMessageDetails(errorNumber); + } + + this.apiLog('throwSCORMError', null, errorNumber + ': ' + message, global_constants.LOG_LEVEL_ERROR); + this.lastErrorCode = String(errorNumber); + } + /** + * Clears the last SCORM error code on success. + * + * @param {string} success + */ + + }, { + key: "clearSCORMError", + value: function clearSCORMError(success) { + if (success !== undefined && success !== global_constants.SCORM_FALSE) { + this.lastErrorCode = 0; + } + } + /** + * Attempts to store the data to the LMS, logs data if no LMS configured + * APIs that inherit BaseAPI should override this function + * + * @param {boolean} _calculateTotalTime + * @return {string} + * @abstract + */ + + }, { + key: "storeData", + value: function storeData(_calculateTotalTime) { + throw new Error('The storeData method has not been implemented'); + } + /** + * Load the CMI from a flattened JSON object + * @param {object} json + * @param {string} CMIElement + */ + + }, { + key: "loadFromFlattenedJSON", + value: function loadFromFlattenedJSON(json, CMIElement) { + var _this3 = this; + + if (!this.isNotInitialized()) { + console.error('loadFromFlattenedJSON can only be called before the call to lmsInitialize.'); + return; + } + /** + * Test match pattern. + * + * @param {string} a + * @param {string} c + * @param {RegExp} a_pattern + * @return {number} + */ + + + function testPattern(a, c, a_pattern) { + var a_match = a.match(a_pattern); + var c_match; + + if (a_match !== null && (c_match = c.match(a_pattern)) !== null) { + var a_num = Number(a_match[2]); + var c_num = Number(c_match[2]); + + if (a_num === c_num) { + if (a_match[3] === 'id') { + return -1; + } else if (a_match[3] === 'type') { + if (c_match[3] === 'id') { + return 1; + } else { + return -1; + } + } else { + return 1; + } + } + + return a_num - c_num; + } + + return null; + } + + var int_pattern = /^(cmi\.interactions\.)(\d+)\.(.*)$/; + var obj_pattern = /^(cmi\.objectives\.)(\d+)\.(.*)$/; + var result = Object.keys(json).map(function (key) { + return [String(key), json[key]]; + }); // CMI interactions need to have id and type loaded before any other fields + + result.sort(function (_ref, _ref2) { + var _ref3 = _slicedToArray(_ref, 2), + a = _ref3[0], + b = _ref3[1]; + + var _ref4 = _slicedToArray(_ref2, 2), + c = _ref4[0], + d = _ref4[1]; + + var test; + + if ((test = testPattern(a, c, int_pattern)) !== null) { + return test; + } + + if ((test = testPattern(a, c, obj_pattern)) !== null) { + return test; + } + + if (a < c) { + return -1; + } + + if (a > c) { + return 1; + } + + return 0; + }); + var obj; + result.forEach(function (element) { + obj = {}; + obj[element[0]] = element[1]; + + _this3.loadFromJSON((0, _utilities.unflatten)(obj), CMIElement); + }); + } + /** + * Loads CMI data from a JSON object. + * + * @param {object} json + * @param {string} CMIElement + */ + + }, { + key: "loadFromJSON", + value: function loadFromJSON(json, CMIElement) { + if (!this.isNotInitialized()) { + console.error('loadFromJSON can only be called before the call to lmsInitialize.'); + return; + } + + CMIElement = CMIElement !== undefined ? CMIElement : 'cmi'; + this.startingData = json; // could this be refactored down to flatten(json) then setCMIValue on each? + + for (var key in json) { + if ({}.hasOwnProperty.call(json, key) && json[key]) { + var currentCMIElement = (CMIElement ? CMIElement + '.' : '') + key; + var value = json[key]; + + if (value['childArray']) { + for (var i = 0; i < value['childArray'].length; i++) { + this.loadFromJSON(value['childArray'][i], currentCMIElement + '.' + i); + } + } else if (value.constructor === Object) { + this.loadFromJSON(value, currentCMIElement); + } else { + this.setCMIValue(currentCMIElement, value); + } + } + } + } + /** + * Render the CMI object to JSON for sending to an LMS. + * + * @return {string} + */ + + }, { + key: "renderCMIToJSONString", + value: function renderCMIToJSONString() { + var cmi = this.cmi; // Do we want/need to return fields that have no set value? + // return JSON.stringify({ cmi }, (k, v) => v === undefined ? null : v, 2); + + return JSON.stringify({ + cmi: cmi + }); + } + /** + * Returns a JS object representing the current cmi + * @return {object} + */ + + }, { + key: "renderCMIToJSONObject", + value: function renderCMIToJSONObject() { + // Do we want/need to return fields that have no set value? + // return JSON.stringify({ cmi }, (k, v) => v === undefined ? null : v, 2); + return JSON.parse(this.renderCMIToJSONString()); + } + /** + * Render the cmi object to the proper format for LMS commit + * APIs that inherit BaseAPI should override this function + * + * @param {boolean} _terminateCommit + * @return {*} + * @abstract + */ + + }, { + key: "renderCommitCMI", + value: function renderCommitCMI(_terminateCommit) { + throw new Error('The storeData method has not been implemented'); + } + /** + * Send the request to the LMS + * @param {string} url + * @param {object|Array} params + * @param {boolean} immediate + * @return {object} + */ + + }, { + key: "processHttpRequest", + value: function processHttpRequest(url, params) { + var immediate = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + var api = this; + + var process = function process(url, params, settings, error_codes) { + var genericError = { + 'result': global_constants.SCORM_FALSE, + 'errorCode': error_codes.GENERAL + }; + var result; + + if (!settings.sendBeaconCommit) { + var httpReq = new XMLHttpRequest(); + httpReq.open('POST', url, settings.asyncCommit); + + if (settings.asyncCommit) { + httpReq.onload = function (e) { + if (typeof settings.responseHandler === 'function') { + result = settings.responseHandler(httpReq); + } else { + result = JSON.parse(httpReq.responseText); + } + }; + } + + try { + if (params instanceof Array) { + httpReq.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded'); + httpReq.send(params.join('&')); + } else { + httpReq.setRequestHeader('Content-Type', settings.commitRequestDataType); + httpReq.send(JSON.stringify(params)); + } + + if (!settings.asyncCommit) { + if (typeof settings.responseHandler === 'function') { + result = settings.responseHandler(httpReq); + } else { + result = JSON.parse(httpReq.responseText); + } + } else { + result = {}; + result.result = global_constants.SCORM_TRUE; + result.errorCode = 0; + api.processListeners('CommitSuccess'); + return result; + } + } catch (e) { + console.error(e); + api.processListeners('CommitError'); + return genericError; + } + } else { + try { + var headers = { + type: settings.commitRequestDataType + }; + var blob; + + if (params instanceof Array) { + blob = new Blob([params.join('&')], headers); + } else { + blob = new Blob([JSON.stringify(params)], headers); + } + + result = {}; + + if (navigator.sendBeacon(url, blob)) { + result.result = global_constants.SCORM_TRUE; + result.errorCode = 0; + } else { + result.result = global_constants.SCORM_FALSE; + result.errorCode = 101; + } + } catch (e) { + console.error(e); + api.processListeners('CommitError'); + return genericError; + } + } + + if (typeof result === 'undefined') { + api.processListeners('CommitError'); + return genericError; + } + + if (result.result === true || result.result === global_constants.SCORM_TRUE) { + api.processListeners('CommitSuccess'); + } else { + api.processListeners('CommitError'); + } + + return result; + }; + + if (typeof _lodash["default"] !== 'undefined') { + var debounced = (0, _lodash["default"])(process, 500); + debounced(url, params, this.settings, this.error_codes); // if we're terminating, go ahead and commit immediately + + if (immediate) { + debounced.flush(); + } + + return { + result: global_constants.SCORM_TRUE, + errorCode: 0 + }; + } else { + return process(url, params, this.settings, this.error_codes); + } + } + /** + * Throws a SCORM error + * + * @param {number} when - the number of milliseconds to wait before committing + * @param {string} callback - the name of the commit event callback + */ + + }, { + key: "scheduleCommit", + value: function scheduleCommit(when, callback) { + _classPrivateFieldSet(this, _timeout, new ScheduledCommit(this, when, callback)); + + this.apiLog('scheduleCommit', '', 'scheduled', global_constants.LOG_LEVEL_DEBUG); + } + /** + * Clears and cancels any currently scheduled commits + */ + + }, { + key: "clearScheduledCommit", + value: function clearScheduledCommit() { + if (_classPrivateFieldGet(this, _timeout)) { + _classPrivateFieldGet(this, _timeout).cancel(); + + _classPrivateFieldSet(this, _timeout, null); + + this.apiLog('clearScheduledCommit', '', 'cleared', global_constants.LOG_LEVEL_DEBUG); + } + } + }]); + + return BaseAPI; +}(); +/** + * Private class that wraps a timeout call to the commit() function + */ + + +exports["default"] = BaseAPI; + +var _API = new WeakMap(); + +var _cancelled = new WeakMap(); + +var _timeout2 = new WeakMap(); + +var _callback = new WeakMap(); + +var ScheduledCommit = /*#__PURE__*/function () { + /** + * Constructor for ScheduledCommit + * @param {BaseAPI} API + * @param {number} when + * @param {string} callback + */ + function ScheduledCommit(API, when, callback) { + _classCallCheck(this, ScheduledCommit); + + _API.set(this, { + writable: true, + value: void 0 + }); + + _cancelled.set(this, { + writable: true, + value: false + }); + + _timeout2.set(this, { + writable: true, + value: void 0 + }); + + _callback.set(this, { + writable: true, + value: void 0 + }); + + _classPrivateFieldSet(this, _API, API); + + _classPrivateFieldSet(this, _timeout2, setTimeout(this.wrapper.bind(this), when)); + + _classPrivateFieldSet(this, _callback, callback); + } + /** + * Cancel any currently scheduled commit + */ + + + _createClass(ScheduledCommit, [{ + key: "cancel", + value: function cancel() { + _classPrivateFieldSet(this, _cancelled, true); + + if (_classPrivateFieldGet(this, _timeout2)) { + clearTimeout(_classPrivateFieldGet(this, _timeout2)); + } + } + /** + * Wrap the API commit call to check if the call has already been cancelled + */ + + }, { + key: "wrapper", + value: function wrapper() { + if (!_classPrivateFieldGet(this, _cancelled)) { + _classPrivateFieldGet(this, _API).commit(_classPrivateFieldGet(this, _callback)); + } + } + }]); + + return ScheduledCommit; +}(); + +},{"./cmi/common":4,"./constants/api_constants":6,"./constants/error_codes":7,"./exceptions":9,"./utilities":11,"lodash.debounce":1}],3:[function(require,module,exports){ +"use strict"; + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +var _BaseAPI2 = _interopRequireDefault(require("./BaseAPI")); + +var _scorm12_cmi = require("./cmi/scorm12_cmi"); + +var Utilities = _interopRequireWildcard(require("./utilities")); + +var _api_constants = _interopRequireDefault(require("./constants/api_constants")); + +var _error_codes = _interopRequireDefault(require("./constants/error_codes")); + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +var scorm12_constants = _api_constants["default"].scorm12; +var global_constants = _api_constants["default"].global; +var scorm12_error_codes = _error_codes["default"].scorm12; +/** + * API class for SCORM 1.2 + */ + +var Scorm12API = /*#__PURE__*/function (_BaseAPI) { + _inherits(Scorm12API, _BaseAPI); + + var _super = _createSuper(Scorm12API); + + /** + * Constructor for SCORM 1.2 API + * @param {object} settings + */ + function Scorm12API(settings) { + var _this; + + _classCallCheck(this, Scorm12API); + + var finalSettings = _objectSpread(_objectSpread({}, { + mastery_override: false + }), settings); + + _this = _super.call(this, scorm12_error_codes, finalSettings); + _this.cmi = new _scorm12_cmi.CMI(); + _this.nav = new _scorm12_cmi.NAV(); // Rename functions to match 1.2 Spec and expose to modules + + _this.LMSInitialize = _this.lmsInitialize; + _this.LMSFinish = _this.lmsFinish; + _this.LMSGetValue = _this.lmsGetValue; + _this.LMSSetValue = _this.lmsSetValue; + _this.LMSCommit = _this.lmsCommit; + _this.LMSGetLastError = _this.lmsGetLastError; + _this.LMSGetErrorString = _this.lmsGetErrorString; + _this.LMSGetDiagnostic = _this.lmsGetDiagnostic; + return _this; + } + /** + * lmsInitialize function from SCORM 1.2 Spec + * + * @return {string} bool + */ + + + _createClass(Scorm12API, [{ + key: "lmsInitialize", + value: function lmsInitialize() { + this.cmi.initialize(); + return this.initialize('LMSInitialize', 'LMS was already initialized!', 'LMS is already finished!'); + } + /** + * LMSFinish function from SCORM 1.2 Spec + * + * @return {string} bool + */ + + }, { + key: "lmsFinish", + value: function lmsFinish() { + var result = this.terminate('LMSFinish', true); + + if (result === global_constants.SCORM_TRUE) { + if (this.nav.event !== '') { + if (this.nav.event === 'continue') { + this.processListeners('SequenceNext'); + } else { + this.processListeners('SequencePrevious'); + } + } else if (this.settings.autoProgress) { + this.processListeners('SequenceNext'); + } + } + + return result; + } + /** + * LMSGetValue function from SCORM 1.2 Spec + * + * @param {string} CMIElement + * @return {string} + */ + + }, { + key: "lmsGetValue", + value: function lmsGetValue(CMIElement) { + return this.getValue('LMSGetValue', false, CMIElement); + } + /** + * LMSSetValue function from SCORM 1.2 Spec + * + * @param {string} CMIElement + * @param {*} value + * @return {string} + */ + + }, { + key: "lmsSetValue", + value: function lmsSetValue(CMIElement, value) { + return this.setValue('LMSSetValue', 'LMSCommit', false, CMIElement, value); + } + /** + * LMSCommit function from SCORM 1.2 Spec + * + * @return {string} bool + */ + + }, { + key: "lmsCommit", + value: function lmsCommit() { + return this.commit('LMSCommit', false); + } + /** + * LMSGetLastError function from SCORM 1.2 Spec + * + * @return {string} + */ + + }, { + key: "lmsGetLastError", + value: function lmsGetLastError() { + return this.getLastError('LMSGetLastError'); + } + /** + * LMSGetErrorString function from SCORM 1.2 Spec + * + * @param {string} CMIErrorCode + * @return {string} + */ + + }, { + key: "lmsGetErrorString", + value: function lmsGetErrorString(CMIErrorCode) { + return this.getErrorString('LMSGetErrorString', CMIErrorCode); + } + /** + * LMSGetDiagnostic function from SCORM 1.2 Spec + * + * @param {string} CMIErrorCode + * @return {string} + */ + + }, { + key: "lmsGetDiagnostic", + value: function lmsGetDiagnostic(CMIErrorCode) { + return this.getDiagnostic('LMSGetDiagnostic', CMIErrorCode); + } + /** + * Sets a value on the CMI Object + * + * @param {string} CMIElement + * @param {*} value + * @return {string} + */ + + }, { + key: "setCMIValue", + value: function setCMIValue(CMIElement, value) { + return this._commonSetCMIValue('LMSSetValue', false, CMIElement, value); + } + /** + * Gets a value from the CMI Object + * + * @param {string} CMIElement + * @return {*} + */ + + }, { + key: "getCMIValue", + value: function getCMIValue(CMIElement) { + return this._commonGetCMIValue('getCMIValue', false, CMIElement); + } + /** + * Gets or builds a new child element to add to the array. + * + * @param {string} CMIElement + * @param {*} value + * @param {boolean} foundFirstIndex + * @return {object} + */ + + }, { + key: "getChildElement", + value: function getChildElement(CMIElement, value, foundFirstIndex) { + var newChild; + + if (this.stringMatches(CMIElement, 'cmi\\.objectives\\.\\d+')) { + newChild = new _scorm12_cmi.CMIObjectivesObject(); + } else if (foundFirstIndex && this.stringMatches(CMIElement, 'cmi\\.interactions\\.\\d+\\.correct_responses\\.\\d+')) { + newChild = new _scorm12_cmi.CMIInteractionsCorrectResponsesObject(); + } else if (foundFirstIndex && this.stringMatches(CMIElement, 'cmi\\.interactions\\.\\d+\\.objectives\\.\\d+')) { + newChild = new _scorm12_cmi.CMIInteractionsObjectivesObject(); + } else if (!foundFirstIndex && this.stringMatches(CMIElement, 'cmi\\.interactions\\.\\d+')) { + newChild = new _scorm12_cmi.CMIInteractionsObject(); + } + + return newChild; + } + /** + * Validates Correct Response values + * + * @param {string} CMIElement + * @param {*} value + * @return {boolean} + */ + + }, { + key: "validateCorrectResponse", + value: function validateCorrectResponse(CMIElement, value) { + return true; + } + /** + * Returns the message that corresponds to errorNumber. + * + * @param {*} errorNumber + * @param {boolean} detail + * @return {string} + */ + + }, { + key: "getLmsErrorMessageDetails", + value: function getLmsErrorMessageDetails(errorNumber, detail) { + var basicMessage = 'No Error'; + var detailMessage = 'No Error'; // Set error number to string since inconsistent from modules if string or number + + errorNumber = String(errorNumber); + + if (scorm12_constants.error_descriptions[errorNumber]) { + basicMessage = scorm12_constants.error_descriptions[errorNumber].basicMessage; + detailMessage = scorm12_constants.error_descriptions[errorNumber].detailMessage; + } + + return detail ? detailMessage : basicMessage; + } + /** + * Replace the whole API with another + * + * @param {Scorm12API} newAPI + */ + + }, { + key: "replaceWithAnotherScormAPI", + value: function replaceWithAnotherScormAPI(newAPI) { + // Data Model + this.cmi = newAPI.cmi; + } + /** + * Render the cmi object to the proper format for LMS commit + * + * @param {boolean} terminateCommit + * @return {object|Array} + */ + + }, { + key: "renderCommitCMI", + value: function renderCommitCMI(terminateCommit) { + var cmiExport = this.renderCMIToJSONObject(); + + if (terminateCommit) { + cmiExport.cmi.core.total_time = this.cmi.getCurrentTotalTime(); + } + + var result = []; + var flattened = Utilities.flatten(cmiExport); + + switch (this.settings.dataCommitFormat) { + case 'flattened': + return Utilities.flatten(cmiExport); + + case 'params': + for (var item in flattened) { + if ({}.hasOwnProperty.call(flattened, item)) { + result.push("".concat(item, "=").concat(flattened[item])); + } + } + + return result; + + case 'json': + default: + return cmiExport; + } + } + /** + * Attempts to store the data to the LMS + * + * @param {boolean} terminateCommit + * @return {string} + */ + + }, { + key: "storeData", + value: function storeData(terminateCommit) { + if (terminateCommit) { + var originalStatus = this.cmi.core.lesson_status; + + if (originalStatus === 'not attempted') { + this.cmi.core.lesson_status = 'completed'; + } + + if (this.cmi.core.lesson_mode === 'normal') { + if (this.cmi.core.credit === 'credit') { + if (this.settings.mastery_override && this.cmi.student_data.mastery_score !== '' && this.cmi.core.score.raw !== '') { + if (parseFloat(this.cmi.core.score.raw) >= parseFloat(this.cmi.student_data.mastery_score)) { + this.cmi.core.lesson_status = 'passed'; + } else { + this.cmi.core.lesson_status = 'failed'; + } + } + } + } else if (this.cmi.core.lesson_mode === 'browse') { + var _this$startingData, _this$startingData$cm, _this$startingData$cm2; + + if ((((_this$startingData = this.startingData) === null || _this$startingData === void 0 ? void 0 : (_this$startingData$cm = _this$startingData.cmi) === null || _this$startingData$cm === void 0 ? void 0 : (_this$startingData$cm2 = _this$startingData$cm.core) === null || _this$startingData$cm2 === void 0 ? void 0 : _this$startingData$cm2.lesson_status) || '') === '' && originalStatus === 'not attempted') { + this.cmi.core.lesson_status = 'browsed'; + } + } + } + + var commitObject = this.renderCommitCMI(terminateCommit || this.settings.alwaysSendTotalTime); + + if (this.apiLogLevel === global_constants.LOG_LEVEL_DEBUG) { + console.debug('Commit (terminated: ' + (terminateCommit ? 'yes' : 'no') + '): '); + console.debug(commitObject); + } + + if (this.settings.lmsCommitUrl) { + return this.processHttpRequest(this.settings.lmsCommitUrl, commitObject, terminateCommit); + } else { + return global_constants.SCORM_TRUE; + } + } + }]); + + return Scorm12API; +}(_BaseAPI2["default"]); + +exports["default"] = Scorm12API; + +},{"./BaseAPI":2,"./cmi/scorm12_cmi":5,"./constants/api_constants":6,"./constants/error_codes":7,"./utilities":11}],4:[function(require,module,exports){ +"use strict"; + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.checkValidFormat = checkValidFormat; +exports.checkValidRange = checkValidRange; +exports.CMIArray = exports.CMIScore = exports.BaseCMI = void 0; + +var _api_constants = _interopRequireDefault(require("../constants/api_constants")); + +var _error_codes = _interopRequireDefault(require("../constants/error_codes")); + +var _regex = _interopRequireDefault(require("../constants/regex")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; } + +function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } } + +function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); } + +function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); } + +function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +var scorm12_constants = _api_constants["default"].scorm12; +var scorm12_regex = _regex["default"].scorm12; +var scorm12_error_codes = _error_codes["default"].scorm12; +/** + * Check if the value matches the proper format. If not, throw proper error code. + * + * @param {string} value + * @param {string} regexPattern + * @param {number} errorCode + * @param {class} errorClass + * @param {boolean} allowEmptyString + * @return {boolean} + */ + +function checkValidFormat(value, regexPattern, errorCode, errorClass, allowEmptyString) { + var formatRegex = new RegExp(regexPattern); + var matches = value.match(formatRegex); + + if (allowEmptyString && value === '') { + return true; + } + + if (value === undefined || !matches || matches[0] === '') { + throw new errorClass.prototype.constructor(errorCode); + } + + return true; +} +/** + * Check if the value matches the proper range. If not, throw proper error code. + * + * @param {*} value + * @param {string} rangePattern + * @param {number} errorCode + * @param {class} errorClass + * @return {boolean} + */ + + +function checkValidRange(value, rangePattern, errorCode, errorClass) { + var ranges = rangePattern.split('#'); + value = value * 1.0; + + if (value >= ranges[0]) { + if (ranges[1] === '*' || value <= ranges[1]) { + return true; + } else { + throw new errorClass.prototype.constructor(errorCode); + } + } else { + throw new errorClass.prototype.constructor(errorCode); + } +} +/** + * Base class for API cmi objects + */ + + +var _initialized = new WeakMap(); + +var _start_time = new WeakMap(); + +var BaseCMI = /*#__PURE__*/function () { + /** + * Constructor for BaseCMI, just marks the class as abstract + */ + function BaseCMI() { + _classCallCheck(this, BaseCMI); + + _defineProperty(this, "jsonString", false); + + _initialized.set(this, { + writable: true, + value: false + }); + + _start_time.set(this, { + writable: true, + value: void 0 + }); + + if ((this instanceof BaseCMI ? this.constructor : void 0) === BaseCMI) { + throw new TypeError('Cannot construct BaseCMI instances directly'); + } + } + /** + * Getter for #initialized + * @return {boolean} + */ + + + _createClass(BaseCMI, [{ + key: "initialized", + get: function get() { + return _classPrivateFieldGet(this, _initialized); + } + /** + * Getter for #start_time + * @return {Number} + */ + + }, { + key: "start_time", + get: function get() { + return _classPrivateFieldGet(this, _start_time); + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + }, { + key: "initialize", + value: function initialize() { + _classPrivateFieldSet(this, _initialized, true); + } + /** + * Called when the player should override the 'session_time' provided by + * the module + */ + + }, { + key: "setStartTime", + value: function setStartTime() { + _classPrivateFieldSet(this, _start_time, new Date().getTime()); + } + }]); + + return BaseCMI; +}(); +/** + * Base class for cmi *.score objects + */ + + +exports.BaseCMI = BaseCMI; + +var _children2 = new WeakMap(); + +var _score_range = new WeakMap(); + +var _invalid_error_code = new WeakMap(); + +var _invalid_type_code = new WeakMap(); + +var _invalid_range_code = new WeakMap(); + +var _decimal_regex = new WeakMap(); + +var _error_class = new WeakMap(); + +var _raw = new WeakMap(); + +var _min = new WeakMap(); + +var _max = new WeakMap(); + +var CMIScore = /*#__PURE__*/function (_BaseCMI) { + _inherits(CMIScore, _BaseCMI); + + var _super = _createSuper(CMIScore); + + /** + * Constructor for *.score + * @param {string} score_children + * @param {string} score_range + * @param {string} max + * @param {number} invalidErrorCode + * @param {number} invalidTypeCode + * @param {number} invalidRangeCode + * @param {string} decimalRegex + * @param {class} errorClass + */ + function CMIScore(_ref) { + var _this; + + var score_children = _ref.score_children, + score_range = _ref.score_range, + max = _ref.max, + invalidErrorCode = _ref.invalidErrorCode, + invalidTypeCode = _ref.invalidTypeCode, + invalidRangeCode = _ref.invalidRangeCode, + decimalRegex = _ref.decimalRegex, + errorClass = _ref.errorClass; + + _classCallCheck(this, CMIScore); + + _this = _super.call(this); + + _children2.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _score_range.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _invalid_error_code.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _invalid_type_code.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _invalid_range_code.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _decimal_regex.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _error_class.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _raw.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _min.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _max.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _classPrivateFieldSet(_assertThisInitialized(_this), _children2, score_children || scorm12_constants.score_children); + + _classPrivateFieldSet(_assertThisInitialized(_this), _score_range, !score_range ? false : scorm12_regex.score_range); + + _classPrivateFieldSet(_assertThisInitialized(_this), _max, max || max === '' ? max : '100'); + + _classPrivateFieldSet(_assertThisInitialized(_this), _invalid_error_code, invalidErrorCode || scorm12_error_codes.INVALID_SET_VALUE); + + _classPrivateFieldSet(_assertThisInitialized(_this), _invalid_type_code, invalidTypeCode || scorm12_error_codes.TYPE_MISMATCH); + + _classPrivateFieldSet(_assertThisInitialized(_this), _invalid_range_code, invalidRangeCode || scorm12_error_codes.VALUE_OUT_OF_RANGE); + + _classPrivateFieldSet(_assertThisInitialized(_this), _decimal_regex, decimalRegex || scorm12_regex.CMIDecimal); + + _classPrivateFieldSet(_assertThisInitialized(_this), _error_class, errorClass); + + return _this; + } + + _createClass(CMIScore, [{ + key: "_children", + get: + /** + * Getter for _children + * @return {string} + * @private + */ + function get() { + return _classPrivateFieldGet(this, _children2); + } + /** + * Setter for _children. Just throws an error. + * @param {string} _children + * @private + */ + , + set: function set(_children) { + throw new (_classPrivateFieldGet(this, _error_class).prototype.constructor)(_classPrivateFieldGet(this, _invalid_error_code)); + } + /** + * Getter for #raw + * @return {string} + */ + + }, { + key: "raw", + get: function get() { + return _classPrivateFieldGet(this, _raw); + } + /** + * Setter for #raw + * @param {string} raw + */ + , + set: function set(raw) { + if (checkValidFormat(raw, _classPrivateFieldGet(this, _decimal_regex), _classPrivateFieldGet(this, _invalid_type_code), _classPrivateFieldGet(this, _error_class)) && (!_classPrivateFieldGet(this, _score_range) || checkValidRange(raw, _classPrivateFieldGet(this, _score_range), _classPrivateFieldGet(this, _invalid_range_code), _classPrivateFieldGet(this, _error_class)))) { + _classPrivateFieldSet(this, _raw, raw); + } + } + /** + * Getter for #min + * @return {string} + */ + + }, { + key: "min", + get: function get() { + return _classPrivateFieldGet(this, _min); + } + /** + * Setter for #min + * @param {string} min + */ + , + set: function set(min) { + if (checkValidFormat(min, _classPrivateFieldGet(this, _decimal_regex), _classPrivateFieldGet(this, _invalid_type_code), _classPrivateFieldGet(this, _error_class)) && (!_classPrivateFieldGet(this, _score_range) || checkValidRange(min, _classPrivateFieldGet(this, _score_range), _classPrivateFieldGet(this, _invalid_range_code), _classPrivateFieldGet(this, _error_class)))) { + _classPrivateFieldSet(this, _min, min); + } + } + /** + * Getter for #max + * @return {string} + */ + + }, { + key: "max", + get: function get() { + return _classPrivateFieldGet(this, _max); + } + /** + * Setter for #max + * @param {string} max + */ + , + set: function set(max) { + if (checkValidFormat(max, _classPrivateFieldGet(this, _decimal_regex), _classPrivateFieldGet(this, _invalid_type_code), _classPrivateFieldGet(this, _error_class)) && (!_classPrivateFieldGet(this, _score_range) || checkValidRange(max, _classPrivateFieldGet(this, _score_range), _classPrivateFieldGet(this, _invalid_range_code), _classPrivateFieldGet(this, _error_class)))) { + _classPrivateFieldSet(this, _max, max); + } + } + /** + * toJSON for *.score + * @return {{min: string, max: string, raw: string}} + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'raw': this.raw, + 'min': this.min, + 'max': this.max + }; + delete this.jsonString; + return result; + } + }]); + + return CMIScore; +}(BaseCMI); +/** + * Base class for cmi *.n objects + */ + + +exports.CMIScore = CMIScore; + +var _errorCode = new WeakMap(); + +var _errorClass = new WeakMap(); + +var _children3 = new WeakMap(); + +var CMIArray = /*#__PURE__*/function (_BaseCMI2) { + _inherits(CMIArray, _BaseCMI2); + + var _super2 = _createSuper(CMIArray); + + /** + * Constructor cmi *.n arrays + * @param {string} children + * @param {number} errorCode + * @param {class} errorClass + */ + function CMIArray(_ref2) { + var _this2; + + var children = _ref2.children, + errorCode = _ref2.errorCode, + errorClass = _ref2.errorClass; + + _classCallCheck(this, CMIArray); + + _this2 = _super2.call(this); + + _errorCode.set(_assertThisInitialized(_this2), { + writable: true, + value: void 0 + }); + + _errorClass.set(_assertThisInitialized(_this2), { + writable: true, + value: void 0 + }); + + _children3.set(_assertThisInitialized(_this2), { + writable: true, + value: void 0 + }); + + _classPrivateFieldSet(_assertThisInitialized(_this2), _children3, children); + + _classPrivateFieldSet(_assertThisInitialized(_this2), _errorCode, errorCode); + + _classPrivateFieldSet(_assertThisInitialized(_this2), _errorClass, errorClass); + + _this2.childArray = []; + return _this2; + } + + _createClass(CMIArray, [{ + key: "_children", + get: + /** + * Getter for _children + * @return {*} + */ + function get() { + return _classPrivateFieldGet(this, _children3); + } + /** + * Setter for _children. Just throws an error. + * @param {string} _children + */ + , + set: function set(_children) { + throw new (_classPrivateFieldGet(this, _errorClass).prototype.constructor)(_classPrivateFieldGet(this, _errorCode)); + } + /** + * Getter for _count + * @return {number} + */ + + }, { + key: "_count", + get: function get() { + return this.childArray.length; + } + /** + * Setter for _count. Just throws an error. + * @param {number} _count + */ + , + set: function set(_count) { + throw new (_classPrivateFieldGet(this, _errorClass).prototype.constructor)(_classPrivateFieldGet(this, _errorCode)); + } + /** + * toJSON for *.n arrays + * @return {object} + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = {}; + + for (var i = 0; i < this.childArray.length; i++) { + result[i + ''] = this.childArray[i]; + } + + delete this.jsonString; + return result; + } + }]); + + return CMIArray; +}(BaseCMI); + +exports.CMIArray = CMIArray; + +},{"../constants/api_constants":6,"../constants/error_codes":7,"../constants/regex":8}],5:[function(require,module,exports){ +"use strict"; + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.throwReadOnlyError = throwReadOnlyError; +exports.throwWriteOnlyError = throwWriteOnlyError; +exports.check12ValidFormat = check12ValidFormat; +exports.check12ValidRange = check12ValidRange; +exports.NAV = exports.CMIInteractionsCorrectResponsesObject = exports.CMIInteractionsObjectivesObject = exports.CMIObjectivesObject = exports.CMIInteractionsObject = exports.CMIStudentPreference = exports.CMIStudentData = exports.CMI = void 0; + +var _common = require("./common"); + +var _api_constants = _interopRequireDefault(require("../constants/api_constants")); + +var _error_codes = _interopRequireDefault(require("../constants/error_codes")); + +var _regex = _interopRequireDefault(require("../constants/regex")); + +var _exceptions = require("../exceptions"); + +var Utilities = _interopRequireWildcard(require("../utilities")); + +var Util = Utilities; + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); } + +function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); } + +function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; } + +function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); } + +function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } } + +var scorm12_constants = _api_constants["default"].scorm12; +var scorm12_regex = _regex["default"].scorm12; +var scorm12_error_codes = _error_codes["default"].scorm12; +/** + * Helper method for throwing Read Only error + */ + +function throwReadOnlyError() { + throw new _exceptions.Scorm12ValidationError(scorm12_error_codes.READ_ONLY_ELEMENT); +} +/** + * Helper method for throwing Write Only error + */ + + +function throwWriteOnlyError() { + throw new _exceptions.Scorm12ValidationError(scorm12_error_codes.WRITE_ONLY_ELEMENT); +} +/** + * Helper method for throwing Invalid Set error + */ + + +function throwInvalidValueError() { + throw new _exceptions.Scorm12ValidationError(scorm12_error_codes.INVALID_SET_VALUE); +} +/** + * Helper method, no reason to have to pass the same error codes every time + * @param {*} value + * @param {string} regexPattern + * @param {boolean} allowEmptyString + * @return {boolean} + */ + + +function check12ValidFormat(value, regexPattern, allowEmptyString) { + return (0, _common.checkValidFormat)(value, regexPattern, scorm12_error_codes.TYPE_MISMATCH, _exceptions.Scorm12ValidationError, allowEmptyString); +} +/** + * Helper method, no reason to have to pass the same error codes every time + * @param {*} value + * @param {string} rangePattern + * @param {boolean} allowEmptyString + * @return {boolean} + */ + + +function check12ValidRange(value, rangePattern, allowEmptyString) { + return (0, _common.checkValidRange)(value, rangePattern, scorm12_error_codes.VALUE_OUT_OF_RANGE, _exceptions.Scorm12ValidationError, allowEmptyString); +} +/** + * Class representing the cmi object for SCORM 1.2 + */ + + +var _children2 = new WeakMap(); + +var _version2 = new WeakMap(); + +var _launch_data = new WeakMap(); + +var _comments = new WeakMap(); + +var _comments_from_lms = new WeakMap(); + +var CMI = /*#__PURE__*/function (_BaseCMI) { + _inherits(CMI, _BaseCMI); + + var _super = _createSuper(CMI); + + /** + * Constructor for the SCORM 1.2 cmi object + * @param {string} cmi_children + * @param {(CMIStudentData|AICCCMIStudentData)} student_data + * @param {boolean} initialized + */ + function CMI(cmi_children, student_data, initialized) { + var _this; + + _classCallCheck(this, CMI); + + _this = _super.call(this); + + _children2.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _version2.set(_assertThisInitialized(_this), { + writable: true, + value: '3.4' + }); + + _launch_data.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _comments.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _comments_from_lms.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _defineProperty(_assertThisInitialized(_this), "student_data", null); + + if (initialized) _this.initialize(); + + _classPrivateFieldSet(_assertThisInitialized(_this), _children2, cmi_children ? cmi_children : scorm12_constants.cmi_children); + + _this.core = new CMICore(); + _this.objectives = new CMIObjectives(); + _this.student_data = student_data ? student_data : new CMIStudentData(); + _this.student_preference = new CMIStudentPreference(); + _this.interactions = new CMIInteractions(); + return _this; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(CMI, [{ + key: "initialize", + value: function initialize() { + var _this$core, _this$objectives, _this$student_data, _this$student_prefere, _this$interactions; + + _get(_getPrototypeOf(CMI.prototype), "initialize", this).call(this); + + (_this$core = this.core) === null || _this$core === void 0 ? void 0 : _this$core.initialize(); + (_this$objectives = this.objectives) === null || _this$objectives === void 0 ? void 0 : _this$objectives.initialize(); + (_this$student_data = this.student_data) === null || _this$student_data === void 0 ? void 0 : _this$student_data.initialize(); + (_this$student_prefere = this.student_preference) === null || _this$student_prefere === void 0 ? void 0 : _this$student_prefere.initialize(); + (_this$interactions = this.interactions) === null || _this$interactions === void 0 ? void 0 : _this$interactions.initialize(); + } + /** + * toJSON for cmi + * + * @return { + * { + * suspend_data: string, + * launch_data: string, + * comments: string, + * comments_from_lms: string, + * core: CMICore, + * objectives: CMIObjectives, + * student_data: CMIStudentData, + * student_preference: CMIStudentPreference, + * interactions: CMIInteractions + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'suspend_data': this.suspend_data, + 'launch_data': this.launch_data, + 'comments': this.comments, + 'comments_from_lms': this.comments_from_lms, + 'core': this.core, + 'objectives': this.objectives, + 'student_data': this.student_data, + 'student_preference': this.student_preference, + 'interactions': this.interactions + }; + delete this.jsonString; + return result; + } + /** + * Getter for #_version + * @return {string} + */ + + }, { + key: "_version", + get: function get() { + return _classPrivateFieldGet(this, _version2); + } + /** + * Setter for #_version. Just throws an error. + * @param {string} _version + */ + , + set: function set(_version) { + throwInvalidValueError(); + } + /** + * Getter for #_children + * @return {string} + */ + + }, { + key: "_children", + get: function get() { + return _classPrivateFieldGet(this, _children2); + } + /** + * Setter for #_version. Just throws an error. + * @param {string} _children + */ + , + set: function set(_children) { + throwInvalidValueError(); + } + /** + * Getter for #suspend_data + * @return {string} + */ + + }, { + key: "suspend_data", + get: function get() { + var _this$core2; + + return (_this$core2 = this.core) === null || _this$core2 === void 0 ? void 0 : _this$core2.suspend_data; + } + /** + * Setter for #suspend_data + * @param {string} suspend_data + */ + , + set: function set(suspend_data) { + if (this.core) { + this.core.suspend_data = suspend_data; + } + } + /** + * Getter for #launch_data + * @return {string} + */ + + }, { + key: "launch_data", + get: function get() { + return _classPrivateFieldGet(this, _launch_data); + } + /** + * Setter for #launch_data. Can only be called before initialization. + * @param {string} launch_data + */ + , + set: function set(launch_data) { + !this.initialized ? _classPrivateFieldSet(this, _launch_data, launch_data) : throwReadOnlyError(); + } + /** + * Getter for #comments + * @return {string} + */ + + }, { + key: "comments", + get: function get() { + return _classPrivateFieldGet(this, _comments); + } + /** + * Setter for #comments + * @param {string} comments + */ + , + set: function set(comments) { + if (check12ValidFormat(comments, scorm12_regex.CMIString4096, true)) { + _classPrivateFieldSet(this, _comments, comments); + } + } + /** + * Getter for #comments_from_lms + * @return {string} + */ + + }, { + key: "comments_from_lms", + get: function get() { + return _classPrivateFieldGet(this, _comments_from_lms); + } + /** + * Setter for #comments_from_lms. Can only be called before initialization. + * @param {string} comments_from_lms + */ + , + set: function set(comments_from_lms) { + !this.initialized ? _classPrivateFieldSet(this, _comments_from_lms, comments_from_lms) : throwReadOnlyError(); + } + /** + * Adds the current session time to the existing total time. + * + * @return {string} + */ + + }, { + key: "getCurrentTotalTime", + value: function getCurrentTotalTime() { + return this.core.getCurrentTotalTime(this.start_time); + } + }]); + + return CMI; +}(_common.BaseCMI); +/** + * Class representing the cmi.core object + * @extends BaseCMI + */ + + +exports.CMI = CMI; + +var _children3 = new WeakMap(); + +var _student_id = new WeakMap(); + +var _student_name = new WeakMap(); + +var _lesson_location = new WeakMap(); + +var _credit = new WeakMap(); + +var _lesson_status = new WeakMap(); + +var _entry = new WeakMap(); + +var _total_time = new WeakMap(); + +var _lesson_mode = new WeakMap(); + +var _exit = new WeakMap(); + +var _session_time = new WeakMap(); + +var _suspend_data = new WeakMap(); + +var CMICore = /*#__PURE__*/function (_BaseCMI2) { + _inherits(CMICore, _BaseCMI2); + + var _super2 = _createSuper(CMICore); + + /** + * Constructor for cmi.core + */ + function CMICore() { + var _this2; + + _classCallCheck(this, CMICore); + + _this2 = _super2.call(this); + + _children3.set(_assertThisInitialized(_this2), { + writable: true, + value: scorm12_constants.core_children + }); + + _student_id.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _student_name.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _lesson_location.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _credit.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _lesson_status.set(_assertThisInitialized(_this2), { + writable: true, + value: 'not attempted' + }); + + _entry.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _total_time.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _lesson_mode.set(_assertThisInitialized(_this2), { + writable: true, + value: 'normal' + }); + + _exit.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _session_time.set(_assertThisInitialized(_this2), { + writable: true, + value: '00:00:00' + }); + + _suspend_data.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _this2.score = new _common.CMIScore({ + score_children: scorm12_constants.score_children, + score_range: scorm12_regex.score_range, + invalidErrorCode: scorm12_error_codes.INVALID_SET_VALUE, + invalidTypeCode: scorm12_error_codes.TYPE_MISMATCH, + invalidRangeCode: scorm12_error_codes.VALUE_OUT_OF_RANGE, + errorClass: _exceptions.Scorm12ValidationError + }); + return _this2; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(CMICore, [{ + key: "initialize", + value: function initialize() { + var _this$score; + + _get(_getPrototypeOf(CMICore.prototype), "initialize", this).call(this); + + (_this$score = this.score) === null || _this$score === void 0 ? void 0 : _this$score.initialize(); + } + }, { + key: "_children", + get: + /** + * Getter for #_children + * @return {string} + * @private + */ + function get() { + return _classPrivateFieldGet(this, _children3); + } + /** + * Setter for #_children. Just throws an error. + * @param {string} _children + * @private + */ + , + set: function set(_children) { + throwInvalidValueError(); + } + /** + * Getter for #student_id + * @return {string} + */ + + }, { + key: "student_id", + get: function get() { + return _classPrivateFieldGet(this, _student_id); + } + /** + * Setter for #student_id. Can only be called before initialization. + * @param {string} student_id + */ + , + set: function set(student_id) { + !this.initialized ? _classPrivateFieldSet(this, _student_id, student_id) : throwReadOnlyError(); + } + /** + * Getter for #student_name + * @return {string} + */ + + }, { + key: "student_name", + get: function get() { + return _classPrivateFieldGet(this, _student_name); + } + /** + * Setter for #student_name. Can only be called before initialization. + * @param {string} student_name + */ + , + set: function set(student_name) { + !this.initialized ? _classPrivateFieldSet(this, _student_name, student_name) : throwReadOnlyError(); + } + /** + * Getter for #lesson_location + * @return {string} + */ + + }, { + key: "lesson_location", + get: function get() { + return _classPrivateFieldGet(this, _lesson_location); + } + /** + * Setter for #lesson_location + * @param {string} lesson_location + */ + , + set: function set(lesson_location) { + if (check12ValidFormat(lesson_location, scorm12_regex.CMIString256, true)) { + _classPrivateFieldSet(this, _lesson_location, lesson_location); + } + } + /** + * Getter for #credit + * @return {string} + */ + + }, { + key: "credit", + get: function get() { + return _classPrivateFieldGet(this, _credit); + } + /** + * Setter for #credit. Can only be called before initialization. + * @param {string} credit + */ + , + set: function set(credit) { + !this.initialized ? _classPrivateFieldSet(this, _credit, credit) : throwReadOnlyError(); + } + /** + * Getter for #lesson_status + * @return {string} + */ + + }, { + key: "lesson_status", + get: function get() { + return _classPrivateFieldGet(this, _lesson_status); + } + /** + * Setter for #lesson_status + * @param {string} lesson_status + */ + , + set: function set(lesson_status) { + if (this.initialized) { + if (check12ValidFormat(lesson_status, scorm12_regex.CMIStatus)) { + _classPrivateFieldSet(this, _lesson_status, lesson_status); + } + } else { + if (check12ValidFormat(lesson_status, scorm12_regex.CMIStatus2)) { + _classPrivateFieldSet(this, _lesson_status, lesson_status); + } + } + } + /** + * Getter for #entry + * @return {string} + */ + + }, { + key: "entry", + get: function get() { + return _classPrivateFieldGet(this, _entry); + } + /** + * Setter for #entry. Can only be called before initialization. + * @param {string} entry + */ + , + set: function set(entry) { + !this.initialized ? _classPrivateFieldSet(this, _entry, entry) : throwReadOnlyError(); + } + /** + * Getter for #total_time + * @return {string} + */ + + }, { + key: "total_time", + get: function get() { + return _classPrivateFieldGet(this, _total_time); + } + /** + * Setter for #total_time. Can only be called before initialization. + * @param {string} total_time + */ + , + set: function set(total_time) { + !this.initialized ? _classPrivateFieldSet(this, _total_time, total_time) : throwReadOnlyError(); + } + /** + * Getter for #lesson_mode + * @return {string} + */ + + }, { + key: "lesson_mode", + get: function get() { + return _classPrivateFieldGet(this, _lesson_mode); + } + /** + * Setter for #lesson_mode. Can only be called before initialization. + * @param {string} lesson_mode + */ + , + set: function set(lesson_mode) { + !this.initialized ? _classPrivateFieldSet(this, _lesson_mode, lesson_mode) : throwReadOnlyError(); + } + /** + * Getter for #exit. Should only be called during JSON export. + * @return {*} + */ + + }, { + key: "exit", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _exit); + } + /** + * Setter for #exit + * @param {string} exit + */ + , + set: function set(exit) { + if (check12ValidFormat(exit, scorm12_regex.CMIExit, true)) { + _classPrivateFieldSet(this, _exit, exit); + } + } + /** + * Getter for #session_time. Should only be called during JSON export. + * @return {*} + */ + + }, { + key: "session_time", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _session_time); + } + /** + * Setter for #session_time + * @param {string} session_time + */ + , + set: function set(session_time) { + if (check12ValidFormat(session_time, scorm12_regex.CMITimespan)) { + _classPrivateFieldSet(this, _session_time, session_time); + } + } + /** + * Getter for #suspend_data + * @return {string} + */ + + }, { + key: "suspend_data", + get: function get() { + return _classPrivateFieldGet(this, _suspend_data); + } + /** + * Setter for #suspend_data + * @param {string} suspend_data + */ + , + set: function set(suspend_data) { + if (check12ValidFormat(suspend_data, scorm12_regex.CMIString4096, true)) { + _classPrivateFieldSet(this, _suspend_data, suspend_data); + } + } + /** + * Adds the current session time to the existing total time. + * @param {Number} start_time + * @return {string} + */ + + }, { + key: "getCurrentTotalTime", + value: function getCurrentTotalTime(start_time) { + var sessionTime = _classPrivateFieldGet(this, _session_time); + + var startTime = start_time; + + if (typeof startTime !== 'undefined' && startTime !== null) { + var seconds = new Date().getTime() - startTime; + sessionTime = Util.getSecondsAsHHMMSS(seconds / 1000); + } + + return Utilities.addHHMMSSTimeStrings(_classPrivateFieldGet(this, _total_time), sessionTime, new RegExp(scorm12_regex.CMITimespan)); + } + /** + * toJSON for cmi.core + * + * @return { + * { + * student_name: string, + * entry: string, + * exit: string, + * score: CMIScore, + * student_id: string, + * lesson_mode: string, + * lesson_location: string, + * lesson_status: string, + * credit: string, + * session_time: * + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'student_id': this.student_id, + 'student_name': this.student_name, + 'lesson_location': this.lesson_location, + 'credit': this.credit, + 'lesson_status': this.lesson_status, + 'entry': this.entry, + 'lesson_mode': this.lesson_mode, + 'exit': this.exit, + 'session_time': this.session_time, + 'score': this.score + }; + delete this.jsonString; + return result; + } + }]); + + return CMICore; +}(_common.BaseCMI); +/** + * Class representing SCORM 1.2's cmi.objectives object + * @extends CMIArray + */ + + +var CMIObjectives = /*#__PURE__*/function (_CMIArray) { + _inherits(CMIObjectives, _CMIArray); + + var _super3 = _createSuper(CMIObjectives); + + /** + * Constructor for cmi.objectives + */ + function CMIObjectives() { + _classCallCheck(this, CMIObjectives); + + return _super3.call(this, { + children: scorm12_constants.objectives_children, + errorCode: scorm12_error_codes.INVALID_SET_VALUE, + errorClass: _exceptions.Scorm12ValidationError + }); + } + + return CMIObjectives; +}(_common.CMIArray); +/** + * Class representing SCORM 1.2's cmi.student_data object + * @extends BaseCMI + */ + + +var _children4 = new WeakMap(); + +var _mastery_score = new WeakMap(); + +var _max_time_allowed = new WeakMap(); + +var _time_limit_action = new WeakMap(); + +var CMIStudentData = /*#__PURE__*/function (_BaseCMI3) { + _inherits(CMIStudentData, _BaseCMI3); + + var _super4 = _createSuper(CMIStudentData); + + /** + * Constructor for cmi.student_data + * @param {string} student_data_children + */ + function CMIStudentData(student_data_children) { + var _this3; + + _classCallCheck(this, CMIStudentData); + + _this3 = _super4.call(this); + + _children4.set(_assertThisInitialized(_this3), { + writable: true, + value: void 0 + }); + + _mastery_score.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _max_time_allowed.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _time_limit_action.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _classPrivateFieldSet(_assertThisInitialized(_this3), _children4, student_data_children ? student_data_children : scorm12_constants.student_data_children); + + return _this3; + } + /** + * Getter for #_children + * @return {*} + * @private + */ + + + _createClass(CMIStudentData, [{ + key: "_children", + get: function get() { + return _classPrivateFieldGet(this, _children4); + } + /** + * Setter for #_children. Just throws an error. + * @param {string} _children + * @private + */ + , + set: function set(_children) { + throwInvalidValueError(); + } + /** + * Getter for #master_score + * @return {string} + */ + + }, { + key: "mastery_score", + get: function get() { + return _classPrivateFieldGet(this, _mastery_score); + } + /** + * Setter for #master_score. Can only be called before initialization. + * @param {string} mastery_score + */ + , + set: function set(mastery_score) { + !this.initialized ? _classPrivateFieldSet(this, _mastery_score, mastery_score) : throwReadOnlyError(); + } + /** + * Getter for #max_time_allowed + * @return {string} + */ + + }, { + key: "max_time_allowed", + get: function get() { + return _classPrivateFieldGet(this, _max_time_allowed); + } + /** + * Setter for #max_time_allowed. Can only be called before initialization. + * @param {string} max_time_allowed + */ + , + set: function set(max_time_allowed) { + !this.initialized ? _classPrivateFieldSet(this, _max_time_allowed, max_time_allowed) : throwReadOnlyError(); + } + /** + * Getter for #time_limit_action + * @return {string} + */ + + }, { + key: "time_limit_action", + get: function get() { + return _classPrivateFieldGet(this, _time_limit_action); + } + /** + * Setter for #time_limit_action. Can only be called before initialization. + * @param {string} time_limit_action + */ + , + set: function set(time_limit_action) { + !this.initialized ? _classPrivateFieldSet(this, _time_limit_action, time_limit_action) : throwReadOnlyError(); + } + /** + * toJSON for cmi.student_data + * + * @return { + * { + * max_time_allowed: string, + * time_limit_action: string, + * mastery_score: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'mastery_score': this.mastery_score, + 'max_time_allowed': this.max_time_allowed, + 'time_limit_action': this.time_limit_action + }; + delete this.jsonString; + return result; + } + }]); + + return CMIStudentData; +}(_common.BaseCMI); +/** + * Class representing SCORM 1.2's cmi.student_preference object + * @extends BaseCMI + */ + + +exports.CMIStudentData = CMIStudentData; + +var _children5 = new WeakMap(); + +var _audio = new WeakMap(); + +var _language = new WeakMap(); + +var _speed = new WeakMap(); + +var _text = new WeakMap(); + +var CMIStudentPreference = /*#__PURE__*/function (_BaseCMI4) { + _inherits(CMIStudentPreference, _BaseCMI4); + + var _super5 = _createSuper(CMIStudentPreference); + + /** + * Constructor for cmi.student_preference + * @param {string} student_preference_children + */ + function CMIStudentPreference(student_preference_children) { + var _this4; + + _classCallCheck(this, CMIStudentPreference); + + _this4 = _super5.call(this); + + _children5.set(_assertThisInitialized(_this4), { + writable: true, + value: void 0 + }); + + _audio.set(_assertThisInitialized(_this4), { + writable: true, + value: '' + }); + + _language.set(_assertThisInitialized(_this4), { + writable: true, + value: '' + }); + + _speed.set(_assertThisInitialized(_this4), { + writable: true, + value: '' + }); + + _text.set(_assertThisInitialized(_this4), { + writable: true, + value: '' + }); + + _classPrivateFieldSet(_assertThisInitialized(_this4), _children5, student_preference_children ? student_preference_children : scorm12_constants.student_preference_children); + + return _this4; + } + + _createClass(CMIStudentPreference, [{ + key: "_children", + get: + /** + * Getter for #_children + * @return {string} + * @private + */ + function get() { + return _classPrivateFieldGet(this, _children5); + } + /** + * Setter for #_children. Just throws an error. + * @param {string} _children + * @private + */ + , + set: function set(_children) { + throwInvalidValueError(); + } + /** + * Getter for #audio + * @return {string} + */ + + }, { + key: "audio", + get: function get() { + return _classPrivateFieldGet(this, _audio); + } + /** + * Setter for #audio + * @param {string} audio + */ + , + set: function set(audio) { + if (check12ValidFormat(audio, scorm12_regex.CMISInteger) && check12ValidRange(audio, scorm12_regex.audio_range)) { + _classPrivateFieldSet(this, _audio, audio); + } + } + /** + * Getter for #language + * @return {string} + */ + + }, { + key: "language", + get: function get() { + return _classPrivateFieldGet(this, _language); + } + /** + * Setter for #language + * @param {string} language + */ + , + set: function set(language) { + if (check12ValidFormat(language, scorm12_regex.CMIString256)) { + _classPrivateFieldSet(this, _language, language); + } + } + /** + * Getter for #speed + * @return {string} + */ + + }, { + key: "speed", + get: function get() { + return _classPrivateFieldGet(this, _speed); + } + /** + * Setter for #speed + * @param {string} speed + */ + , + set: function set(speed) { + if (check12ValidFormat(speed, scorm12_regex.CMISInteger) && check12ValidRange(speed, scorm12_regex.speed_range)) { + _classPrivateFieldSet(this, _speed, speed); + } + } + /** + * Getter for #text + * @return {string} + */ + + }, { + key: "text", + get: function get() { + return _classPrivateFieldGet(this, _text); + } + /** + * Setter for #text + * @param {string} text + */ + , + set: function set(text) { + if (check12ValidFormat(text, scorm12_regex.CMISInteger) && check12ValidRange(text, scorm12_regex.text_range)) { + _classPrivateFieldSet(this, _text, text); + } + } + /** + * toJSON for cmi.student_preference + * + * @return { + * { + * audio: string, + * language: string, + * speed: string, + * text: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'audio': this.audio, + 'language': this.language, + 'speed': this.speed, + 'text': this.text + }; + delete this.jsonString; + return result; + } + }]); + + return CMIStudentPreference; +}(_common.BaseCMI); +/** + * Class representing SCORM 1.2's cmi.interactions object + * @extends BaseCMI + */ + + +exports.CMIStudentPreference = CMIStudentPreference; + +var CMIInteractions = /*#__PURE__*/function (_CMIArray2) { + _inherits(CMIInteractions, _CMIArray2); + + var _super6 = _createSuper(CMIInteractions); + + /** + * Constructor for cmi.interactions + */ + function CMIInteractions() { + _classCallCheck(this, CMIInteractions); + + return _super6.call(this, { + children: scorm12_constants.interactions_children, + errorCode: scorm12_error_codes.INVALID_SET_VALUE, + errorClass: _exceptions.Scorm12ValidationError + }); + } + + return CMIInteractions; +}(_common.CMIArray); +/** + * Class representing SCORM 1.2's cmi.interactions.n object + * @extends BaseCMI + */ + + +var _id = new WeakMap(); + +var _time = new WeakMap(); + +var _type = new WeakMap(); + +var _weighting = new WeakMap(); + +var _student_response = new WeakMap(); + +var _result = new WeakMap(); + +var _latency = new WeakMap(); + +var CMIInteractionsObject = /*#__PURE__*/function (_BaseCMI5) { + _inherits(CMIInteractionsObject, _BaseCMI5); + + var _super7 = _createSuper(CMIInteractionsObject); + + /** + * Constructor for cmi.interactions.n object + */ + function CMIInteractionsObject() { + var _this5; + + _classCallCheck(this, CMIInteractionsObject); + + _this5 = _super7.call(this); + + _id.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _time.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _type.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _weighting.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _student_response.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _result.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _latency.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _this5.objectives = new _common.CMIArray({ + errorCode: scorm12_error_codes.INVALID_SET_VALUE, + errorClass: _exceptions.Scorm12ValidationError, + children: scorm12_constants.objectives_children + }); + _this5.correct_responses = new _common.CMIArray({ + errorCode: scorm12_error_codes.INVALID_SET_VALUE, + errorClass: _exceptions.Scorm12ValidationError, + children: scorm12_constants.correct_responses_children + }); + return _this5; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(CMIInteractionsObject, [{ + key: "initialize", + value: function initialize() { + var _this$objectives2, _this$correct_respons; + + _get(_getPrototypeOf(CMIInteractionsObject.prototype), "initialize", this).call(this); + + (_this$objectives2 = this.objectives) === null || _this$objectives2 === void 0 ? void 0 : _this$objectives2.initialize(); + (_this$correct_respons = this.correct_responses) === null || _this$correct_respons === void 0 ? void 0 : _this$correct_respons.initialize(); + } + }, { + key: "id", + get: + /** + * Getter for #id. Should only be called during JSON export. + * @return {*} + */ + function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _id); + } + /** + * Setter for #id + * @param {string} id + */ + , + set: function set(id) { + if (check12ValidFormat(id, scorm12_regex.CMIIdentifier)) { + _classPrivateFieldSet(this, _id, id); + } + } + /** + * Getter for #time. Should only be called during JSON export. + * @return {*} + */ + + }, { + key: "time", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _time); + } + /** + * Setter for #time + * @param {string} time + */ + , + set: function set(time) { + if (check12ValidFormat(time, scorm12_regex.CMITime)) { + _classPrivateFieldSet(this, _time, time); + } + } + /** + * Getter for #type. Should only be called during JSON export. + * @return {*} + */ + + }, { + key: "type", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _type); + } + /** + * Setter for #type + * @param {string} type + */ + , + set: function set(type) { + if (check12ValidFormat(type, scorm12_regex.CMIType)) { + _classPrivateFieldSet(this, _type, type); + } + } + /** + * Getter for #weighting. Should only be called during JSON export. + * @return {*} + */ + + }, { + key: "weighting", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _weighting); + } + /** + * Setter for #weighting + * @param {string} weighting + */ + , + set: function set(weighting) { + if (check12ValidFormat(weighting, scorm12_regex.CMIDecimal) && check12ValidRange(weighting, scorm12_regex.weighting_range)) { + _classPrivateFieldSet(this, _weighting, weighting); + } + } + /** + * Getter for #student_response. Should only be called during JSON export. + * @return {*} + */ + + }, { + key: "student_response", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _student_response); + } + /** + * Setter for #student_response + * @param {string} student_response + */ + , + set: function set(student_response) { + if (check12ValidFormat(student_response, scorm12_regex.CMIFeedback, true)) { + _classPrivateFieldSet(this, _student_response, student_response); + } + } + /** + * Getter for #result. Should only be called during JSON export. + * @return {*} + */ + + }, { + key: "result", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _result); + } + /** + * Setter for #result + * @param {string} result + */ + , + set: function set(result) { + if (check12ValidFormat(result, scorm12_regex.CMIResult)) { + _classPrivateFieldSet(this, _result, result); + } + } + /** + * Getter for #latency. Should only be called during JSON export. + * @return {*} + */ + + }, { + key: "latency", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _latency); + } + /** + * Setter for #latency + * @param {string} latency + */ + , + set: function set(latency) { + if (check12ValidFormat(latency, scorm12_regex.CMITimespan)) { + _classPrivateFieldSet(this, _latency, latency); + } + } + /** + * toJSON for cmi.interactions.n + * + * @return { + * { + * id: string, + * time: string, + * type: string, + * weighting: string, + * student_response: string, + * result: string, + * latency: string, + * objectives: CMIArray, + * correct_responses: CMIArray + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'id': this.id, + 'time': this.time, + 'type': this.type, + 'weighting': this.weighting, + 'student_response': this.student_response, + 'result': this.result, + 'latency': this.latency, + 'objectives': this.objectives, + 'correct_responses': this.correct_responses + }; + delete this.jsonString; + return result; + } + }]); + + return CMIInteractionsObject; +}(_common.BaseCMI); +/** + * Class representing SCORM 1.2's cmi.objectives.n object + * @extends BaseCMI + */ + + +exports.CMIInteractionsObject = CMIInteractionsObject; + +var _id2 = new WeakMap(); + +var _status = new WeakMap(); + +var CMIObjectivesObject = /*#__PURE__*/function (_BaseCMI6) { + _inherits(CMIObjectivesObject, _BaseCMI6); + + var _super8 = _createSuper(CMIObjectivesObject); + + /** + * Constructor for cmi.objectives.n + */ + function CMIObjectivesObject() { + var _this6; + + _classCallCheck(this, CMIObjectivesObject); + + _this6 = _super8.call(this); + + _id2.set(_assertThisInitialized(_this6), { + writable: true, + value: '' + }); + + _status.set(_assertThisInitialized(_this6), { + writable: true, + value: '' + }); + + _this6.score = new _common.CMIScore({ + score_children: scorm12_constants.score_children, + score_range: scorm12_regex.score_range, + invalidErrorCode: scorm12_error_codes.INVALID_SET_VALUE, + invalidTypeCode: scorm12_error_codes.TYPE_MISMATCH, + invalidRangeCode: scorm12_error_codes.VALUE_OUT_OF_RANGE, + errorClass: _exceptions.Scorm12ValidationError + }); + return _this6; + } + + _createClass(CMIObjectivesObject, [{ + key: "id", + get: + /** + * Getter for #id + * @return {""} + */ + function get() { + return _classPrivateFieldGet(this, _id2); + } + /** + * Setter for #id + * @param {string} id + */ + , + set: function set(id) { + if (check12ValidFormat(id, scorm12_regex.CMIIdentifier)) { + _classPrivateFieldSet(this, _id2, id); + } + } + /** + * Getter for #status + * @return {""} + */ + + }, { + key: "status", + get: function get() { + return _classPrivateFieldGet(this, _status); + } + /** + * Setter for #status + * @param {string} status + */ + , + set: function set(status) { + if (check12ValidFormat(status, scorm12_regex.CMIStatus2)) { + _classPrivateFieldSet(this, _status, status); + } + } + /** + * toJSON for cmi.objectives.n + * @return { + * { + * id: string, + * status: string, + * score: CMIScore + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'id': this.id, + 'status': this.status, + 'score': this.score + }; + delete this.jsonString; + return result; + } + }]); + + return CMIObjectivesObject; +}(_common.BaseCMI); +/** + * Class representing SCORM 1.2's cmi.interactions.n.objectives.n object + * @extends BaseCMI + */ + + +exports.CMIObjectivesObject = CMIObjectivesObject; + +var _id3 = new WeakMap(); + +var CMIInteractionsObjectivesObject = /*#__PURE__*/function (_BaseCMI7) { + _inherits(CMIInteractionsObjectivesObject, _BaseCMI7); + + var _super9 = _createSuper(CMIInteractionsObjectivesObject); + + /** + * Constructor for cmi.interactions.n.objectives.n + */ + function CMIInteractionsObjectivesObject() { + var _this7; + + _classCallCheck(this, CMIInteractionsObjectivesObject); + + _this7 = _super9.call(this); + + _id3.set(_assertThisInitialized(_this7), { + writable: true, + value: '' + }); + + return _this7; + } + + _createClass(CMIInteractionsObjectivesObject, [{ + key: "id", + get: + /** + * Getter for #id + * @return {""} + */ + function get() { + return _classPrivateFieldGet(this, _id3); + } + /** + * Setter for #id + * @param {string} id + */ + , + set: function set(id) { + if (check12ValidFormat(id, scorm12_regex.CMIIdentifier)) { + _classPrivateFieldSet(this, _id3, id); + } + } + /** + * toJSON for cmi.interactions.n.objectives.n + * @return { + * { + * id: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'id': this.id + }; + delete this.jsonString; + return result; + } + }]); + + return CMIInteractionsObjectivesObject; +}(_common.BaseCMI); +/** + * Class representing SCORM 1.2's cmi.interactions.correct_responses.n object + * @extends BaseCMI + */ + + +exports.CMIInteractionsObjectivesObject = CMIInteractionsObjectivesObject; + +var _pattern = new WeakMap(); + +var CMIInteractionsCorrectResponsesObject = /*#__PURE__*/function (_BaseCMI8) { + _inherits(CMIInteractionsCorrectResponsesObject, _BaseCMI8); + + var _super10 = _createSuper(CMIInteractionsCorrectResponsesObject); + + /** + * Constructor for cmi.interactions.correct_responses.n + */ + function CMIInteractionsCorrectResponsesObject() { + var _this8; + + _classCallCheck(this, CMIInteractionsCorrectResponsesObject); + + _this8 = _super10.call(this); + + _pattern.set(_assertThisInitialized(_this8), { + writable: true, + value: '' + }); + + return _this8; + } + + _createClass(CMIInteractionsCorrectResponsesObject, [{ + key: "pattern", + get: + /** + * Getter for #pattern + * @return {string} + */ + function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _pattern); + } + /** + * Setter for #pattern + * @param {string} pattern + */ + , + set: function set(pattern) { + if (check12ValidFormat(pattern, scorm12_regex.CMIFeedback, true)) { + _classPrivateFieldSet(this, _pattern, pattern); + } + } + /** + * toJSON for cmi.interactions.correct_responses.n + * @return { + * { + * pattern: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'pattern': this.pattern + }; + delete this.jsonString; + return result; + } + }]); + + return CMIInteractionsCorrectResponsesObject; +}(_common.BaseCMI); +/** + * Class for AICC Navigation object + */ + + +exports.CMIInteractionsCorrectResponsesObject = CMIInteractionsCorrectResponsesObject; + +var _event = new WeakMap(); + +var NAV = /*#__PURE__*/function (_BaseCMI9) { + _inherits(NAV, _BaseCMI9); + + var _super11 = _createSuper(NAV); + + /** + * Constructor for NAV object + */ + function NAV() { + var _this9; + + _classCallCheck(this, NAV); + + _this9 = _super11.call(this); + + _event.set(_assertThisInitialized(_this9), { + writable: true, + value: '' + }); + + return _this9; + } + + _createClass(NAV, [{ + key: "event", + get: + /** + * Getter for #event + * @return {string} + */ + function get() { + return _classPrivateFieldGet(this, _event); + } + /** + * Setter for #event + * @param {string} event + */ + , + set: function set(event) { + if (check12ValidFormat(event, scorm12_regex.NAVEvent)) { + _classPrivateFieldSet(this, _event, event); + } + } + /** + * toJSON for nav object + * @return { + * { + * event: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'event': this.event + }; + delete this.jsonString; + return result; + } + }]); + + return NAV; +}(_common.BaseCMI); + +exports.NAV = NAV; + +},{"../constants/api_constants":6,"../constants/error_codes":7,"../constants/regex":8,"../exceptions":9,"../utilities":11,"./common":4}],6:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var global = { + SCORM_TRUE: 'true', + SCORM_FALSE: 'false', + STATE_NOT_INITIALIZED: 0, + STATE_INITIALIZED: 1, + STATE_TERMINATED: 2, + LOG_LEVEL_DEBUG: 1, + LOG_LEVEL_INFO: 2, + LOG_LEVEL_WARNING: 3, + LOG_LEVEL_ERROR: 4, + LOG_LEVEL_NONE: 5 +}; +var scorm12 = { + // Children lists + cmi_children: 'core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions', + core_children: 'student_id,student_name,lesson_location,credit,lesson_status,entry,score,total_time,lesson_mode,exit,session_time', + score_children: 'raw,min,max', + comments_children: 'content,location,time', + objectives_children: 'id,score,status', + correct_responses_children: 'pattern', + student_data_children: 'mastery_score,max_time_allowed,time_limit_action', + student_preference_children: 'audio,language,speed,text', + interactions_children: 'id,objectives,time,type,correct_responses,weighting,student_response,result,latency', + error_descriptions: { + '101': { + basicMessage: 'General Exception', + detailMessage: 'No specific error code exists to describe the error. Use LMSGetDiagnostic for more information' + }, + '201': { + basicMessage: 'Invalid argument error', + detailMessage: 'Indicates that an argument represents an invalid data model element or is otherwise incorrect.' + }, + '202': { + basicMessage: 'Element cannot have children', + detailMessage: 'Indicates that LMSGetValue was called with a data model element name that ends in "_children" for a data model element that does not support the "_children" suffix.' + }, + '203': { + basicMessage: 'Element not an array - cannot have count', + detailMessage: 'Indicates that LMSGetValue was called with a data model element name that ends in "_count" for a data model element that does not support the "_count" suffix.' + }, + '301': { + basicMessage: 'Not initialized', + detailMessage: 'Indicates that an API call was made before the call to lmsInitialize.' + }, + '401': { + basicMessage: 'Not implemented error', + detailMessage: 'The data model element indicated in a call to LMSGetValue or LMSSetValue is valid, but was not implemented by this LMS. SCORM 1.2 defines a set of data model elements as being optional for an LMS to implement.' + }, + '402': { + basicMessage: 'Invalid set value, element is a keyword', + detailMessage: 'Indicates that LMSSetValue was called on a data model element that represents a keyword (elements that end in "_children" and "_count").' + }, + '403': { + basicMessage: 'Element is read only', + detailMessage: 'LMSSetValue was called with a data model element that can only be read.' + }, + '404': { + basicMessage: 'Element is write only', + detailMessage: 'LMSGetValue was called on a data model element that can only be written to.' + }, + '405': { + basicMessage: 'Incorrect Data Type', + detailMessage: 'LMSSetValue was called with a value that is not consistent with the data format of the supplied data model element.' + }, + '407': { + basicMessage: 'Element Value Out Of Range', + detailMessage: 'The numeric value supplied to a LMSSetValue call is outside of the numeric range allowed for the supplied data model element.' + }, + '408': { + basicMessage: 'Data Model Dependency Not Established', + detailMessage: 'Some data model elements cannot be set until another data model element was set. This error condition indicates that the prerequisite element was not set before the dependent element.' + } + } +}; + +var aicc = _objectSpread(_objectSpread({}, scorm12), { + cmi_children: 'core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions,evaluation', + student_preference_children: 'audio,language,lesson_type,speed,text,text_color,text_location,text_size,video,windows', + student_data_children: 'attempt_number,tries,mastery_score,max_time_allowed,time_limit_action', + student_demographics_children: 'city,class,company,country,experience,familiar_name,instructor_name,title,native_language,state,street_address,telephone,years_experience', + tries_children: 'time,status,score', + attempt_records_children: 'score,lesson_status', + paths_children: 'location_id,date,time,status,why_left,time_in_element' +}); + +var scorm2004 = { + // Children lists + cmi_children: '_version,comments_from_learner,comments_from_lms,completion_status,credit,entry,exit,interactions,launch_data,learner_id,learner_name,learner_preference,location,max_time_allowed,mode,objectives,progress_measure,scaled_passing_score,score,session_time,success_status,suspend_data,time_limit_action,total_time', + comments_children: 'comment,timestamp,location', + score_children: 'max,raw,scaled,min', + objectives_children: 'progress_measure,completion_status,success_status,description,score,id', + correct_responses_children: 'pattern', + student_data_children: 'mastery_score,max_time_allowed,time_limit_action', + student_preference_children: 'audio_level,audio_captioning,delivery_speed,language', + interactions_children: 'id,type,objectives,timestamp,correct_responses,weighting,learner_response,result,latency,description', + error_descriptions: { + '0': { + basicMessage: 'No Error', + detailMessage: 'No error occurred, the previous API call was successful.' + }, + '101': { + basicMessage: 'General Exception', + detailMessage: 'No specific error code exists to describe the error. Use GetDiagnostic for more information.' + }, + '102': { + basicMessage: 'General Initialization Failure', + detailMessage: 'Call to Initialize failed for an unknown reason.' + }, + '103': { + basicMessage: 'Already Initialized', + detailMessage: 'Call to Initialize failed because Initialize was already called.' + }, + '104': { + basicMessage: 'Content Instance Terminated', + detailMessage: 'Call to Initialize failed because Terminate was already called.' + }, + '111': { + basicMessage: 'General Termination Failure', + detailMessage: 'Call to Terminate failed for an unknown reason.' + }, + '112': { + basicMessage: 'Termination Before Initialization', + detailMessage: 'Call to Terminate failed because it was made before the call to Initialize.' + }, + '113': { + basicMessage: 'Termination After Termination', + detailMessage: 'Call to Terminate failed because Terminate was already called.' + }, + '122': { + basicMessage: 'Retrieve Data Before Initialization', + detailMessage: 'Call to GetValue failed because it was made before the call to Initialize.' + }, + '123': { + basicMessage: 'Retrieve Data After Termination', + detailMessage: 'Call to GetValue failed because it was made after the call to Terminate.' + }, + '132': { + basicMessage: 'Store Data Before Initialization', + detailMessage: 'Call to SetValue failed because it was made before the call to Initialize.' + }, + '133': { + basicMessage: 'Store Data After Termination', + detailMessage: 'Call to SetValue failed because it was made after the call to Terminate.' + }, + '142': { + basicMessage: 'Commit Before Initialization', + detailMessage: 'Call to Commit failed because it was made before the call to Initialize.' + }, + '143': { + basicMessage: 'Commit After Termination', + detailMessage: 'Call to Commit failed because it was made after the call to Terminate.' + }, + '201': { + basicMessage: 'General Argument Error', + detailMessage: 'An invalid argument was passed to an API method (usually indicates that Initialize, Commit or Terminate did not receive the expected empty string argument.' + }, + '301': { + basicMessage: 'General Get Failure', + detailMessage: 'Indicates a failed GetValue call where no other specific error code is applicable. Use GetDiagnostic for more information.' + }, + '351': { + basicMessage: 'General Set Failure', + detailMessage: 'Indicates a failed SetValue call where no other specific error code is applicable. Use GetDiagnostic for more information.' + }, + '391': { + basicMessage: 'General Commit Failure', + detailMessage: 'Indicates a failed Commit call where no other specific error code is applicable. Use GetDiagnostic for more information.' + }, + '401': { + basicMessage: 'Undefined Data Model Element', + detailMessage: 'The data model element name passed to GetValue or SetValue is not a valid SCORM data model element.' + }, + '402': { + basicMessage: 'Unimplemented Data Model Element', + detailMessage: 'The data model element indicated in a call to GetValue or SetValue is valid, but was not implemented by this LMS. In SCORM 2004, this error would indicate an LMS that is not fully SCORM conformant.' + }, + '403': { + basicMessage: 'Data Model Element Value Not Initialized', + detailMessage: 'Attempt to read a data model element that has not been initialized by the LMS or through a SetValue call. This error condition is often reached during normal execution of a SCO.' + }, + '404': { + basicMessage: 'Data Model Element Is Read Only', + detailMessage: 'SetValue was called with a data model element that can only be read.' + }, + '405': { + basicMessage: 'Data Model Element Is Write Only', + detailMessage: 'GetValue was called on a data model element that can only be written to.' + }, + '406': { + basicMessage: 'Data Model Element Type Mismatch', + detailMessage: 'SetValue was called with a value that is not consistent with the data format of the supplied data model element.' + }, + '407': { + basicMessage: 'Data Model Element Value Out Of Range', + detailMessage: 'The numeric value supplied to a SetValue call is outside of the numeric range allowed for the supplied data model element.' + }, + '408': { + basicMessage: 'Data Model Dependency Not Established', + detailMessage: 'Some data model elements cannot be set until another data model element was set. This error condition indicates that the prerequisite element was not set before the dependent element.' + } + } +}; +var APIConstants = { + global: global, + scorm12: scorm12, + aicc: aicc, + scorm2004: scorm2004 +}; +var _default = APIConstants; +exports["default"] = _default; + +},{}],7:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var global = { + GENERAL: 101, + INITIALIZATION_FAILED: 101, + INITIALIZED: 101, + TERMINATED: 101, + TERMINATION_FAILURE: 101, + TERMINATION_BEFORE_INIT: 101, + MULTIPLE_TERMINATION: 101, + RETRIEVE_BEFORE_INIT: 101, + RETRIEVE_AFTER_TERM: 101, + STORE_BEFORE_INIT: 101, + STORE_AFTER_TERM: 101, + COMMIT_BEFORE_INIT: 101, + COMMIT_AFTER_TERM: 101, + ARGUMENT_ERROR: 101, + CHILDREN_ERROR: 101, + COUNT_ERROR: 101, + GENERAL_GET_FAILURE: 101, + GENERAL_SET_FAILURE: 101, + GENERAL_COMMIT_FAILURE: 101, + UNDEFINED_DATA_MODEL: 101, + UNIMPLEMENTED_ELEMENT: 101, + VALUE_NOT_INITIALIZED: 101, + INVALID_SET_VALUE: 101, + READ_ONLY_ELEMENT: 101, + WRITE_ONLY_ELEMENT: 101, + TYPE_MISMATCH: 101, + VALUE_OUT_OF_RANGE: 101, + DEPENDENCY_NOT_ESTABLISHED: 101 +}; + +var scorm12 = _objectSpread(_objectSpread({}, global), { + RETRIEVE_BEFORE_INIT: 301, + STORE_BEFORE_INIT: 301, + COMMIT_BEFORE_INIT: 301, + ARGUMENT_ERROR: 201, + CHILDREN_ERROR: 202, + COUNT_ERROR: 203, + UNDEFINED_DATA_MODEL: 401, + UNIMPLEMENTED_ELEMENT: 401, + VALUE_NOT_INITIALIZED: 301, + INVALID_SET_VALUE: 402, + READ_ONLY_ELEMENT: 403, + WRITE_ONLY_ELEMENT: 404, + TYPE_MISMATCH: 405, + VALUE_OUT_OF_RANGE: 407, + DEPENDENCY_NOT_ESTABLISHED: 408 +}); + +var scorm2004 = _objectSpread(_objectSpread({}, global), { + INITIALIZATION_FAILED: 102, + INITIALIZED: 103, + TERMINATED: 104, + TERMINATION_FAILURE: 111, + TERMINATION_BEFORE_INIT: 112, + MULTIPLE_TERMINATIONS: 113, + RETRIEVE_BEFORE_INIT: 122, + RETRIEVE_AFTER_TERM: 123, + STORE_BEFORE_INIT: 132, + STORE_AFTER_TERM: 133, + COMMIT_BEFORE_INIT: 142, + COMMIT_AFTER_TERM: 143, + ARGUMENT_ERROR: 201, + GENERAL_GET_FAILURE: 301, + GENERAL_SET_FAILURE: 351, + GENERAL_COMMIT_FAILURE: 391, + UNDEFINED_DATA_MODEL: 401, + UNIMPLEMENTED_ELEMENT: 402, + VALUE_NOT_INITIALIZED: 403, + READ_ONLY_ELEMENT: 404, + WRITE_ONLY_ELEMENT: 405, + TYPE_MISMATCH: 406, + VALUE_OUT_OF_RANGE: 407, + DEPENDENCY_NOT_ESTABLISHED: 408 +}); + +var ErrorCodes = { + scorm12: scorm12, + scorm2004: scorm2004 +}; +var _default = ErrorCodes; +exports["default"] = _default; + +},{}],8:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var scorm12 = { + CMIString256: '^.{0,255}$', + CMIString4096: '^.{0,4096}$', + CMITime: '^(?:[01]\\d|2[0123]):(?:[012345]\\d):(?:[012345]\\d)$', + // eslint-disable-line + CMITimespan: '^([0-9]{2,}):([0-9]{2}):([0-9]{2})(\.[0-9]{1,2})?$', + // eslint-disable-line + CMIInteger: '^\\d+$', + CMISInteger: '^-?([0-9]+)$', + CMIDecimal: '^-?([0-9]{0,3})(\.[0-9]*)?$', + // eslint-disable-line + CMIIdentifier: "^[\\u0021-\\u007E\\s]{0,255}$", + CMIFeedback: '^.{0,255}$', + // This must be redefined + CMIIndex: '[._](\\d+).', + // Vocabulary Data Type Definition + CMIStatus: '^(passed|completed|failed|incomplete|browsed)$', + CMIStatus2: '^(passed|completed|failed|incomplete|browsed|not attempted)$', + CMIExit: '^(time-out|suspend|logout|)$', + CMIType: '^(true-false|choice|fill-in|matching|performance|sequencing|likert|numeric)$', + CMIResult: '^(correct|wrong|unanticipated|neutral|([0-9]{0,3})?(\\.[0-9]*)?)$', + // eslint-disable-line + NAVEvent: '^(previous|continue)$', + // Data ranges + score_range: '0#100', + audio_range: '-1#100', + speed_range: '-100#100', + weighting_range: '-100#100', + text_range: '-1#1' +}; + +var aicc = _objectSpread(_objectSpread({}, scorm12), { + CMIIdentifier: '^\\w{1,255}$' +}); + +var scorm2004 = { + CMIString200: "^[\\u0000-\\uFFFF]{0,200}$", + CMIString250: "^[\\u0000-\\uFFFF]{0,250}$", + CMIString1000: "^[\\u0000-\\uFFFF]{0,1000}$", + CMIString4000: "^[\\u0000-\\uFFFF]{0,4000}$", + CMIString64000: "^[\\u0000-\\uFFFF]{0,64000}$", + CMILang: '^([a-zA-Z]{2,3}|i|x)(\-[a-zA-Z0-9\-]{2,8})?$|^$', + // eslint-disable-line + CMILangString250: '^(\{lang=([a-zA-Z]{2,3}|i|x)(\-[a-zA-Z0-9\-]{2,8})?\})?((?!\{.*$).{0,250}$)?$', + // eslint-disable-line + CMILangcr: '^((\{lang=([a-zA-Z]{2,3}|i|x)?(\-[a-zA-Z0-9\-]{2,8})?\}))(.*?)$', + // eslint-disable-line + CMILangString250cr: '^((\{lang=([a-zA-Z]{2,3}|i|x)?(\-[a-zA-Z0-9\-]{2,8})?\})?(.{0,250})?)?$', + // eslint-disable-line + CMILangString4000: '^(\{lang=([a-zA-Z]{2,3}|i|x)(\-[a-zA-Z0-9\-]{2,8})?\})?((?!\{.*$).{0,4000}$)?$', + // eslint-disable-line + CMITime: '^(19[7-9]{1}[0-9]{1}|20[0-2]{1}[0-9]{1}|203[0-8]{1})((-(0[1-9]{1}|1[0-2]{1}))((-(0[1-9]{1}|[1-2]{1}[0-9]{1}|3[0-1]{1}))(T([0-1]{1}[0-9]{1}|2[0-3]{1})((:[0-5]{1}[0-9]{1})((:[0-5]{1}[0-9]{1})((\\.[0-9]{1,2})((Z|([+|-]([0-1]{1}[0-9]{1}|2[0-3]{1})))(:[0-5]{1}[0-9]{1})?)?)?)?)?)?)?)?$', + CMITimespan: '^P(?:([.,\\d]+)Y)?(?:([.,\\d]+)M)?(?:([.,\\d]+)W)?(?:([.,\\d]+)D)?(?:T?(?:([.,\\d]+)H)?(?:([.,\\d]+)M)?(?:([.,\\d]+)S)?)?$', + CMIInteger: '^\\d+$', + CMISInteger: '^-?([0-9]+)$', + CMIDecimal: '^-?([0-9]{1,5})(\\.[0-9]{1,18})?$', + CMIIdentifier: '^\\S{1,250}[a-zA-Z0-9]$', + CMIShortIdentifier: '^[\\w\\.\\-\\_]{1,250}$', + // eslint-disable-line + CMILongIdentifier: '^(?:(?!urn:)\\S{1,4000}|urn:[A-Za-z0-9-]{1,31}:\\S{1,4000}|.{1,4000})$', + // need to re-examine this + CMIFeedback: '^.*$', + // This must be redefined + CMIIndex: '[._](\\d+).', + CMIIndexStore: '.N(\\d+).', + // Vocabulary Data Type Definition + CMICStatus: '^(completed|incomplete|not attempted|unknown)$', + CMISStatus: '^(passed|failed|unknown)$', + CMIExit: '^(time-out|suspend|logout|normal)$', + CMIType: '^(true-false|choice|fill-in|long-fill-in|matching|performance|sequencing|likert|numeric|other)$', + CMIResult: '^(correct|incorrect|unanticipated|neutral|-?([0-9]{1,4})(\\.[0-9]{1,18})?)$', + NAVEvent: '^(previous|continue|exit|exitAll|abandon|abandonAll|suspendAll|\{target=\\S{0,200}[a-zA-Z0-9]\}choice|jump)$', + // eslint-disable-line + NAVBoolean: '^(unknown|true|false$)', + NAVTarget: '^(previous|continue|choice.{target=\\S{0,200}[a-zA-Z0-9]})$', + // Data ranges + scaled_range: '-1#1', + audio_range: '0#*', + speed_range: '0#*', + text_range: '-1#1', + progress_range: '0#1' +}; +var Regex = { + aicc: aicc, + scorm12: scorm12, + scorm2004: scorm2004 +}; +var _default = Regex; +exports["default"] = _default; + +},{}],9:[function(require,module,exports){ +"use strict"; + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.Scorm2004ValidationError = exports.AICCValidationError = exports.Scorm12ValidationError = exports.ValidationError = void 0; + +var _api_constants = _interopRequireDefault(require("./constants/api_constants")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); } + +function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); } + +function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; } + +function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); } + +function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } } + +var scorm12_errors = _api_constants["default"].scorm12.error_descriptions; +var aicc_errors = _api_constants["default"].aicc.error_descriptions; +var scorm2004_errors = _api_constants["default"].scorm2004.error_descriptions; +/** + * Base Validation Exception + */ + +var _errorCode = new WeakMap(); + +var _errorMessage = new WeakMap(); + +var _detailedMessage = new WeakMap(); + +var ValidationError = /*#__PURE__*/function (_Error) { + _inherits(ValidationError, _Error); + + var _super = _createSuper(ValidationError); + + /** + * Constructor to take in an error message and code + * @param {number} errorCode + * @param {string} errorMessage + * @param {string} detailedMessage + */ + function ValidationError(errorCode, errorMessage, detailedMessage) { + var _this; + + _classCallCheck(this, ValidationError); + + _this = _super.call(this, errorMessage); + + _errorCode.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _errorMessage.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _detailedMessage.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _classPrivateFieldSet(_assertThisInitialized(_this), _errorCode, errorCode); + + _classPrivateFieldSet(_assertThisInitialized(_this), _errorMessage, errorMessage); + + _classPrivateFieldSet(_assertThisInitialized(_this), _detailedMessage, detailedMessage); + + return _this; + } + + _createClass(ValidationError, [{ + key: "errorCode", + get: + /** + * Getter for #errorCode + * @return {number} + */ + function get() { + return _classPrivateFieldGet(this, _errorCode); + } + /** + * Getter for #errorMessage + * @return {string} + */ + + }, { + key: "errorMessage", + get: function get() { + return _classPrivateFieldGet(this, _errorMessage); + } + /** + * Getter for #detailedMessage + * @return {string} + */ + + }, { + key: "detailedMessage", + get: function get() { + return _classPrivateFieldGet(this, _detailedMessage); + } + }]); + + return ValidationError; +}( /*#__PURE__*/_wrapNativeSuper(Error)); +/** + * SCORM 1.2 Validation Error + */ + + +exports.ValidationError = ValidationError; + +var Scorm12ValidationError = /*#__PURE__*/function (_ValidationError) { + _inherits(Scorm12ValidationError, _ValidationError); + + var _super2 = _createSuper(Scorm12ValidationError); + + /** + * Constructor to take in an error code + * @param {number} errorCode + */ + function Scorm12ValidationError(errorCode) { + var _this2; + + _classCallCheck(this, Scorm12ValidationError); + + if ({}.hasOwnProperty.call(scorm12_errors, String(errorCode))) { + _this2 = _super2.call(this, errorCode, scorm12_errors[String(errorCode)].basicMessage, scorm12_errors[String(errorCode)].detailMessage); + } else { + _this2 = _super2.call(this, 101, scorm12_errors['101'].basicMessage, scorm12_errors['101'].detailMessage); + } + + return _possibleConstructorReturn(_this2); + } + + return Scorm12ValidationError; +}(ValidationError); +/** + * AICC Validation Error + */ + + +exports.Scorm12ValidationError = Scorm12ValidationError; + +var AICCValidationError = /*#__PURE__*/function (_ValidationError2) { + _inherits(AICCValidationError, _ValidationError2); + + var _super3 = _createSuper(AICCValidationError); + + /** + * Constructor to take in an error code + * @param {number} errorCode + */ + function AICCValidationError(errorCode) { + var _this3; + + _classCallCheck(this, AICCValidationError); + + if ({}.hasOwnProperty.call(aicc_errors, String(errorCode))) { + _this3 = _super3.call(this, errorCode, aicc_errors[String(errorCode)].basicMessage, aicc_errors[String(errorCode)].detailMessage); + } else { + _this3 = _super3.call(this, 101, aicc_errors['101'].basicMessage, aicc_errors['101'].detailMessage); + } + + return _possibleConstructorReturn(_this3); + } + + return AICCValidationError; +}(ValidationError); +/** + * SCORM 2004 Validation Error + */ + + +exports.AICCValidationError = AICCValidationError; + +var Scorm2004ValidationError = /*#__PURE__*/function (_ValidationError3) { + _inherits(Scorm2004ValidationError, _ValidationError3); + + var _super4 = _createSuper(Scorm2004ValidationError); + + /** + * Constructor to take in an error code + * @param {number} errorCode + */ + function Scorm2004ValidationError(errorCode) { + var _this4; + + _classCallCheck(this, Scorm2004ValidationError); + + if ({}.hasOwnProperty.call(scorm2004_errors, String(errorCode))) { + _this4 = _super4.call(this, errorCode, scorm2004_errors[String(errorCode)].basicMessage, scorm2004_errors[String(errorCode)].detailMessage); + } else { + _this4 = _super4.call(this, 101, scorm2004_errors['101'].basicMessage, scorm2004_errors['101'].detailMessage); + } + + return _possibleConstructorReturn(_this4); + } + + return Scorm2004ValidationError; +}(ValidationError); + +exports.Scorm2004ValidationError = Scorm2004ValidationError; + +},{"./constants/api_constants":6}],10:[function(require,module,exports){ +"use strict"; + +var _Scorm12API = _interopRequireDefault(require("../Scorm12API")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +window.Scorm12API = _Scorm12API["default"]; + +},{"../Scorm12API":3}],11:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.getSecondsAsHHMMSS = getSecondsAsHHMMSS; +exports.getSecondsAsISODuration = getSecondsAsISODuration; +exports.getTimeAsSeconds = getTimeAsSeconds; +exports.getDurationAsSeconds = getDurationAsSeconds; +exports.addTwoDurations = addTwoDurations; +exports.addHHMMSSTimeStrings = addHHMMSSTimeStrings; +exports.flatten = flatten; +exports.unflatten = unflatten; +exports.countDecimals = countDecimals; +exports.SECONDS_PER_DAY = exports.SECONDS_PER_HOUR = exports.SECONDS_PER_MINUTE = exports.SECONDS_PER_SECOND = void 0; + +function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); } + +function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } + +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit(arr, i) { var _i = arr && (typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]); if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } + +var SECONDS_PER_SECOND = 1.0; +exports.SECONDS_PER_SECOND = SECONDS_PER_SECOND; +var SECONDS_PER_MINUTE = 60; +exports.SECONDS_PER_MINUTE = SECONDS_PER_MINUTE; +var SECONDS_PER_HOUR = 60 * SECONDS_PER_MINUTE; +exports.SECONDS_PER_HOUR = SECONDS_PER_HOUR; +var SECONDS_PER_DAY = 24 * SECONDS_PER_HOUR; +exports.SECONDS_PER_DAY = SECONDS_PER_DAY; +var designations = [['D', SECONDS_PER_DAY], ['H', SECONDS_PER_HOUR], ['M', SECONDS_PER_MINUTE], ['S', SECONDS_PER_SECOND]]; +/** + * Converts a Number to a String of HH:MM:SS + * + * @param {Number} totalSeconds + * @return {string} + */ + +function getSecondsAsHHMMSS(totalSeconds) { + // SCORM spec does not deal with negative durations, give zero back + if (!totalSeconds || totalSeconds <= 0) { + return '00:00:00'; + } + + var hours = Math.floor(totalSeconds / SECONDS_PER_HOUR); + var dateObj = new Date(totalSeconds * 1000); + var minutes = dateObj.getUTCMinutes(); // make sure we add any possible decimal value + + var seconds = dateObj.getSeconds(); + var ms = totalSeconds % 1.0; + var msStr = ''; + + if (countDecimals(ms) > 0) { + if (countDecimals(ms) > 2) { + msStr = ms.toFixed(2); + } else { + msStr = String(ms); + } + + msStr = '.' + msStr.split('.')[1]; + } + + return (hours + ':' + minutes + ':' + seconds).replace(/\b\d\b/g, '0$&') + msStr; +} +/** + * Calculate the number of seconds from ISO 8601 Duration + * + * @param {Number} seconds + * @return {String} + */ + + +function getSecondsAsISODuration(seconds) { + // SCORM spec does not deal with negative durations, give zero back + if (!seconds || seconds <= 0) { + return 'PT0S'; + } + + var duration = 'P'; + var remainder = seconds; + designations.forEach(function (_ref) { + var _ref2 = _slicedToArray(_ref, 2), + sign = _ref2[0], + current_seconds = _ref2[1]; + + var value = Math.floor(remainder / current_seconds); + remainder = remainder % current_seconds; + + if (countDecimals(remainder) > 2) { + remainder = Number(Number(remainder).toFixed(2)); + } // If we have anything left in the remainder, and we're currently adding + // seconds to the duration, go ahead and add the decimal to the seconds + + + if (sign === 'S' && remainder > 0) { + value += remainder; + } + + if (value) { + if ((duration.indexOf('D') > 0 || sign === 'H' || sign === 'M' || sign === 'S') && duration.indexOf('T') === -1) { + duration += 'T'; + } + + duration += "".concat(value).concat(sign); + } + }); + return duration; +} +/** + * Calculate the number of seconds from HH:MM:SS.DDDDDD + * + * @param {string} timeString + * @param {RegExp} timeRegex + * @return {number} + */ + + +function getTimeAsSeconds(timeString, timeRegex) { + if (!timeString || typeof timeString !== 'string' || !timeString.match(timeRegex)) { + return 0; + } + + var parts = timeString.split(':'); + var hours = Number(parts[0]); + var minutes = Number(parts[1]); + var seconds = Number(parts[2]); + return hours * 3600 + minutes * 60 + seconds; +} +/** + * Calculate the number of seconds from ISO 8601 Duration + * + * @param {string} duration + * @param {RegExp} durationRegex + * @return {number} + */ + + +function getDurationAsSeconds(duration, durationRegex) { + if (!duration || !duration.match(durationRegex)) { + return 0; + } + + var _ref3 = new RegExp(durationRegex).exec(duration) || [], + _ref4 = _slicedToArray(_ref3, 8), + years = _ref4[1], + months = _ref4[2], + days = _ref4[4], + hours = _ref4[5], + minutes = _ref4[6], + seconds = _ref4[7]; + + var result = 0.0; + result += Number(seconds) * 1.0 || 0.0; + result += Number(minutes) * 60.0 || 0.0; + result += Number(hours) * 3600.0 || 0.0; + result += Number(days) * (60 * 60 * 24.0) || 0.0; + result += Number(years) * (60 * 60 * 24 * 365.0) || 0.0; + return result; +} +/** + * Adds together two ISO8601 Duration strings + * + * @param {string} first + * @param {string} second + * @param {RegExp} durationRegex + * @return {string} + */ + + +function addTwoDurations(first, second, durationRegex) { + return getSecondsAsISODuration(getDurationAsSeconds(first, durationRegex) + getDurationAsSeconds(second, durationRegex)); +} +/** + * Add together two HH:MM:SS.DD strings + * + * @param {string} first + * @param {string} second + * @param {RegExp} timeRegex + * @return {string} + */ + + +function addHHMMSSTimeStrings(first, second, timeRegex) { + return getSecondsAsHHMMSS(getTimeAsSeconds(first, timeRegex) + getTimeAsSeconds(second, timeRegex)); +} +/** + * Flatten a JSON object down to string paths for each values + * @param {object} data + * @return {object} + */ + + +function flatten(data) { + var result = {}; + /** + * Recurse through the object + * @param {*} cur + * @param {*} prop + */ + + function recurse(cur, prop) { + if (Object(cur) !== cur) { + result[prop] = cur; + } else if (Array.isArray(cur)) { + for (var i = 0, l = cur.length; i < l; i++) { + recurse(cur[i], prop + '[' + i + ']'); + if (l === 0) result[prop] = []; + } + } else { + var isEmpty = true; + + for (var p in cur) { + if ({}.hasOwnProperty.call(cur, p)) { + isEmpty = false; + recurse(cur[p], prop ? prop + '.' + p : p); + } + } + + if (isEmpty && prop) result[prop] = {}; + } + } + + recurse(data, ''); + return result; +} +/** + * Un-flatten a flat JSON object + * @param {object} data + * @return {object} + */ + + +function unflatten(data) { + 'use strict'; + + if (Object(data) !== data || Array.isArray(data)) return data; + var regex = /\.?([^.[\]]+)|\[(\d+)]/g; + var result = {}; + + for (var p in data) { + if ({}.hasOwnProperty.call(data, p)) { + var cur = result; + var prop = ''; + var m = regex.exec(p); + + while (m) { + cur = cur[prop] || (cur[prop] = m[2] ? [] : {}); + prop = m[2] || m[1]; + m = regex.exec(p); + } + + cur[prop] = data[p]; + } + } + + return result[''] || result; +} +/** + * Counts the number of decimal places + * @param {number} num + * @return {number} + */ + + +function countDecimals(num) { + if (Math.floor(num) === num || String(num).indexOf('.') < 0) return 0; + var parts = num.toString().split('.')[1]; + return parts.length || 0; +} + +},{}]},{},[10]) +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","node_modules/lodash.debounce/index.js","src/BaseAPI.js","src/Scorm12API.js","src/cmi/common.js","src/cmi/scorm12_cmi.js","src/constants/api_constants.js","src/constants/error_codes.js","src/constants/regex.js","src/exceptions.js","src/exports/scorm12.js","src/utilities.js"],"names":[],"mappings":"AAAA;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;ACxXA;;AACA;;AACA;;AACA;;AACA;;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,IAAM,gBAAgB,GAAG,0BAAa,MAAtC;AACA,IAAM,mBAAmB,GAAG,yBAAW,OAAvC;AAEA;AACA;AACA;AACA;;;;;;;;IACqB,O;AAqCnB;AACF;AACA;AACA;AACA;AACA;AACE,mBAAY,WAAZ,EAAyB,QAAzB,EAAmC;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA,aAxCvB;AACV,QAAA,UAAU,EAAE,KADF;AAEV,QAAA,iBAAiB,EAAE,EAFT;AAGV,QAAA,WAAW,EAAE,KAHH;AAIV,QAAA,gBAAgB,EAAE,KAJR;AAKV,QAAA,YAAY,EAAE,KALJ;AAMV,QAAA,gBAAgB,EAAE,MANR;AAMgB;AAC1B,QAAA,qBAAqB,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","file":"generated.js","sourceRoot":"","sourcesContent":["(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()","/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the `TypeError` message for \"Functions\" methods. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n  return root.Date.now();\n};\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        result = wait - timeSinceLastCall;\n\n    return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && objectToString.call(value) == symbolTag);\n}\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = value.replace(reTrim, '');\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = debounce;\n","// @flow\nimport {CMIArray} from './cmi/common';\nimport {ValidationError} from './exceptions';\nimport ErrorCodes from './constants/error_codes';\nimport APIConstants from './constants/api_constants';\nimport {unflatten} from './utilities';\nimport debounce from 'lodash.debounce';\n\nconst global_constants = APIConstants.global;\nconst scorm12_error_codes = ErrorCodes.scorm12;\n\n/**\n * Base API class for AICC, SCORM 1.2, and SCORM 2004. Should be considered\n * abstract, and never initialized on it's own.\n */\nexport default class BaseAPI {\n  #timeout;\n  #error_codes;\n  #settings = {\n    autocommit: false,\n    autocommitSeconds: 10,\n    asyncCommit: false,\n    sendBeaconCommit: false,\n    lmsCommitUrl: false,\n    dataCommitFormat: 'json', // valid formats are 'json' or 'flattened', 'params'\n    commitRequestDataType: 'application/json;charset=UTF-8',\n    autoProgress: false,\n    logLevel: global_constants.LOG_LEVEL_ERROR,\n    selfReportSessionTime: false,\n    alwaysSendTotalTime: false,\n    strict_errors: true,\n    responseHandler: function(xhr) {\n      let result;\n      if (typeof xhr !== 'undefined') {\n        result = JSON.parse(xhr.responseText);\n        if (result === null || !{}.hasOwnProperty.call(result, 'result')) {\n          result = {};\n          if (xhr.status === 200) {\n            result.result = global_constants.SCORM_TRUE;\n            result.errorCode = 0;\n          } else {\n            result.result = global_constants.SCORM_FALSE;\n            result.errorCode = 101;\n          }\n        }\n      }\n      return result;\n    },\n  };\n  cmi;\n  startingData: {};\n\n  /**\n   * Constructor for Base API class. Sets some shared API fields, as well as\n   * sets up options for the API.\n   * @param {object} error_codes\n   * @param {object} settings\n   */\n  constructor(error_codes, settings) {\n    if (new.target === BaseAPI) {\n      throw new TypeError('Cannot construct BaseAPI instances directly');\n    }\n    this.currentState = global_constants.STATE_NOT_INITIALIZED;\n    this.lastErrorCode = 0;\n    this.listenerArray = [];\n\n    this.#timeout = null;\n    this.#error_codes = error_codes;\n\n    this.settings = settings;\n    this.apiLogLevel = this.settings.logLevel;\n    this.selfReportSessionTime = this.settings.selfReportSessionTime;\n  }\n\n  /**\n   * Initialize the API\n   * @param {string} callbackName\n   * @param {string} initializeMessage\n   * @param {string} terminationMessage\n   * @return {string}\n   */\n  initialize(\n      callbackName: String,\n      initializeMessage?: String,\n      terminationMessage?: String) {\n    let returnValue = global_constants.SCORM_FALSE;\n\n    if (this.isInitialized()) {\n      this.throwSCORMError(this.#error_codes.INITIALIZED, initializeMessage);\n    } else if (this.isTerminated()) {\n      this.throwSCORMError(this.#error_codes.TERMINATED, terminationMessage);\n    } else {\n      if (this.selfReportSessionTime) {\n        this.cmi.setStartTime();\n      }\n\n      this.currentState = global_constants.STATE_INITIALIZED;\n      this.lastErrorCode = 0;\n      returnValue = global_constants.SCORM_TRUE;\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n    this.clearSCORMError(returnValue);\n\n    return returnValue;\n  }\n\n  /**\n   * Getter for #error_codes\n   * @return {object}\n   */\n  get error_codes() {\n    return this.#error_codes;\n  }\n\n  /**\n   * Getter for #settings\n   * @return {object}\n   */\n  get settings() {\n    return this.#settings;\n  }\n\n  /**\n   * Setter for #settings\n   * @param {object} settings\n   */\n  set settings(settings: Object) {\n    this.#settings = {...this.#settings, ...settings};\n  }\n\n  /**\n   * Terminates the current run of the API\n   * @param {string} callbackName\n   * @param {boolean} checkTerminated\n   * @return {string}\n   */\n  terminate(\n      callbackName: String,\n      checkTerminated: boolean) {\n    let returnValue = global_constants.SCORM_FALSE;\n\n    if (this.checkState(checkTerminated,\n        this.#error_codes.TERMINATION_BEFORE_INIT,\n        this.#error_codes.MULTIPLE_TERMINATION)) {\n      this.currentState = global_constants.STATE_TERMINATED;\n\n      const result = this.storeData(true);\n      if (!this.settings.sendBeaconCommit && !this.settings.asyncCommit &&\n          typeof result.errorCode !== 'undefined' && result.errorCode > 0) {\n        this.throwSCORMError(result.errorCode);\n      }\n      returnValue = (typeof result !== 'undefined' && result.result) ?\n          result.result : global_constants.SCORM_FALSE;\n\n      if (checkTerminated) this.lastErrorCode = 0;\n\n      returnValue = global_constants.SCORM_TRUE;\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n    this.clearSCORMError(returnValue);\n\n    return returnValue;\n  }\n\n  /**\n   * Get the value of the CMIElement.\n   *\n   * @param {string} callbackName\n   * @param {boolean} checkTerminated\n   * @param {string} CMIElement\n   * @return {string}\n   */\n  getValue(\n      callbackName: String,\n      checkTerminated: boolean,\n      CMIElement: String) {\n    let returnValue;\n\n    if (this.checkState(checkTerminated,\n        this.#error_codes.RETRIEVE_BEFORE_INIT,\n        this.#error_codes.RETRIEVE_AFTER_TERM)) {\n      if (checkTerminated) this.lastErrorCode = 0;\n      try {\n        returnValue = this.getCMIValue(CMIElement);\n      } catch (e) {\n        if (e instanceof ValidationError) {\n          this.lastErrorCode = e.errorCode;\n          returnValue = global_constants.SCORM_FALSE;\n        } else {\n          if (e.message) {\n            console.error(e.message);\n          } else {\n            console.error(e);\n          }\n          this.throwSCORMError(this.#error_codes.GENERAL);\n        }\n      }\n      this.processListeners(callbackName, CMIElement);\n    }\n\n    this.apiLog(callbackName, CMIElement, ': returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n    this.clearSCORMError(returnValue);\n\n    return returnValue;\n  }\n\n  /**\n   * Sets the value of the CMIElement.\n   *\n   * @param {string} callbackName\n   * @param {string} commitCallback\n   * @param {boolean} checkTerminated\n   * @param {string} CMIElement\n   * @param {*} value\n   * @return {string}\n   */\n  setValue(\n      callbackName: String,\n      commitCallback: String,\n      checkTerminated: boolean,\n      CMIElement,\n      value) {\n    if (value !== undefined) {\n      value = String(value);\n    }\n    let returnValue = global_constants.SCORM_FALSE;\n\n    if (this.checkState(checkTerminated, this.#error_codes.STORE_BEFORE_INIT,\n        this.#error_codes.STORE_AFTER_TERM)) {\n      if (checkTerminated) this.lastErrorCode = 0;\n      try {\n        returnValue = this.setCMIValue(CMIElement, value);\n      } catch (e) {\n        if (e instanceof ValidationError) {\n          this.lastErrorCode = e.errorCode;\n          returnValue = global_constants.SCORM_FALSE;\n        } else {\n          if (e.message) {\n            console.error(e.message);\n          } else {\n            console.error(e);\n          }\n          this.throwSCORMError(this.#error_codes.GENERAL);\n        }\n      }\n      this.processListeners(callbackName, CMIElement, value);\n    }\n\n    if (returnValue === undefined) {\n      returnValue = global_constants.SCORM_FALSE;\n    }\n\n    // If we didn't have any errors while setting the data, go ahead and\n    // schedule a commit, if autocommit is turned on\n    if (String(this.lastErrorCode) === '0') {\n      if (this.settings.autocommit && !this.#timeout) {\n        this.scheduleCommit(this.settings.autocommitSeconds * 1000, commitCallback);\n      }\n    }\n\n    this.apiLog(callbackName, CMIElement,\n        ': ' + value + ': result: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n    this.clearSCORMError(returnValue);\n\n    return returnValue;\n  }\n\n  /**\n   * Orders LMS to store all content parameters\n   * @param {string} callbackName\n   * @param {boolean} checkTerminated\n   * @return {string}\n   */\n  commit(\n      callbackName: String,\n      checkTerminated: boolean) {\n    this.clearScheduledCommit();\n\n    let returnValue = global_constants.SCORM_FALSE;\n\n    if (this.checkState(checkTerminated, this.#error_codes.COMMIT_BEFORE_INIT,\n        this.#error_codes.COMMIT_AFTER_TERM)) {\n      const result = this.storeData(false);\n      if (!this.settings.sendBeaconCommit && !this.settings.asyncCommit &&\n          result.errorCode && result.errorCode > 0) {\n        this.throwSCORMError(result.errorCode);\n      }\n      returnValue = (typeof result !== 'undefined' && result.result) ?\n          result.result : global_constants.SCORM_FALSE;\n\n      this.apiLog(callbackName, 'HttpRequest', ' Result: ' + returnValue,\n          global_constants.LOG_LEVEL_DEBUG);\n\n      if (checkTerminated) this.lastErrorCode = 0;\n\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n    this.clearSCORMError(returnValue);\n\n    return returnValue;\n  }\n\n  /**\n   * Returns last error code\n   * @param {string} callbackName\n   * @return {string}\n   */\n  getLastError(callbackName: String) {\n    const returnValue = String(this.lastErrorCode);\n\n    this.processListeners(callbackName);\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n\n    return returnValue;\n  }\n\n  /**\n   * Returns the errorNumber error description\n   *\n   * @param {string} callbackName\n   * @param {(string|number)} CMIErrorCode\n   * @return {string}\n   */\n  getErrorString(callbackName: String, CMIErrorCode) {\n    let returnValue = '';\n\n    if (CMIErrorCode !== null && CMIErrorCode !== '') {\n      returnValue = this.getLmsErrorMessageDetails(CMIErrorCode);\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n\n    return returnValue;\n  }\n\n  /**\n   * Returns a comprehensive description of the errorNumber error.\n   *\n   * @param {string} callbackName\n   * @param {(string|number)} CMIErrorCode\n   * @return {string}\n   */\n  getDiagnostic(callbackName: String, CMIErrorCode) {\n    let returnValue = '';\n\n    if (CMIErrorCode !== null && CMIErrorCode !== '') {\n      returnValue = this.getLmsErrorMessageDetails(CMIErrorCode, true);\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n\n    return returnValue;\n  }\n\n  /**\n   * Checks the LMS state and ensures it has been initialized.\n   *\n   * @param {boolean} checkTerminated\n   * @param {number} beforeInitError\n   * @param {number} afterTermError\n   * @return {boolean}\n   */\n  checkState(\n      checkTerminated: boolean,\n      beforeInitError: number,\n      afterTermError?: number) {\n    if (this.isNotInitialized()) {\n      this.throwSCORMError(beforeInitError);\n      return false;\n    } else if (checkTerminated && this.isTerminated()) {\n      this.throwSCORMError(afterTermError);\n      return false;\n    }\n\n    return true;\n  }\n\n  /**\n   * Logging for all SCORM actions\n   *\n   * @param {string} functionName\n   * @param {string} CMIElement\n   * @param {string} logMessage\n   * @param {number}messageLevel\n   */\n  apiLog(\n      functionName: String,\n      CMIElement: String,\n      logMessage: String,\n      messageLevel: number) {\n    logMessage = this.formatMessage(functionName, CMIElement, logMessage);\n\n    if (messageLevel >= this.apiLogLevel) {\n      switch (messageLevel) {\n        case global_constants.LOG_LEVEL_ERROR:\n          console.error(logMessage);\n          break;\n        case global_constants.LOG_LEVEL_WARNING:\n          console.warn(logMessage);\n          break;\n        case global_constants.LOG_LEVEL_INFO:\n          console.info(logMessage);\n          break;\n        case global_constants.LOG_LEVEL_DEBUG:\n          if (console.debug) {\n            console.debug(logMessage);\n          } else {\n            console.log(logMessage);\n          }\n          break;\n      }\n    }\n  }\n\n  /**\n   * Formats the SCORM messages for easy reading\n   *\n   * @param {string} functionName\n   * @param {string} CMIElement\n   * @param {string} message\n   * @return {string}\n   */\n  formatMessage(functionName: String, CMIElement: String, message: String) {\n    const baseLength = 20;\n    let messageString = '';\n\n    messageString += functionName;\n\n    let fillChars = baseLength - messageString.length;\n\n    for (let i = 0; i < fillChars; i++) {\n      messageString += ' ';\n    }\n\n    messageString += ': ';\n\n    if (CMIElement) {\n      const CMIElementBaseLength = 70;\n\n      messageString += CMIElement;\n\n      fillChars = CMIElementBaseLength - messageString.length;\n\n      for (let j = 0; j < fillChars; j++) {\n        messageString += ' ';\n      }\n    }\n\n    if (message) {\n      messageString += message;\n    }\n\n    return messageString;\n  }\n\n  /**\n   * Checks to see if {str} contains {tester}\n   *\n   * @param {string} str String to check against\n   * @param {string} tester String to check for\n   * @return {boolean}\n   */\n  stringMatches(str: String, tester: String) {\n    return str && tester && str.match(tester);\n  }\n\n  /**\n   * Check to see if the specific object has the given property\n   * @param {*} refObject\n   * @param {string} attribute\n   * @return {boolean}\n   * @private\n   */\n  _checkObjectHasProperty(refObject, attribute: String) {\n    return Object.hasOwnProperty.call(refObject, attribute) ||\n        Object.getOwnPropertyDescriptor(\n            Object.getPrototypeOf(refObject), attribute) ||\n        (attribute in refObject);\n  }\n\n  /**\n   * Returns the message that corresponds to errorNumber\n   * APIs that inherit BaseAPI should override this function\n   *\n   * @param {(string|number)} _errorNumber\n   * @param {boolean} _detail\n   * @return {string}\n   * @abstract\n   */\n  getLmsErrorMessageDetails(_errorNumber, _detail) {\n    throw new Error(\n        'The getLmsErrorMessageDetails method has not been implemented');\n  }\n\n  /**\n   * Gets the value for the specific element.\n   * APIs that inherit BaseAPI should override this function\n   *\n   * @param {string} _CMIElement\n   * @return {string}\n   * @abstract\n   */\n  getCMIValue(_CMIElement) {\n    throw new Error('The getCMIValue method has not been implemented');\n  }\n\n  /**\n   * Sets the value for the specific element.\n   * APIs that inherit BaseAPI should override this function\n   *\n   * @param {string} _CMIElement\n   * @param {any} _value\n   * @return {string}\n   * @abstract\n   */\n  setCMIValue(_CMIElement, _value) {\n    throw new Error('The setCMIValue method has not been implemented');\n  }\n\n  /**\n   * Shared API method to set a valid for a given element.\n   *\n   * @param {string} methodName\n   * @param {boolean} scorm2004\n   * @param {string} CMIElement\n   * @param {*} value\n   * @return {string}\n   */\n  _commonSetCMIValue(\n      methodName: String, scorm2004: boolean, CMIElement, value) {\n    if (!CMIElement || CMIElement === '') {\n      return global_constants.SCORM_FALSE;\n    }\n\n    const structure = CMIElement.split('.');\n    let refObject = this;\n    let returnValue = global_constants.SCORM_FALSE;\n    let foundFirstIndex = false;\n\n    const invalidErrorMessage = `The data model element passed to ${methodName} (${CMIElement}) is not a valid SCORM data model element.`;\n    const invalidErrorCode = scorm2004 ?\n        this.#error_codes.UNDEFINED_DATA_MODEL :\n        this.#error_codes.GENERAL;\n\n    for (let i = 0; i < structure.length; i++) {\n      const attribute = structure[i];\n\n      if (i === structure.length - 1) {\n        if (scorm2004 && (attribute.substr(0, 8) === '{target=') &&\n            (typeof refObject._isTargetValid == 'function')) {\n          this.throwSCORMError(this.#error_codes.READ_ONLY_ELEMENT);\n        } else if (!this._checkObjectHasProperty(refObject, attribute)) {\n          this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n        } else {\n          if (this.isInitialized() &&\n              this.stringMatches(CMIElement, '\\\\.correct_responses\\\\.\\\\d+')) {\n            this.validateCorrectResponse(CMIElement, value);\n          }\n\n          if (!scorm2004 || this.lastErrorCode === 0) {\n            refObject[attribute] = value;\n            returnValue = global_constants.SCORM_TRUE;\n          }\n        }\n      } else {\n        refObject = refObject[attribute];\n        if (!refObject) {\n          this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n          break;\n        }\n\n        if (refObject instanceof CMIArray) {\n          const index = parseInt(structure[i + 1], 10);\n\n          // SCO is trying to set an item on an array\n          if (!isNaN(index)) {\n            const item = refObject.childArray[index];\n\n            if (item) {\n              refObject = item;\n              foundFirstIndex = true;\n            } else {\n              const newChild = this.getChildElement(CMIElement, value,\n                  foundFirstIndex);\n              foundFirstIndex = true;\n\n              if (!newChild) {\n                this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n              } else {\n                if (refObject.initialized) newChild.initialize();\n\n                refObject.childArray.push(newChild);\n                refObject = newChild;\n              }\n            }\n\n            // Have to update i value to skip the array position\n            i++;\n          }\n        }\n      }\n    }\n\n    if (returnValue === global_constants.SCORM_FALSE) {\n      this.apiLog(methodName, null,\n          `There was an error setting the value for: ${CMIElement}, value of: ${value}`,\n          global_constants.LOG_LEVEL_WARNING);\n    }\n\n    return returnValue;\n  }\n\n  /**\n   * Abstract method for validating that a response is correct.\n   *\n   * @param {string} _CMIElement\n   * @param {*} _value\n   */\n  validateCorrectResponse(_CMIElement, _value) {\n    // just a stub method\n  }\n\n  /**\n   * Gets or builds a new child element to add to the array.\n   * APIs that inherit BaseAPI should override this method.\n   *\n   * @param {string} _CMIElement - unused\n   * @param {*} _value - unused\n   * @param {boolean} _foundFirstIndex - unused\n   * @return {*}\n   * @abstract\n   */\n  getChildElement(_CMIElement, _value, _foundFirstIndex) {\n    throw new Error('The getChildElement method has not been implemented');\n  }\n\n  /**\n   * Gets a value from the CMI Object\n   *\n   * @param {string} methodName\n   * @param {boolean} scorm2004\n   * @param {string} CMIElement\n   * @return {*}\n   */\n  _commonGetCMIValue(methodName: String, scorm2004: boolean, CMIElement) {\n    if (!CMIElement || CMIElement === '') {\n      return '';\n    }\n\n    const structure = CMIElement.split('.');\n    let refObject = this;\n    let attribute = null;\n\n    const uninitializedErrorMessage = `The data model element passed to ${methodName} (${CMIElement}) has not been initialized.`;\n    const invalidErrorMessage = `The data model element passed to ${methodName} (${CMIElement}) is not a valid SCORM data model element.`;\n    const invalidErrorCode = scorm2004 ?\n        this.#error_codes.UNDEFINED_DATA_MODEL :\n        this.#error_codes.GENERAL;\n\n    for (let i = 0; i < structure.length; i++) {\n      attribute = structure[i];\n\n      if (!scorm2004) {\n        if (i === structure.length - 1) {\n          if (!this._checkObjectHasProperty(refObject, attribute)) {\n            this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n            return;\n          }\n        }\n      } else {\n        if ((String(attribute).substr(0, 8) === '{target=') &&\n            (typeof refObject._isTargetValid == 'function')) {\n          const target = String(attribute).\n              substr(8, String(attribute).length - 9);\n          return refObject._isTargetValid(target);\n        } else if (!this._checkObjectHasProperty(refObject, attribute)) {\n          this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n          return;\n        }\n      }\n\n      refObject = refObject[attribute];\n      if (refObject === undefined) {\n        this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n        break;\n      }\n\n      if (refObject instanceof CMIArray) {\n        const index = parseInt(structure[i + 1], 10);\n\n        // SCO is trying to set an item on an array\n        if (!isNaN(index)) {\n          const item = refObject.childArray[index];\n\n          if (item) {\n            refObject = item;\n          } else {\n            this.throwSCORMError(this.#error_codes.VALUE_NOT_INITIALIZED,\n                uninitializedErrorMessage);\n            break;\n          }\n\n          // Have to update i value to skip the array position\n          i++;\n        }\n      }\n    }\n\n    if (refObject === null || refObject === undefined) {\n      if (!scorm2004) {\n        if (attribute === '_children') {\n          this.throwSCORMError(scorm12_error_codes.CHILDREN_ERROR);\n        } else if (attribute === '_count') {\n          this.throwSCORMError(scorm12_error_codes.COUNT_ERROR);\n        }\n      }\n    } else {\n      return refObject;\n    }\n  }\n\n  /**\n   * Returns true if the API's current state is STATE_INITIALIZED\n   *\n   * @return {boolean}\n   */\n  isInitialized() {\n    return this.currentState === global_constants.STATE_INITIALIZED;\n  }\n\n  /**\n   * Returns true if the API's current state is STATE_NOT_INITIALIZED\n   *\n   * @return {boolean}\n   */\n  isNotInitialized() {\n    return this.currentState === global_constants.STATE_NOT_INITIALIZED;\n  }\n\n  /**\n   * Returns true if the API's current state is STATE_TERMINATED\n   *\n   * @return {boolean}\n   */\n  isTerminated() {\n    return this.currentState === global_constants.STATE_TERMINATED;\n  }\n\n  /**\n   * Provides a mechanism for attaching to a specific SCORM event\n   *\n   * @param {string} listenerName\n   * @param {function} callback\n   */\n  on(listenerName: String, callback: function) {\n    if (!callback) return;\n\n    const listenerFunctions = listenerName.split(' ');\n    for (let i = 0; i < listenerFunctions.length; i++) {\n      const listenerSplit = listenerFunctions[i].split('.');\n      if (listenerSplit.length === 0) return;\n\n      const functionName = listenerSplit[0];\n\n      let CMIElement = null;\n      if (listenerSplit.length > 1) {\n        CMIElement = listenerName.replace(functionName + '.', '');\n      }\n\n      this.listenerArray.push({\n        functionName: functionName,\n        CMIElement: CMIElement,\n        callback: callback,\n      });\n\n      this.apiLog('on', functionName, `Added event listener: ${this.listenerArray.length}`, global_constants.LOG_LEVEL_INFO);\n    }\n  }\n\n  /**\n   * Provides a mechanism for detaching a specific SCORM event listener\n   *\n   * @param {string} listenerName\n   * @param {function} callback\n   */\n  off(listenerName: String, callback: function) {\n    if (!callback) return;\n\n    const listenerFunctions = listenerName.split(' ');\n    for (let i = 0; i < listenerFunctions.length; i++) {\n      const listenerSplit = listenerFunctions[i].split('.');\n      if (listenerSplit.length === 0) return;\n\n      const functionName = listenerSplit[0];\n\n      let CMIElement = null;\n      if (listenerSplit.length > 1) {\n        CMIElement = listenerName.replace(functionName + '.', '');\n      }\n\n      const removeIndex = this.listenerArray.findIndex((obj) =>\n        obj.functionName === functionName &&\n        obj.CMIElement === CMIElement &&\n        obj.callback === callback\n      );\n      if (removeIndex !== -1) {\n        this.listenerArray.splice(removeIndex, 1);\n        this.apiLog('off', functionName, `Removed event listener: ${this.listenerArray.length}`, global_constants.LOG_LEVEL_INFO);\n      }\n    }\n  }\n\n  /**\n   * Provides a mechanism for clearing all listeners from a specific SCORM event\n   *\n   * @param {string} listenerName\n   */\n  clear(listenerName: String) {\n    const listenerFunctions = listenerName.split(' ');\n    for (let i = 0; i < listenerFunctions.length; i++) {\n      const listenerSplit = listenerFunctions[i].split('.');\n      if (listenerSplit.length === 0) return;\n\n      const functionName = listenerSplit[0];\n\n      let CMIElement = null;\n      if (listenerSplit.length > 1) {\n        CMIElement = listenerName.replace(functionName + '.', '');\n      }\n\n      this.listenerArray = this.listenerArray.filter((obj) =>\n        obj.functionName !== functionName &&\n        obj.CMIElement !== CMIElement,\n      );\n    }\n  }\n\n  /**\n   * Processes any 'on' listeners that have been created\n   *\n   * @param {string} functionName\n   * @param {string} CMIElement\n   * @param {*} value\n   */\n  processListeners(functionName: String, CMIElement: String, value: any) {\n    this.apiLog(functionName, CMIElement, value);\n    for (let i = 0; i < this.listenerArray.length; i++) {\n      const listener = this.listenerArray[i];\n      const functionsMatch = listener.functionName === functionName;\n      const listenerHasCMIElement = !!listener.CMIElement;\n      let CMIElementsMatch = false;\n      if (CMIElement && listener.CMIElement &&\n          listener.CMIElement.substring(listener.CMIElement.length - 1) ===\n          '*') {\n        CMIElementsMatch = CMIElement.indexOf(listener.CMIElement.substring(0,\n            listener.CMIElement.length - 1)) === 0;\n      } else {\n        CMIElementsMatch = listener.CMIElement === CMIElement;\n      }\n\n      if (functionsMatch && (!listenerHasCMIElement || CMIElementsMatch)) {\n        listener.callback(CMIElement, value);\n      }\n    }\n  }\n\n  /**\n   * Throws a SCORM error\n   *\n   * @param {number} errorNumber\n   * @param {string} message\n   */\n  throwSCORMError(errorNumber: number, message: String) {\n    if (!message) {\n      message = this.getLmsErrorMessageDetails(errorNumber);\n    }\n\n    this.apiLog('throwSCORMError', null, errorNumber + ': ' + message,\n        global_constants.LOG_LEVEL_ERROR);\n\n    this.lastErrorCode = String(errorNumber);\n  }\n\n  /**\n   * Clears the last SCORM error code on success.\n   *\n   * @param {string} success\n   */\n  clearSCORMError(success: String) {\n    if (success !== undefined && success !== global_constants.SCORM_FALSE) {\n      this.lastErrorCode = 0;\n    }\n  }\n\n  /**\n   * Attempts to store the data to the LMS, logs data if no LMS configured\n   * APIs that inherit BaseAPI should override this function\n   *\n   * @param {boolean} _calculateTotalTime\n   * @return {string}\n   * @abstract\n   */\n  storeData(_calculateTotalTime) {\n    throw new Error(\n        'The storeData method has not been implemented');\n  }\n\n  /**\n   * Load the CMI from a flattened JSON object\n   * @param {object} json\n   * @param {string} CMIElement\n   */\n  loadFromFlattenedJSON(json, CMIElement) {\n    if (!this.isNotInitialized()) {\n      console.error(\n          'loadFromFlattenedJSON can only be called before the call to lmsInitialize.');\n      return;\n    }\n\n    /**\n     * Test match pattern.\n     *\n     * @param {string} a\n     * @param {string} c\n     * @param {RegExp} a_pattern\n     * @return {number}\n     */\n    function testPattern(a, c, a_pattern) {\n      const a_match = a.match(a_pattern);\n\n      let c_match;\n      if (a_match !== null && (c_match = c.match(a_pattern)) !== null) {\n        const a_num = Number(a_match[2]);\n        const c_num = Number(c_match[2]);\n        if (a_num === c_num) {\n          if (a_match[3] === 'id') {\n            return -1;\n          } else if (a_match[3] === 'type') {\n            if (c_match[3] === 'id') {\n              return 1;\n            } else {\n              return -1;\n            }\n          } else {\n            return 1;\n          }\n        }\n        return a_num - c_num;\n      }\n\n      return null;\n    }\n\n    const int_pattern = /^(cmi\\.interactions\\.)(\\d+)\\.(.*)$/;\n    const obj_pattern = /^(cmi\\.objectives\\.)(\\d+)\\.(.*)$/;\n\n    const result = Object.keys(json).map(function(key) {\n      return [String(key), json[key]];\n    });\n\n    // CMI interactions need to have id and type loaded before any other fields\n    result.sort(function([a, b], [c, d]) {\n      let test;\n      if ((test = testPattern(a, c, int_pattern)) !== null) {\n        return test;\n      }\n      if ((test = testPattern(a, c, obj_pattern)) !== null) {\n        return test;\n      }\n\n      if (a < c) {\n        return -1;\n      }\n      if (a > c) {\n        return 1;\n      }\n      return 0;\n    });\n\n    let obj;\n    result.forEach((element) => {\n      obj = {};\n      obj[element[0]] = element[1];\n      this.loadFromJSON(unflatten(obj), CMIElement);\n    });\n  }\n\n  /**\n   * Loads CMI data from a JSON object.\n   *\n   * @param {object} json\n   * @param {string} CMIElement\n   */\n  loadFromJSON(json, CMIElement) {\n    if (!this.isNotInitialized()) {\n      console.error(\n          'loadFromJSON can only be called before the call to lmsInitialize.');\n      return;\n    }\n\n    CMIElement = CMIElement !== undefined ? CMIElement : 'cmi';\n\n    this.startingData = json;\n\n    // could this be refactored down to flatten(json) then setCMIValue on each?\n    for (const key in json) {\n      if ({}.hasOwnProperty.call(json, key) && json[key]) {\n        const currentCMIElement = (CMIElement ? CMIElement + '.' : '') + key;\n        const value = json[key];\n\n        if (value['childArray']) {\n          for (let i = 0; i < value['childArray'].length; i++) {\n            this.loadFromJSON(value['childArray'][i],\n                currentCMIElement + '.' + i);\n          }\n        } else if (value.constructor === Object) {\n          this.loadFromJSON(value, currentCMIElement);\n        } else {\n          this.setCMIValue(currentCMIElement, value);\n        }\n      }\n    }\n  }\n\n  /**\n   * Render the CMI object to JSON for sending to an LMS.\n   *\n   * @return {string}\n   */\n  renderCMIToJSONString() {\n    const cmi = this.cmi;\n    // Do we want/need to return fields that have no set value?\n    // return JSON.stringify({ cmi }, (k, v) => v === undefined ? null : v, 2);\n    return JSON.stringify({cmi});\n  }\n\n  /**\n   * Returns a JS object representing the current cmi\n   * @return {object}\n   */\n  renderCMIToJSONObject() {\n    // Do we want/need to return fields that have no set value?\n    // return JSON.stringify({ cmi }, (k, v) => v === undefined ? null : v, 2);\n    return JSON.parse(this.renderCMIToJSONString());\n  }\n\n  /**\n   * Render the cmi object to the proper format for LMS commit\n   * APIs that inherit BaseAPI should override this function\n   *\n   * @param {boolean} _terminateCommit\n   * @return {*}\n   * @abstract\n   */\n  renderCommitCMI(_terminateCommit) {\n    throw new Error(\n        'The storeData method has not been implemented');\n  }\n\n  /**\n   * Send the request to the LMS\n   * @param {string} url\n   * @param {object|Array} params\n   * @param {boolean} immediate\n   * @return {object}\n   */\n  processHttpRequest(url: String, params, immediate = false) {\n    const api = this;\n    const process = function(url, params, settings, error_codes) {\n      const genericError = {\n        'result': global_constants.SCORM_FALSE,\n        'errorCode': error_codes.GENERAL,\n      };\n\n      let result;\n      if (!settings.sendBeaconCommit) {\n        const httpReq = new XMLHttpRequest();\n        httpReq.open('POST', url, settings.asyncCommit);\n        if (settings.asyncCommit) {\n          httpReq.onload = function(e) {\n            if (typeof settings.responseHandler === 'function') {\n              result = settings.responseHandler(httpReq);\n            } else {\n              result = JSON.parse(httpReq.responseText);\n            }\n          };\n        }\n        try {\n          if (params instanceof Array) {\n            httpReq.setRequestHeader('Content-Type',\n                'application/x-www-form-urlencoded');\n            httpReq.send(params.join('&'));\n          } else {\n            httpReq.setRequestHeader('Content-Type',\n                settings.commitRequestDataType);\n            httpReq.send(JSON.stringify(params));\n          }\n\n          if (!settings.asyncCommit) {\n            if (typeof settings.responseHandler === 'function') {\n              result = settings.responseHandler(httpReq);\n            } else {\n              result = JSON.parse(httpReq.responseText);\n            }\n          } else {\n            result = {};\n            result.result = global_constants.SCORM_TRUE;\n            result.errorCode = 0;\n            api.processListeners('CommitSuccess');\n            return result;\n          }\n        } catch (e) {\n          console.error(e);\n          api.processListeners('CommitError');\n          return genericError;\n        }\n      } else {\n        try {\n          const headers = {\n            type: settings.commitRequestDataType,\n          };\n          let blob;\n          if (params instanceof Array) {\n            blob = new Blob([params.join('&')], headers);\n          } else {\n            blob = new Blob([JSON.stringify(params)], headers);\n          }\n\n          result = {};\n          if (navigator.sendBeacon(url, blob)) {\n            result.result = global_constants.SCORM_TRUE;\n            result.errorCode = 0;\n          } else {\n            result.result = global_constants.SCORM_FALSE;\n            result.errorCode = 101;\n          }\n        } catch (e) {\n          console.error(e);\n          api.processListeners('CommitError');\n          return genericError;\n        }\n      }\n\n      if (typeof result === 'undefined') {\n        api.processListeners('CommitError');\n        return genericError;\n      }\n\n      if (result.result === true ||\n          result.result === global_constants.SCORM_TRUE) {\n        api.processListeners('CommitSuccess');\n      } else {\n        api.processListeners('CommitError');\n      }\n\n      return result;\n    };\n\n    if (typeof debounce !== 'undefined') {\n      const debounced = debounce(process, 500);\n      debounced(url, params, this.settings, this.error_codes);\n\n      // if we're terminating, go ahead and commit immediately\n      if (immediate) {\n        debounced.flush();\n      }\n\n      return {\n        result: global_constants.SCORM_TRUE,\n        errorCode: 0,\n      };\n    } else {\n      return process(url, params, this.settings, this.error_codes);\n    }\n  }\n\n  /**\n   * Throws a SCORM error\n   *\n   * @param {number} when - the number of milliseconds to wait before committing\n   * @param {string} callback - the name of the commit event callback\n   */\n  scheduleCommit(when: number, callback: string) {\n    this.#timeout = new ScheduledCommit(this, when, callback);\n    this.apiLog('scheduleCommit', '', 'scheduled',\n        global_constants.LOG_LEVEL_DEBUG);\n  }\n\n  /**\n   * Clears and cancels any currently scheduled commits\n   */\n  clearScheduledCommit() {\n    if (this.#timeout) {\n      this.#timeout.cancel();\n      this.#timeout = null;\n      this.apiLog('clearScheduledCommit', '', 'cleared',\n          global_constants.LOG_LEVEL_DEBUG);\n    }\n  }\n}\n\n/**\n * Private class that wraps a timeout call to the commit() function\n */\nclass ScheduledCommit {\n  #API;\n  #cancelled = false;\n  #timeout;\n  #callback;\n\n  /**\n   * Constructor for ScheduledCommit\n   * @param {BaseAPI} API\n   * @param {number} when\n   * @param {string} callback\n   */\n  constructor(API: any, when: number, callback: string) {\n    this.#API = API;\n    this.#timeout = setTimeout(this.wrapper.bind(this), when);\n    this.#callback = callback;\n  }\n\n  /**\n   * Cancel any currently scheduled commit\n   */\n  cancel() {\n    this.#cancelled = true;\n    if (this.#timeout) {\n      clearTimeout(this.#timeout);\n    }\n  }\n\n  /**\n   * Wrap the API commit call to check if the call has already been cancelled\n   */\n  wrapper() {\n    if (!this.#cancelled) {\n      this.#API.commit(this.#callback);\n    }\n  }\n}\n","// @flow\nimport BaseAPI from './BaseAPI';\nimport {\n  CMI,\n  CMIInteractionsCorrectResponsesObject,\n  CMIInteractionsObject,\n  CMIInteractionsObjectivesObject,\n  CMIObjectivesObject, NAV,\n} from './cmi/scorm12_cmi';\nimport * as Utilities from './utilities';\nimport APIConstants from './constants/api_constants';\nimport ErrorCodes from './constants/error_codes';\n\nconst scorm12_constants = APIConstants.scorm12;\nconst global_constants = APIConstants.global;\nconst scorm12_error_codes = ErrorCodes.scorm12;\n\n/**\n * API class for SCORM 1.2\n */\nexport default class Scorm12API extends BaseAPI {\n  /**\n   * Constructor for SCORM 1.2 API\n   * @param {object} settings\n   */\n  constructor(settings: {}) {\n    const finalSettings = {\n      ...{\n        mastery_override: false,\n      }, ...settings,\n    };\n\n    super(scorm12_error_codes, finalSettings);\n\n    this.cmi = new CMI();\n    this.nav = new NAV();\n\n    // Rename functions to match 1.2 Spec and expose to modules\n    this.LMSInitialize = this.lmsInitialize;\n    this.LMSFinish = this.lmsFinish;\n    this.LMSGetValue = this.lmsGetValue;\n    this.LMSSetValue = this.lmsSetValue;\n    this.LMSCommit = this.lmsCommit;\n    this.LMSGetLastError = this.lmsGetLastError;\n    this.LMSGetErrorString = this.lmsGetErrorString;\n    this.LMSGetDiagnostic = this.lmsGetDiagnostic;\n  }\n\n  /**\n   * lmsInitialize function from SCORM 1.2 Spec\n   *\n   * @return {string} bool\n   */\n  lmsInitialize() {\n    this.cmi.initialize();\n    return this.initialize('LMSInitialize', 'LMS was already initialized!',\n        'LMS is already finished!');\n  }\n\n  /**\n   * LMSFinish function from SCORM 1.2 Spec\n   *\n   * @return {string} bool\n   */\n  lmsFinish() {\n    const result = this.terminate('LMSFinish', true);\n\n    if (result === global_constants.SCORM_TRUE) {\n      if (this.nav.event !== '') {\n        if (this.nav.event === 'continue') {\n          this.processListeners('SequenceNext');\n        } else {\n          this.processListeners('SequencePrevious');\n        }\n      } else if (this.settings.autoProgress) {\n        this.processListeners('SequenceNext');\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * LMSGetValue function from SCORM 1.2 Spec\n   *\n   * @param {string} CMIElement\n   * @return {string}\n   */\n  lmsGetValue(CMIElement) {\n    return this.getValue('LMSGetValue', false, CMIElement);\n  }\n\n  /**\n   * LMSSetValue function from SCORM 1.2 Spec\n   *\n   * @param {string} CMIElement\n   * @param {*} value\n   * @return {string}\n   */\n  lmsSetValue(CMIElement, value) {\n    return this.setValue('LMSSetValue', 'LMSCommit', false, CMIElement, value);\n  }\n\n  /**\n   * LMSCommit function from SCORM 1.2 Spec\n   *\n   * @return {string} bool\n   */\n  lmsCommit() {\n    return this.commit('LMSCommit', false);\n  }\n\n  /**\n   * LMSGetLastError function from SCORM 1.2 Spec\n   *\n   * @return {string}\n   */\n  lmsGetLastError() {\n    return this.getLastError('LMSGetLastError');\n  }\n\n  /**\n   * LMSGetErrorString function from SCORM 1.2 Spec\n   *\n   * @param {string} CMIErrorCode\n   * @return {string}\n   */\n  lmsGetErrorString(CMIErrorCode) {\n    return this.getErrorString('LMSGetErrorString', CMIErrorCode);\n  }\n\n  /**\n   * LMSGetDiagnostic function from SCORM 1.2 Spec\n   *\n   * @param {string} CMIErrorCode\n   * @return {string}\n   */\n  lmsGetDiagnostic(CMIErrorCode) {\n    return this.getDiagnostic('LMSGetDiagnostic', CMIErrorCode);\n  }\n\n  /**\n   * Sets a value on the CMI Object\n   *\n   * @param {string} CMIElement\n   * @param {*} value\n   * @return {string}\n   */\n  setCMIValue(CMIElement, value) {\n    return this._commonSetCMIValue('LMSSetValue', false, CMIElement, value);\n  }\n\n  /**\n   * Gets a value from the CMI Object\n   *\n   * @param {string} CMIElement\n   * @return {*}\n   */\n  getCMIValue(CMIElement) {\n    return this._commonGetCMIValue('getCMIValue', false, CMIElement);\n  }\n\n  /**\n   * Gets or builds a new child element to add to the array.\n   *\n   * @param {string} CMIElement\n   * @param {*} value\n   * @param {boolean} foundFirstIndex\n   * @return {object}\n   */\n  getChildElement(CMIElement, value, foundFirstIndex) {\n    let newChild;\n\n    if (this.stringMatches(CMIElement, 'cmi\\\\.objectives\\\\.\\\\d+')) {\n      newChild = new CMIObjectivesObject();\n    } else if (foundFirstIndex && this.stringMatches(CMIElement,\n        'cmi\\\\.interactions\\\\.\\\\d+\\\\.correct_responses\\\\.\\\\d+')) {\n      newChild = new CMIInteractionsCorrectResponsesObject();\n    } else if (foundFirstIndex && this.stringMatches(CMIElement,\n        'cmi\\\\.interactions\\\\.\\\\d+\\\\.objectives\\\\.\\\\d+')) {\n      newChild = new CMIInteractionsObjectivesObject();\n    } else if (!foundFirstIndex &&\n        this.stringMatches(CMIElement, 'cmi\\\\.interactions\\\\.\\\\d+')) {\n      newChild = new CMIInteractionsObject();\n    }\n\n    return newChild;\n  }\n\n  /**\n   * Validates Correct Response values\n   *\n   * @param {string} CMIElement\n   * @param {*} value\n   * @return {boolean}\n   */\n  validateCorrectResponse(CMIElement, value) {\n    return true;\n  }\n\n  /**\n   * Returns the message that corresponds to errorNumber.\n   *\n   * @param {*} errorNumber\n   * @param {boolean} detail\n   * @return {string}\n   */\n  getLmsErrorMessageDetails(errorNumber, detail) {\n    let basicMessage = 'No Error';\n    let detailMessage = 'No Error';\n\n    // Set error number to string since inconsistent from modules if string or number\n    errorNumber = String(errorNumber);\n    if (scorm12_constants.error_descriptions[errorNumber]) {\n      basicMessage = scorm12_constants.error_descriptions[errorNumber].basicMessage;\n      detailMessage = scorm12_constants.error_descriptions[errorNumber].detailMessage;\n    }\n\n    return detail ? detailMessage : basicMessage;\n  }\n\n  /**\n   * Replace the whole API with another\n   *\n   * @param {Scorm12API} newAPI\n   */\n  replaceWithAnotherScormAPI(newAPI) {\n    // Data Model\n    this.cmi = newAPI.cmi;\n  }\n\n  /**\n   * Render the cmi object to the proper format for LMS commit\n   *\n   * @param {boolean} terminateCommit\n   * @return {object|Array}\n   */\n  renderCommitCMI(terminateCommit: boolean) {\n    const cmiExport = this.renderCMIToJSONObject();\n\n    if (terminateCommit) {\n      cmiExport.cmi.core.total_time = this.cmi.getCurrentTotalTime();\n    }\n\n    const result = [];\n    const flattened = Utilities.flatten(cmiExport);\n    switch (this.settings.dataCommitFormat) {\n      case 'flattened':\n        return Utilities.flatten(cmiExport);\n      case 'params':\n        for (const item in flattened) {\n          if ({}.hasOwnProperty.call(flattened, item)) {\n            result.push(`${item}=${flattened[item]}`);\n          }\n        }\n        return result;\n      case 'json':\n      default:\n        return cmiExport;\n    }\n  }\n\n  /**\n   * Attempts to store the data to the LMS\n   *\n   * @param {boolean} terminateCommit\n   * @return {string}\n   */\n  storeData(terminateCommit: boolean) {\n    if (terminateCommit) {\n      const originalStatus = this.cmi.core.lesson_status;\n      if (originalStatus === 'not attempted') {\n        this.cmi.core.lesson_status = 'completed';\n      }\n\n      if (this.cmi.core.lesson_mode === 'normal') {\n        if (this.cmi.core.credit === 'credit') {\n          if (this.settings.mastery_override &&\n              this.cmi.student_data.mastery_score !== '' &&\n              this.cmi.core.score.raw !== '') {\n            if (parseFloat(this.cmi.core.score.raw) >= parseFloat(this.cmi.student_data.mastery_score)) {\n              this.cmi.core.lesson_status = 'passed';\n            } else {\n              this.cmi.core.lesson_status = 'failed';\n            }\n          }\n        }\n      } else if (this.cmi.core.lesson_mode === 'browse') {\n        if ((this.startingData?.cmi?.core?.lesson_status || '') === '' && originalStatus === 'not attempted') {\n          this.cmi.core.lesson_status = 'browsed';\n        }\n      }\n    }\n\n    const commitObject = this.renderCommitCMI(terminateCommit ||\n        this.settings.alwaysSendTotalTime);\n\n    if (this.apiLogLevel === global_constants.LOG_LEVEL_DEBUG) {\n      console.debug('Commit (terminated: ' + (terminateCommit ? 'yes' : 'no') + '): ');\n      console.debug(commitObject);\n    }\n    if (this.settings.lmsCommitUrl) {\n      return this.processHttpRequest(this.settings.lmsCommitUrl, commitObject, terminateCommit);\n    } else {\n      return global_constants.SCORM_TRUE;\n    }\n  }\n}\n","// @flow\nimport APIConstants from '../constants/api_constants';\nimport ErrorCodes from '../constants/error_codes';\nimport Regex from '../constants/regex';\n\nconst scorm12_constants = APIConstants.scorm12;\nconst scorm12_regex = Regex.scorm12;\nconst scorm12_error_codes = ErrorCodes.scorm12;\n\n/**\n * Check if the value matches the proper format. If not, throw proper error code.\n *\n * @param {string} value\n * @param {string} regexPattern\n * @param {number} errorCode\n * @param {class} errorClass\n * @param {boolean} allowEmptyString\n * @return {boolean}\n */\nexport function checkValidFormat(\n    value: String,\n    regexPattern: String,\n    errorCode: number,\n    errorClass: function,\n    allowEmptyString?: boolean) {\n  const formatRegex = new RegExp(regexPattern);\n  const matches = value.match(formatRegex);\n  if (allowEmptyString && value === '') {\n    return true;\n  }\n  if (value === undefined || !matches || matches[0] === '') {\n    throw new errorClass.prototype.constructor(errorCode);\n  }\n  return true;\n}\n\n/**\n * Check if the value matches the proper range. If not, throw proper error code.\n *\n * @param {*} value\n * @param {string} rangePattern\n * @param {number} errorCode\n * @param {class} errorClass\n * @return {boolean}\n */\nexport function checkValidRange(\n    value: any,\n    rangePattern: String,\n    errorCode: number,\n    errorClass: function) {\n  const ranges = rangePattern.split('#');\n  value = value * 1.0;\n  if (value >= ranges[0]) {\n    if ((ranges[1] === '*') || (value <= ranges[1])) {\n      return true;\n    } else {\n      throw new errorClass.prototype.constructor(errorCode);\n    }\n  } else {\n    throw new errorClass.prototype.constructor(errorCode);\n  }\n}\n\n/**\n * Base class for API cmi objects\n */\nexport class BaseCMI {\n  jsonString = false;\n  #initialized = false;\n  #start_time;\n\n  /**\n   * Constructor for BaseCMI, just marks the class as abstract\n   */\n  constructor() {\n    if (new.target === BaseCMI) {\n      throw new TypeError('Cannot construct BaseCMI instances directly');\n    }\n  }\n\n  /**\n   * Getter for #initialized\n   * @return {boolean}\n   */\n  get initialized() {\n    return this.#initialized;\n  }\n\n  /**\n   * Getter for #start_time\n   * @return {Number}\n   */\n  get start_time() {\n    return this.#start_time;\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    this.#initialized = true;\n  }\n\n  /**\n   * Called when the player should override the 'session_time' provided by\n   * the module\n   */\n  setStartTime() {\n    this.#start_time = new Date().getTime();\n  }\n}\n\n/**\n * Base class for cmi *.score objects\n */\nexport class CMIScore extends BaseCMI {\n  /**\n   * Constructor for *.score\n   * @param {string} score_children\n   * @param {string} score_range\n   * @param {string} max\n   * @param {number} invalidErrorCode\n   * @param {number} invalidTypeCode\n   * @param {number} invalidRangeCode\n   * @param {string} decimalRegex\n   * @param {class} errorClass\n   */\n  constructor(\n      {\n        score_children,\n        score_range,\n        max,\n        invalidErrorCode,\n        invalidTypeCode,\n        invalidRangeCode,\n        decimalRegex,\n        errorClass,\n      }) {\n    super();\n\n    this.#_children = score_children ||\n        scorm12_constants.score_children;\n    this.#_score_range = !score_range ? false : scorm12_regex.score_range;\n    this.#max = (max || max === '') ? max : '100';\n    this.#_invalid_error_code = invalidErrorCode ||\n        scorm12_error_codes.INVALID_SET_VALUE;\n    this.#_invalid_type_code = invalidTypeCode ||\n        scorm12_error_codes.TYPE_MISMATCH;\n    this.#_invalid_range_code = invalidRangeCode ||\n        scorm12_error_codes.VALUE_OUT_OF_RANGE;\n    this.#_decimal_regex = decimalRegex ||\n        scorm12_regex.CMIDecimal;\n    this.#_error_class = errorClass;\n  }\n\n  #_children;\n  #_score_range;\n  #_invalid_error_code;\n  #_invalid_type_code;\n  #_invalid_range_code;\n  #_decimal_regex;\n  #_error_class;\n  #raw = '';\n  #min = '';\n  #max;\n\n  /**\n   * Getter for _children\n   * @return {string}\n   * @private\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for _children. Just throws an error.\n   * @param {string} _children\n   * @private\n   */\n  set _children(_children) {\n    throw new this.#_error_class.prototype.constructor(this.#_invalid_error_code);\n  }\n\n  /**\n   * Getter for #raw\n   * @return {string}\n   */\n  get raw() {\n    return this.#raw;\n  }\n\n  /**\n   * Setter for #raw\n   * @param {string} raw\n   */\n  set raw(raw) {\n    if (checkValidFormat(raw, this.#_decimal_regex, this.#_invalid_type_code, this.#_error_class) &&\n        (!this.#_score_range ||\n            checkValidRange(raw, this.#_score_range, this.#_invalid_range_code, this.#_error_class))) {\n      this.#raw = raw;\n    }\n  }\n\n  /**\n   * Getter for #min\n   * @return {string}\n   */\n  get min() {\n    return this.#min;\n  }\n\n  /**\n   * Setter for #min\n   * @param {string} min\n   */\n  set min(min) {\n    if (checkValidFormat(min, this.#_decimal_regex, this.#_invalid_type_code, this.#_error_class) &&\n        (!this.#_score_range ||\n            checkValidRange(min, this.#_score_range, this.#_invalid_range_code, this.#_error_class))) {\n      this.#min = min;\n    }\n  }\n\n  /**\n   * Getter for #max\n   * @return {string}\n   */\n  get max() {\n    return this.#max;\n  }\n\n  /**\n   * Setter for #max\n   * @param {string} max\n   */\n  set max(max) {\n    if (checkValidFormat(max, this.#_decimal_regex, this.#_invalid_type_code, this.#_error_class) &&\n        (!this.#_score_range ||\n            checkValidRange(max, this.#_score_range, this.#_invalid_range_code, this.#_error_class))) {\n      this.#max = max;\n    }\n  }\n\n  /**\n   * toJSON for *.score\n   * @return {{min: string, max: string, raw: string}}\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'raw': this.raw,\n      'min': this.min,\n      'max': this.max,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Base class for cmi *.n objects\n */\nexport class CMIArray extends BaseCMI {\n  /**\n   * Constructor cmi *.n arrays\n   * @param {string} children\n   * @param {number} errorCode\n   * @param {class} errorClass\n   */\n  constructor({children, errorCode, errorClass}) {\n    super();\n    this.#_children = children;\n    this.#errorCode = errorCode;\n    this.#errorClass = errorClass;\n    this.childArray = [];\n  }\n\n  #errorCode;\n  #errorClass;\n  #_children;\n\n  /**\n   * Getter for _children\n   * @return {*}\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for _children. Just throws an error.\n   * @param {string} _children\n   */\n  set _children(_children) {\n    throw new this.#errorClass.prototype.constructor(this.#errorCode);\n  }\n\n  /**\n   * Getter for _count\n   * @return {number}\n   */\n  get _count() {\n    return this.childArray.length;\n  }\n\n  /**\n   * Setter for _count. Just throws an error.\n   * @param {number} _count\n   */\n  set _count(_count) {\n    throw new this.#errorClass.prototype.constructor(this.#errorCode);\n  }\n\n  /**\n   * toJSON for *.n arrays\n   * @return {object}\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {};\n    for (let i = 0; i < this.childArray.length; i++) {\n      result[i + ''] = this.childArray[i];\n    }\n    delete this.jsonString;\n    return result;\n  }\n}\n","// @flow\nimport {\n  BaseCMI,\n  checkValidFormat,\n  checkValidRange,\n  CMIArray,\n  CMIScore,\n} from './common';\nimport APIConstants from '../constants/api_constants';\nimport ErrorCodes from '../constants/error_codes';\nimport Regex from '../constants/regex';\nimport {Scorm12ValidationError} from '../exceptions';\nimport * as Utilities from '../utilities';\nimport * as Util from '../utilities';\n\nconst scorm12_constants = APIConstants.scorm12;\nconst scorm12_regex = Regex.scorm12;\nconst scorm12_error_codes = ErrorCodes.scorm12;\n\n/**\n * Helper method for throwing Read Only error\n */\nexport function throwReadOnlyError() {\n  throw new Scorm12ValidationError(scorm12_error_codes.READ_ONLY_ELEMENT);\n}\n\n/**\n * Helper method for throwing Write Only error\n */\nexport function throwWriteOnlyError() {\n  throw new Scorm12ValidationError(scorm12_error_codes.WRITE_ONLY_ELEMENT);\n}\n\n/**\n * Helper method for throwing Invalid Set error\n */\nfunction throwInvalidValueError() {\n  throw new Scorm12ValidationError(scorm12_error_codes.INVALID_SET_VALUE);\n}\n\n/**\n * Helper method, no reason to have to pass the same error codes every time\n * @param {*} value\n * @param {string} regexPattern\n * @param {boolean} allowEmptyString\n * @return {boolean}\n */\nexport function check12ValidFormat(\n    value: String,\n    regexPattern: String,\n    allowEmptyString?: boolean) {\n  return checkValidFormat(\n      value,\n      regexPattern,\n      scorm12_error_codes.TYPE_MISMATCH,\n      Scorm12ValidationError,\n      allowEmptyString\n  );\n}\n\n/**\n * Helper method, no reason to have to pass the same error codes every time\n * @param {*} value\n * @param {string} rangePattern\n * @param {boolean} allowEmptyString\n * @return {boolean}\n */\nexport function check12ValidRange(\n    value: any,\n    rangePattern: String,\n    allowEmptyString?: boolean) {\n  return checkValidRange(\n      value,\n      rangePattern,\n      scorm12_error_codes.VALUE_OUT_OF_RANGE,\n      Scorm12ValidationError,\n      allowEmptyString\n  );\n}\n\n/**\n * Class representing the cmi object for SCORM 1.2\n */\nexport class CMI extends BaseCMI {\n  #_children = '';\n  #_version = '3.4';\n  #launch_data = '';\n  #comments = '';\n  #comments_from_lms = '';\n\n  student_data = null;\n\n  /**\n   * Constructor for the SCORM 1.2 cmi object\n   * @param {string} cmi_children\n   * @param {(CMIStudentData|AICCCMIStudentData)} student_data\n   * @param {boolean} initialized\n   */\n  constructor(cmi_children, student_data, initialized: boolean) {\n    super();\n\n    if (initialized) this.initialize();\n\n    this.#_children = cmi_children ?\n        cmi_children :\n        scorm12_constants.cmi_children;\n    this.core = new CMICore();\n    this.objectives = new CMIObjectives();\n    this.student_data = student_data ? student_data : new CMIStudentData();\n    this.student_preference = new CMIStudentPreference();\n    this.interactions = new CMIInteractions();\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.core?.initialize();\n    this.objectives?.initialize();\n    this.student_data?.initialize();\n    this.student_preference?.initialize();\n    this.interactions?.initialize();\n  }\n\n  /**\n   * toJSON for cmi\n   *\n   * @return {\n   *    {\n   *      suspend_data: string,\n   *      launch_data: string,\n   *      comments: string,\n   *      comments_from_lms: string,\n   *      core: CMICore,\n   *      objectives: CMIObjectives,\n   *      student_data: CMIStudentData,\n   *      student_preference: CMIStudentPreference,\n   *      interactions: CMIInteractions\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'suspend_data': this.suspend_data,\n      'launch_data': this.launch_data,\n      'comments': this.comments,\n      'comments_from_lms': this.comments_from_lms,\n      'core': this.core,\n      'objectives': this.objectives,\n      'student_data': this.student_data,\n      'student_preference': this.student_preference,\n      'interactions': this.interactions,\n    };\n    delete this.jsonString;\n    return result;\n  }\n\n  /**\n   * Getter for #_version\n   * @return {string}\n   */\n  get _version() {\n    return this.#_version;\n  }\n\n  /**\n   * Setter for #_version. Just throws an error.\n   * @param {string} _version\n   */\n  set _version(_version) {\n    throwInvalidValueError();\n  }\n\n  /**\n   * Getter for #_children\n   * @return {string}\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for #_version. Just throws an error.\n   * @param {string} _children\n   */\n  set _children(_children) {\n    throwInvalidValueError();\n  }\n\n  /**\n   * Getter for #suspend_data\n   * @return {string}\n   */\n  get suspend_data() {\n    return this.core?.suspend_data;\n  }\n\n  /**\n   * Setter for #suspend_data\n   * @param {string} suspend_data\n   */\n  set suspend_data(suspend_data) {\n    if (this.core) {\n      this.core.suspend_data = suspend_data;\n    }\n  }\n\n  /**\n   * Getter for #launch_data\n   * @return {string}\n   */\n  get launch_data() {\n    return this.#launch_data;\n  }\n\n  /**\n   * Setter for #launch_data. Can only be called before  initialization.\n   * @param {string} launch_data\n   */\n  set launch_data(launch_data) {\n    !this.initialized ? this.#launch_data = launch_data : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #comments\n   * @return {string}\n   */\n  get comments() {\n    return this.#comments;\n  }\n\n  /**\n   * Setter for #comments\n   * @param {string} comments\n   */\n  set comments(comments) {\n    if (check12ValidFormat(comments, scorm12_regex.CMIString4096, true)) {\n      this.#comments = comments;\n    }\n  }\n\n  /**\n   * Getter for #comments_from_lms\n   * @return {string}\n   */\n  get comments_from_lms() {\n    return this.#comments_from_lms;\n  }\n\n  /**\n   * Setter for #comments_from_lms. Can only be called before  initialization.\n   * @param {string} comments_from_lms\n   */\n  set comments_from_lms(comments_from_lms) {\n    !this.initialized ?\n        this.#comments_from_lms = comments_from_lms :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Adds the current session time to the existing total time.\n   *\n   * @return {string}\n   */\n  getCurrentTotalTime() {\n    return this.core.getCurrentTotalTime(this.start_time);\n  }\n}\n\n/**\n * Class representing the cmi.core object\n * @extends BaseCMI\n */\nclass CMICore extends BaseCMI {\n  /**\n   * Constructor for cmi.core\n   */\n  constructor() {\n    super();\n\n    this.score = new CMIScore(\n        {\n          score_children: scorm12_constants.score_children,\n          score_range: scorm12_regex.score_range,\n          invalidErrorCode: scorm12_error_codes.INVALID_SET_VALUE,\n          invalidTypeCode: scorm12_error_codes.TYPE_MISMATCH,\n          invalidRangeCode: scorm12_error_codes.VALUE_OUT_OF_RANGE,\n          errorClass: Scorm12ValidationError,\n        });\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.score?.initialize();\n  }\n\n  #_children = scorm12_constants.core_children;\n  #student_id = '';\n  #student_name = '';\n  #lesson_location = '';\n  #credit = '';\n  #lesson_status = 'not attempted';\n  #entry = '';\n  #total_time = '';\n  #lesson_mode = 'normal';\n  #exit = '';\n  #session_time = '00:00:00';\n  #suspend_data = '';\n\n  /**\n   * Getter for #_children\n   * @return {string}\n   * @private\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for #_children. Just throws an error.\n   * @param {string} _children\n   * @private\n   */\n  set _children(_children) {\n    throwInvalidValueError();\n  }\n\n  /**\n   * Getter for #student_id\n   * @return {string}\n   */\n  get student_id() {\n    return this.#student_id;\n  }\n\n  /**\n   * Setter for #student_id. Can only be called before  initialization.\n   * @param {string} student_id\n   */\n  set student_id(student_id) {\n    !this.initialized ? this.#student_id = student_id : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #student_name\n   * @return {string}\n   */\n  get student_name() {\n    return this.#student_name;\n  }\n\n  /**\n   * Setter for #student_name. Can only be called before  initialization.\n   * @param {string} student_name\n   */\n  set student_name(student_name) {\n    !this.initialized ?\n        this.#student_name = student_name :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #lesson_location\n   * @return {string}\n   */\n  get lesson_location() {\n    return this.#lesson_location;\n  }\n\n  /**\n   * Setter for #lesson_location\n   * @param {string} lesson_location\n   */\n  set lesson_location(lesson_location) {\n    if (check12ValidFormat(lesson_location, scorm12_regex.CMIString256, true)) {\n      this.#lesson_location = lesson_location;\n    }\n  }\n\n  /**\n   * Getter for #credit\n   * @return {string}\n   */\n  get credit() {\n    return this.#credit;\n  }\n\n  /**\n   * Setter for #credit. Can only be called before  initialization.\n   * @param {string} credit\n   */\n  set credit(credit) {\n    !this.initialized ? this.#credit = credit : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #lesson_status\n   * @return {string}\n   */\n  get lesson_status() {\n    return this.#lesson_status;\n  }\n\n  /**\n   * Setter for #lesson_status\n   * @param {string} lesson_status\n   */\n  set lesson_status(lesson_status) {\n    if (this.initialized) {\n      if (check12ValidFormat(lesson_status, scorm12_regex.CMIStatus)) {\n        this.#lesson_status = lesson_status;\n      }\n    } else {\n      if (check12ValidFormat(lesson_status, scorm12_regex.CMIStatus2)) {\n        this.#lesson_status = lesson_status;\n      }\n    }\n  }\n\n  /**\n   * Getter for #entry\n   * @return {string}\n   */\n  get entry() {\n    return this.#entry;\n  }\n\n  /**\n   * Setter for #entry. Can only be called before  initialization.\n   * @param {string} entry\n   */\n  set entry(entry) {\n    !this.initialized ? this.#entry = entry : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #total_time\n   * @return {string}\n   */\n  get total_time() {\n    return this.#total_time;\n  }\n\n  /**\n   * Setter for #total_time. Can only be called before  initialization.\n   * @param {string} total_time\n   */\n  set total_time(total_time) {\n    !this.initialized ? this.#total_time = total_time : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #lesson_mode\n   * @return {string}\n   */\n  get lesson_mode() {\n    return this.#lesson_mode;\n  }\n\n  /**\n   * Setter for #lesson_mode. Can only be called before  initialization.\n   * @param {string} lesson_mode\n   */\n  set lesson_mode(lesson_mode) {\n    !this.initialized ? this.#lesson_mode = lesson_mode : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #exit. Should only be called during JSON export.\n   * @return {*}\n   */\n  get exit() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#exit;\n  }\n\n  /**\n   * Setter for #exit\n   * @param {string} exit\n   */\n  set exit(exit) {\n    if (check12ValidFormat(exit, scorm12_regex.CMIExit, true)) {\n      this.#exit = exit;\n    }\n  }\n\n  /**\n   * Getter for #session_time. Should only be called during JSON export.\n   * @return {*}\n   */\n  get session_time() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#session_time;\n  }\n\n  /**\n   * Setter for #session_time\n   * @param {string} session_time\n   */\n  set session_time(session_time) {\n    if (check12ValidFormat(session_time, scorm12_regex.CMITimespan)) {\n      this.#session_time = session_time;\n    }\n  }\n\n  /**\n   * Getter for #suspend_data\n   * @return {string}\n   */\n  get suspend_data() {\n    return this.#suspend_data;\n  }\n\n  /**\n   * Setter for #suspend_data\n   * @param {string} suspend_data\n   */\n  set suspend_data(suspend_data) {\n    if (check12ValidFormat(suspend_data, scorm12_regex.CMIString4096, true)) {\n      this.#suspend_data = suspend_data;\n    }\n  }\n\n  /**\n   * Adds the current session time to the existing total time.\n   * @param {Number} start_time\n   * @return {string}\n   */\n  getCurrentTotalTime(start_time: Number) {\n    let sessionTime = this.#session_time;\n    const startTime = start_time;\n\n    if (typeof startTime !== 'undefined' && startTime !== null) {\n      const seconds = new Date().getTime() - startTime;\n      sessionTime = Util.getSecondsAsHHMMSS(seconds / 1000);\n    }\n\n    return Utilities.addHHMMSSTimeStrings(\n        this.#total_time,\n        sessionTime,\n        new RegExp(scorm12_regex.CMITimespan),\n    );\n  }\n\n  /**\n   * toJSON for cmi.core\n   *\n   * @return {\n   *    {\n   *      student_name: string,\n   *      entry: string,\n   *      exit: string,\n   *      score: CMIScore,\n   *      student_id: string,\n   *      lesson_mode: string,\n   *      lesson_location: string,\n   *      lesson_status: string,\n   *      credit: string,\n   *      session_time: *\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'student_id': this.student_id,\n      'student_name': this.student_name,\n      'lesson_location': this.lesson_location,\n      'credit': this.credit,\n      'lesson_status': this.lesson_status,\n      'entry': this.entry,\n      'lesson_mode': this.lesson_mode,\n      'exit': this.exit,\n      'session_time': this.session_time,\n      'score': this.score,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.objectives object\n * @extends CMIArray\n */\nclass CMIObjectives extends CMIArray {\n  /**\n   * Constructor for cmi.objectives\n   */\n  constructor() {\n    super({\n      children: scorm12_constants.objectives_children,\n      errorCode: scorm12_error_codes.INVALID_SET_VALUE,\n      errorClass: Scorm12ValidationError,\n    });\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.student_data object\n * @extends BaseCMI\n */\nexport class CMIStudentData extends BaseCMI {\n  #_children;\n  #mastery_score = '';\n  #max_time_allowed = '';\n  #time_limit_action = '';\n\n  /**\n   * Constructor for cmi.student_data\n   * @param {string} student_data_children\n   */\n  constructor(student_data_children) {\n    super();\n\n    this.#_children = student_data_children ?\n        student_data_children :\n        scorm12_constants.student_data_children;\n  }\n\n  /**\n   * Getter for #_children\n   * @return {*}\n   * @private\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for #_children. Just throws an error.\n   * @param {string} _children\n   * @private\n   */\n  set _children(_children) {\n    throwInvalidValueError();\n  }\n\n  /**\n   * Getter for #master_score\n   * @return {string}\n   */\n  get mastery_score() {\n    return this.#mastery_score;\n  }\n\n  /**\n   * Setter for #master_score. Can only be called before  initialization.\n   * @param {string} mastery_score\n   */\n  set mastery_score(mastery_score) {\n    !this.initialized ?\n        this.#mastery_score = mastery_score :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #max_time_allowed\n   * @return {string}\n   */\n  get max_time_allowed() {\n    return this.#max_time_allowed;\n  }\n\n  /**\n   * Setter for #max_time_allowed. Can only be called before  initialization.\n   * @param {string} max_time_allowed\n   */\n  set max_time_allowed(max_time_allowed) {\n    !this.initialized ?\n        this.#max_time_allowed = max_time_allowed :\n        throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #time_limit_action\n   * @return {string}\n   */\n  get time_limit_action() {\n    return this.#time_limit_action;\n  }\n\n  /**\n   * Setter for #time_limit_action. Can only be called before  initialization.\n   * @param {string} time_limit_action\n   */\n  set time_limit_action(time_limit_action) {\n    !this.initialized ?\n        this.#time_limit_action = time_limit_action :\n        throwReadOnlyError();\n  }\n\n  /**\n   * toJSON for cmi.student_data\n   *\n   * @return {\n   *    {\n   *      max_time_allowed: string,\n   *      time_limit_action: string,\n   *      mastery_score: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'mastery_score': this.mastery_score,\n      'max_time_allowed': this.max_time_allowed,\n      'time_limit_action': this.time_limit_action,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.student_preference object\n * @extends BaseCMI\n */\nexport class CMIStudentPreference extends BaseCMI {\n  #_children;\n\n  /**\n   * Constructor for cmi.student_preference\n   * @param {string} student_preference_children\n   */\n  constructor(student_preference_children) {\n    super();\n\n    this.#_children = student_preference_children ?\n        student_preference_children :\n        scorm12_constants.student_preference_children;\n  }\n\n  #audio = '';\n  #language = '';\n  #speed = '';\n  #text = '';\n\n  /**\n   * Getter for #_children\n   * @return {string}\n   * @private\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for #_children. Just throws an error.\n   * @param {string} _children\n   * @private\n   */\n  set _children(_children) {\n    throwInvalidValueError();\n  }\n\n  /**\n   * Getter for #audio\n   * @return {string}\n   */\n  get audio() {\n    return this.#audio;\n  }\n\n  /**\n   * Setter for #audio\n   * @param {string} audio\n   */\n  set audio(audio) {\n    if (check12ValidFormat(audio, scorm12_regex.CMISInteger) &&\n        check12ValidRange(audio, scorm12_regex.audio_range)) {\n      this.#audio = audio;\n    }\n  }\n\n  /**\n   * Getter for #language\n   * @return {string}\n   */\n  get language() {\n    return this.#language;\n  }\n\n  /**\n   * Setter for #language\n   * @param {string} language\n   */\n  set language(language) {\n    if (check12ValidFormat(language, scorm12_regex.CMIString256)) {\n      this.#language = language;\n    }\n  }\n\n  /**\n   * Getter for #speed\n   * @return {string}\n   */\n  get speed() {\n    return this.#speed;\n  }\n\n  /**\n   * Setter for #speed\n   * @param {string} speed\n   */\n  set speed(speed) {\n    if (check12ValidFormat(speed, scorm12_regex.CMISInteger) &&\n        check12ValidRange(speed, scorm12_regex.speed_range)) {\n      this.#speed = speed;\n    }\n  }\n\n  /**\n   * Getter for #text\n   * @return {string}\n   */\n  get text() {\n    return this.#text;\n  }\n\n  /**\n   * Setter for #text\n   * @param {string} text\n   */\n  set text(text) {\n    if (check12ValidFormat(text, scorm12_regex.CMISInteger) &&\n        check12ValidRange(text, scorm12_regex.text_range)) {\n      this.#text = text;\n    }\n  }\n\n  /**\n   * toJSON for cmi.student_preference\n   *\n   * @return {\n   *    {\n   *      audio: string,\n   *      language: string,\n   *      speed: string,\n   *      text: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'audio': this.audio,\n      'language': this.language,\n      'speed': this.speed,\n      'text': this.text,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.interactions object\n * @extends BaseCMI\n */\nclass CMIInteractions extends CMIArray {\n  /**\n   * Constructor for cmi.interactions\n   */\n  constructor() {\n    super({\n      children: scorm12_constants.interactions_children,\n      errorCode: scorm12_error_codes.INVALID_SET_VALUE,\n      errorClass: Scorm12ValidationError,\n    });\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.interactions.n object\n * @extends BaseCMI\n */\nexport class CMIInteractionsObject extends BaseCMI {\n  /**\n   * Constructor for cmi.interactions.n object\n   */\n  constructor() {\n    super();\n\n    this.objectives = new CMIArray({\n      errorCode: scorm12_error_codes.INVALID_SET_VALUE,\n      errorClass: Scorm12ValidationError,\n      children: scorm12_constants.objectives_children,\n    });\n    this.correct_responses = new CMIArray({\n      errorCode: scorm12_error_codes.INVALID_SET_VALUE,\n      errorClass: Scorm12ValidationError,\n      children: scorm12_constants.correct_responses_children,\n    });\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.objectives?.initialize();\n    this.correct_responses?.initialize();\n  }\n\n  #id = '';\n  #time = '';\n  #type = '';\n  #weighting = '';\n  #student_response = '';\n  #result = '';\n  #latency = '';\n\n  /**\n   * Getter for #id. Should only be called during JSON export.\n   * @return {*}\n   */\n  get id() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#id;\n  }\n\n  /**\n   * Setter for #id\n   * @param {string} id\n   */\n  set id(id) {\n    if (check12ValidFormat(id, scorm12_regex.CMIIdentifier)) {\n      this.#id = id;\n    }\n  }\n\n  /**\n   * Getter for #time. Should only be called during JSON export.\n   * @return {*}\n   */\n  get time() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#time;\n  }\n\n  /**\n   * Setter for #time\n   * @param {string} time\n   */\n  set time(time) {\n    if (check12ValidFormat(time, scorm12_regex.CMITime)) {\n      this.#time = time;\n    }\n  }\n\n  /**\n   * Getter for #type. Should only be called during JSON export.\n   * @return {*}\n   */\n  get type() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#type;\n  }\n\n  /**\n   * Setter for #type\n   * @param {string} type\n   */\n  set type(type) {\n    if (check12ValidFormat(type, scorm12_regex.CMIType)) {\n      this.#type = type;\n    }\n  }\n\n  /**\n   * Getter for #weighting. Should only be called during JSON export.\n   * @return {*}\n   */\n  get weighting() {\n    return (!this.jsonString) ?\n        throwWriteOnlyError() :\n        this.#weighting;\n  }\n\n  /**\n   * Setter for #weighting\n   * @param {string} weighting\n   */\n  set weighting(weighting) {\n    if (check12ValidFormat(weighting, scorm12_regex.CMIDecimal) &&\n        check12ValidRange(weighting, scorm12_regex.weighting_range)) {\n      this.#weighting = weighting;\n    }\n  }\n\n  /**\n   * Getter for #student_response. Should only be called during JSON export.\n   * @return {*}\n   */\n  get student_response() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#student_response;\n  }\n\n  /**\n   * Setter for #student_response\n   * @param {string} student_response\n   */\n  set student_response(student_response) {\n    if (check12ValidFormat(student_response, scorm12_regex.CMIFeedback, true)) {\n      this.#student_response = student_response;\n    }\n  }\n\n  /**\n   * Getter for #result. Should only be called during JSON export.\n   * @return {*}\n   */\n  get result() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#result;\n  }\n\n  /**\n   * Setter for #result\n   * @param {string} result\n   */\n  set result(result) {\n    if (check12ValidFormat(result, scorm12_regex.CMIResult)) {\n      this.#result = result;\n    }\n  }\n\n  /**\n   * Getter for #latency. Should only be called during JSON export.\n   * @return {*}\n   */\n  get latency() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#latency;\n  }\n\n  /**\n   * Setter for #latency\n   * @param {string} latency\n   */\n  set latency(latency) {\n    if (check12ValidFormat(latency, scorm12_regex.CMITimespan)) {\n      this.#latency = latency;\n    }\n  }\n\n  /**\n   * toJSON for cmi.interactions.n\n   *\n   * @return {\n   *    {\n   *      id: string,\n   *      time: string,\n   *      type: string,\n   *      weighting: string,\n   *      student_response: string,\n   *      result: string,\n   *      latency: string,\n   *      objectives: CMIArray,\n   *      correct_responses: CMIArray\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'id': this.id,\n      'time': this.time,\n      'type': this.type,\n      'weighting': this.weighting,\n      'student_response': this.student_response,\n      'result': this.result,\n      'latency': this.latency,\n      'objectives': this.objectives,\n      'correct_responses': this.correct_responses,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.objectives.n object\n * @extends BaseCMI\n */\nexport class CMIObjectivesObject extends BaseCMI {\n  /**\n   * Constructor for cmi.objectives.n\n   */\n  constructor() {\n    super();\n\n    this.score = new CMIScore(\n        {\n          score_children: scorm12_constants.score_children,\n          score_range: scorm12_regex.score_range,\n          invalidErrorCode: scorm12_error_codes.INVALID_SET_VALUE,\n          invalidTypeCode: scorm12_error_codes.TYPE_MISMATCH,\n          invalidRangeCode: scorm12_error_codes.VALUE_OUT_OF_RANGE,\n          errorClass: Scorm12ValidationError,\n        });\n  }\n\n  #id = '';\n  #status = '';\n\n  /**\n   * Getter for #id\n   * @return {\"\"}\n   */\n  get id() {\n    return this.#id;\n  }\n\n  /**\n   * Setter for #id\n   * @param {string} id\n   */\n  set id(id) {\n    if (check12ValidFormat(id, scorm12_regex.CMIIdentifier)) {\n      this.#id = id;\n    }\n  }\n\n  /**\n   * Getter for #status\n   * @return {\"\"}\n   */\n  get status() {\n    return this.#status;\n  }\n\n  /**\n   * Setter for #status\n   * @param {string} status\n   */\n  set status(status) {\n    if (check12ValidFormat(status, scorm12_regex.CMIStatus2)) {\n      this.#status = status;\n    }\n  }\n\n  /**\n   * toJSON for cmi.objectives.n\n   * @return {\n   *    {\n   *      id: string,\n   *      status: string,\n   *      score: CMIScore\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'id': this.id,\n      'status': this.status,\n      'score': this.score,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.interactions.n.objectives.n object\n * @extends BaseCMI\n */\nexport class CMIInteractionsObjectivesObject extends BaseCMI {\n  /**\n   * Constructor for cmi.interactions.n.objectives.n\n   */\n  constructor() {\n    super();\n  }\n\n  #id = '';\n\n  /**\n   * Getter for #id\n   * @return {\"\"}\n   */\n  get id() {\n    return this.#id;\n  }\n\n  /**\n   * Setter for #id\n   * @param {string} id\n   */\n  set id(id) {\n    if (check12ValidFormat(id, scorm12_regex.CMIIdentifier)) {\n      this.#id = id;\n    }\n  }\n\n  /**\n   * toJSON for cmi.interactions.n.objectives.n\n   * @return {\n   *    {\n   *      id: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'id': this.id,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.interactions.correct_responses.n object\n * @extends BaseCMI\n */\nexport class CMIInteractionsCorrectResponsesObject extends BaseCMI {\n  /**\n   * Constructor for cmi.interactions.correct_responses.n\n   */\n  constructor() {\n    super();\n  }\n\n  #pattern = '';\n\n  /**\n   * Getter for #pattern\n   * @return {string}\n   */\n  get pattern() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#pattern;\n  }\n\n  /**\n   * Setter for #pattern\n   * @param {string} pattern\n   */\n  set pattern(pattern) {\n    if (check12ValidFormat(pattern, scorm12_regex.CMIFeedback, true)) {\n      this.#pattern = pattern;\n    }\n  }\n\n  /**\n   * toJSON for cmi.interactions.correct_responses.n\n   * @return {\n   *    {\n   *      pattern: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'pattern': this.pattern,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class for AICC Navigation object\n */\nexport class NAV extends BaseCMI {\n  /**\n   * Constructor for NAV object\n   */\n  constructor() {\n    super();\n  }\n\n  #event = '';\n\n  /**\n   * Getter for #event\n   * @return {string}\n   */\n  get event() {\n    return this.#event;\n  }\n\n  /**\n   * Setter for #event\n   * @param {string} event\n   */\n  set event(event) {\n    if (check12ValidFormat(event, scorm12_regex.NAVEvent)) {\n      this.#event = event;\n    }\n  }\n\n  /**\n   * toJSON for nav object\n   * @return {\n   *    {\n   *      event: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'event': this.event,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n","// @flow\n\nconst global = {\n  SCORM_TRUE: 'true',\n  SCORM_FALSE: 'false',\n  STATE_NOT_INITIALIZED: 0,\n  STATE_INITIALIZED: 1,\n  STATE_TERMINATED: 2,\n  LOG_LEVEL_DEBUG: 1,\n  LOG_LEVEL_INFO: 2,\n  LOG_LEVEL_WARNING: 3,\n  LOG_LEVEL_ERROR: 4,\n  LOG_LEVEL_NONE: 5,\n};\n\nconst scorm12 = {\n  // Children lists\n  cmi_children: 'core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions',\n  core_children: 'student_id,student_name,lesson_location,credit,lesson_status,entry,score,total_time,lesson_mode,exit,session_time',\n  score_children: 'raw,min,max',\n  comments_children: 'content,location,time',\n  objectives_children: 'id,score,status',\n  correct_responses_children: 'pattern',\n  student_data_children: 'mastery_score,max_time_allowed,time_limit_action',\n  student_preference_children: 'audio,language,speed,text',\n  interactions_children: 'id,objectives,time,type,correct_responses,weighting,student_response,result,latency',\n\n  error_descriptions: {\n    '101': {\n      basicMessage: 'General Exception',\n      detailMessage: 'No specific error code exists to describe the error. Use LMSGetDiagnostic for more information',\n    },\n    '201': {\n      basicMessage: 'Invalid argument error',\n      detailMessage: 'Indicates that an argument represents an invalid data model element or is otherwise incorrect.',\n    },\n    '202': {\n      basicMessage: 'Element cannot have children',\n      detailMessage: 'Indicates that LMSGetValue was called with a data model element name that ends in \"_children\" for a data model element that does not support the \"_children\" suffix.',\n    },\n    '203': {\n      basicMessage: 'Element not an array - cannot have count',\n      detailMessage: 'Indicates that LMSGetValue was called with a data model element name that ends in \"_count\" for a data model element that does not support the \"_count\" suffix.',\n    },\n    '301': {\n      basicMessage: 'Not initialized',\n      detailMessage: 'Indicates that an API call was made before the call to lmsInitialize.',\n    },\n    '401': {\n      basicMessage: 'Not implemented error',\n      detailMessage: 'The data model element indicated in a call to LMSGetValue or LMSSetValue is valid, but was not implemented by this LMS. SCORM 1.2 defines a set of data model elements as being optional for an LMS to implement.',\n    },\n    '402': {\n      basicMessage: 'Invalid set value, element is a keyword',\n      detailMessage: 'Indicates that LMSSetValue was called on a data model element that represents a keyword (elements that end in \"_children\" and \"_count\").',\n    },\n    '403': {\n      basicMessage: 'Element is read only',\n      detailMessage: 'LMSSetValue was called with a data model element that can only be read.',\n    },\n    '404': {\n      basicMessage: 'Element is write only',\n      detailMessage: 'LMSGetValue was called on a data model element that can only be written to.',\n    },\n    '405': {\n      basicMessage: 'Incorrect Data Type',\n      detailMessage: 'LMSSetValue was called with a value that is not consistent with the data format of the supplied data model element.',\n    },\n    '407': {\n      basicMessage: 'Element Value Out Of Range',\n      detailMessage: 'The numeric value supplied to a LMSSetValue call is outside of the numeric range allowed for the supplied data model element.',\n    },\n    '408': {\n      basicMessage: 'Data Model Dependency Not Established',\n      detailMessage: 'Some data model elements cannot be set until another data model element was set. This error condition indicates that the prerequisite element was not set before the dependent element.',\n    },\n  },\n};\n\nconst aicc = {\n  ...scorm12, ...{\n    cmi_children: 'core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions,evaluation',\n    student_preference_children: 'audio,language,lesson_type,speed,text,text_color,text_location,text_size,video,windows',\n    student_data_children: 'attempt_number,tries,mastery_score,max_time_allowed,time_limit_action',\n    student_demographics_children: 'city,class,company,country,experience,familiar_name,instructor_name,title,native_language,state,street_address,telephone,years_experience',\n    tries_children: 'time,status,score',\n    attempt_records_children: 'score,lesson_status',\n    paths_children: 'location_id,date,time,status,why_left,time_in_element',\n  },\n};\n\nconst scorm2004 = {\n  // Children lists\n  cmi_children: '_version,comments_from_learner,comments_from_lms,completion_status,credit,entry,exit,interactions,launch_data,learner_id,learner_name,learner_preference,location,max_time_allowed,mode,objectives,progress_measure,scaled_passing_score,score,session_time,success_status,suspend_data,time_limit_action,total_time',\n  comments_children: 'comment,timestamp,location',\n  score_children: 'max,raw,scaled,min',\n  objectives_children: 'progress_measure,completion_status,success_status,description,score,id',\n  correct_responses_children: 'pattern',\n  student_data_children: 'mastery_score,max_time_allowed,time_limit_action',\n  student_preference_children: 'audio_level,audio_captioning,delivery_speed,language',\n  interactions_children: 'id,type,objectives,timestamp,correct_responses,weighting,learner_response,result,latency,description',\n\n  error_descriptions: {\n    '0': {\n      basicMessage: 'No Error',\n      detailMessage: 'No error occurred, the previous API call was successful.',\n    },\n    '101': {\n      basicMessage: 'General Exception',\n      detailMessage: 'No specific error code exists to describe the error. Use GetDiagnostic for more information.',\n    },\n    '102': {\n      basicMessage: 'General Initialization Failure',\n      detailMessage: 'Call to Initialize failed for an unknown reason.',\n    },\n    '103': {\n      basicMessage: 'Already Initialized',\n      detailMessage: 'Call to Initialize failed because Initialize was already called.',\n    },\n    '104': {\n      basicMessage: 'Content Instance Terminated',\n      detailMessage: 'Call to Initialize failed because Terminate was already called.',\n    },\n    '111': {\n      basicMessage: 'General Termination Failure',\n      detailMessage: 'Call to Terminate failed for an unknown reason.',\n    },\n    '112': {\n      basicMessage: 'Termination Before Initialization',\n      detailMessage: 'Call to Terminate failed because it was made before the call to Initialize.',\n    },\n    '113': {\n      basicMessage: 'Termination After Termination',\n      detailMessage: 'Call to Terminate failed because Terminate was already called.',\n    },\n    '122': {\n      basicMessage: 'Retrieve Data Before Initialization',\n      detailMessage: 'Call to GetValue failed because it was made before the call to Initialize.',\n    },\n    '123': {\n      basicMessage: 'Retrieve Data After Termination',\n      detailMessage: 'Call to GetValue failed because it was made after the call to Terminate.',\n    },\n    '132': {\n      basicMessage: 'Store Data Before Initialization',\n      detailMessage: 'Call to SetValue failed because it was made before the call to Initialize.',\n    },\n    '133': {\n      basicMessage: 'Store Data After Termination',\n      detailMessage: 'Call to SetValue failed because it was made after the call to Terminate.',\n    },\n    '142': {\n      basicMessage: 'Commit Before Initialization',\n      detailMessage: 'Call to Commit failed because it was made before the call to Initialize.',\n    },\n    '143': {\n      basicMessage: 'Commit After Termination',\n      detailMessage: 'Call to Commit failed because it was made after the call to Terminate.',\n    },\n    '201': {\n      basicMessage: 'General Argument Error',\n      detailMessage: 'An invalid argument was passed to an API method (usually indicates that Initialize, Commit or Terminate did not receive the expected empty string argument.',\n    },\n    '301': {\n      basicMessage: 'General Get Failure',\n      detailMessage: 'Indicates a failed GetValue call where no other specific error code is applicable. Use GetDiagnostic for more information.',\n    },\n    '351': {\n      basicMessage: 'General Set Failure',\n      detailMessage: 'Indicates a failed SetValue call where no other specific error code is applicable. Use GetDiagnostic for more information.',\n    },\n    '391': {\n      basicMessage: 'General Commit Failure',\n      detailMessage: 'Indicates a failed Commit call where no other specific error code is applicable. Use GetDiagnostic for more information.',\n    },\n    '401': {\n      basicMessage: 'Undefined Data Model Element',\n      detailMessage: 'The data model element name passed to GetValue or SetValue is not a valid SCORM data model element.',\n    },\n    '402': {\n      basicMessage: 'Unimplemented Data Model Element',\n      detailMessage: 'The data model element indicated in a call to GetValue or SetValue is valid, but was not implemented by this LMS. In SCORM 2004, this error would indicate an LMS that is not fully SCORM conformant.',\n    },\n    '403': {\n      basicMessage: 'Data Model Element Value Not Initialized',\n      detailMessage: 'Attempt to read a data model element that has not been initialized by the LMS or through a SetValue call. This error condition is often reached during normal execution of a SCO.',\n    },\n    '404': {\n      basicMessage: 'Data Model Element Is Read Only',\n      detailMessage: 'SetValue was called with a data model element that can only be read.',\n    },\n    '405': {\n      basicMessage: 'Data Model Element Is Write Only',\n      detailMessage: 'GetValue was called on a data model element that can only be written to.',\n    },\n    '406': {\n      basicMessage: 'Data Model Element Type Mismatch',\n      detailMessage: 'SetValue was called with a value that is not consistent with the data format of the supplied data model element.',\n    },\n    '407': {\n      basicMessage: 'Data Model Element Value Out Of Range',\n      detailMessage: 'The numeric value supplied to a SetValue call is outside of the numeric range allowed for the supplied data model element.',\n    },\n    '408': {\n      basicMessage: 'Data Model Dependency Not Established',\n      detailMessage: 'Some data model elements cannot be set until another data model element was set. This error condition indicates that the prerequisite element was not set before the dependent element.',\n    },\n  },\n};\n\nconst APIConstants = {\n  global: global,\n  scorm12: scorm12,\n  aicc: aicc,\n  scorm2004: scorm2004,\n};\n\nexport default APIConstants;\n","// @flow\nconst global = {\n  GENERAL: 101,\n  INITIALIZATION_FAILED: 101,\n  INITIALIZED: 101,\n  TERMINATED: 101,\n  TERMINATION_FAILURE: 101,\n  TERMINATION_BEFORE_INIT: 101,\n  MULTIPLE_TERMINATION: 101,\n  RETRIEVE_BEFORE_INIT: 101,\n  RETRIEVE_AFTER_TERM: 101,\n  STORE_BEFORE_INIT: 101,\n  STORE_AFTER_TERM: 101,\n  COMMIT_BEFORE_INIT: 101,\n  COMMIT_AFTER_TERM: 101,\n  ARGUMENT_ERROR: 101,\n  CHILDREN_ERROR: 101,\n  COUNT_ERROR: 101,\n  GENERAL_GET_FAILURE: 101,\n  GENERAL_SET_FAILURE: 101,\n  GENERAL_COMMIT_FAILURE: 101,\n  UNDEFINED_DATA_MODEL: 101,\n  UNIMPLEMENTED_ELEMENT: 101,\n  VALUE_NOT_INITIALIZED: 101,\n  INVALID_SET_VALUE: 101,\n  READ_ONLY_ELEMENT: 101,\n  WRITE_ONLY_ELEMENT: 101,\n  TYPE_MISMATCH: 101,\n  VALUE_OUT_OF_RANGE: 101,\n  DEPENDENCY_NOT_ESTABLISHED: 101,\n};\n\nconst scorm12 = {\n  ...global, ...{\n    RETRIEVE_BEFORE_INIT: 301,\n    STORE_BEFORE_INIT: 301,\n    COMMIT_BEFORE_INIT: 301,\n    ARGUMENT_ERROR: 201,\n    CHILDREN_ERROR: 202,\n    COUNT_ERROR: 203,\n    UNDEFINED_DATA_MODEL: 401,\n    UNIMPLEMENTED_ELEMENT: 401,\n    VALUE_NOT_INITIALIZED: 301,\n    INVALID_SET_VALUE: 402,\n    READ_ONLY_ELEMENT: 403,\n    WRITE_ONLY_ELEMENT: 404,\n    TYPE_MISMATCH: 405,\n    VALUE_OUT_OF_RANGE: 407,\n    DEPENDENCY_NOT_ESTABLISHED: 408,\n  },\n};\n\nconst scorm2004 = {\n  ...global, ...{\n    INITIALIZATION_FAILED: 102,\n    INITIALIZED: 103,\n    TERMINATED: 104,\n    TERMINATION_FAILURE: 111,\n    TERMINATION_BEFORE_INIT: 112,\n    MULTIPLE_TERMINATIONS: 113,\n    RETRIEVE_BEFORE_INIT: 122,\n    RETRIEVE_AFTER_TERM: 123,\n    STORE_BEFORE_INIT: 132,\n    STORE_AFTER_TERM: 133,\n    COMMIT_BEFORE_INIT: 142,\n    COMMIT_AFTER_TERM: 143,\n    ARGUMENT_ERROR: 201,\n    GENERAL_GET_FAILURE: 301,\n    GENERAL_SET_FAILURE: 351,\n    GENERAL_COMMIT_FAILURE: 391,\n    UNDEFINED_DATA_MODEL: 401,\n    UNIMPLEMENTED_ELEMENT: 402,\n    VALUE_NOT_INITIALIZED: 403,\n    READ_ONLY_ELEMENT: 404,\n    WRITE_ONLY_ELEMENT: 405,\n    TYPE_MISMATCH: 406,\n    VALUE_OUT_OF_RANGE: 407,\n    DEPENDENCY_NOT_ESTABLISHED: 408,\n  },\n};\n\nconst ErrorCodes = {\n  scorm12: scorm12,\n  scorm2004: scorm2004,\n};\n\nexport default ErrorCodes;\n","// @flow\n\nconst scorm12 = {\n  CMIString256: '^.{0,255}$',\n  CMIString4096: '^.{0,4096}$',\n  CMITime: '^(?:[01]\\\\d|2[0123]):(?:[012345]\\\\d):(?:[012345]\\\\d)$', // eslint-disable-line\n  CMITimespan: '^([0-9]{2,}):([0-9]{2}):([0-9]{2})(\\.[0-9]{1,2})?$', // eslint-disable-line\n  CMIInteger: '^\\\\d+$',\n  CMISInteger: '^-?([0-9]+)$',\n  CMIDecimal: '^-?([0-9]{0,3})(\\.[0-9]*)?$', // eslint-disable-line\n  CMIIdentifier: '^[\\\\u0021-\\\\u007E\\\\s]{0,255}$',\n  CMIFeedback: '^.{0,255}$', // This must be redefined\n  CMIIndex: '[._](\\\\d+).',\n\n  // Vocabulary Data Type Definition\n  CMIStatus: '^(passed|completed|failed|incomplete|browsed)$',\n  CMIStatus2: '^(passed|completed|failed|incomplete|browsed|not attempted)$',\n  CMIExit: '^(time-out|suspend|logout|)$',\n  CMIType: '^(true-false|choice|fill-in|matching|performance|sequencing|likert|numeric)$',\n  CMIResult: '^(correct|wrong|unanticipated|neutral|([0-9]{0,3})?(\\\\.[0-9]*)?)$', // eslint-disable-line\n  NAVEvent: '^(previous|continue)$',\n\n  // Data ranges\n  score_range: '0#100',\n  audio_range: '-1#100',\n  speed_range: '-100#100',\n  weighting_range: '-100#100',\n  text_range: '-1#1',\n};\n\nconst aicc = {\n  ...scorm12, ...{\n    CMIIdentifier: '^\\\\w{1,255}$',\n  },\n};\n\nconst scorm2004 = {\n  CMIString200: '^[\\\\u0000-\\\\uFFFF]{0,200}$',\n  CMIString250: '^[\\\\u0000-\\\\uFFFF]{0,250}$',\n  CMIString1000: '^[\\\\u0000-\\\\uFFFF]{0,1000}$',\n  CMIString4000: '^[\\\\u0000-\\\\uFFFF]{0,4000}$',\n  CMIString64000: '^[\\\\u0000-\\\\uFFFF]{0,64000}$',\n  CMILang: '^([a-zA-Z]{2,3}|i|x)(\\-[a-zA-Z0-9\\-]{2,8})?$|^$', // eslint-disable-line\n  CMILangString250: '^(\\{lang=([a-zA-Z]{2,3}|i|x)(\\-[a-zA-Z0-9\\-]{2,8})?\\})?((?!\\{.*$).{0,250}$)?$', // eslint-disable-line\n  CMILangcr: '^((\\{lang=([a-zA-Z]{2,3}|i|x)?(\\-[a-zA-Z0-9\\-]{2,8})?\\}))(.*?)$', // eslint-disable-line\n  CMILangString250cr: '^((\\{lang=([a-zA-Z]{2,3}|i|x)?(\\-[a-zA-Z0-9\\-]{2,8})?\\})?(.{0,250})?)?$', // eslint-disable-line\n  CMILangString4000: '^(\\{lang=([a-zA-Z]{2,3}|i|x)(\\-[a-zA-Z0-9\\-]{2,8})?\\})?((?!\\{.*$).{0,4000}$)?$', // eslint-disable-line\n  CMITime: '^(19[7-9]{1}[0-9]{1}|20[0-2]{1}[0-9]{1}|203[0-8]{1})((-(0[1-9]{1}|1[0-2]{1}))((-(0[1-9]{1}|[1-2]{1}[0-9]{1}|3[0-1]{1}))(T([0-1]{1}[0-9]{1}|2[0-3]{1})((:[0-5]{1}[0-9]{1})((:[0-5]{1}[0-9]{1})((\\\\.[0-9]{1,2})((Z|([+|-]([0-1]{1}[0-9]{1}|2[0-3]{1})))(:[0-5]{1}[0-9]{1})?)?)?)?)?)?)?)?$',\n  CMITimespan: '^P(?:([.,\\\\d]+)Y)?(?:([.,\\\\d]+)M)?(?:([.,\\\\d]+)W)?(?:([.,\\\\d]+)D)?(?:T?(?:([.,\\\\d]+)H)?(?:([.,\\\\d]+)M)?(?:([.,\\\\d]+)S)?)?$',\n  CMIInteger: '^\\\\d+$',\n  CMISInteger: '^-?([0-9]+)$',\n  CMIDecimal: '^-?([0-9]{1,5})(\\\\.[0-9]{1,18})?$',\n  CMIIdentifier: '^\\\\S{1,250}[a-zA-Z0-9]$',\n  CMIShortIdentifier: '^[\\\\w\\\\.\\\\-\\\\_]{1,250}$', // eslint-disable-line\n  CMILongIdentifier: '^(?:(?!urn:)\\\\S{1,4000}|urn:[A-Za-z0-9-]{1,31}:\\\\S{1,4000}|.{1,4000})$', // need to re-examine this\n  CMIFeedback: '^.*$', // This must be redefined\n  CMIIndex: '[._](\\\\d+).',\n  CMIIndexStore: '.N(\\\\d+).',\n\n  // Vocabulary Data Type Definition\n  CMICStatus: '^(completed|incomplete|not attempted|unknown)$',\n  CMISStatus: '^(passed|failed|unknown)$',\n  CMIExit: '^(time-out|suspend|logout|normal)$',\n  CMIType: '^(true-false|choice|fill-in|long-fill-in|matching|performance|sequencing|likert|numeric|other)$',\n  CMIResult: '^(correct|incorrect|unanticipated|neutral|-?([0-9]{1,4})(\\\\.[0-9]{1,18})?)$',\n  NAVEvent: '^(previous|continue|exit|exitAll|abandon|abandonAll|suspendAll|\\{target=\\\\S{0,200}[a-zA-Z0-9]\\}choice|jump)$', // eslint-disable-line\n  NAVBoolean: '^(unknown|true|false$)',\n  NAVTarget: '^(previous|continue|choice.{target=\\\\S{0,200}[a-zA-Z0-9]})$',\n\n  // Data ranges\n  scaled_range: '-1#1',\n  audio_range: '0#*',\n  speed_range: '0#*',\n  text_range: '-1#1',\n  progress_range: '0#1',\n};\n\nconst Regex = {\n  aicc: aicc,\n  scorm12: scorm12,\n  scorm2004: scorm2004,\n};\n\nexport default Regex;\n","// @flow\n\nimport APIConstants from './constants/api_constants';\n\nconst scorm12_errors = APIConstants.scorm12.error_descriptions;\nconst aicc_errors = APIConstants.aicc.error_descriptions;\nconst scorm2004_errors = APIConstants.scorm2004.error_descriptions;\n\n/**\n * Base Validation Exception\n */\nexport class ValidationError extends Error {\n  /**\n   * Constructor to take in an error message and code\n   * @param {number} errorCode\n   * @param {string} errorMessage\n   * @param {string} detailedMessage\n   */\n  constructor(errorCode: number, errorMessage: String, detailedMessage: String) {\n    super(errorMessage);\n    this.#errorCode = errorCode;\n    this.#errorMessage = errorMessage;\n    this.#detailedMessage = detailedMessage;\n  }\n\n  #errorCode;\n  #errorMessage;\n  #detailedMessage;\n\n  /**\n   * Getter for #errorCode\n   * @return {number}\n   */\n  get errorCode() {\n    return this.#errorCode;\n  }\n\n  /**\n   * Getter for #errorMessage\n   * @return {string}\n   */\n  get errorMessage() {\n    return this.#errorMessage;\n  }\n\n  /**\n   * Getter for #detailedMessage\n   * @return {string}\n   */\n  get detailedMessage() {\n    return this.#detailedMessage;\n  }\n}\n\n/**\n * SCORM 1.2 Validation Error\n */\nexport class Scorm12ValidationError extends ValidationError {\n  /**\n   * Constructor to take in an error code\n   * @param {number} errorCode\n   */\n  constructor(errorCode: number) {\n    if ({}.hasOwnProperty.call(scorm12_errors, String(errorCode))) {\n      super(errorCode, scorm12_errors[String(errorCode)].basicMessage, scorm12_errors[String(errorCode)].detailMessage);\n    } else {\n      super(101, scorm12_errors['101'].basicMessage, scorm12_errors['101'].detailMessage);\n    }\n  }\n}\n\n/**\n * AICC Validation Error\n */\nexport class AICCValidationError extends ValidationError {\n  /**\n   * Constructor to take in an error code\n   * @param {number} errorCode\n   */\n  constructor(errorCode: number) {\n    if ({}.hasOwnProperty.call(aicc_errors, String(errorCode))) {\n      super(errorCode, aicc_errors[String(errorCode)].basicMessage, aicc_errors[String(errorCode)].detailMessage);\n    } else {\n      super(101, aicc_errors['101'].basicMessage, aicc_errors['101'].detailMessage);\n    }\n  }\n}\n\n/**\n * SCORM 2004 Validation Error\n */\nexport class Scorm2004ValidationError extends ValidationError {\n  /**\n   * Constructor to take in an error code\n   * @param {number} errorCode\n   */\n  constructor(errorCode: number) {\n    if ({}.hasOwnProperty.call(scorm2004_errors, String(errorCode))) {\n      super(errorCode, scorm2004_errors[String(errorCode)].basicMessage, scorm2004_errors[String(errorCode)].detailMessage);\n    } else {\n      super(101, scorm2004_errors['101'].basicMessage, scorm2004_errors['101'].detailMessage);\n    }\n  }\n}\n","import Scorm12API from '../Scorm12API';\n\nwindow.Scorm12API = Scorm12API;\n","// @flow\nexport const SECONDS_PER_SECOND = 1.0;\nexport const SECONDS_PER_MINUTE = 60;\nexport const SECONDS_PER_HOUR = 60 * SECONDS_PER_MINUTE;\nexport const SECONDS_PER_DAY = 24 * SECONDS_PER_HOUR;\n\nconst designations = [\n  ['D', SECONDS_PER_DAY],\n  ['H', SECONDS_PER_HOUR],\n  ['M', SECONDS_PER_MINUTE],\n  ['S', SECONDS_PER_SECOND],\n];\n\n/**\n * Converts a Number to a String of HH:MM:SS\n *\n * @param {Number} totalSeconds\n * @return {string}\n */\nexport function getSecondsAsHHMMSS(totalSeconds: Number) {\n  // SCORM spec does not deal with negative durations, give zero back\n  if (!totalSeconds || totalSeconds <= 0) {\n    return '00:00:00';\n  }\n\n  const hours = Math.floor(totalSeconds / SECONDS_PER_HOUR);\n\n  const dateObj = new Date(totalSeconds * 1000);\n  const minutes = dateObj.getUTCMinutes();\n  // make sure we add any possible decimal value\n  const seconds = dateObj.getSeconds();\n  const ms = totalSeconds % 1.0;\n  let msStr = '';\n  if (countDecimals(ms) > 0) {\n    if (countDecimals(ms) > 2) {\n      msStr = ms.toFixed(2);\n    } else {\n      msStr = String(ms);\n    }\n    msStr = '.' + msStr.split('.')[1];\n  }\n\n  return (hours + ':' + minutes + ':' + seconds).replace(/\\b\\d\\b/g,\n      '0$&') + msStr;\n}\n\n/**\n * Calculate the number of seconds from ISO 8601 Duration\n *\n * @param {Number} seconds\n * @return {String}\n */\nexport function getSecondsAsISODuration(seconds: Number) {\n  // SCORM spec does not deal with negative durations, give zero back\n  if (!seconds || seconds <= 0) {\n    return 'PT0S';\n  }\n\n  let duration = 'P';\n  let remainder = seconds;\n\n  designations.forEach(([sign, current_seconds]) => {\n    let value = Math.floor(remainder / current_seconds);\n\n    remainder = remainder % current_seconds;\n    if (countDecimals(remainder) > 2) {\n      remainder = Number(Number(remainder).toFixed(2));\n    }\n    // If we have anything left in the remainder, and we're currently adding\n    // seconds to the duration, go ahead and add the decimal to the seconds\n    if (sign === 'S' && remainder > 0) {\n      value += remainder;\n    }\n\n    if (value) {\n      if ((duration.indexOf('D') > 0 ||\n          sign === 'H' || sign === 'M' || sign === 'S') &&\n          duration.indexOf('T') === -1) {\n        duration += 'T';\n      }\n      duration += `${value}${sign}`;\n    }\n  });\n\n  return duration;\n}\n\n/**\n * Calculate the number of seconds from HH:MM:SS.DDDDDD\n *\n * @param {string} timeString\n * @param {RegExp} timeRegex\n * @return {number}\n */\nexport function getTimeAsSeconds(timeString: String, timeRegex: RegExp) {\n  if (!timeString || typeof timeString !== 'string' ||\n      !timeString.match(timeRegex)) {\n    return 0;\n  }\n  const parts = timeString.split(':');\n  const hours = Number(parts[0]);\n  const minutes = Number(parts[1]);\n  const seconds = Number(parts[2]);\n  return (hours * 3600) + (minutes * 60) + seconds;\n}\n\n/**\n * Calculate the number of seconds from ISO 8601 Duration\n *\n * @param {string} duration\n * @param {RegExp} durationRegex\n * @return {number}\n */\nexport function getDurationAsSeconds(duration: String, durationRegex: RegExp) {\n  if (!duration || !duration.match(durationRegex)) {\n    return 0;\n  }\n\n  const [, years, months, , days, hours, minutes, seconds] = new RegExp(\n      durationRegex).exec(duration) || [];\n\n  let result = 0.0;\n\n  result += (Number(seconds) * 1.0 || 0.0);\n  result += (Number(minutes) * 60.0 || 0.0);\n  result += (Number(hours) * 3600.0 || 0.0);\n  result += (Number(days) * (60 * 60 * 24.0) || 0.0);\n  result += (Number(years) * (60 * 60 * 24 * 365.0) || 0.0);\n\n  return result;\n}\n\n/**\n * Adds together two ISO8601 Duration strings\n *\n * @param {string} first\n * @param {string} second\n * @param {RegExp} durationRegex\n * @return {string}\n */\nexport function addTwoDurations(\n    first: String,\n    second: String,\n    durationRegex: RegExp) {\n  return getSecondsAsISODuration(\n      getDurationAsSeconds(first, durationRegex) +\n      getDurationAsSeconds(second, durationRegex),\n  );\n}\n\n/**\n * Add together two HH:MM:SS.DD strings\n *\n * @param {string} first\n * @param {string} second\n * @param {RegExp} timeRegex\n * @return {string}\n */\nexport function addHHMMSSTimeStrings(\n    first: String,\n    second: String,\n    timeRegex: RegExp) {\n  return getSecondsAsHHMMSS(\n      getTimeAsSeconds(first, timeRegex) +\n      getTimeAsSeconds(\n          second, timeRegex),\n  );\n}\n\n/**\n * Flatten a JSON object down to string paths for each values\n * @param {object} data\n * @return {object}\n */\nexport function flatten(data) {\n  const result = {};\n\n  /**\n   * Recurse through the object\n   * @param {*} cur\n   * @param {*} prop\n   */\n  function recurse(cur, prop) {\n    if (Object(cur) !== cur) {\n      result[prop] = cur;\n    } else if (Array.isArray(cur)) {\n      for (let i = 0, l = cur.length; i < l; i++) {\n        recurse(cur[i], prop + '[' + i + ']');\n        if (l === 0) result[prop] = [];\n      }\n    } else {\n      let isEmpty = true;\n      for (const p in cur) {\n        if ({}.hasOwnProperty.call(cur, p)) {\n          isEmpty = false;\n          recurse(cur[p], prop ? prop + '.' + p : p);\n        }\n      }\n      if (isEmpty && prop) result[prop] = {};\n    }\n  }\n\n  recurse(data, '');\n  return result;\n}\n\n/**\n * Un-flatten a flat JSON object\n * @param {object} data\n * @return {object}\n */\nexport function unflatten(data) {\n  'use strict';\n  if (Object(data) !== data || Array.isArray(data)) return data;\n  const regex = /\\.?([^.[\\]]+)|\\[(\\d+)]/g;\n  const result = {};\n  for (const p in data) {\n    if ({}.hasOwnProperty.call(data, p)) {\n      let cur = result;\n      let prop = '';\n      let m = regex.exec(p);\n      while (m) {\n        cur = cur[prop] || (cur[prop] = (m[2] ? [] : {}));\n        prop = m[2] || m[1];\n        m = regex.exec(p);\n      }\n      cur[prop] = data[p];\n    }\n  }\n  return result[''] || result;\n}\n\n/**\n * Counts the number of decimal places\n * @param {number} num\n * @return {number}\n */\nexport function countDecimals(num: number) {\n  if (Math.floor(num) === num || String(num).indexOf('.') < 0) return 0;\n  const parts = num.toString().split('.')[1];\n  return parts.length || 0;\n}\n"]} diff --git a/dist/scorm12.min.js b/dist/scorm12.min.js new file mode 100644 index 0000000..2af111d --- /dev/null +++ b/dist/scorm12.min.js @@ -0,0 +1,5500 @@ +(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i + * Build: `lodash modularize exports="npm" -o ./` + * Copyright jQuery Foundation and other contributors + * Released under MIT license + * Based on Underscore.js 1.8.3 + * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + */ + +/** Used as the `TypeError` message for "Functions" methods. */ +var FUNC_ERROR_TEXT = 'Expected a function'; + +/** Used as references for various `Number` constants. */ +var NAN = 0 / 0; + +/** `Object#toString` result references. */ +var symbolTag = '[object Symbol]'; + +/** Used to match leading and trailing whitespace. */ +var reTrim = /^\s+|\s+$/g; + +/** Used to detect bad signed hexadecimal string values. */ +var reIsBadHex = /^[-+]0x[0-9a-f]+$/i; + +/** Used to detect binary string values. */ +var reIsBinary = /^0b[01]+$/i; + +/** Used to detect octal string values. */ +var reIsOctal = /^0o[0-7]+$/i; + +/** Built-in method references without a dependency on `root`. */ +var freeParseInt = parseInt; + +/** Detect free variable `global` from Node.js. */ +var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; + +/** Detect free variable `self`. */ +var freeSelf = typeof self == 'object' && self && self.Object === Object && self; + +/** Used as a reference to the global object. */ +var root = freeGlobal || freeSelf || Function('return this')(); + +/** Used for built-in method references. */ +var objectProto = Object.prototype; + +/** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ +var objectToString = objectProto.toString; + +/* Built-in method references for those with the same name as other `lodash` methods. */ +var nativeMax = Math.max, + nativeMin = Math.min; + +/** + * Gets the timestamp of the number of milliseconds that have elapsed since + * the Unix epoch (1 January 1970 00:00:00 UTC). + * + * @static + * @memberOf _ + * @since 2.4.0 + * @category Date + * @returns {number} Returns the timestamp. + * @example + * + * _.defer(function(stamp) { + * console.log(_.now() - stamp); + * }, _.now()); + * // => Logs the number of milliseconds it took for the deferred invocation. + */ +var now = function() { + return root.Date.now(); +}; + +/** + * Creates a debounced function that delays invoking `func` until after `wait` + * milliseconds have elapsed since the last time the debounced function was + * invoked. The debounced function comes with a `cancel` method to cancel + * delayed `func` invocations and a `flush` method to immediately invoke them. + * Provide `options` to indicate whether `func` should be invoked on the + * leading and/or trailing edge of the `wait` timeout. The `func` is invoked + * with the last arguments provided to the debounced function. Subsequent + * calls to the debounced function return the result of the last `func` + * invocation. + * + * **Note:** If `leading` and `trailing` options are `true`, `func` is + * invoked on the trailing edge of the timeout only if the debounced function + * is invoked more than once during the `wait` timeout. + * + * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred + * until to the next tick, similar to `setTimeout` with a timeout of `0`. + * + * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) + * for details over the differences between `_.debounce` and `_.throttle`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to debounce. + * @param {number} [wait=0] The number of milliseconds to delay. + * @param {Object} [options={}] The options object. + * @param {boolean} [options.leading=false] + * Specify invoking on the leading edge of the timeout. + * @param {number} [options.maxWait] + * The maximum time `func` is allowed to be delayed before it's invoked. + * @param {boolean} [options.trailing=true] + * Specify invoking on the trailing edge of the timeout. + * @returns {Function} Returns the new debounced function. + * @example + * + * // Avoid costly calculations while the window size is in flux. + * jQuery(window).on('resize', _.debounce(calculateLayout, 150)); + * + * // Invoke `sendMail` when clicked, debouncing subsequent calls. + * jQuery(element).on('click', _.debounce(sendMail, 300, { + * 'leading': true, + * 'trailing': false + * })); + * + * // Ensure `batchLog` is invoked once after 1 second of debounced calls. + * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 }); + * var source = new EventSource('/stream'); + * jQuery(source).on('message', debounced); + * + * // Cancel the trailing debounced invocation. + * jQuery(window).on('popstate', debounced.cancel); + */ +function debounce(func, wait, options) { + var lastArgs, + lastThis, + maxWait, + result, + timerId, + lastCallTime, + lastInvokeTime = 0, + leading = false, + maxing = false, + trailing = true; + + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + wait = toNumber(wait) || 0; + if (isObject(options)) { + leading = !!options.leading; + maxing = 'maxWait' in options; + maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait; + trailing = 'trailing' in options ? !!options.trailing : trailing; + } + + function invokeFunc(time) { + var args = lastArgs, + thisArg = lastThis; + + lastArgs = lastThis = undefined; + lastInvokeTime = time; + result = func.apply(thisArg, args); + return result; + } + + function leadingEdge(time) { + // Reset any `maxWait` timer. + lastInvokeTime = time; + // Start the timer for the trailing edge. + timerId = setTimeout(timerExpired, wait); + // Invoke the leading edge. + return leading ? invokeFunc(time) : result; + } + + function remainingWait(time) { + var timeSinceLastCall = time - lastCallTime, + timeSinceLastInvoke = time - lastInvokeTime, + result = wait - timeSinceLastCall; + + return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result; + } + + function shouldInvoke(time) { + var timeSinceLastCall = time - lastCallTime, + timeSinceLastInvoke = time - lastInvokeTime; + + // Either this is the first call, activity has stopped and we're at the + // trailing edge, the system time has gone backwards and we're treating + // it as the trailing edge, or we've hit the `maxWait` limit. + return (lastCallTime === undefined || (timeSinceLastCall >= wait) || + (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait)); + } + + function timerExpired() { + var time = now(); + if (shouldInvoke(time)) { + return trailingEdge(time); + } + // Restart the timer. + timerId = setTimeout(timerExpired, remainingWait(time)); + } + + function trailingEdge(time) { + timerId = undefined; + + // Only invoke if we have `lastArgs` which means `func` has been + // debounced at least once. + if (trailing && lastArgs) { + return invokeFunc(time); + } + lastArgs = lastThis = undefined; + return result; + } + + function cancel() { + if (timerId !== undefined) { + clearTimeout(timerId); + } + lastInvokeTime = 0; + lastArgs = lastCallTime = lastThis = timerId = undefined; + } + + function flush() { + return timerId === undefined ? result : trailingEdge(now()); + } + + function debounced() { + var time = now(), + isInvoking = shouldInvoke(time); + + lastArgs = arguments; + lastThis = this; + lastCallTime = time; + + if (isInvoking) { + if (timerId === undefined) { + return leadingEdge(lastCallTime); + } + if (maxing) { + // Handle invocations in a tight loop. + timerId = setTimeout(timerExpired, wait); + return invokeFunc(lastCallTime); + } + } + if (timerId === undefined) { + timerId = setTimeout(timerExpired, wait); + } + return result; + } + debounced.cancel = cancel; + debounced.flush = flush; + return debounced; +} + +/** + * Checks if `value` is the + * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) + * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an object, else `false`. + * @example + * + * _.isObject({}); + * // => true + * + * _.isObject([1, 2, 3]); + * // => true + * + * _.isObject(_.noop); + * // => true + * + * _.isObject(null); + * // => false + */ +function isObject(value) { + var type = typeof value; + return !!value && (type == 'object' || type == 'function'); +} + +/** + * Checks if `value` is object-like. A value is object-like if it's not `null` + * and has a `typeof` result of "object". + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is object-like, else `false`. + * @example + * + * _.isObjectLike({}); + * // => true + * + * _.isObjectLike([1, 2, 3]); + * // => true + * + * _.isObjectLike(_.noop); + * // => false + * + * _.isObjectLike(null); + * // => false + */ +function isObjectLike(value) { + return !!value && typeof value == 'object'; +} + +/** + * Checks if `value` is classified as a `Symbol` primitive or object. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. + * @example + * + * _.isSymbol(Symbol.iterator); + * // => true + * + * _.isSymbol('abc'); + * // => false + */ +function isSymbol(value) { + return typeof value == 'symbol' || + (isObjectLike(value) && objectToString.call(value) == symbolTag); +} + +/** + * Converts `value` to a number. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to process. + * @returns {number} Returns the number. + * @example + * + * _.toNumber(3.2); + * // => 3.2 + * + * _.toNumber(Number.MIN_VALUE); + * // => 5e-324 + * + * _.toNumber(Infinity); + * // => Infinity + * + * _.toNumber('3.2'); + * // => 3.2 + */ +function toNumber(value) { + if (typeof value == 'number') { + return value; + } + if (isSymbol(value)) { + return NAN; + } + if (isObject(value)) { + var other = typeof value.valueOf == 'function' ? value.valueOf() : value; + value = isObject(other) ? (other + '') : other; + } + if (typeof value != 'string') { + return value === 0 ? value : +value; + } + value = value.replace(reTrim, ''); + var isBinary = reIsBinary.test(value); + return (isBinary || reIsOctal.test(value)) + ? freeParseInt(value.slice(2), isBinary ? 2 : 8) + : (reIsBadHex.test(value) ? NAN : +value); +} + +module.exports = debounce; + +}).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +},{}],2:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +var _common = require("./cmi/common"); + +var _exceptions = require("./exceptions"); + +var _error_codes2 = _interopRequireDefault(require("./constants/error_codes")); + +var _api_constants = _interopRequireDefault(require("./constants/api_constants")); + +var _utilities = require("./utilities"); + +var _lodash = _interopRequireDefault(require("lodash.debounce")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); } + +function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } + +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit(arr, i) { var _i = arr && (typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]); if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); } + +function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; } + +function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); } + +function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } } + +var global_constants = _api_constants["default"].global; +var scorm12_error_codes = _error_codes2["default"].scorm12; +/** + * Base API class for AICC, SCORM 1.2, and SCORM 2004. Should be considered + * abstract, and never initialized on it's own. + */ + +var _timeout = new WeakMap(); + +var _error_codes = new WeakMap(); + +var _settings = new WeakMap(); + +var BaseAPI = /*#__PURE__*/function () { + /** + * Constructor for Base API class. Sets some shared API fields, as well as + * sets up options for the API. + * @param {object} error_codes + * @param {object} settings + */ + function BaseAPI(error_codes, settings) { + _classCallCheck(this, BaseAPI); + + _timeout.set(this, { + writable: true, + value: void 0 + }); + + _error_codes.set(this, { + writable: true, + value: void 0 + }); + + _settings.set(this, { + writable: true, + value: { + autocommit: false, + autocommitSeconds: 10, + asyncCommit: false, + sendBeaconCommit: false, + lmsCommitUrl: false, + dataCommitFormat: 'json', + // valid formats are 'json' or 'flattened', 'params' + commitRequestDataType: 'application/json;charset=UTF-8', + autoProgress: false, + logLevel: global_constants.LOG_LEVEL_ERROR, + selfReportSessionTime: false, + alwaysSendTotalTime: false, + strict_errors: true, + responseHandler: function responseHandler(xhr) { + var result; + + if (typeof xhr !== 'undefined') { + result = JSON.parse(xhr.responseText); + + if (result === null || !{}.hasOwnProperty.call(result, 'result')) { + result = {}; + + if (xhr.status === 200) { + result.result = global_constants.SCORM_TRUE; + result.errorCode = 0; + } else { + result.result = global_constants.SCORM_FALSE; + result.errorCode = 101; + } + } + } + + return result; + } + } + }); + + _defineProperty(this, "cmi", void 0); + + _defineProperty(this, "startingData", void 0); + + if ((this instanceof BaseAPI ? this.constructor : void 0) === BaseAPI) { + throw new TypeError('Cannot construct BaseAPI instances directly'); + } + + this.currentState = global_constants.STATE_NOT_INITIALIZED; + this.lastErrorCode = 0; + this.listenerArray = []; + + _classPrivateFieldSet(this, _timeout, null); + + _classPrivateFieldSet(this, _error_codes, error_codes); + + this.settings = settings; + this.apiLogLevel = this.settings.logLevel; + this.selfReportSessionTime = this.settings.selfReportSessionTime; + } + /** + * Initialize the API + * @param {string} callbackName + * @param {string} initializeMessage + * @param {string} terminationMessage + * @return {string} + */ + + + _createClass(BaseAPI, [{ + key: "initialize", + value: function initialize(callbackName, initializeMessage, terminationMessage) { + var returnValue = global_constants.SCORM_FALSE; + + if (this.isInitialized()) { + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).INITIALIZED, initializeMessage); + } else if (this.isTerminated()) { + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).TERMINATED, terminationMessage); + } else { + if (this.selfReportSessionTime) { + this.cmi.setStartTime(); + } + + this.currentState = global_constants.STATE_INITIALIZED; + this.lastErrorCode = 0; + returnValue = global_constants.SCORM_TRUE; + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Getter for #error_codes + * @return {object} + */ + + }, { + key: "error_codes", + get: function get() { + return _classPrivateFieldGet(this, _error_codes); + } + /** + * Getter for #settings + * @return {object} + */ + + }, { + key: "settings", + get: function get() { + return _classPrivateFieldGet(this, _settings); + } + /** + * Setter for #settings + * @param {object} settings + */ + , + set: function set(settings) { + _classPrivateFieldSet(this, _settings, _objectSpread(_objectSpread({}, _classPrivateFieldGet(this, _settings)), settings)); + } + /** + * Terminates the current run of the API + * @param {string} callbackName + * @param {boolean} checkTerminated + * @return {string} + */ + + }, { + key: "terminate", + value: function terminate(callbackName, checkTerminated) { + var returnValue = global_constants.SCORM_FALSE; + + if (this.checkState(checkTerminated, _classPrivateFieldGet(this, _error_codes).TERMINATION_BEFORE_INIT, _classPrivateFieldGet(this, _error_codes).MULTIPLE_TERMINATION)) { + this.currentState = global_constants.STATE_TERMINATED; + var result = this.storeData(true); + + if (!this.settings.sendBeaconCommit && !this.settings.asyncCommit && typeof result.errorCode !== 'undefined' && result.errorCode > 0) { + this.throwSCORMError(result.errorCode); + } + + returnValue = typeof result !== 'undefined' && result.result ? result.result : global_constants.SCORM_FALSE; + if (checkTerminated) this.lastErrorCode = 0; + returnValue = global_constants.SCORM_TRUE; + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Get the value of the CMIElement. + * + * @param {string} callbackName + * @param {boolean} checkTerminated + * @param {string} CMIElement + * @return {string} + */ + + }, { + key: "getValue", + value: function getValue(callbackName, checkTerminated, CMIElement) { + var returnValue; + + if (this.checkState(checkTerminated, _classPrivateFieldGet(this, _error_codes).RETRIEVE_BEFORE_INIT, _classPrivateFieldGet(this, _error_codes).RETRIEVE_AFTER_TERM)) { + if (checkTerminated) this.lastErrorCode = 0; + + try { + returnValue = this.getCMIValue(CMIElement); + } catch (e) { + if (e instanceof _exceptions.ValidationError) { + this.lastErrorCode = e.errorCode; + returnValue = global_constants.SCORM_FALSE; + } else { + if (e.message) { + console.error(e.message); + } else { + console.error(e); + } + + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).GENERAL); + } + } + + this.processListeners(callbackName, CMIElement); + } + + this.apiLog(callbackName, CMIElement, ': returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Sets the value of the CMIElement. + * + * @param {string} callbackName + * @param {string} commitCallback + * @param {boolean} checkTerminated + * @param {string} CMIElement + * @param {*} value + * @return {string} + */ + + }, { + key: "setValue", + value: function setValue(callbackName, commitCallback, checkTerminated, CMIElement, value) { + if (value !== undefined) { + value = String(value); + } + + var returnValue = global_constants.SCORM_FALSE; + + if (this.checkState(checkTerminated, _classPrivateFieldGet(this, _error_codes).STORE_BEFORE_INIT, _classPrivateFieldGet(this, _error_codes).STORE_AFTER_TERM)) { + if (checkTerminated) this.lastErrorCode = 0; + + try { + returnValue = this.setCMIValue(CMIElement, value); + } catch (e) { + if (e instanceof _exceptions.ValidationError) { + this.lastErrorCode = e.errorCode; + returnValue = global_constants.SCORM_FALSE; + } else { + if (e.message) { + console.error(e.message); + } else { + console.error(e); + } + + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).GENERAL); + } + } + + this.processListeners(callbackName, CMIElement, value); + } + + if (returnValue === undefined) { + returnValue = global_constants.SCORM_FALSE; + } // If we didn't have any errors while setting the data, go ahead and + // schedule a commit, if autocommit is turned on + + + if (String(this.lastErrorCode) === '0') { + if (this.settings.autocommit && !_classPrivateFieldGet(this, _timeout)) { + this.scheduleCommit(this.settings.autocommitSeconds * 1000, commitCallback); + } + } + + this.apiLog(callbackName, CMIElement, ': ' + value + ': result: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Orders LMS to store all content parameters + * @param {string} callbackName + * @param {boolean} checkTerminated + * @return {string} + */ + + }, { + key: "commit", + value: function commit(callbackName, checkTerminated) { + this.clearScheduledCommit(); + var returnValue = global_constants.SCORM_FALSE; + + if (this.checkState(checkTerminated, _classPrivateFieldGet(this, _error_codes).COMMIT_BEFORE_INIT, _classPrivateFieldGet(this, _error_codes).COMMIT_AFTER_TERM)) { + var result = this.storeData(false); + + if (!this.settings.sendBeaconCommit && !this.settings.asyncCommit && result.errorCode && result.errorCode > 0) { + this.throwSCORMError(result.errorCode); + } + + returnValue = typeof result !== 'undefined' && result.result ? result.result : global_constants.SCORM_FALSE; + this.apiLog(callbackName, 'HttpRequest', ' Result: ' + returnValue, global_constants.LOG_LEVEL_DEBUG); + if (checkTerminated) this.lastErrorCode = 0; + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Returns last error code + * @param {string} callbackName + * @return {string} + */ + + }, { + key: "getLastError", + value: function getLastError(callbackName) { + var returnValue = String(this.lastErrorCode); + this.processListeners(callbackName); + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + return returnValue; + } + /** + * Returns the errorNumber error description + * + * @param {string} callbackName + * @param {(string|number)} CMIErrorCode + * @return {string} + */ + + }, { + key: "getErrorString", + value: function getErrorString(callbackName, CMIErrorCode) { + var returnValue = ''; + + if (CMIErrorCode !== null && CMIErrorCode !== '') { + returnValue = this.getLmsErrorMessageDetails(CMIErrorCode); + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + return returnValue; + } + /** + * Returns a comprehensive description of the errorNumber error. + * + * @param {string} callbackName + * @param {(string|number)} CMIErrorCode + * @return {string} + */ + + }, { + key: "getDiagnostic", + value: function getDiagnostic(callbackName, CMIErrorCode) { + var returnValue = ''; + + if (CMIErrorCode !== null && CMIErrorCode !== '') { + returnValue = this.getLmsErrorMessageDetails(CMIErrorCode, true); + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + return returnValue; + } + /** + * Checks the LMS state and ensures it has been initialized. + * + * @param {boolean} checkTerminated + * @param {number} beforeInitError + * @param {number} afterTermError + * @return {boolean} + */ + + }, { + key: "checkState", + value: function checkState(checkTerminated, beforeInitError, afterTermError) { + if (this.isNotInitialized()) { + this.throwSCORMError(beforeInitError); + return false; + } else if (checkTerminated && this.isTerminated()) { + this.throwSCORMError(afterTermError); + return false; + } + + return true; + } + /** + * Logging for all SCORM actions + * + * @param {string} functionName + * @param {string} CMIElement + * @param {string} logMessage + * @param {number}messageLevel + */ + + }, { + key: "apiLog", + value: function apiLog(functionName, CMIElement, logMessage, messageLevel) { + logMessage = this.formatMessage(functionName, CMIElement, logMessage); + + if (messageLevel >= this.apiLogLevel) { + switch (messageLevel) { + case global_constants.LOG_LEVEL_ERROR: + console.error(logMessage); + break; + + case global_constants.LOG_LEVEL_WARNING: + console.warn(logMessage); + break; + + case global_constants.LOG_LEVEL_INFO: + console.info(logMessage); + break; + + case global_constants.LOG_LEVEL_DEBUG: + if (console.debug) { + console.debug(logMessage); + } else { + console.log(logMessage); + } + + break; + } + } + } + /** + * Formats the SCORM messages for easy reading + * + * @param {string} functionName + * @param {string} CMIElement + * @param {string} message + * @return {string} + */ + + }, { + key: "formatMessage", + value: function formatMessage(functionName, CMIElement, message) { + var baseLength = 20; + var messageString = ''; + messageString += functionName; + var fillChars = baseLength - messageString.length; + + for (var i = 0; i < fillChars; i++) { + messageString += ' '; + } + + messageString += ': '; + + if (CMIElement) { + var CMIElementBaseLength = 70; + messageString += CMIElement; + fillChars = CMIElementBaseLength - messageString.length; + + for (var j = 0; j < fillChars; j++) { + messageString += ' '; + } + } + + if (message) { + messageString += message; + } + + return messageString; + } + /** + * Checks to see if {str} contains {tester} + * + * @param {string} str String to check against + * @param {string} tester String to check for + * @return {boolean} + */ + + }, { + key: "stringMatches", + value: function stringMatches(str, tester) { + return str && tester && str.match(tester); + } + /** + * Check to see if the specific object has the given property + * @param {*} refObject + * @param {string} attribute + * @return {boolean} + * @private + */ + + }, { + key: "_checkObjectHasProperty", + value: function _checkObjectHasProperty(refObject, attribute) { + return Object.hasOwnProperty.call(refObject, attribute) || Object.getOwnPropertyDescriptor(Object.getPrototypeOf(refObject), attribute) || attribute in refObject; + } + /** + * Returns the message that corresponds to errorNumber + * APIs that inherit BaseAPI should override this function + * + * @param {(string|number)} _errorNumber + * @param {boolean} _detail + * @return {string} + * @abstract + */ + + }, { + key: "getLmsErrorMessageDetails", + value: function getLmsErrorMessageDetails(_errorNumber, _detail) { + throw new Error('The getLmsErrorMessageDetails method has not been implemented'); + } + /** + * Gets the value for the specific element. + * APIs that inherit BaseAPI should override this function + * + * @param {string} _CMIElement + * @return {string} + * @abstract + */ + + }, { + key: "getCMIValue", + value: function getCMIValue(_CMIElement) { + throw new Error('The getCMIValue method has not been implemented'); + } + /** + * Sets the value for the specific element. + * APIs that inherit BaseAPI should override this function + * + * @param {string} _CMIElement + * @param {any} _value + * @return {string} + * @abstract + */ + + }, { + key: "setCMIValue", + value: function setCMIValue(_CMIElement, _value) { + throw new Error('The setCMIValue method has not been implemented'); + } + /** + * Shared API method to set a valid for a given element. + * + * @param {string} methodName + * @param {boolean} scorm2004 + * @param {string} CMIElement + * @param {*} value + * @return {string} + */ + + }, { + key: "_commonSetCMIValue", + value: function _commonSetCMIValue(methodName, scorm2004, CMIElement, value) { + if (!CMIElement || CMIElement === '') { + return global_constants.SCORM_FALSE; + } + + var structure = CMIElement.split('.'); + var refObject = this; + var returnValue = global_constants.SCORM_FALSE; + var foundFirstIndex = false; + var invalidErrorMessage = "The data model element passed to ".concat(methodName, " (").concat(CMIElement, ") is not a valid SCORM data model element."); + var invalidErrorCode = scorm2004 ? _classPrivateFieldGet(this, _error_codes).UNDEFINED_DATA_MODEL : _classPrivateFieldGet(this, _error_codes).GENERAL; + + for (var i = 0; i < structure.length; i++) { + var attribute = structure[i]; + + if (i === structure.length - 1) { + if (scorm2004 && attribute.substr(0, 8) === '{target=' && typeof refObject._isTargetValid == 'function') { + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).READ_ONLY_ELEMENT); + } else if (!this._checkObjectHasProperty(refObject, attribute)) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + } else { + if (this.isInitialized() && this.stringMatches(CMIElement, '\\.correct_responses\\.\\d+')) { + this.validateCorrectResponse(CMIElement, value); + } + + if (!scorm2004 || this.lastErrorCode === 0) { + refObject[attribute] = value; + returnValue = global_constants.SCORM_TRUE; + } + } + } else { + refObject = refObject[attribute]; + + if (!refObject) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + break; + } + + if (refObject instanceof _common.CMIArray) { + var index = parseInt(structure[i + 1], 10); // SCO is trying to set an item on an array + + if (!isNaN(index)) { + var item = refObject.childArray[index]; + + if (item) { + refObject = item; + foundFirstIndex = true; + } else { + var newChild = this.getChildElement(CMIElement, value, foundFirstIndex); + foundFirstIndex = true; + + if (!newChild) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + } else { + if (refObject.initialized) newChild.initialize(); + refObject.childArray.push(newChild); + refObject = newChild; + } + } // Have to update i value to skip the array position + + + i++; + } + } + } + } + + if (returnValue === global_constants.SCORM_FALSE) { + this.apiLog(methodName, null, "There was an error setting the value for: ".concat(CMIElement, ", value of: ").concat(value), global_constants.LOG_LEVEL_WARNING); + } + + return returnValue; + } + /** + * Abstract method for validating that a response is correct. + * + * @param {string} _CMIElement + * @param {*} _value + */ + + }, { + key: "validateCorrectResponse", + value: function validateCorrectResponse(_CMIElement, _value) {// just a stub method + } + /** + * Gets or builds a new child element to add to the array. + * APIs that inherit BaseAPI should override this method. + * + * @param {string} _CMIElement - unused + * @param {*} _value - unused + * @param {boolean} _foundFirstIndex - unused + * @return {*} + * @abstract + */ + + }, { + key: "getChildElement", + value: function getChildElement(_CMIElement, _value, _foundFirstIndex) { + throw new Error('The getChildElement method has not been implemented'); + } + /** + * Gets a value from the CMI Object + * + * @param {string} methodName + * @param {boolean} scorm2004 + * @param {string} CMIElement + * @return {*} + */ + + }, { + key: "_commonGetCMIValue", + value: function _commonGetCMIValue(methodName, scorm2004, CMIElement) { + if (!CMIElement || CMIElement === '') { + return ''; + } + + var structure = CMIElement.split('.'); + var refObject = this; + var attribute = null; + var uninitializedErrorMessage = "The data model element passed to ".concat(methodName, " (").concat(CMIElement, ") has not been initialized."); + var invalidErrorMessage = "The data model element passed to ".concat(methodName, " (").concat(CMIElement, ") is not a valid SCORM data model element."); + var invalidErrorCode = scorm2004 ? _classPrivateFieldGet(this, _error_codes).UNDEFINED_DATA_MODEL : _classPrivateFieldGet(this, _error_codes).GENERAL; + + for (var i = 0; i < structure.length; i++) { + attribute = structure[i]; + + if (!scorm2004) { + if (i === structure.length - 1) { + if (!this._checkObjectHasProperty(refObject, attribute)) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + return; + } + } + } else { + if (String(attribute).substr(0, 8) === '{target=' && typeof refObject._isTargetValid == 'function') { + var target = String(attribute).substr(8, String(attribute).length - 9); + return refObject._isTargetValid(target); + } else if (!this._checkObjectHasProperty(refObject, attribute)) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + return; + } + } + + refObject = refObject[attribute]; + + if (refObject === undefined) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + break; + } + + if (refObject instanceof _common.CMIArray) { + var index = parseInt(structure[i + 1], 10); // SCO is trying to set an item on an array + + if (!isNaN(index)) { + var item = refObject.childArray[index]; + + if (item) { + refObject = item; + } else { + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).VALUE_NOT_INITIALIZED, uninitializedErrorMessage); + break; + } // Have to update i value to skip the array position + + + i++; + } + } + } + + if (refObject === null || refObject === undefined) { + if (!scorm2004) { + if (attribute === '_children') { + this.throwSCORMError(scorm12_error_codes.CHILDREN_ERROR); + } else if (attribute === '_count') { + this.throwSCORMError(scorm12_error_codes.COUNT_ERROR); + } + } + } else { + return refObject; + } + } + /** + * Returns true if the API's current state is STATE_INITIALIZED + * + * @return {boolean} + */ + + }, { + key: "isInitialized", + value: function isInitialized() { + return this.currentState === global_constants.STATE_INITIALIZED; + } + /** + * Returns true if the API's current state is STATE_NOT_INITIALIZED + * + * @return {boolean} + */ + + }, { + key: "isNotInitialized", + value: function isNotInitialized() { + return this.currentState === global_constants.STATE_NOT_INITIALIZED; + } + /** + * Returns true if the API's current state is STATE_TERMINATED + * + * @return {boolean} + */ + + }, { + key: "isTerminated", + value: function isTerminated() { + return this.currentState === global_constants.STATE_TERMINATED; + } + /** + * Provides a mechanism for attaching to a specific SCORM event + * + * @param {string} listenerName + * @param {function} callback + */ + + }, { + key: "on", + value: function on(listenerName, callback) { + if (!callback) return; + var listenerFunctions = listenerName.split(' '); + + for (var i = 0; i < listenerFunctions.length; i++) { + var listenerSplit = listenerFunctions[i].split('.'); + if (listenerSplit.length === 0) return; + var functionName = listenerSplit[0]; + var CMIElement = null; + + if (listenerSplit.length > 1) { + CMIElement = listenerName.replace(functionName + '.', ''); + } + + this.listenerArray.push({ + functionName: functionName, + CMIElement: CMIElement, + callback: callback + }); + this.apiLog('on', functionName, "Added event listener: ".concat(this.listenerArray.length), global_constants.LOG_LEVEL_INFO); + } + } + /** + * Provides a mechanism for detaching a specific SCORM event listener + * + * @param {string} listenerName + * @param {function} callback + */ + + }, { + key: "off", + value: function off(listenerName, callback) { + var _this = this; + + if (!callback) return; + var listenerFunctions = listenerName.split(' '); + + var _loop = function _loop(i) { + var listenerSplit = listenerFunctions[i].split('.'); + if (listenerSplit.length === 0) return { + v: void 0 + }; + var functionName = listenerSplit[0]; + var CMIElement = null; + + if (listenerSplit.length > 1) { + CMIElement = listenerName.replace(functionName + '.', ''); + } + + var removeIndex = _this.listenerArray.findIndex(function (obj) { + return obj.functionName === functionName && obj.CMIElement === CMIElement && obj.callback === callback; + }); + + if (removeIndex !== -1) { + _this.listenerArray.splice(removeIndex, 1); + + _this.apiLog('off', functionName, "Removed event listener: ".concat(_this.listenerArray.length), global_constants.LOG_LEVEL_INFO); + } + }; + + for (var i = 0; i < listenerFunctions.length; i++) { + var _ret = _loop(i); + + if (_typeof(_ret) === "object") return _ret.v; + } + } + /** + * Provides a mechanism for clearing all listeners from a specific SCORM event + * + * @param {string} listenerName + */ + + }, { + key: "clear", + value: function clear(listenerName) { + var _this2 = this; + + var listenerFunctions = listenerName.split(' '); + + var _loop2 = function _loop2(i) { + var listenerSplit = listenerFunctions[i].split('.'); + if (listenerSplit.length === 0) return { + v: void 0 + }; + var functionName = listenerSplit[0]; + var CMIElement = null; + + if (listenerSplit.length > 1) { + CMIElement = listenerName.replace(functionName + '.', ''); + } + + _this2.listenerArray = _this2.listenerArray.filter(function (obj) { + return obj.functionName !== functionName && obj.CMIElement !== CMIElement; + }); + }; + + for (var i = 0; i < listenerFunctions.length; i++) { + var _ret2 = _loop2(i); + + if (_typeof(_ret2) === "object") return _ret2.v; + } + } + /** + * Processes any 'on' listeners that have been created + * + * @param {string} functionName + * @param {string} CMIElement + * @param {*} value + */ + + }, { + key: "processListeners", + value: function processListeners(functionName, CMIElement, value) { + this.apiLog(functionName, CMIElement, value); + + for (var i = 0; i < this.listenerArray.length; i++) { + var listener = this.listenerArray[i]; + var functionsMatch = listener.functionName === functionName; + var listenerHasCMIElement = !!listener.CMIElement; + var CMIElementsMatch = false; + + if (CMIElement && listener.CMIElement && listener.CMIElement.substring(listener.CMIElement.length - 1) === '*') { + CMIElementsMatch = CMIElement.indexOf(listener.CMIElement.substring(0, listener.CMIElement.length - 1)) === 0; + } else { + CMIElementsMatch = listener.CMIElement === CMIElement; + } + + if (functionsMatch && (!listenerHasCMIElement || CMIElementsMatch)) { + listener.callback(CMIElement, value); + } + } + } + /** + * Throws a SCORM error + * + * @param {number} errorNumber + * @param {string} message + */ + + }, { + key: "throwSCORMError", + value: function throwSCORMError(errorNumber, message) { + if (!message) { + message = this.getLmsErrorMessageDetails(errorNumber); + } + + this.apiLog('throwSCORMError', null, errorNumber + ': ' + message, global_constants.LOG_LEVEL_ERROR); + this.lastErrorCode = String(errorNumber); + } + /** + * Clears the last SCORM error code on success. + * + * @param {string} success + */ + + }, { + key: "clearSCORMError", + value: function clearSCORMError(success) { + if (success !== undefined && success !== global_constants.SCORM_FALSE) { + this.lastErrorCode = 0; + } + } + /** + * Attempts to store the data to the LMS, logs data if no LMS configured + * APIs that inherit BaseAPI should override this function + * + * @param {boolean} _calculateTotalTime + * @return {string} + * @abstract + */ + + }, { + key: "storeData", + value: function storeData(_calculateTotalTime) { + throw new Error('The storeData method has not been implemented'); + } + /** + * Load the CMI from a flattened JSON object + * @param {object} json + * @param {string} CMIElement + */ + + }, { + key: "loadFromFlattenedJSON", + value: function loadFromFlattenedJSON(json, CMIElement) { + var _this3 = this; + + if (!this.isNotInitialized()) { + console.error('loadFromFlattenedJSON can only be called before the call to lmsInitialize.'); + return; + } + /** + * Test match pattern. + * + * @param {string} a + * @param {string} c + * @param {RegExp} a_pattern + * @return {number} + */ + + + function testPattern(a, c, a_pattern) { + var a_match = a.match(a_pattern); + var c_match; + + if (a_match !== null && (c_match = c.match(a_pattern)) !== null) { + var a_num = Number(a_match[2]); + var c_num = Number(c_match[2]); + + if (a_num === c_num) { + if (a_match[3] === 'id') { + return -1; + } else if (a_match[3] === 'type') { + if (c_match[3] === 'id') { + return 1; + } else { + return -1; + } + } else { + return 1; + } + } + + return a_num - c_num; + } + + return null; + } + + var int_pattern = /^(cmi\.interactions\.)(\d+)\.(.*)$/; + var obj_pattern = /^(cmi\.objectives\.)(\d+)\.(.*)$/; + var result = Object.keys(json).map(function (key) { + return [String(key), json[key]]; + }); // CMI interactions need to have id and type loaded before any other fields + + result.sort(function (_ref, _ref2) { + var _ref3 = _slicedToArray(_ref, 2), + a = _ref3[0], + b = _ref3[1]; + + var _ref4 = _slicedToArray(_ref2, 2), + c = _ref4[0], + d = _ref4[1]; + + var test; + + if ((test = testPattern(a, c, int_pattern)) !== null) { + return test; + } + + if ((test = testPattern(a, c, obj_pattern)) !== null) { + return test; + } + + if (a < c) { + return -1; + } + + if (a > c) { + return 1; + } + + return 0; + }); + var obj; + result.forEach(function (element) { + obj = {}; + obj[element[0]] = element[1]; + + _this3.loadFromJSON((0, _utilities.unflatten)(obj), CMIElement); + }); + } + /** + * Loads CMI data from a JSON object. + * + * @param {object} json + * @param {string} CMIElement + */ + + }, { + key: "loadFromJSON", + value: function loadFromJSON(json, CMIElement) { + if (!this.isNotInitialized()) { + console.error('loadFromJSON can only be called before the call to lmsInitialize.'); + return; + } + + CMIElement = CMIElement !== undefined ? CMIElement : 'cmi'; + this.startingData = json; // could this be refactored down to flatten(json) then setCMIValue on each? + + for (var key in json) { + if ({}.hasOwnProperty.call(json, key) && json[key]) { + var currentCMIElement = (CMIElement ? CMIElement + '.' : '') + key; + var value = json[key]; + + if (value['childArray']) { + for (var i = 0; i < value['childArray'].length; i++) { + this.loadFromJSON(value['childArray'][i], currentCMIElement + '.' + i); + } + } else if (value.constructor === Object) { + this.loadFromJSON(value, currentCMIElement); + } else { + this.setCMIValue(currentCMIElement, value); + } + } + } + } + /** + * Render the CMI object to JSON for sending to an LMS. + * + * @return {string} + */ + + }, { + key: "renderCMIToJSONString", + value: function renderCMIToJSONString() { + var cmi = this.cmi; // Do we want/need to return fields that have no set value? + // return JSON.stringify({ cmi }, (k, v) => v === undefined ? null : v, 2); + + return JSON.stringify({ + cmi: cmi + }); + } + /** + * Returns a JS object representing the current cmi + * @return {object} + */ + + }, { + key: "renderCMIToJSONObject", + value: function renderCMIToJSONObject() { + // Do we want/need to return fields that have no set value? + // return JSON.stringify({ cmi }, (k, v) => v === undefined ? null : v, 2); + return JSON.parse(this.renderCMIToJSONString()); + } + /** + * Render the cmi object to the proper format for LMS commit + * APIs that inherit BaseAPI should override this function + * + * @param {boolean} _terminateCommit + * @return {*} + * @abstract + */ + + }, { + key: "renderCommitCMI", + value: function renderCommitCMI(_terminateCommit) { + throw new Error('The storeData method has not been implemented'); + } + /** + * Send the request to the LMS + * @param {string} url + * @param {object|Array} params + * @param {boolean} immediate + * @return {object} + */ + + }, { + key: "processHttpRequest", + value: function processHttpRequest(url, params) { + var immediate = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + var api = this; + + var process = function process(url, params, settings, error_codes) { + var genericError = { + 'result': global_constants.SCORM_FALSE, + 'errorCode': error_codes.GENERAL + }; + var result; + + if (!settings.sendBeaconCommit) { + var httpReq = new XMLHttpRequest(); + httpReq.open('POST', url, settings.asyncCommit); + + if (settings.asyncCommit) { + httpReq.onload = function (e) { + if (typeof settings.responseHandler === 'function') { + result = settings.responseHandler(httpReq); + } else { + result = JSON.parse(httpReq.responseText); + } + }; + } + + try { + if (params instanceof Array) { + httpReq.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded'); + httpReq.send(params.join('&')); + } else { + httpReq.setRequestHeader('Content-Type', settings.commitRequestDataType); + httpReq.send(JSON.stringify(params)); + } + + if (!settings.asyncCommit) { + if (typeof settings.responseHandler === 'function') { + result = settings.responseHandler(httpReq); + } else { + result = JSON.parse(httpReq.responseText); + } + } else { + result = {}; + result.result = global_constants.SCORM_TRUE; + result.errorCode = 0; + api.processListeners('CommitSuccess'); + return result; + } + } catch (e) { + console.error(e); + api.processListeners('CommitError'); + return genericError; + } + } else { + try { + var headers = { + type: settings.commitRequestDataType + }; + var blob; + + if (params instanceof Array) { + blob = new Blob([params.join('&')], headers); + } else { + blob = new Blob([JSON.stringify(params)], headers); + } + + result = {}; + + if (navigator.sendBeacon(url, blob)) { + result.result = global_constants.SCORM_TRUE; + result.errorCode = 0; + } else { + result.result = global_constants.SCORM_FALSE; + result.errorCode = 101; + } + } catch (e) { + console.error(e); + api.processListeners('CommitError'); + return genericError; + } + } + + if (typeof result === 'undefined') { + api.processListeners('CommitError'); + return genericError; + } + + if (result.result === true || result.result === global_constants.SCORM_TRUE) { + api.processListeners('CommitSuccess'); + } else { + api.processListeners('CommitError'); + } + + return result; + }; + + if (typeof _lodash["default"] !== 'undefined') { + var debounced = (0, _lodash["default"])(process, 500); + debounced(url, params, this.settings, this.error_codes); // if we're terminating, go ahead and commit immediately + + if (immediate) { + debounced.flush(); + } + + return { + result: global_constants.SCORM_TRUE, + errorCode: 0 + }; + } else { + return process(url, params, this.settings, this.error_codes); + } + } + /** + * Throws a SCORM error + * + * @param {number} when - the number of milliseconds to wait before committing + * @param {string} callback - the name of the commit event callback + */ + + }, { + key: "scheduleCommit", + value: function scheduleCommit(when, callback) { + _classPrivateFieldSet(this, _timeout, new ScheduledCommit(this, when, callback)); + + this.apiLog('scheduleCommit', '', 'scheduled', global_constants.LOG_LEVEL_DEBUG); + } + /** + * Clears and cancels any currently scheduled commits + */ + + }, { + key: "clearScheduledCommit", + value: function clearScheduledCommit() { + if (_classPrivateFieldGet(this, _timeout)) { + _classPrivateFieldGet(this, _timeout).cancel(); + + _classPrivateFieldSet(this, _timeout, null); + + this.apiLog('clearScheduledCommit', '', 'cleared', global_constants.LOG_LEVEL_DEBUG); + } + } + }]); + + return BaseAPI; +}(); +/** + * Private class that wraps a timeout call to the commit() function + */ + + +exports["default"] = BaseAPI; + +var _API = new WeakMap(); + +var _cancelled = new WeakMap(); + +var _timeout2 = new WeakMap(); + +var _callback = new WeakMap(); + +var ScheduledCommit = /*#__PURE__*/function () { + /** + * Constructor for ScheduledCommit + * @param {BaseAPI} API + * @param {number} when + * @param {string} callback + */ + function ScheduledCommit(API, when, callback) { + _classCallCheck(this, ScheduledCommit); + + _API.set(this, { + writable: true, + value: void 0 + }); + + _cancelled.set(this, { + writable: true, + value: false + }); + + _timeout2.set(this, { + writable: true, + value: void 0 + }); + + _callback.set(this, { + writable: true, + value: void 0 + }); + + _classPrivateFieldSet(this, _API, API); + + _classPrivateFieldSet(this, _timeout2, setTimeout(this.wrapper.bind(this), when)); + + _classPrivateFieldSet(this, _callback, callback); + } + /** + * Cancel any currently scheduled commit + */ + + + _createClass(ScheduledCommit, [{ + key: "cancel", + value: function cancel() { + _classPrivateFieldSet(this, _cancelled, true); + + if (_classPrivateFieldGet(this, _timeout2)) { + clearTimeout(_classPrivateFieldGet(this, _timeout2)); + } + } + /** + * Wrap the API commit call to check if the call has already been cancelled + */ + + }, { + key: "wrapper", + value: function wrapper() { + if (!_classPrivateFieldGet(this, _cancelled)) { + _classPrivateFieldGet(this, _API).commit(_classPrivateFieldGet(this, _callback)); + } + } + }]); + + return ScheduledCommit; +}(); + +},{"./cmi/common":4,"./constants/api_constants":6,"./constants/error_codes":7,"./exceptions":9,"./utilities":11,"lodash.debounce":1}],3:[function(require,module,exports){ +"use strict"; + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +var _BaseAPI2 = _interopRequireDefault(require("./BaseAPI")); + +var _scorm12_cmi = require("./cmi/scorm12_cmi"); + +var Utilities = _interopRequireWildcard(require("./utilities")); + +var _api_constants = _interopRequireDefault(require("./constants/api_constants")); + +var _error_codes = _interopRequireDefault(require("./constants/error_codes")); + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +var scorm12_constants = _api_constants["default"].scorm12; +var global_constants = _api_constants["default"].global; +var scorm12_error_codes = _error_codes["default"].scorm12; +/** + * API class for SCORM 1.2 + */ + +var Scorm12API = /*#__PURE__*/function (_BaseAPI) { + _inherits(Scorm12API, _BaseAPI); + + var _super = _createSuper(Scorm12API); + + /** + * Constructor for SCORM 1.2 API + * @param {object} settings + */ + function Scorm12API(settings) { + var _this; + + _classCallCheck(this, Scorm12API); + + var finalSettings = _objectSpread(_objectSpread({}, { + mastery_override: false + }), settings); + + _this = _super.call(this, scorm12_error_codes, finalSettings); + _this.cmi = new _scorm12_cmi.CMI(); + _this.nav = new _scorm12_cmi.NAV(); // Rename functions to match 1.2 Spec and expose to modules + + _this.LMSInitialize = _this.lmsInitialize; + _this.LMSFinish = _this.lmsFinish; + _this.LMSGetValue = _this.lmsGetValue; + _this.LMSSetValue = _this.lmsSetValue; + _this.LMSCommit = _this.lmsCommit; + _this.LMSGetLastError = _this.lmsGetLastError; + _this.LMSGetErrorString = _this.lmsGetErrorString; + _this.LMSGetDiagnostic = _this.lmsGetDiagnostic; + return _this; + } + /** + * lmsInitialize function from SCORM 1.2 Spec + * + * @return {string} bool + */ + + + _createClass(Scorm12API, [{ + key: "lmsInitialize", + value: function lmsInitialize() { + this.cmi.initialize(); + return this.initialize('LMSInitialize', 'LMS was already initialized!', 'LMS is already finished!'); + } + /** + * LMSFinish function from SCORM 1.2 Spec + * + * @return {string} bool + */ + + }, { + key: "lmsFinish", + value: function lmsFinish() { + var result = this.terminate('LMSFinish', true); + + if (result === global_constants.SCORM_TRUE) { + if (this.nav.event !== '') { + if (this.nav.event === 'continue') { + this.processListeners('SequenceNext'); + } else { + this.processListeners('SequencePrevious'); + } + } else if (this.settings.autoProgress) { + this.processListeners('SequenceNext'); + } + } + + return result; + } + /** + * LMSGetValue function from SCORM 1.2 Spec + * + * @param {string} CMIElement + * @return {string} + */ + + }, { + key: "lmsGetValue", + value: function lmsGetValue(CMIElement) { + return this.getValue('LMSGetValue', false, CMIElement); + } + /** + * LMSSetValue function from SCORM 1.2 Spec + * + * @param {string} CMIElement + * @param {*} value + * @return {string} + */ + + }, { + key: "lmsSetValue", + value: function lmsSetValue(CMIElement, value) { + return this.setValue('LMSSetValue', 'LMSCommit', false, CMIElement, value); + } + /** + * LMSCommit function from SCORM 1.2 Spec + * + * @return {string} bool + */ + + }, { + key: "lmsCommit", + value: function lmsCommit() { + return this.commit('LMSCommit', false); + } + /** + * LMSGetLastError function from SCORM 1.2 Spec + * + * @return {string} + */ + + }, { + key: "lmsGetLastError", + value: function lmsGetLastError() { + return this.getLastError('LMSGetLastError'); + } + /** + * LMSGetErrorString function from SCORM 1.2 Spec + * + * @param {string} CMIErrorCode + * @return {string} + */ + + }, { + key: "lmsGetErrorString", + value: function lmsGetErrorString(CMIErrorCode) { + return this.getErrorString('LMSGetErrorString', CMIErrorCode); + } + /** + * LMSGetDiagnostic function from SCORM 1.2 Spec + * + * @param {string} CMIErrorCode + * @return {string} + */ + + }, { + key: "lmsGetDiagnostic", + value: function lmsGetDiagnostic(CMIErrorCode) { + return this.getDiagnostic('LMSGetDiagnostic', CMIErrorCode); + } + /** + * Sets a value on the CMI Object + * + * @param {string} CMIElement + * @param {*} value + * @return {string} + */ + + }, { + key: "setCMIValue", + value: function setCMIValue(CMIElement, value) { + return this._commonSetCMIValue('LMSSetValue', false, CMIElement, value); + } + /** + * Gets a value from the CMI Object + * + * @param {string} CMIElement + * @return {*} + */ + + }, { + key: "getCMIValue", + value: function getCMIValue(CMIElement) { + return this._commonGetCMIValue('getCMIValue', false, CMIElement); + } + /** + * Gets or builds a new child element to add to the array. + * + * @param {string} CMIElement + * @param {*} value + * @param {boolean} foundFirstIndex + * @return {object} + */ + + }, { + key: "getChildElement", + value: function getChildElement(CMIElement, value, foundFirstIndex) { + var newChild; + + if (this.stringMatches(CMIElement, 'cmi\\.objectives\\.\\d+')) { + newChild = new _scorm12_cmi.CMIObjectivesObject(); + } else if (foundFirstIndex && this.stringMatches(CMIElement, 'cmi\\.interactions\\.\\d+\\.correct_responses\\.\\d+')) { + newChild = new _scorm12_cmi.CMIInteractionsCorrectResponsesObject(); + } else if (foundFirstIndex && this.stringMatches(CMIElement, 'cmi\\.interactions\\.\\d+\\.objectives\\.\\d+')) { + newChild = new _scorm12_cmi.CMIInteractionsObjectivesObject(); + } else if (!foundFirstIndex && this.stringMatches(CMIElement, 'cmi\\.interactions\\.\\d+')) { + newChild = new _scorm12_cmi.CMIInteractionsObject(); + } + + return newChild; + } + /** + * Validates Correct Response values + * + * @param {string} CMIElement + * @param {*} value + * @return {boolean} + */ + + }, { + key: "validateCorrectResponse", + value: function validateCorrectResponse(CMIElement, value) { + return true; + } + /** + * Returns the message that corresponds to errorNumber. + * + * @param {*} errorNumber + * @param {boolean} detail + * @return {string} + */ + + }, { + key: "getLmsErrorMessageDetails", + value: function getLmsErrorMessageDetails(errorNumber, detail) { + var basicMessage = 'No Error'; + var detailMessage = 'No Error'; // Set error number to string since inconsistent from modules if string or number + + errorNumber = String(errorNumber); + + if (scorm12_constants.error_descriptions[errorNumber]) { + basicMessage = scorm12_constants.error_descriptions[errorNumber].basicMessage; + detailMessage = scorm12_constants.error_descriptions[errorNumber].detailMessage; + } + + return detail ? detailMessage : basicMessage; + } + /** + * Replace the whole API with another + * + * @param {Scorm12API} newAPI + */ + + }, { + key: "replaceWithAnotherScormAPI", + value: function replaceWithAnotherScormAPI(newAPI) { + // Data Model + this.cmi = newAPI.cmi; + } + /** + * Render the cmi object to the proper format for LMS commit + * + * @param {boolean} terminateCommit + * @return {object|Array} + */ + + }, { + key: "renderCommitCMI", + value: function renderCommitCMI(terminateCommit) { + var cmiExport = this.renderCMIToJSONObject(); + + if (terminateCommit) { + cmiExport.cmi.core.total_time = this.cmi.getCurrentTotalTime(); + } + + var result = []; + var flattened = Utilities.flatten(cmiExport); + + switch (this.settings.dataCommitFormat) { + case 'flattened': + return Utilities.flatten(cmiExport); + + case 'params': + for (var item in flattened) { + if ({}.hasOwnProperty.call(flattened, item)) { + result.push("".concat(item, "=").concat(flattened[item])); + } + } + + return result; + + case 'json': + default: + return cmiExport; + } + } + /** + * Attempts to store the data to the LMS + * + * @param {boolean} terminateCommit + * @return {string} + */ + + }, { + key: "storeData", + value: function storeData(terminateCommit) { + if (terminateCommit) { + var originalStatus = this.cmi.core.lesson_status; + + if (originalStatus === 'not attempted') { + this.cmi.core.lesson_status = 'completed'; + } + + if (this.cmi.core.lesson_mode === 'normal') { + if (this.cmi.core.credit === 'credit') { + if (this.settings.mastery_override && this.cmi.student_data.mastery_score !== '' && this.cmi.core.score.raw !== '') { + if (parseFloat(this.cmi.core.score.raw) >= parseFloat(this.cmi.student_data.mastery_score)) { + this.cmi.core.lesson_status = 'passed'; + } else { + this.cmi.core.lesson_status = 'failed'; + } + } + } + } else if (this.cmi.core.lesson_mode === 'browse') { + var _this$startingData, _this$startingData$cm, _this$startingData$cm2; + + if ((((_this$startingData = this.startingData) === null || _this$startingData === void 0 ? void 0 : (_this$startingData$cm = _this$startingData.cmi) === null || _this$startingData$cm === void 0 ? void 0 : (_this$startingData$cm2 = _this$startingData$cm.core) === null || _this$startingData$cm2 === void 0 ? void 0 : _this$startingData$cm2.lesson_status) || '') === '' && originalStatus === 'not attempted') { + this.cmi.core.lesson_status = 'browsed'; + } + } + } + + var commitObject = this.renderCommitCMI(terminateCommit || this.settings.alwaysSendTotalTime); + + if (this.apiLogLevel === global_constants.LOG_LEVEL_DEBUG) { + console.debug('Commit (terminated: ' + (terminateCommit ? 'yes' : 'no') + '): '); + console.debug(commitObject); + } + + if (this.settings.lmsCommitUrl) { + return this.processHttpRequest(this.settings.lmsCommitUrl, commitObject, terminateCommit); + } else { + return global_constants.SCORM_TRUE; + } + } + }]); + + return Scorm12API; +}(_BaseAPI2["default"]); + +exports["default"] = Scorm12API; + +},{"./BaseAPI":2,"./cmi/scorm12_cmi":5,"./constants/api_constants":6,"./constants/error_codes":7,"./utilities":11}],4:[function(require,module,exports){ +"use strict"; + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.checkValidFormat = checkValidFormat; +exports.checkValidRange = checkValidRange; +exports.CMIArray = exports.CMIScore = exports.BaseCMI = void 0; + +var _api_constants = _interopRequireDefault(require("../constants/api_constants")); + +var _error_codes = _interopRequireDefault(require("../constants/error_codes")); + +var _regex = _interopRequireDefault(require("../constants/regex")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; } + +function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } } + +function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); } + +function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); } + +function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +var scorm12_constants = _api_constants["default"].scorm12; +var scorm12_regex = _regex["default"].scorm12; +var scorm12_error_codes = _error_codes["default"].scorm12; +/** + * Check if the value matches the proper format. If not, throw proper error code. + * + * @param {string} value + * @param {string} regexPattern + * @param {number} errorCode + * @param {class} errorClass + * @param {boolean} allowEmptyString + * @return {boolean} + */ + +function checkValidFormat(value, regexPattern, errorCode, errorClass, allowEmptyString) { + var formatRegex = new RegExp(regexPattern); + var matches = value.match(formatRegex); + + if (allowEmptyString && value === '') { + return true; + } + + if (value === undefined || !matches || matches[0] === '') { + throw new errorClass.prototype.constructor(errorCode); + } + + return true; +} +/** + * Check if the value matches the proper range. If not, throw proper error code. + * + * @param {*} value + * @param {string} rangePattern + * @param {number} errorCode + * @param {class} errorClass + * @return {boolean} + */ + + +function checkValidRange(value, rangePattern, errorCode, errorClass) { + var ranges = rangePattern.split('#'); + value = value * 1.0; + + if (value >= ranges[0]) { + if (ranges[1] === '*' || value <= ranges[1]) { + return true; + } else { + throw new errorClass.prototype.constructor(errorCode); + } + } else { + throw new errorClass.prototype.constructor(errorCode); + } +} +/** + * Base class for API cmi objects + */ + + +var _initialized = new WeakMap(); + +var _start_time = new WeakMap(); + +var BaseCMI = /*#__PURE__*/function () { + /** + * Constructor for BaseCMI, just marks the class as abstract + */ + function BaseCMI() { + _classCallCheck(this, BaseCMI); + + _defineProperty(this, "jsonString", false); + + _initialized.set(this, { + writable: true, + value: false + }); + + _start_time.set(this, { + writable: true, + value: void 0 + }); + + if ((this instanceof BaseCMI ? this.constructor : void 0) === BaseCMI) { + throw new TypeError('Cannot construct BaseCMI instances directly'); + } + } + /** + * Getter for #initialized + * @return {boolean} + */ + + + _createClass(BaseCMI, [{ + key: "initialized", + get: function get() { + return _classPrivateFieldGet(this, _initialized); + } + /** + * Getter for #start_time + * @return {Number} + */ + + }, { + key: "start_time", + get: function get() { + return _classPrivateFieldGet(this, _start_time); + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + }, { + key: "initialize", + value: function initialize() { + _classPrivateFieldSet(this, _initialized, true); + } + /** + * Called when the player should override the 'session_time' provided by + * the module + */ + + }, { + key: "setStartTime", + value: function setStartTime() { + _classPrivateFieldSet(this, _start_time, new Date().getTime()); + } + }]); + + return BaseCMI; +}(); +/** + * Base class for cmi *.score objects + */ + + +exports.BaseCMI = BaseCMI; + +var _children2 = new WeakMap(); + +var _score_range = new WeakMap(); + +var _invalid_error_code = new WeakMap(); + +var _invalid_type_code = new WeakMap(); + +var _invalid_range_code = new WeakMap(); + +var _decimal_regex = new WeakMap(); + +var _error_class = new WeakMap(); + +var _raw = new WeakMap(); + +var _min = new WeakMap(); + +var _max = new WeakMap(); + +var CMIScore = /*#__PURE__*/function (_BaseCMI) { + _inherits(CMIScore, _BaseCMI); + + var _super = _createSuper(CMIScore); + + /** + * Constructor for *.score + * @param {string} score_children + * @param {string} score_range + * @param {string} max + * @param {number} invalidErrorCode + * @param {number} invalidTypeCode + * @param {number} invalidRangeCode + * @param {string} decimalRegex + * @param {class} errorClass + */ + function CMIScore(_ref) { + var _this; + + var score_children = _ref.score_children, + score_range = _ref.score_range, + max = _ref.max, + invalidErrorCode = _ref.invalidErrorCode, + invalidTypeCode = _ref.invalidTypeCode, + invalidRangeCode = _ref.invalidRangeCode, + decimalRegex = _ref.decimalRegex, + errorClass = _ref.errorClass; + + _classCallCheck(this, CMIScore); + + _this = _super.call(this); + + _children2.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _score_range.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _invalid_error_code.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _invalid_type_code.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _invalid_range_code.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _decimal_regex.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _error_class.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _raw.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _min.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _max.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _classPrivateFieldSet(_assertThisInitialized(_this), _children2, score_children || scorm12_constants.score_children); + + _classPrivateFieldSet(_assertThisInitialized(_this), _score_range, !score_range ? false : scorm12_regex.score_range); + + _classPrivateFieldSet(_assertThisInitialized(_this), _max, max || max === '' ? max : '100'); + + _classPrivateFieldSet(_assertThisInitialized(_this), _invalid_error_code, invalidErrorCode || scorm12_error_codes.INVALID_SET_VALUE); + + _classPrivateFieldSet(_assertThisInitialized(_this), _invalid_type_code, invalidTypeCode || scorm12_error_codes.TYPE_MISMATCH); + + _classPrivateFieldSet(_assertThisInitialized(_this), _invalid_range_code, invalidRangeCode || scorm12_error_codes.VALUE_OUT_OF_RANGE); + + _classPrivateFieldSet(_assertThisInitialized(_this), _decimal_regex, decimalRegex || scorm12_regex.CMIDecimal); + + _classPrivateFieldSet(_assertThisInitialized(_this), _error_class, errorClass); + + return _this; + } + + _createClass(CMIScore, [{ + key: "_children", + get: + /** + * Getter for _children + * @return {string} + * @private + */ + function get() { + return _classPrivateFieldGet(this, _children2); + } + /** + * Setter for _children. Just throws an error. + * @param {string} _children + * @private + */ + , + set: function set(_children) { + throw new (_classPrivateFieldGet(this, _error_class).prototype.constructor)(_classPrivateFieldGet(this, _invalid_error_code)); + } + /** + * Getter for #raw + * @return {string} + */ + + }, { + key: "raw", + get: function get() { + return _classPrivateFieldGet(this, _raw); + } + /** + * Setter for #raw + * @param {string} raw + */ + , + set: function set(raw) { + if (checkValidFormat(raw, _classPrivateFieldGet(this, _decimal_regex), _classPrivateFieldGet(this, _invalid_type_code), _classPrivateFieldGet(this, _error_class)) && (!_classPrivateFieldGet(this, _score_range) || checkValidRange(raw, _classPrivateFieldGet(this, _score_range), _classPrivateFieldGet(this, _invalid_range_code), _classPrivateFieldGet(this, _error_class)))) { + _classPrivateFieldSet(this, _raw, raw); + } + } + /** + * Getter for #min + * @return {string} + */ + + }, { + key: "min", + get: function get() { + return _classPrivateFieldGet(this, _min); + } + /** + * Setter for #min + * @param {string} min + */ + , + set: function set(min) { + if (checkValidFormat(min, _classPrivateFieldGet(this, _decimal_regex), _classPrivateFieldGet(this, _invalid_type_code), _classPrivateFieldGet(this, _error_class)) && (!_classPrivateFieldGet(this, _score_range) || checkValidRange(min, _classPrivateFieldGet(this, _score_range), _classPrivateFieldGet(this, _invalid_range_code), _classPrivateFieldGet(this, _error_class)))) { + _classPrivateFieldSet(this, _min, min); + } + } + /** + * Getter for #max + * @return {string} + */ + + }, { + key: "max", + get: function get() { + return _classPrivateFieldGet(this, _max); + } + /** + * Setter for #max + * @param {string} max + */ + , + set: function set(max) { + if (checkValidFormat(max, _classPrivateFieldGet(this, _decimal_regex), _classPrivateFieldGet(this, _invalid_type_code), _classPrivateFieldGet(this, _error_class)) && (!_classPrivateFieldGet(this, _score_range) || checkValidRange(max, _classPrivateFieldGet(this, _score_range), _classPrivateFieldGet(this, _invalid_range_code), _classPrivateFieldGet(this, _error_class)))) { + _classPrivateFieldSet(this, _max, max); + } + } + /** + * toJSON for *.score + * @return {{min: string, max: string, raw: string}} + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'raw': this.raw, + 'min': this.min, + 'max': this.max + }; + delete this.jsonString; + return result; + } + }]); + + return CMIScore; +}(BaseCMI); +/** + * Base class for cmi *.n objects + */ + + +exports.CMIScore = CMIScore; + +var _errorCode = new WeakMap(); + +var _errorClass = new WeakMap(); + +var _children3 = new WeakMap(); + +var CMIArray = /*#__PURE__*/function (_BaseCMI2) { + _inherits(CMIArray, _BaseCMI2); + + var _super2 = _createSuper(CMIArray); + + /** + * Constructor cmi *.n arrays + * @param {string} children + * @param {number} errorCode + * @param {class} errorClass + */ + function CMIArray(_ref2) { + var _this2; + + var children = _ref2.children, + errorCode = _ref2.errorCode, + errorClass = _ref2.errorClass; + + _classCallCheck(this, CMIArray); + + _this2 = _super2.call(this); + + _errorCode.set(_assertThisInitialized(_this2), { + writable: true, + value: void 0 + }); + + _errorClass.set(_assertThisInitialized(_this2), { + writable: true, + value: void 0 + }); + + _children3.set(_assertThisInitialized(_this2), { + writable: true, + value: void 0 + }); + + _classPrivateFieldSet(_assertThisInitialized(_this2), _children3, children); + + _classPrivateFieldSet(_assertThisInitialized(_this2), _errorCode, errorCode); + + _classPrivateFieldSet(_assertThisInitialized(_this2), _errorClass, errorClass); + + _this2.childArray = []; + return _this2; + } + + _createClass(CMIArray, [{ + key: "_children", + get: + /** + * Getter for _children + * @return {*} + */ + function get() { + return _classPrivateFieldGet(this, _children3); + } + /** + * Setter for _children. Just throws an error. + * @param {string} _children + */ + , + set: function set(_children) { + throw new (_classPrivateFieldGet(this, _errorClass).prototype.constructor)(_classPrivateFieldGet(this, _errorCode)); + } + /** + * Getter for _count + * @return {number} + */ + + }, { + key: "_count", + get: function get() { + return this.childArray.length; + } + /** + * Setter for _count. Just throws an error. + * @param {number} _count + */ + , + set: function set(_count) { + throw new (_classPrivateFieldGet(this, _errorClass).prototype.constructor)(_classPrivateFieldGet(this, _errorCode)); + } + /** + * toJSON for *.n arrays + * @return {object} + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = {}; + + for (var i = 0; i < this.childArray.length; i++) { + result[i + ''] = this.childArray[i]; + } + + delete this.jsonString; + return result; + } + }]); + + return CMIArray; +}(BaseCMI); + +exports.CMIArray = CMIArray; + +},{"../constants/api_constants":6,"../constants/error_codes":7,"../constants/regex":8}],5:[function(require,module,exports){ +"use strict"; + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.throwReadOnlyError = throwReadOnlyError; +exports.throwWriteOnlyError = throwWriteOnlyError; +exports.check12ValidFormat = check12ValidFormat; +exports.check12ValidRange = check12ValidRange; +exports.NAV = exports.CMIInteractionsCorrectResponsesObject = exports.CMIInteractionsObjectivesObject = exports.CMIObjectivesObject = exports.CMIInteractionsObject = exports.CMIStudentPreference = exports.CMIStudentData = exports.CMI = void 0; + +var _common = require("./common"); + +var _api_constants = _interopRequireDefault(require("../constants/api_constants")); + +var _error_codes = _interopRequireDefault(require("../constants/error_codes")); + +var _regex = _interopRequireDefault(require("../constants/regex")); + +var _exceptions = require("../exceptions"); + +var Utilities = _interopRequireWildcard(require("../utilities")); + +var Util = Utilities; + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); } + +function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); } + +function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; } + +function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); } + +function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } } + +var scorm12_constants = _api_constants["default"].scorm12; +var scorm12_regex = _regex["default"].scorm12; +var scorm12_error_codes = _error_codes["default"].scorm12; +/** + * Helper method for throwing Read Only error + */ + +function throwReadOnlyError() { + throw new _exceptions.Scorm12ValidationError(scorm12_error_codes.READ_ONLY_ELEMENT); +} +/** + * Helper method for throwing Write Only error + */ + + +function throwWriteOnlyError() { + throw new _exceptions.Scorm12ValidationError(scorm12_error_codes.WRITE_ONLY_ELEMENT); +} +/** + * Helper method for throwing Invalid Set error + */ + + +function throwInvalidValueError() { + throw new _exceptions.Scorm12ValidationError(scorm12_error_codes.INVALID_SET_VALUE); +} +/** + * Helper method, no reason to have to pass the same error codes every time + * @param {*} value + * @param {string} regexPattern + * @param {boolean} allowEmptyString + * @return {boolean} + */ + + +function check12ValidFormat(value, regexPattern, allowEmptyString) { + return (0, _common.checkValidFormat)(value, regexPattern, scorm12_error_codes.TYPE_MISMATCH, _exceptions.Scorm12ValidationError, allowEmptyString); +} +/** + * Helper method, no reason to have to pass the same error codes every time + * @param {*} value + * @param {string} rangePattern + * @param {boolean} allowEmptyString + * @return {boolean} + */ + + +function check12ValidRange(value, rangePattern, allowEmptyString) { + return (0, _common.checkValidRange)(value, rangePattern, scorm12_error_codes.VALUE_OUT_OF_RANGE, _exceptions.Scorm12ValidationError, allowEmptyString); +} +/** + * Class representing the cmi object for SCORM 1.2 + */ + + +var _children2 = new WeakMap(); + +var _version2 = new WeakMap(); + +var _launch_data = new WeakMap(); + +var _comments = new WeakMap(); + +var _comments_from_lms = new WeakMap(); + +var CMI = /*#__PURE__*/function (_BaseCMI) { + _inherits(CMI, _BaseCMI); + + var _super = _createSuper(CMI); + + /** + * Constructor for the SCORM 1.2 cmi object + * @param {string} cmi_children + * @param {(CMIStudentData|AICCCMIStudentData)} student_data + * @param {boolean} initialized + */ + function CMI(cmi_children, student_data, initialized) { + var _this; + + _classCallCheck(this, CMI); + + _this = _super.call(this); + + _children2.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _version2.set(_assertThisInitialized(_this), { + writable: true, + value: '3.4' + }); + + _launch_data.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _comments.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _comments_from_lms.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _defineProperty(_assertThisInitialized(_this), "student_data", null); + + if (initialized) _this.initialize(); + + _classPrivateFieldSet(_assertThisInitialized(_this), _children2, cmi_children ? cmi_children : scorm12_constants.cmi_children); + + _this.core = new CMICore(); + _this.objectives = new CMIObjectives(); + _this.student_data = student_data ? student_data : new CMIStudentData(); + _this.student_preference = new CMIStudentPreference(); + _this.interactions = new CMIInteractions(); + return _this; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(CMI, [{ + key: "initialize", + value: function initialize() { + var _this$core, _this$objectives, _this$student_data, _this$student_prefere, _this$interactions; + + _get(_getPrototypeOf(CMI.prototype), "initialize", this).call(this); + + (_this$core = this.core) === null || _this$core === void 0 ? void 0 : _this$core.initialize(); + (_this$objectives = this.objectives) === null || _this$objectives === void 0 ? void 0 : _this$objectives.initialize(); + (_this$student_data = this.student_data) === null || _this$student_data === void 0 ? void 0 : _this$student_data.initialize(); + (_this$student_prefere = this.student_preference) === null || _this$student_prefere === void 0 ? void 0 : _this$student_prefere.initialize(); + (_this$interactions = this.interactions) === null || _this$interactions === void 0 ? void 0 : _this$interactions.initialize(); + } + /** + * toJSON for cmi + * + * @return { + * { + * suspend_data: string, + * launch_data: string, + * comments: string, + * comments_from_lms: string, + * core: CMICore, + * objectives: CMIObjectives, + * student_data: CMIStudentData, + * student_preference: CMIStudentPreference, + * interactions: CMIInteractions + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'suspend_data': this.suspend_data, + 'launch_data': this.launch_data, + 'comments': this.comments, + 'comments_from_lms': this.comments_from_lms, + 'core': this.core, + 'objectives': this.objectives, + 'student_data': this.student_data, + 'student_preference': this.student_preference, + 'interactions': this.interactions + }; + delete this.jsonString; + return result; + } + /** + * Getter for #_version + * @return {string} + */ + + }, { + key: "_version", + get: function get() { + return _classPrivateFieldGet(this, _version2); + } + /** + * Setter for #_version. Just throws an error. + * @param {string} _version + */ + , + set: function set(_version) { + throwInvalidValueError(); + } + /** + * Getter for #_children + * @return {string} + */ + + }, { + key: "_children", + get: function get() { + return _classPrivateFieldGet(this, _children2); + } + /** + * Setter for #_version. Just throws an error. + * @param {string} _children + */ + , + set: function set(_children) { + throwInvalidValueError(); + } + /** + * Getter for #suspend_data + * @return {string} + */ + + }, { + key: "suspend_data", + get: function get() { + var _this$core2; + + return (_this$core2 = this.core) === null || _this$core2 === void 0 ? void 0 : _this$core2.suspend_data; + } + /** + * Setter for #suspend_data + * @param {string} suspend_data + */ + , + set: function set(suspend_data) { + if (this.core) { + this.core.suspend_data = suspend_data; + } + } + /** + * Getter for #launch_data + * @return {string} + */ + + }, { + key: "launch_data", + get: function get() { + return _classPrivateFieldGet(this, _launch_data); + } + /** + * Setter for #launch_data. Can only be called before initialization. + * @param {string} launch_data + */ + , + set: function set(launch_data) { + !this.initialized ? _classPrivateFieldSet(this, _launch_data, launch_data) : throwReadOnlyError(); + } + /** + * Getter for #comments + * @return {string} + */ + + }, { + key: "comments", + get: function get() { + return _classPrivateFieldGet(this, _comments); + } + /** + * Setter for #comments + * @param {string} comments + */ + , + set: function set(comments) { + if (check12ValidFormat(comments, scorm12_regex.CMIString4096, true)) { + _classPrivateFieldSet(this, _comments, comments); + } + } + /** + * Getter for #comments_from_lms + * @return {string} + */ + + }, { + key: "comments_from_lms", + get: function get() { + return _classPrivateFieldGet(this, _comments_from_lms); + } + /** + * Setter for #comments_from_lms. Can only be called before initialization. + * @param {string} comments_from_lms + */ + , + set: function set(comments_from_lms) { + !this.initialized ? _classPrivateFieldSet(this, _comments_from_lms, comments_from_lms) : throwReadOnlyError(); + } + /** + * Adds the current session time to the existing total time. + * + * @return {string} + */ + + }, { + key: "getCurrentTotalTime", + value: function getCurrentTotalTime() { + return this.core.getCurrentTotalTime(this.start_time); + } + }]); + + return CMI; +}(_common.BaseCMI); +/** + * Class representing the cmi.core object + * @extends BaseCMI + */ + + +exports.CMI = CMI; + +var _children3 = new WeakMap(); + +var _student_id = new WeakMap(); + +var _student_name = new WeakMap(); + +var _lesson_location = new WeakMap(); + +var _credit = new WeakMap(); + +var _lesson_status = new WeakMap(); + +var _entry = new WeakMap(); + +var _total_time = new WeakMap(); + +var _lesson_mode = new WeakMap(); + +var _exit = new WeakMap(); + +var _session_time = new WeakMap(); + +var _suspend_data = new WeakMap(); + +var CMICore = /*#__PURE__*/function (_BaseCMI2) { + _inherits(CMICore, _BaseCMI2); + + var _super2 = _createSuper(CMICore); + + /** + * Constructor for cmi.core + */ + function CMICore() { + var _this2; + + _classCallCheck(this, CMICore); + + _this2 = _super2.call(this); + + _children3.set(_assertThisInitialized(_this2), { + writable: true, + value: scorm12_constants.core_children + }); + + _student_id.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _student_name.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _lesson_location.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _credit.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _lesson_status.set(_assertThisInitialized(_this2), { + writable: true, + value: 'not attempted' + }); + + _entry.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _total_time.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _lesson_mode.set(_assertThisInitialized(_this2), { + writable: true, + value: 'normal' + }); + + _exit.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _session_time.set(_assertThisInitialized(_this2), { + writable: true, + value: '00:00:00' + }); + + _suspend_data.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _this2.score = new _common.CMIScore({ + score_children: scorm12_constants.score_children, + score_range: scorm12_regex.score_range, + invalidErrorCode: scorm12_error_codes.INVALID_SET_VALUE, + invalidTypeCode: scorm12_error_codes.TYPE_MISMATCH, + invalidRangeCode: scorm12_error_codes.VALUE_OUT_OF_RANGE, + errorClass: _exceptions.Scorm12ValidationError + }); + return _this2; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(CMICore, [{ + key: "initialize", + value: function initialize() { + var _this$score; + + _get(_getPrototypeOf(CMICore.prototype), "initialize", this).call(this); + + (_this$score = this.score) === null || _this$score === void 0 ? void 0 : _this$score.initialize(); + } + }, { + key: "_children", + get: + /** + * Getter for #_children + * @return {string} + * @private + */ + function get() { + return _classPrivateFieldGet(this, _children3); + } + /** + * Setter for #_children. Just throws an error. + * @param {string} _children + * @private + */ + , + set: function set(_children) { + throwInvalidValueError(); + } + /** + * Getter for #student_id + * @return {string} + */ + + }, { + key: "student_id", + get: function get() { + return _classPrivateFieldGet(this, _student_id); + } + /** + * Setter for #student_id. Can only be called before initialization. + * @param {string} student_id + */ + , + set: function set(student_id) { + !this.initialized ? _classPrivateFieldSet(this, _student_id, student_id) : throwReadOnlyError(); + } + /** + * Getter for #student_name + * @return {string} + */ + + }, { + key: "student_name", + get: function get() { + return _classPrivateFieldGet(this, _student_name); + } + /** + * Setter for #student_name. Can only be called before initialization. + * @param {string} student_name + */ + , + set: function set(student_name) { + !this.initialized ? _classPrivateFieldSet(this, _student_name, student_name) : throwReadOnlyError(); + } + /** + * Getter for #lesson_location + * @return {string} + */ + + }, { + key: "lesson_location", + get: function get() { + return _classPrivateFieldGet(this, _lesson_location); + } + /** + * Setter for #lesson_location + * @param {string} lesson_location + */ + , + set: function set(lesson_location) { + if (check12ValidFormat(lesson_location, scorm12_regex.CMIString256, true)) { + _classPrivateFieldSet(this, _lesson_location, lesson_location); + } + } + /** + * Getter for #credit + * @return {string} + */ + + }, { + key: "credit", + get: function get() { + return _classPrivateFieldGet(this, _credit); + } + /** + * Setter for #credit. Can only be called before initialization. + * @param {string} credit + */ + , + set: function set(credit) { + !this.initialized ? _classPrivateFieldSet(this, _credit, credit) : throwReadOnlyError(); + } + /** + * Getter for #lesson_status + * @return {string} + */ + + }, { + key: "lesson_status", + get: function get() { + return _classPrivateFieldGet(this, _lesson_status); + } + /** + * Setter for #lesson_status + * @param {string} lesson_status + */ + , + set: function set(lesson_status) { + if (this.initialized) { + if (check12ValidFormat(lesson_status, scorm12_regex.CMIStatus)) { + _classPrivateFieldSet(this, _lesson_status, lesson_status); + } + } else { + if (check12ValidFormat(lesson_status, scorm12_regex.CMIStatus2)) { + _classPrivateFieldSet(this, _lesson_status, lesson_status); + } + } + } + /** + * Getter for #entry + * @return {string} + */ + + }, { + key: "entry", + get: function get() { + return _classPrivateFieldGet(this, _entry); + } + /** + * Setter for #entry. Can only be called before initialization. + * @param {string} entry + */ + , + set: function set(entry) { + !this.initialized ? _classPrivateFieldSet(this, _entry, entry) : throwReadOnlyError(); + } + /** + * Getter for #total_time + * @return {string} + */ + + }, { + key: "total_time", + get: function get() { + return _classPrivateFieldGet(this, _total_time); + } + /** + * Setter for #total_time. Can only be called before initialization. + * @param {string} total_time + */ + , + set: function set(total_time) { + !this.initialized ? _classPrivateFieldSet(this, _total_time, total_time) : throwReadOnlyError(); + } + /** + * Getter for #lesson_mode + * @return {string} + */ + + }, { + key: "lesson_mode", + get: function get() { + return _classPrivateFieldGet(this, _lesson_mode); + } + /** + * Setter for #lesson_mode. Can only be called before initialization. + * @param {string} lesson_mode + */ + , + set: function set(lesson_mode) { + !this.initialized ? _classPrivateFieldSet(this, _lesson_mode, lesson_mode) : throwReadOnlyError(); + } + /** + * Getter for #exit. Should only be called during JSON export. + * @return {*} + */ + + }, { + key: "exit", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _exit); + } + /** + * Setter for #exit + * @param {string} exit + */ + , + set: function set(exit) { + if (check12ValidFormat(exit, scorm12_regex.CMIExit, true)) { + _classPrivateFieldSet(this, _exit, exit); + } + } + /** + * Getter for #session_time. Should only be called during JSON export. + * @return {*} + */ + + }, { + key: "session_time", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _session_time); + } + /** + * Setter for #session_time + * @param {string} session_time + */ + , + set: function set(session_time) { + if (check12ValidFormat(session_time, scorm12_regex.CMITimespan)) { + _classPrivateFieldSet(this, _session_time, session_time); + } + } + /** + * Getter for #suspend_data + * @return {string} + */ + + }, { + key: "suspend_data", + get: function get() { + return _classPrivateFieldGet(this, _suspend_data); + } + /** + * Setter for #suspend_data + * @param {string} suspend_data + */ + , + set: function set(suspend_data) { + if (check12ValidFormat(suspend_data, scorm12_regex.CMIString4096, true)) { + _classPrivateFieldSet(this, _suspend_data, suspend_data); + } + } + /** + * Adds the current session time to the existing total time. + * @param {Number} start_time + * @return {string} + */ + + }, { + key: "getCurrentTotalTime", + value: function getCurrentTotalTime(start_time) { + var sessionTime = _classPrivateFieldGet(this, _session_time); + + var startTime = start_time; + + if (typeof startTime !== 'undefined' && startTime !== null) { + var seconds = new Date().getTime() - startTime; + sessionTime = Util.getSecondsAsHHMMSS(seconds / 1000); + } + + return Utilities.addHHMMSSTimeStrings(_classPrivateFieldGet(this, _total_time), sessionTime, new RegExp(scorm12_regex.CMITimespan)); + } + /** + * toJSON for cmi.core + * + * @return { + * { + * student_name: string, + * entry: string, + * exit: string, + * score: CMIScore, + * student_id: string, + * lesson_mode: string, + * lesson_location: string, + * lesson_status: string, + * credit: string, + * session_time: * + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'student_id': this.student_id, + 'student_name': this.student_name, + 'lesson_location': this.lesson_location, + 'credit': this.credit, + 'lesson_status': this.lesson_status, + 'entry': this.entry, + 'lesson_mode': this.lesson_mode, + 'exit': this.exit, + 'session_time': this.session_time, + 'score': this.score + }; + delete this.jsonString; + return result; + } + }]); + + return CMICore; +}(_common.BaseCMI); +/** + * Class representing SCORM 1.2's cmi.objectives object + * @extends CMIArray + */ + + +var CMIObjectives = /*#__PURE__*/function (_CMIArray) { + _inherits(CMIObjectives, _CMIArray); + + var _super3 = _createSuper(CMIObjectives); + + /** + * Constructor for cmi.objectives + */ + function CMIObjectives() { + _classCallCheck(this, CMIObjectives); + + return _super3.call(this, { + children: scorm12_constants.objectives_children, + errorCode: scorm12_error_codes.INVALID_SET_VALUE, + errorClass: _exceptions.Scorm12ValidationError + }); + } + + return CMIObjectives; +}(_common.CMIArray); +/** + * Class representing SCORM 1.2's cmi.student_data object + * @extends BaseCMI + */ + + +var _children4 = new WeakMap(); + +var _mastery_score = new WeakMap(); + +var _max_time_allowed = new WeakMap(); + +var _time_limit_action = new WeakMap(); + +var CMIStudentData = /*#__PURE__*/function (_BaseCMI3) { + _inherits(CMIStudentData, _BaseCMI3); + + var _super4 = _createSuper(CMIStudentData); + + /** + * Constructor for cmi.student_data + * @param {string} student_data_children + */ + function CMIStudentData(student_data_children) { + var _this3; + + _classCallCheck(this, CMIStudentData); + + _this3 = _super4.call(this); + + _children4.set(_assertThisInitialized(_this3), { + writable: true, + value: void 0 + }); + + _mastery_score.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _max_time_allowed.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _time_limit_action.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _classPrivateFieldSet(_assertThisInitialized(_this3), _children4, student_data_children ? student_data_children : scorm12_constants.student_data_children); + + return _this3; + } + /** + * Getter for #_children + * @return {*} + * @private + */ + + + _createClass(CMIStudentData, [{ + key: "_children", + get: function get() { + return _classPrivateFieldGet(this, _children4); + } + /** + * Setter for #_children. Just throws an error. + * @param {string} _children + * @private + */ + , + set: function set(_children) { + throwInvalidValueError(); + } + /** + * Getter for #master_score + * @return {string} + */ + + }, { + key: "mastery_score", + get: function get() { + return _classPrivateFieldGet(this, _mastery_score); + } + /** + * Setter for #master_score. Can only be called before initialization. + * @param {string} mastery_score + */ + , + set: function set(mastery_score) { + !this.initialized ? _classPrivateFieldSet(this, _mastery_score, mastery_score) : throwReadOnlyError(); + } + /** + * Getter for #max_time_allowed + * @return {string} + */ + + }, { + key: "max_time_allowed", + get: function get() { + return _classPrivateFieldGet(this, _max_time_allowed); + } + /** + * Setter for #max_time_allowed. Can only be called before initialization. + * @param {string} max_time_allowed + */ + , + set: function set(max_time_allowed) { + !this.initialized ? _classPrivateFieldSet(this, _max_time_allowed, max_time_allowed) : throwReadOnlyError(); + } + /** + * Getter for #time_limit_action + * @return {string} + */ + + }, { + key: "time_limit_action", + get: function get() { + return _classPrivateFieldGet(this, _time_limit_action); + } + /** + * Setter for #time_limit_action. Can only be called before initialization. + * @param {string} time_limit_action + */ + , + set: function set(time_limit_action) { + !this.initialized ? _classPrivateFieldSet(this, _time_limit_action, time_limit_action) : throwReadOnlyError(); + } + /** + * toJSON for cmi.student_data + * + * @return { + * { + * max_time_allowed: string, + * time_limit_action: string, + * mastery_score: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'mastery_score': this.mastery_score, + 'max_time_allowed': this.max_time_allowed, + 'time_limit_action': this.time_limit_action + }; + delete this.jsonString; + return result; + } + }]); + + return CMIStudentData; +}(_common.BaseCMI); +/** + * Class representing SCORM 1.2's cmi.student_preference object + * @extends BaseCMI + */ + + +exports.CMIStudentData = CMIStudentData; + +var _children5 = new WeakMap(); + +var _audio = new WeakMap(); + +var _language = new WeakMap(); + +var _speed = new WeakMap(); + +var _text = new WeakMap(); + +var CMIStudentPreference = /*#__PURE__*/function (_BaseCMI4) { + _inherits(CMIStudentPreference, _BaseCMI4); + + var _super5 = _createSuper(CMIStudentPreference); + + /** + * Constructor for cmi.student_preference + * @param {string} student_preference_children + */ + function CMIStudentPreference(student_preference_children) { + var _this4; + + _classCallCheck(this, CMIStudentPreference); + + _this4 = _super5.call(this); + + _children5.set(_assertThisInitialized(_this4), { + writable: true, + value: void 0 + }); + + _audio.set(_assertThisInitialized(_this4), { + writable: true, + value: '' + }); + + _language.set(_assertThisInitialized(_this4), { + writable: true, + value: '' + }); + + _speed.set(_assertThisInitialized(_this4), { + writable: true, + value: '' + }); + + _text.set(_assertThisInitialized(_this4), { + writable: true, + value: '' + }); + + _classPrivateFieldSet(_assertThisInitialized(_this4), _children5, student_preference_children ? student_preference_children : scorm12_constants.student_preference_children); + + return _this4; + } + + _createClass(CMIStudentPreference, [{ + key: "_children", + get: + /** + * Getter for #_children + * @return {string} + * @private + */ + function get() { + return _classPrivateFieldGet(this, _children5); + } + /** + * Setter for #_children. Just throws an error. + * @param {string} _children + * @private + */ + , + set: function set(_children) { + throwInvalidValueError(); + } + /** + * Getter for #audio + * @return {string} + */ + + }, { + key: "audio", + get: function get() { + return _classPrivateFieldGet(this, _audio); + } + /** + * Setter for #audio + * @param {string} audio + */ + , + set: function set(audio) { + if (check12ValidFormat(audio, scorm12_regex.CMISInteger) && check12ValidRange(audio, scorm12_regex.audio_range)) { + _classPrivateFieldSet(this, _audio, audio); + } + } + /** + * Getter for #language + * @return {string} + */ + + }, { + key: "language", + get: function get() { + return _classPrivateFieldGet(this, _language); + } + /** + * Setter for #language + * @param {string} language + */ + , + set: function set(language) { + if (check12ValidFormat(language, scorm12_regex.CMIString256)) { + _classPrivateFieldSet(this, _language, language); + } + } + /** + * Getter for #speed + * @return {string} + */ + + }, { + key: "speed", + get: function get() { + return _classPrivateFieldGet(this, _speed); + } + /** + * Setter for #speed + * @param {string} speed + */ + , + set: function set(speed) { + if (check12ValidFormat(speed, scorm12_regex.CMISInteger) && check12ValidRange(speed, scorm12_regex.speed_range)) { + _classPrivateFieldSet(this, _speed, speed); + } + } + /** + * Getter for #text + * @return {string} + */ + + }, { + key: "text", + get: function get() { + return _classPrivateFieldGet(this, _text); + } + /** + * Setter for #text + * @param {string} text + */ + , + set: function set(text) { + if (check12ValidFormat(text, scorm12_regex.CMISInteger) && check12ValidRange(text, scorm12_regex.text_range)) { + _classPrivateFieldSet(this, _text, text); + } + } + /** + * toJSON for cmi.student_preference + * + * @return { + * { + * audio: string, + * language: string, + * speed: string, + * text: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'audio': this.audio, + 'language': this.language, + 'speed': this.speed, + 'text': this.text + }; + delete this.jsonString; + return result; + } + }]); + + return CMIStudentPreference; +}(_common.BaseCMI); +/** + * Class representing SCORM 1.2's cmi.interactions object + * @extends BaseCMI + */ + + +exports.CMIStudentPreference = CMIStudentPreference; + +var CMIInteractions = /*#__PURE__*/function (_CMIArray2) { + _inherits(CMIInteractions, _CMIArray2); + + var _super6 = _createSuper(CMIInteractions); + + /** + * Constructor for cmi.interactions + */ + function CMIInteractions() { + _classCallCheck(this, CMIInteractions); + + return _super6.call(this, { + children: scorm12_constants.interactions_children, + errorCode: scorm12_error_codes.INVALID_SET_VALUE, + errorClass: _exceptions.Scorm12ValidationError + }); + } + + return CMIInteractions; +}(_common.CMIArray); +/** + * Class representing SCORM 1.2's cmi.interactions.n object + * @extends BaseCMI + */ + + +var _id = new WeakMap(); + +var _time = new WeakMap(); + +var _type = new WeakMap(); + +var _weighting = new WeakMap(); + +var _student_response = new WeakMap(); + +var _result = new WeakMap(); + +var _latency = new WeakMap(); + +var CMIInteractionsObject = /*#__PURE__*/function (_BaseCMI5) { + _inherits(CMIInteractionsObject, _BaseCMI5); + + var _super7 = _createSuper(CMIInteractionsObject); + + /** + * Constructor for cmi.interactions.n object + */ + function CMIInteractionsObject() { + var _this5; + + _classCallCheck(this, CMIInteractionsObject); + + _this5 = _super7.call(this); + + _id.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _time.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _type.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _weighting.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _student_response.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _result.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _latency.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + _this5.objectives = new _common.CMIArray({ + errorCode: scorm12_error_codes.INVALID_SET_VALUE, + errorClass: _exceptions.Scorm12ValidationError, + children: scorm12_constants.objectives_children + }); + _this5.correct_responses = new _common.CMIArray({ + errorCode: scorm12_error_codes.INVALID_SET_VALUE, + errorClass: _exceptions.Scorm12ValidationError, + children: scorm12_constants.correct_responses_children + }); + return _this5; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(CMIInteractionsObject, [{ + key: "initialize", + value: function initialize() { + var _this$objectives2, _this$correct_respons; + + _get(_getPrototypeOf(CMIInteractionsObject.prototype), "initialize", this).call(this); + + (_this$objectives2 = this.objectives) === null || _this$objectives2 === void 0 ? void 0 : _this$objectives2.initialize(); + (_this$correct_respons = this.correct_responses) === null || _this$correct_respons === void 0 ? void 0 : _this$correct_respons.initialize(); + } + }, { + key: "id", + get: + /** + * Getter for #id. Should only be called during JSON export. + * @return {*} + */ + function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _id); + } + /** + * Setter for #id + * @param {string} id + */ + , + set: function set(id) { + if (check12ValidFormat(id, scorm12_regex.CMIIdentifier)) { + _classPrivateFieldSet(this, _id, id); + } + } + /** + * Getter for #time. Should only be called during JSON export. + * @return {*} + */ + + }, { + key: "time", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _time); + } + /** + * Setter for #time + * @param {string} time + */ + , + set: function set(time) { + if (check12ValidFormat(time, scorm12_regex.CMITime)) { + _classPrivateFieldSet(this, _time, time); + } + } + /** + * Getter for #type. Should only be called during JSON export. + * @return {*} + */ + + }, { + key: "type", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _type); + } + /** + * Setter for #type + * @param {string} type + */ + , + set: function set(type) { + if (check12ValidFormat(type, scorm12_regex.CMIType)) { + _classPrivateFieldSet(this, _type, type); + } + } + /** + * Getter for #weighting. Should only be called during JSON export. + * @return {*} + */ + + }, { + key: "weighting", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _weighting); + } + /** + * Setter for #weighting + * @param {string} weighting + */ + , + set: function set(weighting) { + if (check12ValidFormat(weighting, scorm12_regex.CMIDecimal) && check12ValidRange(weighting, scorm12_regex.weighting_range)) { + _classPrivateFieldSet(this, _weighting, weighting); + } + } + /** + * Getter for #student_response. Should only be called during JSON export. + * @return {*} + */ + + }, { + key: "student_response", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _student_response); + } + /** + * Setter for #student_response + * @param {string} student_response + */ + , + set: function set(student_response) { + if (check12ValidFormat(student_response, scorm12_regex.CMIFeedback, true)) { + _classPrivateFieldSet(this, _student_response, student_response); + } + } + /** + * Getter for #result. Should only be called during JSON export. + * @return {*} + */ + + }, { + key: "result", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _result); + } + /** + * Setter for #result + * @param {string} result + */ + , + set: function set(result) { + if (check12ValidFormat(result, scorm12_regex.CMIResult)) { + _classPrivateFieldSet(this, _result, result); + } + } + /** + * Getter for #latency. Should only be called during JSON export. + * @return {*} + */ + + }, { + key: "latency", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _latency); + } + /** + * Setter for #latency + * @param {string} latency + */ + , + set: function set(latency) { + if (check12ValidFormat(latency, scorm12_regex.CMITimespan)) { + _classPrivateFieldSet(this, _latency, latency); + } + } + /** + * toJSON for cmi.interactions.n + * + * @return { + * { + * id: string, + * time: string, + * type: string, + * weighting: string, + * student_response: string, + * result: string, + * latency: string, + * objectives: CMIArray, + * correct_responses: CMIArray + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'id': this.id, + 'time': this.time, + 'type': this.type, + 'weighting': this.weighting, + 'student_response': this.student_response, + 'result': this.result, + 'latency': this.latency, + 'objectives': this.objectives, + 'correct_responses': this.correct_responses + }; + delete this.jsonString; + return result; + } + }]); + + return CMIInteractionsObject; +}(_common.BaseCMI); +/** + * Class representing SCORM 1.2's cmi.objectives.n object + * @extends BaseCMI + */ + + +exports.CMIInteractionsObject = CMIInteractionsObject; + +var _id2 = new WeakMap(); + +var _status = new WeakMap(); + +var CMIObjectivesObject = /*#__PURE__*/function (_BaseCMI6) { + _inherits(CMIObjectivesObject, _BaseCMI6); + + var _super8 = _createSuper(CMIObjectivesObject); + + /** + * Constructor for cmi.objectives.n + */ + function CMIObjectivesObject() { + var _this6; + + _classCallCheck(this, CMIObjectivesObject); + + _this6 = _super8.call(this); + + _id2.set(_assertThisInitialized(_this6), { + writable: true, + value: '' + }); + + _status.set(_assertThisInitialized(_this6), { + writable: true, + value: '' + }); + + _this6.score = new _common.CMIScore({ + score_children: scorm12_constants.score_children, + score_range: scorm12_regex.score_range, + invalidErrorCode: scorm12_error_codes.INVALID_SET_VALUE, + invalidTypeCode: scorm12_error_codes.TYPE_MISMATCH, + invalidRangeCode: scorm12_error_codes.VALUE_OUT_OF_RANGE, + errorClass: _exceptions.Scorm12ValidationError + }); + return _this6; + } + + _createClass(CMIObjectivesObject, [{ + key: "id", + get: + /** + * Getter for #id + * @return {""} + */ + function get() { + return _classPrivateFieldGet(this, _id2); + } + /** + * Setter for #id + * @param {string} id + */ + , + set: function set(id) { + if (check12ValidFormat(id, scorm12_regex.CMIIdentifier)) { + _classPrivateFieldSet(this, _id2, id); + } + } + /** + * Getter for #status + * @return {""} + */ + + }, { + key: "status", + get: function get() { + return _classPrivateFieldGet(this, _status); + } + /** + * Setter for #status + * @param {string} status + */ + , + set: function set(status) { + if (check12ValidFormat(status, scorm12_regex.CMIStatus2)) { + _classPrivateFieldSet(this, _status, status); + } + } + /** + * toJSON for cmi.objectives.n + * @return { + * { + * id: string, + * status: string, + * score: CMIScore + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'id': this.id, + 'status': this.status, + 'score': this.score + }; + delete this.jsonString; + return result; + } + }]); + + return CMIObjectivesObject; +}(_common.BaseCMI); +/** + * Class representing SCORM 1.2's cmi.interactions.n.objectives.n object + * @extends BaseCMI + */ + + +exports.CMIObjectivesObject = CMIObjectivesObject; + +var _id3 = new WeakMap(); + +var CMIInteractionsObjectivesObject = /*#__PURE__*/function (_BaseCMI7) { + _inherits(CMIInteractionsObjectivesObject, _BaseCMI7); + + var _super9 = _createSuper(CMIInteractionsObjectivesObject); + + /** + * Constructor for cmi.interactions.n.objectives.n + */ + function CMIInteractionsObjectivesObject() { + var _this7; + + _classCallCheck(this, CMIInteractionsObjectivesObject); + + _this7 = _super9.call(this); + + _id3.set(_assertThisInitialized(_this7), { + writable: true, + value: '' + }); + + return _this7; + } + + _createClass(CMIInteractionsObjectivesObject, [{ + key: "id", + get: + /** + * Getter for #id + * @return {""} + */ + function get() { + return _classPrivateFieldGet(this, _id3); + } + /** + * Setter for #id + * @param {string} id + */ + , + set: function set(id) { + if (check12ValidFormat(id, scorm12_regex.CMIIdentifier)) { + _classPrivateFieldSet(this, _id3, id); + } + } + /** + * toJSON for cmi.interactions.n.objectives.n + * @return { + * { + * id: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'id': this.id + }; + delete this.jsonString; + return result; + } + }]); + + return CMIInteractionsObjectivesObject; +}(_common.BaseCMI); +/** + * Class representing SCORM 1.2's cmi.interactions.correct_responses.n object + * @extends BaseCMI + */ + + +exports.CMIInteractionsObjectivesObject = CMIInteractionsObjectivesObject; + +var _pattern = new WeakMap(); + +var CMIInteractionsCorrectResponsesObject = /*#__PURE__*/function (_BaseCMI8) { + _inherits(CMIInteractionsCorrectResponsesObject, _BaseCMI8); + + var _super10 = _createSuper(CMIInteractionsCorrectResponsesObject); + + /** + * Constructor for cmi.interactions.correct_responses.n + */ + function CMIInteractionsCorrectResponsesObject() { + var _this8; + + _classCallCheck(this, CMIInteractionsCorrectResponsesObject); + + _this8 = _super10.call(this); + + _pattern.set(_assertThisInitialized(_this8), { + writable: true, + value: '' + }); + + return _this8; + } + + _createClass(CMIInteractionsCorrectResponsesObject, [{ + key: "pattern", + get: + /** + * Getter for #pattern + * @return {string} + */ + function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _pattern); + } + /** + * Setter for #pattern + * @param {string} pattern + */ + , + set: function set(pattern) { + if (check12ValidFormat(pattern, scorm12_regex.CMIFeedback, true)) { + _classPrivateFieldSet(this, _pattern, pattern); + } + } + /** + * toJSON for cmi.interactions.correct_responses.n + * @return { + * { + * pattern: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'pattern': this.pattern + }; + delete this.jsonString; + return result; + } + }]); + + return CMIInteractionsCorrectResponsesObject; +}(_common.BaseCMI); +/** + * Class for AICC Navigation object + */ + + +exports.CMIInteractionsCorrectResponsesObject = CMIInteractionsCorrectResponsesObject; + +var _event = new WeakMap(); + +var NAV = /*#__PURE__*/function (_BaseCMI9) { + _inherits(NAV, _BaseCMI9); + + var _super11 = _createSuper(NAV); + + /** + * Constructor for NAV object + */ + function NAV() { + var _this9; + + _classCallCheck(this, NAV); + + _this9 = _super11.call(this); + + _event.set(_assertThisInitialized(_this9), { + writable: true, + value: '' + }); + + return _this9; + } + + _createClass(NAV, [{ + key: "event", + get: + /** + * Getter for #event + * @return {string} + */ + function get() { + return _classPrivateFieldGet(this, _event); + } + /** + * Setter for #event + * @param {string} event + */ + , + set: function set(event) { + if (check12ValidFormat(event, scorm12_regex.NAVEvent)) { + _classPrivateFieldSet(this, _event, event); + } + } + /** + * toJSON for nav object + * @return { + * { + * event: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'event': this.event + }; + delete this.jsonString; + return result; + } + }]); + + return NAV; +}(_common.BaseCMI); + +exports.NAV = NAV; + +},{"../constants/api_constants":6,"../constants/error_codes":7,"../constants/regex":8,"../exceptions":9,"../utilities":11,"./common":4}],6:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var global = { + SCORM_TRUE: 'true', + SCORM_FALSE: 'false', + STATE_NOT_INITIALIZED: 0, + STATE_INITIALIZED: 1, + STATE_TERMINATED: 2, + LOG_LEVEL_DEBUG: 1, + LOG_LEVEL_INFO: 2, + LOG_LEVEL_WARNING: 3, + LOG_LEVEL_ERROR: 4, + LOG_LEVEL_NONE: 5 +}; +var scorm12 = { + // Children lists + cmi_children: 'core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions', + core_children: 'student_id,student_name,lesson_location,credit,lesson_status,entry,score,total_time,lesson_mode,exit,session_time', + score_children: 'raw,min,max', + comments_children: 'content,location,time', + objectives_children: 'id,score,status', + correct_responses_children: 'pattern', + student_data_children: 'mastery_score,max_time_allowed,time_limit_action', + student_preference_children: 'audio,language,speed,text', + interactions_children: 'id,objectives,time,type,correct_responses,weighting,student_response,result,latency', + error_descriptions: { + '101': { + basicMessage: 'General Exception', + detailMessage: 'No specific error code exists to describe the error. Use LMSGetDiagnostic for more information' + }, + '201': { + basicMessage: 'Invalid argument error', + detailMessage: 'Indicates that an argument represents an invalid data model element or is otherwise incorrect.' + }, + '202': { + basicMessage: 'Element cannot have children', + detailMessage: 'Indicates that LMSGetValue was called with a data model element name that ends in "_children" for a data model element that does not support the "_children" suffix.' + }, + '203': { + basicMessage: 'Element not an array - cannot have count', + detailMessage: 'Indicates that LMSGetValue was called with a data model element name that ends in "_count" for a data model element that does not support the "_count" suffix.' + }, + '301': { + basicMessage: 'Not initialized', + detailMessage: 'Indicates that an API call was made before the call to lmsInitialize.' + }, + '401': { + basicMessage: 'Not implemented error', + detailMessage: 'The data model element indicated in a call to LMSGetValue or LMSSetValue is valid, but was not implemented by this LMS. SCORM 1.2 defines a set of data model elements as being optional for an LMS to implement.' + }, + '402': { + basicMessage: 'Invalid set value, element is a keyword', + detailMessage: 'Indicates that LMSSetValue was called on a data model element that represents a keyword (elements that end in "_children" and "_count").' + }, + '403': { + basicMessage: 'Element is read only', + detailMessage: 'LMSSetValue was called with a data model element that can only be read.' + }, + '404': { + basicMessage: 'Element is write only', + detailMessage: 'LMSGetValue was called on a data model element that can only be written to.' + }, + '405': { + basicMessage: 'Incorrect Data Type', + detailMessage: 'LMSSetValue was called with a value that is not consistent with the data format of the supplied data model element.' + }, + '407': { + basicMessage: 'Element Value Out Of Range', + detailMessage: 'The numeric value supplied to a LMSSetValue call is outside of the numeric range allowed for the supplied data model element.' + }, + '408': { + basicMessage: 'Data Model Dependency Not Established', + detailMessage: 'Some data model elements cannot be set until another data model element was set. This error condition indicates that the prerequisite element was not set before the dependent element.' + } + } +}; + +var aicc = _objectSpread(_objectSpread({}, scorm12), { + cmi_children: 'core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions,evaluation', + student_preference_children: 'audio,language,lesson_type,speed,text,text_color,text_location,text_size,video,windows', + student_data_children: 'attempt_number,tries,mastery_score,max_time_allowed,time_limit_action', + student_demographics_children: 'city,class,company,country,experience,familiar_name,instructor_name,title,native_language,state,street_address,telephone,years_experience', + tries_children: 'time,status,score', + attempt_records_children: 'score,lesson_status', + paths_children: 'location_id,date,time,status,why_left,time_in_element' +}); + +var scorm2004 = { + // Children lists + cmi_children: '_version,comments_from_learner,comments_from_lms,completion_status,credit,entry,exit,interactions,launch_data,learner_id,learner_name,learner_preference,location,max_time_allowed,mode,objectives,progress_measure,scaled_passing_score,score,session_time,success_status,suspend_data,time_limit_action,total_time', + comments_children: 'comment,timestamp,location', + score_children: 'max,raw,scaled,min', + objectives_children: 'progress_measure,completion_status,success_status,description,score,id', + correct_responses_children: 'pattern', + student_data_children: 'mastery_score,max_time_allowed,time_limit_action', + student_preference_children: 'audio_level,audio_captioning,delivery_speed,language', + interactions_children: 'id,type,objectives,timestamp,correct_responses,weighting,learner_response,result,latency,description', + error_descriptions: { + '0': { + basicMessage: 'No Error', + detailMessage: 'No error occurred, the previous API call was successful.' + }, + '101': { + basicMessage: 'General Exception', + detailMessage: 'No specific error code exists to describe the error. Use GetDiagnostic for more information.' + }, + '102': { + basicMessage: 'General Initialization Failure', + detailMessage: 'Call to Initialize failed for an unknown reason.' + }, + '103': { + basicMessage: 'Already Initialized', + detailMessage: 'Call to Initialize failed because Initialize was already called.' + }, + '104': { + basicMessage: 'Content Instance Terminated', + detailMessage: 'Call to Initialize failed because Terminate was already called.' + }, + '111': { + basicMessage: 'General Termination Failure', + detailMessage: 'Call to Terminate failed for an unknown reason.' + }, + '112': { + basicMessage: 'Termination Before Initialization', + detailMessage: 'Call to Terminate failed because it was made before the call to Initialize.' + }, + '113': { + basicMessage: 'Termination After Termination', + detailMessage: 'Call to Terminate failed because Terminate was already called.' + }, + '122': { + basicMessage: 'Retrieve Data Before Initialization', + detailMessage: 'Call to GetValue failed because it was made before the call to Initialize.' + }, + '123': { + basicMessage: 'Retrieve Data After Termination', + detailMessage: 'Call to GetValue failed because it was made after the call to Terminate.' + }, + '132': { + basicMessage: 'Store Data Before Initialization', + detailMessage: 'Call to SetValue failed because it was made before the call to Initialize.' + }, + '133': { + basicMessage: 'Store Data After Termination', + detailMessage: 'Call to SetValue failed because it was made after the call to Terminate.' + }, + '142': { + basicMessage: 'Commit Before Initialization', + detailMessage: 'Call to Commit failed because it was made before the call to Initialize.' + }, + '143': { + basicMessage: 'Commit After Termination', + detailMessage: 'Call to Commit failed because it was made after the call to Terminate.' + }, + '201': { + basicMessage: 'General Argument Error', + detailMessage: 'An invalid argument was passed to an API method (usually indicates that Initialize, Commit or Terminate did not receive the expected empty string argument.' + }, + '301': { + basicMessage: 'General Get Failure', + detailMessage: 'Indicates a failed GetValue call where no other specific error code is applicable. Use GetDiagnostic for more information.' + }, + '351': { + basicMessage: 'General Set Failure', + detailMessage: 'Indicates a failed SetValue call where no other specific error code is applicable. Use GetDiagnostic for more information.' + }, + '391': { + basicMessage: 'General Commit Failure', + detailMessage: 'Indicates a failed Commit call where no other specific error code is applicable. Use GetDiagnostic for more information.' + }, + '401': { + basicMessage: 'Undefined Data Model Element', + detailMessage: 'The data model element name passed to GetValue or SetValue is not a valid SCORM data model element.' + }, + '402': { + basicMessage: 'Unimplemented Data Model Element', + detailMessage: 'The data model element indicated in a call to GetValue or SetValue is valid, but was not implemented by this LMS. In SCORM 2004, this error would indicate an LMS that is not fully SCORM conformant.' + }, + '403': { + basicMessage: 'Data Model Element Value Not Initialized', + detailMessage: 'Attempt to read a data model element that has not been initialized by the LMS or through a SetValue call. This error condition is often reached during normal execution of a SCO.' + }, + '404': { + basicMessage: 'Data Model Element Is Read Only', + detailMessage: 'SetValue was called with a data model element that can only be read.' + }, + '405': { + basicMessage: 'Data Model Element Is Write Only', + detailMessage: 'GetValue was called on a data model element that can only be written to.' + }, + '406': { + basicMessage: 'Data Model Element Type Mismatch', + detailMessage: 'SetValue was called with a value that is not consistent with the data format of the supplied data model element.' + }, + '407': { + basicMessage: 'Data Model Element Value Out Of Range', + detailMessage: 'The numeric value supplied to a SetValue call is outside of the numeric range allowed for the supplied data model element.' + }, + '408': { + basicMessage: 'Data Model Dependency Not Established', + detailMessage: 'Some data model elements cannot be set until another data model element was set. This error condition indicates that the prerequisite element was not set before the dependent element.' + } + } +}; +var APIConstants = { + global: global, + scorm12: scorm12, + aicc: aicc, + scorm2004: scorm2004 +}; +var _default = APIConstants; +exports["default"] = _default; + +},{}],7:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var global = { + GENERAL: 101, + INITIALIZATION_FAILED: 101, + INITIALIZED: 101, + TERMINATED: 101, + TERMINATION_FAILURE: 101, + TERMINATION_BEFORE_INIT: 101, + MULTIPLE_TERMINATION: 101, + RETRIEVE_BEFORE_INIT: 101, + RETRIEVE_AFTER_TERM: 101, + STORE_BEFORE_INIT: 101, + STORE_AFTER_TERM: 101, + COMMIT_BEFORE_INIT: 101, + COMMIT_AFTER_TERM: 101, + ARGUMENT_ERROR: 101, + CHILDREN_ERROR: 101, + COUNT_ERROR: 101, + GENERAL_GET_FAILURE: 101, + GENERAL_SET_FAILURE: 101, + GENERAL_COMMIT_FAILURE: 101, + UNDEFINED_DATA_MODEL: 101, + UNIMPLEMENTED_ELEMENT: 101, + VALUE_NOT_INITIALIZED: 101, + INVALID_SET_VALUE: 101, + READ_ONLY_ELEMENT: 101, + WRITE_ONLY_ELEMENT: 101, + TYPE_MISMATCH: 101, + VALUE_OUT_OF_RANGE: 101, + DEPENDENCY_NOT_ESTABLISHED: 101 +}; + +var scorm12 = _objectSpread(_objectSpread({}, global), { + RETRIEVE_BEFORE_INIT: 301, + STORE_BEFORE_INIT: 301, + COMMIT_BEFORE_INIT: 301, + ARGUMENT_ERROR: 201, + CHILDREN_ERROR: 202, + COUNT_ERROR: 203, + UNDEFINED_DATA_MODEL: 401, + UNIMPLEMENTED_ELEMENT: 401, + VALUE_NOT_INITIALIZED: 301, + INVALID_SET_VALUE: 402, + READ_ONLY_ELEMENT: 403, + WRITE_ONLY_ELEMENT: 404, + TYPE_MISMATCH: 405, + VALUE_OUT_OF_RANGE: 407, + DEPENDENCY_NOT_ESTABLISHED: 408 +}); + +var scorm2004 = _objectSpread(_objectSpread({}, global), { + INITIALIZATION_FAILED: 102, + INITIALIZED: 103, + TERMINATED: 104, + TERMINATION_FAILURE: 111, + TERMINATION_BEFORE_INIT: 112, + MULTIPLE_TERMINATIONS: 113, + RETRIEVE_BEFORE_INIT: 122, + RETRIEVE_AFTER_TERM: 123, + STORE_BEFORE_INIT: 132, + STORE_AFTER_TERM: 133, + COMMIT_BEFORE_INIT: 142, + COMMIT_AFTER_TERM: 143, + ARGUMENT_ERROR: 201, + GENERAL_GET_FAILURE: 301, + GENERAL_SET_FAILURE: 351, + GENERAL_COMMIT_FAILURE: 391, + UNDEFINED_DATA_MODEL: 401, + UNIMPLEMENTED_ELEMENT: 402, + VALUE_NOT_INITIALIZED: 403, + READ_ONLY_ELEMENT: 404, + WRITE_ONLY_ELEMENT: 405, + TYPE_MISMATCH: 406, + VALUE_OUT_OF_RANGE: 407, + DEPENDENCY_NOT_ESTABLISHED: 408 +}); + +var ErrorCodes = { + scorm12: scorm12, + scorm2004: scorm2004 +}; +var _default = ErrorCodes; +exports["default"] = _default; + +},{}],8:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var scorm12 = { + CMIString256: '^.{0,255}$', + CMIString4096: '^.{0,4096}$', + CMITime: '^(?:[01]\\d|2[0123]):(?:[012345]\\d):(?:[012345]\\d)$', + // eslint-disable-line + CMITimespan: '^([0-9]{2,}):([0-9]{2}):([0-9]{2})(\.[0-9]{1,2})?$', + // eslint-disable-line + CMIInteger: '^\\d+$', + CMISInteger: '^-?([0-9]+)$', + CMIDecimal: '^-?([0-9]{0,3})(\.[0-9]*)?$', + // eslint-disable-line + CMIIdentifier: "^[\\u0021-\\u007E\\s]{0,255}$", + CMIFeedback: '^.{0,255}$', + // This must be redefined + CMIIndex: '[._](\\d+).', + // Vocabulary Data Type Definition + CMIStatus: '^(passed|completed|failed|incomplete|browsed)$', + CMIStatus2: '^(passed|completed|failed|incomplete|browsed|not attempted)$', + CMIExit: '^(time-out|suspend|logout|)$', + CMIType: '^(true-false|choice|fill-in|matching|performance|sequencing|likert|numeric)$', + CMIResult: '^(correct|wrong|unanticipated|neutral|([0-9]{0,3})?(\\.[0-9]*)?)$', + // eslint-disable-line + NAVEvent: '^(previous|continue)$', + // Data ranges + score_range: '0#100', + audio_range: '-1#100', + speed_range: '-100#100', + weighting_range: '-100#100', + text_range: '-1#1' +}; + +var aicc = _objectSpread(_objectSpread({}, scorm12), { + CMIIdentifier: '^\\w{1,255}$' +}); + +var scorm2004 = { + CMIString200: "^[\\u0000-\\uFFFF]{0,200}$", + CMIString250: "^[\\u0000-\\uFFFF]{0,250}$", + CMIString1000: "^[\\u0000-\\uFFFF]{0,1000}$", + CMIString4000: "^[\\u0000-\\uFFFF]{0,4000}$", + CMIString64000: "^[\\u0000-\\uFFFF]{0,64000}$", + CMILang: '^([a-zA-Z]{2,3}|i|x)(\-[a-zA-Z0-9\-]{2,8})?$|^$', + // eslint-disable-line + CMILangString250: '^(\{lang=([a-zA-Z]{2,3}|i|x)(\-[a-zA-Z0-9\-]{2,8})?\})?((?!\{.*$).{0,250}$)?$', + // eslint-disable-line + CMILangcr: '^((\{lang=([a-zA-Z]{2,3}|i|x)?(\-[a-zA-Z0-9\-]{2,8})?\}))(.*?)$', + // eslint-disable-line + CMILangString250cr: '^((\{lang=([a-zA-Z]{2,3}|i|x)?(\-[a-zA-Z0-9\-]{2,8})?\})?(.{0,250})?)?$', + // eslint-disable-line + CMILangString4000: '^(\{lang=([a-zA-Z]{2,3}|i|x)(\-[a-zA-Z0-9\-]{2,8})?\})?((?!\{.*$).{0,4000}$)?$', + // eslint-disable-line + CMITime: '^(19[7-9]{1}[0-9]{1}|20[0-2]{1}[0-9]{1}|203[0-8]{1})((-(0[1-9]{1}|1[0-2]{1}))((-(0[1-9]{1}|[1-2]{1}[0-9]{1}|3[0-1]{1}))(T([0-1]{1}[0-9]{1}|2[0-3]{1})((:[0-5]{1}[0-9]{1})((:[0-5]{1}[0-9]{1})((\\.[0-9]{1,2})((Z|([+|-]([0-1]{1}[0-9]{1}|2[0-3]{1})))(:[0-5]{1}[0-9]{1})?)?)?)?)?)?)?)?$', + CMITimespan: '^P(?:([.,\\d]+)Y)?(?:([.,\\d]+)M)?(?:([.,\\d]+)W)?(?:([.,\\d]+)D)?(?:T?(?:([.,\\d]+)H)?(?:([.,\\d]+)M)?(?:([.,\\d]+)S)?)?$', + CMIInteger: '^\\d+$', + CMISInteger: '^-?([0-9]+)$', + CMIDecimal: '^-?([0-9]{1,5})(\\.[0-9]{1,18})?$', + CMIIdentifier: '^\\S{1,250}[a-zA-Z0-9]$', + CMIShortIdentifier: '^[\\w\\.\\-\\_]{1,250}$', + // eslint-disable-line + CMILongIdentifier: '^(?:(?!urn:)\\S{1,4000}|urn:[A-Za-z0-9-]{1,31}:\\S{1,4000}|.{1,4000})$', + // need to re-examine this + CMIFeedback: '^.*$', + // This must be redefined + CMIIndex: '[._](\\d+).', + CMIIndexStore: '.N(\\d+).', + // Vocabulary Data Type Definition + CMICStatus: '^(completed|incomplete|not attempted|unknown)$', + CMISStatus: '^(passed|failed|unknown)$', + CMIExit: '^(time-out|suspend|logout|normal)$', + CMIType: '^(true-false|choice|fill-in|long-fill-in|matching|performance|sequencing|likert|numeric|other)$', + CMIResult: '^(correct|incorrect|unanticipated|neutral|-?([0-9]{1,4})(\\.[0-9]{1,18})?)$', + NAVEvent: '^(previous|continue|exit|exitAll|abandon|abandonAll|suspendAll|\{target=\\S{0,200}[a-zA-Z0-9]\}choice|jump)$', + // eslint-disable-line + NAVBoolean: '^(unknown|true|false$)', + NAVTarget: '^(previous|continue|choice.{target=\\S{0,200}[a-zA-Z0-9]})$', + // Data ranges + scaled_range: '-1#1', + audio_range: '0#*', + speed_range: '0#*', + text_range: '-1#1', + progress_range: '0#1' +}; +var Regex = { + aicc: aicc, + scorm12: scorm12, + scorm2004: scorm2004 +}; +var _default = Regex; +exports["default"] = _default; + +},{}],9:[function(require,module,exports){ +"use strict"; + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.Scorm2004ValidationError = exports.AICCValidationError = exports.Scorm12ValidationError = exports.ValidationError = void 0; + +var _api_constants = _interopRequireDefault(require("./constants/api_constants")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); } + +function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); } + +function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; } + +function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); } + +function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } } + +var scorm12_errors = _api_constants["default"].scorm12.error_descriptions; +var aicc_errors = _api_constants["default"].aicc.error_descriptions; +var scorm2004_errors = _api_constants["default"].scorm2004.error_descriptions; +/** + * Base Validation Exception + */ + +var _errorCode = new WeakMap(); + +var _errorMessage = new WeakMap(); + +var _detailedMessage = new WeakMap(); + +var ValidationError = /*#__PURE__*/function (_Error) { + _inherits(ValidationError, _Error); + + var _super = _createSuper(ValidationError); + + /** + * Constructor to take in an error message and code + * @param {number} errorCode + * @param {string} errorMessage + * @param {string} detailedMessage + */ + function ValidationError(errorCode, errorMessage, detailedMessage) { + var _this; + + _classCallCheck(this, ValidationError); + + _this = _super.call(this, errorMessage); + + _errorCode.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _errorMessage.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _detailedMessage.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _classPrivateFieldSet(_assertThisInitialized(_this), _errorCode, errorCode); + + _classPrivateFieldSet(_assertThisInitialized(_this), _errorMessage, errorMessage); + + _classPrivateFieldSet(_assertThisInitialized(_this), _detailedMessage, detailedMessage); + + return _this; + } + + _createClass(ValidationError, [{ + key: "errorCode", + get: + /** + * Getter for #errorCode + * @return {number} + */ + function get() { + return _classPrivateFieldGet(this, _errorCode); + } + /** + * Getter for #errorMessage + * @return {string} + */ + + }, { + key: "errorMessage", + get: function get() { + return _classPrivateFieldGet(this, _errorMessage); + } + /** + * Getter for #detailedMessage + * @return {string} + */ + + }, { + key: "detailedMessage", + get: function get() { + return _classPrivateFieldGet(this, _detailedMessage); + } + }]); + + return ValidationError; +}( /*#__PURE__*/_wrapNativeSuper(Error)); +/** + * SCORM 1.2 Validation Error + */ + + +exports.ValidationError = ValidationError; + +var Scorm12ValidationError = /*#__PURE__*/function (_ValidationError) { + _inherits(Scorm12ValidationError, _ValidationError); + + var _super2 = _createSuper(Scorm12ValidationError); + + /** + * Constructor to take in an error code + * @param {number} errorCode + */ + function Scorm12ValidationError(errorCode) { + var _this2; + + _classCallCheck(this, Scorm12ValidationError); + + if ({}.hasOwnProperty.call(scorm12_errors, String(errorCode))) { + _this2 = _super2.call(this, errorCode, scorm12_errors[String(errorCode)].basicMessage, scorm12_errors[String(errorCode)].detailMessage); + } else { + _this2 = _super2.call(this, 101, scorm12_errors['101'].basicMessage, scorm12_errors['101'].detailMessage); + } + + return _possibleConstructorReturn(_this2); + } + + return Scorm12ValidationError; +}(ValidationError); +/** + * AICC Validation Error + */ + + +exports.Scorm12ValidationError = Scorm12ValidationError; + +var AICCValidationError = /*#__PURE__*/function (_ValidationError2) { + _inherits(AICCValidationError, _ValidationError2); + + var _super3 = _createSuper(AICCValidationError); + + /** + * Constructor to take in an error code + * @param {number} errorCode + */ + function AICCValidationError(errorCode) { + var _this3; + + _classCallCheck(this, AICCValidationError); + + if ({}.hasOwnProperty.call(aicc_errors, String(errorCode))) { + _this3 = _super3.call(this, errorCode, aicc_errors[String(errorCode)].basicMessage, aicc_errors[String(errorCode)].detailMessage); + } else { + _this3 = _super3.call(this, 101, aicc_errors['101'].basicMessage, aicc_errors['101'].detailMessage); + } + + return _possibleConstructorReturn(_this3); + } + + return AICCValidationError; +}(ValidationError); +/** + * SCORM 2004 Validation Error + */ + + +exports.AICCValidationError = AICCValidationError; + +var Scorm2004ValidationError = /*#__PURE__*/function (_ValidationError3) { + _inherits(Scorm2004ValidationError, _ValidationError3); + + var _super4 = _createSuper(Scorm2004ValidationError); + + /** + * Constructor to take in an error code + * @param {number} errorCode + */ + function Scorm2004ValidationError(errorCode) { + var _this4; + + _classCallCheck(this, Scorm2004ValidationError); + + if ({}.hasOwnProperty.call(scorm2004_errors, String(errorCode))) { + _this4 = _super4.call(this, errorCode, scorm2004_errors[String(errorCode)].basicMessage, scorm2004_errors[String(errorCode)].detailMessage); + } else { + _this4 = _super4.call(this, 101, scorm2004_errors['101'].basicMessage, scorm2004_errors['101'].detailMessage); + } + + return _possibleConstructorReturn(_this4); + } + + return Scorm2004ValidationError; +}(ValidationError); + +exports.Scorm2004ValidationError = Scorm2004ValidationError; + +},{"./constants/api_constants":6}],10:[function(require,module,exports){ +"use strict"; + +var _Scorm12API = _interopRequireDefault(require("../Scorm12API")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +window.Scorm12API = _Scorm12API["default"]; + +},{"../Scorm12API":3}],11:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.getSecondsAsHHMMSS = getSecondsAsHHMMSS; +exports.getSecondsAsISODuration = getSecondsAsISODuration; +exports.getTimeAsSeconds = getTimeAsSeconds; +exports.getDurationAsSeconds = getDurationAsSeconds; +exports.addTwoDurations = addTwoDurations; +exports.addHHMMSSTimeStrings = addHHMMSSTimeStrings; +exports.flatten = flatten; +exports.unflatten = unflatten; +exports.countDecimals = countDecimals; +exports.SECONDS_PER_DAY = exports.SECONDS_PER_HOUR = exports.SECONDS_PER_MINUTE = exports.SECONDS_PER_SECOND = void 0; + +function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); } + +function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } + +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit(arr, i) { var _i = arr && (typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]); if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } + +var SECONDS_PER_SECOND = 1.0; +exports.SECONDS_PER_SECOND = SECONDS_PER_SECOND; +var SECONDS_PER_MINUTE = 60; +exports.SECONDS_PER_MINUTE = SECONDS_PER_MINUTE; +var SECONDS_PER_HOUR = 60 * SECONDS_PER_MINUTE; +exports.SECONDS_PER_HOUR = SECONDS_PER_HOUR; +var SECONDS_PER_DAY = 24 * SECONDS_PER_HOUR; +exports.SECONDS_PER_DAY = SECONDS_PER_DAY; +var designations = [['D', SECONDS_PER_DAY], ['H', SECONDS_PER_HOUR], ['M', SECONDS_PER_MINUTE], ['S', SECONDS_PER_SECOND]]; +/** + * Converts a Number to a String of HH:MM:SS + * + * @param {Number} totalSeconds + * @return {string} + */ + +function getSecondsAsHHMMSS(totalSeconds) { + // SCORM spec does not deal with negative durations, give zero back + if (!totalSeconds || totalSeconds <= 0) { + return '00:00:00'; + } + + var hours = Math.floor(totalSeconds / SECONDS_PER_HOUR); + var dateObj = new Date(totalSeconds * 1000); + var minutes = dateObj.getUTCMinutes(); // make sure we add any possible decimal value + + var seconds = dateObj.getSeconds(); + var ms = totalSeconds % 1.0; + var msStr = ''; + + if (countDecimals(ms) > 0) { + if (countDecimals(ms) > 2) { + msStr = ms.toFixed(2); + } else { + msStr = String(ms); + } + + msStr = '.' + msStr.split('.')[1]; + } + + return (hours + ':' + minutes + ':' + seconds).replace(/\b\d\b/g, '0$&') + msStr; +} +/** + * Calculate the number of seconds from ISO 8601 Duration + * + * @param {Number} seconds + * @return {String} + */ + + +function getSecondsAsISODuration(seconds) { + // SCORM spec does not deal with negative durations, give zero back + if (!seconds || seconds <= 0) { + return 'PT0S'; + } + + var duration = 'P'; + var remainder = seconds; + designations.forEach(function (_ref) { + var _ref2 = _slicedToArray(_ref, 2), + sign = _ref2[0], + current_seconds = _ref2[1]; + + var value = Math.floor(remainder / current_seconds); + remainder = remainder % current_seconds; + + if (countDecimals(remainder) > 2) { + remainder = Number(Number(remainder).toFixed(2)); + } // If we have anything left in the remainder, and we're currently adding + // seconds to the duration, go ahead and add the decimal to the seconds + + + if (sign === 'S' && remainder > 0) { + value += remainder; + } + + if (value) { + if ((duration.indexOf('D') > 0 || sign === 'H' || sign === 'M' || sign === 'S') && duration.indexOf('T') === -1) { + duration += 'T'; + } + + duration += "".concat(value).concat(sign); + } + }); + return duration; +} +/** + * Calculate the number of seconds from HH:MM:SS.DDDDDD + * + * @param {string} timeString + * @param {RegExp} timeRegex + * @return {number} + */ + + +function getTimeAsSeconds(timeString, timeRegex) { + if (!timeString || typeof timeString !== 'string' || !timeString.match(timeRegex)) { + return 0; + } + + var parts = timeString.split(':'); + var hours = Number(parts[0]); + var minutes = Number(parts[1]); + var seconds = Number(parts[2]); + return hours * 3600 + minutes * 60 + seconds; +} +/** + * Calculate the number of seconds from ISO 8601 Duration + * + * @param {string} duration + * @param {RegExp} durationRegex + * @return {number} + */ + + +function getDurationAsSeconds(duration, durationRegex) { + if (!duration || !duration.match(durationRegex)) { + return 0; + } + + var _ref3 = new RegExp(durationRegex).exec(duration) || [], + _ref4 = _slicedToArray(_ref3, 8), + years = _ref4[1], + months = _ref4[2], + days = _ref4[4], + hours = _ref4[5], + minutes = _ref4[6], + seconds = _ref4[7]; + + var result = 0.0; + result += Number(seconds) * 1.0 || 0.0; + result += Number(minutes) * 60.0 || 0.0; + result += Number(hours) * 3600.0 || 0.0; + result += Number(days) * (60 * 60 * 24.0) || 0.0; + result += Number(years) * (60 * 60 * 24 * 365.0) || 0.0; + return result; +} +/** + * Adds together two ISO8601 Duration strings + * + * @param {string} first + * @param {string} second + * @param {RegExp} durationRegex + * @return {string} + */ + + +function addTwoDurations(first, second, durationRegex) { + return getSecondsAsISODuration(getDurationAsSeconds(first, durationRegex) + getDurationAsSeconds(second, durationRegex)); +} +/** + * Add together two HH:MM:SS.DD strings + * + * @param {string} first + * @param {string} second + * @param {RegExp} timeRegex + * @return {string} + */ + + +function addHHMMSSTimeStrings(first, second, timeRegex) { + return getSecondsAsHHMMSS(getTimeAsSeconds(first, timeRegex) + getTimeAsSeconds(second, timeRegex)); +} +/** + * Flatten a JSON object down to string paths for each values + * @param {object} data + * @return {object} + */ + + +function flatten(data) { + var result = {}; + /** + * Recurse through the object + * @param {*} cur + * @param {*} prop + */ + + function recurse(cur, prop) { + if (Object(cur) !== cur) { + result[prop] = cur; + } else if (Array.isArray(cur)) { + for (var i = 0, l = cur.length; i < l; i++) { + recurse(cur[i], prop + '[' + i + ']'); + if (l === 0) result[prop] = []; + } + } else { + var isEmpty = true; + + for (var p in cur) { + if ({}.hasOwnProperty.call(cur, p)) { + isEmpty = false; + recurse(cur[p], prop ? prop + '.' + p : p); + } + } + + if (isEmpty && prop) result[prop] = {}; + } + } + + recurse(data, ''); + return result; +} +/** + * Un-flatten a flat JSON object + * @param {object} data + * @return {object} + */ + + +function unflatten(data) { + 'use strict'; + + if (Object(data) !== data || Array.isArray(data)) return data; + var regex = /\.?([^.[\]]+)|\[(\d+)]/g; + var result = {}; + + for (var p in data) { + if ({}.hasOwnProperty.call(data, p)) { + var cur = result; + var prop = ''; + var m = regex.exec(p); + + while (m) { + cur = cur[prop] || (cur[prop] = m[2] ? [] : {}); + prop = m[2] || m[1]; + m = regex.exec(p); + } + + cur[prop] = data[p]; + } + } + + return result[''] || result; +} +/** + * Counts the number of decimal places + * @param {number} num + * @return {number} + */ + + +function countDecimals(num) { + if (Math.floor(num) === num || String(num).indexOf('.') < 0) return 0; + var parts = num.toString().split('.')[1]; + return parts.length || 0; +} + +},{}]},{},[10]); diff --git a/dist/scorm2004.js b/dist/scorm2004.js new file mode 100644 index 0000000..f3d7e42 --- /dev/null +++ b/dist/scorm2004.js @@ -0,0 +1,6886 @@ +(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i + * Build: `lodash modularize exports="npm" -o ./` + * Copyright jQuery Foundation and other contributors + * Released under MIT license + * Based on Underscore.js 1.8.3 + * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + */ + +/** Used as the `TypeError` message for "Functions" methods. */ +var FUNC_ERROR_TEXT = 'Expected a function'; + +/** Used as references for various `Number` constants. */ +var NAN = 0 / 0; + +/** `Object#toString` result references. */ +var symbolTag = '[object Symbol]'; + +/** Used to match leading and trailing whitespace. */ +var reTrim = /^\s+|\s+$/g; + +/** Used to detect bad signed hexadecimal string values. */ +var reIsBadHex = /^[-+]0x[0-9a-f]+$/i; + +/** Used to detect binary string values. */ +var reIsBinary = /^0b[01]+$/i; + +/** Used to detect octal string values. */ +var reIsOctal = /^0o[0-7]+$/i; + +/** Built-in method references without a dependency on `root`. */ +var freeParseInt = parseInt; + +/** Detect free variable `global` from Node.js. */ +var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; + +/** Detect free variable `self`. */ +var freeSelf = typeof self == 'object' && self && self.Object === Object && self; + +/** Used as a reference to the global object. */ +var root = freeGlobal || freeSelf || Function('return this')(); + +/** Used for built-in method references. */ +var objectProto = Object.prototype; + +/** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ +var objectToString = objectProto.toString; + +/* Built-in method references for those with the same name as other `lodash` methods. */ +var nativeMax = Math.max, + nativeMin = Math.min; + +/** + * Gets the timestamp of the number of milliseconds that have elapsed since + * the Unix epoch (1 January 1970 00:00:00 UTC). + * + * @static + * @memberOf _ + * @since 2.4.0 + * @category Date + * @returns {number} Returns the timestamp. + * @example + * + * _.defer(function(stamp) { + * console.log(_.now() - stamp); + * }, _.now()); + * // => Logs the number of milliseconds it took for the deferred invocation. + */ +var now = function() { + return root.Date.now(); +}; + +/** + * Creates a debounced function that delays invoking `func` until after `wait` + * milliseconds have elapsed since the last time the debounced function was + * invoked. The debounced function comes with a `cancel` method to cancel + * delayed `func` invocations and a `flush` method to immediately invoke them. + * Provide `options` to indicate whether `func` should be invoked on the + * leading and/or trailing edge of the `wait` timeout. The `func` is invoked + * with the last arguments provided to the debounced function. Subsequent + * calls to the debounced function return the result of the last `func` + * invocation. + * + * **Note:** If `leading` and `trailing` options are `true`, `func` is + * invoked on the trailing edge of the timeout only if the debounced function + * is invoked more than once during the `wait` timeout. + * + * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred + * until to the next tick, similar to `setTimeout` with a timeout of `0`. + * + * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) + * for details over the differences between `_.debounce` and `_.throttle`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to debounce. + * @param {number} [wait=0] The number of milliseconds to delay. + * @param {Object} [options={}] The options object. + * @param {boolean} [options.leading=false] + * Specify invoking on the leading edge of the timeout. + * @param {number} [options.maxWait] + * The maximum time `func` is allowed to be delayed before it's invoked. + * @param {boolean} [options.trailing=true] + * Specify invoking on the trailing edge of the timeout. + * @returns {Function} Returns the new debounced function. + * @example + * + * // Avoid costly calculations while the window size is in flux. + * jQuery(window).on('resize', _.debounce(calculateLayout, 150)); + * + * // Invoke `sendMail` when clicked, debouncing subsequent calls. + * jQuery(element).on('click', _.debounce(sendMail, 300, { + * 'leading': true, + * 'trailing': false + * })); + * + * // Ensure `batchLog` is invoked once after 1 second of debounced calls. + * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 }); + * var source = new EventSource('/stream'); + * jQuery(source).on('message', debounced); + * + * // Cancel the trailing debounced invocation. + * jQuery(window).on('popstate', debounced.cancel); + */ +function debounce(func, wait, options) { + var lastArgs, + lastThis, + maxWait, + result, + timerId, + lastCallTime, + lastInvokeTime = 0, + leading = false, + maxing = false, + trailing = true; + + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + wait = toNumber(wait) || 0; + if (isObject(options)) { + leading = !!options.leading; + maxing = 'maxWait' in options; + maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait; + trailing = 'trailing' in options ? !!options.trailing : trailing; + } + + function invokeFunc(time) { + var args = lastArgs, + thisArg = lastThis; + + lastArgs = lastThis = undefined; + lastInvokeTime = time; + result = func.apply(thisArg, args); + return result; + } + + function leadingEdge(time) { + // Reset any `maxWait` timer. + lastInvokeTime = time; + // Start the timer for the trailing edge. + timerId = setTimeout(timerExpired, wait); + // Invoke the leading edge. + return leading ? invokeFunc(time) : result; + } + + function remainingWait(time) { + var timeSinceLastCall = time - lastCallTime, + timeSinceLastInvoke = time - lastInvokeTime, + result = wait - timeSinceLastCall; + + return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result; + } + + function shouldInvoke(time) { + var timeSinceLastCall = time - lastCallTime, + timeSinceLastInvoke = time - lastInvokeTime; + + // Either this is the first call, activity has stopped and we're at the + // trailing edge, the system time has gone backwards and we're treating + // it as the trailing edge, or we've hit the `maxWait` limit. + return (lastCallTime === undefined || (timeSinceLastCall >= wait) || + (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait)); + } + + function timerExpired() { + var time = now(); + if (shouldInvoke(time)) { + return trailingEdge(time); + } + // Restart the timer. + timerId = setTimeout(timerExpired, remainingWait(time)); + } + + function trailingEdge(time) { + timerId = undefined; + + // Only invoke if we have `lastArgs` which means `func` has been + // debounced at least once. + if (trailing && lastArgs) { + return invokeFunc(time); + } + lastArgs = lastThis = undefined; + return result; + } + + function cancel() { + if (timerId !== undefined) { + clearTimeout(timerId); + } + lastInvokeTime = 0; + lastArgs = lastCallTime = lastThis = timerId = undefined; + } + + function flush() { + return timerId === undefined ? result : trailingEdge(now()); + } + + function debounced() { + var time = now(), + isInvoking = shouldInvoke(time); + + lastArgs = arguments; + lastThis = this; + lastCallTime = time; + + if (isInvoking) { + if (timerId === undefined) { + return leadingEdge(lastCallTime); + } + if (maxing) { + // Handle invocations in a tight loop. + timerId = setTimeout(timerExpired, wait); + return invokeFunc(lastCallTime); + } + } + if (timerId === undefined) { + timerId = setTimeout(timerExpired, wait); + } + return result; + } + debounced.cancel = cancel; + debounced.flush = flush; + return debounced; +} + +/** + * Checks if `value` is the + * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) + * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an object, else `false`. + * @example + * + * _.isObject({}); + * // => true + * + * _.isObject([1, 2, 3]); + * // => true + * + * _.isObject(_.noop); + * // => true + * + * _.isObject(null); + * // => false + */ +function isObject(value) { + var type = typeof value; + return !!value && (type == 'object' || type == 'function'); +} + +/** + * Checks if `value` is object-like. A value is object-like if it's not `null` + * and has a `typeof` result of "object". + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is object-like, else `false`. + * @example + * + * _.isObjectLike({}); + * // => true + * + * _.isObjectLike([1, 2, 3]); + * // => true + * + * _.isObjectLike(_.noop); + * // => false + * + * _.isObjectLike(null); + * // => false + */ +function isObjectLike(value) { + return !!value && typeof value == 'object'; +} + +/** + * Checks if `value` is classified as a `Symbol` primitive or object. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. + * @example + * + * _.isSymbol(Symbol.iterator); + * // => true + * + * _.isSymbol('abc'); + * // => false + */ +function isSymbol(value) { + return typeof value == 'symbol' || + (isObjectLike(value) && objectToString.call(value) == symbolTag); +} + +/** + * Converts `value` to a number. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to process. + * @returns {number} Returns the number. + * @example + * + * _.toNumber(3.2); + * // => 3.2 + * + * _.toNumber(Number.MIN_VALUE); + * // => 5e-324 + * + * _.toNumber(Infinity); + * // => Infinity + * + * _.toNumber('3.2'); + * // => 3.2 + */ +function toNumber(value) { + if (typeof value == 'number') { + return value; + } + if (isSymbol(value)) { + return NAN; + } + if (isObject(value)) { + var other = typeof value.valueOf == 'function' ? value.valueOf() : value; + value = isObject(other) ? (other + '') : other; + } + if (typeof value != 'string') { + return value === 0 ? value : +value; + } + value = value.replace(reTrim, ''); + var isBinary = reIsBinary.test(value); + return (isBinary || reIsOctal.test(value)) + ? freeParseInt(value.slice(2), isBinary ? 2 : 8) + : (reIsBadHex.test(value) ? NAN : +value); +} + +module.exports = debounce; + +}).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) + +},{}],2:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +var _common = require("./cmi/common"); + +var _exceptions = require("./exceptions"); + +var _error_codes2 = _interopRequireDefault(require("./constants/error_codes")); + +var _api_constants = _interopRequireDefault(require("./constants/api_constants")); + +var _utilities = require("./utilities"); + +var _lodash = _interopRequireDefault(require("lodash.debounce")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); } + +function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } + +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit(arr, i) { var _i = arr && (typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]); if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); } + +function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; } + +function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); } + +function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } } + +var global_constants = _api_constants["default"].global; +var scorm12_error_codes = _error_codes2["default"].scorm12; +/** + * Base API class for AICC, SCORM 1.2, and SCORM 2004. Should be considered + * abstract, and never initialized on it's own. + */ + +var _timeout = new WeakMap(); + +var _error_codes = new WeakMap(); + +var _settings = new WeakMap(); + +var BaseAPI = /*#__PURE__*/function () { + /** + * Constructor for Base API class. Sets some shared API fields, as well as + * sets up options for the API. + * @param {object} error_codes + * @param {object} settings + */ + function BaseAPI(error_codes, settings) { + _classCallCheck(this, BaseAPI); + + _timeout.set(this, { + writable: true, + value: void 0 + }); + + _error_codes.set(this, { + writable: true, + value: void 0 + }); + + _settings.set(this, { + writable: true, + value: { + autocommit: false, + autocommitSeconds: 10, + asyncCommit: false, + sendBeaconCommit: false, + lmsCommitUrl: false, + dataCommitFormat: 'json', + // valid formats are 'json' or 'flattened', 'params' + commitRequestDataType: 'application/json;charset=UTF-8', + autoProgress: false, + logLevel: global_constants.LOG_LEVEL_ERROR, + selfReportSessionTime: false, + alwaysSendTotalTime: false, + strict_errors: true, + responseHandler: function responseHandler(xhr) { + var result; + + if (typeof xhr !== 'undefined') { + result = JSON.parse(xhr.responseText); + + if (result === null || !{}.hasOwnProperty.call(result, 'result')) { + result = {}; + + if (xhr.status === 200) { + result.result = global_constants.SCORM_TRUE; + result.errorCode = 0; + } else { + result.result = global_constants.SCORM_FALSE; + result.errorCode = 101; + } + } + } + + return result; + } + } + }); + + _defineProperty(this, "cmi", void 0); + + _defineProperty(this, "startingData", void 0); + + if ((this instanceof BaseAPI ? this.constructor : void 0) === BaseAPI) { + throw new TypeError('Cannot construct BaseAPI instances directly'); + } + + this.currentState = global_constants.STATE_NOT_INITIALIZED; + this.lastErrorCode = 0; + this.listenerArray = []; + + _classPrivateFieldSet(this, _timeout, null); + + _classPrivateFieldSet(this, _error_codes, error_codes); + + this.settings = settings; + this.apiLogLevel = this.settings.logLevel; + this.selfReportSessionTime = this.settings.selfReportSessionTime; + } + /** + * Initialize the API + * @param {string} callbackName + * @param {string} initializeMessage + * @param {string} terminationMessage + * @return {string} + */ + + + _createClass(BaseAPI, [{ + key: "initialize", + value: function initialize(callbackName, initializeMessage, terminationMessage) { + var returnValue = global_constants.SCORM_FALSE; + + if (this.isInitialized()) { + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).INITIALIZED, initializeMessage); + } else if (this.isTerminated()) { + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).TERMINATED, terminationMessage); + } else { + if (this.selfReportSessionTime) { + this.cmi.setStartTime(); + } + + this.currentState = global_constants.STATE_INITIALIZED; + this.lastErrorCode = 0; + returnValue = global_constants.SCORM_TRUE; + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Getter for #error_codes + * @return {object} + */ + + }, { + key: "error_codes", + get: function get() { + return _classPrivateFieldGet(this, _error_codes); + } + /** + * Getter for #settings + * @return {object} + */ + + }, { + key: "settings", + get: function get() { + return _classPrivateFieldGet(this, _settings); + } + /** + * Setter for #settings + * @param {object} settings + */ + , + set: function set(settings) { + _classPrivateFieldSet(this, _settings, _objectSpread(_objectSpread({}, _classPrivateFieldGet(this, _settings)), settings)); + } + /** + * Terminates the current run of the API + * @param {string} callbackName + * @param {boolean} checkTerminated + * @return {string} + */ + + }, { + key: "terminate", + value: function terminate(callbackName, checkTerminated) { + var returnValue = global_constants.SCORM_FALSE; + + if (this.checkState(checkTerminated, _classPrivateFieldGet(this, _error_codes).TERMINATION_BEFORE_INIT, _classPrivateFieldGet(this, _error_codes).MULTIPLE_TERMINATION)) { + this.currentState = global_constants.STATE_TERMINATED; + var result = this.storeData(true); + + if (!this.settings.sendBeaconCommit && !this.settings.asyncCommit && typeof result.errorCode !== 'undefined' && result.errorCode > 0) { + this.throwSCORMError(result.errorCode); + } + + returnValue = typeof result !== 'undefined' && result.result ? result.result : global_constants.SCORM_FALSE; + if (checkTerminated) this.lastErrorCode = 0; + returnValue = global_constants.SCORM_TRUE; + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Get the value of the CMIElement. + * + * @param {string} callbackName + * @param {boolean} checkTerminated + * @param {string} CMIElement + * @return {string} + */ + + }, { + key: "getValue", + value: function getValue(callbackName, checkTerminated, CMIElement) { + var returnValue; + + if (this.checkState(checkTerminated, _classPrivateFieldGet(this, _error_codes).RETRIEVE_BEFORE_INIT, _classPrivateFieldGet(this, _error_codes).RETRIEVE_AFTER_TERM)) { + if (checkTerminated) this.lastErrorCode = 0; + + try { + returnValue = this.getCMIValue(CMIElement); + } catch (e) { + if (e instanceof _exceptions.ValidationError) { + this.lastErrorCode = e.errorCode; + returnValue = global_constants.SCORM_FALSE; + } else { + if (e.message) { + console.error(e.message); + } else { + console.error(e); + } + + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).GENERAL); + } + } + + this.processListeners(callbackName, CMIElement); + } + + this.apiLog(callbackName, CMIElement, ': returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Sets the value of the CMIElement. + * + * @param {string} callbackName + * @param {string} commitCallback + * @param {boolean} checkTerminated + * @param {string} CMIElement + * @param {*} value + * @return {string} + */ + + }, { + key: "setValue", + value: function setValue(callbackName, commitCallback, checkTerminated, CMIElement, value) { + if (value !== undefined) { + value = String(value); + } + + var returnValue = global_constants.SCORM_FALSE; + + if (this.checkState(checkTerminated, _classPrivateFieldGet(this, _error_codes).STORE_BEFORE_INIT, _classPrivateFieldGet(this, _error_codes).STORE_AFTER_TERM)) { + if (checkTerminated) this.lastErrorCode = 0; + + try { + returnValue = this.setCMIValue(CMIElement, value); + } catch (e) { + if (e instanceof _exceptions.ValidationError) { + this.lastErrorCode = e.errorCode; + returnValue = global_constants.SCORM_FALSE; + } else { + if (e.message) { + console.error(e.message); + } else { + console.error(e); + } + + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).GENERAL); + } + } + + this.processListeners(callbackName, CMIElement, value); + } + + if (returnValue === undefined) { + returnValue = global_constants.SCORM_FALSE; + } // If we didn't have any errors while setting the data, go ahead and + // schedule a commit, if autocommit is turned on + + + if (String(this.lastErrorCode) === '0') { + if (this.settings.autocommit && !_classPrivateFieldGet(this, _timeout)) { + this.scheduleCommit(this.settings.autocommitSeconds * 1000, commitCallback); + } + } + + this.apiLog(callbackName, CMIElement, ': ' + value + ': result: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Orders LMS to store all content parameters + * @param {string} callbackName + * @param {boolean} checkTerminated + * @return {string} + */ + + }, { + key: "commit", + value: function commit(callbackName, checkTerminated) { + this.clearScheduledCommit(); + var returnValue = global_constants.SCORM_FALSE; + + if (this.checkState(checkTerminated, _classPrivateFieldGet(this, _error_codes).COMMIT_BEFORE_INIT, _classPrivateFieldGet(this, _error_codes).COMMIT_AFTER_TERM)) { + var result = this.storeData(false); + + if (!this.settings.sendBeaconCommit && !this.settings.asyncCommit && result.errorCode && result.errorCode > 0) { + this.throwSCORMError(result.errorCode); + } + + returnValue = typeof result !== 'undefined' && result.result ? result.result : global_constants.SCORM_FALSE; + this.apiLog(callbackName, 'HttpRequest', ' Result: ' + returnValue, global_constants.LOG_LEVEL_DEBUG); + if (checkTerminated) this.lastErrorCode = 0; + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Returns last error code + * @param {string} callbackName + * @return {string} + */ + + }, { + key: "getLastError", + value: function getLastError(callbackName) { + var returnValue = String(this.lastErrorCode); + this.processListeners(callbackName); + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + return returnValue; + } + /** + * Returns the errorNumber error description + * + * @param {string} callbackName + * @param {(string|number)} CMIErrorCode + * @return {string} + */ + + }, { + key: "getErrorString", + value: function getErrorString(callbackName, CMIErrorCode) { + var returnValue = ''; + + if (CMIErrorCode !== null && CMIErrorCode !== '') { + returnValue = this.getLmsErrorMessageDetails(CMIErrorCode); + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + return returnValue; + } + /** + * Returns a comprehensive description of the errorNumber error. + * + * @param {string} callbackName + * @param {(string|number)} CMIErrorCode + * @return {string} + */ + + }, { + key: "getDiagnostic", + value: function getDiagnostic(callbackName, CMIErrorCode) { + var returnValue = ''; + + if (CMIErrorCode !== null && CMIErrorCode !== '') { + returnValue = this.getLmsErrorMessageDetails(CMIErrorCode, true); + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + return returnValue; + } + /** + * Checks the LMS state and ensures it has been initialized. + * + * @param {boolean} checkTerminated + * @param {number} beforeInitError + * @param {number} afterTermError + * @return {boolean} + */ + + }, { + key: "checkState", + value: function checkState(checkTerminated, beforeInitError, afterTermError) { + if (this.isNotInitialized()) { + this.throwSCORMError(beforeInitError); + return false; + } else if (checkTerminated && this.isTerminated()) { + this.throwSCORMError(afterTermError); + return false; + } + + return true; + } + /** + * Logging for all SCORM actions + * + * @param {string} functionName + * @param {string} CMIElement + * @param {string} logMessage + * @param {number}messageLevel + */ + + }, { + key: "apiLog", + value: function apiLog(functionName, CMIElement, logMessage, messageLevel) { + logMessage = this.formatMessage(functionName, CMIElement, logMessage); + + if (messageLevel >= this.apiLogLevel) { + switch (messageLevel) { + case global_constants.LOG_LEVEL_ERROR: + console.error(logMessage); + break; + + case global_constants.LOG_LEVEL_WARNING: + console.warn(logMessage); + break; + + case global_constants.LOG_LEVEL_INFO: + console.info(logMessage); + break; + + case global_constants.LOG_LEVEL_DEBUG: + if (console.debug) { + console.debug(logMessage); + } else { + console.log(logMessage); + } + + break; + } + } + } + /** + * Formats the SCORM messages for easy reading + * + * @param {string} functionName + * @param {string} CMIElement + * @param {string} message + * @return {string} + */ + + }, { + key: "formatMessage", + value: function formatMessage(functionName, CMIElement, message) { + var baseLength = 20; + var messageString = ''; + messageString += functionName; + var fillChars = baseLength - messageString.length; + + for (var i = 0; i < fillChars; i++) { + messageString += ' '; + } + + messageString += ': '; + + if (CMIElement) { + var CMIElementBaseLength = 70; + messageString += CMIElement; + fillChars = CMIElementBaseLength - messageString.length; + + for (var j = 0; j < fillChars; j++) { + messageString += ' '; + } + } + + if (message) { + messageString += message; + } + + return messageString; + } + /** + * Checks to see if {str} contains {tester} + * + * @param {string} str String to check against + * @param {string} tester String to check for + * @return {boolean} + */ + + }, { + key: "stringMatches", + value: function stringMatches(str, tester) { + return str && tester && str.match(tester); + } + /** + * Check to see if the specific object has the given property + * @param {*} refObject + * @param {string} attribute + * @return {boolean} + * @private + */ + + }, { + key: "_checkObjectHasProperty", + value: function _checkObjectHasProperty(refObject, attribute) { + return Object.hasOwnProperty.call(refObject, attribute) || Object.getOwnPropertyDescriptor(Object.getPrototypeOf(refObject), attribute) || attribute in refObject; + } + /** + * Returns the message that corresponds to errorNumber + * APIs that inherit BaseAPI should override this function + * + * @param {(string|number)} _errorNumber + * @param {boolean} _detail + * @return {string} + * @abstract + */ + + }, { + key: "getLmsErrorMessageDetails", + value: function getLmsErrorMessageDetails(_errorNumber, _detail) { + throw new Error('The getLmsErrorMessageDetails method has not been implemented'); + } + /** + * Gets the value for the specific element. + * APIs that inherit BaseAPI should override this function + * + * @param {string} _CMIElement + * @return {string} + * @abstract + */ + + }, { + key: "getCMIValue", + value: function getCMIValue(_CMIElement) { + throw new Error('The getCMIValue method has not been implemented'); + } + /** + * Sets the value for the specific element. + * APIs that inherit BaseAPI should override this function + * + * @param {string} _CMIElement + * @param {any} _value + * @return {string} + * @abstract + */ + + }, { + key: "setCMIValue", + value: function setCMIValue(_CMIElement, _value) { + throw new Error('The setCMIValue method has not been implemented'); + } + /** + * Shared API method to set a valid for a given element. + * + * @param {string} methodName + * @param {boolean} scorm2004 + * @param {string} CMIElement + * @param {*} value + * @return {string} + */ + + }, { + key: "_commonSetCMIValue", + value: function _commonSetCMIValue(methodName, scorm2004, CMIElement, value) { + if (!CMIElement || CMIElement === '') { + return global_constants.SCORM_FALSE; + } + + var structure = CMIElement.split('.'); + var refObject = this; + var returnValue = global_constants.SCORM_FALSE; + var foundFirstIndex = false; + var invalidErrorMessage = "The data model element passed to ".concat(methodName, " (").concat(CMIElement, ") is not a valid SCORM data model element."); + var invalidErrorCode = scorm2004 ? _classPrivateFieldGet(this, _error_codes).UNDEFINED_DATA_MODEL : _classPrivateFieldGet(this, _error_codes).GENERAL; + + for (var i = 0; i < structure.length; i++) { + var attribute = structure[i]; + + if (i === structure.length - 1) { + if (scorm2004 && attribute.substr(0, 8) === '{target=' && typeof refObject._isTargetValid == 'function') { + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).READ_ONLY_ELEMENT); + } else if (!this._checkObjectHasProperty(refObject, attribute)) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + } else { + if (this.isInitialized() && this.stringMatches(CMIElement, '\\.correct_responses\\.\\d+')) { + this.validateCorrectResponse(CMIElement, value); + } + + if (!scorm2004 || this.lastErrorCode === 0) { + refObject[attribute] = value; + returnValue = global_constants.SCORM_TRUE; + } + } + } else { + refObject = refObject[attribute]; + + if (!refObject) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + break; + } + + if (refObject instanceof _common.CMIArray) { + var index = parseInt(structure[i + 1], 10); // SCO is trying to set an item on an array + + if (!isNaN(index)) { + var item = refObject.childArray[index]; + + if (item) { + refObject = item; + foundFirstIndex = true; + } else { + var newChild = this.getChildElement(CMIElement, value, foundFirstIndex); + foundFirstIndex = true; + + if (!newChild) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + } else { + if (refObject.initialized) newChild.initialize(); + refObject.childArray.push(newChild); + refObject = newChild; + } + } // Have to update i value to skip the array position + + + i++; + } + } + } + } + + if (returnValue === global_constants.SCORM_FALSE) { + this.apiLog(methodName, null, "There was an error setting the value for: ".concat(CMIElement, ", value of: ").concat(value), global_constants.LOG_LEVEL_WARNING); + } + + return returnValue; + } + /** + * Abstract method for validating that a response is correct. + * + * @param {string} _CMIElement + * @param {*} _value + */ + + }, { + key: "validateCorrectResponse", + value: function validateCorrectResponse(_CMIElement, _value) {// just a stub method + } + /** + * Gets or builds a new child element to add to the array. + * APIs that inherit BaseAPI should override this method. + * + * @param {string} _CMIElement - unused + * @param {*} _value - unused + * @param {boolean} _foundFirstIndex - unused + * @return {*} + * @abstract + */ + + }, { + key: "getChildElement", + value: function getChildElement(_CMIElement, _value, _foundFirstIndex) { + throw new Error('The getChildElement method has not been implemented'); + } + /** + * Gets a value from the CMI Object + * + * @param {string} methodName + * @param {boolean} scorm2004 + * @param {string} CMIElement + * @return {*} + */ + + }, { + key: "_commonGetCMIValue", + value: function _commonGetCMIValue(methodName, scorm2004, CMIElement) { + if (!CMIElement || CMIElement === '') { + return ''; + } + + var structure = CMIElement.split('.'); + var refObject = this; + var attribute = null; + var uninitializedErrorMessage = "The data model element passed to ".concat(methodName, " (").concat(CMIElement, ") has not been initialized."); + var invalidErrorMessage = "The data model element passed to ".concat(methodName, " (").concat(CMIElement, ") is not a valid SCORM data model element."); + var invalidErrorCode = scorm2004 ? _classPrivateFieldGet(this, _error_codes).UNDEFINED_DATA_MODEL : _classPrivateFieldGet(this, _error_codes).GENERAL; + + for (var i = 0; i < structure.length; i++) { + attribute = structure[i]; + + if (!scorm2004) { + if (i === structure.length - 1) { + if (!this._checkObjectHasProperty(refObject, attribute)) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + return; + } + } + } else { + if (String(attribute).substr(0, 8) === '{target=' && typeof refObject._isTargetValid == 'function') { + var target = String(attribute).substr(8, String(attribute).length - 9); + return refObject._isTargetValid(target); + } else if (!this._checkObjectHasProperty(refObject, attribute)) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + return; + } + } + + refObject = refObject[attribute]; + + if (refObject === undefined) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + break; + } + + if (refObject instanceof _common.CMIArray) { + var index = parseInt(structure[i + 1], 10); // SCO is trying to set an item on an array + + if (!isNaN(index)) { + var item = refObject.childArray[index]; + + if (item) { + refObject = item; + } else { + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).VALUE_NOT_INITIALIZED, uninitializedErrorMessage); + break; + } // Have to update i value to skip the array position + + + i++; + } + } + } + + if (refObject === null || refObject === undefined) { + if (!scorm2004) { + if (attribute === '_children') { + this.throwSCORMError(scorm12_error_codes.CHILDREN_ERROR); + } else if (attribute === '_count') { + this.throwSCORMError(scorm12_error_codes.COUNT_ERROR); + } + } + } else { + return refObject; + } + } + /** + * Returns true if the API's current state is STATE_INITIALIZED + * + * @return {boolean} + */ + + }, { + key: "isInitialized", + value: function isInitialized() { + return this.currentState === global_constants.STATE_INITIALIZED; + } + /** + * Returns true if the API's current state is STATE_NOT_INITIALIZED + * + * @return {boolean} + */ + + }, { + key: "isNotInitialized", + value: function isNotInitialized() { + return this.currentState === global_constants.STATE_NOT_INITIALIZED; + } + /** + * Returns true if the API's current state is STATE_TERMINATED + * + * @return {boolean} + */ + + }, { + key: "isTerminated", + value: function isTerminated() { + return this.currentState === global_constants.STATE_TERMINATED; + } + /** + * Provides a mechanism for attaching to a specific SCORM event + * + * @param {string} listenerName + * @param {function} callback + */ + + }, { + key: "on", + value: function on(listenerName, callback) { + if (!callback) return; + var listenerFunctions = listenerName.split(' '); + + for (var i = 0; i < listenerFunctions.length; i++) { + var listenerSplit = listenerFunctions[i].split('.'); + if (listenerSplit.length === 0) return; + var functionName = listenerSplit[0]; + var CMIElement = null; + + if (listenerSplit.length > 1) { + CMIElement = listenerName.replace(functionName + '.', ''); + } + + this.listenerArray.push({ + functionName: functionName, + CMIElement: CMIElement, + callback: callback + }); + this.apiLog('on', functionName, "Added event listener: ".concat(this.listenerArray.length), global_constants.LOG_LEVEL_INFO); + } + } + /** + * Provides a mechanism for detaching a specific SCORM event listener + * + * @param {string} listenerName + * @param {function} callback + */ + + }, { + key: "off", + value: function off(listenerName, callback) { + var _this = this; + + if (!callback) return; + var listenerFunctions = listenerName.split(' '); + + var _loop = function _loop(i) { + var listenerSplit = listenerFunctions[i].split('.'); + if (listenerSplit.length === 0) return { + v: void 0 + }; + var functionName = listenerSplit[0]; + var CMIElement = null; + + if (listenerSplit.length > 1) { + CMIElement = listenerName.replace(functionName + '.', ''); + } + + var removeIndex = _this.listenerArray.findIndex(function (obj) { + return obj.functionName === functionName && obj.CMIElement === CMIElement && obj.callback === callback; + }); + + if (removeIndex !== -1) { + _this.listenerArray.splice(removeIndex, 1); + + _this.apiLog('off', functionName, "Removed event listener: ".concat(_this.listenerArray.length), global_constants.LOG_LEVEL_INFO); + } + }; + + for (var i = 0; i < listenerFunctions.length; i++) { + var _ret = _loop(i); + + if (_typeof(_ret) === "object") return _ret.v; + } + } + /** + * Provides a mechanism for clearing all listeners from a specific SCORM event + * + * @param {string} listenerName + */ + + }, { + key: "clear", + value: function clear(listenerName) { + var _this2 = this; + + var listenerFunctions = listenerName.split(' '); + + var _loop2 = function _loop2(i) { + var listenerSplit = listenerFunctions[i].split('.'); + if (listenerSplit.length === 0) return { + v: void 0 + }; + var functionName = listenerSplit[0]; + var CMIElement = null; + + if (listenerSplit.length > 1) { + CMIElement = listenerName.replace(functionName + '.', ''); + } + + _this2.listenerArray = _this2.listenerArray.filter(function (obj) { + return obj.functionName !== functionName && obj.CMIElement !== CMIElement; + }); + }; + + for (var i = 0; i < listenerFunctions.length; i++) { + var _ret2 = _loop2(i); + + if (_typeof(_ret2) === "object") return _ret2.v; + } + } + /** + * Processes any 'on' listeners that have been created + * + * @param {string} functionName + * @param {string} CMIElement + * @param {*} value + */ + + }, { + key: "processListeners", + value: function processListeners(functionName, CMIElement, value) { + this.apiLog(functionName, CMIElement, value); + + for (var i = 0; i < this.listenerArray.length; i++) { + var listener = this.listenerArray[i]; + var functionsMatch = listener.functionName === functionName; + var listenerHasCMIElement = !!listener.CMIElement; + var CMIElementsMatch = false; + + if (CMIElement && listener.CMIElement && listener.CMIElement.substring(listener.CMIElement.length - 1) === '*') { + CMIElementsMatch = CMIElement.indexOf(listener.CMIElement.substring(0, listener.CMIElement.length - 1)) === 0; + } else { + CMIElementsMatch = listener.CMIElement === CMIElement; + } + + if (functionsMatch && (!listenerHasCMIElement || CMIElementsMatch)) { + listener.callback(CMIElement, value); + } + } + } + /** + * Throws a SCORM error + * + * @param {number} errorNumber + * @param {string} message + */ + + }, { + key: "throwSCORMError", + value: function throwSCORMError(errorNumber, message) { + if (!message) { + message = this.getLmsErrorMessageDetails(errorNumber); + } + + this.apiLog('throwSCORMError', null, errorNumber + ': ' + message, global_constants.LOG_LEVEL_ERROR); + this.lastErrorCode = String(errorNumber); + } + /** + * Clears the last SCORM error code on success. + * + * @param {string} success + */ + + }, { + key: "clearSCORMError", + value: function clearSCORMError(success) { + if (success !== undefined && success !== global_constants.SCORM_FALSE) { + this.lastErrorCode = 0; + } + } + /** + * Attempts to store the data to the LMS, logs data if no LMS configured + * APIs that inherit BaseAPI should override this function + * + * @param {boolean} _calculateTotalTime + * @return {string} + * @abstract + */ + + }, { + key: "storeData", + value: function storeData(_calculateTotalTime) { + throw new Error('The storeData method has not been implemented'); + } + /** + * Load the CMI from a flattened JSON object + * @param {object} json + * @param {string} CMIElement + */ + + }, { + key: "loadFromFlattenedJSON", + value: function loadFromFlattenedJSON(json, CMIElement) { + var _this3 = this; + + if (!this.isNotInitialized()) { + console.error('loadFromFlattenedJSON can only be called before the call to lmsInitialize.'); + return; + } + /** + * Test match pattern. + * + * @param {string} a + * @param {string} c + * @param {RegExp} a_pattern + * @return {number} + */ + + + function testPattern(a, c, a_pattern) { + var a_match = a.match(a_pattern); + var c_match; + + if (a_match !== null && (c_match = c.match(a_pattern)) !== null) { + var a_num = Number(a_match[2]); + var c_num = Number(c_match[2]); + + if (a_num === c_num) { + if (a_match[3] === 'id') { + return -1; + } else if (a_match[3] === 'type') { + if (c_match[3] === 'id') { + return 1; + } else { + return -1; + } + } else { + return 1; + } + } + + return a_num - c_num; + } + + return null; + } + + var int_pattern = /^(cmi\.interactions\.)(\d+)\.(.*)$/; + var obj_pattern = /^(cmi\.objectives\.)(\d+)\.(.*)$/; + var result = Object.keys(json).map(function (key) { + return [String(key), json[key]]; + }); // CMI interactions need to have id and type loaded before any other fields + + result.sort(function (_ref, _ref2) { + var _ref3 = _slicedToArray(_ref, 2), + a = _ref3[0], + b = _ref3[1]; + + var _ref4 = _slicedToArray(_ref2, 2), + c = _ref4[0], + d = _ref4[1]; + + var test; + + if ((test = testPattern(a, c, int_pattern)) !== null) { + return test; + } + + if ((test = testPattern(a, c, obj_pattern)) !== null) { + return test; + } + + if (a < c) { + return -1; + } + + if (a > c) { + return 1; + } + + return 0; + }); + var obj; + result.forEach(function (element) { + obj = {}; + obj[element[0]] = element[1]; + + _this3.loadFromJSON((0, _utilities.unflatten)(obj), CMIElement); + }); + } + /** + * Loads CMI data from a JSON object. + * + * @param {object} json + * @param {string} CMIElement + */ + + }, { + key: "loadFromJSON", + value: function loadFromJSON(json, CMIElement) { + if (!this.isNotInitialized()) { + console.error('loadFromJSON can only be called before the call to lmsInitialize.'); + return; + } + + CMIElement = CMIElement !== undefined ? CMIElement : 'cmi'; + this.startingData = json; // could this be refactored down to flatten(json) then setCMIValue on each? + + for (var key in json) { + if ({}.hasOwnProperty.call(json, key) && json[key]) { + var currentCMIElement = (CMIElement ? CMIElement + '.' : '') + key; + var value = json[key]; + + if (value['childArray']) { + for (var i = 0; i < value['childArray'].length; i++) { + this.loadFromJSON(value['childArray'][i], currentCMIElement + '.' + i); + } + } else if (value.constructor === Object) { + this.loadFromJSON(value, currentCMIElement); + } else { + this.setCMIValue(currentCMIElement, value); + } + } + } + } + /** + * Render the CMI object to JSON for sending to an LMS. + * + * @return {string} + */ + + }, { + key: "renderCMIToJSONString", + value: function renderCMIToJSONString() { + var cmi = this.cmi; // Do we want/need to return fields that have no set value? + // return JSON.stringify({ cmi }, (k, v) => v === undefined ? null : v, 2); + + return JSON.stringify({ + cmi: cmi + }); + } + /** + * Returns a JS object representing the current cmi + * @return {object} + */ + + }, { + key: "renderCMIToJSONObject", + value: function renderCMIToJSONObject() { + // Do we want/need to return fields that have no set value? + // return JSON.stringify({ cmi }, (k, v) => v === undefined ? null : v, 2); + return JSON.parse(this.renderCMIToJSONString()); + } + /** + * Render the cmi object to the proper format for LMS commit + * APIs that inherit BaseAPI should override this function + * + * @param {boolean} _terminateCommit + * @return {*} + * @abstract + */ + + }, { + key: "renderCommitCMI", + value: function renderCommitCMI(_terminateCommit) { + throw new Error('The storeData method has not been implemented'); + } + /** + * Send the request to the LMS + * @param {string} url + * @param {object|Array} params + * @param {boolean} immediate + * @return {object} + */ + + }, { + key: "processHttpRequest", + value: function processHttpRequest(url, params) { + var immediate = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + var api = this; + + var process = function process(url, params, settings, error_codes) { + var genericError = { + 'result': global_constants.SCORM_FALSE, + 'errorCode': error_codes.GENERAL + }; + var result; + + if (!settings.sendBeaconCommit) { + var httpReq = new XMLHttpRequest(); + httpReq.open('POST', url, settings.asyncCommit); + + if (settings.asyncCommit) { + httpReq.onload = function (e) { + if (typeof settings.responseHandler === 'function') { + result = settings.responseHandler(httpReq); + } else { + result = JSON.parse(httpReq.responseText); + } + }; + } + + try { + if (params instanceof Array) { + httpReq.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded'); + httpReq.send(params.join('&')); + } else { + httpReq.setRequestHeader('Content-Type', settings.commitRequestDataType); + httpReq.send(JSON.stringify(params)); + } + + if (!settings.asyncCommit) { + if (typeof settings.responseHandler === 'function') { + result = settings.responseHandler(httpReq); + } else { + result = JSON.parse(httpReq.responseText); + } + } else { + result = {}; + result.result = global_constants.SCORM_TRUE; + result.errorCode = 0; + api.processListeners('CommitSuccess'); + return result; + } + } catch (e) { + console.error(e); + api.processListeners('CommitError'); + return genericError; + } + } else { + try { + var headers = { + type: settings.commitRequestDataType + }; + var blob; + + if (params instanceof Array) { + blob = new Blob([params.join('&')], headers); + } else { + blob = new Blob([JSON.stringify(params)], headers); + } + + result = {}; + + if (navigator.sendBeacon(url, blob)) { + result.result = global_constants.SCORM_TRUE; + result.errorCode = 0; + } else { + result.result = global_constants.SCORM_FALSE; + result.errorCode = 101; + } + } catch (e) { + console.error(e); + api.processListeners('CommitError'); + return genericError; + } + } + + if (typeof result === 'undefined') { + api.processListeners('CommitError'); + return genericError; + } + + if (result.result === true || result.result === global_constants.SCORM_TRUE) { + api.processListeners('CommitSuccess'); + } else { + api.processListeners('CommitError'); + } + + return result; + }; + + if (typeof _lodash["default"] !== 'undefined') { + var debounced = (0, _lodash["default"])(process, 500); + debounced(url, params, this.settings, this.error_codes); // if we're terminating, go ahead and commit immediately + + if (immediate) { + debounced.flush(); + } + + return { + result: global_constants.SCORM_TRUE, + errorCode: 0 + }; + } else { + return process(url, params, this.settings, this.error_codes); + } + } + /** + * Throws a SCORM error + * + * @param {number} when - the number of milliseconds to wait before committing + * @param {string} callback - the name of the commit event callback + */ + + }, { + key: "scheduleCommit", + value: function scheduleCommit(when, callback) { + _classPrivateFieldSet(this, _timeout, new ScheduledCommit(this, when, callback)); + + this.apiLog('scheduleCommit', '', 'scheduled', global_constants.LOG_LEVEL_DEBUG); + } + /** + * Clears and cancels any currently scheduled commits + */ + + }, { + key: "clearScheduledCommit", + value: function clearScheduledCommit() { + if (_classPrivateFieldGet(this, _timeout)) { + _classPrivateFieldGet(this, _timeout).cancel(); + + _classPrivateFieldSet(this, _timeout, null); + + this.apiLog('clearScheduledCommit', '', 'cleared', global_constants.LOG_LEVEL_DEBUG); + } + } + }]); + + return BaseAPI; +}(); +/** + * Private class that wraps a timeout call to the commit() function + */ + + +exports["default"] = BaseAPI; + +var _API = new WeakMap(); + +var _cancelled = new WeakMap(); + +var _timeout2 = new WeakMap(); + +var _callback = new WeakMap(); + +var ScheduledCommit = /*#__PURE__*/function () { + /** + * Constructor for ScheduledCommit + * @param {BaseAPI} API + * @param {number} when + * @param {string} callback + */ + function ScheduledCommit(API, when, callback) { + _classCallCheck(this, ScheduledCommit); + + _API.set(this, { + writable: true, + value: void 0 + }); + + _cancelled.set(this, { + writable: true, + value: false + }); + + _timeout2.set(this, { + writable: true, + value: void 0 + }); + + _callback.set(this, { + writable: true, + value: void 0 + }); + + _classPrivateFieldSet(this, _API, API); + + _classPrivateFieldSet(this, _timeout2, setTimeout(this.wrapper.bind(this), when)); + + _classPrivateFieldSet(this, _callback, callback); + } + /** + * Cancel any currently scheduled commit + */ + + + _createClass(ScheduledCommit, [{ + key: "cancel", + value: function cancel() { + _classPrivateFieldSet(this, _cancelled, true); + + if (_classPrivateFieldGet(this, _timeout2)) { + clearTimeout(_classPrivateFieldGet(this, _timeout2)); + } + } + /** + * Wrap the API commit call to check if the call has already been cancelled + */ + + }, { + key: "wrapper", + value: function wrapper() { + if (!_classPrivateFieldGet(this, _cancelled)) { + _classPrivateFieldGet(this, _API).commit(_classPrivateFieldGet(this, _callback)); + } + } + }]); + + return ScheduledCommit; +}(); + +},{"./cmi/common":4,"./constants/api_constants":6,"./constants/error_codes":7,"./exceptions":11,"./utilities":13,"lodash.debounce":1}],3:[function(require,module,exports){ +"use strict"; + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +var _BaseAPI2 = _interopRequireDefault(require("./BaseAPI")); + +var _scorm2004_cmi = require("./cmi/scorm2004_cmi"); + +var Utilities = _interopRequireWildcard(require("./utilities")); + +var _api_constants = _interopRequireDefault(require("./constants/api_constants")); + +var _error_codes = _interopRequireDefault(require("./constants/error_codes")); + +var _response_constants = _interopRequireDefault(require("./constants/response_constants")); + +var _language_constants = _interopRequireDefault(require("./constants/language_constants")); + +var _regex = _interopRequireDefault(require("./constants/regex")); + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); } + +function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); } + +function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +var scorm2004_constants = _api_constants["default"].scorm2004; +var global_constants = _api_constants["default"].global; +var scorm2004_error_codes = _error_codes["default"].scorm2004; +var correct_responses = _response_constants["default"].correct; +var scorm2004_regex = _regex["default"].scorm2004; +/** + * API class for SCORM 2004 + */ + +var _version = new WeakMap(); + +var Scorm2004API = /*#__PURE__*/function (_BaseAPI) { + _inherits(Scorm2004API, _BaseAPI); + + var _super = _createSuper(Scorm2004API); + + /** + * Constructor for SCORM 2004 API + * @param {object} settings + */ + function Scorm2004API(settings) { + var _this; + + _classCallCheck(this, Scorm2004API); + + var finalSettings = _objectSpread(_objectSpread({}, { + mastery_override: false + }), settings); + + _this = _super.call(this, scorm2004_error_codes, finalSettings); + + _version.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _defineProperty(_assertThisInitialized(_this), "checkDuplicatedPattern", function (correct_response, current_index, value) { + var found = false; + var count = correct_response._count; + + for (var i = 0; i < count && !found; i++) { + if (i !== current_index && correct_response.childArray[i] === value) { + found = true; + } + } + + return found; + }); + + _this.cmi = new _scorm2004_cmi.CMI(); + _this.adl = new _scorm2004_cmi.ADL(); // Rename functions to match 2004 Spec and expose to modules + + _this.Initialize = _this.lmsInitialize; + _this.Terminate = _this.lmsTerminate; + _this.GetValue = _this.lmsGetValue; + _this.SetValue = _this.lmsSetValue; + _this.Commit = _this.lmsCommit; + _this.GetLastError = _this.lmsGetLastError; + _this.GetErrorString = _this.lmsGetErrorString; + _this.GetDiagnostic = _this.lmsGetDiagnostic; + return _this; + } + /** + * Getter for #version + * @return {string} + */ + + + _createClass(Scorm2004API, [{ + key: "version", + get: function get() { + return _classPrivateFieldGet(this, _version); + } + /** + * @return {string} bool + */ + + }, { + key: "lmsInitialize", + value: function lmsInitialize() { + this.cmi.initialize(); + return this.initialize('Initialize'); + } + /** + * @return {string} bool + */ + + }, { + key: "lmsTerminate", + value: function lmsTerminate() { + var result = this.terminate('Terminate', true); + + if (result === global_constants.SCORM_TRUE) { + if (this.adl.nav.request !== '_none_') { + switch (this.adl.nav.request) { + case 'continue': + this.processListeners('SequenceNext'); + break; + + case 'previous': + this.processListeners('SequencePrevious'); + break; + + case 'choice': + this.processListeners('SequenceChoice'); + break; + + case 'exit': + this.processListeners('SequenceExit'); + break; + + case 'exitAll': + this.processListeners('SequenceExitAll'); + break; + + case 'abandon': + this.processListeners('SequenceAbandon'); + break; + + case 'abandonAll': + this.processListeners('SequenceAbandonAll'); + break; + } + } else if (this.settings.autoProgress) { + this.processListeners('SequenceNext'); + } + } + + return result; + } + /** + * @param {string} CMIElement + * @return {string} + */ + + }, { + key: "lmsGetValue", + value: function lmsGetValue(CMIElement) { + return this.getValue('GetValue', true, CMIElement); + } + /** + * @param {string} CMIElement + * @param {any} value + * @return {string} + */ + + }, { + key: "lmsSetValue", + value: function lmsSetValue(CMIElement, value) { + return this.setValue('SetValue', 'Commit', true, CMIElement, value); + } + /** + * Orders LMS to store all content parameters + * + * @return {string} bool + */ + + }, { + key: "lmsCommit", + value: function lmsCommit() { + return this.commit('Commit'); + } + /** + * Returns last error code + * + * @return {string} + */ + + }, { + key: "lmsGetLastError", + value: function lmsGetLastError() { + return this.getLastError('GetLastError'); + } + /** + * Returns the errorNumber error description + * + * @param {(string|number)} CMIErrorCode + * @return {string} + */ + + }, { + key: "lmsGetErrorString", + value: function lmsGetErrorString(CMIErrorCode) { + return this.getErrorString('GetErrorString', CMIErrorCode); + } + /** + * Returns a comprehensive description of the errorNumber error. + * + * @param {(string|number)} CMIErrorCode + * @return {string} + */ + + }, { + key: "lmsGetDiagnostic", + value: function lmsGetDiagnostic(CMIErrorCode) { + return this.getDiagnostic('GetDiagnostic', CMIErrorCode); + } + /** + * Sets a value on the CMI Object + * + * @param {string} CMIElement + * @param {any} value + * @return {string} + */ + + }, { + key: "setCMIValue", + value: function setCMIValue(CMIElement, value) { + return this._commonSetCMIValue('SetValue', true, CMIElement, value); + } + /** + * Gets or builds a new child element to add to the array. + * + * @param {string} CMIElement + * @param {any} value + * @param {boolean} foundFirstIndex + * @return {any} + */ + + }, { + key: "getChildElement", + value: function getChildElement(CMIElement, value, foundFirstIndex) { + var newChild; + + if (this.stringMatches(CMIElement, 'cmi\\.objectives\\.\\d+')) { + newChild = new _scorm2004_cmi.CMIObjectivesObject(); + } else if (foundFirstIndex && this.stringMatches(CMIElement, 'cmi\\.interactions\\.\\d+\\.correct_responses\\.\\d+')) { + var parts = CMIElement.split('.'); + var index = Number(parts[2]); + var interaction = this.cmi.interactions.childArray[index]; + + if (this.isInitialized()) { + if (!interaction.type) { + this.throwSCORMError(scorm2004_error_codes.DEPENDENCY_NOT_ESTABLISHED); + } else { + this.checkDuplicateChoiceResponse(interaction, value); + var response_type = correct_responses[interaction.type]; + + if (response_type) { + this.checkValidResponseType(response_type, value, interaction.type); + } else { + this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE, 'Incorrect Response Type: ' + interaction.type); + } + } + } + + if (this.lastErrorCode === 0) { + newChild = new _scorm2004_cmi.CMIInteractionsCorrectResponsesObject(); + } + } else if (foundFirstIndex && this.stringMatches(CMIElement, 'cmi\\.interactions\\.\\d+\\.objectives\\.\\d+')) { + newChild = new _scorm2004_cmi.CMIInteractionsObjectivesObject(); + } else if (!foundFirstIndex && this.stringMatches(CMIElement, 'cmi\\.interactions\\.\\d+')) { + newChild = new _scorm2004_cmi.CMIInteractionsObject(); + } else if (this.stringMatches(CMIElement, 'cmi\\.comments_from_learner\\.\\d+')) { + newChild = new _scorm2004_cmi.CMICommentsObject(); + } else if (this.stringMatches(CMIElement, 'cmi\\.comments_from_lms\\.\\d+')) { + newChild = new _scorm2004_cmi.CMICommentsObject(true); + } + + return newChild; + } + /** + * Checks for valid response types + * @param {object} response_type + * @param {any} value + * @param {string} interaction_type + */ + + }, { + key: "checkValidResponseType", + value: function checkValidResponseType(response_type, value, interaction_type) { + var nodes = []; + + if (response_type !== null && response_type !== void 0 && response_type.delimiter) { + nodes = String(value).split(response_type.delimiter); + } else { + nodes[0] = value; + } + + if (nodes.length > 0 && nodes.length <= response_type.max) { + this.checkCorrectResponseValue(interaction_type, nodes, value); + } else if (nodes.length > response_type.max) { + this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE, 'Data Model Element Pattern Too Long'); + } + } + /** + * Checks for duplicate 'choice' responses. + * @param {CMIInteractionsObject} interaction + * @param {any} value + */ + + }, { + key: "checkDuplicateChoiceResponse", + value: function checkDuplicateChoiceResponse(interaction, value) { + var interaction_count = interaction.correct_responses._count; + + if (interaction.type === 'choice') { + for (var i = 0; i < interaction_count && this.lastErrorCode === 0; i++) { + var response = interaction.correct_responses.childArray[i]; + + if (response.pattern === value) { + this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE); + } + } + } + } + /** + * Validate correct response. + * @param {string} CMIElement + * @param {*} value + */ + + }, { + key: "validateCorrectResponse", + value: function validateCorrectResponse(CMIElement, value) { + var parts = CMIElement.split('.'); + var index = Number(parts[2]); + var pattern_index = Number(parts[4]); + var interaction = this.cmi.interactions.childArray[index]; + var interaction_count = interaction.correct_responses._count; + this.checkDuplicateChoiceResponse(interaction, value); + var response_type = correct_responses[interaction.type]; + + if (typeof response_type.limit === 'undefined' || interaction_count <= response_type.limit) { + this.checkValidResponseType(response_type, value, interaction.type); + + if (this.lastErrorCode === 0 && (!response_type.duplicate || !this.checkDuplicatedPattern(interaction.correct_responses, pattern_index, value)) || this.lastErrorCode === 0 && value === '') {// do nothing, we want the inverse + } else { + if (this.lastErrorCode === 0) { + this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE, 'Data Model Element Pattern Already Exists'); + } + } + } else { + this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE, 'Data Model Element Collection Limit Reached'); + } + } + /** + * Gets a value from the CMI Object + * + * @param {string} CMIElement + * @return {*} + */ + + }, { + key: "getCMIValue", + value: function getCMIValue(CMIElement) { + return this._commonGetCMIValue('GetValue', true, CMIElement); + } + /** + * Returns the message that corresponds to errorNumber. + * + * @param {(string|number)} errorNumber + * @param {boolean} detail + * @return {string} + */ + + }, { + key: "getLmsErrorMessageDetails", + value: function getLmsErrorMessageDetails(errorNumber, detail) { + var basicMessage = ''; + var detailMessage = ''; // Set error number to string since inconsistent from modules if string or number + + errorNumber = String(errorNumber); + + if (scorm2004_constants.error_descriptions[errorNumber]) { + basicMessage = scorm2004_constants.error_descriptions[errorNumber].basicMessage; + detailMessage = scorm2004_constants.error_descriptions[errorNumber].detailMessage; + } + + return detail ? detailMessage : basicMessage; + } + /** + * Check to see if a correct_response value has been duplicated + * @param {CMIArray} correct_response + * @param {number} current_index + * @param {*} value + * @return {boolean} + */ + + }, { + key: "checkCorrectResponseValue", + value: + /** + * Checks for a valid correct_response value + * @param {string} interaction_type + * @param {Array} nodes + * @param {*} value + */ + function checkCorrectResponseValue(interaction_type, nodes, value) { + var response = correct_responses[interaction_type]; + var formatRegex = new RegExp(response.format); + + for (var i = 0; i < nodes.length && this.lastErrorCode === 0; i++) { + if (interaction_type.match('^(fill-in|long-fill-in|matching|performance|sequencing)$')) { + nodes[i] = this.removeCorrectResponsePrefixes(nodes[i]); + } + + if (response !== null && response !== void 0 && response.delimiter2) { + var values = nodes[i].split(response.delimiter2); + + if (values.length === 2) { + var matches = values[0].match(formatRegex); + + if (!matches) { + this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH); + } else { + if (!values[1].match(new RegExp(response.format2))) { + this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH); + } + } + } else { + this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH); + } + } else { + var _matches = nodes[i].match(formatRegex); + + if (!_matches && value !== '' || !_matches && interaction_type === 'true-false') { + this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH); + } else { + if (interaction_type === 'numeric' && nodes.length > 1) { + if (Number(nodes[0]) > Number(nodes[1])) { + this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH); + } + } else { + if (nodes[i] !== '' && response.unique) { + for (var j = 0; j < i && this.lastErrorCode === 0; j++) { + if (nodes[i] === nodes[j]) { + this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH); + } + } + } + } + } + } + } + } + /** + * Remove prefixes from correct_response + * @param {string} node + * @return {*} + */ + + }, { + key: "removeCorrectResponsePrefixes", + value: function removeCorrectResponsePrefixes(node) { + var seenOrder = false; + var seenCase = false; + var seenLang = false; + var prefixRegex = new RegExp('^({(lang|case_matters|order_matters)=([^}]+)})'); + var matches = node.match(prefixRegex); + var langMatches = null; + + while (matches) { + switch (matches[2]) { + case 'lang': + langMatches = node.match(scorm2004_regex.CMILangcr); + + if (langMatches) { + var lang = langMatches[3]; + + if (lang !== undefined && lang.length > 0) { + if (_language_constants["default"][lang.toLowerCase()] === undefined) { + this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH); + } + } + } + + seenLang = true; + break; + + case 'case_matters': + if (!seenLang && !seenOrder && !seenCase) { + if (matches[3] !== 'true' && matches[3] !== 'false') { + this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH); + } + } + + seenCase = true; + break; + + case 'order_matters': + if (!seenCase && !seenLang && !seenOrder) { + if (matches[3] !== 'true' && matches[3] !== 'false') { + this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH); + } + } + + seenOrder = true; + break; + + default: + break; + } + + node = node.substr(matches[1].length); + matches = node.match(prefixRegex); + } + + return node; + } + /** + * Replace the whole API with another + * @param {Scorm2004API} newAPI + */ + + }, { + key: "replaceWithAnotherScormAPI", + value: function replaceWithAnotherScormAPI(newAPI) { + // Data Model + this.cmi = newAPI.cmi; + this.adl = newAPI.adl; + } + /** + * Render the cmi object to the proper format for LMS commit + * + * @param {boolean} terminateCommit + * @return {object|Array} + */ + + }, { + key: "renderCommitCMI", + value: function renderCommitCMI(terminateCommit) { + var cmiExport = this.renderCMIToJSONObject(); + + if (terminateCommit) { + cmiExport.cmi.total_time = this.cmi.getCurrentTotalTime(); + } + + var result = []; + var flattened = Utilities.flatten(cmiExport); + + switch (this.settings.dataCommitFormat) { + case 'flattened': + return Utilities.flatten(cmiExport); + + case 'params': + for (var item in flattened) { + if ({}.hasOwnProperty.call(flattened, item)) { + result.push("".concat(item, "=").concat(flattened[item])); + } + } + + return result; + + case 'json': + default: + return cmiExport; + } + } + /** + * Attempts to store the data to the LMS + * + * @param {boolean} terminateCommit + * @return {string} + */ + + }, { + key: "storeData", + value: function storeData(terminateCommit) { + var _this$startingData, _this$startingData$ad, _this$startingData$ad2; + + if (terminateCommit) { + if (this.cmi.mode === 'normal') { + if (this.cmi.credit === 'credit') { + if (this.cmi.completion_threshold && this.cmi.progress_measure) { + if (this.cmi.progress_measure >= this.cmi.completion_threshold) { + console.debug('Setting Completion Status: Completed'); + this.cmi.completion_status = 'completed'; + } else { + console.debug('Setting Completion Status: Incomplete'); + this.cmi.completion_status = 'incomplete'; + } + } + + if (this.cmi.scaled_passing_score && this.cmi.score.scaled) { + if (this.cmi.score.scaled >= this.cmi.scaled_passing_score) { + console.debug('Setting Success Status: Passed'); + this.cmi.success_status = 'passed'; + } else { + console.debug('Setting Success Status: Failed'); + this.cmi.success_status = 'failed'; + } + } + } + } + } + + var navRequest = false; + + if (this.adl.nav.request !== ((_this$startingData = this.startingData) === null || _this$startingData === void 0 ? void 0 : (_this$startingData$ad = _this$startingData.adl) === null || _this$startingData$ad === void 0 ? void 0 : (_this$startingData$ad2 = _this$startingData$ad.nav) === null || _this$startingData$ad2 === void 0 ? void 0 : _this$startingData$ad2.request) && this.adl.nav.request !== '_none_') { + this.adl.nav.request = encodeURIComponent(this.adl.nav.request); + navRequest = true; + } + + var commitObject = this.renderCommitCMI(terminateCommit || this.settings.alwaysSendTotalTime); + + if (this.apiLogLevel === global_constants.LOG_LEVEL_DEBUG) { + console.debug('Commit (terminated: ' + (terminateCommit ? 'yes' : 'no') + '): '); + console.debug(commitObject); + } + + if (this.settings.lmsCommitUrl) { + var result = this.processHttpRequest(this.settings.lmsCommitUrl, commitObject, terminateCommit); // check if this is a sequencing call, and then call the necessary JS + + { + if (navRequest && result.navRequest !== undefined && result.navRequest !== '') { + Function("\"use strict\";(() => { ".concat(result.navRequest, " })()"))(); + } + } + return result; + } else { + return global_constants.SCORM_TRUE; + } + } + }]); + + return Scorm2004API; +}(_BaseAPI2["default"]); + +exports["default"] = Scorm2004API; + +},{"./BaseAPI":2,"./cmi/scorm2004_cmi":5,"./constants/api_constants":6,"./constants/error_codes":7,"./constants/language_constants":8,"./constants/regex":9,"./constants/response_constants":10,"./utilities":13}],4:[function(require,module,exports){ +"use strict"; + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.checkValidFormat = checkValidFormat; +exports.checkValidRange = checkValidRange; +exports.CMIArray = exports.CMIScore = exports.BaseCMI = void 0; + +var _api_constants = _interopRequireDefault(require("../constants/api_constants")); + +var _error_codes = _interopRequireDefault(require("../constants/error_codes")); + +var _regex = _interopRequireDefault(require("../constants/regex")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; } + +function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } } + +function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); } + +function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); } + +function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +var scorm12_constants = _api_constants["default"].scorm12; +var scorm12_regex = _regex["default"].scorm12; +var scorm12_error_codes = _error_codes["default"].scorm12; +/** + * Check if the value matches the proper format. If not, throw proper error code. + * + * @param {string} value + * @param {string} regexPattern + * @param {number} errorCode + * @param {class} errorClass + * @param {boolean} allowEmptyString + * @return {boolean} + */ + +function checkValidFormat(value, regexPattern, errorCode, errorClass, allowEmptyString) { + var formatRegex = new RegExp(regexPattern); + var matches = value.match(formatRegex); + + if (allowEmptyString && value === '') { + return true; + } + + if (value === undefined || !matches || matches[0] === '') { + throw new errorClass.prototype.constructor(errorCode); + } + + return true; +} +/** + * Check if the value matches the proper range. If not, throw proper error code. + * + * @param {*} value + * @param {string} rangePattern + * @param {number} errorCode + * @param {class} errorClass + * @return {boolean} + */ + + +function checkValidRange(value, rangePattern, errorCode, errorClass) { + var ranges = rangePattern.split('#'); + value = value * 1.0; + + if (value >= ranges[0]) { + if (ranges[1] === '*' || value <= ranges[1]) { + return true; + } else { + throw new errorClass.prototype.constructor(errorCode); + } + } else { + throw new errorClass.prototype.constructor(errorCode); + } +} +/** + * Base class for API cmi objects + */ + + +var _initialized = new WeakMap(); + +var _start_time = new WeakMap(); + +var BaseCMI = /*#__PURE__*/function () { + /** + * Constructor for BaseCMI, just marks the class as abstract + */ + function BaseCMI() { + _classCallCheck(this, BaseCMI); + + _defineProperty(this, "jsonString", false); + + _initialized.set(this, { + writable: true, + value: false + }); + + _start_time.set(this, { + writable: true, + value: void 0 + }); + + if ((this instanceof BaseCMI ? this.constructor : void 0) === BaseCMI) { + throw new TypeError('Cannot construct BaseCMI instances directly'); + } + } + /** + * Getter for #initialized + * @return {boolean} + */ + + + _createClass(BaseCMI, [{ + key: "initialized", + get: function get() { + return _classPrivateFieldGet(this, _initialized); + } + /** + * Getter for #start_time + * @return {Number} + */ + + }, { + key: "start_time", + get: function get() { + return _classPrivateFieldGet(this, _start_time); + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + }, { + key: "initialize", + value: function initialize() { + _classPrivateFieldSet(this, _initialized, true); + } + /** + * Called when the player should override the 'session_time' provided by + * the module + */ + + }, { + key: "setStartTime", + value: function setStartTime() { + _classPrivateFieldSet(this, _start_time, new Date().getTime()); + } + }]); + + return BaseCMI; +}(); +/** + * Base class for cmi *.score objects + */ + + +exports.BaseCMI = BaseCMI; + +var _children2 = new WeakMap(); + +var _score_range = new WeakMap(); + +var _invalid_error_code = new WeakMap(); + +var _invalid_type_code = new WeakMap(); + +var _invalid_range_code = new WeakMap(); + +var _decimal_regex = new WeakMap(); + +var _error_class = new WeakMap(); + +var _raw = new WeakMap(); + +var _min = new WeakMap(); + +var _max = new WeakMap(); + +var CMIScore = /*#__PURE__*/function (_BaseCMI) { + _inherits(CMIScore, _BaseCMI); + + var _super = _createSuper(CMIScore); + + /** + * Constructor for *.score + * @param {string} score_children + * @param {string} score_range + * @param {string} max + * @param {number} invalidErrorCode + * @param {number} invalidTypeCode + * @param {number} invalidRangeCode + * @param {string} decimalRegex + * @param {class} errorClass + */ + function CMIScore(_ref) { + var _this; + + var score_children = _ref.score_children, + score_range = _ref.score_range, + max = _ref.max, + invalidErrorCode = _ref.invalidErrorCode, + invalidTypeCode = _ref.invalidTypeCode, + invalidRangeCode = _ref.invalidRangeCode, + decimalRegex = _ref.decimalRegex, + errorClass = _ref.errorClass; + + _classCallCheck(this, CMIScore); + + _this = _super.call(this); + + _children2.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _score_range.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _invalid_error_code.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _invalid_type_code.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _invalid_range_code.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _decimal_regex.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _error_class.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _raw.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _min.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _max.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _classPrivateFieldSet(_assertThisInitialized(_this), _children2, score_children || scorm12_constants.score_children); + + _classPrivateFieldSet(_assertThisInitialized(_this), _score_range, !score_range ? false : scorm12_regex.score_range); + + _classPrivateFieldSet(_assertThisInitialized(_this), _max, max || max === '' ? max : '100'); + + _classPrivateFieldSet(_assertThisInitialized(_this), _invalid_error_code, invalidErrorCode || scorm12_error_codes.INVALID_SET_VALUE); + + _classPrivateFieldSet(_assertThisInitialized(_this), _invalid_type_code, invalidTypeCode || scorm12_error_codes.TYPE_MISMATCH); + + _classPrivateFieldSet(_assertThisInitialized(_this), _invalid_range_code, invalidRangeCode || scorm12_error_codes.VALUE_OUT_OF_RANGE); + + _classPrivateFieldSet(_assertThisInitialized(_this), _decimal_regex, decimalRegex || scorm12_regex.CMIDecimal); + + _classPrivateFieldSet(_assertThisInitialized(_this), _error_class, errorClass); + + return _this; + } + + _createClass(CMIScore, [{ + key: "_children", + get: + /** + * Getter for _children + * @return {string} + * @private + */ + function get() { + return _classPrivateFieldGet(this, _children2); + } + /** + * Setter for _children. Just throws an error. + * @param {string} _children + * @private + */ + , + set: function set(_children) { + throw new (_classPrivateFieldGet(this, _error_class).prototype.constructor)(_classPrivateFieldGet(this, _invalid_error_code)); + } + /** + * Getter for #raw + * @return {string} + */ + + }, { + key: "raw", + get: function get() { + return _classPrivateFieldGet(this, _raw); + } + /** + * Setter for #raw + * @param {string} raw + */ + , + set: function set(raw) { + if (checkValidFormat(raw, _classPrivateFieldGet(this, _decimal_regex), _classPrivateFieldGet(this, _invalid_type_code), _classPrivateFieldGet(this, _error_class)) && (!_classPrivateFieldGet(this, _score_range) || checkValidRange(raw, _classPrivateFieldGet(this, _score_range), _classPrivateFieldGet(this, _invalid_range_code), _classPrivateFieldGet(this, _error_class)))) { + _classPrivateFieldSet(this, _raw, raw); + } + } + /** + * Getter for #min + * @return {string} + */ + + }, { + key: "min", + get: function get() { + return _classPrivateFieldGet(this, _min); + } + /** + * Setter for #min + * @param {string} min + */ + , + set: function set(min) { + if (checkValidFormat(min, _classPrivateFieldGet(this, _decimal_regex), _classPrivateFieldGet(this, _invalid_type_code), _classPrivateFieldGet(this, _error_class)) && (!_classPrivateFieldGet(this, _score_range) || checkValidRange(min, _classPrivateFieldGet(this, _score_range), _classPrivateFieldGet(this, _invalid_range_code), _classPrivateFieldGet(this, _error_class)))) { + _classPrivateFieldSet(this, _min, min); + } + } + /** + * Getter for #max + * @return {string} + */ + + }, { + key: "max", + get: function get() { + return _classPrivateFieldGet(this, _max); + } + /** + * Setter for #max + * @param {string} max + */ + , + set: function set(max) { + if (checkValidFormat(max, _classPrivateFieldGet(this, _decimal_regex), _classPrivateFieldGet(this, _invalid_type_code), _classPrivateFieldGet(this, _error_class)) && (!_classPrivateFieldGet(this, _score_range) || checkValidRange(max, _classPrivateFieldGet(this, _score_range), _classPrivateFieldGet(this, _invalid_range_code), _classPrivateFieldGet(this, _error_class)))) { + _classPrivateFieldSet(this, _max, max); + } + } + /** + * toJSON for *.score + * @return {{min: string, max: string, raw: string}} + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'raw': this.raw, + 'min': this.min, + 'max': this.max + }; + delete this.jsonString; + return result; + } + }]); + + return CMIScore; +}(BaseCMI); +/** + * Base class for cmi *.n objects + */ + + +exports.CMIScore = CMIScore; + +var _errorCode = new WeakMap(); + +var _errorClass = new WeakMap(); + +var _children3 = new WeakMap(); + +var CMIArray = /*#__PURE__*/function (_BaseCMI2) { + _inherits(CMIArray, _BaseCMI2); + + var _super2 = _createSuper(CMIArray); + + /** + * Constructor cmi *.n arrays + * @param {string} children + * @param {number} errorCode + * @param {class} errorClass + */ + function CMIArray(_ref2) { + var _this2; + + var children = _ref2.children, + errorCode = _ref2.errorCode, + errorClass = _ref2.errorClass; + + _classCallCheck(this, CMIArray); + + _this2 = _super2.call(this); + + _errorCode.set(_assertThisInitialized(_this2), { + writable: true, + value: void 0 + }); + + _errorClass.set(_assertThisInitialized(_this2), { + writable: true, + value: void 0 + }); + + _children3.set(_assertThisInitialized(_this2), { + writable: true, + value: void 0 + }); + + _classPrivateFieldSet(_assertThisInitialized(_this2), _children3, children); + + _classPrivateFieldSet(_assertThisInitialized(_this2), _errorCode, errorCode); + + _classPrivateFieldSet(_assertThisInitialized(_this2), _errorClass, errorClass); + + _this2.childArray = []; + return _this2; + } + + _createClass(CMIArray, [{ + key: "_children", + get: + /** + * Getter for _children + * @return {*} + */ + function get() { + return _classPrivateFieldGet(this, _children3); + } + /** + * Setter for _children. Just throws an error. + * @param {string} _children + */ + , + set: function set(_children) { + throw new (_classPrivateFieldGet(this, _errorClass).prototype.constructor)(_classPrivateFieldGet(this, _errorCode)); + } + /** + * Getter for _count + * @return {number} + */ + + }, { + key: "_count", + get: function get() { + return this.childArray.length; + } + /** + * Setter for _count. Just throws an error. + * @param {number} _count + */ + , + set: function set(_count) { + throw new (_classPrivateFieldGet(this, _errorClass).prototype.constructor)(_classPrivateFieldGet(this, _errorCode)); + } + /** + * toJSON for *.n arrays + * @return {object} + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = {}; + + for (var i = 0; i < this.childArray.length; i++) { + result[i + ''] = this.childArray[i]; + } + + delete this.jsonString; + return result; + } + }]); + + return CMIArray; +}(BaseCMI); + +exports.CMIArray = CMIArray; + +},{"../constants/api_constants":6,"../constants/error_codes":7,"../constants/regex":9}],5:[function(require,module,exports){ +"use strict"; + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.ADL = exports.CMIInteractionsCorrectResponsesObject = exports.CMIInteractionsObjectivesObject = exports.CMICommentsObject = exports.CMIObjectivesObject = exports.CMIInteractionsObject = exports.CMI = void 0; + +var _common = require("./common"); + +var _api_constants = _interopRequireDefault(require("../constants/api_constants")); + +var _regex = _interopRequireDefault(require("../constants/regex")); + +var _error_codes = _interopRequireDefault(require("../constants/error_codes")); + +var _response_constants = _interopRequireDefault(require("../constants/response_constants")); + +var _exceptions = require("../exceptions"); + +var Util = _interopRequireWildcard(require("../utilities")); + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); } + +function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; } + +function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } } + +function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); } + +function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); } + +function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +var scorm2004_constants = _api_constants["default"].scorm2004; +var scorm2004_error_codes = _error_codes["default"].scorm2004; +var learner_responses = _response_constants["default"].learner; +var scorm2004_regex = _regex["default"].scorm2004; +/** + * Helper method for throwing Read Only error + */ + +function throwReadOnlyError() { + throw new _exceptions.Scorm2004ValidationError(scorm2004_error_codes.READ_ONLY_ELEMENT); +} +/** + * Helper method for throwing Write Only error + */ + + +function throwWriteOnlyError() { + throw new _exceptions.Scorm2004ValidationError(scorm2004_error_codes.WRITE_ONLY_ELEMENT); +} +/** + * Helper method for throwing Type Mismatch error + */ + + +function throwTypeMismatchError() { + throw new _exceptions.Scorm2004ValidationError(scorm2004_error_codes.TYPE_MISMATCH); +} +/** + * Helper method for throwing Dependency Not Established error + */ + + +function throwDependencyNotEstablishedError() { + throw new _exceptions.Scorm2004ValidationError(scorm2004_error_codes.DEPENDENCY_NOT_ESTABLISHED); +} +/** + * Helper method for throwing Dependency Not Established error + */ + + +function throwGeneralSetError() { + throw new _exceptions.Scorm2004ValidationError(scorm2004_error_codes.GENERAL_SET_FAILURE); +} +/** + * Helper method, no reason to have to pass the same error codes every time + * @param {*} value + * @param {string} regexPattern + * @param {boolean} allowEmptyString + * @return {boolean} + */ + + +function check2004ValidFormat(value, regexPattern, allowEmptyString) { + return (0, _common.checkValidFormat)(value, regexPattern, scorm2004_error_codes.TYPE_MISMATCH, _exceptions.Scorm2004ValidationError, allowEmptyString); +} +/** + * Helper method, no reason to have to pass the same error codes every time + * @param {*} value + * @param {string} rangePattern + * @return {boolean} + */ + + +function check2004ValidRange(value, rangePattern) { + return (0, _common.checkValidRange)(value, rangePattern, scorm2004_error_codes.VALUE_OUT_OF_RANGE, _exceptions.Scorm2004ValidationError); +} +/** + * Class representing cmi object for SCORM 2004 + */ + + +var _version2 = new WeakMap(); + +var _children2 = new WeakMap(); + +var _completion_status = new WeakMap(); + +var _completion_threshold = new WeakMap(); + +var _credit = new WeakMap(); + +var _entry = new WeakMap(); + +var _exit = new WeakMap(); + +var _launch_data = new WeakMap(); + +var _learner_id = new WeakMap(); + +var _learner_name = new WeakMap(); + +var _location = new WeakMap(); + +var _max_time_allowed = new WeakMap(); + +var _mode = new WeakMap(); + +var _progress_measure = new WeakMap(); + +var _scaled_passing_score = new WeakMap(); + +var _session_time = new WeakMap(); + +var _success_status = new WeakMap(); + +var _suspend_data = new WeakMap(); + +var _time_limit_action = new WeakMap(); + +var _total_time = new WeakMap(); + +var CMI = /*#__PURE__*/function (_BaseCMI) { + _inherits(CMI, _BaseCMI); + + var _super = _createSuper(CMI); + + /** + * Constructor for the SCORM 2004 cmi object + * @param {boolean} initialized + */ + function CMI(initialized) { + var _this; + + _classCallCheck(this, CMI); + + _this = _super.call(this); + + _version2.set(_assertThisInitialized(_this), { + writable: true, + value: '1.0' + }); + + _children2.set(_assertThisInitialized(_this), { + writable: true, + value: scorm2004_constants.cmi_children + }); + + _completion_status.set(_assertThisInitialized(_this), { + writable: true, + value: 'unknown' + }); + + _completion_threshold.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _credit.set(_assertThisInitialized(_this), { + writable: true, + value: 'credit' + }); + + _entry.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _exit.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _launch_data.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _learner_id.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _learner_name.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _location.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _max_time_allowed.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _mode.set(_assertThisInitialized(_this), { + writable: true, + value: 'normal' + }); + + _progress_measure.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _scaled_passing_score.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _session_time.set(_assertThisInitialized(_this), { + writable: true, + value: 'PT0H0M0S' + }); + + _success_status.set(_assertThisInitialized(_this), { + writable: true, + value: 'unknown' + }); + + _suspend_data.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _time_limit_action.set(_assertThisInitialized(_this), { + writable: true, + value: 'continue,no message' + }); + + _total_time.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _this.learner_preference = new CMILearnerPreference(); + _this.score = new Scorm2004CMIScore(); + _this.comments_from_learner = new CMICommentsFromLearner(); + _this.comments_from_lms = new CMICommentsFromLMS(); + _this.interactions = new CMIInteractions(); + _this.objectives = new CMIObjectives(); + if (initialized) _this.initialize(); + return _this; + } + + _createClass(CMI, [{ + key: "initialize", + value: + /** + * Called when the API has been initialized after the CMI has been created + */ + function initialize() { + var _this$learner_prefere, _this$score, _this$comments_from_l, _this$comments_from_l2, _this$interactions, _this$objectives; + + _get(_getPrototypeOf(CMI.prototype), "initialize", this).call(this); + + (_this$learner_prefere = this.learner_preference) === null || _this$learner_prefere === void 0 ? void 0 : _this$learner_prefere.initialize(); + (_this$score = this.score) === null || _this$score === void 0 ? void 0 : _this$score.initialize(); + (_this$comments_from_l = this.comments_from_learner) === null || _this$comments_from_l === void 0 ? void 0 : _this$comments_from_l.initialize(); + (_this$comments_from_l2 = this.comments_from_lms) === null || _this$comments_from_l2 === void 0 ? void 0 : _this$comments_from_l2.initialize(); + (_this$interactions = this.interactions) === null || _this$interactions === void 0 ? void 0 : _this$interactions.initialize(); + (_this$objectives = this.objectives) === null || _this$objectives === void 0 ? void 0 : _this$objectives.initialize(); + } + /** + * Getter for #_version + * @return {string} + * @private + */ + + }, { + key: "_version", + get: function get() { + return _classPrivateFieldGet(this, _version2); + } + /** + * Setter for #_version. Just throws an error. + * @param {string} _version + * @private + */ + , + set: function set(_version) { + throwReadOnlyError(); + } + /** + * Getter for #_children + * @return {string} + * @private + */ + + }, { + key: "_children", + get: function get() { + return _classPrivateFieldGet(this, _children2); + } + /** + * Setter for #_children. Just throws an error. + * @param {number} _children + * @private + */ + , + set: function set(_children) { + throwReadOnlyError(); + } + /** + * Getter for #completion_status + * @return {string} + */ + + }, { + key: "completion_status", + get: function get() { + return _classPrivateFieldGet(this, _completion_status); + } + /** + * Setter for #completion_status + * @param {string} completion_status + */ + , + set: function set(completion_status) { + if (check2004ValidFormat(completion_status, scorm2004_regex.CMICStatus)) { + _classPrivateFieldSet(this, _completion_status, completion_status); + } + } + /** + * Getter for #completion_threshold + * @return {string} + */ + + }, { + key: "completion_threshold", + get: function get() { + return _classPrivateFieldGet(this, _completion_threshold); + } + /** + * Setter for #completion_threshold. Can only be called before initialization. + * @param {string} completion_threshold + */ + , + set: function set(completion_threshold) { + !this.initialized ? _classPrivateFieldSet(this, _completion_threshold, completion_threshold) : throwReadOnlyError(); + } + /** + * Setter for #credit + * @return {string} + */ + + }, { + key: "credit", + get: function get() { + return _classPrivateFieldGet(this, _credit); + } + /** + * Setter for #credit. Can only be called before initialization. + * @param {string} credit + */ + , + set: function set(credit) { + !this.initialized ? _classPrivateFieldSet(this, _credit, credit) : throwReadOnlyError(); + } + /** + * Getter for #entry + * @return {string} + */ + + }, { + key: "entry", + get: function get() { + return _classPrivateFieldGet(this, _entry); + } + /** + * Setter for #entry. Can only be called before initialization. + * @param {string} entry + */ + , + set: function set(entry) { + !this.initialized ? _classPrivateFieldSet(this, _entry, entry) : throwReadOnlyError(); + } + /** + * Getter for #exit. Should only be called during JSON export. + * @return {string} + */ + + }, { + key: "exit", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _exit); + } + /** + * Getter for #exit + * @param {string} exit + */ + , + set: function set(exit) { + if (check2004ValidFormat(exit, scorm2004_regex.CMIExit, true)) { + _classPrivateFieldSet(this, _exit, exit); + } + } + /** + * Getter for #launch_data + * @return {string} + */ + + }, { + key: "launch_data", + get: function get() { + return _classPrivateFieldGet(this, _launch_data); + } + /** + * Setter for #launch_data. Can only be called before initialization. + * @param {string} launch_data + */ + , + set: function set(launch_data) { + !this.initialized ? _classPrivateFieldSet(this, _launch_data, launch_data) : throwReadOnlyError(); + } + /** + * Getter for #learner_id + * @return {string} + */ + + }, { + key: "learner_id", + get: function get() { + return _classPrivateFieldGet(this, _learner_id); + } + /** + * Setter for #learner_id. Can only be called before initialization. + * @param {string} learner_id + */ + , + set: function set(learner_id) { + !this.initialized ? _classPrivateFieldSet(this, _learner_id, learner_id) : throwReadOnlyError(); + } + /** + * Getter for #learner_name + * @return {string} + */ + + }, { + key: "learner_name", + get: function get() { + return _classPrivateFieldGet(this, _learner_name); + } + /** + * Setter for #learner_name. Can only be called before initialization. + * @param {string} learner_name + */ + , + set: function set(learner_name) { + !this.initialized ? _classPrivateFieldSet(this, _learner_name, learner_name) : throwReadOnlyError(); + } + /** + * Getter for #location + * @return {string} + */ + + }, { + key: "location", + get: function get() { + return _classPrivateFieldGet(this, _location); + } + /** + * Setter for #location + * @param {string} location + */ + , + set: function set(location) { + if (check2004ValidFormat(location, scorm2004_regex.CMIString1000)) { + _classPrivateFieldSet(this, _location, location); + } + } + /** + * Getter for #max_time_allowed + * @return {string} + */ + + }, { + key: "max_time_allowed", + get: function get() { + return _classPrivateFieldGet(this, _max_time_allowed); + } + /** + * Setter for #max_time_allowed. Can only be called before initialization. + * @param {string} max_time_allowed + */ + , + set: function set(max_time_allowed) { + !this.initialized ? _classPrivateFieldSet(this, _max_time_allowed, max_time_allowed) : throwReadOnlyError(); + } + /** + * Getter for #mode + * @return {string} + */ + + }, { + key: "mode", + get: function get() { + return _classPrivateFieldGet(this, _mode); + } + /** + * Setter for #mode. Can only be called before initialization. + * @param {string} mode + */ + , + set: function set(mode) { + !this.initialized ? _classPrivateFieldSet(this, _mode, mode) : throwReadOnlyError(); + } + /** + * Getter for #progress_measure + * @return {string} + */ + + }, { + key: "progress_measure", + get: function get() { + return _classPrivateFieldGet(this, _progress_measure); + } + /** + * Setter for #progress_measure + * @param {string} progress_measure + */ + , + set: function set(progress_measure) { + if (check2004ValidFormat(progress_measure, scorm2004_regex.CMIDecimal) && check2004ValidRange(progress_measure, scorm2004_regex.progress_range)) { + _classPrivateFieldSet(this, _progress_measure, progress_measure); + } + } + /** + * Getter for #scaled_passing_score + * @return {string} + */ + + }, { + key: "scaled_passing_score", + get: function get() { + return _classPrivateFieldGet(this, _scaled_passing_score); + } + /** + * Setter for #scaled_passing_score. Can only be called before initialization. + * @param {string} scaled_passing_score + */ + , + set: function set(scaled_passing_score) { + !this.initialized ? _classPrivateFieldSet(this, _scaled_passing_score, scaled_passing_score) : throwReadOnlyError(); + } + /** + * Getter for #session_time. Should only be called during JSON export. + * @return {string} + */ + + }, { + key: "session_time", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _session_time); + } + /** + * Setter for #session_time + * @param {string} session_time + */ + , + set: function set(session_time) { + if (check2004ValidFormat(session_time, scorm2004_regex.CMITimespan)) { + _classPrivateFieldSet(this, _session_time, session_time); + } + } + /** + * Getter for #success_status + * @return {string} + */ + + }, { + key: "success_status", + get: function get() { + return _classPrivateFieldGet(this, _success_status); + } + /** + * Setter for #success_status + * @param {string} success_status + */ + , + set: function set(success_status) { + if (check2004ValidFormat(success_status, scorm2004_regex.CMISStatus)) { + _classPrivateFieldSet(this, _success_status, success_status); + } + } + /** + * Getter for #suspend_data + * @return {string} + */ + + }, { + key: "suspend_data", + get: function get() { + return _classPrivateFieldGet(this, _suspend_data); + } + /** + * Setter for #suspend_data + * @param {string} suspend_data + */ + , + set: function set(suspend_data) { + if (check2004ValidFormat(suspend_data, scorm2004_regex.CMIString64000, true)) { + _classPrivateFieldSet(this, _suspend_data, suspend_data); + } + } + /** + * Getter for #time_limit_action + * @return {string} + */ + + }, { + key: "time_limit_action", + get: function get() { + return _classPrivateFieldGet(this, _time_limit_action); + } + /** + * Setter for #time_limit_action. Can only be called before initialization. + * @param {string} time_limit_action + */ + , + set: function set(time_limit_action) { + !this.initialized ? _classPrivateFieldSet(this, _time_limit_action, time_limit_action) : throwReadOnlyError(); + } + /** + * Getter for #total_time + * @return {string} + */ + + }, { + key: "total_time", + get: function get() { + return _classPrivateFieldGet(this, _total_time); + } + /** + * Setter for #total_time. Can only be called before initialization. + * @param {string} total_time + */ + , + set: function set(total_time) { + !this.initialized ? _classPrivateFieldSet(this, _total_time, total_time) : throwReadOnlyError(); + } + /** + * Adds the current session time to the existing total time. + * + * @return {string} ISO8601 Duration + */ + + }, { + key: "getCurrentTotalTime", + value: function getCurrentTotalTime() { + var sessionTime = _classPrivateFieldGet(this, _session_time); + + var startTime = this.start_time; + + if (typeof startTime !== 'undefined' && startTime !== null) { + var seconds = new Date().getTime() - startTime; + sessionTime = Util.getSecondsAsISODuration(seconds / 1000); + } + + return Util.addTwoDurations(_classPrivateFieldGet(this, _total_time), sessionTime, scorm2004_regex.CMITimespan); + } + /** + * toJSON for cmi + * + * @return { + * { + * comments_from_learner: CMICommentsFromLearner, + * comments_from_lms: CMICommentsFromLMS, + * completion_status: string, + * completion_threshold: string, + * credit: string, + * entry: string, + * exit: string, + * interactions: CMIInteractions, + * launch_data: string, + * learner_id: string, + * learner_name: string, + * learner_preference: CMILearnerPreference, + * location: string, + * max_time_allowed: string, + * mode: string, + * objectives: CMIObjectives, + * progress_measure: string, + * scaled_passing_score: string, + * score: Scorm2004CMIScore, + * session_time: string, + * success_status: string, + * suspend_data: string, + * time_limit_action: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'comments_from_learner': this.comments_from_learner, + 'comments_from_lms': this.comments_from_lms, + 'completion_status': this.completion_status, + 'completion_threshold': this.completion_threshold, + 'credit': this.credit, + 'entry': this.entry, + 'exit': this.exit, + 'interactions': this.interactions, + 'launch_data': this.launch_data, + 'learner_id': this.learner_id, + 'learner_name': this.learner_name, + 'learner_preference': this.learner_preference, + 'location': this.location, + 'max_time_allowed': this.max_time_allowed, + 'mode': this.mode, + 'objectives': this.objectives, + 'progress_measure': this.progress_measure, + 'scaled_passing_score': this.scaled_passing_score, + 'score': this.score, + 'session_time': this.session_time, + 'success_status': this.success_status, + 'suspend_data': this.suspend_data, + 'time_limit_action': this.time_limit_action + }; + delete this.jsonString; + return result; + } + }]); + + return CMI; +}(_common.BaseCMI); +/** + * Class for SCORM 2004's cmi.learner_preference object + */ + + +exports.CMI = CMI; + +var _children3 = new WeakMap(); + +var _audio_level = new WeakMap(); + +var _language = new WeakMap(); + +var _delivery_speed = new WeakMap(); + +var _audio_captioning = new WeakMap(); + +var CMILearnerPreference = /*#__PURE__*/function (_BaseCMI2) { + _inherits(CMILearnerPreference, _BaseCMI2); + + var _super2 = _createSuper(CMILearnerPreference); + + /** + * Constructor for cmi.learner_preference + */ + function CMILearnerPreference() { + var _this2; + + _classCallCheck(this, CMILearnerPreference); + + _this2 = _super2.call(this); + + _children3.set(_assertThisInitialized(_this2), { + writable: true, + value: scorm2004_constants.student_preference_children + }); + + _audio_level.set(_assertThisInitialized(_this2), { + writable: true, + value: '1' + }); + + _language.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _delivery_speed.set(_assertThisInitialized(_this2), { + writable: true, + value: '1' + }); + + _audio_captioning.set(_assertThisInitialized(_this2), { + writable: true, + value: '0' + }); + + return _this2; + } + /** + * Getter for #_children + * @return {string} + * @private + */ + + + _createClass(CMILearnerPreference, [{ + key: "_children", + get: function get() { + return _classPrivateFieldGet(this, _children3); + } + /** + * Setter for #_children. Just throws an error. + * @param {string} _children + * @private + */ + , + set: function set(_children) { + throwReadOnlyError(); + } + /** + * Getter for #audio_level + * @return {string} + */ + + }, { + key: "audio_level", + get: function get() { + return _classPrivateFieldGet(this, _audio_level); + } + /** + * Setter for #audio_level + * @param {string} audio_level + */ + , + set: function set(audio_level) { + if (check2004ValidFormat(audio_level, scorm2004_regex.CMIDecimal) && check2004ValidRange(audio_level, scorm2004_regex.audio_range)) { + _classPrivateFieldSet(this, _audio_level, audio_level); + } + } + /** + * Getter for #language + * @return {string} + */ + + }, { + key: "language", + get: function get() { + return _classPrivateFieldGet(this, _language); + } + /** + * Setter for #language + * @param {string} language + */ + , + set: function set(language) { + if (check2004ValidFormat(language, scorm2004_regex.CMILang)) { + _classPrivateFieldSet(this, _language, language); + } + } + /** + * Getter for #delivery_speed + * @return {string} + */ + + }, { + key: "delivery_speed", + get: function get() { + return _classPrivateFieldGet(this, _delivery_speed); + } + /** + * Setter for #delivery_speed + * @param {string} delivery_speed + */ + , + set: function set(delivery_speed) { + if (check2004ValidFormat(delivery_speed, scorm2004_regex.CMIDecimal) && check2004ValidRange(delivery_speed, scorm2004_regex.speed_range)) { + _classPrivateFieldSet(this, _delivery_speed, delivery_speed); + } + } + /** + * Getter for #audio_captioning + * @return {string} + */ + + }, { + key: "audio_captioning", + get: function get() { + return _classPrivateFieldGet(this, _audio_captioning); + } + /** + * Setter for #audio_captioning + * @param {string} audio_captioning + */ + , + set: function set(audio_captioning) { + if (check2004ValidFormat(audio_captioning, scorm2004_regex.CMISInteger) && check2004ValidRange(audio_captioning, scorm2004_regex.text_range)) { + _classPrivateFieldSet(this, _audio_captioning, audio_captioning); + } + } + /** + * toJSON for cmi.learner_preference + * + * @return { + * { + * audio_level: string, + * language: string, + * delivery_speed: string, + * audio_captioning: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'audio_level': this.audio_level, + 'language': this.language, + 'delivery_speed': this.delivery_speed, + 'audio_captioning': this.audio_captioning + }; + delete this.jsonString; + return result; + } + }]); + + return CMILearnerPreference; +}(_common.BaseCMI); +/** + * Class representing SCORM 2004's cmi.interactions object + */ + + +var CMIInteractions = /*#__PURE__*/function (_CMIArray) { + _inherits(CMIInteractions, _CMIArray); + + var _super3 = _createSuper(CMIInteractions); + + /** + * Constructor for cmi.objectives Array + */ + function CMIInteractions() { + _classCallCheck(this, CMIInteractions); + + return _super3.call(this, { + children: scorm2004_constants.interactions_children, + errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT, + errorClass: _exceptions.Scorm2004ValidationError + }); + } + + return CMIInteractions; +}(_common.CMIArray); +/** + * Class representing SCORM 2004's cmi.objectives object + */ + + +var CMIObjectives = /*#__PURE__*/function (_CMIArray2) { + _inherits(CMIObjectives, _CMIArray2); + + var _super4 = _createSuper(CMIObjectives); + + /** + * Constructor for cmi.objectives Array + */ + function CMIObjectives() { + _classCallCheck(this, CMIObjectives); + + return _super4.call(this, { + children: scorm2004_constants.objectives_children, + errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT, + errorClass: _exceptions.Scorm2004ValidationError + }); + } + + return CMIObjectives; +}(_common.CMIArray); +/** + * Class representing SCORM 2004's cmi.comments_from_lms object + */ + + +var CMICommentsFromLMS = /*#__PURE__*/function (_CMIArray3) { + _inherits(CMICommentsFromLMS, _CMIArray3); + + var _super5 = _createSuper(CMICommentsFromLMS); + + /** + * Constructor for cmi.comments_from_lms Array + */ + function CMICommentsFromLMS() { + _classCallCheck(this, CMICommentsFromLMS); + + return _super5.call(this, { + children: scorm2004_constants.comments_children, + errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT, + errorClass: _exceptions.Scorm2004ValidationError + }); + } + + return CMICommentsFromLMS; +}(_common.CMIArray); +/** + * Class representing SCORM 2004's cmi.comments_from_learner object + */ + + +var CMICommentsFromLearner = /*#__PURE__*/function (_CMIArray4) { + _inherits(CMICommentsFromLearner, _CMIArray4); + + var _super6 = _createSuper(CMICommentsFromLearner); + + /** + * Constructor for cmi.comments_from_learner Array + */ + function CMICommentsFromLearner() { + _classCallCheck(this, CMICommentsFromLearner); + + return _super6.call(this, { + children: scorm2004_constants.comments_children, + errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT, + errorClass: _exceptions.Scorm2004ValidationError + }); + } + + return CMICommentsFromLearner; +}(_common.CMIArray); +/** + * Class for SCORM 2004's cmi.interaction.n object + */ + + +var _id = new WeakMap(); + +var _type = new WeakMap(); + +var _timestamp = new WeakMap(); + +var _weighting = new WeakMap(); + +var _learner_response = new WeakMap(); + +var _result = new WeakMap(); + +var _latency = new WeakMap(); + +var _description = new WeakMap(); + +var CMIInteractionsObject = /*#__PURE__*/function (_BaseCMI3) { + _inherits(CMIInteractionsObject, _BaseCMI3); + + var _super7 = _createSuper(CMIInteractionsObject); + + /** + * Constructor for cmi.interaction.n + */ + function CMIInteractionsObject() { + var _this3; + + _classCallCheck(this, CMIInteractionsObject); + + _this3 = _super7.call(this); + + _id.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _type.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _timestamp.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _weighting.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _learner_response.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _result.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _latency.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _description.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _this3.objectives = new _common.CMIArray({ + errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT, + errorClass: _exceptions.Scorm2004ValidationError, + children: scorm2004_constants.objectives_children + }); + _this3.correct_responses = new _common.CMIArray({ + errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT, + errorClass: _exceptions.Scorm2004ValidationError, + children: scorm2004_constants.correct_responses_children + }); + return _this3; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(CMIInteractionsObject, [{ + key: "initialize", + value: function initialize() { + var _this$objectives2, _this$correct_respons; + + _get(_getPrototypeOf(CMIInteractionsObject.prototype), "initialize", this).call(this); + + (_this$objectives2 = this.objectives) === null || _this$objectives2 === void 0 ? void 0 : _this$objectives2.initialize(); + (_this$correct_respons = this.correct_responses) === null || _this$correct_respons === void 0 ? void 0 : _this$correct_respons.initialize(); + } + /** + * Getter for #id + * @return {string} + */ + + }, { + key: "id", + get: function get() { + return _classPrivateFieldGet(this, _id); + } + /** + * Setter for #id + * @param {string} id + */ + , + set: function set(id) { + if (check2004ValidFormat(id, scorm2004_regex.CMILongIdentifier)) { + _classPrivateFieldSet(this, _id, id); + } + } + /** + * Getter for #type + * @return {string} + */ + + }, { + key: "type", + get: function get() { + return _classPrivateFieldGet(this, _type); + } + /** + * Setter for #type + * @param {string} type + */ + , + set: function set(type) { + if (this.initialized && _classPrivateFieldGet(this, _id) === '') { + throwDependencyNotEstablishedError(); + } else { + if (check2004ValidFormat(type, scorm2004_regex.CMIType)) { + _classPrivateFieldSet(this, _type, type); + } + } + } + /** + * Getter for #timestamp + * @return {string} + */ + + }, { + key: "timestamp", + get: function get() { + return _classPrivateFieldGet(this, _timestamp); + } + /** + * Setter for #timestamp + * @param {string} timestamp + */ + , + set: function set(timestamp) { + if (this.initialized && _classPrivateFieldGet(this, _id) === '') { + throwDependencyNotEstablishedError(); + } else { + if (check2004ValidFormat(timestamp, scorm2004_regex.CMITime)) { + _classPrivateFieldSet(this, _timestamp, timestamp); + } + } + } + /** + * Getter for #weighting + * @return {string} + */ + + }, { + key: "weighting", + get: function get() { + return _classPrivateFieldGet(this, _weighting); + } + /** + * Setter for #weighting + * @param {string} weighting + */ + , + set: function set(weighting) { + if (this.initialized && _classPrivateFieldGet(this, _id) === '') { + throwDependencyNotEstablishedError(); + } else { + if (check2004ValidFormat(weighting, scorm2004_regex.CMIDecimal)) { + _classPrivateFieldSet(this, _weighting, weighting); + } + } + } + /** + * Getter for #learner_response + * @return {string} + */ + + }, { + key: "learner_response", + get: function get() { + return _classPrivateFieldGet(this, _learner_response); + } + /** + * Setter for #learner_response. Does type validation to make sure response + * matches SCORM 2004's spec + * @param {string} learner_response + */ + , + set: function set(learner_response) { + if (this.initialized && (_classPrivateFieldGet(this, _type) === '' || _classPrivateFieldGet(this, _id) === '')) { + throwDependencyNotEstablishedError(); + } else { + var nodes = []; + var response_type = learner_responses[this.type]; + + if (response_type) { + if (response_type !== null && response_type !== void 0 && response_type.delimiter) { + nodes = learner_response.split(response_type.delimiter); + } else { + nodes[0] = learner_response; + } + + if (nodes.length > 0 && nodes.length <= response_type.max) { + var formatRegex = new RegExp(response_type.format); + + for (var i = 0; i < nodes.length; i++) { + if (response_type !== null && response_type !== void 0 && response_type.delimiter2) { + var values = nodes[i].split(response_type.delimiter2); + + if (values.length === 2) { + if (!values[0].match(formatRegex)) { + throwTypeMismatchError(); + } else { + if (!values[1].match(new RegExp(response_type.format2))) { + throwTypeMismatchError(); + } + } + } else { + throwTypeMismatchError(); + } + } else { + if (!nodes[i].match(formatRegex)) { + throwTypeMismatchError(); + } else { + if (nodes[i] !== '' && response_type.unique) { + for (var j = 0; j < i; j++) { + if (nodes[i] === nodes[j]) { + throwTypeMismatchError(); + } + } + } + } + } + } + } else { + throwGeneralSetError(); + } + + _classPrivateFieldSet(this, _learner_response, learner_response); + } else { + throwTypeMismatchError(); + } + } + } + /** + * Getter for #result + * @return {string} + */ + + }, { + key: "result", + get: function get() { + return _classPrivateFieldGet(this, _result); + } + /** + * Setter for #result + * @param {string} result + */ + , + set: function set(result) { + if (check2004ValidFormat(result, scorm2004_regex.CMIResult)) { + _classPrivateFieldSet(this, _result, result); + } + } + /** + * Getter for #latency + * @return {string} + */ + + }, { + key: "latency", + get: function get() { + return _classPrivateFieldGet(this, _latency); + } + /** + * Setter for #latency + * @param {string} latency + */ + , + set: function set(latency) { + if (this.initialized && _classPrivateFieldGet(this, _id) === '') { + throwDependencyNotEstablishedError(); + } else { + if (check2004ValidFormat(latency, scorm2004_regex.CMITimespan)) { + _classPrivateFieldSet(this, _latency, latency); + } + } + } + /** + * Getter for #description + * @return {string} + */ + + }, { + key: "description", + get: function get() { + return _classPrivateFieldGet(this, _description); + } + /** + * Setter for #description + * @param {string} description + */ + , + set: function set(description) { + if (this.initialized && _classPrivateFieldGet(this, _id) === '') { + throwDependencyNotEstablishedError(); + } else { + if (check2004ValidFormat(description, scorm2004_regex.CMILangString250, true)) { + _classPrivateFieldSet(this, _description, description); + } + } + } + /** + * toJSON for cmi.interactions.n + * + * @return { + * { + * id: string, + * type: string, + * objectives: CMIArray, + * timestamp: string, + * correct_responses: CMIArray, + * weighting: string, + * learner_response: string, + * result: string, + * latency: string, + * description: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'id': this.id, + 'type': this.type, + 'objectives': this.objectives, + 'timestamp': this.timestamp, + 'weighting': this.weighting, + 'learner_response': this.learner_response, + 'result': this.result, + 'latency': this.latency, + 'description': this.description, + 'correct_responses': this.correct_responses + }; + delete this.jsonString; + return result; + } + }]); + + return CMIInteractionsObject; +}(_common.BaseCMI); +/** + * Class for SCORM 2004's cmi.objectives.n object + */ + + +exports.CMIInteractionsObject = CMIInteractionsObject; + +var _id2 = new WeakMap(); + +var _success_status2 = new WeakMap(); + +var _completion_status2 = new WeakMap(); + +var _progress_measure2 = new WeakMap(); + +var _description2 = new WeakMap(); + +var CMIObjectivesObject = /*#__PURE__*/function (_BaseCMI4) { + _inherits(CMIObjectivesObject, _BaseCMI4); + + var _super8 = _createSuper(CMIObjectivesObject); + + /** + * Constructor for cmi.objectives.n + */ + function CMIObjectivesObject() { + var _this4; + + _classCallCheck(this, CMIObjectivesObject); + + _this4 = _super8.call(this); + + _id2.set(_assertThisInitialized(_this4), { + writable: true, + value: '' + }); + + _success_status2.set(_assertThisInitialized(_this4), { + writable: true, + value: 'unknown' + }); + + _completion_status2.set(_assertThisInitialized(_this4), { + writable: true, + value: 'unknown' + }); + + _progress_measure2.set(_assertThisInitialized(_this4), { + writable: true, + value: '' + }); + + _description2.set(_assertThisInitialized(_this4), { + writable: true, + value: '' + }); + + _this4.score = new Scorm2004CMIScore(); + return _this4; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(CMIObjectivesObject, [{ + key: "initialize", + value: function initialize() { + var _this$score2; + + _get(_getPrototypeOf(CMIObjectivesObject.prototype), "initialize", this).call(this); + + (_this$score2 = this.score) === null || _this$score2 === void 0 ? void 0 : _this$score2.initialize(); + } + /** + * Getter for #id + * @return {string} + */ + + }, { + key: "id", + get: function get() { + return _classPrivateFieldGet(this, _id2); + } + /** + * Setter for #id + * @param {string} id + */ + , + set: function set(id) { + if (check2004ValidFormat(id, scorm2004_regex.CMILongIdentifier)) { + _classPrivateFieldSet(this, _id2, id); + } + } + /** + * Getter for #success_status + * @return {string} + */ + + }, { + key: "success_status", + get: function get() { + return _classPrivateFieldGet(this, _success_status2); + } + /** + * Setter for #success_status + * @param {string} success_status + */ + , + set: function set(success_status) { + if (this.initialized && _classPrivateFieldGet(this, _id2) === '') { + throwDependencyNotEstablishedError(); + } else { + if (check2004ValidFormat(success_status, scorm2004_regex.CMISStatus)) { + _classPrivateFieldSet(this, _success_status2, success_status); + } + } + } + /** + * Getter for #completion_status + * @return {string} + */ + + }, { + key: "completion_status", + get: function get() { + return _classPrivateFieldGet(this, _completion_status2); + } + /** + * Setter for #completion_status + * @param {string} completion_status + */ + , + set: function set(completion_status) { + if (this.initialized && _classPrivateFieldGet(this, _id2) === '') { + throwDependencyNotEstablishedError(); + } else { + if (check2004ValidFormat(completion_status, scorm2004_regex.CMICStatus)) { + _classPrivateFieldSet(this, _completion_status2, completion_status); + } + } + } + /** + * Getter for #progress_measure + * @return {string} + */ + + }, { + key: "progress_measure", + get: function get() { + return _classPrivateFieldGet(this, _progress_measure2); + } + /** + * Setter for #progress_measure + * @param {string} progress_measure + */ + , + set: function set(progress_measure) { + if (this.initialized && _classPrivateFieldGet(this, _id2) === '') { + throwDependencyNotEstablishedError(); + } else { + if (check2004ValidFormat(progress_measure, scorm2004_regex.CMIDecimal) && check2004ValidRange(progress_measure, scorm2004_regex.progress_range)) { + _classPrivateFieldSet(this, _progress_measure2, progress_measure); + } + } + } + /** + * Getter for #description + * @return {string} + */ + + }, { + key: "description", + get: function get() { + return _classPrivateFieldGet(this, _description2); + } + /** + * Setter for #description + * @param {string} description + */ + , + set: function set(description) { + if (this.initialized && _classPrivateFieldGet(this, _id2) === '') { + throwDependencyNotEstablishedError(); + } else { + if (check2004ValidFormat(description, scorm2004_regex.CMILangString250, true)) { + _classPrivateFieldSet(this, _description2, description); + } + } + } + /** + * toJSON for cmi.objectives.n + * + * @return { + * { + * id: string, + * success_status: string, + * completion_status: string, + * progress_measure: string, + * description: string, + * score: Scorm2004CMIScore + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'id': this.id, + 'success_status': this.success_status, + 'completion_status': this.completion_status, + 'progress_measure': this.progress_measure, + 'description': this.description, + 'score': this.score + }; + delete this.jsonString; + return result; + } + }]); + + return CMIObjectivesObject; +}(_common.BaseCMI); +/** + * Class for SCORM 2004's cmi *.score object + */ + + +exports.CMIObjectivesObject = CMIObjectivesObject; + +var _scaled = new WeakMap(); + +var Scorm2004CMIScore = /*#__PURE__*/function (_CMIScore) { + _inherits(Scorm2004CMIScore, _CMIScore); + + var _super9 = _createSuper(Scorm2004CMIScore); + + /** + * Constructor for cmi *.score + */ + function Scorm2004CMIScore() { + var _this5; + + _classCallCheck(this, Scorm2004CMIScore); + + _this5 = _super9.call(this, { + score_children: scorm2004_constants.score_children, + max: '', + invalidErrorCode: scorm2004_error_codes.READ_ONLY_ELEMENT, + invalidTypeCode: scorm2004_error_codes.TYPE_MISMATCH, + invalidRangeCode: scorm2004_error_codes.VALUE_OUT_OF_RANGE, + decimalRegex: scorm2004_regex.CMIDecimal, + errorClass: _exceptions.Scorm2004ValidationError + }); + + _scaled.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + return _this5; + } + /** + * Getter for #scaled + * @return {string} + */ + + + _createClass(Scorm2004CMIScore, [{ + key: "scaled", + get: function get() { + return _classPrivateFieldGet(this, _scaled); + } + /** + * Setter for #scaled + * @param {string} scaled + */ + , + set: function set(scaled) { + if (check2004ValidFormat(scaled, scorm2004_regex.CMIDecimal) && check2004ValidRange(scaled, scorm2004_regex.scaled_range)) { + _classPrivateFieldSet(this, _scaled, scaled); + } + } + /** + * toJSON for cmi *.score + * + * @return { + * { + * scaled: string, + * raw: string, + * min: string, + * max: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'scaled': this.scaled, + 'raw': _get(_getPrototypeOf(Scorm2004CMIScore.prototype), "raw", this), + 'min': _get(_getPrototypeOf(Scorm2004CMIScore.prototype), "min", this), + 'max': _get(_getPrototypeOf(Scorm2004CMIScore.prototype), "max", this) + }; + delete this.jsonString; + return result; + } + }]); + + return Scorm2004CMIScore; +}(_common.CMIScore); +/** + * Class representing SCORM 2004's cmi.comments_from_learner.n and cmi.comments_from_lms.n object + */ + + +var _comment = new WeakMap(); + +var _location2 = new WeakMap(); + +var _timestamp2 = new WeakMap(); + +var _readOnlyAfterInit = new WeakMap(); + +var CMICommentsObject = /*#__PURE__*/function (_BaseCMI5) { + _inherits(CMICommentsObject, _BaseCMI5); + + var _super10 = _createSuper(CMICommentsObject); + + /** + * Constructor for cmi.comments_from_learner.n and cmi.comments_from_lms.n + * @param {boolean} readOnlyAfterInit + */ + function CMICommentsObject() { + var _this6; + + var readOnlyAfterInit = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + + _classCallCheck(this, CMICommentsObject); + + _this6 = _super10.call(this); + + _comment.set(_assertThisInitialized(_this6), { + writable: true, + value: '' + }); + + _location2.set(_assertThisInitialized(_this6), { + writable: true, + value: '' + }); + + _timestamp2.set(_assertThisInitialized(_this6), { + writable: true, + value: '' + }); + + _readOnlyAfterInit.set(_assertThisInitialized(_this6), { + writable: true, + value: void 0 + }); + + _classPrivateFieldSet(_assertThisInitialized(_this6), _comment, ''); + + _classPrivateFieldSet(_assertThisInitialized(_this6), _location2, ''); + + _classPrivateFieldSet(_assertThisInitialized(_this6), _timestamp2, ''); + + _classPrivateFieldSet(_assertThisInitialized(_this6), _readOnlyAfterInit, readOnlyAfterInit); + + return _this6; + } + /** + * Getter for #comment + * @return {string} + */ + + + _createClass(CMICommentsObject, [{ + key: "comment", + get: function get() { + return _classPrivateFieldGet(this, _comment); + } + /** + * Setter for #comment + * @param {string} comment + */ + , + set: function set(comment) { + if (this.initialized && _classPrivateFieldGet(this, _readOnlyAfterInit)) { + throwReadOnlyError(); + } else { + if (check2004ValidFormat(comment, scorm2004_regex.CMILangString4000, true)) { + _classPrivateFieldSet(this, _comment, comment); + } + } + } + /** + * Getter for #location + * @return {string} + */ + + }, { + key: "location", + get: function get() { + return _classPrivateFieldGet(this, _location2); + } + /** + * Setter for #location + * @param {string} location + */ + , + set: function set(location) { + if (this.initialized && _classPrivateFieldGet(this, _readOnlyAfterInit)) { + throwReadOnlyError(); + } else { + if (check2004ValidFormat(location, scorm2004_regex.CMIString250)) { + _classPrivateFieldSet(this, _location2, location); + } + } + } + /** + * Getter for #timestamp + * @return {string} + */ + + }, { + key: "timestamp", + get: function get() { + return _classPrivateFieldGet(this, _timestamp2); + } + /** + * Setter for #timestamp + * @param {string} timestamp + */ + , + set: function set(timestamp) { + if (this.initialized && _classPrivateFieldGet(this, _readOnlyAfterInit)) { + throwReadOnlyError(); + } else { + if (check2004ValidFormat(timestamp, scorm2004_regex.CMITime)) { + _classPrivateFieldSet(this, _timestamp2, timestamp); + } + } + } + /** + * toJSON for cmi.comments_from_learner.n object + * @return { + * { + * comment: string, + * location: string, + * timestamp: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'comment': this.comment, + 'location': this.location, + 'timestamp': this.timestamp + }; + delete this.jsonString; + return result; + } + }]); + + return CMICommentsObject; +}(_common.BaseCMI); +/** + * Class representing SCORM 2004's cmi.interactions.n.objectives.n object + */ + + +exports.CMICommentsObject = CMICommentsObject; + +var _id3 = new WeakMap(); + +var CMIInteractionsObjectivesObject = /*#__PURE__*/function (_BaseCMI6) { + _inherits(CMIInteractionsObjectivesObject, _BaseCMI6); + + var _super11 = _createSuper(CMIInteractionsObjectivesObject); + + /** + * Constructor for cmi.interactions.n.objectives.n + */ + function CMIInteractionsObjectivesObject() { + var _this7; + + _classCallCheck(this, CMIInteractionsObjectivesObject); + + _this7 = _super11.call(this); + + _id3.set(_assertThisInitialized(_this7), { + writable: true, + value: '' + }); + + return _this7; + } + /** + * Getter for #id + * @return {string} + */ + + + _createClass(CMIInteractionsObjectivesObject, [{ + key: "id", + get: function get() { + return _classPrivateFieldGet(this, _id3); + } + /** + * Setter for #id + * @param {string} id + */ + , + set: function set(id) { + if (check2004ValidFormat(id, scorm2004_regex.CMILongIdentifier)) { + _classPrivateFieldSet(this, _id3, id); + } + } + /** + * toJSON for cmi.interactions.n.objectives.n + * @return { + * { + * id: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'id': this.id + }; + delete this.jsonString; + return result; + } + }]); + + return CMIInteractionsObjectivesObject; +}(_common.BaseCMI); +/** + * Class representing SCORM 2004's cmi.interactions.n.correct_responses.n object + */ + + +exports.CMIInteractionsObjectivesObject = CMIInteractionsObjectivesObject; + +var _pattern = new WeakMap(); + +var CMIInteractionsCorrectResponsesObject = /*#__PURE__*/function (_BaseCMI7) { + _inherits(CMIInteractionsCorrectResponsesObject, _BaseCMI7); + + var _super12 = _createSuper(CMIInteractionsCorrectResponsesObject); + + /** + * Constructor for cmi.interactions.n.correct_responses.n + */ + function CMIInteractionsCorrectResponsesObject() { + var _this8; + + _classCallCheck(this, CMIInteractionsCorrectResponsesObject); + + _this8 = _super12.call(this); + + _pattern.set(_assertThisInitialized(_this8), { + writable: true, + value: '' + }); + + return _this8; + } + /** + * Getter for #pattern + * @return {string} + */ + + + _createClass(CMIInteractionsCorrectResponsesObject, [{ + key: "pattern", + get: function get() { + return _classPrivateFieldGet(this, _pattern); + } + /** + * Setter for #pattern + * @param {string} pattern + */ + , + set: function set(pattern) { + if (check2004ValidFormat(pattern, scorm2004_regex.CMIFeedback)) { + _classPrivateFieldSet(this, _pattern, pattern); + } + } + /** + * toJSON cmi.interactions.n.correct_responses.n object + * @return { + * { + * pattern: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'pattern': this.pattern + }; + delete this.jsonString; + return result; + } + }]); + + return CMIInteractionsCorrectResponsesObject; +}(_common.BaseCMI); +/** + * Class representing SCORM 2004's adl object + */ + + +exports.CMIInteractionsCorrectResponsesObject = CMIInteractionsCorrectResponsesObject; + +var ADL = /*#__PURE__*/function (_BaseCMI8) { + _inherits(ADL, _BaseCMI8); + + var _super13 = _createSuper(ADL); + + /** + * Constructor for adl + */ + function ADL() { + var _this9; + + _classCallCheck(this, ADL); + + _this9 = _super13.call(this); + _this9.nav = new ADLNav(); + return _this9; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(ADL, [{ + key: "initialize", + value: function initialize() { + var _this$nav; + + _get(_getPrototypeOf(ADL.prototype), "initialize", this).call(this); + + (_this$nav = this.nav) === null || _this$nav === void 0 ? void 0 : _this$nav.initialize(); + } + /** + * toJSON for adl + * @return { + * { + * nav: { + * request: string + * } + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'nav': this.nav + }; + delete this.jsonString; + return result; + } + }]); + + return ADL; +}(_common.BaseCMI); +/** + * Class representing SCORM 2004's adl.nav object + */ + + +exports.ADL = ADL; + +var _request = new WeakMap(); + +var ADLNav = /*#__PURE__*/function (_BaseCMI9) { + _inherits(ADLNav, _BaseCMI9); + + var _super14 = _createSuper(ADLNav); + + /** + * Constructor for adl.nav + */ + function ADLNav() { + var _this10; + + _classCallCheck(this, ADLNav); + + _this10 = _super14.call(this); + + _request.set(_assertThisInitialized(_this10), { + writable: true, + value: '_none_' + }); + + _this10.request_valid = new ADLNavRequestValid(); + return _this10; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(ADLNav, [{ + key: "initialize", + value: function initialize() { + var _this$request_valid; + + _get(_getPrototypeOf(ADLNav.prototype), "initialize", this).call(this); + + (_this$request_valid = this.request_valid) === null || _this$request_valid === void 0 ? void 0 : _this$request_valid.initialize(); + } + /** + * Getter for #request + * @return {string} + */ + + }, { + key: "request", + get: function get() { + return _classPrivateFieldGet(this, _request); + } + /** + * Setter for #request + * @param {string} request + */ + , + set: function set(request) { + if (check2004ValidFormat(request, scorm2004_regex.NAVEvent)) { + _classPrivateFieldSet(this, _request, request); + } + } + /** + * toJSON for adl.nav + * + * @return { + * { + * request: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'request': this.request + }; + delete this.jsonString; + return result; + } + }]); + + return ADLNav; +}(_common.BaseCMI); +/** + * Class representing SCORM 2004's adl.nav.request_valid object + */ + + +var _continue = new WeakMap(); + +var _previous = new WeakMap(); + +var ADLNavRequestValid = /*#__PURE__*/function (_BaseCMI10) { + _inherits(ADLNavRequestValid, _BaseCMI10); + + var _super15 = _createSuper(ADLNavRequestValid); + + /** + * Constructor for adl.nav.request_valid + */ + function ADLNavRequestValid() { + var _temp, _temp2; + + var _this11; + + _classCallCheck(this, ADLNavRequestValid); + + _this11 = _super15.call(this); + + _continue.set(_assertThisInitialized(_this11), { + writable: true, + value: 'unknown' + }); + + _previous.set(_assertThisInitialized(_this11), { + writable: true, + value: 'unknown' + }); + + _defineProperty(_assertThisInitialized(_this11), "choice", (_temp = function _temp() { + _classCallCheck(this, _temp); + + _defineProperty(this, "_isTargetValid", function (_target) { + return 'unknown'; + }); + }, _temp)); + + _defineProperty(_assertThisInitialized(_this11), "jump", (_temp2 = function _temp2() { + _classCallCheck(this, _temp2); + + _defineProperty(this, "_isTargetValid", function (_target) { + return 'unknown'; + }); + }, _temp2)); + + return _this11; + } + /** + * Getter for #continue + * @return {string} + */ + + + _createClass(ADLNavRequestValid, [{ + key: "continue", + get: function get() { + return _classPrivateFieldGet(this, _continue); + } + /** + * Setter for #continue. Just throws an error. + * @param {*} _ + */ + , + set: function set(_) { + throwReadOnlyError(); + } + /** + * Getter for #previous + * @return {string} + */ + + }, { + key: "previous", + get: function get() { + return _classPrivateFieldGet(this, _previous); + } + /** + * Setter for #previous. Just throws an error. + * @param {*} _ + */ + , + set: function set(_) { + throwReadOnlyError(); + } + /** + * toJSON for adl.nav.request_valid + * + * @return { + * { + * previous: string, + * continue: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'previous': this.previous, + 'continue': this["continue"] + }; + delete this.jsonString; + return result; + } + }]); + + return ADLNavRequestValid; +}(_common.BaseCMI); + +},{"../constants/api_constants":6,"../constants/error_codes":7,"../constants/regex":9,"../constants/response_constants":10,"../exceptions":11,"../utilities":13,"./common":4}],6:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var global = { + SCORM_TRUE: 'true', + SCORM_FALSE: 'false', + STATE_NOT_INITIALIZED: 0, + STATE_INITIALIZED: 1, + STATE_TERMINATED: 2, + LOG_LEVEL_DEBUG: 1, + LOG_LEVEL_INFO: 2, + LOG_LEVEL_WARNING: 3, + LOG_LEVEL_ERROR: 4, + LOG_LEVEL_NONE: 5 +}; +var scorm12 = { + // Children lists + cmi_children: 'core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions', + core_children: 'student_id,student_name,lesson_location,credit,lesson_status,entry,score,total_time,lesson_mode,exit,session_time', + score_children: 'raw,min,max', + comments_children: 'content,location,time', + objectives_children: 'id,score,status', + correct_responses_children: 'pattern', + student_data_children: 'mastery_score,max_time_allowed,time_limit_action', + student_preference_children: 'audio,language,speed,text', + interactions_children: 'id,objectives,time,type,correct_responses,weighting,student_response,result,latency', + error_descriptions: { + '101': { + basicMessage: 'General Exception', + detailMessage: 'No specific error code exists to describe the error. Use LMSGetDiagnostic for more information' + }, + '201': { + basicMessage: 'Invalid argument error', + detailMessage: 'Indicates that an argument represents an invalid data model element or is otherwise incorrect.' + }, + '202': { + basicMessage: 'Element cannot have children', + detailMessage: 'Indicates that LMSGetValue was called with a data model element name that ends in "_children" for a data model element that does not support the "_children" suffix.' + }, + '203': { + basicMessage: 'Element not an array - cannot have count', + detailMessage: 'Indicates that LMSGetValue was called with a data model element name that ends in "_count" for a data model element that does not support the "_count" suffix.' + }, + '301': { + basicMessage: 'Not initialized', + detailMessage: 'Indicates that an API call was made before the call to lmsInitialize.' + }, + '401': { + basicMessage: 'Not implemented error', + detailMessage: 'The data model element indicated in a call to LMSGetValue or LMSSetValue is valid, but was not implemented by this LMS. SCORM 1.2 defines a set of data model elements as being optional for an LMS to implement.' + }, + '402': { + basicMessage: 'Invalid set value, element is a keyword', + detailMessage: 'Indicates that LMSSetValue was called on a data model element that represents a keyword (elements that end in "_children" and "_count").' + }, + '403': { + basicMessage: 'Element is read only', + detailMessage: 'LMSSetValue was called with a data model element that can only be read.' + }, + '404': { + basicMessage: 'Element is write only', + detailMessage: 'LMSGetValue was called on a data model element that can only be written to.' + }, + '405': { + basicMessage: 'Incorrect Data Type', + detailMessage: 'LMSSetValue was called with a value that is not consistent with the data format of the supplied data model element.' + }, + '407': { + basicMessage: 'Element Value Out Of Range', + detailMessage: 'The numeric value supplied to a LMSSetValue call is outside of the numeric range allowed for the supplied data model element.' + }, + '408': { + basicMessage: 'Data Model Dependency Not Established', + detailMessage: 'Some data model elements cannot be set until another data model element was set. This error condition indicates that the prerequisite element was not set before the dependent element.' + } + } +}; + +var aicc = _objectSpread(_objectSpread({}, scorm12), { + cmi_children: 'core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions,evaluation', + student_preference_children: 'audio,language,lesson_type,speed,text,text_color,text_location,text_size,video,windows', + student_data_children: 'attempt_number,tries,mastery_score,max_time_allowed,time_limit_action', + student_demographics_children: 'city,class,company,country,experience,familiar_name,instructor_name,title,native_language,state,street_address,telephone,years_experience', + tries_children: 'time,status,score', + attempt_records_children: 'score,lesson_status', + paths_children: 'location_id,date,time,status,why_left,time_in_element' +}); + +var scorm2004 = { + // Children lists + cmi_children: '_version,comments_from_learner,comments_from_lms,completion_status,credit,entry,exit,interactions,launch_data,learner_id,learner_name,learner_preference,location,max_time_allowed,mode,objectives,progress_measure,scaled_passing_score,score,session_time,success_status,suspend_data,time_limit_action,total_time', + comments_children: 'comment,timestamp,location', + score_children: 'max,raw,scaled,min', + objectives_children: 'progress_measure,completion_status,success_status,description,score,id', + correct_responses_children: 'pattern', + student_data_children: 'mastery_score,max_time_allowed,time_limit_action', + student_preference_children: 'audio_level,audio_captioning,delivery_speed,language', + interactions_children: 'id,type,objectives,timestamp,correct_responses,weighting,learner_response,result,latency,description', + error_descriptions: { + '0': { + basicMessage: 'No Error', + detailMessage: 'No error occurred, the previous API call was successful.' + }, + '101': { + basicMessage: 'General Exception', + detailMessage: 'No specific error code exists to describe the error. Use GetDiagnostic for more information.' + }, + '102': { + basicMessage: 'General Initialization Failure', + detailMessage: 'Call to Initialize failed for an unknown reason.' + }, + '103': { + basicMessage: 'Already Initialized', + detailMessage: 'Call to Initialize failed because Initialize was already called.' + }, + '104': { + basicMessage: 'Content Instance Terminated', + detailMessage: 'Call to Initialize failed because Terminate was already called.' + }, + '111': { + basicMessage: 'General Termination Failure', + detailMessage: 'Call to Terminate failed for an unknown reason.' + }, + '112': { + basicMessage: 'Termination Before Initialization', + detailMessage: 'Call to Terminate failed because it was made before the call to Initialize.' + }, + '113': { + basicMessage: 'Termination After Termination', + detailMessage: 'Call to Terminate failed because Terminate was already called.' + }, + '122': { + basicMessage: 'Retrieve Data Before Initialization', + detailMessage: 'Call to GetValue failed because it was made before the call to Initialize.' + }, + '123': { + basicMessage: 'Retrieve Data After Termination', + detailMessage: 'Call to GetValue failed because it was made after the call to Terminate.' + }, + '132': { + basicMessage: 'Store Data Before Initialization', + detailMessage: 'Call to SetValue failed because it was made before the call to Initialize.' + }, + '133': { + basicMessage: 'Store Data After Termination', + detailMessage: 'Call to SetValue failed because it was made after the call to Terminate.' + }, + '142': { + basicMessage: 'Commit Before Initialization', + detailMessage: 'Call to Commit failed because it was made before the call to Initialize.' + }, + '143': { + basicMessage: 'Commit After Termination', + detailMessage: 'Call to Commit failed because it was made after the call to Terminate.' + }, + '201': { + basicMessage: 'General Argument Error', + detailMessage: 'An invalid argument was passed to an API method (usually indicates that Initialize, Commit or Terminate did not receive the expected empty string argument.' + }, + '301': { + basicMessage: 'General Get Failure', + detailMessage: 'Indicates a failed GetValue call where no other specific error code is applicable. Use GetDiagnostic for more information.' + }, + '351': { + basicMessage: 'General Set Failure', + detailMessage: 'Indicates a failed SetValue call where no other specific error code is applicable. Use GetDiagnostic for more information.' + }, + '391': { + basicMessage: 'General Commit Failure', + detailMessage: 'Indicates a failed Commit call where no other specific error code is applicable. Use GetDiagnostic for more information.' + }, + '401': { + basicMessage: 'Undefined Data Model Element', + detailMessage: 'The data model element name passed to GetValue or SetValue is not a valid SCORM data model element.' + }, + '402': { + basicMessage: 'Unimplemented Data Model Element', + detailMessage: 'The data model element indicated in a call to GetValue or SetValue is valid, but was not implemented by this LMS. In SCORM 2004, this error would indicate an LMS that is not fully SCORM conformant.' + }, + '403': { + basicMessage: 'Data Model Element Value Not Initialized', + detailMessage: 'Attempt to read a data model element that has not been initialized by the LMS or through a SetValue call. This error condition is often reached during normal execution of a SCO.' + }, + '404': { + basicMessage: 'Data Model Element Is Read Only', + detailMessage: 'SetValue was called with a data model element that can only be read.' + }, + '405': { + basicMessage: 'Data Model Element Is Write Only', + detailMessage: 'GetValue was called on a data model element that can only be written to.' + }, + '406': { + basicMessage: 'Data Model Element Type Mismatch', + detailMessage: 'SetValue was called with a value that is not consistent with the data format of the supplied data model element.' + }, + '407': { + basicMessage: 'Data Model Element Value Out Of Range', + detailMessage: 'The numeric value supplied to a SetValue call is outside of the numeric range allowed for the supplied data model element.' + }, + '408': { + basicMessage: 'Data Model Dependency Not Established', + detailMessage: 'Some data model elements cannot be set until another data model element was set. This error condition indicates that the prerequisite element was not set before the dependent element.' + } + } +}; +var APIConstants = { + global: global, + scorm12: scorm12, + aicc: aicc, + scorm2004: scorm2004 +}; +var _default = APIConstants; +exports["default"] = _default; + +},{}],7:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var global = { + GENERAL: 101, + INITIALIZATION_FAILED: 101, + INITIALIZED: 101, + TERMINATED: 101, + TERMINATION_FAILURE: 101, + TERMINATION_BEFORE_INIT: 101, + MULTIPLE_TERMINATION: 101, + RETRIEVE_BEFORE_INIT: 101, + RETRIEVE_AFTER_TERM: 101, + STORE_BEFORE_INIT: 101, + STORE_AFTER_TERM: 101, + COMMIT_BEFORE_INIT: 101, + COMMIT_AFTER_TERM: 101, + ARGUMENT_ERROR: 101, + CHILDREN_ERROR: 101, + COUNT_ERROR: 101, + GENERAL_GET_FAILURE: 101, + GENERAL_SET_FAILURE: 101, + GENERAL_COMMIT_FAILURE: 101, + UNDEFINED_DATA_MODEL: 101, + UNIMPLEMENTED_ELEMENT: 101, + VALUE_NOT_INITIALIZED: 101, + INVALID_SET_VALUE: 101, + READ_ONLY_ELEMENT: 101, + WRITE_ONLY_ELEMENT: 101, + TYPE_MISMATCH: 101, + VALUE_OUT_OF_RANGE: 101, + DEPENDENCY_NOT_ESTABLISHED: 101 +}; + +var scorm12 = _objectSpread(_objectSpread({}, global), { + RETRIEVE_BEFORE_INIT: 301, + STORE_BEFORE_INIT: 301, + COMMIT_BEFORE_INIT: 301, + ARGUMENT_ERROR: 201, + CHILDREN_ERROR: 202, + COUNT_ERROR: 203, + UNDEFINED_DATA_MODEL: 401, + UNIMPLEMENTED_ELEMENT: 401, + VALUE_NOT_INITIALIZED: 301, + INVALID_SET_VALUE: 402, + READ_ONLY_ELEMENT: 403, + WRITE_ONLY_ELEMENT: 404, + TYPE_MISMATCH: 405, + VALUE_OUT_OF_RANGE: 407, + DEPENDENCY_NOT_ESTABLISHED: 408 +}); + +var scorm2004 = _objectSpread(_objectSpread({}, global), { + INITIALIZATION_FAILED: 102, + INITIALIZED: 103, + TERMINATED: 104, + TERMINATION_FAILURE: 111, + TERMINATION_BEFORE_INIT: 112, + MULTIPLE_TERMINATIONS: 113, + RETRIEVE_BEFORE_INIT: 122, + RETRIEVE_AFTER_TERM: 123, + STORE_BEFORE_INIT: 132, + STORE_AFTER_TERM: 133, + COMMIT_BEFORE_INIT: 142, + COMMIT_AFTER_TERM: 143, + ARGUMENT_ERROR: 201, + GENERAL_GET_FAILURE: 301, + GENERAL_SET_FAILURE: 351, + GENERAL_COMMIT_FAILURE: 391, + UNDEFINED_DATA_MODEL: 401, + UNIMPLEMENTED_ELEMENT: 402, + VALUE_NOT_INITIALIZED: 403, + READ_ONLY_ELEMENT: 404, + WRITE_ONLY_ELEMENT: 405, + TYPE_MISMATCH: 406, + VALUE_OUT_OF_RANGE: 407, + DEPENDENCY_NOT_ESTABLISHED: 408 +}); + +var ErrorCodes = { + scorm12: scorm12, + scorm2004: scorm2004 +}; +var _default = ErrorCodes; +exports["default"] = _default; + +},{}],8:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; +var ValidLanguages = { + 'aa': 'aa', + 'ab': 'ab', + 'ae': 'ae', + 'af': 'af', + 'ak': 'ak', + 'am': 'am', + 'an': 'an', + 'ar': 'ar', + 'as': 'as', + 'av': 'av', + 'ay': 'ay', + 'az': 'az', + 'ba': 'ba', + 'be': 'be', + 'bg': 'bg', + 'bh': 'bh', + 'bi': 'bi', + 'bm': 'bm', + 'bn': 'bn', + 'bo': 'bo', + 'br': 'br', + 'bs': 'bs', + 'ca': 'ca', + 'ce': 'ce', + 'ch': 'ch', + 'co': 'co', + 'cr': 'cr', + 'cs': 'cs', + 'cu': 'cu', + 'cv': 'cv', + 'cy': 'cy', + 'da': 'da', + 'de': 'de', + 'dv': 'dv', + 'dz': 'dz', + 'ee': 'ee', + 'el': 'el', + 'en': 'en', + 'eo': 'eo', + 'es': 'es', + 'et': 'et', + 'eu': 'eu', + 'fa': 'fa', + 'ff': 'ff', + 'fi': 'fi', + 'fj': 'fj', + 'fo': 'fo', + 'fr': 'fr', + 'fy': 'fy', + 'ga': 'ga', + 'gd': 'gd', + 'gl': 'gl', + 'gn': 'gn', + 'gu': 'gu', + 'gv': 'gv', + 'ha': 'ha', + 'he': 'he', + 'hi': 'hi', + 'ho': 'ho', + 'hr': 'hr', + 'ht': 'ht', + 'hu': 'hu', + 'hy': 'hy', + 'hz': 'hz', + 'ia': 'ia', + 'id': 'id', + 'ie': 'ie', + 'ig': 'ig', + 'ii': 'ii', + 'ik': 'ik', + 'io': 'io', + 'is': 'is', + 'it': 'it', + 'iu': 'iu', + 'ja': 'ja', + 'jv': 'jv', + 'ka': 'ka', + 'kg': 'kg', + 'ki': 'ki', + 'kj': 'kj', + 'kk': 'kk', + 'kl': 'kl', + 'km': 'km', + 'kn': 'kn', + 'ko': 'ko', + 'kr': 'kr', + 'ks': 'ks', + 'ku': 'ku', + 'kv': 'kv', + 'kw': 'kw', + 'ky': 'ky', + 'la': 'la', + 'lb': 'lb', + 'lg': 'lg', + 'li': 'li', + 'ln': 'ln', + 'lo': 'lo', + 'lt': 'lt', + 'lu': 'lu', + 'lv': 'lv', + 'mg': 'mg', + 'mh': 'mh', + 'mi': 'mi', + 'mk': 'mk', + 'ml': 'ml', + 'mn': 'mn', + 'mo': 'mo', + 'mr': 'mr', + 'ms': 'ms', + 'mt': 'mt', + 'my': 'my', + 'na': 'na', + 'nb': 'nb', + 'nd': 'nd', + 'ne': 'ne', + 'ng': 'ng', + 'nl': 'nl', + 'nn': 'nn', + 'no': 'no', + 'nr': 'nr', + 'nv': 'nv', + 'ny': 'ny', + 'oc': 'oc', + 'oj': 'oj', + 'om': 'om', + 'or': 'or', + 'os': 'os', + 'pa': 'pa', + 'pi': 'pi', + 'pl': 'pl', + 'ps': 'ps', + 'pt': 'pt', + 'qu': 'qu', + 'rm': 'rm', + 'rn': 'rn', + 'ro': 'ro', + 'ru': 'ru', + 'rw': 'rw', + 'sa': 'sa', + 'sc': 'sc', + 'sd': 'sd', + 'se': 'se', + 'sg': 'sg', + 'sh': 'sh', + 'si': 'si', + 'sk': 'sk', + 'sl': 'sl', + 'sm': 'sm', + 'sn': 'sn', + 'so': 'so', + 'sq': 'sq', + 'sr': 'sr', + 'ss': 'ss', + 'st': 'st', + 'su': 'su', + 'sv': 'sv', + 'sw': 'sw', + 'ta': 'ta', + 'te': 'te', + 'tg': 'tg', + 'th': 'th', + 'ti': 'ti', + 'tk': 'tk', + 'tl': 'tl', + 'tn': 'tn', + 'to': 'to', + 'tr': 'tr', + 'ts': 'ts', + 'tt': 'tt', + 'tw': 'tw', + 'ty': 'ty', + 'ug': 'ug', + 'uk': 'uk', + 'ur': 'ur', + 'uz': 'uz', + 've': 've', + 'vi': 'vi', + 'vo': 'vo', + 'wa': 'wa', + 'wo': 'wo', + 'xh': 'xh', + 'yi': 'yi', + 'yo': 'yo', + 'za': 'za', + 'zh': 'zh', + 'zu': 'zu', + 'aar': 'aar', + 'abk': 'abk', + 'ave': 'ave', + 'afr': 'afr', + 'aka': 'aka', + 'amh': 'amh', + 'arg': 'arg', + 'ara': 'ara', + 'asm': 'asm', + 'ava': 'ava', + 'aym': 'aym', + 'aze': 'aze', + 'bak': 'bak', + 'bel': 'bel', + 'bul': 'bul', + 'bih': 'bih', + 'bis': 'bis', + 'bam': 'bam', + 'ben': 'ben', + 'tib': 'tib', + 'bod': 'bod', + 'bre': 'bre', + 'bos': 'bos', + 'cat': 'cat', + 'che': 'che', + 'cha': 'cha', + 'cos': 'cos', + 'cre': 'cre', + 'cze': 'cze', + 'ces': 'ces', + 'chu': 'chu', + 'chv': 'chv', + 'wel': 'wel', + 'cym': 'cym', + 'dan': 'dan', + 'ger': 'ger', + 'deu': 'deu', + 'div': 'div', + 'dzo': 'dzo', + 'ewe': 'ewe', + 'gre': 'gre', + 'ell': 'ell', + 'eng': 'eng', + 'epo': 'epo', + 'spa': 'spa', + 'est': 'est', + 'baq': 'baq', + 'eus': 'eus', + 'per': 'per', + 'fas': 'fas', + 'ful': 'ful', + 'fin': 'fin', + 'fij': 'fij', + 'fao': 'fao', + 'fre': 'fre', + 'fra': 'fra', + 'fry': 'fry', + 'gle': 'gle', + 'gla': 'gla', + 'glg': 'glg', + 'grn': 'grn', + 'guj': 'guj', + 'glv': 'glv', + 'hau': 'hau', + 'heb': 'heb', + 'hin': 'hin', + 'hmo': 'hmo', + 'hrv': 'hrv', + 'hat': 'hat', + 'hun': 'hun', + 'arm': 'arm', + 'hye': 'hye', + 'her': 'her', + 'ina': 'ina', + 'ind': 'ind', + 'ile': 'ile', + 'ibo': 'ibo', + 'iii': 'iii', + 'ipk': 'ipk', + 'ido': 'ido', + 'ice': 'ice', + 'isl': 'isl', + 'ita': 'ita', + 'iku': 'iku', + 'jpn': 'jpn', + 'jav': 'jav', + 'geo': 'geo', + 'kat': 'kat', + 'kon': 'kon', + 'kik': 'kik', + 'kua': 'kua', + 'kaz': 'kaz', + 'kal': 'kal', + 'khm': 'khm', + 'kan': 'kan', + 'kor': 'kor', + 'kau': 'kau', + 'kas': 'kas', + 'kur': 'kur', + 'kom': 'kom', + 'cor': 'cor', + 'kir': 'kir', + 'lat': 'lat', + 'ltz': 'ltz', + 'lug': 'lug', + 'lim': 'lim', + 'lin': 'lin', + 'lao': 'lao', + 'lit': 'lit', + 'lub': 'lub', + 'lav': 'lav', + 'mlg': 'mlg', + 'mah': 'mah', + 'mao': 'mao', + 'mri': 'mri', + 'mac': 'mac', + 'mkd': 'mkd', + 'mal': 'mal', + 'mon': 'mon', + 'mol': 'mol', + 'mar': 'mar', + 'may': 'may', + 'msa': 'msa', + 'mlt': 'mlt', + 'bur': 'bur', + 'mya': 'mya', + 'nau': 'nau', + 'nob': 'nob', + 'nde': 'nde', + 'nep': 'nep', + 'ndo': 'ndo', + 'dut': 'dut', + 'nld': 'nld', + 'nno': 'nno', + 'nor': 'nor', + 'nbl': 'nbl', + 'nav': 'nav', + 'nya': 'nya', + 'oci': 'oci', + 'oji': 'oji', + 'orm': 'orm', + 'ori': 'ori', + 'oss': 'oss', + 'pan': 'pan', + 'pli': 'pli', + 'pol': 'pol', + 'pus': 'pus', + 'por': 'por', + 'que': 'que', + 'roh': 'roh', + 'run': 'run', + 'rum': 'rum', + 'ron': 'ron', + 'rus': 'rus', + 'kin': 'kin', + 'san': 'san', + 'srd': 'srd', + 'snd': 'snd', + 'sme': 'sme', + 'sag': 'sag', + 'slo': 'slo', + 'sin': 'sin', + 'slk': 'slk', + 'slv': 'slv', + 'smo': 'smo', + 'sna': 'sna', + 'som': 'som', + 'alb': 'alb', + 'sqi': 'sqi', + 'srp': 'srp', + 'ssw': 'ssw', + 'sot': 'sot', + 'sun': 'sun', + 'swe': 'swe', + 'swa': 'swa', + 'tam': 'tam', + 'tel': 'tel', + 'tgk': 'tgk', + 'tha': 'tha', + 'tir': 'tir', + 'tuk': 'tuk', + 'tgl': 'tgl', + 'tsn': 'tsn', + 'ton': 'ton', + 'tur': 'tur', + 'tso': 'tso', + 'tat': 'tat', + 'twi': 'twi', + 'tah': 'tah', + 'uig': 'uig', + 'ukr': 'ukr', + 'urd': 'urd', + 'uzb': 'uzb', + 'ven': 'ven', + 'vie': 'vie', + 'vol': 'vol', + 'wln': 'wln', + 'wol': 'wol', + 'xho': 'xho', + 'yid': 'yid', + 'yor': 'yor', + 'zha': 'zha', + 'chi': 'chi', + 'zho': 'zho', + 'zul': 'zul' +}; +var _default = ValidLanguages; +exports["default"] = _default; + +},{}],9:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var scorm12 = { + CMIString256: '^.{0,255}$', + CMIString4096: '^.{0,4096}$', + CMITime: '^(?:[01]\\d|2[0123]):(?:[012345]\\d):(?:[012345]\\d)$', + // eslint-disable-line + CMITimespan: '^([0-9]{2,}):([0-9]{2}):([0-9]{2})(\.[0-9]{1,2})?$', + // eslint-disable-line + CMIInteger: '^\\d+$', + CMISInteger: '^-?([0-9]+)$', + CMIDecimal: '^-?([0-9]{0,3})(\.[0-9]*)?$', + // eslint-disable-line + CMIIdentifier: "^[\\u0021-\\u007E\\s]{0,255}$", + CMIFeedback: '^.{0,255}$', + // This must be redefined + CMIIndex: '[._](\\d+).', + // Vocabulary Data Type Definition + CMIStatus: '^(passed|completed|failed|incomplete|browsed)$', + CMIStatus2: '^(passed|completed|failed|incomplete|browsed|not attempted)$', + CMIExit: '^(time-out|suspend|logout|)$', + CMIType: '^(true-false|choice|fill-in|matching|performance|sequencing|likert|numeric)$', + CMIResult: '^(correct|wrong|unanticipated|neutral|([0-9]{0,3})?(\\.[0-9]*)?)$', + // eslint-disable-line + NAVEvent: '^(previous|continue)$', + // Data ranges + score_range: '0#100', + audio_range: '-1#100', + speed_range: '-100#100', + weighting_range: '-100#100', + text_range: '-1#1' +}; + +var aicc = _objectSpread(_objectSpread({}, scorm12), { + CMIIdentifier: '^\\w{1,255}$' +}); + +var scorm2004 = { + CMIString200: "^[\\u0000-\\uFFFF]{0,200}$", + CMIString250: "^[\\u0000-\\uFFFF]{0,250}$", + CMIString1000: "^[\\u0000-\\uFFFF]{0,1000}$", + CMIString4000: "^[\\u0000-\\uFFFF]{0,4000}$", + CMIString64000: "^[\\u0000-\\uFFFF]{0,64000}$", + CMILang: '^([a-zA-Z]{2,3}|i|x)(\-[a-zA-Z0-9\-]{2,8})?$|^$', + // eslint-disable-line + CMILangString250: '^(\{lang=([a-zA-Z]{2,3}|i|x)(\-[a-zA-Z0-9\-]{2,8})?\})?((?!\{.*$).{0,250}$)?$', + // eslint-disable-line + CMILangcr: '^((\{lang=([a-zA-Z]{2,3}|i|x)?(\-[a-zA-Z0-9\-]{2,8})?\}))(.*?)$', + // eslint-disable-line + CMILangString250cr: '^((\{lang=([a-zA-Z]{2,3}|i|x)?(\-[a-zA-Z0-9\-]{2,8})?\})?(.{0,250})?)?$', + // eslint-disable-line + CMILangString4000: '^(\{lang=([a-zA-Z]{2,3}|i|x)(\-[a-zA-Z0-9\-]{2,8})?\})?((?!\{.*$).{0,4000}$)?$', + // eslint-disable-line + CMITime: '^(19[7-9]{1}[0-9]{1}|20[0-2]{1}[0-9]{1}|203[0-8]{1})((-(0[1-9]{1}|1[0-2]{1}))((-(0[1-9]{1}|[1-2]{1}[0-9]{1}|3[0-1]{1}))(T([0-1]{1}[0-9]{1}|2[0-3]{1})((:[0-5]{1}[0-9]{1})((:[0-5]{1}[0-9]{1})((\\.[0-9]{1,2})((Z|([+|-]([0-1]{1}[0-9]{1}|2[0-3]{1})))(:[0-5]{1}[0-9]{1})?)?)?)?)?)?)?)?$', + CMITimespan: '^P(?:([.,\\d]+)Y)?(?:([.,\\d]+)M)?(?:([.,\\d]+)W)?(?:([.,\\d]+)D)?(?:T?(?:([.,\\d]+)H)?(?:([.,\\d]+)M)?(?:([.,\\d]+)S)?)?$', + CMIInteger: '^\\d+$', + CMISInteger: '^-?([0-9]+)$', + CMIDecimal: '^-?([0-9]{1,5})(\\.[0-9]{1,18})?$', + CMIIdentifier: '^\\S{1,250}[a-zA-Z0-9]$', + CMIShortIdentifier: '^[\\w\\.\\-\\_]{1,250}$', + // eslint-disable-line + CMILongIdentifier: '^(?:(?!urn:)\\S{1,4000}|urn:[A-Za-z0-9-]{1,31}:\\S{1,4000}|.{1,4000})$', + // need to re-examine this + CMIFeedback: '^.*$', + // This must be redefined + CMIIndex: '[._](\\d+).', + CMIIndexStore: '.N(\\d+).', + // Vocabulary Data Type Definition + CMICStatus: '^(completed|incomplete|not attempted|unknown)$', + CMISStatus: '^(passed|failed|unknown)$', + CMIExit: '^(time-out|suspend|logout|normal)$', + CMIType: '^(true-false|choice|fill-in|long-fill-in|matching|performance|sequencing|likert|numeric|other)$', + CMIResult: '^(correct|incorrect|unanticipated|neutral|-?([0-9]{1,4})(\\.[0-9]{1,18})?)$', + NAVEvent: '^(previous|continue|exit|exitAll|abandon|abandonAll|suspendAll|\{target=\\S{0,200}[a-zA-Z0-9]\}choice|jump)$', + // eslint-disable-line + NAVBoolean: '^(unknown|true|false$)', + NAVTarget: '^(previous|continue|choice.{target=\\S{0,200}[a-zA-Z0-9]})$', + // Data ranges + scaled_range: '-1#1', + audio_range: '0#*', + speed_range: '0#*', + text_range: '-1#1', + progress_range: '0#1' +}; +var Regex = { + aicc: aicc, + scorm12: scorm12, + scorm2004: scorm2004 +}; +var _default = Regex; +exports["default"] = _default; + +},{}],10:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +var _regex = _interopRequireDefault(require("./regex")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +var scorm2004_regex = _regex["default"].scorm2004; +var learner = { + 'true-false': { + format: '^true$|^false$', + max: 1, + delimiter: '', + unique: false + }, + 'choice': { + format: scorm2004_regex.CMIShortIdentifier, + max: 36, + delimiter: '[,]', + unique: true + }, + 'fill-in': { + format: scorm2004_regex.CMILangString250, + max: 10, + delimiter: '[,]', + unique: false + }, + 'long-fill-in': { + format: scorm2004_regex.CMILangString4000, + max: 1, + delimiter: '', + unique: false + }, + 'matching': { + format: scorm2004_regex.CMIShortIdentifier, + format2: scorm2004_regex.CMIShortIdentifier, + max: 36, + delimiter: '[,]', + delimiter2: '[.]', + unique: false + }, + 'performance': { + format: '^$|' + scorm2004_regex.CMIShortIdentifier, + format2: scorm2004_regex.CMIDecimal + '|^$|' + scorm2004_regex.CMIShortIdentifier, + max: 250, + delimiter: '[,]', + delimiter2: '[.]', + unique: false + }, + 'sequencing': { + format: scorm2004_regex.CMIShortIdentifier, + max: 36, + delimiter: '[,]', + unique: false + }, + 'likert': { + format: scorm2004_regex.CMIShortIdentifier, + max: 1, + delimiter: '', + unique: false + }, + 'numeric': { + format: scorm2004_regex.CMIDecimal, + max: 1, + delimiter: '', + unique: false + }, + 'other': { + format: scorm2004_regex.CMIString4000, + max: 1, + delimiter: '', + unique: false + } +}; +var correct = { + 'true-false': { + max: 1, + delimiter: '', + unique: false, + duplicate: false, + format: '^true$|^false$', + limit: 1 + }, + 'choice': { + max: 36, + delimiter: '[,]', + unique: true, + duplicate: false, + format: scorm2004_regex.CMIShortIdentifier + }, + 'fill-in': { + max: 10, + delimiter: '[,]', + unique: false, + duplicate: false, + format: scorm2004_regex.CMILangString250cr + }, + 'long-fill-in': { + max: 1, + delimiter: '', + unique: false, + duplicate: true, + format: scorm2004_regex.CMILangString4000 + }, + 'matching': { + max: 36, + delimiter: '[,]', + delimiter2: '[.]', + unique: false, + duplicate: false, + format: scorm2004_regex.CMIShortIdentifier, + format2: scorm2004_regex.CMIShortIdentifier + }, + 'performance': { + max: 250, + delimiter: '[,]', + delimiter2: '[.]', + unique: false, + duplicate: false, + format: '^$|' + scorm2004_regex.CMIShortIdentifier, + format2: scorm2004_regex.CMIDecimal + '|^$|' + scorm2004_regex.CMIShortIdentifier + }, + 'sequencing': { + max: 36, + delimiter: '[,]', + unique: false, + duplicate: false, + format: scorm2004_regex.CMIShortIdentifier + }, + 'likert': { + max: 1, + delimiter: '', + unique: false, + duplicate: false, + format: scorm2004_regex.CMIShortIdentifier, + limit: 1 + }, + 'numeric': { + max: 2, + delimiter: '[:]', + unique: false, + duplicate: false, + format: scorm2004_regex.CMIDecimal, + limit: 1 + }, + 'other': { + max: 1, + delimiter: '', + unique: false, + duplicate: false, + format: scorm2004_regex.CMIString4000, + limit: 1 + } +}; +var Responses = { + learner: learner, + correct: correct +}; +var _default = Responses; +exports["default"] = _default; + +},{"./regex":9}],11:[function(require,module,exports){ +"use strict"; + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.Scorm2004ValidationError = exports.AICCValidationError = exports.Scorm12ValidationError = exports.ValidationError = void 0; + +var _api_constants = _interopRequireDefault(require("./constants/api_constants")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); } + +function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); } + +function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; } + +function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); } + +function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } } + +var scorm12_errors = _api_constants["default"].scorm12.error_descriptions; +var aicc_errors = _api_constants["default"].aicc.error_descriptions; +var scorm2004_errors = _api_constants["default"].scorm2004.error_descriptions; +/** + * Base Validation Exception + */ + +var _errorCode = new WeakMap(); + +var _errorMessage = new WeakMap(); + +var _detailedMessage = new WeakMap(); + +var ValidationError = /*#__PURE__*/function (_Error) { + _inherits(ValidationError, _Error); + + var _super = _createSuper(ValidationError); + + /** + * Constructor to take in an error message and code + * @param {number} errorCode + * @param {string} errorMessage + * @param {string} detailedMessage + */ + function ValidationError(errorCode, errorMessage, detailedMessage) { + var _this; + + _classCallCheck(this, ValidationError); + + _this = _super.call(this, errorMessage); + + _errorCode.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _errorMessage.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _detailedMessage.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _classPrivateFieldSet(_assertThisInitialized(_this), _errorCode, errorCode); + + _classPrivateFieldSet(_assertThisInitialized(_this), _errorMessage, errorMessage); + + _classPrivateFieldSet(_assertThisInitialized(_this), _detailedMessage, detailedMessage); + + return _this; + } + + _createClass(ValidationError, [{ + key: "errorCode", + get: + /** + * Getter for #errorCode + * @return {number} + */ + function get() { + return _classPrivateFieldGet(this, _errorCode); + } + /** + * Getter for #errorMessage + * @return {string} + */ + + }, { + key: "errorMessage", + get: function get() { + return _classPrivateFieldGet(this, _errorMessage); + } + /** + * Getter for #detailedMessage + * @return {string} + */ + + }, { + key: "detailedMessage", + get: function get() { + return _classPrivateFieldGet(this, _detailedMessage); + } + }]); + + return ValidationError; +}( /*#__PURE__*/_wrapNativeSuper(Error)); +/** + * SCORM 1.2 Validation Error + */ + + +exports.ValidationError = ValidationError; + +var Scorm12ValidationError = /*#__PURE__*/function (_ValidationError) { + _inherits(Scorm12ValidationError, _ValidationError); + + var _super2 = _createSuper(Scorm12ValidationError); + + /** + * Constructor to take in an error code + * @param {number} errorCode + */ + function Scorm12ValidationError(errorCode) { + var _this2; + + _classCallCheck(this, Scorm12ValidationError); + + if ({}.hasOwnProperty.call(scorm12_errors, String(errorCode))) { + _this2 = _super2.call(this, errorCode, scorm12_errors[String(errorCode)].basicMessage, scorm12_errors[String(errorCode)].detailMessage); + } else { + _this2 = _super2.call(this, 101, scorm12_errors['101'].basicMessage, scorm12_errors['101'].detailMessage); + } + + return _possibleConstructorReturn(_this2); + } + + return Scorm12ValidationError; +}(ValidationError); +/** + * AICC Validation Error + */ + + +exports.Scorm12ValidationError = Scorm12ValidationError; + +var AICCValidationError = /*#__PURE__*/function (_ValidationError2) { + _inherits(AICCValidationError, _ValidationError2); + + var _super3 = _createSuper(AICCValidationError); + + /** + * Constructor to take in an error code + * @param {number} errorCode + */ + function AICCValidationError(errorCode) { + var _this3; + + _classCallCheck(this, AICCValidationError); + + if ({}.hasOwnProperty.call(aicc_errors, String(errorCode))) { + _this3 = _super3.call(this, errorCode, aicc_errors[String(errorCode)].basicMessage, aicc_errors[String(errorCode)].detailMessage); + } else { + _this3 = _super3.call(this, 101, aicc_errors['101'].basicMessage, aicc_errors['101'].detailMessage); + } + + return _possibleConstructorReturn(_this3); + } + + return AICCValidationError; +}(ValidationError); +/** + * SCORM 2004 Validation Error + */ + + +exports.AICCValidationError = AICCValidationError; + +var Scorm2004ValidationError = /*#__PURE__*/function (_ValidationError3) { + _inherits(Scorm2004ValidationError, _ValidationError3); + + var _super4 = _createSuper(Scorm2004ValidationError); + + /** + * Constructor to take in an error code + * @param {number} errorCode + */ + function Scorm2004ValidationError(errorCode) { + var _this4; + + _classCallCheck(this, Scorm2004ValidationError); + + if ({}.hasOwnProperty.call(scorm2004_errors, String(errorCode))) { + _this4 = _super4.call(this, errorCode, scorm2004_errors[String(errorCode)].basicMessage, scorm2004_errors[String(errorCode)].detailMessage); + } else { + _this4 = _super4.call(this, 101, scorm2004_errors['101'].basicMessage, scorm2004_errors['101'].detailMessage); + } + + return _possibleConstructorReturn(_this4); + } + + return Scorm2004ValidationError; +}(ValidationError); + +exports.Scorm2004ValidationError = Scorm2004ValidationError; + +},{"./constants/api_constants":6}],12:[function(require,module,exports){ +"use strict"; + +var _Scorm2004API = _interopRequireDefault(require("../Scorm2004API")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +window.Scorm2004API = _Scorm2004API["default"]; + +},{"../Scorm2004API":3}],13:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.getSecondsAsHHMMSS = getSecondsAsHHMMSS; +exports.getSecondsAsISODuration = getSecondsAsISODuration; +exports.getTimeAsSeconds = getTimeAsSeconds; +exports.getDurationAsSeconds = getDurationAsSeconds; +exports.addTwoDurations = addTwoDurations; +exports.addHHMMSSTimeStrings = addHHMMSSTimeStrings; +exports.flatten = flatten; +exports.unflatten = unflatten; +exports.countDecimals = countDecimals; +exports.SECONDS_PER_DAY = exports.SECONDS_PER_HOUR = exports.SECONDS_PER_MINUTE = exports.SECONDS_PER_SECOND = void 0; + +function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); } + +function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } + +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit(arr, i) { var _i = arr && (typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]); if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } + +var SECONDS_PER_SECOND = 1.0; +exports.SECONDS_PER_SECOND = SECONDS_PER_SECOND; +var SECONDS_PER_MINUTE = 60; +exports.SECONDS_PER_MINUTE = SECONDS_PER_MINUTE; +var SECONDS_PER_HOUR = 60 * SECONDS_PER_MINUTE; +exports.SECONDS_PER_HOUR = SECONDS_PER_HOUR; +var SECONDS_PER_DAY = 24 * SECONDS_PER_HOUR; +exports.SECONDS_PER_DAY = SECONDS_PER_DAY; +var designations = [['D', SECONDS_PER_DAY], ['H', SECONDS_PER_HOUR], ['M', SECONDS_PER_MINUTE], ['S', SECONDS_PER_SECOND]]; +/** + * Converts a Number to a String of HH:MM:SS + * + * @param {Number} totalSeconds + * @return {string} + */ + +function getSecondsAsHHMMSS(totalSeconds) { + // SCORM spec does not deal with negative durations, give zero back + if (!totalSeconds || totalSeconds <= 0) { + return '00:00:00'; + } + + var hours = Math.floor(totalSeconds / SECONDS_PER_HOUR); + var dateObj = new Date(totalSeconds * 1000); + var minutes = dateObj.getUTCMinutes(); // make sure we add any possible decimal value + + var seconds = dateObj.getSeconds(); + var ms = totalSeconds % 1.0; + var msStr = ''; + + if (countDecimals(ms) > 0) { + if (countDecimals(ms) > 2) { + msStr = ms.toFixed(2); + } else { + msStr = String(ms); + } + + msStr = '.' + msStr.split('.')[1]; + } + + return (hours + ':' + minutes + ':' + seconds).replace(/\b\d\b/g, '0$&') + msStr; +} +/** + * Calculate the number of seconds from ISO 8601 Duration + * + * @param {Number} seconds + * @return {String} + */ + + +function getSecondsAsISODuration(seconds) { + // SCORM spec does not deal with negative durations, give zero back + if (!seconds || seconds <= 0) { + return 'PT0S'; + } + + var duration = 'P'; + var remainder = seconds; + designations.forEach(function (_ref) { + var _ref2 = _slicedToArray(_ref, 2), + sign = _ref2[0], + current_seconds = _ref2[1]; + + var value = Math.floor(remainder / current_seconds); + remainder = remainder % current_seconds; + + if (countDecimals(remainder) > 2) { + remainder = Number(Number(remainder).toFixed(2)); + } // If we have anything left in the remainder, and we're currently adding + // seconds to the duration, go ahead and add the decimal to the seconds + + + if (sign === 'S' && remainder > 0) { + value += remainder; + } + + if (value) { + if ((duration.indexOf('D') > 0 || sign === 'H' || sign === 'M' || sign === 'S') && duration.indexOf('T') === -1) { + duration += 'T'; + } + + duration += "".concat(value).concat(sign); + } + }); + return duration; +} +/** + * Calculate the number of seconds from HH:MM:SS.DDDDDD + * + * @param {string} timeString + * @param {RegExp} timeRegex + * @return {number} + */ + + +function getTimeAsSeconds(timeString, timeRegex) { + if (!timeString || typeof timeString !== 'string' || !timeString.match(timeRegex)) { + return 0; + } + + var parts = timeString.split(':'); + var hours = Number(parts[0]); + var minutes = Number(parts[1]); + var seconds = Number(parts[2]); + return hours * 3600 + minutes * 60 + seconds; +} +/** + * Calculate the number of seconds from ISO 8601 Duration + * + * @param {string} duration + * @param {RegExp} durationRegex + * @return {number} + */ + + +function getDurationAsSeconds(duration, durationRegex) { + if (!duration || !duration.match(durationRegex)) { + return 0; + } + + var _ref3 = new RegExp(durationRegex).exec(duration) || [], + _ref4 = _slicedToArray(_ref3, 8), + years = _ref4[1], + months = _ref4[2], + days = _ref4[4], + hours = _ref4[5], + minutes = _ref4[6], + seconds = _ref4[7]; + + var result = 0.0; + result += Number(seconds) * 1.0 || 0.0; + result += Number(minutes) * 60.0 || 0.0; + result += Number(hours) * 3600.0 || 0.0; + result += Number(days) * (60 * 60 * 24.0) || 0.0; + result += Number(years) * (60 * 60 * 24 * 365.0) || 0.0; + return result; +} +/** + * Adds together two ISO8601 Duration strings + * + * @param {string} first + * @param {string} second + * @param {RegExp} durationRegex + * @return {string} + */ + + +function addTwoDurations(first, second, durationRegex) { + return getSecondsAsISODuration(getDurationAsSeconds(first, durationRegex) + getDurationAsSeconds(second, durationRegex)); +} +/** + * Add together two HH:MM:SS.DD strings + * + * @param {string} first + * @param {string} second + * @param {RegExp} timeRegex + * @return {string} + */ + + +function addHHMMSSTimeStrings(first, second, timeRegex) { + return getSecondsAsHHMMSS(getTimeAsSeconds(first, timeRegex) + getTimeAsSeconds(second, timeRegex)); +} +/** + * Flatten a JSON object down to string paths for each values + * @param {object} data + * @return {object} + */ + + +function flatten(data) { + var result = {}; + /** + * Recurse through the object + * @param {*} cur + * @param {*} prop + */ + + function recurse(cur, prop) { + if (Object(cur) !== cur) { + result[prop] = cur; + } else if (Array.isArray(cur)) { + for (var i = 0, l = cur.length; i < l; i++) { + recurse(cur[i], prop + '[' + i + ']'); + if (l === 0) result[prop] = []; + } + } else { + var isEmpty = true; + + for (var p in cur) { + if ({}.hasOwnProperty.call(cur, p)) { + isEmpty = false; + recurse(cur[p], prop ? prop + '.' + p : p); + } + } + + if (isEmpty && prop) result[prop] = {}; + } + } + + recurse(data, ''); + return result; +} +/** + * Un-flatten a flat JSON object + * @param {object} data + * @return {object} + */ + + +function unflatten(data) { + 'use strict'; + + if (Object(data) !== data || Array.isArray(data)) return data; + var regex = /\.?([^.[\]]+)|\[(\d+)]/g; + var result = {}; + + for (var p in data) { + if ({}.hasOwnProperty.call(data, p)) { + var cur = result; + var prop = ''; + var m = regex.exec(p); + + while (m) { + cur = cur[prop] || (cur[prop] = m[2] ? [] : {}); + prop = m[2] || m[1]; + m = regex.exec(p); + } + + cur[prop] = data[p]; + } + } + + return result[''] || result; +} +/** + * Counts the number of decimal places + * @param {number} num + * @return {number} + */ + + +function countDecimals(num) { + if (Math.floor(num) === num || String(num).indexOf('.') < 0) return 0; + var parts = num.toString().split('.')[1]; + return parts.length || 0; +} + +},{}]},{},[12]) +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","node_modules/lodash.debounce/index.js","src/BaseAPI.js","src/Scorm2004API.js","src/cmi/common.js","src/cmi/scorm2004_cmi.js","src/constants/api_constants.js","src/constants/error_codes.js","src/constants/language_constants.js","src/constants/regex.js","src/constants/response_constants.js","src/exceptions.js","src/exports/scorm2004.js","src/utilities.js"],"names":[],"mappings":"AAAA;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;ACxXA;;AACA;;AACA;;AACA;;AACA;;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,IAAM,gBAAgB,GAAG,0BAAa,MAAtC;AACA,IAAM,mBAAmB,GAAG,yBAAW,OAAvC;AAEA;AACA;AACA;AACA;;;;;;;;IACqB,O;AAqCnB;AACF;AACA;AACA;AACA;AACA;AACE,mBAAY,WAAZ,EAAyB,QAAzB,EAAmC;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA,aAxCvB;AACV,QAAA,UAAU,EAAE,KADF;AAEV,QAAA,iBAAiB,EAAE,EAFT;AAGV,QAAA,WAAW,EAAE,KAHH;AAIV,QAAA,gBAAgB,EAAE,KAJR;AAKV,QAAA,YAAY,EAAE,KALJ;AAMV,QAAA,gBAAgB,EAAE,MANR;AAMgB;AAC1B,QAAA,qBAAqB,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","file":"generated.js","sourceRoot":"","sourcesContent":["(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()","/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the `TypeError` message for \"Functions\" methods. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n  return root.Date.now();\n};\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        result = wait - timeSinceLastCall;\n\n    return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && objectToString.call(value) == symbolTag);\n}\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = value.replace(reTrim, '');\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = debounce;\n","// @flow\nimport {CMIArray} from './cmi/common';\nimport {ValidationError} from './exceptions';\nimport ErrorCodes from './constants/error_codes';\nimport APIConstants from './constants/api_constants';\nimport {unflatten} from './utilities';\nimport debounce from 'lodash.debounce';\n\nconst global_constants = APIConstants.global;\nconst scorm12_error_codes = ErrorCodes.scorm12;\n\n/**\n * Base API class for AICC, SCORM 1.2, and SCORM 2004. Should be considered\n * abstract, and never initialized on it's own.\n */\nexport default class BaseAPI {\n  #timeout;\n  #error_codes;\n  #settings = {\n    autocommit: false,\n    autocommitSeconds: 10,\n    asyncCommit: false,\n    sendBeaconCommit: false,\n    lmsCommitUrl: false,\n    dataCommitFormat: 'json', // valid formats are 'json' or 'flattened', 'params'\n    commitRequestDataType: 'application/json;charset=UTF-8',\n    autoProgress: false,\n    logLevel: global_constants.LOG_LEVEL_ERROR,\n    selfReportSessionTime: false,\n    alwaysSendTotalTime: false,\n    strict_errors: true,\n    responseHandler: function(xhr) {\n      let result;\n      if (typeof xhr !== 'undefined') {\n        result = JSON.parse(xhr.responseText);\n        if (result === null || !{}.hasOwnProperty.call(result, 'result')) {\n          result = {};\n          if (xhr.status === 200) {\n            result.result = global_constants.SCORM_TRUE;\n            result.errorCode = 0;\n          } else {\n            result.result = global_constants.SCORM_FALSE;\n            result.errorCode = 101;\n          }\n        }\n      }\n      return result;\n    },\n  };\n  cmi;\n  startingData: {};\n\n  /**\n   * Constructor for Base API class. Sets some shared API fields, as well as\n   * sets up options for the API.\n   * @param {object} error_codes\n   * @param {object} settings\n   */\n  constructor(error_codes, settings) {\n    if (new.target === BaseAPI) {\n      throw new TypeError('Cannot construct BaseAPI instances directly');\n    }\n    this.currentState = global_constants.STATE_NOT_INITIALIZED;\n    this.lastErrorCode = 0;\n    this.listenerArray = [];\n\n    this.#timeout = null;\n    this.#error_codes = error_codes;\n\n    this.settings = settings;\n    this.apiLogLevel = this.settings.logLevel;\n    this.selfReportSessionTime = this.settings.selfReportSessionTime;\n  }\n\n  /**\n   * Initialize the API\n   * @param {string} callbackName\n   * @param {string} initializeMessage\n   * @param {string} terminationMessage\n   * @return {string}\n   */\n  initialize(\n      callbackName: String,\n      initializeMessage?: String,\n      terminationMessage?: String) {\n    let returnValue = global_constants.SCORM_FALSE;\n\n    if (this.isInitialized()) {\n      this.throwSCORMError(this.#error_codes.INITIALIZED, initializeMessage);\n    } else if (this.isTerminated()) {\n      this.throwSCORMError(this.#error_codes.TERMINATED, terminationMessage);\n    } else {\n      if (this.selfReportSessionTime) {\n        this.cmi.setStartTime();\n      }\n\n      this.currentState = global_constants.STATE_INITIALIZED;\n      this.lastErrorCode = 0;\n      returnValue = global_constants.SCORM_TRUE;\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n    this.clearSCORMError(returnValue);\n\n    return returnValue;\n  }\n\n  /**\n   * Getter for #error_codes\n   * @return {object}\n   */\n  get error_codes() {\n    return this.#error_codes;\n  }\n\n  /**\n   * Getter for #settings\n   * @return {object}\n   */\n  get settings() {\n    return this.#settings;\n  }\n\n  /**\n   * Setter for #settings\n   * @param {object} settings\n   */\n  set settings(settings: Object) {\n    this.#settings = {...this.#settings, ...settings};\n  }\n\n  /**\n   * Terminates the current run of the API\n   * @param {string} callbackName\n   * @param {boolean} checkTerminated\n   * @return {string}\n   */\n  terminate(\n      callbackName: String,\n      checkTerminated: boolean) {\n    let returnValue = global_constants.SCORM_FALSE;\n\n    if (this.checkState(checkTerminated,\n        this.#error_codes.TERMINATION_BEFORE_INIT,\n        this.#error_codes.MULTIPLE_TERMINATION)) {\n      this.currentState = global_constants.STATE_TERMINATED;\n\n      const result = this.storeData(true);\n      if (!this.settings.sendBeaconCommit && !this.settings.asyncCommit &&\n          typeof result.errorCode !== 'undefined' && result.errorCode > 0) {\n        this.throwSCORMError(result.errorCode);\n      }\n      returnValue = (typeof result !== 'undefined' && result.result) ?\n          result.result : global_constants.SCORM_FALSE;\n\n      if (checkTerminated) this.lastErrorCode = 0;\n\n      returnValue = global_constants.SCORM_TRUE;\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n    this.clearSCORMError(returnValue);\n\n    return returnValue;\n  }\n\n  /**\n   * Get the value of the CMIElement.\n   *\n   * @param {string} callbackName\n   * @param {boolean} checkTerminated\n   * @param {string} CMIElement\n   * @return {string}\n   */\n  getValue(\n      callbackName: String,\n      checkTerminated: boolean,\n      CMIElement: String) {\n    let returnValue;\n\n    if (this.checkState(checkTerminated,\n        this.#error_codes.RETRIEVE_BEFORE_INIT,\n        this.#error_codes.RETRIEVE_AFTER_TERM)) {\n      if (checkTerminated) this.lastErrorCode = 0;\n      try {\n        returnValue = this.getCMIValue(CMIElement);\n      } catch (e) {\n        if (e instanceof ValidationError) {\n          this.lastErrorCode = e.errorCode;\n          returnValue = global_constants.SCORM_FALSE;\n        } else {\n          if (e.message) {\n            console.error(e.message);\n          } else {\n            console.error(e);\n          }\n          this.throwSCORMError(this.#error_codes.GENERAL);\n        }\n      }\n      this.processListeners(callbackName, CMIElement);\n    }\n\n    this.apiLog(callbackName, CMIElement, ': returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n    this.clearSCORMError(returnValue);\n\n    return returnValue;\n  }\n\n  /**\n   * Sets the value of the CMIElement.\n   *\n   * @param {string} callbackName\n   * @param {string} commitCallback\n   * @param {boolean} checkTerminated\n   * @param {string} CMIElement\n   * @param {*} value\n   * @return {string}\n   */\n  setValue(\n      callbackName: String,\n      commitCallback: String,\n      checkTerminated: boolean,\n      CMIElement,\n      value) {\n    if (value !== undefined) {\n      value = String(value);\n    }\n    let returnValue = global_constants.SCORM_FALSE;\n\n    if (this.checkState(checkTerminated, this.#error_codes.STORE_BEFORE_INIT,\n        this.#error_codes.STORE_AFTER_TERM)) {\n      if (checkTerminated) this.lastErrorCode = 0;\n      try {\n        returnValue = this.setCMIValue(CMIElement, value);\n      } catch (e) {\n        if (e instanceof ValidationError) {\n          this.lastErrorCode = e.errorCode;\n          returnValue = global_constants.SCORM_FALSE;\n        } else {\n          if (e.message) {\n            console.error(e.message);\n          } else {\n            console.error(e);\n          }\n          this.throwSCORMError(this.#error_codes.GENERAL);\n        }\n      }\n      this.processListeners(callbackName, CMIElement, value);\n    }\n\n    if (returnValue === undefined) {\n      returnValue = global_constants.SCORM_FALSE;\n    }\n\n    // If we didn't have any errors while setting the data, go ahead and\n    // schedule a commit, if autocommit is turned on\n    if (String(this.lastErrorCode) === '0') {\n      if (this.settings.autocommit && !this.#timeout) {\n        this.scheduleCommit(this.settings.autocommitSeconds * 1000, commitCallback);\n      }\n    }\n\n    this.apiLog(callbackName, CMIElement,\n        ': ' + value + ': result: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n    this.clearSCORMError(returnValue);\n\n    return returnValue;\n  }\n\n  /**\n   * Orders LMS to store all content parameters\n   * @param {string} callbackName\n   * @param {boolean} checkTerminated\n   * @return {string}\n   */\n  commit(\n      callbackName: String,\n      checkTerminated: boolean) {\n    this.clearScheduledCommit();\n\n    let returnValue = global_constants.SCORM_FALSE;\n\n    if (this.checkState(checkTerminated, this.#error_codes.COMMIT_BEFORE_INIT,\n        this.#error_codes.COMMIT_AFTER_TERM)) {\n      const result = this.storeData(false);\n      if (!this.settings.sendBeaconCommit && !this.settings.asyncCommit &&\n          result.errorCode && result.errorCode > 0) {\n        this.throwSCORMError(result.errorCode);\n      }\n      returnValue = (typeof result !== 'undefined' && result.result) ?\n          result.result : global_constants.SCORM_FALSE;\n\n      this.apiLog(callbackName, 'HttpRequest', ' Result: ' + returnValue,\n          global_constants.LOG_LEVEL_DEBUG);\n\n      if (checkTerminated) this.lastErrorCode = 0;\n\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n    this.clearSCORMError(returnValue);\n\n    return returnValue;\n  }\n\n  /**\n   * Returns last error code\n   * @param {string} callbackName\n   * @return {string}\n   */\n  getLastError(callbackName: String) {\n    const returnValue = String(this.lastErrorCode);\n\n    this.processListeners(callbackName);\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n\n    return returnValue;\n  }\n\n  /**\n   * Returns the errorNumber error description\n   *\n   * @param {string} callbackName\n   * @param {(string|number)} CMIErrorCode\n   * @return {string}\n   */\n  getErrorString(callbackName: String, CMIErrorCode) {\n    let returnValue = '';\n\n    if (CMIErrorCode !== null && CMIErrorCode !== '') {\n      returnValue = this.getLmsErrorMessageDetails(CMIErrorCode);\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n\n    return returnValue;\n  }\n\n  /**\n   * Returns a comprehensive description of the errorNumber error.\n   *\n   * @param {string} callbackName\n   * @param {(string|number)} CMIErrorCode\n   * @return {string}\n   */\n  getDiagnostic(callbackName: String, CMIErrorCode) {\n    let returnValue = '';\n\n    if (CMIErrorCode !== null && CMIErrorCode !== '') {\n      returnValue = this.getLmsErrorMessageDetails(CMIErrorCode, true);\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        global_constants.LOG_LEVEL_INFO);\n\n    return returnValue;\n  }\n\n  /**\n   * Checks the LMS state and ensures it has been initialized.\n   *\n   * @param {boolean} checkTerminated\n   * @param {number} beforeInitError\n   * @param {number} afterTermError\n   * @return {boolean}\n   */\n  checkState(\n      checkTerminated: boolean,\n      beforeInitError: number,\n      afterTermError?: number) {\n    if (this.isNotInitialized()) {\n      this.throwSCORMError(beforeInitError);\n      return false;\n    } else if (checkTerminated && this.isTerminated()) {\n      this.throwSCORMError(afterTermError);\n      return false;\n    }\n\n    return true;\n  }\n\n  /**\n   * Logging for all SCORM actions\n   *\n   * @param {string} functionName\n   * @param {string} CMIElement\n   * @param {string} logMessage\n   * @param {number}messageLevel\n   */\n  apiLog(\n      functionName: String,\n      CMIElement: String,\n      logMessage: String,\n      messageLevel: number) {\n    logMessage = this.formatMessage(functionName, CMIElement, logMessage);\n\n    if (messageLevel >= this.apiLogLevel) {\n      switch (messageLevel) {\n        case global_constants.LOG_LEVEL_ERROR:\n          console.error(logMessage);\n          break;\n        case global_constants.LOG_LEVEL_WARNING:\n          console.warn(logMessage);\n          break;\n        case global_constants.LOG_LEVEL_INFO:\n          console.info(logMessage);\n          break;\n        case global_constants.LOG_LEVEL_DEBUG:\n          if (console.debug) {\n            console.debug(logMessage);\n          } else {\n            console.log(logMessage);\n          }\n          break;\n      }\n    }\n  }\n\n  /**\n   * Formats the SCORM messages for easy reading\n   *\n   * @param {string} functionName\n   * @param {string} CMIElement\n   * @param {string} message\n   * @return {string}\n   */\n  formatMessage(functionName: String, CMIElement: String, message: String) {\n    const baseLength = 20;\n    let messageString = '';\n\n    messageString += functionName;\n\n    let fillChars = baseLength - messageString.length;\n\n    for (let i = 0; i < fillChars; i++) {\n      messageString += ' ';\n    }\n\n    messageString += ': ';\n\n    if (CMIElement) {\n      const CMIElementBaseLength = 70;\n\n      messageString += CMIElement;\n\n      fillChars = CMIElementBaseLength - messageString.length;\n\n      for (let j = 0; j < fillChars; j++) {\n        messageString += ' ';\n      }\n    }\n\n    if (message) {\n      messageString += message;\n    }\n\n    return messageString;\n  }\n\n  /**\n   * Checks to see if {str} contains {tester}\n   *\n   * @param {string} str String to check against\n   * @param {string} tester String to check for\n   * @return {boolean}\n   */\n  stringMatches(str: String, tester: String) {\n    return str && tester && str.match(tester);\n  }\n\n  /**\n   * Check to see if the specific object has the given property\n   * @param {*} refObject\n   * @param {string} attribute\n   * @return {boolean}\n   * @private\n   */\n  _checkObjectHasProperty(refObject, attribute: String) {\n    return Object.hasOwnProperty.call(refObject, attribute) ||\n        Object.getOwnPropertyDescriptor(\n            Object.getPrototypeOf(refObject), attribute) ||\n        (attribute in refObject);\n  }\n\n  /**\n   * Returns the message that corresponds to errorNumber\n   * APIs that inherit BaseAPI should override this function\n   *\n   * @param {(string|number)} _errorNumber\n   * @param {boolean} _detail\n   * @return {string}\n   * @abstract\n   */\n  getLmsErrorMessageDetails(_errorNumber, _detail) {\n    throw new Error(\n        'The getLmsErrorMessageDetails method has not been implemented');\n  }\n\n  /**\n   * Gets the value for the specific element.\n   * APIs that inherit BaseAPI should override this function\n   *\n   * @param {string} _CMIElement\n   * @return {string}\n   * @abstract\n   */\n  getCMIValue(_CMIElement) {\n    throw new Error('The getCMIValue method has not been implemented');\n  }\n\n  /**\n   * Sets the value for the specific element.\n   * APIs that inherit BaseAPI should override this function\n   *\n   * @param {string} _CMIElement\n   * @param {any} _value\n   * @return {string}\n   * @abstract\n   */\n  setCMIValue(_CMIElement, _value) {\n    throw new Error('The setCMIValue method has not been implemented');\n  }\n\n  /**\n   * Shared API method to set a valid for a given element.\n   *\n   * @param {string} methodName\n   * @param {boolean} scorm2004\n   * @param {string} CMIElement\n   * @param {*} value\n   * @return {string}\n   */\n  _commonSetCMIValue(\n      methodName: String, scorm2004: boolean, CMIElement, value) {\n    if (!CMIElement || CMIElement === '') {\n      return global_constants.SCORM_FALSE;\n    }\n\n    const structure = CMIElement.split('.');\n    let refObject = this;\n    let returnValue = global_constants.SCORM_FALSE;\n    let foundFirstIndex = false;\n\n    const invalidErrorMessage = `The data model element passed to ${methodName} (${CMIElement}) is not a valid SCORM data model element.`;\n    const invalidErrorCode = scorm2004 ?\n        this.#error_codes.UNDEFINED_DATA_MODEL :\n        this.#error_codes.GENERAL;\n\n    for (let i = 0; i < structure.length; i++) {\n      const attribute = structure[i];\n\n      if (i === structure.length - 1) {\n        if (scorm2004 && (attribute.substr(0, 8) === '{target=') &&\n            (typeof refObject._isTargetValid == 'function')) {\n          this.throwSCORMError(this.#error_codes.READ_ONLY_ELEMENT);\n        } else if (!this._checkObjectHasProperty(refObject, attribute)) {\n          this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n        } else {\n          if (this.isInitialized() &&\n              this.stringMatches(CMIElement, '\\\\.correct_responses\\\\.\\\\d+')) {\n            this.validateCorrectResponse(CMIElement, value);\n          }\n\n          if (!scorm2004 || this.lastErrorCode === 0) {\n            refObject[attribute] = value;\n            returnValue = global_constants.SCORM_TRUE;\n          }\n        }\n      } else {\n        refObject = refObject[attribute];\n        if (!refObject) {\n          this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n          break;\n        }\n\n        if (refObject instanceof CMIArray) {\n          const index = parseInt(structure[i + 1], 10);\n\n          // SCO is trying to set an item on an array\n          if (!isNaN(index)) {\n            const item = refObject.childArray[index];\n\n            if (item) {\n              refObject = item;\n              foundFirstIndex = true;\n            } else {\n              const newChild = this.getChildElement(CMIElement, value,\n                  foundFirstIndex);\n              foundFirstIndex = true;\n\n              if (!newChild) {\n                this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n              } else {\n                if (refObject.initialized) newChild.initialize();\n\n                refObject.childArray.push(newChild);\n                refObject = newChild;\n              }\n            }\n\n            // Have to update i value to skip the array position\n            i++;\n          }\n        }\n      }\n    }\n\n    if (returnValue === global_constants.SCORM_FALSE) {\n      this.apiLog(methodName, null,\n          `There was an error setting the value for: ${CMIElement}, value of: ${value}`,\n          global_constants.LOG_LEVEL_WARNING);\n    }\n\n    return returnValue;\n  }\n\n  /**\n   * Abstract method for validating that a response is correct.\n   *\n   * @param {string} _CMIElement\n   * @param {*} _value\n   */\n  validateCorrectResponse(_CMIElement, _value) {\n    // just a stub method\n  }\n\n  /**\n   * Gets or builds a new child element to add to the array.\n   * APIs that inherit BaseAPI should override this method.\n   *\n   * @param {string} _CMIElement - unused\n   * @param {*} _value - unused\n   * @param {boolean} _foundFirstIndex - unused\n   * @return {*}\n   * @abstract\n   */\n  getChildElement(_CMIElement, _value, _foundFirstIndex) {\n    throw new Error('The getChildElement method has not been implemented');\n  }\n\n  /**\n   * Gets a value from the CMI Object\n   *\n   * @param {string} methodName\n   * @param {boolean} scorm2004\n   * @param {string} CMIElement\n   * @return {*}\n   */\n  _commonGetCMIValue(methodName: String, scorm2004: boolean, CMIElement) {\n    if (!CMIElement || CMIElement === '') {\n      return '';\n    }\n\n    const structure = CMIElement.split('.');\n    let refObject = this;\n    let attribute = null;\n\n    const uninitializedErrorMessage = `The data model element passed to ${methodName} (${CMIElement}) has not been initialized.`;\n    const invalidErrorMessage = `The data model element passed to ${methodName} (${CMIElement}) is not a valid SCORM data model element.`;\n    const invalidErrorCode = scorm2004 ?\n        this.#error_codes.UNDEFINED_DATA_MODEL :\n        this.#error_codes.GENERAL;\n\n    for (let i = 0; i < structure.length; i++) {\n      attribute = structure[i];\n\n      if (!scorm2004) {\n        if (i === structure.length - 1) {\n          if (!this._checkObjectHasProperty(refObject, attribute)) {\n            this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n            return;\n          }\n        }\n      } else {\n        if ((String(attribute).substr(0, 8) === '{target=') &&\n            (typeof refObject._isTargetValid == 'function')) {\n          const target = String(attribute).\n              substr(8, String(attribute).length - 9);\n          return refObject._isTargetValid(target);\n        } else if (!this._checkObjectHasProperty(refObject, attribute)) {\n          this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n          return;\n        }\n      }\n\n      refObject = refObject[attribute];\n      if (refObject === undefined) {\n        this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n        break;\n      }\n\n      if (refObject instanceof CMIArray) {\n        const index = parseInt(structure[i + 1], 10);\n\n        // SCO is trying to set an item on an array\n        if (!isNaN(index)) {\n          const item = refObject.childArray[index];\n\n          if (item) {\n            refObject = item;\n          } else {\n            this.throwSCORMError(this.#error_codes.VALUE_NOT_INITIALIZED,\n                uninitializedErrorMessage);\n            break;\n          }\n\n          // Have to update i value to skip the array position\n          i++;\n        }\n      }\n    }\n\n    if (refObject === null || refObject === undefined) {\n      if (!scorm2004) {\n        if (attribute === '_children') {\n          this.throwSCORMError(scorm12_error_codes.CHILDREN_ERROR);\n        } else if (attribute === '_count') {\n          this.throwSCORMError(scorm12_error_codes.COUNT_ERROR);\n        }\n      }\n    } else {\n      return refObject;\n    }\n  }\n\n  /**\n   * Returns true if the API's current state is STATE_INITIALIZED\n   *\n   * @return {boolean}\n   */\n  isInitialized() {\n    return this.currentState === global_constants.STATE_INITIALIZED;\n  }\n\n  /**\n   * Returns true if the API's current state is STATE_NOT_INITIALIZED\n   *\n   * @return {boolean}\n   */\n  isNotInitialized() {\n    return this.currentState === global_constants.STATE_NOT_INITIALIZED;\n  }\n\n  /**\n   * Returns true if the API's current state is STATE_TERMINATED\n   *\n   * @return {boolean}\n   */\n  isTerminated() {\n    return this.currentState === global_constants.STATE_TERMINATED;\n  }\n\n  /**\n   * Provides a mechanism for attaching to a specific SCORM event\n   *\n   * @param {string} listenerName\n   * @param {function} callback\n   */\n  on(listenerName: String, callback: function) {\n    if (!callback) return;\n\n    const listenerFunctions = listenerName.split(' ');\n    for (let i = 0; i < listenerFunctions.length; i++) {\n      const listenerSplit = listenerFunctions[i].split('.');\n      if (listenerSplit.length === 0) return;\n\n      const functionName = listenerSplit[0];\n\n      let CMIElement = null;\n      if (listenerSplit.length > 1) {\n        CMIElement = listenerName.replace(functionName + '.', '');\n      }\n\n      this.listenerArray.push({\n        functionName: functionName,\n        CMIElement: CMIElement,\n        callback: callback,\n      });\n\n      this.apiLog('on', functionName, `Added event listener: ${this.listenerArray.length}`, global_constants.LOG_LEVEL_INFO);\n    }\n  }\n\n  /**\n   * Provides a mechanism for detaching a specific SCORM event listener\n   *\n   * @param {string} listenerName\n   * @param {function} callback\n   */\n  off(listenerName: String, callback: function) {\n    if (!callback) return;\n\n    const listenerFunctions = listenerName.split(' ');\n    for (let i = 0; i < listenerFunctions.length; i++) {\n      const listenerSplit = listenerFunctions[i].split('.');\n      if (listenerSplit.length === 0) return;\n\n      const functionName = listenerSplit[0];\n\n      let CMIElement = null;\n      if (listenerSplit.length > 1) {\n        CMIElement = listenerName.replace(functionName + '.', '');\n      }\n\n      const removeIndex = this.listenerArray.findIndex((obj) =>\n        obj.functionName === functionName &&\n        obj.CMIElement === CMIElement &&\n        obj.callback === callback\n      );\n      if (removeIndex !== -1) {\n        this.listenerArray.splice(removeIndex, 1);\n        this.apiLog('off', functionName, `Removed event listener: ${this.listenerArray.length}`, global_constants.LOG_LEVEL_INFO);\n      }\n    }\n  }\n\n  /**\n   * Provides a mechanism for clearing all listeners from a specific SCORM event\n   *\n   * @param {string} listenerName\n   */\n  clear(listenerName: String) {\n    const listenerFunctions = listenerName.split(' ');\n    for (let i = 0; i < listenerFunctions.length; i++) {\n      const listenerSplit = listenerFunctions[i].split('.');\n      if (listenerSplit.length === 0) return;\n\n      const functionName = listenerSplit[0];\n\n      let CMIElement = null;\n      if (listenerSplit.length > 1) {\n        CMIElement = listenerName.replace(functionName + '.', '');\n      }\n\n      this.listenerArray = this.listenerArray.filter((obj) =>\n        obj.functionName !== functionName &&\n        obj.CMIElement !== CMIElement,\n      );\n    }\n  }\n\n  /**\n   * Processes any 'on' listeners that have been created\n   *\n   * @param {string} functionName\n   * @param {string} CMIElement\n   * @param {*} value\n   */\n  processListeners(functionName: String, CMIElement: String, value: any) {\n    this.apiLog(functionName, CMIElement, value);\n    for (let i = 0; i < this.listenerArray.length; i++) {\n      const listener = this.listenerArray[i];\n      const functionsMatch = listener.functionName === functionName;\n      const listenerHasCMIElement = !!listener.CMIElement;\n      let CMIElementsMatch = false;\n      if (CMIElement && listener.CMIElement &&\n          listener.CMIElement.substring(listener.CMIElement.length - 1) ===\n          '*') {\n        CMIElementsMatch = CMIElement.indexOf(listener.CMIElement.substring(0,\n            listener.CMIElement.length - 1)) === 0;\n      } else {\n        CMIElementsMatch = listener.CMIElement === CMIElement;\n      }\n\n      if (functionsMatch && (!listenerHasCMIElement || CMIElementsMatch)) {\n        listener.callback(CMIElement, value);\n      }\n    }\n  }\n\n  /**\n   * Throws a SCORM error\n   *\n   * @param {number} errorNumber\n   * @param {string} message\n   */\n  throwSCORMError(errorNumber: number, message: String) {\n    if (!message) {\n      message = this.getLmsErrorMessageDetails(errorNumber);\n    }\n\n    this.apiLog('throwSCORMError', null, errorNumber + ': ' + message,\n        global_constants.LOG_LEVEL_ERROR);\n\n    this.lastErrorCode = String(errorNumber);\n  }\n\n  /**\n   * Clears the last SCORM error code on success.\n   *\n   * @param {string} success\n   */\n  clearSCORMError(success: String) {\n    if (success !== undefined && success !== global_constants.SCORM_FALSE) {\n      this.lastErrorCode = 0;\n    }\n  }\n\n  /**\n   * Attempts to store the data to the LMS, logs data if no LMS configured\n   * APIs that inherit BaseAPI should override this function\n   *\n   * @param {boolean} _calculateTotalTime\n   * @return {string}\n   * @abstract\n   */\n  storeData(_calculateTotalTime) {\n    throw new Error(\n        'The storeData method has not been implemented');\n  }\n\n  /**\n   * Load the CMI from a flattened JSON object\n   * @param {object} json\n   * @param {string} CMIElement\n   */\n  loadFromFlattenedJSON(json, CMIElement) {\n    if (!this.isNotInitialized()) {\n      console.error(\n          'loadFromFlattenedJSON can only be called before the call to lmsInitialize.');\n      return;\n    }\n\n    /**\n     * Test match pattern.\n     *\n     * @param {string} a\n     * @param {string} c\n     * @param {RegExp} a_pattern\n     * @return {number}\n     */\n    function testPattern(a, c, a_pattern) {\n      const a_match = a.match(a_pattern);\n\n      let c_match;\n      if (a_match !== null && (c_match = c.match(a_pattern)) !== null) {\n        const a_num = Number(a_match[2]);\n        const c_num = Number(c_match[2]);\n        if (a_num === c_num) {\n          if (a_match[3] === 'id') {\n            return -1;\n          } else if (a_match[3] === 'type') {\n            if (c_match[3] === 'id') {\n              return 1;\n            } else {\n              return -1;\n            }\n          } else {\n            return 1;\n          }\n        }\n        return a_num - c_num;\n      }\n\n      return null;\n    }\n\n    const int_pattern = /^(cmi\\.interactions\\.)(\\d+)\\.(.*)$/;\n    const obj_pattern = /^(cmi\\.objectives\\.)(\\d+)\\.(.*)$/;\n\n    const result = Object.keys(json).map(function(key) {\n      return [String(key), json[key]];\n    });\n\n    // CMI interactions need to have id and type loaded before any other fields\n    result.sort(function([a, b], [c, d]) {\n      let test;\n      if ((test = testPattern(a, c, int_pattern)) !== null) {\n        return test;\n      }\n      if ((test = testPattern(a, c, obj_pattern)) !== null) {\n        return test;\n      }\n\n      if (a < c) {\n        return -1;\n      }\n      if (a > c) {\n        return 1;\n      }\n      return 0;\n    });\n\n    let obj;\n    result.forEach((element) => {\n      obj = {};\n      obj[element[0]] = element[1];\n      this.loadFromJSON(unflatten(obj), CMIElement);\n    });\n  }\n\n  /**\n   * Loads CMI data from a JSON object.\n   *\n   * @param {object} json\n   * @param {string} CMIElement\n   */\n  loadFromJSON(json, CMIElement) {\n    if (!this.isNotInitialized()) {\n      console.error(\n          'loadFromJSON can only be called before the call to lmsInitialize.');\n      return;\n    }\n\n    CMIElement = CMIElement !== undefined ? CMIElement : 'cmi';\n\n    this.startingData = json;\n\n    // could this be refactored down to flatten(json) then setCMIValue on each?\n    for (const key in json) {\n      if ({}.hasOwnProperty.call(json, key) && json[key]) {\n        const currentCMIElement = (CMIElement ? CMIElement + '.' : '') + key;\n        const value = json[key];\n\n        if (value['childArray']) {\n          for (let i = 0; i < value['childArray'].length; i++) {\n            this.loadFromJSON(value['childArray'][i],\n                currentCMIElement + '.' + i);\n          }\n        } else if (value.constructor === Object) {\n          this.loadFromJSON(value, currentCMIElement);\n        } else {\n          this.setCMIValue(currentCMIElement, value);\n        }\n      }\n    }\n  }\n\n  /**\n   * Render the CMI object to JSON for sending to an LMS.\n   *\n   * @return {string}\n   */\n  renderCMIToJSONString() {\n    const cmi = this.cmi;\n    // Do we want/need to return fields that have no set value?\n    // return JSON.stringify({ cmi }, (k, v) => v === undefined ? null : v, 2);\n    return JSON.stringify({cmi});\n  }\n\n  /**\n   * Returns a JS object representing the current cmi\n   * @return {object}\n   */\n  renderCMIToJSONObject() {\n    // Do we want/need to return fields that have no set value?\n    // return JSON.stringify({ cmi }, (k, v) => v === undefined ? null : v, 2);\n    return JSON.parse(this.renderCMIToJSONString());\n  }\n\n  /**\n   * Render the cmi object to the proper format for LMS commit\n   * APIs that inherit BaseAPI should override this function\n   *\n   * @param {boolean} _terminateCommit\n   * @return {*}\n   * @abstract\n   */\n  renderCommitCMI(_terminateCommit) {\n    throw new Error(\n        'The storeData method has not been implemented');\n  }\n\n  /**\n   * Send the request to the LMS\n   * @param {string} url\n   * @param {object|Array} params\n   * @param {boolean} immediate\n   * @return {object}\n   */\n  processHttpRequest(url: String, params, immediate = false) {\n    const api = this;\n    const process = function(url, params, settings, error_codes) {\n      const genericError = {\n        'result': global_constants.SCORM_FALSE,\n        'errorCode': error_codes.GENERAL,\n      };\n\n      let result;\n      if (!settings.sendBeaconCommit) {\n        const httpReq = new XMLHttpRequest();\n        httpReq.open('POST', url, settings.asyncCommit);\n        if (settings.asyncCommit) {\n          httpReq.onload = function(e) {\n            if (typeof settings.responseHandler === 'function') {\n              result = settings.responseHandler(httpReq);\n            } else {\n              result = JSON.parse(httpReq.responseText);\n            }\n          };\n        }\n        try {\n          if (params instanceof Array) {\n            httpReq.setRequestHeader('Content-Type',\n                'application/x-www-form-urlencoded');\n            httpReq.send(params.join('&'));\n          } else {\n            httpReq.setRequestHeader('Content-Type',\n                settings.commitRequestDataType);\n            httpReq.send(JSON.stringify(params));\n          }\n\n          if (!settings.asyncCommit) {\n            if (typeof settings.responseHandler === 'function') {\n              result = settings.responseHandler(httpReq);\n            } else {\n              result = JSON.parse(httpReq.responseText);\n            }\n          } else {\n            result = {};\n            result.result = global_constants.SCORM_TRUE;\n            result.errorCode = 0;\n            api.processListeners('CommitSuccess');\n            return result;\n          }\n        } catch (e) {\n          console.error(e);\n          api.processListeners('CommitError');\n          return genericError;\n        }\n      } else {\n        try {\n          const headers = {\n            type: settings.commitRequestDataType,\n          };\n          let blob;\n          if (params instanceof Array) {\n            blob = new Blob([params.join('&')], headers);\n          } else {\n            blob = new Blob([JSON.stringify(params)], headers);\n          }\n\n          result = {};\n          if (navigator.sendBeacon(url, blob)) {\n            result.result = global_constants.SCORM_TRUE;\n            result.errorCode = 0;\n          } else {\n            result.result = global_constants.SCORM_FALSE;\n            result.errorCode = 101;\n          }\n        } catch (e) {\n          console.error(e);\n          api.processListeners('CommitError');\n          return genericError;\n        }\n      }\n\n      if (typeof result === 'undefined') {\n        api.processListeners('CommitError');\n        return genericError;\n      }\n\n      if (result.result === true ||\n          result.result === global_constants.SCORM_TRUE) {\n        api.processListeners('CommitSuccess');\n      } else {\n        api.processListeners('CommitError');\n      }\n\n      return result;\n    };\n\n    if (typeof debounce !== 'undefined') {\n      const debounced = debounce(process, 500);\n      debounced(url, params, this.settings, this.error_codes);\n\n      // if we're terminating, go ahead and commit immediately\n      if (immediate) {\n        debounced.flush();\n      }\n\n      return {\n        result: global_constants.SCORM_TRUE,\n        errorCode: 0,\n      };\n    } else {\n      return process(url, params, this.settings, this.error_codes);\n    }\n  }\n\n  /**\n   * Throws a SCORM error\n   *\n   * @param {number} when - the number of milliseconds to wait before committing\n   * @param {string} callback - the name of the commit event callback\n   */\n  scheduleCommit(when: number, callback: string) {\n    this.#timeout = new ScheduledCommit(this, when, callback);\n    this.apiLog('scheduleCommit', '', 'scheduled',\n        global_constants.LOG_LEVEL_DEBUG);\n  }\n\n  /**\n   * Clears and cancels any currently scheduled commits\n   */\n  clearScheduledCommit() {\n    if (this.#timeout) {\n      this.#timeout.cancel();\n      this.#timeout = null;\n      this.apiLog('clearScheduledCommit', '', 'cleared',\n          global_constants.LOG_LEVEL_DEBUG);\n    }\n  }\n}\n\n/**\n * Private class that wraps a timeout call to the commit() function\n */\nclass ScheduledCommit {\n  #API;\n  #cancelled = false;\n  #timeout;\n  #callback;\n\n  /**\n   * Constructor for ScheduledCommit\n   * @param {BaseAPI} API\n   * @param {number} when\n   * @param {string} callback\n   */\n  constructor(API: any, when: number, callback: string) {\n    this.#API = API;\n    this.#timeout = setTimeout(this.wrapper.bind(this), when);\n    this.#callback = callback;\n  }\n\n  /**\n   * Cancel any currently scheduled commit\n   */\n  cancel() {\n    this.#cancelled = true;\n    if (this.#timeout) {\n      clearTimeout(this.#timeout);\n    }\n  }\n\n  /**\n   * Wrap the API commit call to check if the call has already been cancelled\n   */\n  wrapper() {\n    if (!this.#cancelled) {\n      this.#API.commit(this.#callback);\n    }\n  }\n}\n","// @flow\nimport BaseAPI from './BaseAPI';\nimport {\n  ADL,\n  CMI,\n  CMICommentsObject,\n  CMIInteractionsCorrectResponsesObject,\n  CMIInteractionsObject,\n  CMIInteractionsObjectivesObject,\n  CMIObjectivesObject,\n} from './cmi/scorm2004_cmi';\nimport * as Utilities from './utilities';\nimport APIConstants from './constants/api_constants';\nimport ErrorCodes from './constants/error_codes';\nimport Responses from './constants/response_constants';\nimport ValidLanguages from './constants/language_constants';\nimport Regex from './constants/regex';\n\nconst scorm2004_constants = APIConstants.scorm2004;\nconst global_constants = APIConstants.global;\nconst scorm2004_error_codes = ErrorCodes.scorm2004;\nconst correct_responses = Responses.correct;\nconst scorm2004_regex = Regex.scorm2004;\n\n/**\n * API class for SCORM 2004\n */\nexport default class Scorm2004API extends BaseAPI {\n  #version: '1.0';\n\n  /**\n   * Constructor for SCORM 2004 API\n   * @param {object} settings\n   */\n  constructor(settings: {}) {\n    const finalSettings = {\n      ...{\n        mastery_override: false,\n      }, ...settings,\n    };\n\n    super(scorm2004_error_codes, finalSettings);\n\n    this.cmi = new CMI();\n    this.adl = new ADL();\n\n    // Rename functions to match 2004 Spec and expose to modules\n    this.Initialize = this.lmsInitialize;\n    this.Terminate = this.lmsTerminate;\n    this.GetValue = this.lmsGetValue;\n    this.SetValue = this.lmsSetValue;\n    this.Commit = this.lmsCommit;\n    this.GetLastError = this.lmsGetLastError;\n    this.GetErrorString = this.lmsGetErrorString;\n    this.GetDiagnostic = this.lmsGetDiagnostic;\n  }\n\n  /**\n   * Getter for #version\n   * @return {string}\n   */\n  get version() {\n    return this.#version;\n  }\n\n  /**\n   * @return {string} bool\n   */\n  lmsInitialize() {\n    this.cmi.initialize();\n    return this.initialize('Initialize');\n  }\n\n  /**\n   * @return {string} bool\n   */\n  lmsTerminate() {\n    const result = this.terminate('Terminate', true);\n\n    if (result === global_constants.SCORM_TRUE) {\n      if (this.adl.nav.request !== '_none_') {\n        switch (this.adl.nav.request) {\n          case 'continue':\n            this.processListeners('SequenceNext');\n            break;\n          case 'previous':\n            this.processListeners('SequencePrevious');\n            break;\n          case 'choice':\n            this.processListeners('SequenceChoice');\n            break;\n          case 'exit':\n            this.processListeners('SequenceExit');\n            break;\n          case 'exitAll':\n            this.processListeners('SequenceExitAll');\n            break;\n          case 'abandon':\n            this.processListeners('SequenceAbandon');\n            break;\n          case 'abandonAll':\n            this.processListeners('SequenceAbandonAll');\n            break;\n        }\n      } else if (this.settings.autoProgress) {\n        this.processListeners('SequenceNext');\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * @param {string} CMIElement\n   * @return {string}\n   */\n  lmsGetValue(CMIElement) {\n    return this.getValue('GetValue', true, CMIElement);\n  }\n\n  /**\n   * @param {string} CMIElement\n   * @param {any} value\n   * @return {string}\n   */\n  lmsSetValue(CMIElement, value) {\n    return this.setValue('SetValue', 'Commit', true, CMIElement, value);\n  }\n\n  /**\n   * Orders LMS to store all content parameters\n   *\n   * @return {string} bool\n   */\n  lmsCommit() {\n    return this.commit('Commit');\n  }\n\n  /**\n   * Returns last error code\n   *\n   * @return {string}\n   */\n  lmsGetLastError() {\n    return this.getLastError('GetLastError');\n  }\n\n  /**\n   * Returns the errorNumber error description\n   *\n   * @param {(string|number)} CMIErrorCode\n   * @return {string}\n   */\n  lmsGetErrorString(CMIErrorCode) {\n    return this.getErrorString('GetErrorString', CMIErrorCode);\n  }\n\n  /**\n   * Returns a comprehensive description of the errorNumber error.\n   *\n   * @param {(string|number)} CMIErrorCode\n   * @return {string}\n   */\n  lmsGetDiagnostic(CMIErrorCode) {\n    return this.getDiagnostic('GetDiagnostic', CMIErrorCode);\n  }\n\n  /**\n   * Sets a value on the CMI Object\n   *\n   * @param {string} CMIElement\n   * @param {any} value\n   * @return {string}\n   */\n  setCMIValue(CMIElement, value) {\n    return this._commonSetCMIValue('SetValue', true, CMIElement, value);\n  }\n\n  /**\n   * Gets or builds a new child element to add to the array.\n   *\n   * @param {string} CMIElement\n   * @param {any} value\n   * @param {boolean} foundFirstIndex\n   * @return {any}\n   */\n  getChildElement(CMIElement, value, foundFirstIndex) {\n    let newChild;\n\n    if (this.stringMatches(CMIElement, 'cmi\\\\.objectives\\\\.\\\\d+')) {\n      newChild = new CMIObjectivesObject();\n    } else if (foundFirstIndex && this.stringMatches(CMIElement,\n        'cmi\\\\.interactions\\\\.\\\\d+\\\\.correct_responses\\\\.\\\\d+')) {\n      const parts = CMIElement.split('.');\n      const index = Number(parts[2]);\n      const interaction = this.cmi.interactions.childArray[index];\n      if (this.isInitialized()) {\n        if (!interaction.type) {\n          this.throwSCORMError(\n              scorm2004_error_codes.DEPENDENCY_NOT_ESTABLISHED);\n        } else {\n          this.checkDuplicateChoiceResponse(interaction, value);\n\n          const response_type = correct_responses[interaction.type];\n          if (response_type) {\n            this.checkValidResponseType(response_type, value, interaction.type);\n          } else {\n            this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE,\n                'Incorrect Response Type: ' + interaction.type);\n          }\n        }\n      }\n      if (this.lastErrorCode === 0) {\n        newChild = new CMIInteractionsCorrectResponsesObject();\n      }\n    } else if (foundFirstIndex && this.stringMatches(CMIElement,\n        'cmi\\\\.interactions\\\\.\\\\d+\\\\.objectives\\\\.\\\\d+')) {\n      newChild = new CMIInteractionsObjectivesObject();\n    } else if (!foundFirstIndex &&\n        this.stringMatches(CMIElement, 'cmi\\\\.interactions\\\\.\\\\d+')) {\n      newChild = new CMIInteractionsObject();\n    } else if (this.stringMatches(CMIElement,\n        'cmi\\\\.comments_from_learner\\\\.\\\\d+')) {\n      newChild = new CMICommentsObject();\n    } else if (this.stringMatches(CMIElement,\n        'cmi\\\\.comments_from_lms\\\\.\\\\d+')) {\n      newChild = new CMICommentsObject(true);\n    }\n\n    return newChild;\n  }\n\n  /**\n   * Checks for valid response types\n   * @param {object} response_type\n   * @param {any} value\n   * @param {string} interaction_type\n   */\n  checkValidResponseType(response_type, value, interaction_type) {\n    let nodes = [];\n    if (response_type?.delimiter) {\n      nodes = String(value).split(response_type.delimiter);\n    } else {\n      nodes[0] = value;\n    }\n\n    if (nodes.length > 0 && nodes.length <= response_type.max) {\n      this.checkCorrectResponseValue(interaction_type, nodes, value);\n    } else if (nodes.length > response_type.max) {\n      this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE,\n          'Data Model Element Pattern Too Long');\n    }\n  }\n\n  /**\n   * Checks for duplicate 'choice' responses.\n   * @param {CMIInteractionsObject} interaction\n   * @param {any} value\n   */\n  checkDuplicateChoiceResponse(interaction, value) {\n    const interaction_count = interaction.correct_responses._count;\n    if (interaction.type === 'choice') {\n      for (let i = 0; i < interaction_count && this.lastErrorCode ===\n      0; i++) {\n        const response = interaction.correct_responses.childArray[i];\n        if (response.pattern === value) {\n          this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE);\n        }\n      }\n    }\n  }\n\n  /**\n   * Validate correct response.\n   * @param {string} CMIElement\n   * @param {*} value\n   */\n  validateCorrectResponse(CMIElement, value) {\n    const parts = CMIElement.split('.');\n    const index = Number(parts[2]);\n    const pattern_index = Number(parts[4]);\n    const interaction = this.cmi.interactions.childArray[index];\n\n    const interaction_count = interaction.correct_responses._count;\n    this.checkDuplicateChoiceResponse(interaction, value);\n\n    const response_type = correct_responses[interaction.type];\n    if (typeof response_type.limit === 'undefined' || interaction_count <=\n        response_type.limit) {\n      this.checkValidResponseType(response_type, value, interaction.type);\n\n      if (this.lastErrorCode === 0 &&\n          (!response_type.duplicate ||\n              !this.checkDuplicatedPattern(interaction.correct_responses,\n                  pattern_index, value)) ||\n          (this.lastErrorCode === 0 && value === '')) {\n        // do nothing, we want the inverse\n      } else {\n        if (this.lastErrorCode === 0) {\n          this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE,\n              'Data Model Element Pattern Already Exists');\n        }\n      }\n    } else {\n      this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE,\n          'Data Model Element Collection Limit Reached');\n    }\n  }\n\n  /**\n   * Gets a value from the CMI Object\n   *\n   * @param {string} CMIElement\n   * @return {*}\n   */\n  getCMIValue(CMIElement) {\n    return this._commonGetCMIValue('GetValue', true, CMIElement);\n  }\n\n  /**\n   * Returns the message that corresponds to errorNumber.\n   *\n   * @param {(string|number)} errorNumber\n   * @param {boolean} detail\n   * @return {string}\n   */\n  getLmsErrorMessageDetails(errorNumber, detail) {\n    let basicMessage = '';\n    let detailMessage = '';\n\n    // Set error number to string since inconsistent from modules if string or number\n    errorNumber = String(errorNumber);\n    if (scorm2004_constants.error_descriptions[errorNumber]) {\n      basicMessage = scorm2004_constants.error_descriptions[errorNumber].basicMessage;\n      detailMessage = scorm2004_constants.error_descriptions[errorNumber].detailMessage;\n    }\n\n    return detail ? detailMessage : basicMessage;\n  }\n\n  /**\n   * Check to see if a correct_response value has been duplicated\n   * @param {CMIArray} correct_response\n   * @param {number} current_index\n   * @param {*} value\n   * @return {boolean}\n   */\n  checkDuplicatedPattern = (correct_response, current_index, value) => {\n    let found = false;\n    const count = correct_response._count;\n    for (let i = 0; i < count && !found; i++) {\n      if (i !== current_index && correct_response.childArray[i] === value) {\n        found = true;\n      }\n    }\n    return found;\n  };\n\n  /**\n   * Checks for a valid correct_response value\n   * @param {string} interaction_type\n   * @param {Array} nodes\n   * @param {*} value\n   */\n  checkCorrectResponseValue(interaction_type, nodes, value) {\n    const response = correct_responses[interaction_type];\n    const formatRegex = new RegExp(response.format);\n    for (let i = 0; i < nodes.length && this.lastErrorCode === 0; i++) {\n      if (interaction_type.match(\n          '^(fill-in|long-fill-in|matching|performance|sequencing)$')) {\n        nodes[i] = this.removeCorrectResponsePrefixes(nodes[i]);\n      }\n\n      if (response?.delimiter2) {\n        const values = nodes[i].split(response.delimiter2);\n        if (values.length === 2) {\n          const matches = values[0].match(formatRegex);\n          if (!matches) {\n            this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n          } else {\n            if (!values[1].match(new RegExp(response.format2))) {\n              this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n            }\n          }\n        } else {\n          this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n        }\n      } else {\n        const matches = nodes[i].match(formatRegex);\n        if ((!matches && value !== '') ||\n            (!matches && interaction_type === 'true-false')) {\n          this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n        } else {\n          if (interaction_type === 'numeric' && nodes.length > 1) {\n            if (Number(nodes[0]) > Number(nodes[1])) {\n              this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n            }\n          } else {\n            if (nodes[i] !== '' && response.unique) {\n              for (let j = 0; j < i && this.lastErrorCode === 0; j++) {\n                if (nodes[i] === nodes[j]) {\n                  this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n                }\n              }\n            }\n          }\n        }\n      }\n    }\n  }\n\n  /**\n   * Remove prefixes from correct_response\n   * @param {string} node\n   * @return {*}\n   */\n  removeCorrectResponsePrefixes(node) {\n    let seenOrder = false;\n    let seenCase = false;\n    let seenLang = false;\n\n    const prefixRegex = new RegExp(\n        '^({(lang|case_matters|order_matters)=([^}]+)})');\n    let matches = node.match(prefixRegex);\n    let langMatches = null;\n    while (matches) {\n      switch (matches[2]) {\n        case 'lang':\n          langMatches = node.match(scorm2004_regex.CMILangcr);\n          if (langMatches) {\n            const lang = langMatches[3];\n            if (lang !== undefined && lang.length > 0) {\n              if (ValidLanguages[lang.toLowerCase()] === undefined) {\n                this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n              }\n            }\n          }\n          seenLang = true;\n          break;\n        case 'case_matters':\n          if (!seenLang && !seenOrder && !seenCase) {\n            if (matches[3] !== 'true' && matches[3] !== 'false') {\n              this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n            }\n          }\n\n          seenCase = true;\n          break;\n        case 'order_matters':\n          if (!seenCase && !seenLang && !seenOrder) {\n            if (matches[3] !== 'true' && matches[3] !== 'false') {\n              this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH);\n            }\n          }\n\n          seenOrder = true;\n          break;\n        default:\n          break;\n      }\n      node = node.substr(matches[1].length);\n      matches = node.match(prefixRegex);\n    }\n\n    return node;\n  }\n\n  /**\n   * Replace the whole API with another\n   * @param {Scorm2004API} newAPI\n   */\n  replaceWithAnotherScormAPI(newAPI) {\n    // Data Model\n    this.cmi = newAPI.cmi;\n    this.adl = newAPI.adl;\n  }\n\n  /**\n   * Render the cmi object to the proper format for LMS commit\n   *\n   * @param {boolean} terminateCommit\n   * @return {object|Array}\n   */\n  renderCommitCMI(terminateCommit: boolean) {\n    const cmiExport = this.renderCMIToJSONObject();\n\n    if (terminateCommit) {\n      cmiExport.cmi.total_time = this.cmi.getCurrentTotalTime();\n    }\n\n    const result = [];\n    const flattened = Utilities.flatten(cmiExport);\n    switch (this.settings.dataCommitFormat) {\n      case 'flattened':\n        return Utilities.flatten(cmiExport);\n      case 'params':\n        for (const item in flattened) {\n          if ({}.hasOwnProperty.call(flattened, item)) {\n            result.push(`${item}=${flattened[item]}`);\n          }\n        }\n        return result;\n      case 'json':\n      default:\n        return cmiExport;\n    }\n  }\n\n  /**\n   * Attempts to store the data to the LMS\n   *\n   * @param {boolean} terminateCommit\n   * @return {string}\n   */\n  storeData(terminateCommit: boolean) {\n    if (terminateCommit) {\n      if (this.cmi.mode === 'normal') {\n        if (this.cmi.credit === 'credit') {\n          if (this.cmi.completion_threshold && this.cmi.progress_measure) {\n            if (this.cmi.progress_measure >= this.cmi.completion_threshold) {\n              console.debug('Setting Completion Status: Completed');\n              this.cmi.completion_status = 'completed';\n            } else {\n              console.debug('Setting Completion Status: Incomplete');\n              this.cmi.completion_status = 'incomplete';\n            }\n          }\n          if (this.cmi.scaled_passing_score && this.cmi.score.scaled) {\n            if (this.cmi.score.scaled >= this.cmi.scaled_passing_score) {\n              console.debug('Setting Success Status: Passed');\n              this.cmi.success_status = 'passed';\n            } else {\n              console.debug('Setting Success Status: Failed');\n              this.cmi.success_status = 'failed';\n            }\n          }\n        }\n      }\n    }\n\n    let navRequest = false;\n    if (this.adl.nav.request !== (this.startingData?.adl?.nav?.request) &&\n        this.adl.nav.request !== '_none_') {\n      this.adl.nav.request = encodeURIComponent(this.adl.nav.request);\n      navRequest = true;\n    }\n\n    const commitObject = this.renderCommitCMI(terminateCommit ||\n        this.settings.alwaysSendTotalTime);\n\n    if (this.apiLogLevel === global_constants.LOG_LEVEL_DEBUG) {\n      console.debug('Commit (terminated: ' +\n            (terminateCommit ? 'yes' : 'no') + '): ');\n      console.debug(commitObject);\n    }\n    if (this.settings.lmsCommitUrl) {\n      const result = this.processHttpRequest(this.settings.lmsCommitUrl,\n          commitObject, terminateCommit);\n\n      // check if this is a sequencing call, and then call the necessary JS\n      {\n        if (navRequest && result.navRequest !== undefined &&\n            result.navRequest !== '') {\n          Function(`\"use strict\";(() => { ${result.navRequest} })()`)();\n        }\n      }\n      return result;\n    } else {\n      return global_constants.SCORM_TRUE;\n    }\n  }\n}\n","// @flow\nimport APIConstants from '../constants/api_constants';\nimport ErrorCodes from '../constants/error_codes';\nimport Regex from '../constants/regex';\n\nconst scorm12_constants = APIConstants.scorm12;\nconst scorm12_regex = Regex.scorm12;\nconst scorm12_error_codes = ErrorCodes.scorm12;\n\n/**\n * Check if the value matches the proper format. If not, throw proper error code.\n *\n * @param {string} value\n * @param {string} regexPattern\n * @param {number} errorCode\n * @param {class} errorClass\n * @param {boolean} allowEmptyString\n * @return {boolean}\n */\nexport function checkValidFormat(\n    value: String,\n    regexPattern: String,\n    errorCode: number,\n    errorClass: function,\n    allowEmptyString?: boolean) {\n  const formatRegex = new RegExp(regexPattern);\n  const matches = value.match(formatRegex);\n  if (allowEmptyString && value === '') {\n    return true;\n  }\n  if (value === undefined || !matches || matches[0] === '') {\n    throw new errorClass.prototype.constructor(errorCode);\n  }\n  return true;\n}\n\n/**\n * Check if the value matches the proper range. If not, throw proper error code.\n *\n * @param {*} value\n * @param {string} rangePattern\n * @param {number} errorCode\n * @param {class} errorClass\n * @return {boolean}\n */\nexport function checkValidRange(\n    value: any,\n    rangePattern: String,\n    errorCode: number,\n    errorClass: function) {\n  const ranges = rangePattern.split('#');\n  value = value * 1.0;\n  if (value >= ranges[0]) {\n    if ((ranges[1] === '*') || (value <= ranges[1])) {\n      return true;\n    } else {\n      throw new errorClass.prototype.constructor(errorCode);\n    }\n  } else {\n    throw new errorClass.prototype.constructor(errorCode);\n  }\n}\n\n/**\n * Base class for API cmi objects\n */\nexport class BaseCMI {\n  jsonString = false;\n  #initialized = false;\n  #start_time;\n\n  /**\n   * Constructor for BaseCMI, just marks the class as abstract\n   */\n  constructor() {\n    if (new.target === BaseCMI) {\n      throw new TypeError('Cannot construct BaseCMI instances directly');\n    }\n  }\n\n  /**\n   * Getter for #initialized\n   * @return {boolean}\n   */\n  get initialized() {\n    return this.#initialized;\n  }\n\n  /**\n   * Getter for #start_time\n   * @return {Number}\n   */\n  get start_time() {\n    return this.#start_time;\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    this.#initialized = true;\n  }\n\n  /**\n   * Called when the player should override the 'session_time' provided by\n   * the module\n   */\n  setStartTime() {\n    this.#start_time = new Date().getTime();\n  }\n}\n\n/**\n * Base class for cmi *.score objects\n */\nexport class CMIScore extends BaseCMI {\n  /**\n   * Constructor for *.score\n   * @param {string} score_children\n   * @param {string} score_range\n   * @param {string} max\n   * @param {number} invalidErrorCode\n   * @param {number} invalidTypeCode\n   * @param {number} invalidRangeCode\n   * @param {string} decimalRegex\n   * @param {class} errorClass\n   */\n  constructor(\n      {\n        score_children,\n        score_range,\n        max,\n        invalidErrorCode,\n        invalidTypeCode,\n        invalidRangeCode,\n        decimalRegex,\n        errorClass,\n      }) {\n    super();\n\n    this.#_children = score_children ||\n        scorm12_constants.score_children;\n    this.#_score_range = !score_range ? false : scorm12_regex.score_range;\n    this.#max = (max || max === '') ? max : '100';\n    this.#_invalid_error_code = invalidErrorCode ||\n        scorm12_error_codes.INVALID_SET_VALUE;\n    this.#_invalid_type_code = invalidTypeCode ||\n        scorm12_error_codes.TYPE_MISMATCH;\n    this.#_invalid_range_code = invalidRangeCode ||\n        scorm12_error_codes.VALUE_OUT_OF_RANGE;\n    this.#_decimal_regex = decimalRegex ||\n        scorm12_regex.CMIDecimal;\n    this.#_error_class = errorClass;\n  }\n\n  #_children;\n  #_score_range;\n  #_invalid_error_code;\n  #_invalid_type_code;\n  #_invalid_range_code;\n  #_decimal_regex;\n  #_error_class;\n  #raw = '';\n  #min = '';\n  #max;\n\n  /**\n   * Getter for _children\n   * @return {string}\n   * @private\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for _children. Just throws an error.\n   * @param {string} _children\n   * @private\n   */\n  set _children(_children) {\n    throw new this.#_error_class.prototype.constructor(this.#_invalid_error_code);\n  }\n\n  /**\n   * Getter for #raw\n   * @return {string}\n   */\n  get raw() {\n    return this.#raw;\n  }\n\n  /**\n   * Setter for #raw\n   * @param {string} raw\n   */\n  set raw(raw) {\n    if (checkValidFormat(raw, this.#_decimal_regex, this.#_invalid_type_code, this.#_error_class) &&\n        (!this.#_score_range ||\n            checkValidRange(raw, this.#_score_range, this.#_invalid_range_code, this.#_error_class))) {\n      this.#raw = raw;\n    }\n  }\n\n  /**\n   * Getter for #min\n   * @return {string}\n   */\n  get min() {\n    return this.#min;\n  }\n\n  /**\n   * Setter for #min\n   * @param {string} min\n   */\n  set min(min) {\n    if (checkValidFormat(min, this.#_decimal_regex, this.#_invalid_type_code, this.#_error_class) &&\n        (!this.#_score_range ||\n            checkValidRange(min, this.#_score_range, this.#_invalid_range_code, this.#_error_class))) {\n      this.#min = min;\n    }\n  }\n\n  /**\n   * Getter for #max\n   * @return {string}\n   */\n  get max() {\n    return this.#max;\n  }\n\n  /**\n   * Setter for #max\n   * @param {string} max\n   */\n  set max(max) {\n    if (checkValidFormat(max, this.#_decimal_regex, this.#_invalid_type_code, this.#_error_class) &&\n        (!this.#_score_range ||\n            checkValidRange(max, this.#_score_range, this.#_invalid_range_code, this.#_error_class))) {\n      this.#max = max;\n    }\n  }\n\n  /**\n   * toJSON for *.score\n   * @return {{min: string, max: string, raw: string}}\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'raw': this.raw,\n      'min': this.min,\n      'max': this.max,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Base class for cmi *.n objects\n */\nexport class CMIArray extends BaseCMI {\n  /**\n   * Constructor cmi *.n arrays\n   * @param {string} children\n   * @param {number} errorCode\n   * @param {class} errorClass\n   */\n  constructor({children, errorCode, errorClass}) {\n    super();\n    this.#_children = children;\n    this.#errorCode = errorCode;\n    this.#errorClass = errorClass;\n    this.childArray = [];\n  }\n\n  #errorCode;\n  #errorClass;\n  #_children;\n\n  /**\n   * Getter for _children\n   * @return {*}\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for _children. Just throws an error.\n   * @param {string} _children\n   */\n  set _children(_children) {\n    throw new this.#errorClass.prototype.constructor(this.#errorCode);\n  }\n\n  /**\n   * Getter for _count\n   * @return {number}\n   */\n  get _count() {\n    return this.childArray.length;\n  }\n\n  /**\n   * Setter for _count. Just throws an error.\n   * @param {number} _count\n   */\n  set _count(_count) {\n    throw new this.#errorClass.prototype.constructor(this.#errorCode);\n  }\n\n  /**\n   * toJSON for *.n arrays\n   * @return {object}\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {};\n    for (let i = 0; i < this.childArray.length; i++) {\n      result[i + ''] = this.childArray[i];\n    }\n    delete this.jsonString;\n    return result;\n  }\n}\n","// @flow\nimport {\n  BaseCMI,\n  checkValidFormat,\n  checkValidRange,\n  CMIArray,\n  CMIScore,\n} from './common';\nimport APIConstants from '../constants/api_constants';\nimport Regex from '../constants/regex';\nimport ErrorCodes from '../constants/error_codes';\nimport Responses from '../constants/response_constants';\nimport {Scorm2004ValidationError} from '../exceptions';\nimport * as Util from '../utilities';\n\nconst scorm2004_constants = APIConstants.scorm2004;\nconst scorm2004_error_codes = ErrorCodes.scorm2004;\nconst learner_responses = Responses.learner;\n\nconst scorm2004_regex = Regex.scorm2004;\n\n/**\n * Helper method for throwing Read Only error\n */\nfunction throwReadOnlyError() {\n  throw new Scorm2004ValidationError(scorm2004_error_codes.READ_ONLY_ELEMENT);\n}\n\n/**\n * Helper method for throwing Write Only error\n */\nfunction throwWriteOnlyError() {\n  throw new Scorm2004ValidationError(scorm2004_error_codes.WRITE_ONLY_ELEMENT);\n}\n\n/**\n * Helper method for throwing Type Mismatch error\n */\nfunction throwTypeMismatchError() {\n  throw new Scorm2004ValidationError(scorm2004_error_codes.TYPE_MISMATCH);\n}\n\n/**\n * Helper method for throwing Dependency Not Established error\n */\nfunction throwDependencyNotEstablishedError() {\n  throw new Scorm2004ValidationError(scorm2004_error_codes.DEPENDENCY_NOT_ESTABLISHED);\n}\n\n/**\n * Helper method for throwing Dependency Not Established error\n */\nfunction throwGeneralSetError() {\n  throw new Scorm2004ValidationError(scorm2004_error_codes.GENERAL_SET_FAILURE);\n}\n\n/**\n * Helper method, no reason to have to pass the same error codes every time\n * @param {*} value\n * @param {string} regexPattern\n * @param {boolean} allowEmptyString\n * @return {boolean}\n */\nfunction check2004ValidFormat(\n    value: String,\n    regexPattern: String,\n    allowEmptyString?: boolean) {\n  return checkValidFormat(\n      value,\n      regexPattern,\n      scorm2004_error_codes.TYPE_MISMATCH,\n      Scorm2004ValidationError,\n      allowEmptyString,\n  );\n}\n\n/**\n * Helper method, no reason to have to pass the same error codes every time\n * @param {*} value\n * @param {string} rangePattern\n * @return {boolean}\n */\nfunction check2004ValidRange(value: any, rangePattern: String) {\n  return checkValidRange(\n      value,\n      rangePattern,\n      scorm2004_error_codes.VALUE_OUT_OF_RANGE,\n      Scorm2004ValidationError,\n  );\n}\n\n/**\n * Class representing cmi object for SCORM 2004\n */\nexport class CMI extends BaseCMI {\n  /**\n   * Constructor for the SCORM 2004 cmi object\n   * @param {boolean} initialized\n   */\n  constructor(initialized: boolean) {\n    super();\n\n    this.learner_preference = new CMILearnerPreference();\n    this.score = new Scorm2004CMIScore();\n    this.comments_from_learner = new CMICommentsFromLearner();\n    this.comments_from_lms = new CMICommentsFromLMS();\n    this.interactions = new CMIInteractions();\n    this.objectives = new CMIObjectives();\n\n    if (initialized) this.initialize();\n  }\n\n  #_version = '1.0';\n  #_children = scorm2004_constants.cmi_children;\n  #completion_status = 'unknown';\n  #completion_threshold = '';\n  #credit = 'credit';\n  #entry = '';\n  #exit = '';\n  #launch_data = '';\n  #learner_id = '';\n  #learner_name = '';\n  #location = '';\n  #max_time_allowed = '';\n  #mode = 'normal';\n  #progress_measure = '';\n  #scaled_passing_score = '';\n  #session_time = 'PT0H0M0S';\n  #success_status = 'unknown';\n  #suspend_data = '';\n  #time_limit_action = 'continue,no message';\n  #total_time = '';\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.learner_preference?.initialize();\n    this.score?.initialize();\n    this.comments_from_learner?.initialize();\n    this.comments_from_lms?.initialize();\n    this.interactions?.initialize();\n    this.objectives?.initialize();\n  }\n\n  /**\n   * Getter for #_version\n   * @return {string}\n   * @private\n   */\n  get _version() {\n    return this.#_version;\n  }\n\n  /**\n   * Setter for #_version. Just throws an error.\n   * @param {string} _version\n   * @private\n   */\n  set _version(_version) {\n    throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #_children\n   * @return {string}\n   * @private\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for #_children. Just throws an error.\n   * @param {number} _children\n   * @private\n   */\n  set _children(_children) {\n    throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #completion_status\n   * @return {string}\n   */\n  get completion_status() {\n    return this.#completion_status;\n  }\n\n  /**\n   * Setter for #completion_status\n   * @param {string} completion_status\n   */\n  set completion_status(completion_status) {\n    if (check2004ValidFormat(completion_status, scorm2004_regex.CMICStatus)) {\n      this.#completion_status = completion_status;\n    }\n  }\n\n  /**\n   * Getter for #completion_threshold\n   * @return {string}\n   */\n  get completion_threshold() {\n    return this.#completion_threshold;\n  }\n\n  /**\n   * Setter for #completion_threshold. Can only be called before  initialization.\n   * @param {string} completion_threshold\n   */\n  set completion_threshold(completion_threshold) {\n    !this.initialized ?\n      this.#completion_threshold = completion_threshold :\n      throwReadOnlyError();\n  }\n\n  /**\n   * Setter for #credit\n   * @return {string}\n   */\n  get credit() {\n    return this.#credit;\n  }\n\n  /**\n   * Setter for #credit. Can only be called before  initialization.\n   * @param {string} credit\n   */\n  set credit(credit) {\n    !this.initialized ? this.#credit = credit : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #entry\n   * @return {string}\n   */\n  get entry() {\n    return this.#entry;\n  }\n\n  /**\n   * Setter for #entry. Can only be called before  initialization.\n   * @param {string} entry\n   */\n  set entry(entry) {\n    !this.initialized ? this.#entry = entry : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #exit. Should only be called during JSON export.\n   * @return {string}\n   */\n  get exit() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#exit;\n  }\n\n  /**\n   * Getter for #exit\n   * @param {string} exit\n   */\n  set exit(exit) {\n    if (check2004ValidFormat(exit, scorm2004_regex.CMIExit, true)) {\n      this.#exit = exit;\n    }\n  }\n\n  /**\n   * Getter for #launch_data\n   * @return {string}\n   */\n  get launch_data() {\n    return this.#launch_data;\n  }\n\n  /**\n   * Setter for #launch_data. Can only be called before  initialization.\n   * @param {string} launch_data\n   */\n  set launch_data(launch_data) {\n    !this.initialized ? this.#launch_data = launch_data : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #learner_id\n   * @return {string}\n   */\n  get learner_id() {\n    return this.#learner_id;\n  }\n\n  /**\n   * Setter for #learner_id. Can only be called before  initialization.\n   * @param {string} learner_id\n   */\n  set learner_id(learner_id) {\n    !this.initialized ? this.#learner_id = learner_id : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #learner_name\n   * @return {string}\n   */\n  get learner_name() {\n    return this.#learner_name;\n  }\n\n  /**\n   * Setter for #learner_name. Can only be called before  initialization.\n   * @param {string} learner_name\n   */\n  set learner_name(learner_name) {\n    !this.initialized ?\n      this.#learner_name = learner_name :\n      throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #location\n   * @return {string}\n   */\n  get location() {\n    return this.#location;\n  }\n\n  /**\n   * Setter for #location\n   * @param {string} location\n   */\n  set location(location) {\n    if (check2004ValidFormat(location, scorm2004_regex.CMIString1000)) {\n      this.#location = location;\n    }\n  }\n\n  /**\n   * Getter for #max_time_allowed\n   * @return {string}\n   */\n  get max_time_allowed() {\n    return this.#max_time_allowed;\n  }\n\n  /**\n   * Setter for #max_time_allowed. Can only be called before  initialization.\n   * @param {string} max_time_allowed\n   */\n  set max_time_allowed(max_time_allowed) {\n    !this.initialized ?\n      this.#max_time_allowed = max_time_allowed :\n      throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #mode\n   * @return {string}\n   */\n  get mode() {\n    return this.#mode;\n  }\n\n  /**\n   * Setter for #mode. Can only be called before  initialization.\n   * @param {string} mode\n   */\n  set mode(mode) {\n    !this.initialized ? this.#mode = mode : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #progress_measure\n   * @return {string}\n   */\n  get progress_measure() {\n    return this.#progress_measure;\n  }\n\n  /**\n   * Setter for #progress_measure\n   * @param {string} progress_measure\n   */\n  set progress_measure(progress_measure) {\n    if (check2004ValidFormat(progress_measure, scorm2004_regex.CMIDecimal) &&\n      check2004ValidRange(progress_measure, scorm2004_regex.progress_range)) {\n      this.#progress_measure = progress_measure;\n    }\n  }\n\n  /**\n   * Getter for #scaled_passing_score\n   * @return {string}\n   */\n  get scaled_passing_score() {\n    return this.#scaled_passing_score;\n  }\n\n  /**\n   * Setter for #scaled_passing_score. Can only be called before  initialization.\n   * @param {string} scaled_passing_score\n   */\n  set scaled_passing_score(scaled_passing_score) {\n    !this.initialized ?\n      this.#scaled_passing_score = scaled_passing_score :\n      throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #session_time. Should only be called during JSON export.\n   * @return {string}\n   */\n  get session_time() {\n    return (!this.jsonString) ? throwWriteOnlyError() : this.#session_time;\n  }\n\n  /**\n   * Setter for #session_time\n   * @param {string} session_time\n   */\n  set session_time(session_time) {\n    if (check2004ValidFormat(session_time, scorm2004_regex.CMITimespan)) {\n      this.#session_time = session_time;\n    }\n  }\n\n  /**\n   * Getter for #success_status\n   * @return {string}\n   */\n  get success_status() {\n    return this.#success_status;\n  }\n\n  /**\n   * Setter for #success_status\n   * @param {string} success_status\n   */\n  set success_status(success_status) {\n    if (check2004ValidFormat(success_status, scorm2004_regex.CMISStatus)) {\n      this.#success_status = success_status;\n    }\n  }\n\n  /**\n   * Getter for #suspend_data\n   * @return {string}\n   */\n  get suspend_data() {\n    return this.#suspend_data;\n  }\n\n  /**\n   * Setter for #suspend_data\n   * @param {string} suspend_data\n   */\n  set suspend_data(suspend_data) {\n    if (check2004ValidFormat(suspend_data, scorm2004_regex.CMIString64000,\n        true)) {\n      this.#suspend_data = suspend_data;\n    }\n  }\n\n  /**\n   * Getter for #time_limit_action\n   * @return {string}\n   */\n  get time_limit_action() {\n    return this.#time_limit_action;\n  }\n\n  /**\n   * Setter for #time_limit_action. Can only be called before  initialization.\n   * @param {string} time_limit_action\n   */\n  set time_limit_action(time_limit_action) {\n    !this.initialized ?\n      this.#time_limit_action = time_limit_action :\n      throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #total_time\n   * @return {string}\n   */\n  get total_time() {\n    return this.#total_time;\n  }\n\n  /**\n   * Setter for #total_time. Can only be called before  initialization.\n   * @param {string} total_time\n   */\n  set total_time(total_time) {\n    !this.initialized ? this.#total_time = total_time : throwReadOnlyError();\n  }\n\n  /**\n   * Adds the current session time to the existing total time.\n   *\n   * @return {string} ISO8601 Duration\n   */\n  getCurrentTotalTime() {\n    let sessionTime = this.#session_time;\n    const startTime = this.start_time;\n\n    if (typeof startTime !== 'undefined' && startTime !== null) {\n      const seconds = new Date().getTime() - startTime;\n      sessionTime = Util.getSecondsAsISODuration(seconds / 1000);\n    }\n\n    return Util.addTwoDurations(\n        this.#total_time,\n        sessionTime,\n        scorm2004_regex.CMITimespan,\n    );\n  }\n\n  /**\n   * toJSON for cmi\n   *\n   * @return {\n   *    {\n   *      comments_from_learner: CMICommentsFromLearner,\n   *      comments_from_lms: CMICommentsFromLMS,\n   *      completion_status: string,\n   *      completion_threshold: string,\n   *      credit: string,\n   *      entry: string,\n   *      exit: string,\n   *      interactions: CMIInteractions,\n   *      launch_data: string,\n   *      learner_id: string,\n   *      learner_name: string,\n   *      learner_preference: CMILearnerPreference,\n   *      location: string,\n   *      max_time_allowed: string,\n   *      mode: string,\n   *      objectives: CMIObjectives,\n   *      progress_measure: string,\n   *      scaled_passing_score: string,\n   *      score: Scorm2004CMIScore,\n   *      session_time: string,\n   *      success_status: string,\n   *      suspend_data: string,\n   *      time_limit_action: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'comments_from_learner': this.comments_from_learner,\n      'comments_from_lms': this.comments_from_lms,\n      'completion_status': this.completion_status,\n      'completion_threshold': this.completion_threshold,\n      'credit': this.credit,\n      'entry': this.entry,\n      'exit': this.exit,\n      'interactions': this.interactions,\n      'launch_data': this.launch_data,\n      'learner_id': this.learner_id,\n      'learner_name': this.learner_name,\n      'learner_preference': this.learner_preference,\n      'location': this.location,\n      'max_time_allowed': this.max_time_allowed,\n      'mode': this.mode,\n      'objectives': this.objectives,\n      'progress_measure': this.progress_measure,\n      'scaled_passing_score': this.scaled_passing_score,\n      'score': this.score,\n      'session_time': this.session_time,\n      'success_status': this.success_status,\n      'suspend_data': this.suspend_data,\n      'time_limit_action': this.time_limit_action,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class for SCORM 2004's cmi.learner_preference object\n */\nclass CMILearnerPreference extends BaseCMI {\n  #_children = scorm2004_constants.student_preference_children;\n  #audio_level = '1';\n  #language = '';\n  #delivery_speed = '1';\n  #audio_captioning = '0';\n\n  /**\n   * Constructor for cmi.learner_preference\n   */\n  constructor() {\n    super();\n  }\n\n  /**\n   * Getter for #_children\n   * @return {string}\n   * @private\n   */\n  get _children() {\n    return this.#_children;\n  }\n\n  /**\n   * Setter for #_children. Just throws an error.\n   * @param {string} _children\n   * @private\n   */\n  set _children(_children) {\n    throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #audio_level\n   * @return {string}\n   */\n  get audio_level() {\n    return this.#audio_level;\n  }\n\n  /**\n   * Setter for #audio_level\n   * @param {string} audio_level\n   */\n  set audio_level(audio_level) {\n    if (check2004ValidFormat(audio_level, scorm2004_regex.CMIDecimal) &&\n      check2004ValidRange(audio_level, scorm2004_regex.audio_range)) {\n      this.#audio_level = audio_level;\n    }\n  }\n\n  /**\n   * Getter for #language\n   * @return {string}\n   */\n  get language() {\n    return this.#language;\n  }\n\n  /**\n   * Setter for #language\n   * @param {string} language\n   */\n  set language(language) {\n    if (check2004ValidFormat(language, scorm2004_regex.CMILang)) {\n      this.#language = language;\n    }\n  }\n\n  /**\n   * Getter for #delivery_speed\n   * @return {string}\n   */\n  get delivery_speed() {\n    return this.#delivery_speed;\n  }\n\n  /**\n   * Setter for #delivery_speed\n   * @param {string} delivery_speed\n   */\n  set delivery_speed(delivery_speed) {\n    if (check2004ValidFormat(delivery_speed, scorm2004_regex.CMIDecimal) &&\n      check2004ValidRange(delivery_speed, scorm2004_regex.speed_range)) {\n      this.#delivery_speed = delivery_speed;\n    }\n  }\n\n  /**\n   * Getter for #audio_captioning\n   * @return {string}\n   */\n  get audio_captioning() {\n    return this.#audio_captioning;\n  }\n\n  /**\n   * Setter for #audio_captioning\n   * @param {string} audio_captioning\n   */\n  set audio_captioning(audio_captioning) {\n    if (check2004ValidFormat(audio_captioning, scorm2004_regex.CMISInteger) &&\n      check2004ValidRange(audio_captioning, scorm2004_regex.text_range)) {\n      this.#audio_captioning = audio_captioning;\n    }\n  }\n\n  /**\n   * toJSON for cmi.learner_preference\n   *\n   * @return {\n   *    {\n   *      audio_level: string,\n   *      language: string,\n   *      delivery_speed: string,\n   *      audio_captioning: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'audio_level': this.audio_level,\n      'language': this.language,\n      'delivery_speed': this.delivery_speed,\n      'audio_captioning': this.audio_captioning,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 2004's cmi.interactions object\n */\nclass CMIInteractions extends CMIArray {\n  /**\n   * Constructor for cmi.objectives Array\n   */\n  constructor() {\n    super({\n      children: scorm2004_constants.interactions_children,\n      errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n      errorClass: Scorm2004ValidationError,\n    });\n  }\n}\n\n/**\n * Class representing SCORM 2004's cmi.objectives object\n */\nclass CMIObjectives extends CMIArray {\n  /**\n   * Constructor for cmi.objectives Array\n   */\n  constructor() {\n    super({\n      children: scorm2004_constants.objectives_children,\n      errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n      errorClass: Scorm2004ValidationError,\n    });\n  }\n}\n\n/**\n * Class representing SCORM 2004's cmi.comments_from_lms object\n */\nclass CMICommentsFromLMS extends CMIArray {\n  /**\n   * Constructor for cmi.comments_from_lms Array\n   */\n  constructor() {\n    super({\n      children: scorm2004_constants.comments_children,\n      errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n      errorClass: Scorm2004ValidationError,\n    });\n  }\n}\n\n/**\n * Class representing SCORM 2004's cmi.comments_from_learner object\n */\nclass CMICommentsFromLearner extends CMIArray {\n  /**\n   * Constructor for cmi.comments_from_learner Array\n   */\n  constructor() {\n    super({\n      children: scorm2004_constants.comments_children,\n      errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n      errorClass: Scorm2004ValidationError,\n    });\n  }\n}\n\n/**\n * Class for SCORM 2004's cmi.interaction.n object\n */\nexport class CMIInteractionsObject extends BaseCMI {\n  #id = '';\n  #type = '';\n  #timestamp = '';\n  #weighting = '';\n  #learner_response = '';\n  #result = '';\n  #latency = '';\n  #description = '';\n\n  /**\n   * Constructor for cmi.interaction.n\n   */\n  constructor() {\n    super();\n\n    this.objectives = new CMIArray({\n      errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n      errorClass: Scorm2004ValidationError,\n      children: scorm2004_constants.objectives_children,\n    });\n    this.correct_responses = new CMIArray({\n      errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n      errorClass: Scorm2004ValidationError,\n      children: scorm2004_constants.correct_responses_children,\n    });\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.objectives?.initialize();\n    this.correct_responses?.initialize();\n  }\n\n  /**\n   * Getter for #id\n   * @return {string}\n   */\n  get id() {\n    return this.#id;\n  }\n\n  /**\n   * Setter for #id\n   * @param {string} id\n   */\n  set id(id) {\n    if (check2004ValidFormat(id, scorm2004_regex.CMILongIdentifier)) {\n      this.#id = id;\n    }\n  }\n\n  /**\n   * Getter for #type\n   * @return {string}\n   */\n  get type() {\n    return this.#type;\n  }\n\n  /**\n   * Setter for #type\n   * @param {string} type\n   */\n  set type(type) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(type, scorm2004_regex.CMIType)) {\n        this.#type = type;\n      }\n    }\n  }\n\n  /**\n   * Getter for #timestamp\n   * @return {string}\n   */\n  get timestamp() {\n    return this.#timestamp;\n  }\n\n  /**\n   * Setter for #timestamp\n   * @param {string} timestamp\n   */\n  set timestamp(timestamp) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(timestamp, scorm2004_regex.CMITime)) {\n        this.#timestamp = timestamp;\n      }\n    }\n  }\n\n  /**\n   * Getter for #weighting\n   * @return {string}\n   */\n  get weighting() {\n    return this.#weighting;\n  }\n\n  /**\n   * Setter for #weighting\n   * @param {string} weighting\n   */\n  set weighting(weighting) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(weighting, scorm2004_regex.CMIDecimal)) {\n        this.#weighting = weighting;\n      }\n    }\n  }\n\n  /**\n   * Getter for #learner_response\n   * @return {string}\n   */\n  get learner_response() {\n    return this.#learner_response;\n  }\n\n  /**\n   * Setter for #learner_response. Does type validation to make sure response\n   * matches SCORM 2004's spec\n   * @param {string} learner_response\n   */\n  set learner_response(learner_response) {\n    if (this.initialized && (this.#type === '' || this.#id === '')) {\n      throwDependencyNotEstablishedError();\n    } else {\n      let nodes = [];\n      const response_type = learner_responses[this.type];\n      if (response_type) {\n        if (response_type?.delimiter) {\n          nodes = learner_response.split(response_type.delimiter);\n        } else {\n          nodes[0] = learner_response;\n        }\n\n        if ((nodes.length > 0) && (nodes.length <= response_type.max)) {\n          const formatRegex = new RegExp(response_type.format);\n          for (let i = 0; i < nodes.length; i++) {\n            if (response_type?.delimiter2) {\n              const values = nodes[i].split(response_type.delimiter2);\n              if (values.length === 2) {\n                if (!values[0].match(formatRegex)) {\n                  throwTypeMismatchError();\n                } else {\n                  if (!values[1].match(new RegExp(response_type.format2))) {\n                    throwTypeMismatchError();\n                  }\n                }\n              } else {\n                throwTypeMismatchError();\n              }\n            } else {\n              if (!nodes[i].match(formatRegex)) {\n                throwTypeMismatchError();\n              } else {\n                if (nodes[i] !== '' && response_type.unique) {\n                  for (let j = 0; j < i; j++) {\n                    if (nodes[i] === nodes[j]) {\n                      throwTypeMismatchError();\n                    }\n                  }\n                }\n              }\n            }\n          }\n        } else {\n          throwGeneralSetError();\n        }\n\n        this.#learner_response = learner_response;\n      } else {\n        throwTypeMismatchError();\n      }\n    }\n  }\n\n  /**\n   * Getter for #result\n   * @return {string}\n   */\n  get result() {\n    return this.#result;\n  }\n\n  /**\n   * Setter for #result\n   * @param {string} result\n   */\n  set result(result) {\n    if (check2004ValidFormat(result, scorm2004_regex.CMIResult)) {\n      this.#result = result;\n    }\n  }\n\n  /**\n   * Getter for #latency\n   * @return {string}\n   */\n  get latency() {\n    return this.#latency;\n  }\n\n  /**\n   * Setter for #latency\n   * @param {string} latency\n   */\n  set latency(latency) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(latency, scorm2004_regex.CMITimespan)) {\n        this.#latency = latency;\n      }\n    }\n  }\n\n  /**\n   * Getter for #description\n   * @return {string}\n   */\n  get description() {\n    return this.#description;\n  }\n\n  /**\n   * Setter for #description\n   * @param {string} description\n   */\n  set description(description) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(description, scorm2004_regex.CMILangString250,\n          true)) {\n        this.#description = description;\n      }\n    }\n  }\n\n  /**\n   * toJSON for cmi.interactions.n\n   *\n   * @return {\n   *    {\n   *      id: string,\n   *      type: string,\n   *      objectives: CMIArray,\n   *      timestamp: string,\n   *      correct_responses: CMIArray,\n   *      weighting: string,\n   *      learner_response: string,\n   *      result: string,\n   *      latency: string,\n   *      description: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'id': this.id,\n      'type': this.type,\n      'objectives': this.objectives,\n      'timestamp': this.timestamp,\n      'weighting': this.weighting,\n      'learner_response': this.learner_response,\n      'result': this.result,\n      'latency': this.latency,\n      'description': this.description,\n      'correct_responses': this.correct_responses,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class for SCORM 2004's cmi.objectives.n object\n */\nexport class CMIObjectivesObject extends BaseCMI {\n  #id = '';\n  #success_status = 'unknown';\n  #completion_status = 'unknown';\n  #progress_measure = '';\n  #description = '';\n\n  /**\n   * Constructor for cmi.objectives.n\n   */\n  constructor() {\n    super();\n\n    this.score = new Scorm2004CMIScore();\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.score?.initialize();\n  }\n\n  /**\n   * Getter for #id\n   * @return {string}\n   */\n  get id() {\n    return this.#id;\n  }\n\n  /**\n   * Setter for #id\n   * @param {string} id\n   */\n  set id(id) {\n    if (check2004ValidFormat(id, scorm2004_regex.CMILongIdentifier)) {\n      this.#id = id;\n    }\n  }\n\n  /**\n   * Getter for #success_status\n   * @return {string}\n   */\n  get success_status() {\n    return this.#success_status;\n  }\n\n  /**\n   * Setter for #success_status\n   * @param {string} success_status\n   */\n  set success_status(success_status) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(success_status, scorm2004_regex.CMISStatus)) {\n        this.#success_status = success_status;\n      }\n    }\n  }\n\n  /**\n   * Getter for #completion_status\n   * @return {string}\n   */\n  get completion_status() {\n    return this.#completion_status;\n  }\n\n  /**\n   * Setter for #completion_status\n   * @param {string} completion_status\n   */\n  set completion_status(completion_status) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(completion_status, scorm2004_regex.CMICStatus)) {\n        this.#completion_status = completion_status;\n      }\n    }\n  }\n\n  /**\n   * Getter for #progress_measure\n   * @return {string}\n   */\n  get progress_measure() {\n    return this.#progress_measure;\n  }\n\n  /**\n   * Setter for #progress_measure\n   * @param {string} progress_measure\n   */\n  set progress_measure(progress_measure) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(progress_measure, scorm2004_regex.CMIDecimal) &&\n        check2004ValidRange(progress_measure,\n            scorm2004_regex.progress_range)) {\n        this.#progress_measure = progress_measure;\n      }\n    }\n  }\n\n  /**\n   * Getter for #description\n   * @return {string}\n   */\n  get description() {\n    return this.#description;\n  }\n\n  /**\n   * Setter for #description\n   * @param {string} description\n   */\n  set description(description) {\n    if (this.initialized && this.#id === '') {\n      throwDependencyNotEstablishedError();\n    } else {\n      if (check2004ValidFormat(description, scorm2004_regex.CMILangString250,\n          true)) {\n        this.#description = description;\n      }\n    }\n  }\n\n  /**\n   * toJSON for cmi.objectives.n\n   *\n   * @return {\n   *    {\n   *      id: string,\n   *      success_status: string,\n   *      completion_status: string,\n   *      progress_measure: string,\n   *      description: string,\n   *      score: Scorm2004CMIScore\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'id': this.id,\n      'success_status': this.success_status,\n      'completion_status': this.completion_status,\n      'progress_measure': this.progress_measure,\n      'description': this.description,\n      'score': this.score,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class for SCORM 2004's cmi *.score object\n */\nclass Scorm2004CMIScore extends CMIScore {\n  #scaled = '';\n\n  /**\n   * Constructor for cmi *.score\n   */\n  constructor() {\n    super(\n        {\n          score_children: scorm2004_constants.score_children,\n          max: '',\n          invalidErrorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n          invalidTypeCode: scorm2004_error_codes.TYPE_MISMATCH,\n          invalidRangeCode: scorm2004_error_codes.VALUE_OUT_OF_RANGE,\n          decimalRegex: scorm2004_regex.CMIDecimal,\n          errorClass: Scorm2004ValidationError,\n        });\n  }\n\n  /**\n   * Getter for #scaled\n   * @return {string}\n   */\n  get scaled() {\n    return this.#scaled;\n  }\n\n  /**\n   * Setter for #scaled\n   * @param {string} scaled\n   */\n  set scaled(scaled) {\n    if (check2004ValidFormat(scaled, scorm2004_regex.CMIDecimal) &&\n      check2004ValidRange(scaled, scorm2004_regex.scaled_range)) {\n      this.#scaled = scaled;\n    }\n  }\n\n  /**\n   * toJSON for cmi *.score\n   *\n   * @return {\n   *    {\n   *      scaled: string,\n   *      raw: string,\n   *      min: string,\n   *      max: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'scaled': this.scaled,\n      'raw': super.raw,\n      'min': super.min,\n      'max': super.max,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 2004's cmi.comments_from_learner.n and cmi.comments_from_lms.n object\n */\nexport class CMICommentsObject extends BaseCMI {\n  #comment = '';\n  #location = '';\n  #timestamp = '';\n  #readOnlyAfterInit;\n\n  /**\n   * Constructor for cmi.comments_from_learner.n and cmi.comments_from_lms.n\n   * @param {boolean} readOnlyAfterInit\n   */\n  constructor(readOnlyAfterInit = false) {\n    super();\n    this.#comment = '';\n    this.#location = '';\n    this.#timestamp = '';\n    this.#readOnlyAfterInit = readOnlyAfterInit;\n  }\n\n  /**\n   * Getter for #comment\n   * @return {string}\n   */\n  get comment() {\n    return this.#comment;\n  }\n\n  /**\n   * Setter for #comment\n   * @param {string} comment\n   */\n  set comment(comment) {\n    if (this.initialized && this.#readOnlyAfterInit) {\n      throwReadOnlyError();\n    } else {\n      if (check2004ValidFormat(comment, scorm2004_regex.CMILangString4000,\n          true)) {\n        this.#comment = comment;\n      }\n    }\n  }\n\n  /**\n   * Getter for #location\n   * @return {string}\n   */\n  get location() {\n    return this.#location;\n  }\n\n  /**\n   * Setter for #location\n   * @param {string} location\n   */\n  set location(location) {\n    if (this.initialized && this.#readOnlyAfterInit) {\n      throwReadOnlyError();\n    } else {\n      if (check2004ValidFormat(location, scorm2004_regex.CMIString250)) {\n        this.#location = location;\n      }\n    }\n  }\n\n  /**\n   * Getter for #timestamp\n   * @return {string}\n   */\n  get timestamp() {\n    return this.#timestamp;\n  }\n\n  /**\n   * Setter for #timestamp\n   * @param {string} timestamp\n   */\n  set timestamp(timestamp) {\n    if (this.initialized && this.#readOnlyAfterInit) {\n      throwReadOnlyError();\n    } else {\n      if (check2004ValidFormat(timestamp, scorm2004_regex.CMITime)) {\n        this.#timestamp = timestamp;\n      }\n    }\n  }\n\n  /**\n   * toJSON for cmi.comments_from_learner.n object\n   * @return {\n   *    {\n   *      comment: string,\n   *      location: string,\n   *      timestamp: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'comment': this.comment,\n      'location': this.location,\n      'timestamp': this.timestamp,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 2004's cmi.interactions.n.objectives.n object\n */\nexport class CMIInteractionsObjectivesObject extends BaseCMI {\n  #id = '';\n\n  /**\n   * Constructor for cmi.interactions.n.objectives.n\n   */\n  constructor() {\n    super();\n  }\n\n  /**\n   * Getter for #id\n   * @return {string}\n   */\n  get id() {\n    return this.#id;\n  }\n\n  /**\n   * Setter for #id\n   * @param {string} id\n   */\n  set id(id) {\n    if (check2004ValidFormat(id, scorm2004_regex.CMILongIdentifier)) {\n      this.#id = id;\n    }\n  }\n\n  /**\n   * toJSON for cmi.interactions.n.objectives.n\n   * @return {\n   *    {\n   *      id: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'id': this.id,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 2004's cmi.interactions.n.correct_responses.n object\n */\nexport class CMIInteractionsCorrectResponsesObject extends BaseCMI {\n  #pattern = '';\n\n  /**\n   * Constructor for cmi.interactions.n.correct_responses.n\n   */\n  constructor() {\n    super();\n  }\n\n  /**\n   * Getter for #pattern\n   * @return {string}\n   */\n  get pattern() {\n    return this.#pattern;\n  }\n\n  /**\n   * Setter for #pattern\n   * @param {string} pattern\n   */\n  set pattern(pattern) {\n    if (check2004ValidFormat(pattern, scorm2004_regex.CMIFeedback)) {\n      this.#pattern = pattern;\n    }\n  }\n\n  /**\n   * toJSON cmi.interactions.n.correct_responses.n object\n   * @return {\n   *    {\n   *      pattern: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'pattern': this.pattern,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 2004's adl object\n */\nexport class ADL extends BaseCMI {\n  /**\n   * Constructor for adl\n   */\n  constructor() {\n    super();\n\n    this.nav = new ADLNav();\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.nav?.initialize();\n  }\n\n  /**\n   * toJSON for adl\n   * @return {\n   *    {\n   *      nav: {\n   *        request: string\n   *      }\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'nav': this.nav,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 2004's adl.nav object\n */\nclass ADLNav extends BaseCMI {\n  #request = '_none_';\n\n  /**\n   * Constructor for adl.nav\n   */\n  constructor() {\n    super();\n\n    this.request_valid = new ADLNavRequestValid();\n  }\n\n  /**\n   * Called when the API has been initialized after the CMI has been created\n   */\n  initialize() {\n    super.initialize();\n    this.request_valid?.initialize();\n  }\n\n  /**\n   * Getter for #request\n   * @return {string}\n   */\n  get request() {\n    return this.#request;\n  }\n\n  /**\n   * Setter for #request\n   * @param {string} request\n   */\n  set request(request) {\n    if (check2004ValidFormat(request, scorm2004_regex.NAVEvent)) {\n      this.#request = request;\n    }\n  }\n\n  /**\n   * toJSON for adl.nav\n   *\n   * @return {\n   *    {\n   *      request: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'request': this.request,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n\n/**\n * Class representing SCORM 2004's adl.nav.request_valid object\n */\nclass ADLNavRequestValid extends BaseCMI {\n  #continue = 'unknown';\n  #previous = 'unknown';\n  choice = class {\n    /**\n     * Check if target is valid\n     * @param {*} _target\n     * @return {string}\n     */\n    _isTargetValid = (_target) => 'unknown';\n  };\n  jump = class {\n    /**\n     * Check if target is valid\n     * @param {*} _target\n     * @return {string}\n     */\n    _isTargetValid = (_target) => 'unknown';\n  };\n\n  /**\n   * Constructor for adl.nav.request_valid\n   */\n  constructor() {\n    super();\n  }\n\n  /**\n   * Getter for #continue\n   * @return {string}\n   */\n  get continue() {\n    return this.#continue;\n  }\n\n  /**\n   * Setter for #continue. Just throws an error.\n   * @param {*} _\n   */\n  set continue(_) {\n    throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #previous\n   * @return {string}\n   */\n  get previous() {\n    return this.#previous;\n  }\n\n  /**\n   * Setter for #previous. Just throws an error.\n   * @param {*} _\n   */\n  set previous(_) {\n    throwReadOnlyError();\n  }\n\n  /**\n   * toJSON for adl.nav.request_valid\n   *\n   * @return {\n   *    {\n   *      previous: string,\n   *      continue: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    this.jsonString = true;\n    const result = {\n      'previous': this.previous,\n      'continue': this.continue,\n    };\n    delete this.jsonString;\n    return result;\n  }\n}\n","// @flow\n\nconst global = {\n  SCORM_TRUE: 'true',\n  SCORM_FALSE: 'false',\n  STATE_NOT_INITIALIZED: 0,\n  STATE_INITIALIZED: 1,\n  STATE_TERMINATED: 2,\n  LOG_LEVEL_DEBUG: 1,\n  LOG_LEVEL_INFO: 2,\n  LOG_LEVEL_WARNING: 3,\n  LOG_LEVEL_ERROR: 4,\n  LOG_LEVEL_NONE: 5,\n};\n\nconst scorm12 = {\n  // Children lists\n  cmi_children: 'core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions',\n  core_children: 'student_id,student_name,lesson_location,credit,lesson_status,entry,score,total_time,lesson_mode,exit,session_time',\n  score_children: 'raw,min,max',\n  comments_children: 'content,location,time',\n  objectives_children: 'id,score,status',\n  correct_responses_children: 'pattern',\n  student_data_children: 'mastery_score,max_time_allowed,time_limit_action',\n  student_preference_children: 'audio,language,speed,text',\n  interactions_children: 'id,objectives,time,type,correct_responses,weighting,student_response,result,latency',\n\n  error_descriptions: {\n    '101': {\n      basicMessage: 'General Exception',\n      detailMessage: 'No specific error code exists to describe the error. Use LMSGetDiagnostic for more information',\n    },\n    '201': {\n      basicMessage: 'Invalid argument error',\n      detailMessage: 'Indicates that an argument represents an invalid data model element or is otherwise incorrect.',\n    },\n    '202': {\n      basicMessage: 'Element cannot have children',\n      detailMessage: 'Indicates that LMSGetValue was called with a data model element name that ends in \"_children\" for a data model element that does not support the \"_children\" suffix.',\n    },\n    '203': {\n      basicMessage: 'Element not an array - cannot have count',\n      detailMessage: 'Indicates that LMSGetValue was called with a data model element name that ends in \"_count\" for a data model element that does not support the \"_count\" suffix.',\n    },\n    '301': {\n      basicMessage: 'Not initialized',\n      detailMessage: 'Indicates that an API call was made before the call to lmsInitialize.',\n    },\n    '401': {\n      basicMessage: 'Not implemented error',\n      detailMessage: 'The data model element indicated in a call to LMSGetValue or LMSSetValue is valid, but was not implemented by this LMS. SCORM 1.2 defines a set of data model elements as being optional for an LMS to implement.',\n    },\n    '402': {\n      basicMessage: 'Invalid set value, element is a keyword',\n      detailMessage: 'Indicates that LMSSetValue was called on a data model element that represents a keyword (elements that end in \"_children\" and \"_count\").',\n    },\n    '403': {\n      basicMessage: 'Element is read only',\n      detailMessage: 'LMSSetValue was called with a data model element that can only be read.',\n    },\n    '404': {\n      basicMessage: 'Element is write only',\n      detailMessage: 'LMSGetValue was called on a data model element that can only be written to.',\n    },\n    '405': {\n      basicMessage: 'Incorrect Data Type',\n      detailMessage: 'LMSSetValue was called with a value that is not consistent with the data format of the supplied data model element.',\n    },\n    '407': {\n      basicMessage: 'Element Value Out Of Range',\n      detailMessage: 'The numeric value supplied to a LMSSetValue call is outside of the numeric range allowed for the supplied data model element.',\n    },\n    '408': {\n      basicMessage: 'Data Model Dependency Not Established',\n      detailMessage: 'Some data model elements cannot be set until another data model element was set. This error condition indicates that the prerequisite element was not set before the dependent element.',\n    },\n  },\n};\n\nconst aicc = {\n  ...scorm12, ...{\n    cmi_children: 'core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions,evaluation',\n    student_preference_children: 'audio,language,lesson_type,speed,text,text_color,text_location,text_size,video,windows',\n    student_data_children: 'attempt_number,tries,mastery_score,max_time_allowed,time_limit_action',\n    student_demographics_children: 'city,class,company,country,experience,familiar_name,instructor_name,title,native_language,state,street_address,telephone,years_experience',\n    tries_children: 'time,status,score',\n    attempt_records_children: 'score,lesson_status',\n    paths_children: 'location_id,date,time,status,why_left,time_in_element',\n  },\n};\n\nconst scorm2004 = {\n  // Children lists\n  cmi_children: '_version,comments_from_learner,comments_from_lms,completion_status,credit,entry,exit,interactions,launch_data,learner_id,learner_name,learner_preference,location,max_time_allowed,mode,objectives,progress_measure,scaled_passing_score,score,session_time,success_status,suspend_data,time_limit_action,total_time',\n  comments_children: 'comment,timestamp,location',\n  score_children: 'max,raw,scaled,min',\n  objectives_children: 'progress_measure,completion_status,success_status,description,score,id',\n  correct_responses_children: 'pattern',\n  student_data_children: 'mastery_score,max_time_allowed,time_limit_action',\n  student_preference_children: 'audio_level,audio_captioning,delivery_speed,language',\n  interactions_children: 'id,type,objectives,timestamp,correct_responses,weighting,learner_response,result,latency,description',\n\n  error_descriptions: {\n    '0': {\n      basicMessage: 'No Error',\n      detailMessage: 'No error occurred, the previous API call was successful.',\n    },\n    '101': {\n      basicMessage: 'General Exception',\n      detailMessage: 'No specific error code exists to describe the error. Use GetDiagnostic for more information.',\n    },\n    '102': {\n      basicMessage: 'General Initialization Failure',\n      detailMessage: 'Call to Initialize failed for an unknown reason.',\n    },\n    '103': {\n      basicMessage: 'Already Initialized',\n      detailMessage: 'Call to Initialize failed because Initialize was already called.',\n    },\n    '104': {\n      basicMessage: 'Content Instance Terminated',\n      detailMessage: 'Call to Initialize failed because Terminate was already called.',\n    },\n    '111': {\n      basicMessage: 'General Termination Failure',\n      detailMessage: 'Call to Terminate failed for an unknown reason.',\n    },\n    '112': {\n      basicMessage: 'Termination Before Initialization',\n      detailMessage: 'Call to Terminate failed because it was made before the call to Initialize.',\n    },\n    '113': {\n      basicMessage: 'Termination After Termination',\n      detailMessage: 'Call to Terminate failed because Terminate was already called.',\n    },\n    '122': {\n      basicMessage: 'Retrieve Data Before Initialization',\n      detailMessage: 'Call to GetValue failed because it was made before the call to Initialize.',\n    },\n    '123': {\n      basicMessage: 'Retrieve Data After Termination',\n      detailMessage: 'Call to GetValue failed because it was made after the call to Terminate.',\n    },\n    '132': {\n      basicMessage: 'Store Data Before Initialization',\n      detailMessage: 'Call to SetValue failed because it was made before the call to Initialize.',\n    },\n    '133': {\n      basicMessage: 'Store Data After Termination',\n      detailMessage: 'Call to SetValue failed because it was made after the call to Terminate.',\n    },\n    '142': {\n      basicMessage: 'Commit Before Initialization',\n      detailMessage: 'Call to Commit failed because it was made before the call to Initialize.',\n    },\n    '143': {\n      basicMessage: 'Commit After Termination',\n      detailMessage: 'Call to Commit failed because it was made after the call to Terminate.',\n    },\n    '201': {\n      basicMessage: 'General Argument Error',\n      detailMessage: 'An invalid argument was passed to an API method (usually indicates that Initialize, Commit or Terminate did not receive the expected empty string argument.',\n    },\n    '301': {\n      basicMessage: 'General Get Failure',\n      detailMessage: 'Indicates a failed GetValue call where no other specific error code is applicable. Use GetDiagnostic for more information.',\n    },\n    '351': {\n      basicMessage: 'General Set Failure',\n      detailMessage: 'Indicates a failed SetValue call where no other specific error code is applicable. Use GetDiagnostic for more information.',\n    },\n    '391': {\n      basicMessage: 'General Commit Failure',\n      detailMessage: 'Indicates a failed Commit call where no other specific error code is applicable. Use GetDiagnostic for more information.',\n    },\n    '401': {\n      basicMessage: 'Undefined Data Model Element',\n      detailMessage: 'The data model element name passed to GetValue or SetValue is not a valid SCORM data model element.',\n    },\n    '402': {\n      basicMessage: 'Unimplemented Data Model Element',\n      detailMessage: 'The data model element indicated in a call to GetValue or SetValue is valid, but was not implemented by this LMS. In SCORM 2004, this error would indicate an LMS that is not fully SCORM conformant.',\n    },\n    '403': {\n      basicMessage: 'Data Model Element Value Not Initialized',\n      detailMessage: 'Attempt to read a data model element that has not been initialized by the LMS or through a SetValue call. This error condition is often reached during normal execution of a SCO.',\n    },\n    '404': {\n      basicMessage: 'Data Model Element Is Read Only',\n      detailMessage: 'SetValue was called with a data model element that can only be read.',\n    },\n    '405': {\n      basicMessage: 'Data Model Element Is Write Only',\n      detailMessage: 'GetValue was called on a data model element that can only be written to.',\n    },\n    '406': {\n      basicMessage: 'Data Model Element Type Mismatch',\n      detailMessage: 'SetValue was called with a value that is not consistent with the data format of the supplied data model element.',\n    },\n    '407': {\n      basicMessage: 'Data Model Element Value Out Of Range',\n      detailMessage: 'The numeric value supplied to a SetValue call is outside of the numeric range allowed for the supplied data model element.',\n    },\n    '408': {\n      basicMessage: 'Data Model Dependency Not Established',\n      detailMessage: 'Some data model elements cannot be set until another data model element was set. This error condition indicates that the prerequisite element was not set before the dependent element.',\n    },\n  },\n};\n\nconst APIConstants = {\n  global: global,\n  scorm12: scorm12,\n  aicc: aicc,\n  scorm2004: scorm2004,\n};\n\nexport default APIConstants;\n","// @flow\nconst global = {\n  GENERAL: 101,\n  INITIALIZATION_FAILED: 101,\n  INITIALIZED: 101,\n  TERMINATED: 101,\n  TERMINATION_FAILURE: 101,\n  TERMINATION_BEFORE_INIT: 101,\n  MULTIPLE_TERMINATION: 101,\n  RETRIEVE_BEFORE_INIT: 101,\n  RETRIEVE_AFTER_TERM: 101,\n  STORE_BEFORE_INIT: 101,\n  STORE_AFTER_TERM: 101,\n  COMMIT_BEFORE_INIT: 101,\n  COMMIT_AFTER_TERM: 101,\n  ARGUMENT_ERROR: 101,\n  CHILDREN_ERROR: 101,\n  COUNT_ERROR: 101,\n  GENERAL_GET_FAILURE: 101,\n  GENERAL_SET_FAILURE: 101,\n  GENERAL_COMMIT_FAILURE: 101,\n  UNDEFINED_DATA_MODEL: 101,\n  UNIMPLEMENTED_ELEMENT: 101,\n  VALUE_NOT_INITIALIZED: 101,\n  INVALID_SET_VALUE: 101,\n  READ_ONLY_ELEMENT: 101,\n  WRITE_ONLY_ELEMENT: 101,\n  TYPE_MISMATCH: 101,\n  VALUE_OUT_OF_RANGE: 101,\n  DEPENDENCY_NOT_ESTABLISHED: 101,\n};\n\nconst scorm12 = {\n  ...global, ...{\n    RETRIEVE_BEFORE_INIT: 301,\n    STORE_BEFORE_INIT: 301,\n    COMMIT_BEFORE_INIT: 301,\n    ARGUMENT_ERROR: 201,\n    CHILDREN_ERROR: 202,\n    COUNT_ERROR: 203,\n    UNDEFINED_DATA_MODEL: 401,\n    UNIMPLEMENTED_ELEMENT: 401,\n    VALUE_NOT_INITIALIZED: 301,\n    INVALID_SET_VALUE: 402,\n    READ_ONLY_ELEMENT: 403,\n    WRITE_ONLY_ELEMENT: 404,\n    TYPE_MISMATCH: 405,\n    VALUE_OUT_OF_RANGE: 407,\n    DEPENDENCY_NOT_ESTABLISHED: 408,\n  },\n};\n\nconst scorm2004 = {\n  ...global, ...{\n    INITIALIZATION_FAILED: 102,\n    INITIALIZED: 103,\n    TERMINATED: 104,\n    TERMINATION_FAILURE: 111,\n    TERMINATION_BEFORE_INIT: 112,\n    MULTIPLE_TERMINATIONS: 113,\n    RETRIEVE_BEFORE_INIT: 122,\n    RETRIEVE_AFTER_TERM: 123,\n    STORE_BEFORE_INIT: 132,\n    STORE_AFTER_TERM: 133,\n    COMMIT_BEFORE_INIT: 142,\n    COMMIT_AFTER_TERM: 143,\n    ARGUMENT_ERROR: 201,\n    GENERAL_GET_FAILURE: 301,\n    GENERAL_SET_FAILURE: 351,\n    GENERAL_COMMIT_FAILURE: 391,\n    UNDEFINED_DATA_MODEL: 401,\n    UNIMPLEMENTED_ELEMENT: 402,\n    VALUE_NOT_INITIALIZED: 403,\n    READ_ONLY_ELEMENT: 404,\n    WRITE_ONLY_ELEMENT: 405,\n    TYPE_MISMATCH: 406,\n    VALUE_OUT_OF_RANGE: 407,\n    DEPENDENCY_NOT_ESTABLISHED: 408,\n  },\n};\n\nconst ErrorCodes = {\n  scorm12: scorm12,\n  scorm2004: scorm2004,\n};\n\nexport default ErrorCodes;\n","const ValidLanguages = {\n  'aa': 'aa', 'ab': 'ab', 'ae': 'ae', 'af': 'af', 'ak': 'ak', 'am': 'am',\n  'an': 'an', 'ar': 'ar', 'as': 'as', 'av': 'av', 'ay': 'ay', 'az': 'az',\n  'ba': 'ba', 'be': 'be', 'bg': 'bg', 'bh': 'bh', 'bi': 'bi', 'bm': 'bm',\n  'bn': 'bn', 'bo': 'bo', 'br': 'br', 'bs': 'bs', 'ca': 'ca', 'ce': 'ce',\n  'ch': 'ch', 'co': 'co', 'cr': 'cr', 'cs': 'cs', 'cu': 'cu', 'cv': 'cv',\n  'cy': 'cy', 'da': 'da', 'de': 'de', 'dv': 'dv', 'dz': 'dz', 'ee': 'ee',\n  'el': 'el', 'en': 'en', 'eo': 'eo', 'es': 'es', 'et': 'et', 'eu': 'eu',\n  'fa': 'fa', 'ff': 'ff', 'fi': 'fi', 'fj': 'fj', 'fo': 'fo', 'fr': 'fr',\n  'fy': 'fy', 'ga': 'ga', 'gd': 'gd', 'gl': 'gl', 'gn': 'gn', 'gu': 'gu',\n  'gv': 'gv', 'ha': 'ha', 'he': 'he', 'hi': 'hi', 'ho': 'ho', 'hr': 'hr',\n  'ht': 'ht', 'hu': 'hu', 'hy': 'hy', 'hz': 'hz', 'ia': 'ia', 'id': 'id',\n  'ie': 'ie', 'ig': 'ig', 'ii': 'ii', 'ik': 'ik', 'io': 'io', 'is': 'is',\n  'it': 'it', 'iu': 'iu', 'ja': 'ja', 'jv': 'jv', 'ka': 'ka', 'kg': 'kg',\n  'ki': 'ki', 'kj': 'kj', 'kk': 'kk', 'kl': 'kl', 'km': 'km', 'kn': 'kn',\n  'ko': 'ko', 'kr': 'kr', 'ks': 'ks', 'ku': 'ku', 'kv': 'kv', 'kw': 'kw',\n  'ky': 'ky', 'la': 'la', 'lb': 'lb', 'lg': 'lg', 'li': 'li', 'ln': 'ln',\n  'lo': 'lo', 'lt': 'lt', 'lu': 'lu', 'lv': 'lv', 'mg': 'mg', 'mh': 'mh',\n  'mi': 'mi', 'mk': 'mk', 'ml': 'ml', 'mn': 'mn', 'mo': 'mo', 'mr': 'mr',\n  'ms': 'ms', 'mt': 'mt', 'my': 'my', 'na': 'na', 'nb': 'nb', 'nd': 'nd',\n  'ne': 'ne', 'ng': 'ng', 'nl': 'nl', 'nn': 'nn', 'no': 'no', 'nr': 'nr',\n  'nv': 'nv', 'ny': 'ny', 'oc': 'oc', 'oj': 'oj', 'om': 'om', 'or': 'or',\n  'os': 'os', 'pa': 'pa', 'pi': 'pi', 'pl': 'pl', 'ps': 'ps', 'pt': 'pt',\n  'qu': 'qu', 'rm': 'rm', 'rn': 'rn', 'ro': 'ro', 'ru': 'ru', 'rw': 'rw',\n  'sa': 'sa', 'sc': 'sc', 'sd': 'sd', 'se': 'se', 'sg': 'sg', 'sh': 'sh',\n  'si': 'si', 'sk': 'sk', 'sl': 'sl', 'sm': 'sm', 'sn': 'sn', 'so': 'so',\n  'sq': 'sq', 'sr': 'sr', 'ss': 'ss', 'st': 'st', 'su': 'su', 'sv': 'sv',\n  'sw': 'sw', 'ta': 'ta', 'te': 'te', 'tg': 'tg', 'th': 'th', 'ti': 'ti',\n  'tk': 'tk', 'tl': 'tl', 'tn': 'tn', 'to': 'to', 'tr': 'tr', 'ts': 'ts',\n  'tt': 'tt', 'tw': 'tw', 'ty': 'ty', 'ug': 'ug', 'uk': 'uk', 'ur': 'ur',\n  'uz': 'uz', 've': 've', 'vi': 'vi', 'vo': 'vo', 'wa': 'wa', 'wo': 'wo',\n  'xh': 'xh', 'yi': 'yi', 'yo': 'yo', 'za': 'za', 'zh': 'zh', 'zu': 'zu',\n  'aar': 'aar', 'abk': 'abk', 'ave': 'ave', 'afr': 'afr', 'aka': 'aka',\n  'amh': 'amh', 'arg': 'arg', 'ara': 'ara', 'asm': 'asm', 'ava': 'ava',\n  'aym': 'aym', 'aze': 'aze', 'bak': 'bak', 'bel': 'bel', 'bul': 'bul',\n  'bih': 'bih', 'bis': 'bis', 'bam': 'bam', 'ben': 'ben', 'tib': 'tib',\n  'bod': 'bod', 'bre': 'bre', 'bos': 'bos', 'cat': 'cat', 'che': 'che',\n  'cha': 'cha', 'cos': 'cos', 'cre': 'cre', 'cze': 'cze', 'ces': 'ces',\n  'chu': 'chu', 'chv': 'chv', 'wel': 'wel', 'cym': 'cym', 'dan': 'dan',\n  'ger': 'ger', 'deu': 'deu', 'div': 'div', 'dzo': 'dzo', 'ewe': 'ewe',\n  'gre': 'gre', 'ell': 'ell', 'eng': 'eng', 'epo': 'epo', 'spa': 'spa',\n  'est': 'est', 'baq': 'baq', 'eus': 'eus', 'per': 'per', 'fas': 'fas',\n  'ful': 'ful', 'fin': 'fin', 'fij': 'fij', 'fao': 'fao', 'fre': 'fre',\n  'fra': 'fra', 'fry': 'fry', 'gle': 'gle', 'gla': 'gla', 'glg': 'glg',\n  'grn': 'grn', 'guj': 'guj', 'glv': 'glv', 'hau': 'hau', 'heb': 'heb',\n  'hin': 'hin', 'hmo': 'hmo', 'hrv': 'hrv', 'hat': 'hat', 'hun': 'hun',\n  'arm': 'arm', 'hye': 'hye', 'her': 'her', 'ina': 'ina', 'ind': 'ind',\n  'ile': 'ile', 'ibo': 'ibo', 'iii': 'iii', 'ipk': 'ipk', 'ido': 'ido',\n  'ice': 'ice', 'isl': 'isl', 'ita': 'ita', 'iku': 'iku', 'jpn': 'jpn',\n  'jav': 'jav', 'geo': 'geo', 'kat': 'kat', 'kon': 'kon', 'kik': 'kik',\n  'kua': 'kua', 'kaz': 'kaz', 'kal': 'kal', 'khm': 'khm', 'kan': 'kan',\n  'kor': 'kor', 'kau': 'kau', 'kas': 'kas', 'kur': 'kur', 'kom': 'kom',\n  'cor': 'cor', 'kir': 'kir', 'lat': 'lat', 'ltz': 'ltz', 'lug': 'lug',\n  'lim': 'lim', 'lin': 'lin', 'lao': 'lao', 'lit': 'lit', 'lub': 'lub',\n  'lav': 'lav', 'mlg': 'mlg', 'mah': 'mah', 'mao': 'mao', 'mri': 'mri',\n  'mac': 'mac', 'mkd': 'mkd', 'mal': 'mal', 'mon': 'mon', 'mol': 'mol',\n  'mar': 'mar', 'may': 'may', 'msa': 'msa', 'mlt': 'mlt', 'bur': 'bur',\n  'mya': 'mya', 'nau': 'nau', 'nob': 'nob', 'nde': 'nde', 'nep': 'nep',\n  'ndo': 'ndo', 'dut': 'dut', 'nld': 'nld', 'nno': 'nno', 'nor': 'nor',\n  'nbl': 'nbl', 'nav': 'nav', 'nya': 'nya', 'oci': 'oci', 'oji': 'oji',\n  'orm': 'orm', 'ori': 'ori', 'oss': 'oss', 'pan': 'pan', 'pli': 'pli',\n  'pol': 'pol', 'pus': 'pus', 'por': 'por', 'que': 'que', 'roh': 'roh',\n  'run': 'run', 'rum': 'rum', 'ron': 'ron', 'rus': 'rus', 'kin': 'kin',\n  'san': 'san', 'srd': 'srd', 'snd': 'snd', 'sme': 'sme', 'sag': 'sag',\n  'slo': 'slo', 'sin': 'sin', 'slk': 'slk', 'slv': 'slv', 'smo': 'smo',\n  'sna': 'sna', 'som': 'som', 'alb': 'alb', 'sqi': 'sqi', 'srp': 'srp',\n  'ssw': 'ssw', 'sot': 'sot', 'sun': 'sun', 'swe': 'swe', 'swa': 'swa',\n  'tam': 'tam', 'tel': 'tel', 'tgk': 'tgk', 'tha': 'tha', 'tir': 'tir',\n  'tuk': 'tuk', 'tgl': 'tgl', 'tsn': 'tsn', 'ton': 'ton', 'tur': 'tur',\n  'tso': 'tso', 'tat': 'tat', 'twi': 'twi', 'tah': 'tah', 'uig': 'uig',\n  'ukr': 'ukr', 'urd': 'urd', 'uzb': 'uzb', 'ven': 'ven', 'vie': 'vie',\n  'vol': 'vol', 'wln': 'wln', 'wol': 'wol', 'xho': 'xho', 'yid': 'yid',\n  'yor': 'yor', 'zha': 'zha', 'chi': 'chi', 'zho': 'zho', 'zul': 'zul',\n};\n\nexport default ValidLanguages;\n","// @flow\n\nconst scorm12 = {\n  CMIString256: '^.{0,255}$',\n  CMIString4096: '^.{0,4096}$',\n  CMITime: '^(?:[01]\\\\d|2[0123]):(?:[012345]\\\\d):(?:[012345]\\\\d)$', // eslint-disable-line\n  CMITimespan: '^([0-9]{2,}):([0-9]{2}):([0-9]{2})(\\.[0-9]{1,2})?$', // eslint-disable-line\n  CMIInteger: '^\\\\d+$',\n  CMISInteger: '^-?([0-9]+)$',\n  CMIDecimal: '^-?([0-9]{0,3})(\\.[0-9]*)?$', // eslint-disable-line\n  CMIIdentifier: '^[\\\\u0021-\\\\u007E\\\\s]{0,255}$',\n  CMIFeedback: '^.{0,255}$', // This must be redefined\n  CMIIndex: '[._](\\\\d+).',\n\n  // Vocabulary Data Type Definition\n  CMIStatus: '^(passed|completed|failed|incomplete|browsed)$',\n  CMIStatus2: '^(passed|completed|failed|incomplete|browsed|not attempted)$',\n  CMIExit: '^(time-out|suspend|logout|)$',\n  CMIType: '^(true-false|choice|fill-in|matching|performance|sequencing|likert|numeric)$',\n  CMIResult: '^(correct|wrong|unanticipated|neutral|([0-9]{0,3})?(\\\\.[0-9]*)?)$', // eslint-disable-line\n  NAVEvent: '^(previous|continue)$',\n\n  // Data ranges\n  score_range: '0#100',\n  audio_range: '-1#100',\n  speed_range: '-100#100',\n  weighting_range: '-100#100',\n  text_range: '-1#1',\n};\n\nconst aicc = {\n  ...scorm12, ...{\n    CMIIdentifier: '^\\\\w{1,255}$',\n  },\n};\n\nconst scorm2004 = {\n  CMIString200: '^[\\\\u0000-\\\\uFFFF]{0,200}$',\n  CMIString250: '^[\\\\u0000-\\\\uFFFF]{0,250}$',\n  CMIString1000: '^[\\\\u0000-\\\\uFFFF]{0,1000}$',\n  CMIString4000: '^[\\\\u0000-\\\\uFFFF]{0,4000}$',\n  CMIString64000: '^[\\\\u0000-\\\\uFFFF]{0,64000}$',\n  CMILang: '^([a-zA-Z]{2,3}|i|x)(\\-[a-zA-Z0-9\\-]{2,8})?$|^$', // eslint-disable-line\n  CMILangString250: '^(\\{lang=([a-zA-Z]{2,3}|i|x)(\\-[a-zA-Z0-9\\-]{2,8})?\\})?((?!\\{.*$).{0,250}$)?$', // eslint-disable-line\n  CMILangcr: '^((\\{lang=([a-zA-Z]{2,3}|i|x)?(\\-[a-zA-Z0-9\\-]{2,8})?\\}))(.*?)$', // eslint-disable-line\n  CMILangString250cr: '^((\\{lang=([a-zA-Z]{2,3}|i|x)?(\\-[a-zA-Z0-9\\-]{2,8})?\\})?(.{0,250})?)?$', // eslint-disable-line\n  CMILangString4000: '^(\\{lang=([a-zA-Z]{2,3}|i|x)(\\-[a-zA-Z0-9\\-]{2,8})?\\})?((?!\\{.*$).{0,4000}$)?$', // eslint-disable-line\n  CMITime: '^(19[7-9]{1}[0-9]{1}|20[0-2]{1}[0-9]{1}|203[0-8]{1})((-(0[1-9]{1}|1[0-2]{1}))((-(0[1-9]{1}|[1-2]{1}[0-9]{1}|3[0-1]{1}))(T([0-1]{1}[0-9]{1}|2[0-3]{1})((:[0-5]{1}[0-9]{1})((:[0-5]{1}[0-9]{1})((\\\\.[0-9]{1,2})((Z|([+|-]([0-1]{1}[0-9]{1}|2[0-3]{1})))(:[0-5]{1}[0-9]{1})?)?)?)?)?)?)?)?$',\n  CMITimespan: '^P(?:([.,\\\\d]+)Y)?(?:([.,\\\\d]+)M)?(?:([.,\\\\d]+)W)?(?:([.,\\\\d]+)D)?(?:T?(?:([.,\\\\d]+)H)?(?:([.,\\\\d]+)M)?(?:([.,\\\\d]+)S)?)?$',\n  CMIInteger: '^\\\\d+$',\n  CMISInteger: '^-?([0-9]+)$',\n  CMIDecimal: '^-?([0-9]{1,5})(\\\\.[0-9]{1,18})?$',\n  CMIIdentifier: '^\\\\S{1,250}[a-zA-Z0-9]$',\n  CMIShortIdentifier: '^[\\\\w\\\\.\\\\-\\\\_]{1,250}$', // eslint-disable-line\n  CMILongIdentifier: '^(?:(?!urn:)\\\\S{1,4000}|urn:[A-Za-z0-9-]{1,31}:\\\\S{1,4000}|.{1,4000})$', // need to re-examine this\n  CMIFeedback: '^.*$', // This must be redefined\n  CMIIndex: '[._](\\\\d+).',\n  CMIIndexStore: '.N(\\\\d+).',\n\n  // Vocabulary Data Type Definition\n  CMICStatus: '^(completed|incomplete|not attempted|unknown)$',\n  CMISStatus: '^(passed|failed|unknown)$',\n  CMIExit: '^(time-out|suspend|logout|normal)$',\n  CMIType: '^(true-false|choice|fill-in|long-fill-in|matching|performance|sequencing|likert|numeric|other)$',\n  CMIResult: '^(correct|incorrect|unanticipated|neutral|-?([0-9]{1,4})(\\\\.[0-9]{1,18})?)$',\n  NAVEvent: '^(previous|continue|exit|exitAll|abandon|abandonAll|suspendAll|\\{target=\\\\S{0,200}[a-zA-Z0-9]\\}choice|jump)$', // eslint-disable-line\n  NAVBoolean: '^(unknown|true|false$)',\n  NAVTarget: '^(previous|continue|choice.{target=\\\\S{0,200}[a-zA-Z0-9]})$',\n\n  // Data ranges\n  scaled_range: '-1#1',\n  audio_range: '0#*',\n  speed_range: '0#*',\n  text_range: '-1#1',\n  progress_range: '0#1',\n};\n\nconst Regex = {\n  aicc: aicc,\n  scorm12: scorm12,\n  scorm2004: scorm2004,\n};\n\nexport default Regex;\n","// @flow\nimport Regex from './regex';\n\nconst scorm2004_regex = Regex.scorm2004;\n\nconst learner = {\n  'true-false': {\n    format: '^true$|^false$',\n    max: 1,\n    delimiter: '',\n    unique: false,\n  },\n  'choice': {\n    format: scorm2004_regex.CMIShortIdentifier,\n    max: 36,\n    delimiter: '[,]',\n    unique: true,\n  },\n  'fill-in': {\n    format: scorm2004_regex.CMILangString250,\n    max: 10,\n    delimiter: '[,]',\n    unique: false,\n  },\n  'long-fill-in': {\n    format: scorm2004_regex.CMILangString4000,\n    max: 1,\n    delimiter: '',\n    unique: false,\n  },\n  'matching': {\n    format: scorm2004_regex.CMIShortIdentifier,\n    format2: scorm2004_regex.CMIShortIdentifier,\n    max: 36,\n    delimiter: '[,]',\n    delimiter2: '[.]',\n    unique: false,\n  },\n  'performance': {\n    format: '^$|' + scorm2004_regex.CMIShortIdentifier,\n    format2: scorm2004_regex.CMIDecimal + '|^$|' +\n        scorm2004_regex.CMIShortIdentifier,\n    max: 250,\n    delimiter: '[,]',\n    delimiter2: '[.]',\n    unique: false,\n  },\n  'sequencing': {\n    format: scorm2004_regex.CMIShortIdentifier,\n    max: 36,\n    delimiter: '[,]',\n    unique: false,\n  },\n  'likert': {\n    format: scorm2004_regex.CMIShortIdentifier,\n    max: 1,\n    delimiter: '',\n    unique: false,\n  },\n  'numeric': {\n    format: scorm2004_regex.CMIDecimal,\n    max: 1,\n    delimiter: '',\n    unique: false,\n  },\n  'other': {\n    format: scorm2004_regex.CMIString4000,\n    max: 1,\n    delimiter: '',\n    unique: false,\n  },\n};\n\nconst correct = {\n  'true-false': {\n    max: 1,\n    delimiter: '',\n    unique: false,\n    duplicate: false,\n    format: '^true$|^false$',\n    limit: 1,\n  },\n  'choice': {\n    max: 36,\n    delimiter: '[,]',\n    unique: true,\n    duplicate: false,\n    format: scorm2004_regex.CMIShortIdentifier,\n  },\n  'fill-in': {\n    max: 10,\n    delimiter: '[,]',\n    unique: false,\n    duplicate: false,\n    format: scorm2004_regex.CMILangString250cr,\n  },\n  'long-fill-in': {\n    max: 1,\n    delimiter: '',\n    unique: false,\n    duplicate: true,\n    format: scorm2004_regex.CMILangString4000,\n  },\n  'matching': {\n    max: 36,\n    delimiter: '[,]',\n    delimiter2: '[.]',\n    unique: false,\n    duplicate: false,\n    format: scorm2004_regex.CMIShortIdentifier,\n    format2: scorm2004_regex.CMIShortIdentifier,\n  },\n  'performance': {\n    max: 250,\n    delimiter: '[,]',\n    delimiter2: '[.]',\n    unique: false,\n    duplicate: false,\n    format: '^$|' + scorm2004_regex.CMIShortIdentifier,\n    format2: scorm2004_regex.CMIDecimal + '|^$|' +\n        scorm2004_regex.CMIShortIdentifier,\n  },\n  'sequencing': {\n    max: 36,\n    delimiter: '[,]',\n    unique: false,\n    duplicate: false,\n    format: scorm2004_regex.CMIShortIdentifier,\n  },\n  'likert': {\n    max: 1,\n    delimiter: '',\n    unique: false,\n    duplicate: false,\n    format: scorm2004_regex.CMIShortIdentifier,\n    limit: 1,\n  },\n  'numeric': {\n    max: 2,\n    delimiter: '[:]',\n    unique: false,\n    duplicate: false,\n    format: scorm2004_regex.CMIDecimal,\n    limit: 1,\n  },\n  'other': {\n    max: 1,\n    delimiter: '',\n    unique: false,\n    duplicate: false,\n    format: scorm2004_regex.CMIString4000,\n    limit: 1,\n  },\n};\n\nconst Responses = {\n  learner: learner,\n  correct: correct,\n};\n\nexport default Responses;\n","// @flow\n\nimport APIConstants from './constants/api_constants';\n\nconst scorm12_errors = APIConstants.scorm12.error_descriptions;\nconst aicc_errors = APIConstants.aicc.error_descriptions;\nconst scorm2004_errors = APIConstants.scorm2004.error_descriptions;\n\n/**\n * Base Validation Exception\n */\nexport class ValidationError extends Error {\n  /**\n   * Constructor to take in an error message and code\n   * @param {number} errorCode\n   * @param {string} errorMessage\n   * @param {string} detailedMessage\n   */\n  constructor(errorCode: number, errorMessage: String, detailedMessage: String) {\n    super(errorMessage);\n    this.#errorCode = errorCode;\n    this.#errorMessage = errorMessage;\n    this.#detailedMessage = detailedMessage;\n  }\n\n  #errorCode;\n  #errorMessage;\n  #detailedMessage;\n\n  /**\n   * Getter for #errorCode\n   * @return {number}\n   */\n  get errorCode() {\n    return this.#errorCode;\n  }\n\n  /**\n   * Getter for #errorMessage\n   * @return {string}\n   */\n  get errorMessage() {\n    return this.#errorMessage;\n  }\n\n  /**\n   * Getter for #detailedMessage\n   * @return {string}\n   */\n  get detailedMessage() {\n    return this.#detailedMessage;\n  }\n}\n\n/**\n * SCORM 1.2 Validation Error\n */\nexport class Scorm12ValidationError extends ValidationError {\n  /**\n   * Constructor to take in an error code\n   * @param {number} errorCode\n   */\n  constructor(errorCode: number) {\n    if ({}.hasOwnProperty.call(scorm12_errors, String(errorCode))) {\n      super(errorCode, scorm12_errors[String(errorCode)].basicMessage, scorm12_errors[String(errorCode)].detailMessage);\n    } else {\n      super(101, scorm12_errors['101'].basicMessage, scorm12_errors['101'].detailMessage);\n    }\n  }\n}\n\n/**\n * AICC Validation Error\n */\nexport class AICCValidationError extends ValidationError {\n  /**\n   * Constructor to take in an error code\n   * @param {number} errorCode\n   */\n  constructor(errorCode: number) {\n    if ({}.hasOwnProperty.call(aicc_errors, String(errorCode))) {\n      super(errorCode, aicc_errors[String(errorCode)].basicMessage, aicc_errors[String(errorCode)].detailMessage);\n    } else {\n      super(101, aicc_errors['101'].basicMessage, aicc_errors['101'].detailMessage);\n    }\n  }\n}\n\n/**\n * SCORM 2004 Validation Error\n */\nexport class Scorm2004ValidationError extends ValidationError {\n  /**\n   * Constructor to take in an error code\n   * @param {number} errorCode\n   */\n  constructor(errorCode: number) {\n    if ({}.hasOwnProperty.call(scorm2004_errors, String(errorCode))) {\n      super(errorCode, scorm2004_errors[String(errorCode)].basicMessage, scorm2004_errors[String(errorCode)].detailMessage);\n    } else {\n      super(101, scorm2004_errors['101'].basicMessage, scorm2004_errors['101'].detailMessage);\n    }\n  }\n}\n","import Scorm2004API from '../Scorm2004API';\n\nwindow.Scorm2004API = Scorm2004API;\n","// @flow\nexport const SECONDS_PER_SECOND = 1.0;\nexport const SECONDS_PER_MINUTE = 60;\nexport const SECONDS_PER_HOUR = 60 * SECONDS_PER_MINUTE;\nexport const SECONDS_PER_DAY = 24 * SECONDS_PER_HOUR;\n\nconst designations = [\n  ['D', SECONDS_PER_DAY],\n  ['H', SECONDS_PER_HOUR],\n  ['M', SECONDS_PER_MINUTE],\n  ['S', SECONDS_PER_SECOND],\n];\n\n/**\n * Converts a Number to a String of HH:MM:SS\n *\n * @param {Number} totalSeconds\n * @return {string}\n */\nexport function getSecondsAsHHMMSS(totalSeconds: Number) {\n  // SCORM spec does not deal with negative durations, give zero back\n  if (!totalSeconds || totalSeconds <= 0) {\n    return '00:00:00';\n  }\n\n  const hours = Math.floor(totalSeconds / SECONDS_PER_HOUR);\n\n  const dateObj = new Date(totalSeconds * 1000);\n  const minutes = dateObj.getUTCMinutes();\n  // make sure we add any possible decimal value\n  const seconds = dateObj.getSeconds();\n  const ms = totalSeconds % 1.0;\n  let msStr = '';\n  if (countDecimals(ms) > 0) {\n    if (countDecimals(ms) > 2) {\n      msStr = ms.toFixed(2);\n    } else {\n      msStr = String(ms);\n    }\n    msStr = '.' + msStr.split('.')[1];\n  }\n\n  return (hours + ':' + minutes + ':' + seconds).replace(/\\b\\d\\b/g,\n      '0$&') + msStr;\n}\n\n/**\n * Calculate the number of seconds from ISO 8601 Duration\n *\n * @param {Number} seconds\n * @return {String}\n */\nexport function getSecondsAsISODuration(seconds: Number) {\n  // SCORM spec does not deal with negative durations, give zero back\n  if (!seconds || seconds <= 0) {\n    return 'PT0S';\n  }\n\n  let duration = 'P';\n  let remainder = seconds;\n\n  designations.forEach(([sign, current_seconds]) => {\n    let value = Math.floor(remainder / current_seconds);\n\n    remainder = remainder % current_seconds;\n    if (countDecimals(remainder) > 2) {\n      remainder = Number(Number(remainder).toFixed(2));\n    }\n    // If we have anything left in the remainder, and we're currently adding\n    // seconds to the duration, go ahead and add the decimal to the seconds\n    if (sign === 'S' && remainder > 0) {\n      value += remainder;\n    }\n\n    if (value) {\n      if ((duration.indexOf('D') > 0 ||\n          sign === 'H' || sign === 'M' || sign === 'S') &&\n          duration.indexOf('T') === -1) {\n        duration += 'T';\n      }\n      duration += `${value}${sign}`;\n    }\n  });\n\n  return duration;\n}\n\n/**\n * Calculate the number of seconds from HH:MM:SS.DDDDDD\n *\n * @param {string} timeString\n * @param {RegExp} timeRegex\n * @return {number}\n */\nexport function getTimeAsSeconds(timeString: String, timeRegex: RegExp) {\n  if (!timeString || typeof timeString !== 'string' ||\n      !timeString.match(timeRegex)) {\n    return 0;\n  }\n  const parts = timeString.split(':');\n  const hours = Number(parts[0]);\n  const minutes = Number(parts[1]);\n  const seconds = Number(parts[2]);\n  return (hours * 3600) + (minutes * 60) + seconds;\n}\n\n/**\n * Calculate the number of seconds from ISO 8601 Duration\n *\n * @param {string} duration\n * @param {RegExp} durationRegex\n * @return {number}\n */\nexport function getDurationAsSeconds(duration: String, durationRegex: RegExp) {\n  if (!duration || !duration.match(durationRegex)) {\n    return 0;\n  }\n\n  const [, years, months, , days, hours, minutes, seconds] = new RegExp(\n      durationRegex).exec(duration) || [];\n\n  let result = 0.0;\n\n  result += (Number(seconds) * 1.0 || 0.0);\n  result += (Number(minutes) * 60.0 || 0.0);\n  result += (Number(hours) * 3600.0 || 0.0);\n  result += (Number(days) * (60 * 60 * 24.0) || 0.0);\n  result += (Number(years) * (60 * 60 * 24 * 365.0) || 0.0);\n\n  return result;\n}\n\n/**\n * Adds together two ISO8601 Duration strings\n *\n * @param {string} first\n * @param {string} second\n * @param {RegExp} durationRegex\n * @return {string}\n */\nexport function addTwoDurations(\n    first: String,\n    second: String,\n    durationRegex: RegExp) {\n  return getSecondsAsISODuration(\n      getDurationAsSeconds(first, durationRegex) +\n      getDurationAsSeconds(second, durationRegex),\n  );\n}\n\n/**\n * Add together two HH:MM:SS.DD strings\n *\n * @param {string} first\n * @param {string} second\n * @param {RegExp} timeRegex\n * @return {string}\n */\nexport function addHHMMSSTimeStrings(\n    first: String,\n    second: String,\n    timeRegex: RegExp) {\n  return getSecondsAsHHMMSS(\n      getTimeAsSeconds(first, timeRegex) +\n      getTimeAsSeconds(\n          second, timeRegex),\n  );\n}\n\n/**\n * Flatten a JSON object down to string paths for each values\n * @param {object} data\n * @return {object}\n */\nexport function flatten(data) {\n  const result = {};\n\n  /**\n   * Recurse through the object\n   * @param {*} cur\n   * @param {*} prop\n   */\n  function recurse(cur, prop) {\n    if (Object(cur) !== cur) {\n      result[prop] = cur;\n    } else if (Array.isArray(cur)) {\n      for (let i = 0, l = cur.length; i < l; i++) {\n        recurse(cur[i], prop + '[' + i + ']');\n        if (l === 0) result[prop] = [];\n      }\n    } else {\n      let isEmpty = true;\n      for (const p in cur) {\n        if ({}.hasOwnProperty.call(cur, p)) {\n          isEmpty = false;\n          recurse(cur[p], prop ? prop + '.' + p : p);\n        }\n      }\n      if (isEmpty && prop) result[prop] = {};\n    }\n  }\n\n  recurse(data, '');\n  return result;\n}\n\n/**\n * Un-flatten a flat JSON object\n * @param {object} data\n * @return {object}\n */\nexport function unflatten(data) {\n  'use strict';\n  if (Object(data) !== data || Array.isArray(data)) return data;\n  const regex = /\\.?([^.[\\]]+)|\\[(\\d+)]/g;\n  const result = {};\n  for (const p in data) {\n    if ({}.hasOwnProperty.call(data, p)) {\n      let cur = result;\n      let prop = '';\n      let m = regex.exec(p);\n      while (m) {\n        cur = cur[prop] || (cur[prop] = (m[2] ? [] : {}));\n        prop = m[2] || m[1];\n        m = regex.exec(p);\n      }\n      cur[prop] = data[p];\n    }\n  }\n  return result[''] || result;\n}\n\n/**\n * Counts the number of decimal places\n * @param {number} num\n * @return {number}\n */\nexport function countDecimals(num: number) {\n  if (Math.floor(num) === num || String(num).indexOf('.') < 0) return 0;\n  const parts = num.toString().split('.')[1];\n  return parts.length || 0;\n}\n"]} diff --git a/dist/scorm2004.min.js b/dist/scorm2004.min.js new file mode 100644 index 0000000..a5bc5c9 --- /dev/null +++ b/dist/scorm2004.min.js @@ -0,0 +1,6884 @@ +(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i + * Build: `lodash modularize exports="npm" -o ./` + * Copyright jQuery Foundation and other contributors + * Released under MIT license + * Based on Underscore.js 1.8.3 + * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + */ + +/** Used as the `TypeError` message for "Functions" methods. */ +var FUNC_ERROR_TEXT = 'Expected a function'; + +/** Used as references for various `Number` constants. */ +var NAN = 0 / 0; + +/** `Object#toString` result references. */ +var symbolTag = '[object Symbol]'; + +/** Used to match leading and trailing whitespace. */ +var reTrim = /^\s+|\s+$/g; + +/** Used to detect bad signed hexadecimal string values. */ +var reIsBadHex = /^[-+]0x[0-9a-f]+$/i; + +/** Used to detect binary string values. */ +var reIsBinary = /^0b[01]+$/i; + +/** Used to detect octal string values. */ +var reIsOctal = /^0o[0-7]+$/i; + +/** Built-in method references without a dependency on `root`. */ +var freeParseInt = parseInt; + +/** Detect free variable `global` from Node.js. */ +var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; + +/** Detect free variable `self`. */ +var freeSelf = typeof self == 'object' && self && self.Object === Object && self; + +/** Used as a reference to the global object. */ +var root = freeGlobal || freeSelf || Function('return this')(); + +/** Used for built-in method references. */ +var objectProto = Object.prototype; + +/** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ +var objectToString = objectProto.toString; + +/* Built-in method references for those with the same name as other `lodash` methods. */ +var nativeMax = Math.max, + nativeMin = Math.min; + +/** + * Gets the timestamp of the number of milliseconds that have elapsed since + * the Unix epoch (1 January 1970 00:00:00 UTC). + * + * @static + * @memberOf _ + * @since 2.4.0 + * @category Date + * @returns {number} Returns the timestamp. + * @example + * + * _.defer(function(stamp) { + * console.log(_.now() - stamp); + * }, _.now()); + * // => Logs the number of milliseconds it took for the deferred invocation. + */ +var now = function() { + return root.Date.now(); +}; + +/** + * Creates a debounced function that delays invoking `func` until after `wait` + * milliseconds have elapsed since the last time the debounced function was + * invoked. The debounced function comes with a `cancel` method to cancel + * delayed `func` invocations and a `flush` method to immediately invoke them. + * Provide `options` to indicate whether `func` should be invoked on the + * leading and/or trailing edge of the `wait` timeout. The `func` is invoked + * with the last arguments provided to the debounced function. Subsequent + * calls to the debounced function return the result of the last `func` + * invocation. + * + * **Note:** If `leading` and `trailing` options are `true`, `func` is + * invoked on the trailing edge of the timeout only if the debounced function + * is invoked more than once during the `wait` timeout. + * + * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred + * until to the next tick, similar to `setTimeout` with a timeout of `0`. + * + * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) + * for details over the differences between `_.debounce` and `_.throttle`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to debounce. + * @param {number} [wait=0] The number of milliseconds to delay. + * @param {Object} [options={}] The options object. + * @param {boolean} [options.leading=false] + * Specify invoking on the leading edge of the timeout. + * @param {number} [options.maxWait] + * The maximum time `func` is allowed to be delayed before it's invoked. + * @param {boolean} [options.trailing=true] + * Specify invoking on the trailing edge of the timeout. + * @returns {Function} Returns the new debounced function. + * @example + * + * // Avoid costly calculations while the window size is in flux. + * jQuery(window).on('resize', _.debounce(calculateLayout, 150)); + * + * // Invoke `sendMail` when clicked, debouncing subsequent calls. + * jQuery(element).on('click', _.debounce(sendMail, 300, { + * 'leading': true, + * 'trailing': false + * })); + * + * // Ensure `batchLog` is invoked once after 1 second of debounced calls. + * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 }); + * var source = new EventSource('/stream'); + * jQuery(source).on('message', debounced); + * + * // Cancel the trailing debounced invocation. + * jQuery(window).on('popstate', debounced.cancel); + */ +function debounce(func, wait, options) { + var lastArgs, + lastThis, + maxWait, + result, + timerId, + lastCallTime, + lastInvokeTime = 0, + leading = false, + maxing = false, + trailing = true; + + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + wait = toNumber(wait) || 0; + if (isObject(options)) { + leading = !!options.leading; + maxing = 'maxWait' in options; + maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait; + trailing = 'trailing' in options ? !!options.trailing : trailing; + } + + function invokeFunc(time) { + var args = lastArgs, + thisArg = lastThis; + + lastArgs = lastThis = undefined; + lastInvokeTime = time; + result = func.apply(thisArg, args); + return result; + } + + function leadingEdge(time) { + // Reset any `maxWait` timer. + lastInvokeTime = time; + // Start the timer for the trailing edge. + timerId = setTimeout(timerExpired, wait); + // Invoke the leading edge. + return leading ? invokeFunc(time) : result; + } + + function remainingWait(time) { + var timeSinceLastCall = time - lastCallTime, + timeSinceLastInvoke = time - lastInvokeTime, + result = wait - timeSinceLastCall; + + return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result; + } + + function shouldInvoke(time) { + var timeSinceLastCall = time - lastCallTime, + timeSinceLastInvoke = time - lastInvokeTime; + + // Either this is the first call, activity has stopped and we're at the + // trailing edge, the system time has gone backwards and we're treating + // it as the trailing edge, or we've hit the `maxWait` limit. + return (lastCallTime === undefined || (timeSinceLastCall >= wait) || + (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait)); + } + + function timerExpired() { + var time = now(); + if (shouldInvoke(time)) { + return trailingEdge(time); + } + // Restart the timer. + timerId = setTimeout(timerExpired, remainingWait(time)); + } + + function trailingEdge(time) { + timerId = undefined; + + // Only invoke if we have `lastArgs` which means `func` has been + // debounced at least once. + if (trailing && lastArgs) { + return invokeFunc(time); + } + lastArgs = lastThis = undefined; + return result; + } + + function cancel() { + if (timerId !== undefined) { + clearTimeout(timerId); + } + lastInvokeTime = 0; + lastArgs = lastCallTime = lastThis = timerId = undefined; + } + + function flush() { + return timerId === undefined ? result : trailingEdge(now()); + } + + function debounced() { + var time = now(), + isInvoking = shouldInvoke(time); + + lastArgs = arguments; + lastThis = this; + lastCallTime = time; + + if (isInvoking) { + if (timerId === undefined) { + return leadingEdge(lastCallTime); + } + if (maxing) { + // Handle invocations in a tight loop. + timerId = setTimeout(timerExpired, wait); + return invokeFunc(lastCallTime); + } + } + if (timerId === undefined) { + timerId = setTimeout(timerExpired, wait); + } + return result; + } + debounced.cancel = cancel; + debounced.flush = flush; + return debounced; +} + +/** + * Checks if `value` is the + * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) + * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an object, else `false`. + * @example + * + * _.isObject({}); + * // => true + * + * _.isObject([1, 2, 3]); + * // => true + * + * _.isObject(_.noop); + * // => true + * + * _.isObject(null); + * // => false + */ +function isObject(value) { + var type = typeof value; + return !!value && (type == 'object' || type == 'function'); +} + +/** + * Checks if `value` is object-like. A value is object-like if it's not `null` + * and has a `typeof` result of "object". + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is object-like, else `false`. + * @example + * + * _.isObjectLike({}); + * // => true + * + * _.isObjectLike([1, 2, 3]); + * // => true + * + * _.isObjectLike(_.noop); + * // => false + * + * _.isObjectLike(null); + * // => false + */ +function isObjectLike(value) { + return !!value && typeof value == 'object'; +} + +/** + * Checks if `value` is classified as a `Symbol` primitive or object. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. + * @example + * + * _.isSymbol(Symbol.iterator); + * // => true + * + * _.isSymbol('abc'); + * // => false + */ +function isSymbol(value) { + return typeof value == 'symbol' || + (isObjectLike(value) && objectToString.call(value) == symbolTag); +} + +/** + * Converts `value` to a number. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to process. + * @returns {number} Returns the number. + * @example + * + * _.toNumber(3.2); + * // => 3.2 + * + * _.toNumber(Number.MIN_VALUE); + * // => 5e-324 + * + * _.toNumber(Infinity); + * // => Infinity + * + * _.toNumber('3.2'); + * // => 3.2 + */ +function toNumber(value) { + if (typeof value == 'number') { + return value; + } + if (isSymbol(value)) { + return NAN; + } + if (isObject(value)) { + var other = typeof value.valueOf == 'function' ? value.valueOf() : value; + value = isObject(other) ? (other + '') : other; + } + if (typeof value != 'string') { + return value === 0 ? value : +value; + } + value = value.replace(reTrim, ''); + var isBinary = reIsBinary.test(value); + return (isBinary || reIsOctal.test(value)) + ? freeParseInt(value.slice(2), isBinary ? 2 : 8) + : (reIsBadHex.test(value) ? NAN : +value); +} + +module.exports = debounce; + +}).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +},{}],2:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +var _common = require("./cmi/common"); + +var _exceptions = require("./exceptions"); + +var _error_codes2 = _interopRequireDefault(require("./constants/error_codes")); + +var _api_constants = _interopRequireDefault(require("./constants/api_constants")); + +var _utilities = require("./utilities"); + +var _lodash = _interopRequireDefault(require("lodash.debounce")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); } + +function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } + +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit(arr, i) { var _i = arr && (typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]); if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); } + +function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; } + +function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); } + +function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } } + +var global_constants = _api_constants["default"].global; +var scorm12_error_codes = _error_codes2["default"].scorm12; +/** + * Base API class for AICC, SCORM 1.2, and SCORM 2004. Should be considered + * abstract, and never initialized on it's own. + */ + +var _timeout = new WeakMap(); + +var _error_codes = new WeakMap(); + +var _settings = new WeakMap(); + +var BaseAPI = /*#__PURE__*/function () { + /** + * Constructor for Base API class. Sets some shared API fields, as well as + * sets up options for the API. + * @param {object} error_codes + * @param {object} settings + */ + function BaseAPI(error_codes, settings) { + _classCallCheck(this, BaseAPI); + + _timeout.set(this, { + writable: true, + value: void 0 + }); + + _error_codes.set(this, { + writable: true, + value: void 0 + }); + + _settings.set(this, { + writable: true, + value: { + autocommit: false, + autocommitSeconds: 10, + asyncCommit: false, + sendBeaconCommit: false, + lmsCommitUrl: false, + dataCommitFormat: 'json', + // valid formats are 'json' or 'flattened', 'params' + commitRequestDataType: 'application/json;charset=UTF-8', + autoProgress: false, + logLevel: global_constants.LOG_LEVEL_ERROR, + selfReportSessionTime: false, + alwaysSendTotalTime: false, + strict_errors: true, + responseHandler: function responseHandler(xhr) { + var result; + + if (typeof xhr !== 'undefined') { + result = JSON.parse(xhr.responseText); + + if (result === null || !{}.hasOwnProperty.call(result, 'result')) { + result = {}; + + if (xhr.status === 200) { + result.result = global_constants.SCORM_TRUE; + result.errorCode = 0; + } else { + result.result = global_constants.SCORM_FALSE; + result.errorCode = 101; + } + } + } + + return result; + } + } + }); + + _defineProperty(this, "cmi", void 0); + + _defineProperty(this, "startingData", void 0); + + if ((this instanceof BaseAPI ? this.constructor : void 0) === BaseAPI) { + throw new TypeError('Cannot construct BaseAPI instances directly'); + } + + this.currentState = global_constants.STATE_NOT_INITIALIZED; + this.lastErrorCode = 0; + this.listenerArray = []; + + _classPrivateFieldSet(this, _timeout, null); + + _classPrivateFieldSet(this, _error_codes, error_codes); + + this.settings = settings; + this.apiLogLevel = this.settings.logLevel; + this.selfReportSessionTime = this.settings.selfReportSessionTime; + } + /** + * Initialize the API + * @param {string} callbackName + * @param {string} initializeMessage + * @param {string} terminationMessage + * @return {string} + */ + + + _createClass(BaseAPI, [{ + key: "initialize", + value: function initialize(callbackName, initializeMessage, terminationMessage) { + var returnValue = global_constants.SCORM_FALSE; + + if (this.isInitialized()) { + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).INITIALIZED, initializeMessage); + } else if (this.isTerminated()) { + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).TERMINATED, terminationMessage); + } else { + if (this.selfReportSessionTime) { + this.cmi.setStartTime(); + } + + this.currentState = global_constants.STATE_INITIALIZED; + this.lastErrorCode = 0; + returnValue = global_constants.SCORM_TRUE; + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Getter for #error_codes + * @return {object} + */ + + }, { + key: "error_codes", + get: function get() { + return _classPrivateFieldGet(this, _error_codes); + } + /** + * Getter for #settings + * @return {object} + */ + + }, { + key: "settings", + get: function get() { + return _classPrivateFieldGet(this, _settings); + } + /** + * Setter for #settings + * @param {object} settings + */ + , + set: function set(settings) { + _classPrivateFieldSet(this, _settings, _objectSpread(_objectSpread({}, _classPrivateFieldGet(this, _settings)), settings)); + } + /** + * Terminates the current run of the API + * @param {string} callbackName + * @param {boolean} checkTerminated + * @return {string} + */ + + }, { + key: "terminate", + value: function terminate(callbackName, checkTerminated) { + var returnValue = global_constants.SCORM_FALSE; + + if (this.checkState(checkTerminated, _classPrivateFieldGet(this, _error_codes).TERMINATION_BEFORE_INIT, _classPrivateFieldGet(this, _error_codes).MULTIPLE_TERMINATION)) { + this.currentState = global_constants.STATE_TERMINATED; + var result = this.storeData(true); + + if (!this.settings.sendBeaconCommit && !this.settings.asyncCommit && typeof result.errorCode !== 'undefined' && result.errorCode > 0) { + this.throwSCORMError(result.errorCode); + } + + returnValue = typeof result !== 'undefined' && result.result ? result.result : global_constants.SCORM_FALSE; + if (checkTerminated) this.lastErrorCode = 0; + returnValue = global_constants.SCORM_TRUE; + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Get the value of the CMIElement. + * + * @param {string} callbackName + * @param {boolean} checkTerminated + * @param {string} CMIElement + * @return {string} + */ + + }, { + key: "getValue", + value: function getValue(callbackName, checkTerminated, CMIElement) { + var returnValue; + + if (this.checkState(checkTerminated, _classPrivateFieldGet(this, _error_codes).RETRIEVE_BEFORE_INIT, _classPrivateFieldGet(this, _error_codes).RETRIEVE_AFTER_TERM)) { + if (checkTerminated) this.lastErrorCode = 0; + + try { + returnValue = this.getCMIValue(CMIElement); + } catch (e) { + if (e instanceof _exceptions.ValidationError) { + this.lastErrorCode = e.errorCode; + returnValue = global_constants.SCORM_FALSE; + } else { + if (e.message) { + console.error(e.message); + } else { + console.error(e); + } + + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).GENERAL); + } + } + + this.processListeners(callbackName, CMIElement); + } + + this.apiLog(callbackName, CMIElement, ': returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Sets the value of the CMIElement. + * + * @param {string} callbackName + * @param {string} commitCallback + * @param {boolean} checkTerminated + * @param {string} CMIElement + * @param {*} value + * @return {string} + */ + + }, { + key: "setValue", + value: function setValue(callbackName, commitCallback, checkTerminated, CMIElement, value) { + if (value !== undefined) { + value = String(value); + } + + var returnValue = global_constants.SCORM_FALSE; + + if (this.checkState(checkTerminated, _classPrivateFieldGet(this, _error_codes).STORE_BEFORE_INIT, _classPrivateFieldGet(this, _error_codes).STORE_AFTER_TERM)) { + if (checkTerminated) this.lastErrorCode = 0; + + try { + returnValue = this.setCMIValue(CMIElement, value); + } catch (e) { + if (e instanceof _exceptions.ValidationError) { + this.lastErrorCode = e.errorCode; + returnValue = global_constants.SCORM_FALSE; + } else { + if (e.message) { + console.error(e.message); + } else { + console.error(e); + } + + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).GENERAL); + } + } + + this.processListeners(callbackName, CMIElement, value); + } + + if (returnValue === undefined) { + returnValue = global_constants.SCORM_FALSE; + } // If we didn't have any errors while setting the data, go ahead and + // schedule a commit, if autocommit is turned on + + + if (String(this.lastErrorCode) === '0') { + if (this.settings.autocommit && !_classPrivateFieldGet(this, _timeout)) { + this.scheduleCommit(this.settings.autocommitSeconds * 1000, commitCallback); + } + } + + this.apiLog(callbackName, CMIElement, ': ' + value + ': result: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Orders LMS to store all content parameters + * @param {string} callbackName + * @param {boolean} checkTerminated + * @return {string} + */ + + }, { + key: "commit", + value: function commit(callbackName, checkTerminated) { + this.clearScheduledCommit(); + var returnValue = global_constants.SCORM_FALSE; + + if (this.checkState(checkTerminated, _classPrivateFieldGet(this, _error_codes).COMMIT_BEFORE_INIT, _classPrivateFieldGet(this, _error_codes).COMMIT_AFTER_TERM)) { + var result = this.storeData(false); + + if (!this.settings.sendBeaconCommit && !this.settings.asyncCommit && result.errorCode && result.errorCode > 0) { + this.throwSCORMError(result.errorCode); + } + + returnValue = typeof result !== 'undefined' && result.result ? result.result : global_constants.SCORM_FALSE; + this.apiLog(callbackName, 'HttpRequest', ' Result: ' + returnValue, global_constants.LOG_LEVEL_DEBUG); + if (checkTerminated) this.lastErrorCode = 0; + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + this.clearSCORMError(returnValue); + return returnValue; + } + /** + * Returns last error code + * @param {string} callbackName + * @return {string} + */ + + }, { + key: "getLastError", + value: function getLastError(callbackName) { + var returnValue = String(this.lastErrorCode); + this.processListeners(callbackName); + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + return returnValue; + } + /** + * Returns the errorNumber error description + * + * @param {string} callbackName + * @param {(string|number)} CMIErrorCode + * @return {string} + */ + + }, { + key: "getErrorString", + value: function getErrorString(callbackName, CMIErrorCode) { + var returnValue = ''; + + if (CMIErrorCode !== null && CMIErrorCode !== '') { + returnValue = this.getLmsErrorMessageDetails(CMIErrorCode); + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + return returnValue; + } + /** + * Returns a comprehensive description of the errorNumber error. + * + * @param {string} callbackName + * @param {(string|number)} CMIErrorCode + * @return {string} + */ + + }, { + key: "getDiagnostic", + value: function getDiagnostic(callbackName, CMIErrorCode) { + var returnValue = ''; + + if (CMIErrorCode !== null && CMIErrorCode !== '') { + returnValue = this.getLmsErrorMessageDetails(CMIErrorCode, true); + this.processListeners(callbackName); + } + + this.apiLog(callbackName, null, 'returned: ' + returnValue, global_constants.LOG_LEVEL_INFO); + return returnValue; + } + /** + * Checks the LMS state and ensures it has been initialized. + * + * @param {boolean} checkTerminated + * @param {number} beforeInitError + * @param {number} afterTermError + * @return {boolean} + */ + + }, { + key: "checkState", + value: function checkState(checkTerminated, beforeInitError, afterTermError) { + if (this.isNotInitialized()) { + this.throwSCORMError(beforeInitError); + return false; + } else if (checkTerminated && this.isTerminated()) { + this.throwSCORMError(afterTermError); + return false; + } + + return true; + } + /** + * Logging for all SCORM actions + * + * @param {string} functionName + * @param {string} CMIElement + * @param {string} logMessage + * @param {number}messageLevel + */ + + }, { + key: "apiLog", + value: function apiLog(functionName, CMIElement, logMessage, messageLevel) { + logMessage = this.formatMessage(functionName, CMIElement, logMessage); + + if (messageLevel >= this.apiLogLevel) { + switch (messageLevel) { + case global_constants.LOG_LEVEL_ERROR: + console.error(logMessage); + break; + + case global_constants.LOG_LEVEL_WARNING: + console.warn(logMessage); + break; + + case global_constants.LOG_LEVEL_INFO: + console.info(logMessage); + break; + + case global_constants.LOG_LEVEL_DEBUG: + if (console.debug) { + console.debug(logMessage); + } else { + console.log(logMessage); + } + + break; + } + } + } + /** + * Formats the SCORM messages for easy reading + * + * @param {string} functionName + * @param {string} CMIElement + * @param {string} message + * @return {string} + */ + + }, { + key: "formatMessage", + value: function formatMessage(functionName, CMIElement, message) { + var baseLength = 20; + var messageString = ''; + messageString += functionName; + var fillChars = baseLength - messageString.length; + + for (var i = 0; i < fillChars; i++) { + messageString += ' '; + } + + messageString += ': '; + + if (CMIElement) { + var CMIElementBaseLength = 70; + messageString += CMIElement; + fillChars = CMIElementBaseLength - messageString.length; + + for (var j = 0; j < fillChars; j++) { + messageString += ' '; + } + } + + if (message) { + messageString += message; + } + + return messageString; + } + /** + * Checks to see if {str} contains {tester} + * + * @param {string} str String to check against + * @param {string} tester String to check for + * @return {boolean} + */ + + }, { + key: "stringMatches", + value: function stringMatches(str, tester) { + return str && tester && str.match(tester); + } + /** + * Check to see if the specific object has the given property + * @param {*} refObject + * @param {string} attribute + * @return {boolean} + * @private + */ + + }, { + key: "_checkObjectHasProperty", + value: function _checkObjectHasProperty(refObject, attribute) { + return Object.hasOwnProperty.call(refObject, attribute) || Object.getOwnPropertyDescriptor(Object.getPrototypeOf(refObject), attribute) || attribute in refObject; + } + /** + * Returns the message that corresponds to errorNumber + * APIs that inherit BaseAPI should override this function + * + * @param {(string|number)} _errorNumber + * @param {boolean} _detail + * @return {string} + * @abstract + */ + + }, { + key: "getLmsErrorMessageDetails", + value: function getLmsErrorMessageDetails(_errorNumber, _detail) { + throw new Error('The getLmsErrorMessageDetails method has not been implemented'); + } + /** + * Gets the value for the specific element. + * APIs that inherit BaseAPI should override this function + * + * @param {string} _CMIElement + * @return {string} + * @abstract + */ + + }, { + key: "getCMIValue", + value: function getCMIValue(_CMIElement) { + throw new Error('The getCMIValue method has not been implemented'); + } + /** + * Sets the value for the specific element. + * APIs that inherit BaseAPI should override this function + * + * @param {string} _CMIElement + * @param {any} _value + * @return {string} + * @abstract + */ + + }, { + key: "setCMIValue", + value: function setCMIValue(_CMIElement, _value) { + throw new Error('The setCMIValue method has not been implemented'); + } + /** + * Shared API method to set a valid for a given element. + * + * @param {string} methodName + * @param {boolean} scorm2004 + * @param {string} CMIElement + * @param {*} value + * @return {string} + */ + + }, { + key: "_commonSetCMIValue", + value: function _commonSetCMIValue(methodName, scorm2004, CMIElement, value) { + if (!CMIElement || CMIElement === '') { + return global_constants.SCORM_FALSE; + } + + var structure = CMIElement.split('.'); + var refObject = this; + var returnValue = global_constants.SCORM_FALSE; + var foundFirstIndex = false; + var invalidErrorMessage = "The data model element passed to ".concat(methodName, " (").concat(CMIElement, ") is not a valid SCORM data model element."); + var invalidErrorCode = scorm2004 ? _classPrivateFieldGet(this, _error_codes).UNDEFINED_DATA_MODEL : _classPrivateFieldGet(this, _error_codes).GENERAL; + + for (var i = 0; i < structure.length; i++) { + var attribute = structure[i]; + + if (i === structure.length - 1) { + if (scorm2004 && attribute.substr(0, 8) === '{target=' && typeof refObject._isTargetValid == 'function') { + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).READ_ONLY_ELEMENT); + } else if (!this._checkObjectHasProperty(refObject, attribute)) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + } else { + if (this.isInitialized() && this.stringMatches(CMIElement, '\\.correct_responses\\.\\d+')) { + this.validateCorrectResponse(CMIElement, value); + } + + if (!scorm2004 || this.lastErrorCode === 0) { + refObject[attribute] = value; + returnValue = global_constants.SCORM_TRUE; + } + } + } else { + refObject = refObject[attribute]; + + if (!refObject) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + break; + } + + if (refObject instanceof _common.CMIArray) { + var index = parseInt(structure[i + 1], 10); // SCO is trying to set an item on an array + + if (!isNaN(index)) { + var item = refObject.childArray[index]; + + if (item) { + refObject = item; + foundFirstIndex = true; + } else { + var newChild = this.getChildElement(CMIElement, value, foundFirstIndex); + foundFirstIndex = true; + + if (!newChild) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + } else { + if (refObject.initialized) newChild.initialize(); + refObject.childArray.push(newChild); + refObject = newChild; + } + } // Have to update i value to skip the array position + + + i++; + } + } + } + } + + if (returnValue === global_constants.SCORM_FALSE) { + this.apiLog(methodName, null, "There was an error setting the value for: ".concat(CMIElement, ", value of: ").concat(value), global_constants.LOG_LEVEL_WARNING); + } + + return returnValue; + } + /** + * Abstract method for validating that a response is correct. + * + * @param {string} _CMIElement + * @param {*} _value + */ + + }, { + key: "validateCorrectResponse", + value: function validateCorrectResponse(_CMIElement, _value) {// just a stub method + } + /** + * Gets or builds a new child element to add to the array. + * APIs that inherit BaseAPI should override this method. + * + * @param {string} _CMIElement - unused + * @param {*} _value - unused + * @param {boolean} _foundFirstIndex - unused + * @return {*} + * @abstract + */ + + }, { + key: "getChildElement", + value: function getChildElement(_CMIElement, _value, _foundFirstIndex) { + throw new Error('The getChildElement method has not been implemented'); + } + /** + * Gets a value from the CMI Object + * + * @param {string} methodName + * @param {boolean} scorm2004 + * @param {string} CMIElement + * @return {*} + */ + + }, { + key: "_commonGetCMIValue", + value: function _commonGetCMIValue(methodName, scorm2004, CMIElement) { + if (!CMIElement || CMIElement === '') { + return ''; + } + + var structure = CMIElement.split('.'); + var refObject = this; + var attribute = null; + var uninitializedErrorMessage = "The data model element passed to ".concat(methodName, " (").concat(CMIElement, ") has not been initialized."); + var invalidErrorMessage = "The data model element passed to ".concat(methodName, " (").concat(CMIElement, ") is not a valid SCORM data model element."); + var invalidErrorCode = scorm2004 ? _classPrivateFieldGet(this, _error_codes).UNDEFINED_DATA_MODEL : _classPrivateFieldGet(this, _error_codes).GENERAL; + + for (var i = 0; i < structure.length; i++) { + attribute = structure[i]; + + if (!scorm2004) { + if (i === structure.length - 1) { + if (!this._checkObjectHasProperty(refObject, attribute)) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + return; + } + } + } else { + if (String(attribute).substr(0, 8) === '{target=' && typeof refObject._isTargetValid == 'function') { + var target = String(attribute).substr(8, String(attribute).length - 9); + return refObject._isTargetValid(target); + } else if (!this._checkObjectHasProperty(refObject, attribute)) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + return; + } + } + + refObject = refObject[attribute]; + + if (refObject === undefined) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + break; + } + + if (refObject instanceof _common.CMIArray) { + var index = parseInt(structure[i + 1], 10); // SCO is trying to set an item on an array + + if (!isNaN(index)) { + var item = refObject.childArray[index]; + + if (item) { + refObject = item; + } else { + this.throwSCORMError(_classPrivateFieldGet(this, _error_codes).VALUE_NOT_INITIALIZED, uninitializedErrorMessage); + break; + } // Have to update i value to skip the array position + + + i++; + } + } + } + + if (refObject === null || refObject === undefined) { + if (!scorm2004) { + if (attribute === '_children') { + this.throwSCORMError(scorm12_error_codes.CHILDREN_ERROR); + } else if (attribute === '_count') { + this.throwSCORMError(scorm12_error_codes.COUNT_ERROR); + } + } + } else { + return refObject; + } + } + /** + * Returns true if the API's current state is STATE_INITIALIZED + * + * @return {boolean} + */ + + }, { + key: "isInitialized", + value: function isInitialized() { + return this.currentState === global_constants.STATE_INITIALIZED; + } + /** + * Returns true if the API's current state is STATE_NOT_INITIALIZED + * + * @return {boolean} + */ + + }, { + key: "isNotInitialized", + value: function isNotInitialized() { + return this.currentState === global_constants.STATE_NOT_INITIALIZED; + } + /** + * Returns true if the API's current state is STATE_TERMINATED + * + * @return {boolean} + */ + + }, { + key: "isTerminated", + value: function isTerminated() { + return this.currentState === global_constants.STATE_TERMINATED; + } + /** + * Provides a mechanism for attaching to a specific SCORM event + * + * @param {string} listenerName + * @param {function} callback + */ + + }, { + key: "on", + value: function on(listenerName, callback) { + if (!callback) return; + var listenerFunctions = listenerName.split(' '); + + for (var i = 0; i < listenerFunctions.length; i++) { + var listenerSplit = listenerFunctions[i].split('.'); + if (listenerSplit.length === 0) return; + var functionName = listenerSplit[0]; + var CMIElement = null; + + if (listenerSplit.length > 1) { + CMIElement = listenerName.replace(functionName + '.', ''); + } + + this.listenerArray.push({ + functionName: functionName, + CMIElement: CMIElement, + callback: callback + }); + this.apiLog('on', functionName, "Added event listener: ".concat(this.listenerArray.length), global_constants.LOG_LEVEL_INFO); + } + } + /** + * Provides a mechanism for detaching a specific SCORM event listener + * + * @param {string} listenerName + * @param {function} callback + */ + + }, { + key: "off", + value: function off(listenerName, callback) { + var _this = this; + + if (!callback) return; + var listenerFunctions = listenerName.split(' '); + + var _loop = function _loop(i) { + var listenerSplit = listenerFunctions[i].split('.'); + if (listenerSplit.length === 0) return { + v: void 0 + }; + var functionName = listenerSplit[0]; + var CMIElement = null; + + if (listenerSplit.length > 1) { + CMIElement = listenerName.replace(functionName + '.', ''); + } + + var removeIndex = _this.listenerArray.findIndex(function (obj) { + return obj.functionName === functionName && obj.CMIElement === CMIElement && obj.callback === callback; + }); + + if (removeIndex !== -1) { + _this.listenerArray.splice(removeIndex, 1); + + _this.apiLog('off', functionName, "Removed event listener: ".concat(_this.listenerArray.length), global_constants.LOG_LEVEL_INFO); + } + }; + + for (var i = 0; i < listenerFunctions.length; i++) { + var _ret = _loop(i); + + if (_typeof(_ret) === "object") return _ret.v; + } + } + /** + * Provides a mechanism for clearing all listeners from a specific SCORM event + * + * @param {string} listenerName + */ + + }, { + key: "clear", + value: function clear(listenerName) { + var _this2 = this; + + var listenerFunctions = listenerName.split(' '); + + var _loop2 = function _loop2(i) { + var listenerSplit = listenerFunctions[i].split('.'); + if (listenerSplit.length === 0) return { + v: void 0 + }; + var functionName = listenerSplit[0]; + var CMIElement = null; + + if (listenerSplit.length > 1) { + CMIElement = listenerName.replace(functionName + '.', ''); + } + + _this2.listenerArray = _this2.listenerArray.filter(function (obj) { + return obj.functionName !== functionName && obj.CMIElement !== CMIElement; + }); + }; + + for (var i = 0; i < listenerFunctions.length; i++) { + var _ret2 = _loop2(i); + + if (_typeof(_ret2) === "object") return _ret2.v; + } + } + /** + * Processes any 'on' listeners that have been created + * + * @param {string} functionName + * @param {string} CMIElement + * @param {*} value + */ + + }, { + key: "processListeners", + value: function processListeners(functionName, CMIElement, value) { + this.apiLog(functionName, CMIElement, value); + + for (var i = 0; i < this.listenerArray.length; i++) { + var listener = this.listenerArray[i]; + var functionsMatch = listener.functionName === functionName; + var listenerHasCMIElement = !!listener.CMIElement; + var CMIElementsMatch = false; + + if (CMIElement && listener.CMIElement && listener.CMIElement.substring(listener.CMIElement.length - 1) === '*') { + CMIElementsMatch = CMIElement.indexOf(listener.CMIElement.substring(0, listener.CMIElement.length - 1)) === 0; + } else { + CMIElementsMatch = listener.CMIElement === CMIElement; + } + + if (functionsMatch && (!listenerHasCMIElement || CMIElementsMatch)) { + listener.callback(CMIElement, value); + } + } + } + /** + * Throws a SCORM error + * + * @param {number} errorNumber + * @param {string} message + */ + + }, { + key: "throwSCORMError", + value: function throwSCORMError(errorNumber, message) { + if (!message) { + message = this.getLmsErrorMessageDetails(errorNumber); + } + + this.apiLog('throwSCORMError', null, errorNumber + ': ' + message, global_constants.LOG_LEVEL_ERROR); + this.lastErrorCode = String(errorNumber); + } + /** + * Clears the last SCORM error code on success. + * + * @param {string} success + */ + + }, { + key: "clearSCORMError", + value: function clearSCORMError(success) { + if (success !== undefined && success !== global_constants.SCORM_FALSE) { + this.lastErrorCode = 0; + } + } + /** + * Attempts to store the data to the LMS, logs data if no LMS configured + * APIs that inherit BaseAPI should override this function + * + * @param {boolean} _calculateTotalTime + * @return {string} + * @abstract + */ + + }, { + key: "storeData", + value: function storeData(_calculateTotalTime) { + throw new Error('The storeData method has not been implemented'); + } + /** + * Load the CMI from a flattened JSON object + * @param {object} json + * @param {string} CMIElement + */ + + }, { + key: "loadFromFlattenedJSON", + value: function loadFromFlattenedJSON(json, CMIElement) { + var _this3 = this; + + if (!this.isNotInitialized()) { + console.error('loadFromFlattenedJSON can only be called before the call to lmsInitialize.'); + return; + } + /** + * Test match pattern. + * + * @param {string} a + * @param {string} c + * @param {RegExp} a_pattern + * @return {number} + */ + + + function testPattern(a, c, a_pattern) { + var a_match = a.match(a_pattern); + var c_match; + + if (a_match !== null && (c_match = c.match(a_pattern)) !== null) { + var a_num = Number(a_match[2]); + var c_num = Number(c_match[2]); + + if (a_num === c_num) { + if (a_match[3] === 'id') { + return -1; + } else if (a_match[3] === 'type') { + if (c_match[3] === 'id') { + return 1; + } else { + return -1; + } + } else { + return 1; + } + } + + return a_num - c_num; + } + + return null; + } + + var int_pattern = /^(cmi\.interactions\.)(\d+)\.(.*)$/; + var obj_pattern = /^(cmi\.objectives\.)(\d+)\.(.*)$/; + var result = Object.keys(json).map(function (key) { + return [String(key), json[key]]; + }); // CMI interactions need to have id and type loaded before any other fields + + result.sort(function (_ref, _ref2) { + var _ref3 = _slicedToArray(_ref, 2), + a = _ref3[0], + b = _ref3[1]; + + var _ref4 = _slicedToArray(_ref2, 2), + c = _ref4[0], + d = _ref4[1]; + + var test; + + if ((test = testPattern(a, c, int_pattern)) !== null) { + return test; + } + + if ((test = testPattern(a, c, obj_pattern)) !== null) { + return test; + } + + if (a < c) { + return -1; + } + + if (a > c) { + return 1; + } + + return 0; + }); + var obj; + result.forEach(function (element) { + obj = {}; + obj[element[0]] = element[1]; + + _this3.loadFromJSON((0, _utilities.unflatten)(obj), CMIElement); + }); + } + /** + * Loads CMI data from a JSON object. + * + * @param {object} json + * @param {string} CMIElement + */ + + }, { + key: "loadFromJSON", + value: function loadFromJSON(json, CMIElement) { + if (!this.isNotInitialized()) { + console.error('loadFromJSON can only be called before the call to lmsInitialize.'); + return; + } + + CMIElement = CMIElement !== undefined ? CMIElement : 'cmi'; + this.startingData = json; // could this be refactored down to flatten(json) then setCMIValue on each? + + for (var key in json) { + if ({}.hasOwnProperty.call(json, key) && json[key]) { + var currentCMIElement = (CMIElement ? CMIElement + '.' : '') + key; + var value = json[key]; + + if (value['childArray']) { + for (var i = 0; i < value['childArray'].length; i++) { + this.loadFromJSON(value['childArray'][i], currentCMIElement + '.' + i); + } + } else if (value.constructor === Object) { + this.loadFromJSON(value, currentCMIElement); + } else { + this.setCMIValue(currentCMIElement, value); + } + } + } + } + /** + * Render the CMI object to JSON for sending to an LMS. + * + * @return {string} + */ + + }, { + key: "renderCMIToJSONString", + value: function renderCMIToJSONString() { + var cmi = this.cmi; // Do we want/need to return fields that have no set value? + // return JSON.stringify({ cmi }, (k, v) => v === undefined ? null : v, 2); + + return JSON.stringify({ + cmi: cmi + }); + } + /** + * Returns a JS object representing the current cmi + * @return {object} + */ + + }, { + key: "renderCMIToJSONObject", + value: function renderCMIToJSONObject() { + // Do we want/need to return fields that have no set value? + // return JSON.stringify({ cmi }, (k, v) => v === undefined ? null : v, 2); + return JSON.parse(this.renderCMIToJSONString()); + } + /** + * Render the cmi object to the proper format for LMS commit + * APIs that inherit BaseAPI should override this function + * + * @param {boolean} _terminateCommit + * @return {*} + * @abstract + */ + + }, { + key: "renderCommitCMI", + value: function renderCommitCMI(_terminateCommit) { + throw new Error('The storeData method has not been implemented'); + } + /** + * Send the request to the LMS + * @param {string} url + * @param {object|Array} params + * @param {boolean} immediate + * @return {object} + */ + + }, { + key: "processHttpRequest", + value: function processHttpRequest(url, params) { + var immediate = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + var api = this; + + var process = function process(url, params, settings, error_codes) { + var genericError = { + 'result': global_constants.SCORM_FALSE, + 'errorCode': error_codes.GENERAL + }; + var result; + + if (!settings.sendBeaconCommit) { + var httpReq = new XMLHttpRequest(); + httpReq.open('POST', url, settings.asyncCommit); + + if (settings.asyncCommit) { + httpReq.onload = function (e) { + if (typeof settings.responseHandler === 'function') { + result = settings.responseHandler(httpReq); + } else { + result = JSON.parse(httpReq.responseText); + } + }; + } + + try { + if (params instanceof Array) { + httpReq.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded'); + httpReq.send(params.join('&')); + } else { + httpReq.setRequestHeader('Content-Type', settings.commitRequestDataType); + httpReq.send(JSON.stringify(params)); + } + + if (!settings.asyncCommit) { + if (typeof settings.responseHandler === 'function') { + result = settings.responseHandler(httpReq); + } else { + result = JSON.parse(httpReq.responseText); + } + } else { + result = {}; + result.result = global_constants.SCORM_TRUE; + result.errorCode = 0; + api.processListeners('CommitSuccess'); + return result; + } + } catch (e) { + console.error(e); + api.processListeners('CommitError'); + return genericError; + } + } else { + try { + var headers = { + type: settings.commitRequestDataType + }; + var blob; + + if (params instanceof Array) { + blob = new Blob([params.join('&')], headers); + } else { + blob = new Blob([JSON.stringify(params)], headers); + } + + result = {}; + + if (navigator.sendBeacon(url, blob)) { + result.result = global_constants.SCORM_TRUE; + result.errorCode = 0; + } else { + result.result = global_constants.SCORM_FALSE; + result.errorCode = 101; + } + } catch (e) { + console.error(e); + api.processListeners('CommitError'); + return genericError; + } + } + + if (typeof result === 'undefined') { + api.processListeners('CommitError'); + return genericError; + } + + if (result.result === true || result.result === global_constants.SCORM_TRUE) { + api.processListeners('CommitSuccess'); + } else { + api.processListeners('CommitError'); + } + + return result; + }; + + if (typeof _lodash["default"] !== 'undefined') { + var debounced = (0, _lodash["default"])(process, 500); + debounced(url, params, this.settings, this.error_codes); // if we're terminating, go ahead and commit immediately + + if (immediate) { + debounced.flush(); + } + + return { + result: global_constants.SCORM_TRUE, + errorCode: 0 + }; + } else { + return process(url, params, this.settings, this.error_codes); + } + } + /** + * Throws a SCORM error + * + * @param {number} when - the number of milliseconds to wait before committing + * @param {string} callback - the name of the commit event callback + */ + + }, { + key: "scheduleCommit", + value: function scheduleCommit(when, callback) { + _classPrivateFieldSet(this, _timeout, new ScheduledCommit(this, when, callback)); + + this.apiLog('scheduleCommit', '', 'scheduled', global_constants.LOG_LEVEL_DEBUG); + } + /** + * Clears and cancels any currently scheduled commits + */ + + }, { + key: "clearScheduledCommit", + value: function clearScheduledCommit() { + if (_classPrivateFieldGet(this, _timeout)) { + _classPrivateFieldGet(this, _timeout).cancel(); + + _classPrivateFieldSet(this, _timeout, null); + + this.apiLog('clearScheduledCommit', '', 'cleared', global_constants.LOG_LEVEL_DEBUG); + } + } + }]); + + return BaseAPI; +}(); +/** + * Private class that wraps a timeout call to the commit() function + */ + + +exports["default"] = BaseAPI; + +var _API = new WeakMap(); + +var _cancelled = new WeakMap(); + +var _timeout2 = new WeakMap(); + +var _callback = new WeakMap(); + +var ScheduledCommit = /*#__PURE__*/function () { + /** + * Constructor for ScheduledCommit + * @param {BaseAPI} API + * @param {number} when + * @param {string} callback + */ + function ScheduledCommit(API, when, callback) { + _classCallCheck(this, ScheduledCommit); + + _API.set(this, { + writable: true, + value: void 0 + }); + + _cancelled.set(this, { + writable: true, + value: false + }); + + _timeout2.set(this, { + writable: true, + value: void 0 + }); + + _callback.set(this, { + writable: true, + value: void 0 + }); + + _classPrivateFieldSet(this, _API, API); + + _classPrivateFieldSet(this, _timeout2, setTimeout(this.wrapper.bind(this), when)); + + _classPrivateFieldSet(this, _callback, callback); + } + /** + * Cancel any currently scheduled commit + */ + + + _createClass(ScheduledCommit, [{ + key: "cancel", + value: function cancel() { + _classPrivateFieldSet(this, _cancelled, true); + + if (_classPrivateFieldGet(this, _timeout2)) { + clearTimeout(_classPrivateFieldGet(this, _timeout2)); + } + } + /** + * Wrap the API commit call to check if the call has already been cancelled + */ + + }, { + key: "wrapper", + value: function wrapper() { + if (!_classPrivateFieldGet(this, _cancelled)) { + _classPrivateFieldGet(this, _API).commit(_classPrivateFieldGet(this, _callback)); + } + } + }]); + + return ScheduledCommit; +}(); + +},{"./cmi/common":4,"./constants/api_constants":6,"./constants/error_codes":7,"./exceptions":11,"./utilities":13,"lodash.debounce":1}],3:[function(require,module,exports){ +"use strict"; + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +var _BaseAPI2 = _interopRequireDefault(require("./BaseAPI")); + +var _scorm2004_cmi = require("./cmi/scorm2004_cmi"); + +var Utilities = _interopRequireWildcard(require("./utilities")); + +var _api_constants = _interopRequireDefault(require("./constants/api_constants")); + +var _error_codes = _interopRequireDefault(require("./constants/error_codes")); + +var _response_constants = _interopRequireDefault(require("./constants/response_constants")); + +var _language_constants = _interopRequireDefault(require("./constants/language_constants")); + +var _regex = _interopRequireDefault(require("./constants/regex")); + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); } + +function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); } + +function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +var scorm2004_constants = _api_constants["default"].scorm2004; +var global_constants = _api_constants["default"].global; +var scorm2004_error_codes = _error_codes["default"].scorm2004; +var correct_responses = _response_constants["default"].correct; +var scorm2004_regex = _regex["default"].scorm2004; +/** + * API class for SCORM 2004 + */ + +var _version = new WeakMap(); + +var Scorm2004API = /*#__PURE__*/function (_BaseAPI) { + _inherits(Scorm2004API, _BaseAPI); + + var _super = _createSuper(Scorm2004API); + + /** + * Constructor for SCORM 2004 API + * @param {object} settings + */ + function Scorm2004API(settings) { + var _this; + + _classCallCheck(this, Scorm2004API); + + var finalSettings = _objectSpread(_objectSpread({}, { + mastery_override: false + }), settings); + + _this = _super.call(this, scorm2004_error_codes, finalSettings); + + _version.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _defineProperty(_assertThisInitialized(_this), "checkDuplicatedPattern", function (correct_response, current_index, value) { + var found = false; + var count = correct_response._count; + + for (var i = 0; i < count && !found; i++) { + if (i !== current_index && correct_response.childArray[i] === value) { + found = true; + } + } + + return found; + }); + + _this.cmi = new _scorm2004_cmi.CMI(); + _this.adl = new _scorm2004_cmi.ADL(); // Rename functions to match 2004 Spec and expose to modules + + _this.Initialize = _this.lmsInitialize; + _this.Terminate = _this.lmsTerminate; + _this.GetValue = _this.lmsGetValue; + _this.SetValue = _this.lmsSetValue; + _this.Commit = _this.lmsCommit; + _this.GetLastError = _this.lmsGetLastError; + _this.GetErrorString = _this.lmsGetErrorString; + _this.GetDiagnostic = _this.lmsGetDiagnostic; + return _this; + } + /** + * Getter for #version + * @return {string} + */ + + + _createClass(Scorm2004API, [{ + key: "version", + get: function get() { + return _classPrivateFieldGet(this, _version); + } + /** + * @return {string} bool + */ + + }, { + key: "lmsInitialize", + value: function lmsInitialize() { + this.cmi.initialize(); + return this.initialize('Initialize'); + } + /** + * @return {string} bool + */ + + }, { + key: "lmsTerminate", + value: function lmsTerminate() { + var result = this.terminate('Terminate', true); + + if (result === global_constants.SCORM_TRUE) { + if (this.adl.nav.request !== '_none_') { + switch (this.adl.nav.request) { + case 'continue': + this.processListeners('SequenceNext'); + break; + + case 'previous': + this.processListeners('SequencePrevious'); + break; + + case 'choice': + this.processListeners('SequenceChoice'); + break; + + case 'exit': + this.processListeners('SequenceExit'); + break; + + case 'exitAll': + this.processListeners('SequenceExitAll'); + break; + + case 'abandon': + this.processListeners('SequenceAbandon'); + break; + + case 'abandonAll': + this.processListeners('SequenceAbandonAll'); + break; + } + } else if (this.settings.autoProgress) { + this.processListeners('SequenceNext'); + } + } + + return result; + } + /** + * @param {string} CMIElement + * @return {string} + */ + + }, { + key: "lmsGetValue", + value: function lmsGetValue(CMIElement) { + return this.getValue('GetValue', true, CMIElement); + } + /** + * @param {string} CMIElement + * @param {any} value + * @return {string} + */ + + }, { + key: "lmsSetValue", + value: function lmsSetValue(CMIElement, value) { + return this.setValue('SetValue', 'Commit', true, CMIElement, value); + } + /** + * Orders LMS to store all content parameters + * + * @return {string} bool + */ + + }, { + key: "lmsCommit", + value: function lmsCommit() { + return this.commit('Commit'); + } + /** + * Returns last error code + * + * @return {string} + */ + + }, { + key: "lmsGetLastError", + value: function lmsGetLastError() { + return this.getLastError('GetLastError'); + } + /** + * Returns the errorNumber error description + * + * @param {(string|number)} CMIErrorCode + * @return {string} + */ + + }, { + key: "lmsGetErrorString", + value: function lmsGetErrorString(CMIErrorCode) { + return this.getErrorString('GetErrorString', CMIErrorCode); + } + /** + * Returns a comprehensive description of the errorNumber error. + * + * @param {(string|number)} CMIErrorCode + * @return {string} + */ + + }, { + key: "lmsGetDiagnostic", + value: function lmsGetDiagnostic(CMIErrorCode) { + return this.getDiagnostic('GetDiagnostic', CMIErrorCode); + } + /** + * Sets a value on the CMI Object + * + * @param {string} CMIElement + * @param {any} value + * @return {string} + */ + + }, { + key: "setCMIValue", + value: function setCMIValue(CMIElement, value) { + return this._commonSetCMIValue('SetValue', true, CMIElement, value); + } + /** + * Gets or builds a new child element to add to the array. + * + * @param {string} CMIElement + * @param {any} value + * @param {boolean} foundFirstIndex + * @return {any} + */ + + }, { + key: "getChildElement", + value: function getChildElement(CMIElement, value, foundFirstIndex) { + var newChild; + + if (this.stringMatches(CMIElement, 'cmi\\.objectives\\.\\d+')) { + newChild = new _scorm2004_cmi.CMIObjectivesObject(); + } else if (foundFirstIndex && this.stringMatches(CMIElement, 'cmi\\.interactions\\.\\d+\\.correct_responses\\.\\d+')) { + var parts = CMIElement.split('.'); + var index = Number(parts[2]); + var interaction = this.cmi.interactions.childArray[index]; + + if (this.isInitialized()) { + if (!interaction.type) { + this.throwSCORMError(scorm2004_error_codes.DEPENDENCY_NOT_ESTABLISHED); + } else { + this.checkDuplicateChoiceResponse(interaction, value); + var response_type = correct_responses[interaction.type]; + + if (response_type) { + this.checkValidResponseType(response_type, value, interaction.type); + } else { + this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE, 'Incorrect Response Type: ' + interaction.type); + } + } + } + + if (this.lastErrorCode === 0) { + newChild = new _scorm2004_cmi.CMIInteractionsCorrectResponsesObject(); + } + } else if (foundFirstIndex && this.stringMatches(CMIElement, 'cmi\\.interactions\\.\\d+\\.objectives\\.\\d+')) { + newChild = new _scorm2004_cmi.CMIInteractionsObjectivesObject(); + } else if (!foundFirstIndex && this.stringMatches(CMIElement, 'cmi\\.interactions\\.\\d+')) { + newChild = new _scorm2004_cmi.CMIInteractionsObject(); + } else if (this.stringMatches(CMIElement, 'cmi\\.comments_from_learner\\.\\d+')) { + newChild = new _scorm2004_cmi.CMICommentsObject(); + } else if (this.stringMatches(CMIElement, 'cmi\\.comments_from_lms\\.\\d+')) { + newChild = new _scorm2004_cmi.CMICommentsObject(true); + } + + return newChild; + } + /** + * Checks for valid response types + * @param {object} response_type + * @param {any} value + * @param {string} interaction_type + */ + + }, { + key: "checkValidResponseType", + value: function checkValidResponseType(response_type, value, interaction_type) { + var nodes = []; + + if (response_type !== null && response_type !== void 0 && response_type.delimiter) { + nodes = String(value).split(response_type.delimiter); + } else { + nodes[0] = value; + } + + if (nodes.length > 0 && nodes.length <= response_type.max) { + this.checkCorrectResponseValue(interaction_type, nodes, value); + } else if (nodes.length > response_type.max) { + this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE, 'Data Model Element Pattern Too Long'); + } + } + /** + * Checks for duplicate 'choice' responses. + * @param {CMIInteractionsObject} interaction + * @param {any} value + */ + + }, { + key: "checkDuplicateChoiceResponse", + value: function checkDuplicateChoiceResponse(interaction, value) { + var interaction_count = interaction.correct_responses._count; + + if (interaction.type === 'choice') { + for (var i = 0; i < interaction_count && this.lastErrorCode === 0; i++) { + var response = interaction.correct_responses.childArray[i]; + + if (response.pattern === value) { + this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE); + } + } + } + } + /** + * Validate correct response. + * @param {string} CMIElement + * @param {*} value + */ + + }, { + key: "validateCorrectResponse", + value: function validateCorrectResponse(CMIElement, value) { + var parts = CMIElement.split('.'); + var index = Number(parts[2]); + var pattern_index = Number(parts[4]); + var interaction = this.cmi.interactions.childArray[index]; + var interaction_count = interaction.correct_responses._count; + this.checkDuplicateChoiceResponse(interaction, value); + var response_type = correct_responses[interaction.type]; + + if (typeof response_type.limit === 'undefined' || interaction_count <= response_type.limit) { + this.checkValidResponseType(response_type, value, interaction.type); + + if (this.lastErrorCode === 0 && (!response_type.duplicate || !this.checkDuplicatedPattern(interaction.correct_responses, pattern_index, value)) || this.lastErrorCode === 0 && value === '') {// do nothing, we want the inverse + } else { + if (this.lastErrorCode === 0) { + this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE, 'Data Model Element Pattern Already Exists'); + } + } + } else { + this.throwSCORMError(scorm2004_error_codes.GENERAL_SET_FAILURE, 'Data Model Element Collection Limit Reached'); + } + } + /** + * Gets a value from the CMI Object + * + * @param {string} CMIElement + * @return {*} + */ + + }, { + key: "getCMIValue", + value: function getCMIValue(CMIElement) { + return this._commonGetCMIValue('GetValue', true, CMIElement); + } + /** + * Returns the message that corresponds to errorNumber. + * + * @param {(string|number)} errorNumber + * @param {boolean} detail + * @return {string} + */ + + }, { + key: "getLmsErrorMessageDetails", + value: function getLmsErrorMessageDetails(errorNumber, detail) { + var basicMessage = ''; + var detailMessage = ''; // Set error number to string since inconsistent from modules if string or number + + errorNumber = String(errorNumber); + + if (scorm2004_constants.error_descriptions[errorNumber]) { + basicMessage = scorm2004_constants.error_descriptions[errorNumber].basicMessage; + detailMessage = scorm2004_constants.error_descriptions[errorNumber].detailMessage; + } + + return detail ? detailMessage : basicMessage; + } + /** + * Check to see if a correct_response value has been duplicated + * @param {CMIArray} correct_response + * @param {number} current_index + * @param {*} value + * @return {boolean} + */ + + }, { + key: "checkCorrectResponseValue", + value: + /** + * Checks for a valid correct_response value + * @param {string} interaction_type + * @param {Array} nodes + * @param {*} value + */ + function checkCorrectResponseValue(interaction_type, nodes, value) { + var response = correct_responses[interaction_type]; + var formatRegex = new RegExp(response.format); + + for (var i = 0; i < nodes.length && this.lastErrorCode === 0; i++) { + if (interaction_type.match('^(fill-in|long-fill-in|matching|performance|sequencing)$')) { + nodes[i] = this.removeCorrectResponsePrefixes(nodes[i]); + } + + if (response !== null && response !== void 0 && response.delimiter2) { + var values = nodes[i].split(response.delimiter2); + + if (values.length === 2) { + var matches = values[0].match(formatRegex); + + if (!matches) { + this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH); + } else { + if (!values[1].match(new RegExp(response.format2))) { + this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH); + } + } + } else { + this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH); + } + } else { + var _matches = nodes[i].match(formatRegex); + + if (!_matches && value !== '' || !_matches && interaction_type === 'true-false') { + this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH); + } else { + if (interaction_type === 'numeric' && nodes.length > 1) { + if (Number(nodes[0]) > Number(nodes[1])) { + this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH); + } + } else { + if (nodes[i] !== '' && response.unique) { + for (var j = 0; j < i && this.lastErrorCode === 0; j++) { + if (nodes[i] === nodes[j]) { + this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH); + } + } + } + } + } + } + } + } + /** + * Remove prefixes from correct_response + * @param {string} node + * @return {*} + */ + + }, { + key: "removeCorrectResponsePrefixes", + value: function removeCorrectResponsePrefixes(node) { + var seenOrder = false; + var seenCase = false; + var seenLang = false; + var prefixRegex = new RegExp('^({(lang|case_matters|order_matters)=([^}]+)})'); + var matches = node.match(prefixRegex); + var langMatches = null; + + while (matches) { + switch (matches[2]) { + case 'lang': + langMatches = node.match(scorm2004_regex.CMILangcr); + + if (langMatches) { + var lang = langMatches[3]; + + if (lang !== undefined && lang.length > 0) { + if (_language_constants["default"][lang.toLowerCase()] === undefined) { + this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH); + } + } + } + + seenLang = true; + break; + + case 'case_matters': + if (!seenLang && !seenOrder && !seenCase) { + if (matches[3] !== 'true' && matches[3] !== 'false') { + this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH); + } + } + + seenCase = true; + break; + + case 'order_matters': + if (!seenCase && !seenLang && !seenOrder) { + if (matches[3] !== 'true' && matches[3] !== 'false') { + this.throwSCORMError(scorm2004_error_codes.TYPE_MISMATCH); + } + } + + seenOrder = true; + break; + + default: + break; + } + + node = node.substr(matches[1].length); + matches = node.match(prefixRegex); + } + + return node; + } + /** + * Replace the whole API with another + * @param {Scorm2004API} newAPI + */ + + }, { + key: "replaceWithAnotherScormAPI", + value: function replaceWithAnotherScormAPI(newAPI) { + // Data Model + this.cmi = newAPI.cmi; + this.adl = newAPI.adl; + } + /** + * Render the cmi object to the proper format for LMS commit + * + * @param {boolean} terminateCommit + * @return {object|Array} + */ + + }, { + key: "renderCommitCMI", + value: function renderCommitCMI(terminateCommit) { + var cmiExport = this.renderCMIToJSONObject(); + + if (terminateCommit) { + cmiExport.cmi.total_time = this.cmi.getCurrentTotalTime(); + } + + var result = []; + var flattened = Utilities.flatten(cmiExport); + + switch (this.settings.dataCommitFormat) { + case 'flattened': + return Utilities.flatten(cmiExport); + + case 'params': + for (var item in flattened) { + if ({}.hasOwnProperty.call(flattened, item)) { + result.push("".concat(item, "=").concat(flattened[item])); + } + } + + return result; + + case 'json': + default: + return cmiExport; + } + } + /** + * Attempts to store the data to the LMS + * + * @param {boolean} terminateCommit + * @return {string} + */ + + }, { + key: "storeData", + value: function storeData(terminateCommit) { + var _this$startingData, _this$startingData$ad, _this$startingData$ad2; + + if (terminateCommit) { + if (this.cmi.mode === 'normal') { + if (this.cmi.credit === 'credit') { + if (this.cmi.completion_threshold && this.cmi.progress_measure) { + if (this.cmi.progress_measure >= this.cmi.completion_threshold) { + console.debug('Setting Completion Status: Completed'); + this.cmi.completion_status = 'completed'; + } else { + console.debug('Setting Completion Status: Incomplete'); + this.cmi.completion_status = 'incomplete'; + } + } + + if (this.cmi.scaled_passing_score && this.cmi.score.scaled) { + if (this.cmi.score.scaled >= this.cmi.scaled_passing_score) { + console.debug('Setting Success Status: Passed'); + this.cmi.success_status = 'passed'; + } else { + console.debug('Setting Success Status: Failed'); + this.cmi.success_status = 'failed'; + } + } + } + } + } + + var navRequest = false; + + if (this.adl.nav.request !== ((_this$startingData = this.startingData) === null || _this$startingData === void 0 ? void 0 : (_this$startingData$ad = _this$startingData.adl) === null || _this$startingData$ad === void 0 ? void 0 : (_this$startingData$ad2 = _this$startingData$ad.nav) === null || _this$startingData$ad2 === void 0 ? void 0 : _this$startingData$ad2.request) && this.adl.nav.request !== '_none_') { + this.adl.nav.request = encodeURIComponent(this.adl.nav.request); + navRequest = true; + } + + var commitObject = this.renderCommitCMI(terminateCommit || this.settings.alwaysSendTotalTime); + + if (this.apiLogLevel === global_constants.LOG_LEVEL_DEBUG) { + console.debug('Commit (terminated: ' + (terminateCommit ? 'yes' : 'no') + '): '); + console.debug(commitObject); + } + + if (this.settings.lmsCommitUrl) { + var result = this.processHttpRequest(this.settings.lmsCommitUrl, commitObject, terminateCommit); // check if this is a sequencing call, and then call the necessary JS + + { + if (navRequest && result.navRequest !== undefined && result.navRequest !== '') { + Function("\"use strict\";(() => { ".concat(result.navRequest, " })()"))(); + } + } + return result; + } else { + return global_constants.SCORM_TRUE; + } + } + }]); + + return Scorm2004API; +}(_BaseAPI2["default"]); + +exports["default"] = Scorm2004API; + +},{"./BaseAPI":2,"./cmi/scorm2004_cmi":5,"./constants/api_constants":6,"./constants/error_codes":7,"./constants/language_constants":8,"./constants/regex":9,"./constants/response_constants":10,"./utilities":13}],4:[function(require,module,exports){ +"use strict"; + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.checkValidFormat = checkValidFormat; +exports.checkValidRange = checkValidRange; +exports.CMIArray = exports.CMIScore = exports.BaseCMI = void 0; + +var _api_constants = _interopRequireDefault(require("../constants/api_constants")); + +var _error_codes = _interopRequireDefault(require("../constants/error_codes")); + +var _regex = _interopRequireDefault(require("../constants/regex")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; } + +function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } } + +function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); } + +function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); } + +function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +var scorm12_constants = _api_constants["default"].scorm12; +var scorm12_regex = _regex["default"].scorm12; +var scorm12_error_codes = _error_codes["default"].scorm12; +/** + * Check if the value matches the proper format. If not, throw proper error code. + * + * @param {string} value + * @param {string} regexPattern + * @param {number} errorCode + * @param {class} errorClass + * @param {boolean} allowEmptyString + * @return {boolean} + */ + +function checkValidFormat(value, regexPattern, errorCode, errorClass, allowEmptyString) { + var formatRegex = new RegExp(regexPattern); + var matches = value.match(formatRegex); + + if (allowEmptyString && value === '') { + return true; + } + + if (value === undefined || !matches || matches[0] === '') { + throw new errorClass.prototype.constructor(errorCode); + } + + return true; +} +/** + * Check if the value matches the proper range. If not, throw proper error code. + * + * @param {*} value + * @param {string} rangePattern + * @param {number} errorCode + * @param {class} errorClass + * @return {boolean} + */ + + +function checkValidRange(value, rangePattern, errorCode, errorClass) { + var ranges = rangePattern.split('#'); + value = value * 1.0; + + if (value >= ranges[0]) { + if (ranges[1] === '*' || value <= ranges[1]) { + return true; + } else { + throw new errorClass.prototype.constructor(errorCode); + } + } else { + throw new errorClass.prototype.constructor(errorCode); + } +} +/** + * Base class for API cmi objects + */ + + +var _initialized = new WeakMap(); + +var _start_time = new WeakMap(); + +var BaseCMI = /*#__PURE__*/function () { + /** + * Constructor for BaseCMI, just marks the class as abstract + */ + function BaseCMI() { + _classCallCheck(this, BaseCMI); + + _defineProperty(this, "jsonString", false); + + _initialized.set(this, { + writable: true, + value: false + }); + + _start_time.set(this, { + writable: true, + value: void 0 + }); + + if ((this instanceof BaseCMI ? this.constructor : void 0) === BaseCMI) { + throw new TypeError('Cannot construct BaseCMI instances directly'); + } + } + /** + * Getter for #initialized + * @return {boolean} + */ + + + _createClass(BaseCMI, [{ + key: "initialized", + get: function get() { + return _classPrivateFieldGet(this, _initialized); + } + /** + * Getter for #start_time + * @return {Number} + */ + + }, { + key: "start_time", + get: function get() { + return _classPrivateFieldGet(this, _start_time); + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + }, { + key: "initialize", + value: function initialize() { + _classPrivateFieldSet(this, _initialized, true); + } + /** + * Called when the player should override the 'session_time' provided by + * the module + */ + + }, { + key: "setStartTime", + value: function setStartTime() { + _classPrivateFieldSet(this, _start_time, new Date().getTime()); + } + }]); + + return BaseCMI; +}(); +/** + * Base class for cmi *.score objects + */ + + +exports.BaseCMI = BaseCMI; + +var _children2 = new WeakMap(); + +var _score_range = new WeakMap(); + +var _invalid_error_code = new WeakMap(); + +var _invalid_type_code = new WeakMap(); + +var _invalid_range_code = new WeakMap(); + +var _decimal_regex = new WeakMap(); + +var _error_class = new WeakMap(); + +var _raw = new WeakMap(); + +var _min = new WeakMap(); + +var _max = new WeakMap(); + +var CMIScore = /*#__PURE__*/function (_BaseCMI) { + _inherits(CMIScore, _BaseCMI); + + var _super = _createSuper(CMIScore); + + /** + * Constructor for *.score + * @param {string} score_children + * @param {string} score_range + * @param {string} max + * @param {number} invalidErrorCode + * @param {number} invalidTypeCode + * @param {number} invalidRangeCode + * @param {string} decimalRegex + * @param {class} errorClass + */ + function CMIScore(_ref) { + var _this; + + var score_children = _ref.score_children, + score_range = _ref.score_range, + max = _ref.max, + invalidErrorCode = _ref.invalidErrorCode, + invalidTypeCode = _ref.invalidTypeCode, + invalidRangeCode = _ref.invalidRangeCode, + decimalRegex = _ref.decimalRegex, + errorClass = _ref.errorClass; + + _classCallCheck(this, CMIScore); + + _this = _super.call(this); + + _children2.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _score_range.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _invalid_error_code.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _invalid_type_code.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _invalid_range_code.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _decimal_regex.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _error_class.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _raw.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _min.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _max.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _classPrivateFieldSet(_assertThisInitialized(_this), _children2, score_children || scorm12_constants.score_children); + + _classPrivateFieldSet(_assertThisInitialized(_this), _score_range, !score_range ? false : scorm12_regex.score_range); + + _classPrivateFieldSet(_assertThisInitialized(_this), _max, max || max === '' ? max : '100'); + + _classPrivateFieldSet(_assertThisInitialized(_this), _invalid_error_code, invalidErrorCode || scorm12_error_codes.INVALID_SET_VALUE); + + _classPrivateFieldSet(_assertThisInitialized(_this), _invalid_type_code, invalidTypeCode || scorm12_error_codes.TYPE_MISMATCH); + + _classPrivateFieldSet(_assertThisInitialized(_this), _invalid_range_code, invalidRangeCode || scorm12_error_codes.VALUE_OUT_OF_RANGE); + + _classPrivateFieldSet(_assertThisInitialized(_this), _decimal_regex, decimalRegex || scorm12_regex.CMIDecimal); + + _classPrivateFieldSet(_assertThisInitialized(_this), _error_class, errorClass); + + return _this; + } + + _createClass(CMIScore, [{ + key: "_children", + get: + /** + * Getter for _children + * @return {string} + * @private + */ + function get() { + return _classPrivateFieldGet(this, _children2); + } + /** + * Setter for _children. Just throws an error. + * @param {string} _children + * @private + */ + , + set: function set(_children) { + throw new (_classPrivateFieldGet(this, _error_class).prototype.constructor)(_classPrivateFieldGet(this, _invalid_error_code)); + } + /** + * Getter for #raw + * @return {string} + */ + + }, { + key: "raw", + get: function get() { + return _classPrivateFieldGet(this, _raw); + } + /** + * Setter for #raw + * @param {string} raw + */ + , + set: function set(raw) { + if (checkValidFormat(raw, _classPrivateFieldGet(this, _decimal_regex), _classPrivateFieldGet(this, _invalid_type_code), _classPrivateFieldGet(this, _error_class)) && (!_classPrivateFieldGet(this, _score_range) || checkValidRange(raw, _classPrivateFieldGet(this, _score_range), _classPrivateFieldGet(this, _invalid_range_code), _classPrivateFieldGet(this, _error_class)))) { + _classPrivateFieldSet(this, _raw, raw); + } + } + /** + * Getter for #min + * @return {string} + */ + + }, { + key: "min", + get: function get() { + return _classPrivateFieldGet(this, _min); + } + /** + * Setter for #min + * @param {string} min + */ + , + set: function set(min) { + if (checkValidFormat(min, _classPrivateFieldGet(this, _decimal_regex), _classPrivateFieldGet(this, _invalid_type_code), _classPrivateFieldGet(this, _error_class)) && (!_classPrivateFieldGet(this, _score_range) || checkValidRange(min, _classPrivateFieldGet(this, _score_range), _classPrivateFieldGet(this, _invalid_range_code), _classPrivateFieldGet(this, _error_class)))) { + _classPrivateFieldSet(this, _min, min); + } + } + /** + * Getter for #max + * @return {string} + */ + + }, { + key: "max", + get: function get() { + return _classPrivateFieldGet(this, _max); + } + /** + * Setter for #max + * @param {string} max + */ + , + set: function set(max) { + if (checkValidFormat(max, _classPrivateFieldGet(this, _decimal_regex), _classPrivateFieldGet(this, _invalid_type_code), _classPrivateFieldGet(this, _error_class)) && (!_classPrivateFieldGet(this, _score_range) || checkValidRange(max, _classPrivateFieldGet(this, _score_range), _classPrivateFieldGet(this, _invalid_range_code), _classPrivateFieldGet(this, _error_class)))) { + _classPrivateFieldSet(this, _max, max); + } + } + /** + * toJSON for *.score + * @return {{min: string, max: string, raw: string}} + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'raw': this.raw, + 'min': this.min, + 'max': this.max + }; + delete this.jsonString; + return result; + } + }]); + + return CMIScore; +}(BaseCMI); +/** + * Base class for cmi *.n objects + */ + + +exports.CMIScore = CMIScore; + +var _errorCode = new WeakMap(); + +var _errorClass = new WeakMap(); + +var _children3 = new WeakMap(); + +var CMIArray = /*#__PURE__*/function (_BaseCMI2) { + _inherits(CMIArray, _BaseCMI2); + + var _super2 = _createSuper(CMIArray); + + /** + * Constructor cmi *.n arrays + * @param {string} children + * @param {number} errorCode + * @param {class} errorClass + */ + function CMIArray(_ref2) { + var _this2; + + var children = _ref2.children, + errorCode = _ref2.errorCode, + errorClass = _ref2.errorClass; + + _classCallCheck(this, CMIArray); + + _this2 = _super2.call(this); + + _errorCode.set(_assertThisInitialized(_this2), { + writable: true, + value: void 0 + }); + + _errorClass.set(_assertThisInitialized(_this2), { + writable: true, + value: void 0 + }); + + _children3.set(_assertThisInitialized(_this2), { + writable: true, + value: void 0 + }); + + _classPrivateFieldSet(_assertThisInitialized(_this2), _children3, children); + + _classPrivateFieldSet(_assertThisInitialized(_this2), _errorCode, errorCode); + + _classPrivateFieldSet(_assertThisInitialized(_this2), _errorClass, errorClass); + + _this2.childArray = []; + return _this2; + } + + _createClass(CMIArray, [{ + key: "_children", + get: + /** + * Getter for _children + * @return {*} + */ + function get() { + return _classPrivateFieldGet(this, _children3); + } + /** + * Setter for _children. Just throws an error. + * @param {string} _children + */ + , + set: function set(_children) { + throw new (_classPrivateFieldGet(this, _errorClass).prototype.constructor)(_classPrivateFieldGet(this, _errorCode)); + } + /** + * Getter for _count + * @return {number} + */ + + }, { + key: "_count", + get: function get() { + return this.childArray.length; + } + /** + * Setter for _count. Just throws an error. + * @param {number} _count + */ + , + set: function set(_count) { + throw new (_classPrivateFieldGet(this, _errorClass).prototype.constructor)(_classPrivateFieldGet(this, _errorCode)); + } + /** + * toJSON for *.n arrays + * @return {object} + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = {}; + + for (var i = 0; i < this.childArray.length; i++) { + result[i + ''] = this.childArray[i]; + } + + delete this.jsonString; + return result; + } + }]); + + return CMIArray; +}(BaseCMI); + +exports.CMIArray = CMIArray; + +},{"../constants/api_constants":6,"../constants/error_codes":7,"../constants/regex":9}],5:[function(require,module,exports){ +"use strict"; + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.ADL = exports.CMIInteractionsCorrectResponsesObject = exports.CMIInteractionsObjectivesObject = exports.CMICommentsObject = exports.CMIObjectivesObject = exports.CMIInteractionsObject = exports.CMI = void 0; + +var _common = require("./common"); + +var _api_constants = _interopRequireDefault(require("../constants/api_constants")); + +var _regex = _interopRequireDefault(require("../constants/regex")); + +var _error_codes = _interopRequireDefault(require("../constants/error_codes")); + +var _response_constants = _interopRequireDefault(require("../constants/response_constants")); + +var _exceptions = require("../exceptions"); + +var Util = _interopRequireWildcard(require("../utilities")); + +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } + +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); } + +function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; } + +function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } } + +function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); } + +function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); } + +function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +var scorm2004_constants = _api_constants["default"].scorm2004; +var scorm2004_error_codes = _error_codes["default"].scorm2004; +var learner_responses = _response_constants["default"].learner; +var scorm2004_regex = _regex["default"].scorm2004; +/** + * Helper method for throwing Read Only error + */ + +function throwReadOnlyError() { + throw new _exceptions.Scorm2004ValidationError(scorm2004_error_codes.READ_ONLY_ELEMENT); +} +/** + * Helper method for throwing Write Only error + */ + + +function throwWriteOnlyError() { + throw new _exceptions.Scorm2004ValidationError(scorm2004_error_codes.WRITE_ONLY_ELEMENT); +} +/** + * Helper method for throwing Type Mismatch error + */ + + +function throwTypeMismatchError() { + throw new _exceptions.Scorm2004ValidationError(scorm2004_error_codes.TYPE_MISMATCH); +} +/** + * Helper method for throwing Dependency Not Established error + */ + + +function throwDependencyNotEstablishedError() { + throw new _exceptions.Scorm2004ValidationError(scorm2004_error_codes.DEPENDENCY_NOT_ESTABLISHED); +} +/** + * Helper method for throwing Dependency Not Established error + */ + + +function throwGeneralSetError() { + throw new _exceptions.Scorm2004ValidationError(scorm2004_error_codes.GENERAL_SET_FAILURE); +} +/** + * Helper method, no reason to have to pass the same error codes every time + * @param {*} value + * @param {string} regexPattern + * @param {boolean} allowEmptyString + * @return {boolean} + */ + + +function check2004ValidFormat(value, regexPattern, allowEmptyString) { + return (0, _common.checkValidFormat)(value, regexPattern, scorm2004_error_codes.TYPE_MISMATCH, _exceptions.Scorm2004ValidationError, allowEmptyString); +} +/** + * Helper method, no reason to have to pass the same error codes every time + * @param {*} value + * @param {string} rangePattern + * @return {boolean} + */ + + +function check2004ValidRange(value, rangePattern) { + return (0, _common.checkValidRange)(value, rangePattern, scorm2004_error_codes.VALUE_OUT_OF_RANGE, _exceptions.Scorm2004ValidationError); +} +/** + * Class representing cmi object for SCORM 2004 + */ + + +var _version2 = new WeakMap(); + +var _children2 = new WeakMap(); + +var _completion_status = new WeakMap(); + +var _completion_threshold = new WeakMap(); + +var _credit = new WeakMap(); + +var _entry = new WeakMap(); + +var _exit = new WeakMap(); + +var _launch_data = new WeakMap(); + +var _learner_id = new WeakMap(); + +var _learner_name = new WeakMap(); + +var _location = new WeakMap(); + +var _max_time_allowed = new WeakMap(); + +var _mode = new WeakMap(); + +var _progress_measure = new WeakMap(); + +var _scaled_passing_score = new WeakMap(); + +var _session_time = new WeakMap(); + +var _success_status = new WeakMap(); + +var _suspend_data = new WeakMap(); + +var _time_limit_action = new WeakMap(); + +var _total_time = new WeakMap(); + +var CMI = /*#__PURE__*/function (_BaseCMI) { + _inherits(CMI, _BaseCMI); + + var _super = _createSuper(CMI); + + /** + * Constructor for the SCORM 2004 cmi object + * @param {boolean} initialized + */ + function CMI(initialized) { + var _this; + + _classCallCheck(this, CMI); + + _this = _super.call(this); + + _version2.set(_assertThisInitialized(_this), { + writable: true, + value: '1.0' + }); + + _children2.set(_assertThisInitialized(_this), { + writable: true, + value: scorm2004_constants.cmi_children + }); + + _completion_status.set(_assertThisInitialized(_this), { + writable: true, + value: 'unknown' + }); + + _completion_threshold.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _credit.set(_assertThisInitialized(_this), { + writable: true, + value: 'credit' + }); + + _entry.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _exit.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _launch_data.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _learner_id.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _learner_name.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _location.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _max_time_allowed.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _mode.set(_assertThisInitialized(_this), { + writable: true, + value: 'normal' + }); + + _progress_measure.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _scaled_passing_score.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _session_time.set(_assertThisInitialized(_this), { + writable: true, + value: 'PT0H0M0S' + }); + + _success_status.set(_assertThisInitialized(_this), { + writable: true, + value: 'unknown' + }); + + _suspend_data.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _time_limit_action.set(_assertThisInitialized(_this), { + writable: true, + value: 'continue,no message' + }); + + _total_time.set(_assertThisInitialized(_this), { + writable: true, + value: '' + }); + + _this.learner_preference = new CMILearnerPreference(); + _this.score = new Scorm2004CMIScore(); + _this.comments_from_learner = new CMICommentsFromLearner(); + _this.comments_from_lms = new CMICommentsFromLMS(); + _this.interactions = new CMIInteractions(); + _this.objectives = new CMIObjectives(); + if (initialized) _this.initialize(); + return _this; + } + + _createClass(CMI, [{ + key: "initialize", + value: + /** + * Called when the API has been initialized after the CMI has been created + */ + function initialize() { + var _this$learner_prefere, _this$score, _this$comments_from_l, _this$comments_from_l2, _this$interactions, _this$objectives; + + _get(_getPrototypeOf(CMI.prototype), "initialize", this).call(this); + + (_this$learner_prefere = this.learner_preference) === null || _this$learner_prefere === void 0 ? void 0 : _this$learner_prefere.initialize(); + (_this$score = this.score) === null || _this$score === void 0 ? void 0 : _this$score.initialize(); + (_this$comments_from_l = this.comments_from_learner) === null || _this$comments_from_l === void 0 ? void 0 : _this$comments_from_l.initialize(); + (_this$comments_from_l2 = this.comments_from_lms) === null || _this$comments_from_l2 === void 0 ? void 0 : _this$comments_from_l2.initialize(); + (_this$interactions = this.interactions) === null || _this$interactions === void 0 ? void 0 : _this$interactions.initialize(); + (_this$objectives = this.objectives) === null || _this$objectives === void 0 ? void 0 : _this$objectives.initialize(); + } + /** + * Getter for #_version + * @return {string} + * @private + */ + + }, { + key: "_version", + get: function get() { + return _classPrivateFieldGet(this, _version2); + } + /** + * Setter for #_version. Just throws an error. + * @param {string} _version + * @private + */ + , + set: function set(_version) { + throwReadOnlyError(); + } + /** + * Getter for #_children + * @return {string} + * @private + */ + + }, { + key: "_children", + get: function get() { + return _classPrivateFieldGet(this, _children2); + } + /** + * Setter for #_children. Just throws an error. + * @param {number} _children + * @private + */ + , + set: function set(_children) { + throwReadOnlyError(); + } + /** + * Getter for #completion_status + * @return {string} + */ + + }, { + key: "completion_status", + get: function get() { + return _classPrivateFieldGet(this, _completion_status); + } + /** + * Setter for #completion_status + * @param {string} completion_status + */ + , + set: function set(completion_status) { + if (check2004ValidFormat(completion_status, scorm2004_regex.CMICStatus)) { + _classPrivateFieldSet(this, _completion_status, completion_status); + } + } + /** + * Getter for #completion_threshold + * @return {string} + */ + + }, { + key: "completion_threshold", + get: function get() { + return _classPrivateFieldGet(this, _completion_threshold); + } + /** + * Setter for #completion_threshold. Can only be called before initialization. + * @param {string} completion_threshold + */ + , + set: function set(completion_threshold) { + !this.initialized ? _classPrivateFieldSet(this, _completion_threshold, completion_threshold) : throwReadOnlyError(); + } + /** + * Setter for #credit + * @return {string} + */ + + }, { + key: "credit", + get: function get() { + return _classPrivateFieldGet(this, _credit); + } + /** + * Setter for #credit. Can only be called before initialization. + * @param {string} credit + */ + , + set: function set(credit) { + !this.initialized ? _classPrivateFieldSet(this, _credit, credit) : throwReadOnlyError(); + } + /** + * Getter for #entry + * @return {string} + */ + + }, { + key: "entry", + get: function get() { + return _classPrivateFieldGet(this, _entry); + } + /** + * Setter for #entry. Can only be called before initialization. + * @param {string} entry + */ + , + set: function set(entry) { + !this.initialized ? _classPrivateFieldSet(this, _entry, entry) : throwReadOnlyError(); + } + /** + * Getter for #exit. Should only be called during JSON export. + * @return {string} + */ + + }, { + key: "exit", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _exit); + } + /** + * Getter for #exit + * @param {string} exit + */ + , + set: function set(exit) { + if (check2004ValidFormat(exit, scorm2004_regex.CMIExit, true)) { + _classPrivateFieldSet(this, _exit, exit); + } + } + /** + * Getter for #launch_data + * @return {string} + */ + + }, { + key: "launch_data", + get: function get() { + return _classPrivateFieldGet(this, _launch_data); + } + /** + * Setter for #launch_data. Can only be called before initialization. + * @param {string} launch_data + */ + , + set: function set(launch_data) { + !this.initialized ? _classPrivateFieldSet(this, _launch_data, launch_data) : throwReadOnlyError(); + } + /** + * Getter for #learner_id + * @return {string} + */ + + }, { + key: "learner_id", + get: function get() { + return _classPrivateFieldGet(this, _learner_id); + } + /** + * Setter for #learner_id. Can only be called before initialization. + * @param {string} learner_id + */ + , + set: function set(learner_id) { + !this.initialized ? _classPrivateFieldSet(this, _learner_id, learner_id) : throwReadOnlyError(); + } + /** + * Getter for #learner_name + * @return {string} + */ + + }, { + key: "learner_name", + get: function get() { + return _classPrivateFieldGet(this, _learner_name); + } + /** + * Setter for #learner_name. Can only be called before initialization. + * @param {string} learner_name + */ + , + set: function set(learner_name) { + !this.initialized ? _classPrivateFieldSet(this, _learner_name, learner_name) : throwReadOnlyError(); + } + /** + * Getter for #location + * @return {string} + */ + + }, { + key: "location", + get: function get() { + return _classPrivateFieldGet(this, _location); + } + /** + * Setter for #location + * @param {string} location + */ + , + set: function set(location) { + if (check2004ValidFormat(location, scorm2004_regex.CMIString1000)) { + _classPrivateFieldSet(this, _location, location); + } + } + /** + * Getter for #max_time_allowed + * @return {string} + */ + + }, { + key: "max_time_allowed", + get: function get() { + return _classPrivateFieldGet(this, _max_time_allowed); + } + /** + * Setter for #max_time_allowed. Can only be called before initialization. + * @param {string} max_time_allowed + */ + , + set: function set(max_time_allowed) { + !this.initialized ? _classPrivateFieldSet(this, _max_time_allowed, max_time_allowed) : throwReadOnlyError(); + } + /** + * Getter for #mode + * @return {string} + */ + + }, { + key: "mode", + get: function get() { + return _classPrivateFieldGet(this, _mode); + } + /** + * Setter for #mode. Can only be called before initialization. + * @param {string} mode + */ + , + set: function set(mode) { + !this.initialized ? _classPrivateFieldSet(this, _mode, mode) : throwReadOnlyError(); + } + /** + * Getter for #progress_measure + * @return {string} + */ + + }, { + key: "progress_measure", + get: function get() { + return _classPrivateFieldGet(this, _progress_measure); + } + /** + * Setter for #progress_measure + * @param {string} progress_measure + */ + , + set: function set(progress_measure) { + if (check2004ValidFormat(progress_measure, scorm2004_regex.CMIDecimal) && check2004ValidRange(progress_measure, scorm2004_regex.progress_range)) { + _classPrivateFieldSet(this, _progress_measure, progress_measure); + } + } + /** + * Getter for #scaled_passing_score + * @return {string} + */ + + }, { + key: "scaled_passing_score", + get: function get() { + return _classPrivateFieldGet(this, _scaled_passing_score); + } + /** + * Setter for #scaled_passing_score. Can only be called before initialization. + * @param {string} scaled_passing_score + */ + , + set: function set(scaled_passing_score) { + !this.initialized ? _classPrivateFieldSet(this, _scaled_passing_score, scaled_passing_score) : throwReadOnlyError(); + } + /** + * Getter for #session_time. Should only be called during JSON export. + * @return {string} + */ + + }, { + key: "session_time", + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _session_time); + } + /** + * Setter for #session_time + * @param {string} session_time + */ + , + set: function set(session_time) { + if (check2004ValidFormat(session_time, scorm2004_regex.CMITimespan)) { + _classPrivateFieldSet(this, _session_time, session_time); + } + } + /** + * Getter for #success_status + * @return {string} + */ + + }, { + key: "success_status", + get: function get() { + return _classPrivateFieldGet(this, _success_status); + } + /** + * Setter for #success_status + * @param {string} success_status + */ + , + set: function set(success_status) { + if (check2004ValidFormat(success_status, scorm2004_regex.CMISStatus)) { + _classPrivateFieldSet(this, _success_status, success_status); + } + } + /** + * Getter for #suspend_data + * @return {string} + */ + + }, { + key: "suspend_data", + get: function get() { + return _classPrivateFieldGet(this, _suspend_data); + } + /** + * Setter for #suspend_data + * @param {string} suspend_data + */ + , + set: function set(suspend_data) { + if (check2004ValidFormat(suspend_data, scorm2004_regex.CMIString64000, true)) { + _classPrivateFieldSet(this, _suspend_data, suspend_data); + } + } + /** + * Getter for #time_limit_action + * @return {string} + */ + + }, { + key: "time_limit_action", + get: function get() { + return _classPrivateFieldGet(this, _time_limit_action); + } + /** + * Setter for #time_limit_action. Can only be called before initialization. + * @param {string} time_limit_action + */ + , + set: function set(time_limit_action) { + !this.initialized ? _classPrivateFieldSet(this, _time_limit_action, time_limit_action) : throwReadOnlyError(); + } + /** + * Getter for #total_time + * @return {string} + */ + + }, { + key: "total_time", + get: function get() { + return _classPrivateFieldGet(this, _total_time); + } + /** + * Setter for #total_time. Can only be called before initialization. + * @param {string} total_time + */ + , + set: function set(total_time) { + !this.initialized ? _classPrivateFieldSet(this, _total_time, total_time) : throwReadOnlyError(); + } + /** + * Adds the current session time to the existing total time. + * + * @return {string} ISO8601 Duration + */ + + }, { + key: "getCurrentTotalTime", + value: function getCurrentTotalTime() { + var sessionTime = _classPrivateFieldGet(this, _session_time); + + var startTime = this.start_time; + + if (typeof startTime !== 'undefined' && startTime !== null) { + var seconds = new Date().getTime() - startTime; + sessionTime = Util.getSecondsAsISODuration(seconds / 1000); + } + + return Util.addTwoDurations(_classPrivateFieldGet(this, _total_time), sessionTime, scorm2004_regex.CMITimespan); + } + /** + * toJSON for cmi + * + * @return { + * { + * comments_from_learner: CMICommentsFromLearner, + * comments_from_lms: CMICommentsFromLMS, + * completion_status: string, + * completion_threshold: string, + * credit: string, + * entry: string, + * exit: string, + * interactions: CMIInteractions, + * launch_data: string, + * learner_id: string, + * learner_name: string, + * learner_preference: CMILearnerPreference, + * location: string, + * max_time_allowed: string, + * mode: string, + * objectives: CMIObjectives, + * progress_measure: string, + * scaled_passing_score: string, + * score: Scorm2004CMIScore, + * session_time: string, + * success_status: string, + * suspend_data: string, + * time_limit_action: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'comments_from_learner': this.comments_from_learner, + 'comments_from_lms': this.comments_from_lms, + 'completion_status': this.completion_status, + 'completion_threshold': this.completion_threshold, + 'credit': this.credit, + 'entry': this.entry, + 'exit': this.exit, + 'interactions': this.interactions, + 'launch_data': this.launch_data, + 'learner_id': this.learner_id, + 'learner_name': this.learner_name, + 'learner_preference': this.learner_preference, + 'location': this.location, + 'max_time_allowed': this.max_time_allowed, + 'mode': this.mode, + 'objectives': this.objectives, + 'progress_measure': this.progress_measure, + 'scaled_passing_score': this.scaled_passing_score, + 'score': this.score, + 'session_time': this.session_time, + 'success_status': this.success_status, + 'suspend_data': this.suspend_data, + 'time_limit_action': this.time_limit_action + }; + delete this.jsonString; + return result; + } + }]); + + return CMI; +}(_common.BaseCMI); +/** + * Class for SCORM 2004's cmi.learner_preference object + */ + + +exports.CMI = CMI; + +var _children3 = new WeakMap(); + +var _audio_level = new WeakMap(); + +var _language = new WeakMap(); + +var _delivery_speed = new WeakMap(); + +var _audio_captioning = new WeakMap(); + +var CMILearnerPreference = /*#__PURE__*/function (_BaseCMI2) { + _inherits(CMILearnerPreference, _BaseCMI2); + + var _super2 = _createSuper(CMILearnerPreference); + + /** + * Constructor for cmi.learner_preference + */ + function CMILearnerPreference() { + var _this2; + + _classCallCheck(this, CMILearnerPreference); + + _this2 = _super2.call(this); + + _children3.set(_assertThisInitialized(_this2), { + writable: true, + value: scorm2004_constants.student_preference_children + }); + + _audio_level.set(_assertThisInitialized(_this2), { + writable: true, + value: '1' + }); + + _language.set(_assertThisInitialized(_this2), { + writable: true, + value: '' + }); + + _delivery_speed.set(_assertThisInitialized(_this2), { + writable: true, + value: '1' + }); + + _audio_captioning.set(_assertThisInitialized(_this2), { + writable: true, + value: '0' + }); + + return _this2; + } + /** + * Getter for #_children + * @return {string} + * @private + */ + + + _createClass(CMILearnerPreference, [{ + key: "_children", + get: function get() { + return _classPrivateFieldGet(this, _children3); + } + /** + * Setter for #_children. Just throws an error. + * @param {string} _children + * @private + */ + , + set: function set(_children) { + throwReadOnlyError(); + } + /** + * Getter for #audio_level + * @return {string} + */ + + }, { + key: "audio_level", + get: function get() { + return _classPrivateFieldGet(this, _audio_level); + } + /** + * Setter for #audio_level + * @param {string} audio_level + */ + , + set: function set(audio_level) { + if (check2004ValidFormat(audio_level, scorm2004_regex.CMIDecimal) && check2004ValidRange(audio_level, scorm2004_regex.audio_range)) { + _classPrivateFieldSet(this, _audio_level, audio_level); + } + } + /** + * Getter for #language + * @return {string} + */ + + }, { + key: "language", + get: function get() { + return _classPrivateFieldGet(this, _language); + } + /** + * Setter for #language + * @param {string} language + */ + , + set: function set(language) { + if (check2004ValidFormat(language, scorm2004_regex.CMILang)) { + _classPrivateFieldSet(this, _language, language); + } + } + /** + * Getter for #delivery_speed + * @return {string} + */ + + }, { + key: "delivery_speed", + get: function get() { + return _classPrivateFieldGet(this, _delivery_speed); + } + /** + * Setter for #delivery_speed + * @param {string} delivery_speed + */ + , + set: function set(delivery_speed) { + if (check2004ValidFormat(delivery_speed, scorm2004_regex.CMIDecimal) && check2004ValidRange(delivery_speed, scorm2004_regex.speed_range)) { + _classPrivateFieldSet(this, _delivery_speed, delivery_speed); + } + } + /** + * Getter for #audio_captioning + * @return {string} + */ + + }, { + key: "audio_captioning", + get: function get() { + return _classPrivateFieldGet(this, _audio_captioning); + } + /** + * Setter for #audio_captioning + * @param {string} audio_captioning + */ + , + set: function set(audio_captioning) { + if (check2004ValidFormat(audio_captioning, scorm2004_regex.CMISInteger) && check2004ValidRange(audio_captioning, scorm2004_regex.text_range)) { + _classPrivateFieldSet(this, _audio_captioning, audio_captioning); + } + } + /** + * toJSON for cmi.learner_preference + * + * @return { + * { + * audio_level: string, + * language: string, + * delivery_speed: string, + * audio_captioning: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'audio_level': this.audio_level, + 'language': this.language, + 'delivery_speed': this.delivery_speed, + 'audio_captioning': this.audio_captioning + }; + delete this.jsonString; + return result; + } + }]); + + return CMILearnerPreference; +}(_common.BaseCMI); +/** + * Class representing SCORM 2004's cmi.interactions object + */ + + +var CMIInteractions = /*#__PURE__*/function (_CMIArray) { + _inherits(CMIInteractions, _CMIArray); + + var _super3 = _createSuper(CMIInteractions); + + /** + * Constructor for cmi.objectives Array + */ + function CMIInteractions() { + _classCallCheck(this, CMIInteractions); + + return _super3.call(this, { + children: scorm2004_constants.interactions_children, + errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT, + errorClass: _exceptions.Scorm2004ValidationError + }); + } + + return CMIInteractions; +}(_common.CMIArray); +/** + * Class representing SCORM 2004's cmi.objectives object + */ + + +var CMIObjectives = /*#__PURE__*/function (_CMIArray2) { + _inherits(CMIObjectives, _CMIArray2); + + var _super4 = _createSuper(CMIObjectives); + + /** + * Constructor for cmi.objectives Array + */ + function CMIObjectives() { + _classCallCheck(this, CMIObjectives); + + return _super4.call(this, { + children: scorm2004_constants.objectives_children, + errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT, + errorClass: _exceptions.Scorm2004ValidationError + }); + } + + return CMIObjectives; +}(_common.CMIArray); +/** + * Class representing SCORM 2004's cmi.comments_from_lms object + */ + + +var CMICommentsFromLMS = /*#__PURE__*/function (_CMIArray3) { + _inherits(CMICommentsFromLMS, _CMIArray3); + + var _super5 = _createSuper(CMICommentsFromLMS); + + /** + * Constructor for cmi.comments_from_lms Array + */ + function CMICommentsFromLMS() { + _classCallCheck(this, CMICommentsFromLMS); + + return _super5.call(this, { + children: scorm2004_constants.comments_children, + errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT, + errorClass: _exceptions.Scorm2004ValidationError + }); + } + + return CMICommentsFromLMS; +}(_common.CMIArray); +/** + * Class representing SCORM 2004's cmi.comments_from_learner object + */ + + +var CMICommentsFromLearner = /*#__PURE__*/function (_CMIArray4) { + _inherits(CMICommentsFromLearner, _CMIArray4); + + var _super6 = _createSuper(CMICommentsFromLearner); + + /** + * Constructor for cmi.comments_from_learner Array + */ + function CMICommentsFromLearner() { + _classCallCheck(this, CMICommentsFromLearner); + + return _super6.call(this, { + children: scorm2004_constants.comments_children, + errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT, + errorClass: _exceptions.Scorm2004ValidationError + }); + } + + return CMICommentsFromLearner; +}(_common.CMIArray); +/** + * Class for SCORM 2004's cmi.interaction.n object + */ + + +var _id = new WeakMap(); + +var _type = new WeakMap(); + +var _timestamp = new WeakMap(); + +var _weighting = new WeakMap(); + +var _learner_response = new WeakMap(); + +var _result = new WeakMap(); + +var _latency = new WeakMap(); + +var _description = new WeakMap(); + +var CMIInteractionsObject = /*#__PURE__*/function (_BaseCMI3) { + _inherits(CMIInteractionsObject, _BaseCMI3); + + var _super7 = _createSuper(CMIInteractionsObject); + + /** + * Constructor for cmi.interaction.n + */ + function CMIInteractionsObject() { + var _this3; + + _classCallCheck(this, CMIInteractionsObject); + + _this3 = _super7.call(this); + + _id.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _type.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _timestamp.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _weighting.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _learner_response.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _result.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _latency.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _description.set(_assertThisInitialized(_this3), { + writable: true, + value: '' + }); + + _this3.objectives = new _common.CMIArray({ + errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT, + errorClass: _exceptions.Scorm2004ValidationError, + children: scorm2004_constants.objectives_children + }); + _this3.correct_responses = new _common.CMIArray({ + errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT, + errorClass: _exceptions.Scorm2004ValidationError, + children: scorm2004_constants.correct_responses_children + }); + return _this3; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(CMIInteractionsObject, [{ + key: "initialize", + value: function initialize() { + var _this$objectives2, _this$correct_respons; + + _get(_getPrototypeOf(CMIInteractionsObject.prototype), "initialize", this).call(this); + + (_this$objectives2 = this.objectives) === null || _this$objectives2 === void 0 ? void 0 : _this$objectives2.initialize(); + (_this$correct_respons = this.correct_responses) === null || _this$correct_respons === void 0 ? void 0 : _this$correct_respons.initialize(); + } + /** + * Getter for #id + * @return {string} + */ + + }, { + key: "id", + get: function get() { + return _classPrivateFieldGet(this, _id); + } + /** + * Setter for #id + * @param {string} id + */ + , + set: function set(id) { + if (check2004ValidFormat(id, scorm2004_regex.CMILongIdentifier)) { + _classPrivateFieldSet(this, _id, id); + } + } + /** + * Getter for #type + * @return {string} + */ + + }, { + key: "type", + get: function get() { + return _classPrivateFieldGet(this, _type); + } + /** + * Setter for #type + * @param {string} type + */ + , + set: function set(type) { + if (this.initialized && _classPrivateFieldGet(this, _id) === '') { + throwDependencyNotEstablishedError(); + } else { + if (check2004ValidFormat(type, scorm2004_regex.CMIType)) { + _classPrivateFieldSet(this, _type, type); + } + } + } + /** + * Getter for #timestamp + * @return {string} + */ + + }, { + key: "timestamp", + get: function get() { + return _classPrivateFieldGet(this, _timestamp); + } + /** + * Setter for #timestamp + * @param {string} timestamp + */ + , + set: function set(timestamp) { + if (this.initialized && _classPrivateFieldGet(this, _id) === '') { + throwDependencyNotEstablishedError(); + } else { + if (check2004ValidFormat(timestamp, scorm2004_regex.CMITime)) { + _classPrivateFieldSet(this, _timestamp, timestamp); + } + } + } + /** + * Getter for #weighting + * @return {string} + */ + + }, { + key: "weighting", + get: function get() { + return _classPrivateFieldGet(this, _weighting); + } + /** + * Setter for #weighting + * @param {string} weighting + */ + , + set: function set(weighting) { + if (this.initialized && _classPrivateFieldGet(this, _id) === '') { + throwDependencyNotEstablishedError(); + } else { + if (check2004ValidFormat(weighting, scorm2004_regex.CMIDecimal)) { + _classPrivateFieldSet(this, _weighting, weighting); + } + } + } + /** + * Getter for #learner_response + * @return {string} + */ + + }, { + key: "learner_response", + get: function get() { + return _classPrivateFieldGet(this, _learner_response); + } + /** + * Setter for #learner_response. Does type validation to make sure response + * matches SCORM 2004's spec + * @param {string} learner_response + */ + , + set: function set(learner_response) { + if (this.initialized && (_classPrivateFieldGet(this, _type) === '' || _classPrivateFieldGet(this, _id) === '')) { + throwDependencyNotEstablishedError(); + } else { + var nodes = []; + var response_type = learner_responses[this.type]; + + if (response_type) { + if (response_type !== null && response_type !== void 0 && response_type.delimiter) { + nodes = learner_response.split(response_type.delimiter); + } else { + nodes[0] = learner_response; + } + + if (nodes.length > 0 && nodes.length <= response_type.max) { + var formatRegex = new RegExp(response_type.format); + + for (var i = 0; i < nodes.length; i++) { + if (response_type !== null && response_type !== void 0 && response_type.delimiter2) { + var values = nodes[i].split(response_type.delimiter2); + + if (values.length === 2) { + if (!values[0].match(formatRegex)) { + throwTypeMismatchError(); + } else { + if (!values[1].match(new RegExp(response_type.format2))) { + throwTypeMismatchError(); + } + } + } else { + throwTypeMismatchError(); + } + } else { + if (!nodes[i].match(formatRegex)) { + throwTypeMismatchError(); + } else { + if (nodes[i] !== '' && response_type.unique) { + for (var j = 0; j < i; j++) { + if (nodes[i] === nodes[j]) { + throwTypeMismatchError(); + } + } + } + } + } + } + } else { + throwGeneralSetError(); + } + + _classPrivateFieldSet(this, _learner_response, learner_response); + } else { + throwTypeMismatchError(); + } + } + } + /** + * Getter for #result + * @return {string} + */ + + }, { + key: "result", + get: function get() { + return _classPrivateFieldGet(this, _result); + } + /** + * Setter for #result + * @param {string} result + */ + , + set: function set(result) { + if (check2004ValidFormat(result, scorm2004_regex.CMIResult)) { + _classPrivateFieldSet(this, _result, result); + } + } + /** + * Getter for #latency + * @return {string} + */ + + }, { + key: "latency", + get: function get() { + return _classPrivateFieldGet(this, _latency); + } + /** + * Setter for #latency + * @param {string} latency + */ + , + set: function set(latency) { + if (this.initialized && _classPrivateFieldGet(this, _id) === '') { + throwDependencyNotEstablishedError(); + } else { + if (check2004ValidFormat(latency, scorm2004_regex.CMITimespan)) { + _classPrivateFieldSet(this, _latency, latency); + } + } + } + /** + * Getter for #description + * @return {string} + */ + + }, { + key: "description", + get: function get() { + return _classPrivateFieldGet(this, _description); + } + /** + * Setter for #description + * @param {string} description + */ + , + set: function set(description) { + if (this.initialized && _classPrivateFieldGet(this, _id) === '') { + throwDependencyNotEstablishedError(); + } else { + if (check2004ValidFormat(description, scorm2004_regex.CMILangString250, true)) { + _classPrivateFieldSet(this, _description, description); + } + } + } + /** + * toJSON for cmi.interactions.n + * + * @return { + * { + * id: string, + * type: string, + * objectives: CMIArray, + * timestamp: string, + * correct_responses: CMIArray, + * weighting: string, + * learner_response: string, + * result: string, + * latency: string, + * description: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'id': this.id, + 'type': this.type, + 'objectives': this.objectives, + 'timestamp': this.timestamp, + 'weighting': this.weighting, + 'learner_response': this.learner_response, + 'result': this.result, + 'latency': this.latency, + 'description': this.description, + 'correct_responses': this.correct_responses + }; + delete this.jsonString; + return result; + } + }]); + + return CMIInteractionsObject; +}(_common.BaseCMI); +/** + * Class for SCORM 2004's cmi.objectives.n object + */ + + +exports.CMIInteractionsObject = CMIInteractionsObject; + +var _id2 = new WeakMap(); + +var _success_status2 = new WeakMap(); + +var _completion_status2 = new WeakMap(); + +var _progress_measure2 = new WeakMap(); + +var _description2 = new WeakMap(); + +var CMIObjectivesObject = /*#__PURE__*/function (_BaseCMI4) { + _inherits(CMIObjectivesObject, _BaseCMI4); + + var _super8 = _createSuper(CMIObjectivesObject); + + /** + * Constructor for cmi.objectives.n + */ + function CMIObjectivesObject() { + var _this4; + + _classCallCheck(this, CMIObjectivesObject); + + _this4 = _super8.call(this); + + _id2.set(_assertThisInitialized(_this4), { + writable: true, + value: '' + }); + + _success_status2.set(_assertThisInitialized(_this4), { + writable: true, + value: 'unknown' + }); + + _completion_status2.set(_assertThisInitialized(_this4), { + writable: true, + value: 'unknown' + }); + + _progress_measure2.set(_assertThisInitialized(_this4), { + writable: true, + value: '' + }); + + _description2.set(_assertThisInitialized(_this4), { + writable: true, + value: '' + }); + + _this4.score = new Scorm2004CMIScore(); + return _this4; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(CMIObjectivesObject, [{ + key: "initialize", + value: function initialize() { + var _this$score2; + + _get(_getPrototypeOf(CMIObjectivesObject.prototype), "initialize", this).call(this); + + (_this$score2 = this.score) === null || _this$score2 === void 0 ? void 0 : _this$score2.initialize(); + } + /** + * Getter for #id + * @return {string} + */ + + }, { + key: "id", + get: function get() { + return _classPrivateFieldGet(this, _id2); + } + /** + * Setter for #id + * @param {string} id + */ + , + set: function set(id) { + if (check2004ValidFormat(id, scorm2004_regex.CMILongIdentifier)) { + _classPrivateFieldSet(this, _id2, id); + } + } + /** + * Getter for #success_status + * @return {string} + */ + + }, { + key: "success_status", + get: function get() { + return _classPrivateFieldGet(this, _success_status2); + } + /** + * Setter for #success_status + * @param {string} success_status + */ + , + set: function set(success_status) { + if (this.initialized && _classPrivateFieldGet(this, _id2) === '') { + throwDependencyNotEstablishedError(); + } else { + if (check2004ValidFormat(success_status, scorm2004_regex.CMISStatus)) { + _classPrivateFieldSet(this, _success_status2, success_status); + } + } + } + /** + * Getter for #completion_status + * @return {string} + */ + + }, { + key: "completion_status", + get: function get() { + return _classPrivateFieldGet(this, _completion_status2); + } + /** + * Setter for #completion_status + * @param {string} completion_status + */ + , + set: function set(completion_status) { + if (this.initialized && _classPrivateFieldGet(this, _id2) === '') { + throwDependencyNotEstablishedError(); + } else { + if (check2004ValidFormat(completion_status, scorm2004_regex.CMICStatus)) { + _classPrivateFieldSet(this, _completion_status2, completion_status); + } + } + } + /** + * Getter for #progress_measure + * @return {string} + */ + + }, { + key: "progress_measure", + get: function get() { + return _classPrivateFieldGet(this, _progress_measure2); + } + /** + * Setter for #progress_measure + * @param {string} progress_measure + */ + , + set: function set(progress_measure) { + if (this.initialized && _classPrivateFieldGet(this, _id2) === '') { + throwDependencyNotEstablishedError(); + } else { + if (check2004ValidFormat(progress_measure, scorm2004_regex.CMIDecimal) && check2004ValidRange(progress_measure, scorm2004_regex.progress_range)) { + _classPrivateFieldSet(this, _progress_measure2, progress_measure); + } + } + } + /** + * Getter for #description + * @return {string} + */ + + }, { + key: "description", + get: function get() { + return _classPrivateFieldGet(this, _description2); + } + /** + * Setter for #description + * @param {string} description + */ + , + set: function set(description) { + if (this.initialized && _classPrivateFieldGet(this, _id2) === '') { + throwDependencyNotEstablishedError(); + } else { + if (check2004ValidFormat(description, scorm2004_regex.CMILangString250, true)) { + _classPrivateFieldSet(this, _description2, description); + } + } + } + /** + * toJSON for cmi.objectives.n + * + * @return { + * { + * id: string, + * success_status: string, + * completion_status: string, + * progress_measure: string, + * description: string, + * score: Scorm2004CMIScore + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'id': this.id, + 'success_status': this.success_status, + 'completion_status': this.completion_status, + 'progress_measure': this.progress_measure, + 'description': this.description, + 'score': this.score + }; + delete this.jsonString; + return result; + } + }]); + + return CMIObjectivesObject; +}(_common.BaseCMI); +/** + * Class for SCORM 2004's cmi *.score object + */ + + +exports.CMIObjectivesObject = CMIObjectivesObject; + +var _scaled = new WeakMap(); + +var Scorm2004CMIScore = /*#__PURE__*/function (_CMIScore) { + _inherits(Scorm2004CMIScore, _CMIScore); + + var _super9 = _createSuper(Scorm2004CMIScore); + + /** + * Constructor for cmi *.score + */ + function Scorm2004CMIScore() { + var _this5; + + _classCallCheck(this, Scorm2004CMIScore); + + _this5 = _super9.call(this, { + score_children: scorm2004_constants.score_children, + max: '', + invalidErrorCode: scorm2004_error_codes.READ_ONLY_ELEMENT, + invalidTypeCode: scorm2004_error_codes.TYPE_MISMATCH, + invalidRangeCode: scorm2004_error_codes.VALUE_OUT_OF_RANGE, + decimalRegex: scorm2004_regex.CMIDecimal, + errorClass: _exceptions.Scorm2004ValidationError + }); + + _scaled.set(_assertThisInitialized(_this5), { + writable: true, + value: '' + }); + + return _this5; + } + /** + * Getter for #scaled + * @return {string} + */ + + + _createClass(Scorm2004CMIScore, [{ + key: "scaled", + get: function get() { + return _classPrivateFieldGet(this, _scaled); + } + /** + * Setter for #scaled + * @param {string} scaled + */ + , + set: function set(scaled) { + if (check2004ValidFormat(scaled, scorm2004_regex.CMIDecimal) && check2004ValidRange(scaled, scorm2004_regex.scaled_range)) { + _classPrivateFieldSet(this, _scaled, scaled); + } + } + /** + * toJSON for cmi *.score + * + * @return { + * { + * scaled: string, + * raw: string, + * min: string, + * max: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'scaled': this.scaled, + 'raw': _get(_getPrototypeOf(Scorm2004CMIScore.prototype), "raw", this), + 'min': _get(_getPrototypeOf(Scorm2004CMIScore.prototype), "min", this), + 'max': _get(_getPrototypeOf(Scorm2004CMIScore.prototype), "max", this) + }; + delete this.jsonString; + return result; + } + }]); + + return Scorm2004CMIScore; +}(_common.CMIScore); +/** + * Class representing SCORM 2004's cmi.comments_from_learner.n and cmi.comments_from_lms.n object + */ + + +var _comment = new WeakMap(); + +var _location2 = new WeakMap(); + +var _timestamp2 = new WeakMap(); + +var _readOnlyAfterInit = new WeakMap(); + +var CMICommentsObject = /*#__PURE__*/function (_BaseCMI5) { + _inherits(CMICommentsObject, _BaseCMI5); + + var _super10 = _createSuper(CMICommentsObject); + + /** + * Constructor for cmi.comments_from_learner.n and cmi.comments_from_lms.n + * @param {boolean} readOnlyAfterInit + */ + function CMICommentsObject() { + var _this6; + + var readOnlyAfterInit = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + + _classCallCheck(this, CMICommentsObject); + + _this6 = _super10.call(this); + + _comment.set(_assertThisInitialized(_this6), { + writable: true, + value: '' + }); + + _location2.set(_assertThisInitialized(_this6), { + writable: true, + value: '' + }); + + _timestamp2.set(_assertThisInitialized(_this6), { + writable: true, + value: '' + }); + + _readOnlyAfterInit.set(_assertThisInitialized(_this6), { + writable: true, + value: void 0 + }); + + _classPrivateFieldSet(_assertThisInitialized(_this6), _comment, ''); + + _classPrivateFieldSet(_assertThisInitialized(_this6), _location2, ''); + + _classPrivateFieldSet(_assertThisInitialized(_this6), _timestamp2, ''); + + _classPrivateFieldSet(_assertThisInitialized(_this6), _readOnlyAfterInit, readOnlyAfterInit); + + return _this6; + } + /** + * Getter for #comment + * @return {string} + */ + + + _createClass(CMICommentsObject, [{ + key: "comment", + get: function get() { + return _classPrivateFieldGet(this, _comment); + } + /** + * Setter for #comment + * @param {string} comment + */ + , + set: function set(comment) { + if (this.initialized && _classPrivateFieldGet(this, _readOnlyAfterInit)) { + throwReadOnlyError(); + } else { + if (check2004ValidFormat(comment, scorm2004_regex.CMILangString4000, true)) { + _classPrivateFieldSet(this, _comment, comment); + } + } + } + /** + * Getter for #location + * @return {string} + */ + + }, { + key: "location", + get: function get() { + return _classPrivateFieldGet(this, _location2); + } + /** + * Setter for #location + * @param {string} location + */ + , + set: function set(location) { + if (this.initialized && _classPrivateFieldGet(this, _readOnlyAfterInit)) { + throwReadOnlyError(); + } else { + if (check2004ValidFormat(location, scorm2004_regex.CMIString250)) { + _classPrivateFieldSet(this, _location2, location); + } + } + } + /** + * Getter for #timestamp + * @return {string} + */ + + }, { + key: "timestamp", + get: function get() { + return _classPrivateFieldGet(this, _timestamp2); + } + /** + * Setter for #timestamp + * @param {string} timestamp + */ + , + set: function set(timestamp) { + if (this.initialized && _classPrivateFieldGet(this, _readOnlyAfterInit)) { + throwReadOnlyError(); + } else { + if (check2004ValidFormat(timestamp, scorm2004_regex.CMITime)) { + _classPrivateFieldSet(this, _timestamp2, timestamp); + } + } + } + /** + * toJSON for cmi.comments_from_learner.n object + * @return { + * { + * comment: string, + * location: string, + * timestamp: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'comment': this.comment, + 'location': this.location, + 'timestamp': this.timestamp + }; + delete this.jsonString; + return result; + } + }]); + + return CMICommentsObject; +}(_common.BaseCMI); +/** + * Class representing SCORM 2004's cmi.interactions.n.objectives.n object + */ + + +exports.CMICommentsObject = CMICommentsObject; + +var _id3 = new WeakMap(); + +var CMIInteractionsObjectivesObject = /*#__PURE__*/function (_BaseCMI6) { + _inherits(CMIInteractionsObjectivesObject, _BaseCMI6); + + var _super11 = _createSuper(CMIInteractionsObjectivesObject); + + /** + * Constructor for cmi.interactions.n.objectives.n + */ + function CMIInteractionsObjectivesObject() { + var _this7; + + _classCallCheck(this, CMIInteractionsObjectivesObject); + + _this7 = _super11.call(this); + + _id3.set(_assertThisInitialized(_this7), { + writable: true, + value: '' + }); + + return _this7; + } + /** + * Getter for #id + * @return {string} + */ + + + _createClass(CMIInteractionsObjectivesObject, [{ + key: "id", + get: function get() { + return _classPrivateFieldGet(this, _id3); + } + /** + * Setter for #id + * @param {string} id + */ + , + set: function set(id) { + if (check2004ValidFormat(id, scorm2004_regex.CMILongIdentifier)) { + _classPrivateFieldSet(this, _id3, id); + } + } + /** + * toJSON for cmi.interactions.n.objectives.n + * @return { + * { + * id: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'id': this.id + }; + delete this.jsonString; + return result; + } + }]); + + return CMIInteractionsObjectivesObject; +}(_common.BaseCMI); +/** + * Class representing SCORM 2004's cmi.interactions.n.correct_responses.n object + */ + + +exports.CMIInteractionsObjectivesObject = CMIInteractionsObjectivesObject; + +var _pattern = new WeakMap(); + +var CMIInteractionsCorrectResponsesObject = /*#__PURE__*/function (_BaseCMI7) { + _inherits(CMIInteractionsCorrectResponsesObject, _BaseCMI7); + + var _super12 = _createSuper(CMIInteractionsCorrectResponsesObject); + + /** + * Constructor for cmi.interactions.n.correct_responses.n + */ + function CMIInteractionsCorrectResponsesObject() { + var _this8; + + _classCallCheck(this, CMIInteractionsCorrectResponsesObject); + + _this8 = _super12.call(this); + + _pattern.set(_assertThisInitialized(_this8), { + writable: true, + value: '' + }); + + return _this8; + } + /** + * Getter for #pattern + * @return {string} + */ + + + _createClass(CMIInteractionsCorrectResponsesObject, [{ + key: "pattern", + get: function get() { + return _classPrivateFieldGet(this, _pattern); + } + /** + * Setter for #pattern + * @param {string} pattern + */ + , + set: function set(pattern) { + if (check2004ValidFormat(pattern, scorm2004_regex.CMIFeedback)) { + _classPrivateFieldSet(this, _pattern, pattern); + } + } + /** + * toJSON cmi.interactions.n.correct_responses.n object + * @return { + * { + * pattern: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'pattern': this.pattern + }; + delete this.jsonString; + return result; + } + }]); + + return CMIInteractionsCorrectResponsesObject; +}(_common.BaseCMI); +/** + * Class representing SCORM 2004's adl object + */ + + +exports.CMIInteractionsCorrectResponsesObject = CMIInteractionsCorrectResponsesObject; + +var ADL = /*#__PURE__*/function (_BaseCMI8) { + _inherits(ADL, _BaseCMI8); + + var _super13 = _createSuper(ADL); + + /** + * Constructor for adl + */ + function ADL() { + var _this9; + + _classCallCheck(this, ADL); + + _this9 = _super13.call(this); + _this9.nav = new ADLNav(); + return _this9; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(ADL, [{ + key: "initialize", + value: function initialize() { + var _this$nav; + + _get(_getPrototypeOf(ADL.prototype), "initialize", this).call(this); + + (_this$nav = this.nav) === null || _this$nav === void 0 ? void 0 : _this$nav.initialize(); + } + /** + * toJSON for adl + * @return { + * { + * nav: { + * request: string + * } + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'nav': this.nav + }; + delete this.jsonString; + return result; + } + }]); + + return ADL; +}(_common.BaseCMI); +/** + * Class representing SCORM 2004's adl.nav object + */ + + +exports.ADL = ADL; + +var _request = new WeakMap(); + +var ADLNav = /*#__PURE__*/function (_BaseCMI9) { + _inherits(ADLNav, _BaseCMI9); + + var _super14 = _createSuper(ADLNav); + + /** + * Constructor for adl.nav + */ + function ADLNav() { + var _this10; + + _classCallCheck(this, ADLNav); + + _this10 = _super14.call(this); + + _request.set(_assertThisInitialized(_this10), { + writable: true, + value: '_none_' + }); + + _this10.request_valid = new ADLNavRequestValid(); + return _this10; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(ADLNav, [{ + key: "initialize", + value: function initialize() { + var _this$request_valid; + + _get(_getPrototypeOf(ADLNav.prototype), "initialize", this).call(this); + + (_this$request_valid = this.request_valid) === null || _this$request_valid === void 0 ? void 0 : _this$request_valid.initialize(); + } + /** + * Getter for #request + * @return {string} + */ + + }, { + key: "request", + get: function get() { + return _classPrivateFieldGet(this, _request); + } + /** + * Setter for #request + * @param {string} request + */ + , + set: function set(request) { + if (check2004ValidFormat(request, scorm2004_regex.NAVEvent)) { + _classPrivateFieldSet(this, _request, request); + } + } + /** + * toJSON for adl.nav + * + * @return { + * { + * request: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'request': this.request + }; + delete this.jsonString; + return result; + } + }]); + + return ADLNav; +}(_common.BaseCMI); +/** + * Class representing SCORM 2004's adl.nav.request_valid object + */ + + +var _continue = new WeakMap(); + +var _previous = new WeakMap(); + +var ADLNavRequestValid = /*#__PURE__*/function (_BaseCMI10) { + _inherits(ADLNavRequestValid, _BaseCMI10); + + var _super15 = _createSuper(ADLNavRequestValid); + + /** + * Constructor for adl.nav.request_valid + */ + function ADLNavRequestValid() { + var _temp, _temp2; + + var _this11; + + _classCallCheck(this, ADLNavRequestValid); + + _this11 = _super15.call(this); + + _continue.set(_assertThisInitialized(_this11), { + writable: true, + value: 'unknown' + }); + + _previous.set(_assertThisInitialized(_this11), { + writable: true, + value: 'unknown' + }); + + _defineProperty(_assertThisInitialized(_this11), "choice", (_temp = function _temp() { + _classCallCheck(this, _temp); + + _defineProperty(this, "_isTargetValid", function (_target) { + return 'unknown'; + }); + }, _temp)); + + _defineProperty(_assertThisInitialized(_this11), "jump", (_temp2 = function _temp2() { + _classCallCheck(this, _temp2); + + _defineProperty(this, "_isTargetValid", function (_target) { + return 'unknown'; + }); + }, _temp2)); + + return _this11; + } + /** + * Getter for #continue + * @return {string} + */ + + + _createClass(ADLNavRequestValid, [{ + key: "continue", + get: function get() { + return _classPrivateFieldGet(this, _continue); + } + /** + * Setter for #continue. Just throws an error. + * @param {*} _ + */ + , + set: function set(_) { + throwReadOnlyError(); + } + /** + * Getter for #previous + * @return {string} + */ + + }, { + key: "previous", + get: function get() { + return _classPrivateFieldGet(this, _previous); + } + /** + * Setter for #previous. Just throws an error. + * @param {*} _ + */ + , + set: function set(_) { + throwReadOnlyError(); + } + /** + * toJSON for adl.nav.request_valid + * + * @return { + * { + * previous: string, + * continue: string + * } + * } + */ + + }, { + key: "toJSON", + value: function toJSON() { + this.jsonString = true; + var result = { + 'previous': this.previous, + 'continue': this["continue"] + }; + delete this.jsonString; + return result; + } + }]); + + return ADLNavRequestValid; +}(_common.BaseCMI); + +},{"../constants/api_constants":6,"../constants/error_codes":7,"../constants/regex":9,"../constants/response_constants":10,"../exceptions":11,"../utilities":13,"./common":4}],6:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var global = { + SCORM_TRUE: 'true', + SCORM_FALSE: 'false', + STATE_NOT_INITIALIZED: 0, + STATE_INITIALIZED: 1, + STATE_TERMINATED: 2, + LOG_LEVEL_DEBUG: 1, + LOG_LEVEL_INFO: 2, + LOG_LEVEL_WARNING: 3, + LOG_LEVEL_ERROR: 4, + LOG_LEVEL_NONE: 5 +}; +var scorm12 = { + // Children lists + cmi_children: 'core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions', + core_children: 'student_id,student_name,lesson_location,credit,lesson_status,entry,score,total_time,lesson_mode,exit,session_time', + score_children: 'raw,min,max', + comments_children: 'content,location,time', + objectives_children: 'id,score,status', + correct_responses_children: 'pattern', + student_data_children: 'mastery_score,max_time_allowed,time_limit_action', + student_preference_children: 'audio,language,speed,text', + interactions_children: 'id,objectives,time,type,correct_responses,weighting,student_response,result,latency', + error_descriptions: { + '101': { + basicMessage: 'General Exception', + detailMessage: 'No specific error code exists to describe the error. Use LMSGetDiagnostic for more information' + }, + '201': { + basicMessage: 'Invalid argument error', + detailMessage: 'Indicates that an argument represents an invalid data model element or is otherwise incorrect.' + }, + '202': { + basicMessage: 'Element cannot have children', + detailMessage: 'Indicates that LMSGetValue was called with a data model element name that ends in "_children" for a data model element that does not support the "_children" suffix.' + }, + '203': { + basicMessage: 'Element not an array - cannot have count', + detailMessage: 'Indicates that LMSGetValue was called with a data model element name that ends in "_count" for a data model element that does not support the "_count" suffix.' + }, + '301': { + basicMessage: 'Not initialized', + detailMessage: 'Indicates that an API call was made before the call to lmsInitialize.' + }, + '401': { + basicMessage: 'Not implemented error', + detailMessage: 'The data model element indicated in a call to LMSGetValue or LMSSetValue is valid, but was not implemented by this LMS. SCORM 1.2 defines a set of data model elements as being optional for an LMS to implement.' + }, + '402': { + basicMessage: 'Invalid set value, element is a keyword', + detailMessage: 'Indicates that LMSSetValue was called on a data model element that represents a keyword (elements that end in "_children" and "_count").' + }, + '403': { + basicMessage: 'Element is read only', + detailMessage: 'LMSSetValue was called with a data model element that can only be read.' + }, + '404': { + basicMessage: 'Element is write only', + detailMessage: 'LMSGetValue was called on a data model element that can only be written to.' + }, + '405': { + basicMessage: 'Incorrect Data Type', + detailMessage: 'LMSSetValue was called with a value that is not consistent with the data format of the supplied data model element.' + }, + '407': { + basicMessage: 'Element Value Out Of Range', + detailMessage: 'The numeric value supplied to a LMSSetValue call is outside of the numeric range allowed for the supplied data model element.' + }, + '408': { + basicMessage: 'Data Model Dependency Not Established', + detailMessage: 'Some data model elements cannot be set until another data model element was set. This error condition indicates that the prerequisite element was not set before the dependent element.' + } + } +}; + +var aicc = _objectSpread(_objectSpread({}, scorm12), { + cmi_children: 'core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions,evaluation', + student_preference_children: 'audio,language,lesson_type,speed,text,text_color,text_location,text_size,video,windows', + student_data_children: 'attempt_number,tries,mastery_score,max_time_allowed,time_limit_action', + student_demographics_children: 'city,class,company,country,experience,familiar_name,instructor_name,title,native_language,state,street_address,telephone,years_experience', + tries_children: 'time,status,score', + attempt_records_children: 'score,lesson_status', + paths_children: 'location_id,date,time,status,why_left,time_in_element' +}); + +var scorm2004 = { + // Children lists + cmi_children: '_version,comments_from_learner,comments_from_lms,completion_status,credit,entry,exit,interactions,launch_data,learner_id,learner_name,learner_preference,location,max_time_allowed,mode,objectives,progress_measure,scaled_passing_score,score,session_time,success_status,suspend_data,time_limit_action,total_time', + comments_children: 'comment,timestamp,location', + score_children: 'max,raw,scaled,min', + objectives_children: 'progress_measure,completion_status,success_status,description,score,id', + correct_responses_children: 'pattern', + student_data_children: 'mastery_score,max_time_allowed,time_limit_action', + student_preference_children: 'audio_level,audio_captioning,delivery_speed,language', + interactions_children: 'id,type,objectives,timestamp,correct_responses,weighting,learner_response,result,latency,description', + error_descriptions: { + '0': { + basicMessage: 'No Error', + detailMessage: 'No error occurred, the previous API call was successful.' + }, + '101': { + basicMessage: 'General Exception', + detailMessage: 'No specific error code exists to describe the error. Use GetDiagnostic for more information.' + }, + '102': { + basicMessage: 'General Initialization Failure', + detailMessage: 'Call to Initialize failed for an unknown reason.' + }, + '103': { + basicMessage: 'Already Initialized', + detailMessage: 'Call to Initialize failed because Initialize was already called.' + }, + '104': { + basicMessage: 'Content Instance Terminated', + detailMessage: 'Call to Initialize failed because Terminate was already called.' + }, + '111': { + basicMessage: 'General Termination Failure', + detailMessage: 'Call to Terminate failed for an unknown reason.' + }, + '112': { + basicMessage: 'Termination Before Initialization', + detailMessage: 'Call to Terminate failed because it was made before the call to Initialize.' + }, + '113': { + basicMessage: 'Termination After Termination', + detailMessage: 'Call to Terminate failed because Terminate was already called.' + }, + '122': { + basicMessage: 'Retrieve Data Before Initialization', + detailMessage: 'Call to GetValue failed because it was made before the call to Initialize.' + }, + '123': { + basicMessage: 'Retrieve Data After Termination', + detailMessage: 'Call to GetValue failed because it was made after the call to Terminate.' + }, + '132': { + basicMessage: 'Store Data Before Initialization', + detailMessage: 'Call to SetValue failed because it was made before the call to Initialize.' + }, + '133': { + basicMessage: 'Store Data After Termination', + detailMessage: 'Call to SetValue failed because it was made after the call to Terminate.' + }, + '142': { + basicMessage: 'Commit Before Initialization', + detailMessage: 'Call to Commit failed because it was made before the call to Initialize.' + }, + '143': { + basicMessage: 'Commit After Termination', + detailMessage: 'Call to Commit failed because it was made after the call to Terminate.' + }, + '201': { + basicMessage: 'General Argument Error', + detailMessage: 'An invalid argument was passed to an API method (usually indicates that Initialize, Commit or Terminate did not receive the expected empty string argument.' + }, + '301': { + basicMessage: 'General Get Failure', + detailMessage: 'Indicates a failed GetValue call where no other specific error code is applicable. Use GetDiagnostic for more information.' + }, + '351': { + basicMessage: 'General Set Failure', + detailMessage: 'Indicates a failed SetValue call where no other specific error code is applicable. Use GetDiagnostic for more information.' + }, + '391': { + basicMessage: 'General Commit Failure', + detailMessage: 'Indicates a failed Commit call where no other specific error code is applicable. Use GetDiagnostic for more information.' + }, + '401': { + basicMessage: 'Undefined Data Model Element', + detailMessage: 'The data model element name passed to GetValue or SetValue is not a valid SCORM data model element.' + }, + '402': { + basicMessage: 'Unimplemented Data Model Element', + detailMessage: 'The data model element indicated in a call to GetValue or SetValue is valid, but was not implemented by this LMS. In SCORM 2004, this error would indicate an LMS that is not fully SCORM conformant.' + }, + '403': { + basicMessage: 'Data Model Element Value Not Initialized', + detailMessage: 'Attempt to read a data model element that has not been initialized by the LMS or through a SetValue call. This error condition is often reached during normal execution of a SCO.' + }, + '404': { + basicMessage: 'Data Model Element Is Read Only', + detailMessage: 'SetValue was called with a data model element that can only be read.' + }, + '405': { + basicMessage: 'Data Model Element Is Write Only', + detailMessage: 'GetValue was called on a data model element that can only be written to.' + }, + '406': { + basicMessage: 'Data Model Element Type Mismatch', + detailMessage: 'SetValue was called with a value that is not consistent with the data format of the supplied data model element.' + }, + '407': { + basicMessage: 'Data Model Element Value Out Of Range', + detailMessage: 'The numeric value supplied to a SetValue call is outside of the numeric range allowed for the supplied data model element.' + }, + '408': { + basicMessage: 'Data Model Dependency Not Established', + detailMessage: 'Some data model elements cannot be set until another data model element was set. This error condition indicates that the prerequisite element was not set before the dependent element.' + } + } +}; +var APIConstants = { + global: global, + scorm12: scorm12, + aicc: aicc, + scorm2004: scorm2004 +}; +var _default = APIConstants; +exports["default"] = _default; + +},{}],7:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var global = { + GENERAL: 101, + INITIALIZATION_FAILED: 101, + INITIALIZED: 101, + TERMINATED: 101, + TERMINATION_FAILURE: 101, + TERMINATION_BEFORE_INIT: 101, + MULTIPLE_TERMINATION: 101, + RETRIEVE_BEFORE_INIT: 101, + RETRIEVE_AFTER_TERM: 101, + STORE_BEFORE_INIT: 101, + STORE_AFTER_TERM: 101, + COMMIT_BEFORE_INIT: 101, + COMMIT_AFTER_TERM: 101, + ARGUMENT_ERROR: 101, + CHILDREN_ERROR: 101, + COUNT_ERROR: 101, + GENERAL_GET_FAILURE: 101, + GENERAL_SET_FAILURE: 101, + GENERAL_COMMIT_FAILURE: 101, + UNDEFINED_DATA_MODEL: 101, + UNIMPLEMENTED_ELEMENT: 101, + VALUE_NOT_INITIALIZED: 101, + INVALID_SET_VALUE: 101, + READ_ONLY_ELEMENT: 101, + WRITE_ONLY_ELEMENT: 101, + TYPE_MISMATCH: 101, + VALUE_OUT_OF_RANGE: 101, + DEPENDENCY_NOT_ESTABLISHED: 101 +}; + +var scorm12 = _objectSpread(_objectSpread({}, global), { + RETRIEVE_BEFORE_INIT: 301, + STORE_BEFORE_INIT: 301, + COMMIT_BEFORE_INIT: 301, + ARGUMENT_ERROR: 201, + CHILDREN_ERROR: 202, + COUNT_ERROR: 203, + UNDEFINED_DATA_MODEL: 401, + UNIMPLEMENTED_ELEMENT: 401, + VALUE_NOT_INITIALIZED: 301, + INVALID_SET_VALUE: 402, + READ_ONLY_ELEMENT: 403, + WRITE_ONLY_ELEMENT: 404, + TYPE_MISMATCH: 405, + VALUE_OUT_OF_RANGE: 407, + DEPENDENCY_NOT_ESTABLISHED: 408 +}); + +var scorm2004 = _objectSpread(_objectSpread({}, global), { + INITIALIZATION_FAILED: 102, + INITIALIZED: 103, + TERMINATED: 104, + TERMINATION_FAILURE: 111, + TERMINATION_BEFORE_INIT: 112, + MULTIPLE_TERMINATIONS: 113, + RETRIEVE_BEFORE_INIT: 122, + RETRIEVE_AFTER_TERM: 123, + STORE_BEFORE_INIT: 132, + STORE_AFTER_TERM: 133, + COMMIT_BEFORE_INIT: 142, + COMMIT_AFTER_TERM: 143, + ARGUMENT_ERROR: 201, + GENERAL_GET_FAILURE: 301, + GENERAL_SET_FAILURE: 351, + GENERAL_COMMIT_FAILURE: 391, + UNDEFINED_DATA_MODEL: 401, + UNIMPLEMENTED_ELEMENT: 402, + VALUE_NOT_INITIALIZED: 403, + READ_ONLY_ELEMENT: 404, + WRITE_ONLY_ELEMENT: 405, + TYPE_MISMATCH: 406, + VALUE_OUT_OF_RANGE: 407, + DEPENDENCY_NOT_ESTABLISHED: 408 +}); + +var ErrorCodes = { + scorm12: scorm12, + scorm2004: scorm2004 +}; +var _default = ErrorCodes; +exports["default"] = _default; + +},{}],8:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; +var ValidLanguages = { + 'aa': 'aa', + 'ab': 'ab', + 'ae': 'ae', + 'af': 'af', + 'ak': 'ak', + 'am': 'am', + 'an': 'an', + 'ar': 'ar', + 'as': 'as', + 'av': 'av', + 'ay': 'ay', + 'az': 'az', + 'ba': 'ba', + 'be': 'be', + 'bg': 'bg', + 'bh': 'bh', + 'bi': 'bi', + 'bm': 'bm', + 'bn': 'bn', + 'bo': 'bo', + 'br': 'br', + 'bs': 'bs', + 'ca': 'ca', + 'ce': 'ce', + 'ch': 'ch', + 'co': 'co', + 'cr': 'cr', + 'cs': 'cs', + 'cu': 'cu', + 'cv': 'cv', + 'cy': 'cy', + 'da': 'da', + 'de': 'de', + 'dv': 'dv', + 'dz': 'dz', + 'ee': 'ee', + 'el': 'el', + 'en': 'en', + 'eo': 'eo', + 'es': 'es', + 'et': 'et', + 'eu': 'eu', + 'fa': 'fa', + 'ff': 'ff', + 'fi': 'fi', + 'fj': 'fj', + 'fo': 'fo', + 'fr': 'fr', + 'fy': 'fy', + 'ga': 'ga', + 'gd': 'gd', + 'gl': 'gl', + 'gn': 'gn', + 'gu': 'gu', + 'gv': 'gv', + 'ha': 'ha', + 'he': 'he', + 'hi': 'hi', + 'ho': 'ho', + 'hr': 'hr', + 'ht': 'ht', + 'hu': 'hu', + 'hy': 'hy', + 'hz': 'hz', + 'ia': 'ia', + 'id': 'id', + 'ie': 'ie', + 'ig': 'ig', + 'ii': 'ii', + 'ik': 'ik', + 'io': 'io', + 'is': 'is', + 'it': 'it', + 'iu': 'iu', + 'ja': 'ja', + 'jv': 'jv', + 'ka': 'ka', + 'kg': 'kg', + 'ki': 'ki', + 'kj': 'kj', + 'kk': 'kk', + 'kl': 'kl', + 'km': 'km', + 'kn': 'kn', + 'ko': 'ko', + 'kr': 'kr', + 'ks': 'ks', + 'ku': 'ku', + 'kv': 'kv', + 'kw': 'kw', + 'ky': 'ky', + 'la': 'la', + 'lb': 'lb', + 'lg': 'lg', + 'li': 'li', + 'ln': 'ln', + 'lo': 'lo', + 'lt': 'lt', + 'lu': 'lu', + 'lv': 'lv', + 'mg': 'mg', + 'mh': 'mh', + 'mi': 'mi', + 'mk': 'mk', + 'ml': 'ml', + 'mn': 'mn', + 'mo': 'mo', + 'mr': 'mr', + 'ms': 'ms', + 'mt': 'mt', + 'my': 'my', + 'na': 'na', + 'nb': 'nb', + 'nd': 'nd', + 'ne': 'ne', + 'ng': 'ng', + 'nl': 'nl', + 'nn': 'nn', + 'no': 'no', + 'nr': 'nr', + 'nv': 'nv', + 'ny': 'ny', + 'oc': 'oc', + 'oj': 'oj', + 'om': 'om', + 'or': 'or', + 'os': 'os', + 'pa': 'pa', + 'pi': 'pi', + 'pl': 'pl', + 'ps': 'ps', + 'pt': 'pt', + 'qu': 'qu', + 'rm': 'rm', + 'rn': 'rn', + 'ro': 'ro', + 'ru': 'ru', + 'rw': 'rw', + 'sa': 'sa', + 'sc': 'sc', + 'sd': 'sd', + 'se': 'se', + 'sg': 'sg', + 'sh': 'sh', + 'si': 'si', + 'sk': 'sk', + 'sl': 'sl', + 'sm': 'sm', + 'sn': 'sn', + 'so': 'so', + 'sq': 'sq', + 'sr': 'sr', + 'ss': 'ss', + 'st': 'st', + 'su': 'su', + 'sv': 'sv', + 'sw': 'sw', + 'ta': 'ta', + 'te': 'te', + 'tg': 'tg', + 'th': 'th', + 'ti': 'ti', + 'tk': 'tk', + 'tl': 'tl', + 'tn': 'tn', + 'to': 'to', + 'tr': 'tr', + 'ts': 'ts', + 'tt': 'tt', + 'tw': 'tw', + 'ty': 'ty', + 'ug': 'ug', + 'uk': 'uk', + 'ur': 'ur', + 'uz': 'uz', + 've': 've', + 'vi': 'vi', + 'vo': 'vo', + 'wa': 'wa', + 'wo': 'wo', + 'xh': 'xh', + 'yi': 'yi', + 'yo': 'yo', + 'za': 'za', + 'zh': 'zh', + 'zu': 'zu', + 'aar': 'aar', + 'abk': 'abk', + 'ave': 'ave', + 'afr': 'afr', + 'aka': 'aka', + 'amh': 'amh', + 'arg': 'arg', + 'ara': 'ara', + 'asm': 'asm', + 'ava': 'ava', + 'aym': 'aym', + 'aze': 'aze', + 'bak': 'bak', + 'bel': 'bel', + 'bul': 'bul', + 'bih': 'bih', + 'bis': 'bis', + 'bam': 'bam', + 'ben': 'ben', + 'tib': 'tib', + 'bod': 'bod', + 'bre': 'bre', + 'bos': 'bos', + 'cat': 'cat', + 'che': 'che', + 'cha': 'cha', + 'cos': 'cos', + 'cre': 'cre', + 'cze': 'cze', + 'ces': 'ces', + 'chu': 'chu', + 'chv': 'chv', + 'wel': 'wel', + 'cym': 'cym', + 'dan': 'dan', + 'ger': 'ger', + 'deu': 'deu', + 'div': 'div', + 'dzo': 'dzo', + 'ewe': 'ewe', + 'gre': 'gre', + 'ell': 'ell', + 'eng': 'eng', + 'epo': 'epo', + 'spa': 'spa', + 'est': 'est', + 'baq': 'baq', + 'eus': 'eus', + 'per': 'per', + 'fas': 'fas', + 'ful': 'ful', + 'fin': 'fin', + 'fij': 'fij', + 'fao': 'fao', + 'fre': 'fre', + 'fra': 'fra', + 'fry': 'fry', + 'gle': 'gle', + 'gla': 'gla', + 'glg': 'glg', + 'grn': 'grn', + 'guj': 'guj', + 'glv': 'glv', + 'hau': 'hau', + 'heb': 'heb', + 'hin': 'hin', + 'hmo': 'hmo', + 'hrv': 'hrv', + 'hat': 'hat', + 'hun': 'hun', + 'arm': 'arm', + 'hye': 'hye', + 'her': 'her', + 'ina': 'ina', + 'ind': 'ind', + 'ile': 'ile', + 'ibo': 'ibo', + 'iii': 'iii', + 'ipk': 'ipk', + 'ido': 'ido', + 'ice': 'ice', + 'isl': 'isl', + 'ita': 'ita', + 'iku': 'iku', + 'jpn': 'jpn', + 'jav': 'jav', + 'geo': 'geo', + 'kat': 'kat', + 'kon': 'kon', + 'kik': 'kik', + 'kua': 'kua', + 'kaz': 'kaz', + 'kal': 'kal', + 'khm': 'khm', + 'kan': 'kan', + 'kor': 'kor', + 'kau': 'kau', + 'kas': 'kas', + 'kur': 'kur', + 'kom': 'kom', + 'cor': 'cor', + 'kir': 'kir', + 'lat': 'lat', + 'ltz': 'ltz', + 'lug': 'lug', + 'lim': 'lim', + 'lin': 'lin', + 'lao': 'lao', + 'lit': 'lit', + 'lub': 'lub', + 'lav': 'lav', + 'mlg': 'mlg', + 'mah': 'mah', + 'mao': 'mao', + 'mri': 'mri', + 'mac': 'mac', + 'mkd': 'mkd', + 'mal': 'mal', + 'mon': 'mon', + 'mol': 'mol', + 'mar': 'mar', + 'may': 'may', + 'msa': 'msa', + 'mlt': 'mlt', + 'bur': 'bur', + 'mya': 'mya', + 'nau': 'nau', + 'nob': 'nob', + 'nde': 'nde', + 'nep': 'nep', + 'ndo': 'ndo', + 'dut': 'dut', + 'nld': 'nld', + 'nno': 'nno', + 'nor': 'nor', + 'nbl': 'nbl', + 'nav': 'nav', + 'nya': 'nya', + 'oci': 'oci', + 'oji': 'oji', + 'orm': 'orm', + 'ori': 'ori', + 'oss': 'oss', + 'pan': 'pan', + 'pli': 'pli', + 'pol': 'pol', + 'pus': 'pus', + 'por': 'por', + 'que': 'que', + 'roh': 'roh', + 'run': 'run', + 'rum': 'rum', + 'ron': 'ron', + 'rus': 'rus', + 'kin': 'kin', + 'san': 'san', + 'srd': 'srd', + 'snd': 'snd', + 'sme': 'sme', + 'sag': 'sag', + 'slo': 'slo', + 'sin': 'sin', + 'slk': 'slk', + 'slv': 'slv', + 'smo': 'smo', + 'sna': 'sna', + 'som': 'som', + 'alb': 'alb', + 'sqi': 'sqi', + 'srp': 'srp', + 'ssw': 'ssw', + 'sot': 'sot', + 'sun': 'sun', + 'swe': 'swe', + 'swa': 'swa', + 'tam': 'tam', + 'tel': 'tel', + 'tgk': 'tgk', + 'tha': 'tha', + 'tir': 'tir', + 'tuk': 'tuk', + 'tgl': 'tgl', + 'tsn': 'tsn', + 'ton': 'ton', + 'tur': 'tur', + 'tso': 'tso', + 'tat': 'tat', + 'twi': 'twi', + 'tah': 'tah', + 'uig': 'uig', + 'ukr': 'ukr', + 'urd': 'urd', + 'uzb': 'uzb', + 'ven': 'ven', + 'vie': 'vie', + 'vol': 'vol', + 'wln': 'wln', + 'wol': 'wol', + 'xho': 'xho', + 'yid': 'yid', + 'yor': 'yor', + 'zha': 'zha', + 'chi': 'chi', + 'zho': 'zho', + 'zul': 'zul' +}; +var _default = ValidLanguages; +exports["default"] = _default; + +},{}],9:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +var scorm12 = { + CMIString256: '^.{0,255}$', + CMIString4096: '^.{0,4096}$', + CMITime: '^(?:[01]\\d|2[0123]):(?:[012345]\\d):(?:[012345]\\d)$', + // eslint-disable-line + CMITimespan: '^([0-9]{2,}):([0-9]{2}):([0-9]{2})(\.[0-9]{1,2})?$', + // eslint-disable-line + CMIInteger: '^\\d+$', + CMISInteger: '^-?([0-9]+)$', + CMIDecimal: '^-?([0-9]{0,3})(\.[0-9]*)?$', + // eslint-disable-line + CMIIdentifier: "^[\\u0021-\\u007E\\s]{0,255}$", + CMIFeedback: '^.{0,255}$', + // This must be redefined + CMIIndex: '[._](\\d+).', + // Vocabulary Data Type Definition + CMIStatus: '^(passed|completed|failed|incomplete|browsed)$', + CMIStatus2: '^(passed|completed|failed|incomplete|browsed|not attempted)$', + CMIExit: '^(time-out|suspend|logout|)$', + CMIType: '^(true-false|choice|fill-in|matching|performance|sequencing|likert|numeric)$', + CMIResult: '^(correct|wrong|unanticipated|neutral|([0-9]{0,3})?(\\.[0-9]*)?)$', + // eslint-disable-line + NAVEvent: '^(previous|continue)$', + // Data ranges + score_range: '0#100', + audio_range: '-1#100', + speed_range: '-100#100', + weighting_range: '-100#100', + text_range: '-1#1' +}; + +var aicc = _objectSpread(_objectSpread({}, scorm12), { + CMIIdentifier: '^\\w{1,255}$' +}); + +var scorm2004 = { + CMIString200: "^[\\u0000-\\uFFFF]{0,200}$", + CMIString250: "^[\\u0000-\\uFFFF]{0,250}$", + CMIString1000: "^[\\u0000-\\uFFFF]{0,1000}$", + CMIString4000: "^[\\u0000-\\uFFFF]{0,4000}$", + CMIString64000: "^[\\u0000-\\uFFFF]{0,64000}$", + CMILang: '^([a-zA-Z]{2,3}|i|x)(\-[a-zA-Z0-9\-]{2,8})?$|^$', + // eslint-disable-line + CMILangString250: '^(\{lang=([a-zA-Z]{2,3}|i|x)(\-[a-zA-Z0-9\-]{2,8})?\})?((?!\{.*$).{0,250}$)?$', + // eslint-disable-line + CMILangcr: '^((\{lang=([a-zA-Z]{2,3}|i|x)?(\-[a-zA-Z0-9\-]{2,8})?\}))(.*?)$', + // eslint-disable-line + CMILangString250cr: '^((\{lang=([a-zA-Z]{2,3}|i|x)?(\-[a-zA-Z0-9\-]{2,8})?\})?(.{0,250})?)?$', + // eslint-disable-line + CMILangString4000: '^(\{lang=([a-zA-Z]{2,3}|i|x)(\-[a-zA-Z0-9\-]{2,8})?\})?((?!\{.*$).{0,4000}$)?$', + // eslint-disable-line + CMITime: '^(19[7-9]{1}[0-9]{1}|20[0-2]{1}[0-9]{1}|203[0-8]{1})((-(0[1-9]{1}|1[0-2]{1}))((-(0[1-9]{1}|[1-2]{1}[0-9]{1}|3[0-1]{1}))(T([0-1]{1}[0-9]{1}|2[0-3]{1})((:[0-5]{1}[0-9]{1})((:[0-5]{1}[0-9]{1})((\\.[0-9]{1,2})((Z|([+|-]([0-1]{1}[0-9]{1}|2[0-3]{1})))(:[0-5]{1}[0-9]{1})?)?)?)?)?)?)?)?$', + CMITimespan: '^P(?:([.,\\d]+)Y)?(?:([.,\\d]+)M)?(?:([.,\\d]+)W)?(?:([.,\\d]+)D)?(?:T?(?:([.,\\d]+)H)?(?:([.,\\d]+)M)?(?:([.,\\d]+)S)?)?$', + CMIInteger: '^\\d+$', + CMISInteger: '^-?([0-9]+)$', + CMIDecimal: '^-?([0-9]{1,5})(\\.[0-9]{1,18})?$', + CMIIdentifier: '^\\S{1,250}[a-zA-Z0-9]$', + CMIShortIdentifier: '^[\\w\\.\\-\\_]{1,250}$', + // eslint-disable-line + CMILongIdentifier: '^(?:(?!urn:)\\S{1,4000}|urn:[A-Za-z0-9-]{1,31}:\\S{1,4000}|.{1,4000})$', + // need to re-examine this + CMIFeedback: '^.*$', + // This must be redefined + CMIIndex: '[._](\\d+).', + CMIIndexStore: '.N(\\d+).', + // Vocabulary Data Type Definition + CMICStatus: '^(completed|incomplete|not attempted|unknown)$', + CMISStatus: '^(passed|failed|unknown)$', + CMIExit: '^(time-out|suspend|logout|normal)$', + CMIType: '^(true-false|choice|fill-in|long-fill-in|matching|performance|sequencing|likert|numeric|other)$', + CMIResult: '^(correct|incorrect|unanticipated|neutral|-?([0-9]{1,4})(\\.[0-9]{1,18})?)$', + NAVEvent: '^(previous|continue|exit|exitAll|abandon|abandonAll|suspendAll|\{target=\\S{0,200}[a-zA-Z0-9]\}choice|jump)$', + // eslint-disable-line + NAVBoolean: '^(unknown|true|false$)', + NAVTarget: '^(previous|continue|choice.{target=\\S{0,200}[a-zA-Z0-9]})$', + // Data ranges + scaled_range: '-1#1', + audio_range: '0#*', + speed_range: '0#*', + text_range: '-1#1', + progress_range: '0#1' +}; +var Regex = { + aicc: aicc, + scorm12: scorm12, + scorm2004: scorm2004 +}; +var _default = Regex; +exports["default"] = _default; + +},{}],10:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports["default"] = void 0; + +var _regex = _interopRequireDefault(require("./regex")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +var scorm2004_regex = _regex["default"].scorm2004; +var learner = { + 'true-false': { + format: '^true$|^false$', + max: 1, + delimiter: '', + unique: false + }, + 'choice': { + format: scorm2004_regex.CMIShortIdentifier, + max: 36, + delimiter: '[,]', + unique: true + }, + 'fill-in': { + format: scorm2004_regex.CMILangString250, + max: 10, + delimiter: '[,]', + unique: false + }, + 'long-fill-in': { + format: scorm2004_regex.CMILangString4000, + max: 1, + delimiter: '', + unique: false + }, + 'matching': { + format: scorm2004_regex.CMIShortIdentifier, + format2: scorm2004_regex.CMIShortIdentifier, + max: 36, + delimiter: '[,]', + delimiter2: '[.]', + unique: false + }, + 'performance': { + format: '^$|' + scorm2004_regex.CMIShortIdentifier, + format2: scorm2004_regex.CMIDecimal + '|^$|' + scorm2004_regex.CMIShortIdentifier, + max: 250, + delimiter: '[,]', + delimiter2: '[.]', + unique: false + }, + 'sequencing': { + format: scorm2004_regex.CMIShortIdentifier, + max: 36, + delimiter: '[,]', + unique: false + }, + 'likert': { + format: scorm2004_regex.CMIShortIdentifier, + max: 1, + delimiter: '', + unique: false + }, + 'numeric': { + format: scorm2004_regex.CMIDecimal, + max: 1, + delimiter: '', + unique: false + }, + 'other': { + format: scorm2004_regex.CMIString4000, + max: 1, + delimiter: '', + unique: false + } +}; +var correct = { + 'true-false': { + max: 1, + delimiter: '', + unique: false, + duplicate: false, + format: '^true$|^false$', + limit: 1 + }, + 'choice': { + max: 36, + delimiter: '[,]', + unique: true, + duplicate: false, + format: scorm2004_regex.CMIShortIdentifier + }, + 'fill-in': { + max: 10, + delimiter: '[,]', + unique: false, + duplicate: false, + format: scorm2004_regex.CMILangString250cr + }, + 'long-fill-in': { + max: 1, + delimiter: '', + unique: false, + duplicate: true, + format: scorm2004_regex.CMILangString4000 + }, + 'matching': { + max: 36, + delimiter: '[,]', + delimiter2: '[.]', + unique: false, + duplicate: false, + format: scorm2004_regex.CMIShortIdentifier, + format2: scorm2004_regex.CMIShortIdentifier + }, + 'performance': { + max: 250, + delimiter: '[,]', + delimiter2: '[.]', + unique: false, + duplicate: false, + format: '^$|' + scorm2004_regex.CMIShortIdentifier, + format2: scorm2004_regex.CMIDecimal + '|^$|' + scorm2004_regex.CMIShortIdentifier + }, + 'sequencing': { + max: 36, + delimiter: '[,]', + unique: false, + duplicate: false, + format: scorm2004_regex.CMIShortIdentifier + }, + 'likert': { + max: 1, + delimiter: '', + unique: false, + duplicate: false, + format: scorm2004_regex.CMIShortIdentifier, + limit: 1 + }, + 'numeric': { + max: 2, + delimiter: '[:]', + unique: false, + duplicate: false, + format: scorm2004_regex.CMIDecimal, + limit: 1 + }, + 'other': { + max: 1, + delimiter: '', + unique: false, + duplicate: false, + format: scorm2004_regex.CMIString4000, + limit: 1 + } +}; +var Responses = { + learner: learner, + correct: correct +}; +var _default = Responses; +exports["default"] = _default; + +},{"./regex":9}],11:[function(require,module,exports){ +"use strict"; + +function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.Scorm2004ValidationError = exports.AICCValidationError = exports.Scorm12ValidationError = exports.ValidationError = void 0; + +var _api_constants = _interopRequireDefault(require("./constants/api_constants")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); } + +function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); } + +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } + +function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } + +function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); } + +function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; } + +function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; } + +function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); } + +function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } } + +var scorm12_errors = _api_constants["default"].scorm12.error_descriptions; +var aicc_errors = _api_constants["default"].aicc.error_descriptions; +var scorm2004_errors = _api_constants["default"].scorm2004.error_descriptions; +/** + * Base Validation Exception + */ + +var _errorCode = new WeakMap(); + +var _errorMessage = new WeakMap(); + +var _detailedMessage = new WeakMap(); + +var ValidationError = /*#__PURE__*/function (_Error) { + _inherits(ValidationError, _Error); + + var _super = _createSuper(ValidationError); + + /** + * Constructor to take in an error message and code + * @param {number} errorCode + * @param {string} errorMessage + * @param {string} detailedMessage + */ + function ValidationError(errorCode, errorMessage, detailedMessage) { + var _this; + + _classCallCheck(this, ValidationError); + + _this = _super.call(this, errorMessage); + + _errorCode.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _errorMessage.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _detailedMessage.set(_assertThisInitialized(_this), { + writable: true, + value: void 0 + }); + + _classPrivateFieldSet(_assertThisInitialized(_this), _errorCode, errorCode); + + _classPrivateFieldSet(_assertThisInitialized(_this), _errorMessage, errorMessage); + + _classPrivateFieldSet(_assertThisInitialized(_this), _detailedMessage, detailedMessage); + + return _this; + } + + _createClass(ValidationError, [{ + key: "errorCode", + get: + /** + * Getter for #errorCode + * @return {number} + */ + function get() { + return _classPrivateFieldGet(this, _errorCode); + } + /** + * Getter for #errorMessage + * @return {string} + */ + + }, { + key: "errorMessage", + get: function get() { + return _classPrivateFieldGet(this, _errorMessage); + } + /** + * Getter for #detailedMessage + * @return {string} + */ + + }, { + key: "detailedMessage", + get: function get() { + return _classPrivateFieldGet(this, _detailedMessage); + } + }]); + + return ValidationError; +}( /*#__PURE__*/_wrapNativeSuper(Error)); +/** + * SCORM 1.2 Validation Error + */ + + +exports.ValidationError = ValidationError; + +var Scorm12ValidationError = /*#__PURE__*/function (_ValidationError) { + _inherits(Scorm12ValidationError, _ValidationError); + + var _super2 = _createSuper(Scorm12ValidationError); + + /** + * Constructor to take in an error code + * @param {number} errorCode + */ + function Scorm12ValidationError(errorCode) { + var _this2; + + _classCallCheck(this, Scorm12ValidationError); + + if ({}.hasOwnProperty.call(scorm12_errors, String(errorCode))) { + _this2 = _super2.call(this, errorCode, scorm12_errors[String(errorCode)].basicMessage, scorm12_errors[String(errorCode)].detailMessage); + } else { + _this2 = _super2.call(this, 101, scorm12_errors['101'].basicMessage, scorm12_errors['101'].detailMessage); + } + + return _possibleConstructorReturn(_this2); + } + + return Scorm12ValidationError; +}(ValidationError); +/** + * AICC Validation Error + */ + + +exports.Scorm12ValidationError = Scorm12ValidationError; + +var AICCValidationError = /*#__PURE__*/function (_ValidationError2) { + _inherits(AICCValidationError, _ValidationError2); + + var _super3 = _createSuper(AICCValidationError); + + /** + * Constructor to take in an error code + * @param {number} errorCode + */ + function AICCValidationError(errorCode) { + var _this3; + + _classCallCheck(this, AICCValidationError); + + if ({}.hasOwnProperty.call(aicc_errors, String(errorCode))) { + _this3 = _super3.call(this, errorCode, aicc_errors[String(errorCode)].basicMessage, aicc_errors[String(errorCode)].detailMessage); + } else { + _this3 = _super3.call(this, 101, aicc_errors['101'].basicMessage, aicc_errors['101'].detailMessage); + } + + return _possibleConstructorReturn(_this3); + } + + return AICCValidationError; +}(ValidationError); +/** + * SCORM 2004 Validation Error + */ + + +exports.AICCValidationError = AICCValidationError; + +var Scorm2004ValidationError = /*#__PURE__*/function (_ValidationError3) { + _inherits(Scorm2004ValidationError, _ValidationError3); + + var _super4 = _createSuper(Scorm2004ValidationError); + + /** + * Constructor to take in an error code + * @param {number} errorCode + */ + function Scorm2004ValidationError(errorCode) { + var _this4; + + _classCallCheck(this, Scorm2004ValidationError); + + if ({}.hasOwnProperty.call(scorm2004_errors, String(errorCode))) { + _this4 = _super4.call(this, errorCode, scorm2004_errors[String(errorCode)].basicMessage, scorm2004_errors[String(errorCode)].detailMessage); + } else { + _this4 = _super4.call(this, 101, scorm2004_errors['101'].basicMessage, scorm2004_errors['101'].detailMessage); + } + + return _possibleConstructorReturn(_this4); + } + + return Scorm2004ValidationError; +}(ValidationError); + +exports.Scorm2004ValidationError = Scorm2004ValidationError; + +},{"./constants/api_constants":6}],12:[function(require,module,exports){ +"use strict"; + +var _Scorm2004API = _interopRequireDefault(require("../Scorm2004API")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } + +window.Scorm2004API = _Scorm2004API["default"]; + +},{"../Scorm2004API":3}],13:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.getSecondsAsHHMMSS = getSecondsAsHHMMSS; +exports.getSecondsAsISODuration = getSecondsAsISODuration; +exports.getTimeAsSeconds = getTimeAsSeconds; +exports.getDurationAsSeconds = getDurationAsSeconds; +exports.addTwoDurations = addTwoDurations; +exports.addHHMMSSTimeStrings = addHHMMSSTimeStrings; +exports.flatten = flatten; +exports.unflatten = unflatten; +exports.countDecimals = countDecimals; +exports.SECONDS_PER_DAY = exports.SECONDS_PER_HOUR = exports.SECONDS_PER_MINUTE = exports.SECONDS_PER_SECOND = void 0; + +function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); } + +function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } + +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } + +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; } + +function _iterableToArrayLimit(arr, i) { var _i = arr && (typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]); if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } + +var SECONDS_PER_SECOND = 1.0; +exports.SECONDS_PER_SECOND = SECONDS_PER_SECOND; +var SECONDS_PER_MINUTE = 60; +exports.SECONDS_PER_MINUTE = SECONDS_PER_MINUTE; +var SECONDS_PER_HOUR = 60 * SECONDS_PER_MINUTE; +exports.SECONDS_PER_HOUR = SECONDS_PER_HOUR; +var SECONDS_PER_DAY = 24 * SECONDS_PER_HOUR; +exports.SECONDS_PER_DAY = SECONDS_PER_DAY; +var designations = [['D', SECONDS_PER_DAY], ['H', SECONDS_PER_HOUR], ['M', SECONDS_PER_MINUTE], ['S', SECONDS_PER_SECOND]]; +/** + * Converts a Number to a String of HH:MM:SS + * + * @param {Number} totalSeconds + * @return {string} + */ + +function getSecondsAsHHMMSS(totalSeconds) { + // SCORM spec does not deal with negative durations, give zero back + if (!totalSeconds || totalSeconds <= 0) { + return '00:00:00'; + } + + var hours = Math.floor(totalSeconds / SECONDS_PER_HOUR); + var dateObj = new Date(totalSeconds * 1000); + var minutes = dateObj.getUTCMinutes(); // make sure we add any possible decimal value + + var seconds = dateObj.getSeconds(); + var ms = totalSeconds % 1.0; + var msStr = ''; + + if (countDecimals(ms) > 0) { + if (countDecimals(ms) > 2) { + msStr = ms.toFixed(2); + } else { + msStr = String(ms); + } + + msStr = '.' + msStr.split('.')[1]; + } + + return (hours + ':' + minutes + ':' + seconds).replace(/\b\d\b/g, '0$&') + msStr; +} +/** + * Calculate the number of seconds from ISO 8601 Duration + * + * @param {Number} seconds + * @return {String} + */ + + +function getSecondsAsISODuration(seconds) { + // SCORM spec does not deal with negative durations, give zero back + if (!seconds || seconds <= 0) { + return 'PT0S'; + } + + var duration = 'P'; + var remainder = seconds; + designations.forEach(function (_ref) { + var _ref2 = _slicedToArray(_ref, 2), + sign = _ref2[0], + current_seconds = _ref2[1]; + + var value = Math.floor(remainder / current_seconds); + remainder = remainder % current_seconds; + + if (countDecimals(remainder) > 2) { + remainder = Number(Number(remainder).toFixed(2)); + } // If we have anything left in the remainder, and we're currently adding + // seconds to the duration, go ahead and add the decimal to the seconds + + + if (sign === 'S' && remainder > 0) { + value += remainder; + } + + if (value) { + if ((duration.indexOf('D') > 0 || sign === 'H' || sign === 'M' || sign === 'S') && duration.indexOf('T') === -1) { + duration += 'T'; + } + + duration += "".concat(value).concat(sign); + } + }); + return duration; +} +/** + * Calculate the number of seconds from HH:MM:SS.DDDDDD + * + * @param {string} timeString + * @param {RegExp} timeRegex + * @return {number} + */ + + +function getTimeAsSeconds(timeString, timeRegex) { + if (!timeString || typeof timeString !== 'string' || !timeString.match(timeRegex)) { + return 0; + } + + var parts = timeString.split(':'); + var hours = Number(parts[0]); + var minutes = Number(parts[1]); + var seconds = Number(parts[2]); + return hours * 3600 + minutes * 60 + seconds; +} +/** + * Calculate the number of seconds from ISO 8601 Duration + * + * @param {string} duration + * @param {RegExp} durationRegex + * @return {number} + */ + + +function getDurationAsSeconds(duration, durationRegex) { + if (!duration || !duration.match(durationRegex)) { + return 0; + } + + var _ref3 = new RegExp(durationRegex).exec(duration) || [], + _ref4 = _slicedToArray(_ref3, 8), + years = _ref4[1], + months = _ref4[2], + days = _ref4[4], + hours = _ref4[5], + minutes = _ref4[6], + seconds = _ref4[7]; + + var result = 0.0; + result += Number(seconds) * 1.0 || 0.0; + result += Number(minutes) * 60.0 || 0.0; + result += Number(hours) * 3600.0 || 0.0; + result += Number(days) * (60 * 60 * 24.0) || 0.0; + result += Number(years) * (60 * 60 * 24 * 365.0) || 0.0; + return result; +} +/** + * Adds together two ISO8601 Duration strings + * + * @param {string} first + * @param {string} second + * @param {RegExp} durationRegex + * @return {string} + */ + + +function addTwoDurations(first, second, durationRegex) { + return getSecondsAsISODuration(getDurationAsSeconds(first, durationRegex) + getDurationAsSeconds(second, durationRegex)); +} +/** + * Add together two HH:MM:SS.DD strings + * + * @param {string} first + * @param {string} second + * @param {RegExp} timeRegex + * @return {string} + */ + + +function addHHMMSSTimeStrings(first, second, timeRegex) { + return getSecondsAsHHMMSS(getTimeAsSeconds(first, timeRegex) + getTimeAsSeconds(second, timeRegex)); +} +/** + * Flatten a JSON object down to string paths for each values + * @param {object} data + * @return {object} + */ + + +function flatten(data) { + var result = {}; + /** + * Recurse through the object + * @param {*} cur + * @param {*} prop + */ + + function recurse(cur, prop) { + if (Object(cur) !== cur) { + result[prop] = cur; + } else if (Array.isArray(cur)) { + for (var i = 0, l = cur.length; i < l; i++) { + recurse(cur[i], prop + '[' + i + ']'); + if (l === 0) result[prop] = []; + } + } else { + var isEmpty = true; + + for (var p in cur) { + if ({}.hasOwnProperty.call(cur, p)) { + isEmpty = false; + recurse(cur[p], prop ? prop + '.' + p : p); + } + } + + if (isEmpty && prop) result[prop] = {}; + } + } + + recurse(data, ''); + return result; +} +/** + * Un-flatten a flat JSON object + * @param {object} data + * @return {object} + */ + + +function unflatten(data) { + 'use strict'; + + if (Object(data) !== data || Array.isArray(data)) return data; + var regex = /\.?([^.[\]]+)|\[(\d+)]/g; + var result = {}; + + for (var p in data) { + if ({}.hasOwnProperty.call(data, p)) { + var cur = result; + var prop = ''; + var m = regex.exec(p); + + while (m) { + cur = cur[prop] || (cur[prop] = m[2] ? [] : {}); + prop = m[2] || m[1]; + m = regex.exec(p); + } + + cur[prop] = data[p]; + } + } + + return result[''] || result; +} +/** + * Counts the number of decimal places + * @param {number} num + * @return {number} + */ + + +function countDecimals(num) { + if (Math.floor(num) === num || String(num).indexOf('.') < 0) return 0; + var parts = num.toString().split('.')[1]; + return parts.length || 0; +} + +},{}]},{},[12]); diff --git a/gruntfile.js b/gruntfile.js index bbab47d..7335fd6 100644 --- a/gruntfile.js +++ b/gruntfile.js @@ -23,10 +23,14 @@ module.exports = function(grunt) { }, browserify: { development: { - src: [ - './src/**/*.js', - ], - dest: './dist/scorm-again.js', + files: [{ + expand: true, + cwd: 'src/exports/', + src: ['*.js'], + dest: 'dist/', + ext: '.js', + extDot: 'first', + }], options: { browserifyOptions: {debug: true}, transform: [ @@ -44,12 +48,16 @@ module.exports = function(grunt) { }, }, production: { - src: [ - './src/**/*.js', - ], - dest: './dist/scorm-again.min.js', + files: [{ + expand: true, + cwd: 'src/exports/', + src: ['*.js'], + dest: 'dist/', + ext: '.min.js', + extDot: 'first', + }], options: { - browserifyOptions: {debug: true}, + browserifyOptions: {debug: false}, transform: [ [ 'babelify', { @@ -60,16 +68,11 @@ module.exports = function(grunt) { '@babel/plugin-proposal-optional-chaining', ], }, + 'uglifyify', { + sourceMap: true, + }, ], ], - plugin: [ - [ - 'minifyify', - { - map: 'scorm-again.js.map', - output: './dist/scorm-again.js.map', - }], - ], }, }, }, diff --git a/package.json b/package.json index befc91d..f1fc64c 100644 --- a/package.json +++ b/package.json @@ -34,13 +34,13 @@ "jsdoc": "^3.6.7", "jsdoc-babel": "^0.5.0", "lodash.debounce": "^4.0.8", - "minifyify": "^7.3.5", "minimist": "^1.2.5", "mocha": "^8.4.0", "mocha-junit-reporter": "^2.0.0", "mochawesome": "^6.2.1", "nyc": "^15.1.0", - "sinon": "^11.1.1" + "sinon": "^11.1.1", + "uglifyify": "^5.0.2" }, "scripts": { "test": "./node_modules/.bin/mocha --require @babel/register --bdd --recursive --reporter list", diff --git a/src/exports.js b/src/exports.js deleted file mode 100644 index df9609f..0000000 --- a/src/exports.js +++ /dev/null @@ -1,7 +0,0 @@ -import Scorm2004API from './Scorm2004API'; -import Scorm12API from './Scorm12API'; -import AICC from './AICC'; - -window.Scorm12API = Scorm12API; -window.Scorm2004API = Scorm2004API; -window.AICC = AICC; diff --git a/src/exports/aicc.js b/src/exports/aicc.js new file mode 100644 index 0000000..42d30a9 --- /dev/null +++ b/src/exports/aicc.js @@ -0,0 +1,3 @@ +import AICC from '../AICC'; + +window.AICC = AICC; diff --git a/src/exports/scorm-again.js b/src/exports/scorm-again.js new file mode 100644 index 0000000..60e1be2 --- /dev/null +++ b/src/exports/scorm-again.js @@ -0,0 +1,7 @@ +import Scorm2004API from '../Scorm2004API'; +import Scorm12API from '../Scorm12API'; +import AICC from '../AICC'; + +window.Scorm12API = Scorm12API; +window.Scorm2004API = Scorm2004API; +window.AICC = AICC; diff --git a/src/exports/scorm12.js b/src/exports/scorm12.js new file mode 100644 index 0000000..151db10 --- /dev/null +++ b/src/exports/scorm12.js @@ -0,0 +1,3 @@ +import Scorm12API from '../Scorm12API'; + +window.Scorm12API = Scorm12API; diff --git a/src/exports/scorm2004.js b/src/exports/scorm2004.js new file mode 100644 index 0000000..058ab37 --- /dev/null +++ b/src/exports/scorm2004.js @@ -0,0 +1,3 @@ +import Scorm2004API from '../Scorm2004API'; + +window.Scorm2004API = Scorm2004API; diff --git a/yarn.lock b/yarn.lock index 94f3b43..9130ad6 100644 --- a/yarn.lock +++ b/yarn.lock @@ -1376,15 +1376,6 @@ ajv@^8.0.1: require-from-string "^2.0.2" uri-js "^4.2.2" -align-text@^0.1.1, align-text@^0.1.3: - version "0.1.4" - resolved "https://registry.yarnpkg.com/align-text/-/align-text-0.1.4.tgz#0cd90a561093f35d0a99256c22b7069433fad117" - integrity sha1-DNkKVhCT810KmSVsIrcGlDP60Rc= - dependencies: - kind-of "^3.0.2" - longest "^1.0.1" - repeat-string "^1.5.2" - ansi-colors@4.1.1, ansi-colors@^4.1.1: version "4.1.1" resolved "https://registry.yarnpkg.com/ansi-colors/-/ansi-colors-4.1.1.tgz#cbb9ae256bf750af1eab344f229aa27fe94ba348" @@ -1482,11 +1473,6 @@ arr-union@^3.1.0: resolved "https://registry.yarnpkg.com/arr-union/-/arr-union-3.1.0.tgz#e39b09aea9def866a8f206e288af63919bae39c4" integrity sha1-45sJrqne+Gao8gbiiK9jkZuuOcQ= -array-differ@^1.0.0: - version "1.0.0" - resolved "https://registry.yarnpkg.com/array-differ/-/array-differ-1.0.0.tgz#eff52e3758249d33be402b8bb8e564bb2b5d4031" - integrity sha1-7/UuN1gknTO+QCuLuOVkuytdQDE= - array-each@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/array-each/-/array-each-1.0.1.tgz#a794af0c05ab1752846ee753a1f211a05ba0c44f" @@ -1513,18 +1499,6 @@ array-slice@^1.0.0: resolved "https://registry.yarnpkg.com/array-slice/-/array-slice-1.1.0.tgz#e368ea15f89bc7069f7ffb89aec3a6c7d4ac22d4" integrity sha512-B1qMD3RBP7O8o0H2KbrXDyB0IccejMF15+87Lvlor12ONPRHP6gTjXMNkt/d3ZuOGbAe66hFmaCfECI24Ufp6w== -array-union@^1.0.1: - version "1.0.2" - resolved "https://registry.yarnpkg.com/array-union/-/array-union-1.0.2.tgz#9a34410e4f4e3da23dea375be5be70f24778ec39" - integrity sha1-mjRBDk9OPaI96jdb5b5w8kd47Dk= - dependencies: - array-uniq "^1.0.1" - -array-uniq@^1.0.1: - version "1.0.3" - resolved "https://registry.yarnpkg.com/array-uniq/-/array-uniq-1.0.3.tgz#af6ac877a25cc7f74e058894753858dfdb24fdb6" - integrity sha1-r2rId6Jcx/dOBYiUdThY39sk/bY= - array-unique@^0.3.2: version "0.3.2" resolved "https://registry.yarnpkg.com/array-unique/-/array-unique-0.3.2.tgz#a894b75d4bc4f6cd679ef3244a9fd8f46ae2d428" @@ -1539,11 +1513,6 @@ array.prototype.flat@^1.2.4: define-properties "^1.1.3" es-abstract "^1.18.0-next.1" -arrify@^1.0.0: - version "1.0.1" - resolved "https://registry.yarnpkg.com/arrify/-/arrify-1.0.1.tgz#898508da2226f380df904728456849c1501a4b0d" - integrity sha1-iYUI2iIm84DfkEcoRWhJwVAaSw0= - asn1.js@^5.2.0: version "5.4.1" resolved "https://registry.yarnpkg.com/asn1.js/-/asn1.js-5.4.1.tgz#11a980b84ebb91781ce35b0fdc2ee294e3783f07" @@ -1990,11 +1959,6 @@ callsites@^3.0.0: resolved "https://registry.yarnpkg.com/callsites/-/callsites-3.1.0.tgz#b3630abd8943432f54b3f0519238e33cd7df2f73" integrity sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ== -camelcase@^1.0.2: - version "1.2.1" - resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-1.2.1.tgz#9bb5304d2e0b56698b2c758b08a3eaa9daa58a39" - integrity sha1-m7UwTS4LVmmLLHWLCKPqqdqlijk= - camelcase@^5.0.0, camelcase@^5.3.1: version "5.3.1" resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-5.3.1.tgz#e3c9b31569e106811df242f715725a1f4c494320" @@ -2017,14 +1981,6 @@ catharsis@^0.9.0: dependencies: lodash "^4.17.15" -center-align@^0.1.1: - version "0.1.3" - resolved "https://registry.yarnpkg.com/center-align/-/center-align-0.1.3.tgz#aa0d32629b6ee972200411cbd4461c907bc2b7ad" - integrity sha1-qg0yYptu6XIgBBHL1EYckHvCt60= - dependencies: - align-text "^0.1.3" - lazy-cache "^1.0.3" - chai@^4.3.4: version "4.3.4" resolved "https://registry.yarnpkg.com/chai/-/chai-4.3.4.tgz#b55e655b31e1eac7099be4c08c21964fce2e6c49" @@ -2102,15 +2058,6 @@ clean-stack@^2.0.0: resolved "https://registry.yarnpkg.com/clean-stack/-/clean-stack-2.2.0.tgz#ee8472dbb129e727b31e8a10a427dee9dfe4008b" integrity sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A== -cliui@^2.1.0: - version "2.1.0" - resolved "https://registry.yarnpkg.com/cliui/-/cliui-2.1.0.tgz#4b475760ff80264c762c3a1719032e91c7fea0d1" - integrity sha1-S0dXYP+AJkx2LDoXGQMukcf+oNE= - dependencies: - center-align "^0.1.1" - right-align "^0.1.1" - wordwrap "0.0.2" - cliui@^5.0.0: version "5.0.0" resolved "https://registry.yarnpkg.com/cliui/-/cliui-5.0.0.tgz#deefcfdb2e800784aa34f46fa08e06851c7bbbc5" @@ -2199,6 +2146,11 @@ combine-source-map@^0.8.0, combine-source-map@~0.8.0: lodash.memoize "~3.0.3" source-map "~0.5.3" +commander@^2.19.0: + version "2.20.3" + resolved "https://registry.yarnpkg.com/commander/-/commander-2.20.3.tgz#fd485e84c03eb4881c20722ba48035e8531aeb33" + integrity sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ== + commander@^4.0.1: version "4.1.1" resolved "https://registry.yarnpkg.com/commander/-/commander-4.1.1.tgz#9fd602bd936294e9e9ef46a3f4d6964044b18068" @@ -2219,7 +2171,7 @@ concat-map@0.0.1: resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b" integrity sha1-2Klr13/Wjfd5OnMDajug1UBdR3s= -concat-stream@^1.4.7, concat-stream@^1.6.0, concat-stream@^1.6.1, concat-stream@~1.6.0: +concat-stream@^1.6.0, concat-stream@^1.6.1, concat-stream@~1.6.0: version "1.6.2" resolved "https://registry.yarnpkg.com/concat-stream/-/concat-stream-1.6.2.tgz#904bdf194cd3122fc675c77fc4ac3d4ff0fd1a34" integrity sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw== @@ -2244,7 +2196,7 @@ continuable-cache@^0.3.1: resolved "https://registry.yarnpkg.com/continuable-cache/-/continuable-cache-0.3.1.tgz#bd727a7faed77e71ff3985ac93351a912733ad0f" integrity sha1-vXJ6f67XfnH/OYWskzUakSczrQ8= -convert-source-map@^1.0.0, convert-source-map@^1.1.0, convert-source-map@^1.7.0: +convert-source-map@^1.1.0, convert-source-map@^1.7.0: version "1.7.0" resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-1.7.0.tgz#17a2cb882d7f77d3490585e2ce6c524424a3a442" integrity sha512-4FJkXzKXEDB1snCFZlLP4gpC3JILicCpGbzG9f9G7tGqGCzETQ2hWPrcinA9oU4wtf2biUaEH5065UnMeR33oA== @@ -2380,7 +2332,7 @@ debug@^3.1.0, debug@^3.2.7: dependencies: ms "^2.1.1" -decamelize@^1.0.0, decamelize@^1.2.0: +decamelize@^1.2.0: version "1.2.0" resolved "https://registry.yarnpkg.com/decamelize/-/decamelize-1.2.0.tgz#f6534d15148269b20352e7bee26f501f9a191290" integrity sha1-9lNNFRSCabIDUue+4m9QH5oZEpA= @@ -4145,11 +4097,6 @@ labeled-stream-splicer@^2.0.0: inherits "^2.0.1" stream-splicer "^2.0.0" -lazy-cache@^1.0.3: - version "1.0.4" - resolved "https://registry.yarnpkg.com/lazy-cache/-/lazy-cache-1.0.4.tgz#a1d78fc3a50474cb80845d3b3b6e1da49a446e8e" - integrity sha1-odePw6UEdMuAhF07O24dpJpEbo4= - levn@^0.4.1: version "0.4.1" resolved "https://registry.yarnpkg.com/levn/-/levn-0.4.1.tgz#ae4562c007473b932a6200d403268dd2fffc6ade" @@ -4224,16 +4171,6 @@ locate-path@^6.0.0: dependencies: p-locate "^5.0.0" -lodash.assign@^4.0.0: - version "4.2.0" - resolved "https://registry.yarnpkg.com/lodash.assign/-/lodash.assign-4.2.0.tgz#0d99f3ccd7a6d261d19bdaeb9245005d285808e7" - integrity sha1-DZnzzNem0mHRm9rrkkUAXShYCOc= - -lodash.bind@^4.0.0: - version "4.2.1" - resolved "https://registry.yarnpkg.com/lodash.bind/-/lodash.bind-4.2.1.tgz#7ae3017e939622ac31b7d7d7dcb1b34db1690d35" - integrity sha1-euMBfpOWIqwxt9fX3LGzTbFpDTU= - lodash.clonedeep@^4.5.0: version "4.5.0" resolved "https://registry.yarnpkg.com/lodash.clonedeep/-/lodash.clonedeep-4.5.0.tgz#e23f3f9c4f8fbdde872529c1071857a086e5ccef" @@ -4244,21 +4181,11 @@ lodash.debounce@^4.0.8: resolved "https://registry.yarnpkg.com/lodash.debounce/-/lodash.debounce-4.0.8.tgz#82d79bff30a67c4005ffd5e2515300ad9ca4d7af" integrity sha1-gteb/zCmfEAF/9XiUVMArZyk168= -lodash.defaults@^4.0.0: - version "4.2.0" - resolved "https://registry.yarnpkg.com/lodash.defaults/-/lodash.defaults-4.2.0.tgz#d09178716ffea4dde9e5fb7b37f6f0802274580c" - integrity sha1-0JF4cW/+pN3p5ft7N/bwgCJ0WAw= - lodash.flattendeep@^4.4.0: version "4.4.0" resolved "https://registry.yarnpkg.com/lodash.flattendeep/-/lodash.flattendeep-4.4.0.tgz#fb030917f86a3134e5bc9bec0d69e0013ddfedb2" integrity sha1-+wMJF/hqMTTlvJvsDWngAT3f7bI= -lodash.foreach@^4.0.0: - version "4.5.0" - resolved "https://registry.yarnpkg.com/lodash.foreach/-/lodash.foreach-4.5.0.tgz#1a6a35eace401280c7f06dddec35165ab27e3e53" - integrity sha1-Gmo16s5AEoDH8G3d7DUWWrJ+PlM= - lodash.get@^4.4.2: version "4.4.2" resolved "https://registry.yarnpkg.com/lodash.get/-/lodash.get-4.4.2.tgz#2d177f652fa31e939b4438d5341499dfa3825e99" @@ -4311,11 +4238,6 @@ log-symbols@4.0.0: dependencies: chalk "^4.0.0" -longest@^1.0.1: - version "1.0.1" - resolved "https://registry.yarnpkg.com/longest/-/longest-1.0.1.tgz#30a0b2da38f73770e8294a0d22e6625ed77d0097" - integrity sha1-MKCy2jj3N3DoKUoNIuZiXtd9AJc= - loose-envify@^1.4.0: version "1.4.0" resolved "https://registry.yarnpkg.com/loose-envify/-/loose-envify-1.4.0.tgz#71ee51fa7be4caec1a63839f7e682d8132d30caf" @@ -4443,24 +4365,6 @@ miller-rabin@^4.0.0: bn.js "^4.0.0" brorand "^1.0.1" -minifyify@^7.3.5: - version "7.3.5" - resolved "https://registry.yarnpkg.com/minifyify/-/minifyify-7.3.5.tgz#9f4bb0c8692502478d8ee85b10bd7248570629ae" - integrity sha1-n0uwyGklAkeNjuhbEL1ySFcGKa4= - dependencies: - concat-stream "^1.4.7" - convert-source-map "^1.0.0" - lodash.assign "^4.0.0" - lodash.bind "^4.0.0" - lodash.defaults "^4.0.0" - lodash.foreach "^4.0.0" - mkdirp "^0.5.0" - source-map "^0.5.3" - through "^2.3.6" - tmp "0.0.28" - transform-filter "^0.1.1" - uglify-js "^2.6.1" - minimalistic-assert@^1.0.0, minimalistic-assert@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz#2e194de044626d4a10e7f7fbc00ce73e83e4d5c7" @@ -4471,7 +4375,7 @@ minimalistic-crypto-utils@^1.0.1: resolved "https://registry.yarnpkg.com/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz#f6c00c1c0b082246e5c4d99dfb8c7c083b2b582a" integrity sha1-9sAMHAsIIkblxNmd+4x8CDsrWCo= -"minimatch@2 || 3", minimatch@3.0.4, minimatch@^3.0.0, minimatch@^3.0.4, minimatch@~3.0.2, minimatch@~3.0.4: +"minimatch@2 || 3", minimatch@3.0.4, minimatch@^3.0.2, minimatch@^3.0.4, minimatch@~3.0.2, minimatch@~3.0.4: version "3.0.4" resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.0.4.tgz#5166e286457f03306064be5497e8dbb0c3d32083" integrity sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA== @@ -4620,16 +4524,6 @@ ms@2.1.3, ms@^2.1.1: resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.3.tgz#574c8138ce1d2b5861f0b44579dbadd60c6615b2" integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA== -multimatch@^2.0.0: - version "2.1.0" - resolved "https://registry.yarnpkg.com/multimatch/-/multimatch-2.1.0.tgz#9c7906a22fb4c02919e2f5f75161b4cdbd4b2a2b" - integrity sha1-nHkGoi+0wCkZ4vX3UWG0zb1LKis= - dependencies: - array-differ "^1.0.0" - array-union "^1.0.1" - arrify "^1.0.0" - minimatch "^3.0.0" - nanoid@3.1.20: version "3.1.20" resolved "https://registry.yarnpkg.com/nanoid/-/nanoid-3.1.20.tgz#badc263c6b1dcf14b71efaa85f6ab4c1d6cfc788" @@ -4886,7 +4780,7 @@ os-homedir@^1.0.0: resolved "https://registry.yarnpkg.com/os-homedir/-/os-homedir-1.0.2.tgz#ffbc4988336e0e833de0c168c7ef152121aa7fb3" integrity sha1-/7xJiDNuDoM94MFox+8VISGqf7M= -os-tmpdir@^1.0.0, os-tmpdir@~1.0.1: +os-tmpdir@^1.0.0: version "1.0.2" resolved "https://registry.yarnpkg.com/os-tmpdir/-/os-tmpdir-1.0.2.tgz#bbe67406c79aa85c5cfec766fe5734555dfa1274" integrity sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ= @@ -5434,7 +5328,7 @@ repeat-element@^1.1.2: resolved "https://registry.yarnpkg.com/repeat-element/-/repeat-element-1.1.3.tgz#782e0d825c0c5a3bb39731f84efee6b742e6b1ce" integrity sha512-ahGq0ZnV5m5XtZLMb+vP76kcAM5nkLqk0lpqAuojSKGgQtn4eRi4ZZGm2olo2zKFH+sMsWaqOCW1dqAnOru72g== -repeat-string@^1.5.2, repeat-string@^1.6.1: +repeat-string@^1.6.1: version "1.6.1" resolved "https://registry.yarnpkg.com/repeat-string/-/repeat-string-1.6.1.tgz#8dcae470e1c88abc2d600fff4a776286da75e637" integrity sha1-jcrkcOHIirwtYA//Sndihtp15jc= @@ -5497,13 +5391,6 @@ ret@~0.1.10: resolved "https://registry.yarnpkg.com/ret/-/ret-0.1.15.tgz#b8a4825d5bdb1fc3f6f53c2bc33f81388681c7bc" integrity sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg== -right-align@^0.1.1: - version "0.1.3" - resolved "https://registry.yarnpkg.com/right-align/-/right-align-0.1.3.tgz#61339b722fe6a3515689210d24e14c96148613ef" - integrity sha1-YTObci/mo1FWiSENJOFMlhSGE+8= - dependencies: - align-text "^0.1.1" - rimraf@^3.0.0, rimraf@^3.0.2, rimraf@~3.0.2: version "3.0.2" resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-3.0.2.tgz#f1a5402ba6220ad52cc1282bac1ae3aa49fd061a" @@ -5711,7 +5598,7 @@ source-map-resolve@^0.5.0: source-map-url "^0.4.0" urix "^0.1.0" -source-map-support@^0.5.16: +source-map-support@^0.5.16, source-map-support@~0.5.10: version "0.5.19" resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.19.tgz#a98b62f86dcaf4f67399648c085291ab9e8fed61" integrity sha512-Wonm7zOCIJzBGQdB+thsPar0kYuCIzYvxZwlBa87yi/Mdjv7Tip2cyVbLj5o0cFPN4EVkuTwb3GDDyUx2DGnGw== @@ -5724,12 +5611,12 @@ source-map-url@^0.4.0: resolved "https://registry.yarnpkg.com/source-map-url/-/source-map-url-0.4.1.tgz#0af66605a745a5a2f91cf1bbf8a7afbc283dec56" integrity sha512-cPiFOTLUKvJFIg4SKVScy4ilPPW6rFgMgfuZJPNoDuMs3nC1HbMUycBoJw77xFIp6z1UJQJOfx6C9GMH80DiTw== -source-map@^0.5.0, source-map@^0.5.3, source-map@^0.5.6, source-map@~0.5.1, source-map@~0.5.3: +source-map@^0.5.0, source-map@^0.5.6, source-map@~0.5.3: version "0.5.7" resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.5.7.tgz#8a039d2d1021d22d1ea14c80d8ea468ba2ef3fcc" integrity sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w= -source-map@^0.6.0, source-map@^0.6.1: +source-map@^0.6.0, source-map@^0.6.1, source-map@~0.6.1: version "0.6.1" resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263" integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g== @@ -6013,6 +5900,15 @@ tcomb@^3.0.0, tcomb@^3.2.17: resolved "https://registry.yarnpkg.com/tcomb/-/tcomb-3.2.29.tgz#32404fe9456d90c2cf4798682d37439f1ccc386c" integrity sha512-di2Hd1DB2Zfw6StGv861JoAF5h/uQVu/QJp2g8KVbtfKnoHdBQl5M32YWq6mnSYBQ1vFFrns5B1haWJL7rKaOQ== +terser@^3.7.5: + version "3.17.0" + resolved "https://registry.yarnpkg.com/terser/-/terser-3.17.0.tgz#f88ffbeda0deb5637f9d24b0da66f4e15ab10cb2" + integrity sha512-/FQzzPJmCpjAH9Xvk2paiWrFq+5M6aVOf+2KRbwhByISDX/EujxsK+BAvrhb6H+2rtrLCHK9N01wO014vrIwVQ== + dependencies: + commander "^2.19.0" + source-map "~0.6.1" + source-map-support "~0.5.10" + test-exclude@^6.0.0: version "6.0.0" resolved "https://registry.yarnpkg.com/test-exclude/-/test-exclude-6.0.0.tgz#04a8698661d805ea6fa293b6cb9e63ac044ef15e" @@ -6042,7 +5938,7 @@ through2@^4.0.2: dependencies: readable-stream "3" -"through@>=2.2.7 <3", through@^2.3.6: +"through@>=2.2.7 <3", through@~2.3.4: version "2.3.8" resolved "https://registry.yarnpkg.com/through/-/through-2.3.8.tgz#0dd4c9ffaabc357960b1b724115d7e0e86a2e1f5" integrity sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU= @@ -6066,13 +5962,6 @@ tiny-lr@^1.1.1: object-assign "^4.1.0" qs "^6.4.0" -tmp@0.0.28: - version "0.0.28" - resolved "https://registry.yarnpkg.com/tmp/-/tmp-0.0.28.tgz#172735b7f614ea7af39664fa84cf0de4e515d120" - integrity sha1-Fyc1t/YU6nrzlmT6hM8N5OUV0SA= - dependencies: - os-tmpdir "~1.0.1" - to-fast-properties@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/to-fast-properties/-/to-fast-properties-2.0.0.tgz#dc5e698cbd079265bc73e0377681a4e4e83f616e" @@ -6110,14 +5999,6 @@ to-regex@^3.0.1, to-regex@^3.0.2: regex-not "^1.0.2" safe-regex "^1.1.0" -transform-filter@^0.1.1: - version "0.1.1" - resolved "https://registry.yarnpkg.com/transform-filter/-/transform-filter-0.1.1.tgz#806f851b6e440b23788fd38ca0431b502025ba59" - integrity sha1-gG+FG25ECyN4j9OMoEMbUCAlulk= - dependencies: - multimatch "^2.0.0" - through "^2.3.6" - tsconfig-paths@^3.9.0: version "3.9.0" resolved "https://registry.yarnpkg.com/tsconfig-paths/-/tsconfig-paths-3.9.0.tgz#098547a6c4448807e8fcb8eae081064ee9a3c90b" @@ -6172,20 +6053,16 @@ uc.micro@^1.0.1, uc.micro@^1.0.5: resolved "https://registry.yarnpkg.com/uc.micro/-/uc.micro-1.0.6.tgz#9c411a802a409a91fc6cf74081baba34b24499ac" integrity sha512-8Y75pvTYkLJW2hWQHXxoqRgV7qb9B+9vFEtidML+7koHUFapnVJAZ6cKs+Qjz5Aw3aZWHMC6u0wJE3At+nSGwA== -uglify-js@^2.6.1: - version "2.8.29" - resolved "https://registry.yarnpkg.com/uglify-js/-/uglify-js-2.8.29.tgz#29c5733148057bb4e1f75df35b7a9cb72e6a59dd" - integrity sha1-KcVzMUgFe7Th913zW3qcty5qWd0= +uglifyify@^5.0.2: + version "5.0.2" + resolved "https://registry.yarnpkg.com/uglifyify/-/uglifyify-5.0.2.tgz#7d0269885e09faa963208a9ec6721afcaf45fc50" + integrity sha512-NcSk6pgoC+IgwZZ2tVLVHq+VNKSvLPlLkF5oUiHPVOJI0s/OlSVYEGXG9PCAH0hcyFZLyvt4KBdPAQBRlVDn1Q== dependencies: - source-map "~0.5.1" - yargs "~3.10.0" - optionalDependencies: - uglify-to-browserify "~1.0.0" - -uglify-to-browserify@~1.0.0: - version "1.0.2" - resolved "https://registry.yarnpkg.com/uglify-to-browserify/-/uglify-to-browserify-1.0.2.tgz#6e0924d6bda6b5afe349e39a6d632850a0f882b7" - integrity sha1-bgkk1r2mta/jSeOabWMoUKD4grc= + convert-source-map "~1.1.0" + minimatch "^3.0.2" + terser "^3.7.5" + through "~2.3.4" + xtend "^4.0.1" umd@^3.0.0: version "3.0.3" @@ -6448,21 +6325,11 @@ wide-align@1.1.3: dependencies: string-width "^1.0.2 || 2" -window-size@0.1.0: - version "0.1.0" - resolved "https://registry.yarnpkg.com/window-size/-/window-size-0.1.0.tgz#5438cd2ea93b202efa3a19fe8887aee7c94f9c9d" - integrity sha1-VDjNLqk7IC76Ohn+iIeu58lPnJ0= - word-wrap@^1.2.3: version "1.2.3" resolved "https://registry.yarnpkg.com/word-wrap/-/word-wrap-1.2.3.tgz#610636f6b1f703891bd34771ccb17fb93b47079c" integrity sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ== -wordwrap@0.0.2: - version "0.0.2" - resolved "https://registry.yarnpkg.com/wordwrap/-/wordwrap-0.0.2.tgz#b79669bb42ecb409f83d583cad52ca17eaa1643f" - integrity sha1-t5Zpu0LstAn4PVg8rVLKF+qhZD8= - workerpool@6.1.0: version "6.1.0" resolved "https://registry.yarnpkg.com/workerpool/-/workerpool-6.1.0.tgz#a8e038b4c94569596852de7a8ea4228eefdeb37b" @@ -6627,16 +6494,6 @@ yargs@^15.0.2: y18n "^4.0.0" yargs-parser "^18.1.2" -yargs@~3.10.0: - version "3.10.0" - resolved "https://registry.yarnpkg.com/yargs/-/yargs-3.10.0.tgz#f7ee7bd857dd7c1d2d38c0e74efbd681d1431fd1" - integrity sha1-9+572FfdfB0tOMDnTvvWgdFDH9E= - dependencies: - camelcase "^1.0.2" - cliui "^2.1.0" - decamelize "^1.0.0" - window-size "0.1.0" - yocto-queue@^0.1.0: version "0.1.0" resolved "https://registry.yarnpkg.com/yocto-queue/-/yocto-queue-0.1.0.tgz#0294eb3dee05028d31ee1a5fa2c556a6aaf10a1b"