From 290fb12f82406c2eed023e6fc556555dd93bd97f Mon Sep 17 00:00:00 2001 From: Jonathan Putney Date: Wed, 13 Nov 2019 21:16:30 -0500 Subject: [PATCH] Adding dist and build --- .circleci/config.yml | 39 +- .gitignore | 2 + .mocha-reports.json | 10 + dist/scorm-again.js | 8811 +++++++++++++++++++++++++++++++++++++++ dist/scorm-again.js.map | 1 + dist/scorm-again.min.js | 36 + gruntfile.js | 61 + package-lock.json | 2256 +++++++++- package.json | 6 + 9 files changed, 11050 insertions(+), 172 deletions(-) create mode 100644 .mocha-reports.json create mode 100644 dist/scorm-again.js create mode 100644 dist/scorm-again.js.map create mode 100644 dist/scorm-again.min.js create mode 100644 gruntfile.js diff --git a/.circleci/config.yml b/.circleci/config.yml index 3b17d92..2caa51a 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -4,7 +4,7 @@ # version: 2 jobs: - test: + build: docker: # specify the version you desire here - image: circleci/node:lts-browsers @@ -38,7 +38,7 @@ jobs: - node_modules key: v1-dependencies-{{ checksum "package.json" }} - - run: mkdir reports + - run: mkdir reports dist docs # Run mocha - run: @@ -73,6 +73,21 @@ jobs: ./cc-test-reporter after-build -t lcov when: always + # compile documentation + - run: ./node_modules/.bin/jsdoc -c .jsdoc.json -d ./docs ./src/ + + # run babel compile + - run: git config user.email "jputney@noverant.com" && git config user.name "Jonathan Putney" + - run: ./node_modules/.bin/grunt + - run: git add --all dist/ + + # run jsdoc + # - run: ./node_modules/.bin/jsdoc -c .jsdoc.json -d ./docs ./src/ + # - run: git add --all docs/ + + # git commit and push dist and docs + - run: git commit -m "[skip ci] - Updating Dist and Docs" && git push origin master + # Upload results - store_test_results: @@ -86,22 +101,4 @@ jobs: - store_artifacts: # upload test coverage as artifact path: ./coverage/lcov.info - prefix: tests - docs: - docker: - # specify the version you desire here - - image: circleci/node:lts-browsers - - working_directory: ~/scorm-again - - steps: - - checkout - - - run: ./node_modules/.bin/jsdoc -c .jsdoc.json -d ./reports ./src/ - -workflows: - version: 2 - build: - jobs: - - test - # - docs \ No newline at end of file + prefix: tests \ No newline at end of file diff --git a/.gitignore b/.gitignore index 619d925..578547d 100644 --- a/.gitignore +++ b/.gitignore @@ -63,3 +63,5 @@ typings/ # JetBrains Project Directory .idea/ /reports/ + +.DS_Store \ No newline at end of file diff --git a/.mocha-reports.json b/.mocha-reports.json new file mode 100644 index 0000000..9b662db --- /dev/null +++ b/.mocha-reports.json @@ -0,0 +1,10 @@ +{ + "reporterEnabled": "mocha-junit-reporter, mochawesome", + "mochaJunitReporterReporterOptions": { + "mochaFile": "reports/mocha/test-results.xml" + }, + "mochawesomeReporterOptions": { + "reportDir": "./reports", + "reportFilename": "index" + } +} \ No newline at end of file diff --git a/dist/scorm-again.js b/dist/scorm-again.js new file mode 100644 index 0000000..1ece4fa --- /dev/null +++ b/dist/scorm-again.js @@ -0,0 +1,8811 @@ +(function() { + function r(e, n, t) { + function o(i, f) { + if (!n[i]) { + if (!e[i]) { + const c='function'==typeof require&&require; if (!f&&c) return c(i, !0); if (u) return u(i, !0); const a=new Error('Cannot find module \''+i+'\''); throw a.code='MODULE_NOT_FOUND', a; + } const p=n[i]={exports: {}}; e[i][0].call(p.exports, function(r) { + const 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= this.apiLogLevel) { + switch (messageLevel) { + case api_constants.LOG_LEVEL_ERROR: + console.error(logMessage); + break; + + case api_constants.LOG_LEVEL_WARNING: + console.warn(logMessage); + break; + + case api_constants.LOG_LEVEL_INFO: + console.info(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) { + const baseLength = 20; + let messageString = ''; + messageString += functionName; + let fillChars = baseLength - messageString.length; + + for (let i = 0; i < fillChars; i++) { + messageString += ' '; + } + + messageString += ': '; + + if (CMIElement) { + const CMIElementBaseLength = 70; + messageString += CMIElement; + fillChars = CMIElementBaseLength - messageString.length; + + for (let 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: 'stringContains', + value: function stringContains(str, tester) { + return str.indexOf(tester) > -1; + }, + /** + * Returns the message that corresponds to errorNumber + * APIs that inherit BaseAPI should override this function + * + * @param {(string|number)} _errorNumber + * @param {boolean} _detail + * @return {string} + */ + + }, { + key: 'getLmsErrorMessageDetails', + value: function getLmsErrorMessageDetails(_errorNumber, _detail) { + return 'No error'; + }, + /** + * Gets the value for the specific element. + * APIs that inherit BaseAPI should override this function + * + * @param {string} _CMIElement + * @return {string} + */ + + }, { + key: 'getCMIValue', + value: function getCMIValue(_CMIElement) { + return ''; + }, + /** + * Sets the value for the specific element. + * APIs that inherit BaseAPI should override this function + * + * @param {string} _CMIElement + * @param {any} _value + */ + + }, { + key: 'setCMIValue', + value: function setCMIValue(_CMIElement, _value) {}, // just a stub method + + /** + * 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 api_constants.SCORM_FALSE; + } + + const structure = CMIElement.split('.'); + let refObject = this; + let returnValue = api_constants.SCORM_FALSE; + const invalidErrorMessage = 'The data model element passed to '.concat(methodName, ' (').concat(CMIElement, ') is not a valid SCORM data model element.'); + const invalidErrorCode = scorm2004 ? _classPrivateFieldGet(this, _error_codes).UNDEFINED_DATA_MODEL : _classPrivateFieldGet(this, _error_codes).GENERAL; + + for (let i = 0; i < structure.length; i++) { + const 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 (!{}.hasOwnProperty.call(refObject, attribute)) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + } else { + if (this.stringContains(CMIElement, '.correct_responses')) { + this.validateCorrectResponse(CMIElement, value); + } + + if (!scorm2004 || this.lastErrorCode === 0) { + refObject[attribute] = value; + returnValue = api_constants.SCORM_TRUE; + } + } + } else { + refObject = refObject[attribute]; + + if (!refObject) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + break; + } + + if (refObject instanceof _common.CMIArray) { + const index = parseInt(structure[i + 1], 10); // SCO is trying to set an item on an array + + if (!isNaN(index)) { + const item = refObject.childArray[index]; + + if (item) { + refObject = item; + } else { + const newChild = this.getChildElement(CMIElement, value); + + if (!newChild) { + this.throwSCORMError(invalidErrorCode, invalidErrorMessage); + } else { + refObject.childArray.push(newChild); + refObject = newChild; + } + } // Have to update i value to skip the array position + + + i++; + } + } + } + } + + if (returnValue === api_constants.SCORM_FALSE) { + this.apiLog(methodName, null, 'There was an error setting the value for: '.concat(CMIElement, ', value of: ').concat(value), api_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 + * @return {*} + */ + + }, { + key: 'getChildElement', + value: function getChildElement(_CMIElement, _value) { + return null; + }, + /** + * 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 ''; + } + + const structure = CMIElement.split('.'); + let refObject = this; + let attribute = null; + + for (let i = 0; i < structure.length; i++) { + attribute = structure[i]; + + if (!scorm2004) { + if (i === structure.length - 1) { + if (!{}.hasOwnProperty.call(refObject, attribute)) { + this.throwSCORMError(101, 'getCMIValue did not find a value for: ' + CMIElement); + } + } + } else { + if (String(attribute).substr(0, 8) === '{target=' && typeof refObject._isTargetValid == 'function') { + const target = String(attribute).substr(8, String(attribute).length - 9); + return refObject._isTargetValid(target); + } else if (!{}.hasOwnProperty.call(refObject, attribute)) { + this.throwSCORMError(401, 'The data model element passed to GetValue (' + CMIElement + ') is not a valid SCORM data model element.'); + return ''; + } + } + + refObject = refObject[attribute]; + } + + if (refObject === null || refObject === undefined) { + if (!scorm2004) { + if (attribute === '_children') { + this.throwSCORMError(202); + } else if (attribute === '_count') { + this.throwSCORMError(203); + } + } + + return ''; + } else { + return refObject; + } + }, + /** + * Returns true if the API's current state is STATE_INITIALIZED + * + * @return {boolean} + */ + + }, { + key: 'isInitialized', + value: function isInitialized() { + return this.currentState === api_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 === api_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 === api_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; + const listenerFunctions = listenerName.split(' '); + + for (let i = 0; i < listenerFunctions.length; i++) { + const listenerSplit = listenerFunctions[i].split('.'); + if (listenerSplit.length === 0) return; + const functionName = listenerSplit[0]; + let CMIElement = null; + + if (listenerSplit.length > 1) { + CMIElement = listenerName.replace(functionName + '.', ''); + } + + this.listenerArray.push({ + functionName: functionName, + CMIElement: CMIElement, + callback: callback, + }); + } + }, + /** + * Processes any 'on' listeners that have been created + * + * @param {string} functionName + * @param {string} CMIElement + * @param {*} value + */ + + }, { + key: 'processListeners', + value: function processListeners(functionName, CMIElement, value) { + for (let i = 0; i < this.listenerArray.length; i++) { + const listener = this.listenerArray[i]; + const functionsMatch = listener.functionName === functionName; + const listenerHasCMIElement = !!listener.CMIElement; + const 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, api_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 !== api_constants.SCORM_FALSE) { + this.lastErrorCode = 0; + } + }, + /** + * 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 || 'cmi'; + + for (const key in json) { + if ({}.hasOwnProperty.call(json, key) && json[key]) { + const currentCMIElement = CMIElement + '.' + key; + const value = json[key]; + + if (value['childArray']) { + for (let 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: 'renderCMIToJSON', + value: function renderCMIToJSON() { + const 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, + }); + }, + /** + * Throws a SCORM error + * + * @param {number} when - the number of milliseconds to wait before committing + */ + + }, { + key: 'scheduleCommit', + value: function scheduleCommit(when) { + _classPrivateFieldSet(this, _timeout, new ScheduledCommit(this, when)); + }, + /** + * Clears and cancels any currently scheduled commits + */ + + }, { + key: 'clearScheduledCommit', + value: function clearScheduledCommit() { + if (_classPrivateFieldGet(this, _timeout)) { + _classPrivateFieldGet(this, _timeout).cancel(); + + _classPrivateFieldSet(this, _timeout, null); + } + }, + }]); + + return BaseAPI; +}(); + /** + * Private class that wraps a timeout call to the commit() function + */ + + + exports['default'] = BaseAPI; + + var _timeout = new WeakMap(); + + var _error_codes = new WeakMap(); + + var ScheduledCommit = +/* #__PURE__*/ +function() { + /** + * Constructor for ScheduledCommit + * @param {BaseAPI} API + * @param {number} when + */ + function ScheduledCommit(API, when) { + _classCallCheck(this, ScheduledCommit); + + _API.set(this, { + writable: true, + value: void 0, + }); + + _cancelled.set(this, { + writable: true, + value: void 0, + }); + + _timeout2.set(this, { + writable: true, + value: void 0, + }); + + _classPrivateFieldSet(this, _API, API); + + _classPrivateFieldSet(this, _timeout2, setTimeout(this.wrapper, when)); + } + /** + * 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(); + } + }, + }]); + + return ScheduledCommit; +}(); + + var _API = new WeakMap(); + + var _cancelled = new WeakMap(); + + var _timeout2 = new WeakMap(); +}, {'./cmi/common': 6}], 3: [function(require, module, exports) { + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true, + }); + exports['default'] = void 0; + + const _BaseAPI2 = _interopRequireDefault(require('./BaseAPI')); + + const _scorm12_cmi = require('./cmi/scorm12_cmi'); + + const Utilities = _interopRequireWildcard(require('./utilities')); + + const _api_constants = require('./constants/api_constants'); + + const _error_codes = require('./constants/error_codes'); + + const _regex = require('./constants/regex'); + + function _getRequireWildcardCache() { + if (typeof WeakMap !== 'function') return null; const cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { + return cache; + }; return cache; + } + + function _interopRequireWildcard(obj) { + if (obj && obj.__esModule) { + return obj; + } if (obj === null || _typeof(obj) !== 'object' && typeof obj !== 'function') { + return {'default': obj}; + } const cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { + return cache.get(obj); + } const newObj = {}; const hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (const key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + const 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 _typeof(obj) { + 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 _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError('Cannot call a class as a function'); + } + } + + function _defineProperties(target, props) { + for (let i = 0; i < props.length; i++) { + const 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 _possibleConstructorReturn(self, call) { + if (call && (_typeof(call) === 'object' || typeof call === 'function')) { + return call; + } return _assertThisInitialized(self); + } + + function _getPrototypeOf(o) { + _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { + return o.__proto__ || Object.getPrototypeOf(o); + }; return _getPrototypeOf(o); + } + + function _assertThisInitialized(self) { + if (self === void 0) { + throw new ReferenceError('this hasn\'t been initialised - super() hasn\'t been called'); + } return self; + } + + 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); + } + + const constants = _api_constants.scorm12_constants; + /** + * API class for SCORM 1.2 + */ + + const Scorm12API = +/* #__PURE__*/ +function(_BaseAPI) { + _inherits(Scorm12API, _BaseAPI); + + /** + * Constructor for SCORM 1.2 API + */ + function Scorm12API() { + let _this; + + _classCallCheck(this, Scorm12API); + + _this = _possibleConstructorReturn(this, _getPrototypeOf(Scorm12API).call(this, _error_codes.scorm12_error_codes)); + _this.cmi = new _scorm12_cmi.CMI(_assertThisInitialized(_this)); // 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() { + 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() { + return this.terminate('LMSFinish', false); + }, + /** + * 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', 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 + */ + + }, { + key: 'setCMIValue', + value: function setCMIValue(CMIElement, value) { + 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 + * @return {object} + */ + + }, { + key: 'getChildElement', + value: function getChildElement(CMIElement, value) { + let newChild; + + if (this.stringContains(CMIElement, 'cmi.objectives')) { + newChild = new _scorm12_cmi.CMIObjectivesObject(this); + } else if (this.stringContains(CMIElement, '.correct_responses')) { + newChild = new _scorm12_cmi.CMIInteractionsCorrectResponsesObject(this); + } else if (this.stringContains(CMIElement, '.objectives')) { + newChild = new _scorm12_cmi.CMIInteractionsObjectivesObject(this); + } else if (this.stringContains(CMIElement, 'cmi.interactions')) { + newChild = new _scorm12_cmi.CMIInteractionsObject(this); + } + + 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) { + let basicMessage = 'No Error'; + let detailMessage = 'No Error'; // Set error number to string since inconsistent from modules if string or number + + errorNumber = String(errorNumber); + + if (constants.error_descriptions[errorNumber]) { + basicMessage = constants.error_descriptions[errorNumber].basicMessage; + detailMessage = constants.error_descriptions[errorNumber].detailMessage; + } + + return detail ? detailMessage : basicMessage; + }, + /** + * Adds the current session time to the existing total time. + * + * @return {string} + */ + + }, { + key: 'getCurrentTotalTime', + value: function getCurrentTotalTime() { + const timeRegex = new RegExp(_regex.scorm12_regex.CMITime); + const totalTime = this.cmi.core.total_time; + const sessionTime = this.cmi.core.session_time; + return Utilities.addHHMMSSTimeStrings(totalTime, sessionTime, timeRegex); + }, + /** + * Replace the whole API with another + * + * @param {Scorm12API} newAPI + */ + + }, { + key: 'replaceWithAnotherScormAPI', + value: function replaceWithAnotherScormAPI(newAPI) { + // Data Model + this.cmi = newAPI.cmi; + }, + }]); + + return Scorm12API; +}(_BaseAPI2['default']); + + exports['default'] = Scorm12API; +}, {'./BaseAPI': 2, './cmi/scorm12_cmi': 7, './constants/api_constants': 9, './constants/error_codes': 10, './constants/regex': 13, './utilities': 16}], 4: [function(require, module, exports) { + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true, + }); + exports['default'] = void 0; + + const _BaseAPI2 = _interopRequireDefault(require('./BaseAPI')); + + const _scorm2004_cmi = require('./cmi/scorm2004_cmi'); + + const Util = _interopRequireWildcard(require('./utilities')); + + const _api_constants = require('./constants/api_constants'); + + const _error_codes = require('./constants/error_codes'); + + const _response_constants = require('./constants/response_constants'); + + const _language_constants = require('./constants/language_constants'); + + const _regex = require('./constants/regex'); + + function _getRequireWildcardCache() { + if (typeof WeakMap !== 'function') return null; const cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { + return cache; + }; return cache; + } + + function _interopRequireWildcard(obj) { + if (obj && obj.__esModule) { + return obj; + } if (obj === null || _typeof(obj) !== 'object' && typeof obj !== 'function') { + return {'default': obj}; + } const cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { + return cache.get(obj); + } const newObj = {}; const hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (const key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + const 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 _typeof(obj) { + 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 _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError('Cannot call a class as a function'); + } + } + + function _defineProperties(target, props) { + for (let i = 0; i < props.length; i++) { + const 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 _possibleConstructorReturn(self, call) { + if (call && (_typeof(call) === 'object' || typeof call === 'function')) { + return call; + } return _assertThisInitialized(self); + } + + function _getPrototypeOf(o) { + _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { + return o.__proto__ || Object.getPrototypeOf(o); + }; return _getPrototypeOf(o); + } + + function _assertThisInitialized(self) { + if (self === void 0) { + throw new ReferenceError('this hasn\'t been initialised - super() hasn\'t been called'); + } return self; + } + + 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 _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) { + const descriptor = privateMap.get(receiver); if (!descriptor) { + throw new TypeError('attempted to get private field on non-instance'); + } if (descriptor.get) { + return descriptor.get.call(receiver); + } return descriptor.value; + } + + const constants = _api_constants.scorm2004_constants; + /** + * API class for SCORM 2004 + */ + + const Scorm2004API = +/* #__PURE__*/ +function(_BaseAPI) { + _inherits(Scorm2004API, _BaseAPI); + + /** + * Constructor for SCORM 2004 API + */ + function Scorm2004API() { + let _this; + + _classCallCheck(this, Scorm2004API); + + _this = _possibleConstructorReturn(this, _getPrototypeOf(Scorm2004API).call(this, _error_codes.scorm2004_error_codes)); + + _version.set(_assertThisInitialized(_this), { + writable: true, + value: void 0, + }); + + _defineProperty(_assertThisInitialized(_this), 'checkDuplicatedPattern', function(correct_response, current_index, value) { + let found = false; + const count = correct_response._count; + + for (let 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(_assertThisInitialized(_this)); + _this.adl = new _scorm2004_cmi.ADL(_assertThisInitialized(_this)); // 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: 'lmsInitialize', + + /** + * @return {string} bool + */ + value: function lmsInitialize() { + return this.initialize('Initialize'); + }, + /** + * @return {string} bool + */ + + }, { + key: 'lmsTerminate', + value: function lmsTerminate() { + return this.terminate('Terminate', true); + }, + /** + * @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', 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 + */ + + }, { + key: 'setCMIValue', + value: function setCMIValue(CMIElement, value) { + this._commonSetCMIValue('SetValue', true, CMIElement, value); + }, + /** + * Gets or builds a new child element to add to the array. + * + * @param {string} CMIElement + * @param {any} value + * @return {any} + */ + + }, { + key: 'getChildElement', + value: function getChildElement(CMIElement, value) { + let newChild; + + if (this.stringContains(CMIElement, 'cmi.objectives')) { + newChild = new _scorm2004_cmi.CMIObjectivesObject(this); + } else if (this.stringContains(CMIElement, '.correct_responses')) { + const parts = CMIElement.split('.'); + const index = Number(parts[2]); + const interaction = this.cmi.interactions.childArray[index]; + + if (typeof interaction.type === 'undefined') { + this.throwSCORMError(_error_codes.scorm2004_error_codes.DEPENDENCY_NOT_ESTABLISHED); + } else { + const interaction_type = interaction.type; + const interaction_count = interaction.correct_responses._count; + + if (interaction_type === 'choice') { + for (let i = 0; i < interaction_count && this.lastErrorCode === 0; i++) { + const response = interaction.correct_responses.childArray[i]; + + if (response.pattern === value) { + this.throwSCORMError(_error_codes.scorm2004_error_codes.GENERAL_SET_FAILURE); + } + } + } + + const response_type = _response_constants.correct_responses[interaction_type]; + let nodes = []; + + if (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(_error_codes.scorm2004_error_codes.GENERAL_SET_FAILURE, 'Data Model Element Pattern Too Long'); + } + } + + if (this.lastErrorCode === 0) { + newChild = new _scorm2004_cmi.CMIInteractionsCorrectResponsesObject(this); + } + } else if (this.stringContains(CMIElement, '.objectives')) { + newChild = new _scorm2004_cmi.CMIInteractionsObjectivesObject(this); + } else if (this.stringContains(CMIElement, 'cmi.interactions')) { + newChild = new _scorm2004_cmi.CMIInteractionsObject(this); + } else if (this.stringContains(CMIElement, 'cmi.comments_from_learner')) { + newChild = new _scorm2004_cmi.CMICommentsFromLearnerObject(this); + } else if (this.stringContains(CMIElement, 'cmi.comments_from_lms')) { + newChild = new _scorm2004_cmi.CMICommentsFromLMSObject(this); + } + + return newChild; + }, + /** + * Validate correct response. + * @param {string} CMIElement + * @param {*} value + */ + + }, { + key: 'validateCorrectResponse', + value: function validateCorrectResponse(CMIElement, value) { + const parts = CMIElement.split('.'); + const index = Number(parts[2]); + const pattern_index = Number(parts[4]); + const interaction = this.cmi.interactions.childArray[index]; + const interaction_type = interaction.type; + const interaction_count = interaction.correct_responses._count; + + if (interaction_type === 'choice') { + for (let i = 0; i < interaction_count && this.lastErrorCode === 0; i++) { + const response = interaction.correct_responses.childArray[i]; + + if (response.pattern === value) { + this.throwSCORMError(_error_codes.scorm2004_error_codes.GENERAL_SET_FAILURE); + } + } + } + + const response_type = _api_constants.scorm2004_constants.correct_responses[interaction_type]; + + if (typeof response_type.limit !== 'undefined' || interaction_count < response_type.limit) { + let nodes = []; + + if (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(_error_codes.scorm2004_error_codes.GENERAL_SET_FAILURE, 'Data Model Element Pattern Too Long'); + } + + 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(_error_codes.scorm2004_error_codes.GENERAL_SET_FAILURE, 'Data Model Element Pattern Already Exists'); + } + } + } else { + this.throwSCORMError(_error_codes.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) { + let basicMessage = ''; + let detailMessage = ''; // Set error number to string since inconsistent from modules if string or number + + errorNumber = String(errorNumber); + + if (constants.error_descriptions[errorNumber]) { + basicMessage = constants.error_descriptions[errorNumber].basicMessage; + detailMessage = 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', + + /** + * Checks for a valid correct_response value + * @param {string} interaction_type + * @param {Array} nodes + * @param {*} value + */ + value: function checkCorrectResponseValue(interaction_type, nodes, value) { + const response = _response_constants.correct_responses[interaction_type]; + const formatRegex = new RegExp(response.format); + + for (let 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.delimiter2 !== undefined) { + const values = nodes[i].split(response.delimiter2); + + if (values.length === 2) { + const matches = values[0].match(formatRegex); + + if (!matches) { + this.throwSCORMError(_error_codes.scorm2004_error_codes.TYPE_MISMATCH); + } else { + if (!values[1].match(new RegExp(response.format2))) { + this.throwSCORMError(_error_codes.scorm2004_error_codes.TYPE_MISMATCH); + } + } + } else { + this.throwSCORMError(_error_codes.scorm2004_error_codes.TYPE_MISMATCH); + } + } else { + const _matches = nodes[i].match(formatRegex); + + if (!_matches && value !== '' || !_matches && interaction_type === 'true-false') { + this.throwSCORMError(_error_codes.scorm2004_error_codes.TYPE_MISMATCH); + } else { + if (interaction_type === 'numeric' && nodes.length > 1) { + if (Number(nodes[0]) > Number(nodes[1])) { + this.throwSCORMError(_error_codes.scorm2004_error_codes.TYPE_MISMATCH); + } + } else { + if (nodes[i] !== '' && response.unique) { + for (let j = 0; j < i && this.lastErrorCode === 0; j++) { + if (nodes[i] === nodes[j]) { + this.throwSCORMError(_error_codes.scorm2004_error_codes.TYPE_MISMATCH); + } + } + } + } + } + } + } + }, + /** + * Remove prefixes from correct_response + * @param {string} node + * @return {*} + */ + + }, { + key: 'removeCorrectResponsePrefixes', + value: function removeCorrectResponsePrefixes(node) { + let seenOrder = false; + let seenCase = false; + let seenLang = false; + const prefixRegex = new RegExp('^({(lang|case_matters|order_matters)=([^}]+)})'); + let matches = node.match(prefixRegex); + let langMatches = null; + + while (matches) { + switch (matches[2]) { + case 'lang': + langMatches = node.match(_regex.scorm2004_regex.CMILangcr); + + if (langMatches) { + const lang = langMatches[3]; + + if (lang !== undefined && lang.length > 0) { + if (_language_constants.valid_languages[lang.toLowerCase()] === undefined) { + this.throwSCORMError(_error_codes.scorm2004_error_codes.TYPE_MISMATCH); + } + } + } + + seenLang = true; + break; + + case 'case_matters': + if (!seenLang && !seenOrder && !seenCase) { + if (matches[3] !== 'true' && matches[3] !== 'false') { + this.throwSCORMError(_error_codes.scorm2004_error_codes.TYPE_MISMATCH); + } + } + + seenCase = true; + break; + + case 'order_matters': + if (!seenCase && !seenLang && !seenOrder) { + if (matches[3] !== 'true' && matches[3] !== 'false') { + this.throwSCORMError(_error_codes.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; + }, + /** + * Adds the current session time to the existing total time. + * + * @return {string} ISO8601 Duration + */ + + }, { + key: 'getCurrentTotalTime', + value: function getCurrentTotalTime() { + const totalTime = this.cmi.total_time; + const sessionTime = this.cmi.session_time; + return Util.addTwoDurations(totalTime, sessionTime, _regex.scorm2004_regex.CMITimespan); + }, + }, { + key: 'version', + get: function get() { + return _classPrivateFieldGet(this, _version); + }, + }]); + + return Scorm2004API; +}(_BaseAPI2['default']); + + exports['default'] = Scorm2004API; + + var _version = new WeakMap(); +}, {'./BaseAPI': 2, './cmi/scorm2004_cmi': 8, './constants/api_constants': 9, './constants/error_codes': 10, './constants/language_constants': 12, './constants/regex': 13, './constants/response_constants': 14, './utilities': 16}], 5: [function(require, module, exports) { + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true, + }); + exports.NAV = exports.CMIEvaluationCommentsObject = exports.CMITriesObject = exports.CMITries = exports.CMI = void 0; + + const Scorm12CMI = _interopRequireWildcard(require('./scorm12_cmi')); + + const _common = require('./common'); + + const _api_constants = require('../constants/api_constants'); + + const _regex = require('../constants/regex'); + + const _error_codes = require('../constants/error_codes'); + + function _getRequireWildcardCache() { + if (typeof WeakMap !== 'function') return null; const cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { + return cache; + }; return cache; + } + + function _interopRequireWildcard(obj) { + if (obj && obj.__esModule) { + return obj; + } if (obj === null || _typeof(obj) !== 'object' && typeof obj !== 'function') { + return {'default': obj}; + } const cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { + return cache.get(obj); + } const newObj = {}; const hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (const key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + const 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 _typeof(obj) { + 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 _classPrivateFieldSet(receiver, privateMap, value) { + const descriptor = privateMap.get(receiver); if (!descriptor) { + throw new TypeError('attempted to set private field on non-instance'); + } 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; + } return value; + } + + function _classPrivateFieldGet(receiver, privateMap) { + const descriptor = privateMap.get(receiver); if (!descriptor) { + throw new TypeError('attempted to get private field on non-instance'); + } 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 (let i = 0; i < props.length; i++) { + const 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 _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 _get(target, property, receiver) { + if (typeof Reflect !== 'undefined' && Reflect.get) { + _get = Reflect.get; + } else { + _get = function _get(target, property, receiver) { + const base = _superPropBase(target, property); if (!base) return; const 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 _getPrototypeOf(o) { + _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { + return o.__proto__ || Object.getPrototypeOf(o); + }; return _getPrototypeOf(o); + } + + 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); + } + + const constants = _api_constants.aicc_constants; + const regex = _regex.aicc_regex; + /** + * CMI Class for AICC + */ + + const CMI = +/* #__PURE__*/ +function(_Scorm12CMI$CMI) { + _inherits(CMI, _Scorm12CMI$CMI); + + /** + * Constructor for AICC CMI object + * @param {boolean} initialized + */ + function CMI(initialized) { + let _this; + + _classCallCheck(this, CMI); + + _this = _possibleConstructorReturn(this, _getPrototypeOf(CMI).call(this, constants.cmi_children)); + if (initialized) _this.initialize(); + _this.student_data = new AICCCMIStudentData(); + _this.evaluation = new CMIEvaluation(); + return _this; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(CMI, [{ + key: 'initialize', + value: function initialize() { + let _this$student_data; let _this$evaluation; + + _get(_getPrototypeOf(CMI.prototype), 'initialize', this).call(this); + + (_this$student_data = this.student_data) === null || _this$student_data === void 0 ? void 0 : _this$student_data.initialize(); + (_this$evaluation = this.evaluation) === null || _this$evaluation === void 0 ? void 0 : _this$evaluation.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; + const 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, + 'evaluation': this.evaluation, + }; + delete this.jsonString; + return result; + }, + }]); + + return CMI; +}(Scorm12CMI.CMI); + /** + * AICC Evaluation object + */ + + + exports.CMI = CMI; + + var CMIEvaluation = +/* #__PURE__*/ +function(_BaseCMI) { + _inherits(CMIEvaluation, _BaseCMI); + + /** + * Constructor for AICC Evaluation object + */ + function CMIEvaluation() { + let _this2; + + _classCallCheck(this, CMIEvaluation); + + _this2 = _possibleConstructorReturn(this, _getPrototypeOf(CMIEvaluation).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() { + let _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; + const 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); + + /** + * Constructor for AICC Evaluation Comments object + */ + function CMIEvaluationComments() { + _classCallCheck(this, CMIEvaluationComments); + + return _possibleConstructorReturn(this, _getPrototypeOf(CMIEvaluationComments).call(this, constants.comments_children, _error_codes.scorm12_error_codes.INVALID_SET_VALUE)); + } + + return CMIEvaluationComments; +}(_common.CMIArray); + /** + * StudentData class for AICC + */ + + + var AICCCMIStudentData = +/* #__PURE__*/ +function(_Scorm12CMI$CMIStuden) { + _inherits(AICCCMIStudentData, _Scorm12CMI$CMIStuden); + + /** + * Constructor for AICC StudentData object + */ + function AICCCMIStudentData() { + let _this3; + + _classCallCheck(this, AICCCMIStudentData); + + _this3 = _possibleConstructorReturn(this, _getPrototypeOf(AICCCMIStudentData).call(this, constants.student_data_children)); + + _tries_during_lesson.set(_assertThisInitialized(_this3), { + writable: true, + value: '', + }); + + _this3.tries = new CMITries(); + return _this3; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(AICCCMIStudentData, [{ + key: 'initialize', + value: function initialize() { + let _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: 'toJSON', + + /** + * toJSON for cmi.student_data object + * @return { + * { + * mastery_score: string, + * max_time_allowed: string, + * time_limit_action: string, + * tries: CMITries + * } + * } + */ + value: function toJSON() { + this.jsonString = true; + const 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; + }, + }, { + key: 'tries_during_lesson', + + /** + * Getter for tries_during_lesson + * @return {string} + */ + get: 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) : (0, Scorm12CMI.throwReadOnlyError)(); + }, + }]); + + return AICCCMIStudentData; +}(Scorm12CMI.CMIStudentData); + /** + * Class representing the AICC cmi.student_data.tries object + */ + + + var _tries_during_lesson = new WeakMap(); + + var CMITries = +/* #__PURE__*/ +function(_CMIArray2) { + _inherits(CMITries, _CMIArray2); + + /** + * Constructor for inline Tries Array class + */ + function CMITries() { + _classCallCheck(this, CMITries); + + return _possibleConstructorReturn(this, _getPrototypeOf(CMITries).call(this, _api_constants.aicc_constants.tries_children)); + } + + return CMITries; +}(_common.CMIArray); + /** + * Class for AICC Tries + */ + + + exports.CMITries = CMITries; + + const CMITriesObject = +/* #__PURE__*/ +function(_BaseCMI2) { + _inherits(CMITriesObject, _BaseCMI2); + + /** + * Constructor for AICC Tries object + */ + function CMITriesObject() { + let _this4; + + _classCallCheck(this, CMITriesObject); + + _this4 = _possibleConstructorReturn(this, _getPrototypeOf(CMITriesObject).call(this)); + + _status.set(_assertThisInitialized(_this4), { + writable: true, + value: '', + }); + + _time.set(_assertThisInitialized(_this4), { + writable: true, + value: '', + }); + + _this4.score = new _common.CMIScore({ + score_children: constants.score_children, + score_range: regex.score_range, + invalidErrorCode: _error_codes.scorm12_error_codes.INVALID_SET_VALUE, + invalidTypeCode: _error_codes.scorm12_error_codes.TYPE_MISMATCH, + invalidRangeCode: _error_codes.scorm12_error_codes.VALUE_OUT_OF_RANGE, + }); + return _this4; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(CMITriesObject, [{ + key: 'initialize', + value: function initialize() { + let _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: 'toJSON', + + /** + * toJSON for cmi.student_data.tries.n object + * @return { + * { + * status: string, + * time: string, + * score: CMIScore + * } + * } + */ + value: function toJSON() { + this.jsonString = true; + const result = { + 'status': this.status, + 'time': this.time, + 'score': this.score, + }; + delete this.jsonString; + return result; + }, + }, { + key: 'status', + + /** + * Getter for #status + * @return {string} + */ + get: function get() { + return _classPrivateFieldGet(this, _status); + }, /** + * Setter for #status + * @param {string} status + */ + + set: function set(status) { + if ((0, Scorm12CMI.check12ValidFormat)(status, regex.CMIStatus2)) { + _classPrivateFieldSet(this, _status, status); + } + }, + /** + * 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 ((0, Scorm12CMI.check12ValidFormat)(time, regex.CMITime)) { + _classPrivateFieldSet(this, _time, time); + } + }, + }]); + + return CMITriesObject; +}(_common.BaseCMI); + /** + * Class for AICC Evaluation Comments + */ + + + exports.CMITriesObject = CMITriesObject; + + var _status = new WeakMap(); + + var _time = new WeakMap(); + + const CMIEvaluationCommentsObject = +/* #__PURE__*/ +function(_BaseCMI3) { + _inherits(CMIEvaluationCommentsObject, _BaseCMI3); + + /** + * Constructor for Evaluation Comments + */ + function CMIEvaluationCommentsObject() { + let _this5; + + _classCallCheck(this, CMIEvaluationCommentsObject); + + _this5 = _possibleConstructorReturn(this, _getPrototypeOf(CMIEvaluationCommentsObject).call(this)); + + _content.set(_assertThisInitialized(_this5), { + writable: true, + value: '', + }); + + _location.set(_assertThisInitialized(_this5), { + writable: true, + value: '', + }); + + _time2.set(_assertThisInitialized(_this5), { + writable: true, + value: '', + }); + + return _this5; + } + + _createClass(CMIEvaluationCommentsObject, [{ + key: 'toJSON', + + /** + * toJSON for cmi.evaulation.comments.n object + * @return { + * { + * content: string, + * location: string, + * time: string + * } + * } + */ + value: function toJSON() { + this.jsonString = true; + const result = { + 'content': this.content, + 'location': this.location, + 'time': this.time, + }; + delete this.jsonString; + return result; + }, + }, { + key: 'content', + + /** + * Getter for #content + * @return {string} + */ + get: function get() { + return _classPrivateFieldGet(this, _content); + }, /** + * Setter for #content + * @param {string} content + */ + + set: function set(content) { + if ((0, Scorm12CMI.check12ValidFormat)(content, 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 ((0, Scorm12CMI.check12ValidFormat)(location, regex.CMIString256)) { + _classPrivateFieldSet(this, _location, location); + } + }, + /** + * Getter for #time + * @return {string} + */ + + }, { + key: 'time', + get: function get() { + return _classPrivateFieldGet(this, _time2); + }, /** + * Setting for #time + * @param {string} time + */ + + set: function set(time) { + if ((0, Scorm12CMI.check12ValidFormat)(time, regex.CMITime)) { + _classPrivateFieldSet(this, _time2, time); + } + }, + }]); + + return CMIEvaluationCommentsObject; +}(_common.BaseCMI); + /** + * Class for AICC Navigation object + */ + + + exports.CMIEvaluationCommentsObject = CMIEvaluationCommentsObject; + + var _content = new WeakMap(); + + var _location = new WeakMap(); + + var _time2 = new WeakMap(); + + const NAV = +/* #__PURE__*/ +function(_BaseCMI4) { + _inherits(NAV, _BaseCMI4); + + /** + * Constructor for NAV object + */ + function NAV() { + let _this6; + + _classCallCheck(this, NAV); + + _this6 = _possibleConstructorReturn(this, _getPrototypeOf(NAV).call(this)); + + _event.set(_assertThisInitialized(_this6), { + writable: true, + value: '', + }); + + return _this6; + } + + _createClass(NAV, [{ + key: 'toJSON', + + /** + * toJSON for nav object + * @return { + * { + * event: string + * } + * } + */ + value: function toJSON() { + this.jsonString = true; + const result = { + 'event': this.event, + }; + delete this.jsonString; + return result; + }, + }, { + key: 'event', + + /** + * Getter for #event + * @return {string} + */ + get: function get() { + return !this.jsonString ? (0, Scorm12CMI.throwWriteOnlyError)() : _classPrivateFieldGet(this, _event); + }, /** + * Setter for #event + * @param {string} event + */ + + set: function set(event) { + if ((0, Scorm12CMI.check12ValidFormat)(event, regex.NAVEvent)) { + _classPrivateFieldSet(this, _event, event); + } + }, + }]); + + return NAV; +}(_common.BaseCMI); + + exports.NAV = NAV; + + var _event = new WeakMap(); +}, {'../constants/api_constants': 9, '../constants/error_codes': 10, '../constants/regex': 13, './common': 6, './scorm12_cmi': 7}], 6: [function(require, module, exports) { + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true, + }); + exports.checkValidFormat = checkValidFormat; + exports.checkValidRange = checkValidRange; + exports.CMIArray = exports.CMIScore = exports.BaseCMI = void 0; + + const _api_constants = require('../constants/api_constants'); + + const _error_codes = require('../constants/error_codes'); + + const _exceptions = require('../exceptions'); + + const _regex = require('../constants/regex'); + + function _typeof(obj) { + 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 _possibleConstructorReturn(self, call) { + if (call && (_typeof(call) === 'object' || typeof call === 'function')) { + return call; + } return _assertThisInitialized(self); + } + + function _getPrototypeOf(o) { + _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { + return o.__proto__ || Object.getPrototypeOf(o); + }; return _getPrototypeOf(o); + } + + function _assertThisInitialized(self) { + if (self === void 0) { + throw new ReferenceError('this hasn\'t been initialised - super() hasn\'t been called'); + } return self; + } + + 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 _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError('Cannot call a class as a function'); + } + } + + function _defineProperties(target, props) { + for (let i = 0; i < props.length; i++) { + const 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) { + const descriptor = privateMap.get(receiver); if (!descriptor) { + throw new TypeError('attempted to set private field on non-instance'); + } 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; + } return value; + } + + function _classPrivateFieldGet(receiver, privateMap) { + const descriptor = privateMap.get(receiver); if (!descriptor) { + throw new TypeError('attempted to get private field on non-instance'); + } if (descriptor.get) { + return descriptor.get.call(receiver); + } return descriptor.value; + } + + /** + * Check if the value matches the proper format. If not, throw proper error code. + * + * @param {string} value + * @param {string} regexPattern + * @param {number} errorCode + * @param {boolean} allowEmptyString + * @return {boolean} + */ + function checkValidFormat(value, regexPattern, errorCode, allowEmptyString) { + const formatRegex = new RegExp(regexPattern); + const matches = value.match(formatRegex); + + if (allowEmptyString && value === '') { + return true; + } + + if (value === undefined || !matches || matches[0] === '') { + throw new _exceptions.ValidationError(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 + * @return {boolean} + */ + + + function checkValidRange(value, rangePattern, errorCode) { + const ranges = rangePattern.split('#'); + value = value * 1.0; + + if (value >= ranges[0]) { + if (ranges[1] === '*' || value <= ranges[1]) { + return true; + } else { + throw new _exceptions.ValidationError(errorCode); + } + } else { + throw new _exceptions.ValidationError(errorCode); + } + } + /** + * Base class for API cmi objects + */ + + + const BaseCMI = +/* #__PURE__*/ +function() { + function BaseCMI() { + _classCallCheck(this, BaseCMI); + + _defineProperty(this, 'jsonString', false); + + _initialized.set(this, { + writable: true, + value: false, + }); + } + + _createClass(BaseCMI, [{ + key: 'initialize', + + /** + * Called when the API has been initialized after the CMI has been created + */ + value: function initialize() { + _classPrivateFieldSet(this, _initialized, true); + }, + }, { + key: 'initialized', + + /** + * Getter for #initialized + * @return {boolean} + */ + get: function get() { + return _classPrivateFieldGet(this, _initialized); + }, + }]); + + return BaseCMI; +}(); + /** + * Base class for cmi *.score objects + */ + + + exports.BaseCMI = BaseCMI; + + var _initialized = new WeakMap(); + + const CMIScore = +/* #__PURE__*/ +function(_BaseCMI) { + _inherits(CMIScore, _BaseCMI); + + /** + * 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 + */ + function CMIScore(_ref) { + let _this; + + const score_children = _ref.score_children; + const score_range = _ref.score_range; + const max = _ref.max; + const invalidErrorCode = _ref.invalidErrorCode; + const invalidTypeCode = _ref.invalidTypeCode; + const invalidRangeCode = _ref.invalidRangeCode; + const decimalRegex = _ref.decimalRegex; + + _classCallCheck(this, CMIScore); + + _this = _possibleConstructorReturn(this, _getPrototypeOf(CMIScore).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, + }); + + _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 ? score_children : _api_constants.scorm12_constants.score_children); + + _classPrivateFieldSet(_assertThisInitialized(_this), _score_range, !score_range ? false : _regex.scorm12_regex.score_range); + + _classPrivateFieldSet(_assertThisInitialized(_this), _max, max || max === '' ? max : '100'); + + _classPrivateFieldSet(_assertThisInitialized(_this), _invalid_error_code, invalidErrorCode ? invalidErrorCode : _error_codes.scorm12_error_codes.INVALID_SET_VALUE); + + _classPrivateFieldSet(_assertThisInitialized(_this), _invalid_type_code, invalidTypeCode ? invalidTypeCode : _error_codes.scorm12_error_codes.TYPE_MISMATCH); + + _classPrivateFieldSet(_assertThisInitialized(_this), _invalid_range_code, invalidRangeCode ? invalidRangeCode : _error_codes.scorm12_error_codes.VALUE_OUT_OF_RANGE); + + _classPrivateFieldSet(_assertThisInitialized(_this), _decimal_regex, decimalRegex ? decimalRegex : _regex.scorm12_regex.CMIDecimal); + + return _this; + } + + _createClass(CMIScore, [{ + key: 'toJSON', + + /** + * toJSON for *.score + * @return {{min: string, max: string, raw: string}} + */ + value: function toJSON() { + return { + 'raw': this.raw, + 'min': this.min, + 'max': this.max, + }; + }, + }, { + key: '_children', + + /** + * Getter for _children + * @return {string} + * @private + */ + get: function get() { + return _classPrivateFieldGet(this, _children2); + }, /** + * Setter for _children. Just throws an error. + * @param {string} _children + * @private + */ + + set: function set(_children) { + throw new _exceptions.ValidationError(_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, _score_range) || checkValidRange(raw, _classPrivateFieldGet(this, _score_range), _classPrivateFieldGet(this, _invalid_range_code)))) { + _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, _score_range) || checkValidRange(min, _classPrivateFieldGet(this, _score_range), _classPrivateFieldGet(this, _invalid_range_code)))) { + _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, _score_range) || checkValidRange(max, _classPrivateFieldGet(this, _score_range), _classPrivateFieldGet(this, _invalid_range_code)))) { + _classPrivateFieldSet(this, _max, max); + } + }, + }]); + + return CMIScore; +}(BaseCMI); + /** + * Base class for cmi *.n objects + */ + + + exports.CMIScore = CMIScore; + + 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 _raw = new WeakMap(); + + var _min = new WeakMap(); + + var _max = new WeakMap(); + + const CMIArray = +/* #__PURE__*/ +function(_BaseCMI2) { + _inherits(CMIArray, _BaseCMI2); + + /** + * Constructor cmi *.n arrays + * @param {string} children + * @param {number} errorCode + */ + function CMIArray(_ref2) { + let _this2; + + const children = _ref2.children; + const errorCode = _ref2.errorCode; + + _classCallCheck(this, CMIArray); + + _this2 = _possibleConstructorReturn(this, _getPrototypeOf(CMIArray).call(this)); + + _errorCode.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); + + _this2.childArray = []; + return _this2; + } + + _createClass(CMIArray, [{ + key: 'toJSON', + + /** + * toJSON for *.n arrays + * @return {object} + */ + value: function toJSON() { + this.jsonString = true; + const result = {}; + + for (let i = 0; i < this.childArray.length; i++) { + result[i + ''] = this.childArray[i]; + } + + delete this.jsonString; + return result; + }, + }, { + key: '_children', + + /** + * Getter for _children + * @return {*} + * @private + */ + get: function get() { + return _classPrivateFieldGet(this, _children3); + }, /** + * Setter for _children. Just throws an error. + * @param {string} _children + * @private + */ + + set: function set(_children) { + throw new _exceptions.ValidationError(_classPrivateFieldGet(this, _errorCode)); + }, + /** + * Getter for _count + * @return {number} + * @private + */ + + }, { + key: '_count', + get: function get() { + return this.childArray.length; + }, /** + * Setter for _count. Just throws an error. + * @param {number} _count + * @private + */ + + set: function set(_count) { + throw new _exceptions.ValidationError(_classPrivateFieldGet(this, _errorCode)); + }, + }]); + + return CMIArray; +}(BaseCMI); + + exports.CMIArray = CMIArray; + + var _errorCode = new WeakMap(); + + var _children3 = new WeakMap(); +}, {'../constants/api_constants': 9, '../constants/error_codes': 10, '../constants/regex': 13, '../exceptions': 15}], 7: [function(require, module, exports) { + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true, + }); + exports.throwReadOnlyError = throwReadOnlyError; + exports.throwWriteOnlyError = throwWriteOnlyError; + exports.check12ValidFormat = check12ValidFormat; + exports.check12ValidRange = check12ValidRange; + exports.CMIInteractionsCorrectResponsesObject = exports.CMIInteractionsObjectivesObject = exports.CMIObjectivesObject = exports.CMIInteractionsObject = exports.CMIStudentData = exports.CMI = void 0; + + const _common = require('./common'); + + const _api_constants = require('../constants/api_constants'); + + const _error_codes = require('../constants/error_codes'); + + const _regex = require('../constants/regex'); + + const _exceptions = require('../exceptions'); + + function _typeof(obj) { + 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 _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError('Cannot call a class as a function'); + } + } + + function _defineProperties(target, props) { + for (let i = 0; i < props.length; i++) { + const 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 _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 _get(target, property, receiver) { + if (typeof Reflect !== 'undefined' && Reflect.get) { + _get = Reflect.get; + } else { + _get = function _get(target, property, receiver) { + const base = _superPropBase(target, property); if (!base) return; const 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 _getPrototypeOf(o) { + _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { + return o.__proto__ || Object.getPrototypeOf(o); + }; return _getPrototypeOf(o); + } + + 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 _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) { + const descriptor = privateMap.get(receiver); if (!descriptor) { + throw new TypeError('attempted to get private field on non-instance'); + } if (descriptor.get) { + return descriptor.get.call(receiver); + } return descriptor.value; + } + + function _classPrivateFieldSet(receiver, privateMap, value) { + const descriptor = privateMap.get(receiver); if (!descriptor) { + throw new TypeError('attempted to set private field on non-instance'); + } 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; + } return value; + } + + const constants = _api_constants.scorm12_constants; + const regex = _regex.scorm12_regex; + /** + * Helper method for throwing Read Only error + */ + + function throwReadOnlyError() { + throw new _exceptions.ValidationError(_error_codes.scorm12_error_codes.READ_ONLY_ELEMENT); + } + /** + * Helper method for throwing Write Only error + */ + + + function throwWriteOnlyError() { + throw new _exceptions.ValidationError(_error_codes.scorm12_error_codes.WRITE_ONLY_ELEMENT); + } + /** + * Helper method for throwing Invalid Set error + */ + + + function throwInvalidValueError() { + throw new _exceptions.ValidationError(_error_codes.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 + * @return {boolean} + */ + + + function check12ValidFormat(value, regexPattern) { + return (0, _common.checkValidFormat)(value, regexPattern, _error_codes.scorm12_error_codes.TYPE_MISMATCH); + } + /** + * Helper method, no reason to have to pass the same error codes every time + * @param {*} value + * @param {string} rangePattern + * @return {boolean} + */ + + + function check12ValidRange(value, rangePattern) { + return (0, _common.checkValidRange)(value, rangePattern, _error_codes.scorm12_error_codes.VALUE_OUT_OF_RANGE); + } + /** + * Class representing the cmi object for SCORM 1.2 + */ + + + const CMI = +/* #__PURE__*/ +function(_BaseCMI) { + _inherits(CMI, _BaseCMI); + + /** + * 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) { + let _this; + + _classCallCheck(this, CMI); + + _this = _possibleConstructorReturn(this, _getPrototypeOf(CMI).call(this)); + + _children2.set(_assertThisInitialized(_this), { + writable: true, + value: '', + }); + + _version2.set(_assertThisInitialized(_this), { + writable: true, + value: '3.4', + }); + + _suspend_data.set(_assertThisInitialized(_this), { + writable: true, + value: '', + }); + + _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 : 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() { + let _this$core; let _this$objectives; let _this$student_data; let _this$student_prefere; let _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; + const 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} + * @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) { + throwInvalidValueError(); + }, + /** + * Getter for #_children + * @return {string} + * @private + */ + + }, { + key: '_children', + get: function get() { + return _classPrivateFieldGet(this, _children2); + }, /** + * Setter for #_version. Just throws an error. + * @param {string} _children + * @private + */ + + set: function set(_children) { + throwInvalidValueError(); + }, + /** + * 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, regex.CMIString4096)) { + _classPrivateFieldSet(this, _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, regex.CMIString4096)) { + _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(); + }, + }]); + + return CMI; +}(_common.BaseCMI); + /** + * Class representing the cmi.core object + */ + + + exports.CMI = CMI; + + var _children2 = new WeakMap(); + + var _version2 = new WeakMap(); + + var _suspend_data = new WeakMap(); + + var _launch_data = new WeakMap(); + + var _comments = new WeakMap(); + + var _comments_from_lms = new WeakMap(); + + var CMICore = +/* #__PURE__*/ +function(_BaseCMI2) { + _inherits(CMICore, _BaseCMI2); + + /** + * Constructor for cmi.core + */ + function CMICore() { + let _this2; + + _classCallCheck(this, CMICore); + + _this2 = _possibleConstructorReturn(this, _getPrototypeOf(CMICore).call(this)); + + _children3.set(_assertThisInitialized(_this2), { + writable: true, + value: 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: '', + }); + + _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', + }); + + _this2.score = new _common.CMIScore({ + score_children: constants.score_children, + score_range: regex.score_range, + invalidErrorCode: _error_codes.scorm12_error_codes.INVALID_SET_VALUE, + invalidTypeCode: _error_codes.scorm12_error_codes.TYPE_MISMATCH, + invalidRangeCode: _error_codes.scorm12_error_codes.VALUE_OUT_OF_RANGE, + }); + return _this2; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(CMICore, [{ + key: 'initialize', + value: function initialize() { + let _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: 'toJSON', + + /** + * 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, + * total_time: string, + * session_time: * + * } + * } + */ + value: function toJSON() { + this.jsonString = true; + const 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, + 'total_time': this.total_time, + 'lesson_mode': this.lesson_mode, + 'exit': this.exit, + 'session_time': this.session_time, + 'score': this.score, + }; + delete this.jsonString; + return result; + }, + }, { + key: '_children', + + /** + * Getter for #_children + * @return {string} + * @private + */ + get: 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, regex.CMIString256)) { + _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 (check12ValidFormat(lesson_status, regex.CMIStatus)) { + _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, regex.CMIExit)) { + _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, regex.CMITimespan)) { + _classPrivateFieldSet(this, _session_time, session_time); + } + }, + }]); + + return CMICore; +}(_common.BaseCMI); + /** + * Class representing SCORM 1.2's cmi.objectives object + */ + + + 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 CMIObjectives = +/* #__PURE__*/ +function(_CMIArray) { + _inherits(CMIObjectives, _CMIArray); + + /** + * Constructor for cmi.objectives + */ + function CMIObjectives() { + _classCallCheck(this, CMIObjectives); + + return _possibleConstructorReturn(this, _getPrototypeOf(CMIObjectives).call(this, { + children: constants.objectives_children, + errorCode: _error_codes.scorm12_error_codes.INVALID_SET_VALUE, + })); + } + + return CMIObjectives; +}(_common.CMIArray); + /** + * Class representing SCORM 1.2's cmi.student_data object + */ + + + var CMIStudentData = +/* #__PURE__*/ +function(_BaseCMI3) { + _inherits(CMIStudentData, _BaseCMI3); + + /** + * Constructor for cmi.student_data + * @param {string} student_data_children + */ + function CMIStudentData(student_data_children) { + let _this3; + + _classCallCheck(this, CMIStudentData); + + _this3 = _possibleConstructorReturn(this, _getPrototypeOf(CMIStudentData).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 : constants.student_data_children); + + return _this3; + } + /** + * Getter for #_children + * @return {*} + * @private + */ + + + _createClass(CMIStudentData, [{ + key: 'toJSON', + + /** + * toJSON for cmi.student_data + * + * @return { + * { + * max_time_allowed: string, + * time_limit_action: string, + * mastery_score: string + * } + * } + */ + value: function toJSON() { + this.jsonString = true; + const 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; + }, + }, { + 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(); + }, + }]); + + return CMIStudentData; +}(_common.BaseCMI); + /** + * Class representing SCORM 1.2's cmi.student_preference object + */ + + + exports.CMIStudentData = CMIStudentData; + + var _children4 = new WeakMap(); + + var _mastery_score = new WeakMap(); + + var _max_time_allowed = new WeakMap(); + + var _time_limit_action = new WeakMap(); + + var CMIStudentPreference = +/* #__PURE__*/ +function(_BaseCMI4) { + _inherits(CMIStudentPreference, _BaseCMI4); + + /** + * Constructor for cmi.student_preference + */ + function CMIStudentPreference() { + let _this4; + + _classCallCheck(this, CMIStudentPreference); + + _this4 = _possibleConstructorReturn(this, _getPrototypeOf(CMIStudentPreference).call(this)); + + _children5.set(_assertThisInitialized(_this4), { + writable: true, + value: constants.student_preference_children, + }); + + _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: '', + }); + + return _this4; + } + + _createClass(CMIStudentPreference, [{ + key: 'toJSON', + + /** + * toJSON for cmi.student_preference + * + * @return { + * { + * audio: string, + * language: string, + * speed: string, + * text: string + * } + * } + */ + value: function toJSON() { + this.jsonString = true; + const result = { + 'audio': this.audio, + 'language': this.language, + 'speed': this.speed, + 'text': this.text, + }; + delete this.jsonString; + return result; + }, + }, { + key: '_children', + + /** + * Getter for #_children + * @return {string} + * @private + */ + get: 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, regex.CMISInteger) && check12ValidRange(audio, 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, 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, regex.CMISInteger) && check12ValidRange(speed, 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, regex.CMISInteger) && check12ValidRange(text, regex.text_range)) { + _classPrivateFieldSet(this, _text, text); + } + }, + }]); + + return CMIStudentPreference; +}(_common.BaseCMI); + /** + * Class representing SCORM 1.2's cmi.interactions object + */ + + + var _children5 = new WeakMap(); + + var _audio = new WeakMap(); + + var _language = new WeakMap(); + + var _speed = new WeakMap(); + + var _text = new WeakMap(); + + var CMIInteractions = +/* #__PURE__*/ +function(_CMIArray2) { + _inherits(CMIInteractions, _CMIArray2); + + /** + * Constructor for cmi.interactions + */ + function CMIInteractions() { + _classCallCheck(this, CMIInteractions); + + return _possibleConstructorReturn(this, _getPrototypeOf(CMIInteractions).call(this, { + children: constants.interactions_children, + errorCode: _error_codes.scorm12_error_codes.INVALID_SET_VALUE, + })); + } + + return CMIInteractions; +}(_common.CMIArray); + /** + * Class representing SCORM 1.2's cmi.interactions.n object + */ + + + const CMIInteractionsObject = +/* #__PURE__*/ +function(_BaseCMI5) { + _inherits(CMIInteractionsObject, _BaseCMI5); + + /** + * Constructor for cmi.interactions.n object + */ + function CMIInteractionsObject() { + let _this5; + + _classCallCheck(this, CMIInteractionsObject); + + _this5 = _possibleConstructorReturn(this, _getPrototypeOf(CMIInteractionsObject).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: _error_codes.scorm12_error_codes.INVALID_SET_VALUE, + children: constants.objectives_children, + }); + _this5.correct_responses = new _common.CMIArray({ + errorCode: _error_codes.scorm12_error_codes.INVALID_SET_VALUE, + children: 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() { + let _this$objectives2; let _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: 'toJSON', + + /** + * 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 + * } + * } + */ + value: function toJSON() { + this.jsonString = true; + const 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; + }, + }, { + key: 'id', + + /** + * Getter for #id. Should only be called during JSON export. + * @return {*} + */ + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _id); + }, /** + * Setter for #id + * @param {string} id + */ + + set: function set(id) { + if (check12ValidFormat(id, 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, 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, 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, regex.CMIDecimal) && check12ValidRange(weighting, 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, regex.CMIFeedback)) { + _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, 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, regex.CMITimespan)) { + _classPrivateFieldSet(this, _latency, latency); + } + }, + }]); + + return CMIInteractionsObject; +}(_common.BaseCMI); + /** + * Class representing SCORM 1.2's cmi.objectives.n object + */ + + + exports.CMIInteractionsObject = CMIInteractionsObject; + + 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(); + + const CMIObjectivesObject = +/* #__PURE__*/ +function(_BaseCMI6) { + _inherits(CMIObjectivesObject, _BaseCMI6); + + /** + * Constructor for cmi.objectives.n + */ + function CMIObjectivesObject() { + let _this6; + + _classCallCheck(this, CMIObjectivesObject); + + _this6 = _possibleConstructorReturn(this, _getPrototypeOf(CMIObjectivesObject).call(this)); + + _id2.set(_assertThisInitialized(_this6), { + writable: true, + value: '', + }); + + _status.set(_assertThisInitialized(_this6), { + writable: true, + value: '', + }); + + _this6.score = new _common.CMIScore({ + score_children: constants.score_children, + score_range: regex.score_range, + invalidErrorCode: _error_codes.scorm12_error_codes.INVALID_SET_VALUE, + invalidTypeCode: _error_codes.scorm12_error_codes.TYPE_MISMATCH, + invalidRangeCode: _error_codes.scorm12_error_codes.VALUE_OUT_OF_RANGE, + }); + return _this6; + } + + _createClass(CMIObjectivesObject, [{ + key: 'toJSON', + + /** + * toJSON for cmi.objectives.n + * @return { + * { + * id: string, + * status: string, + * score: CMIScore + * } + * } + */ + value: function toJSON() { + this.jsonString = true; + const result = { + 'id': this.id, + 'status': this.status, + 'score': this.score, + }; + delete this.jsonString; + return result; + }, + }, { + key: 'id', + + /** + * Getter for #id + * @return {""} + */ + get: function get() { + return _classPrivateFieldGet(this, _id2); + }, /** + * Setter for #id + * @param {string} id + */ + + set: function set(id) { + if (check12ValidFormat(id, 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, regex.CMIStatus2)) { + _classPrivateFieldSet(this, _status, status); + } + }, + }]); + + return CMIObjectivesObject; +}(_common.BaseCMI); + /** + * Class representing SCORM 1.2's cmi.interactions.n.objectives.n object + */ + + + exports.CMIObjectivesObject = CMIObjectivesObject; + + var _id2 = new WeakMap(); + + var _status = new WeakMap(); + + const CMIInteractionsObjectivesObject = +/* #__PURE__*/ +function(_BaseCMI7) { + _inherits(CMIInteractionsObjectivesObject, _BaseCMI7); + + /** + * Constructor for cmi.interactions.n.objectives.n + */ + function CMIInteractionsObjectivesObject() { + let _this7; + + _classCallCheck(this, CMIInteractionsObjectivesObject); + + _this7 = _possibleConstructorReturn(this, _getPrototypeOf(CMIInteractionsObjectivesObject).call(this)); + + _id3.set(_assertThisInitialized(_this7), { + writable: true, + value: '', + }); + + return _this7; + } + + _createClass(CMIInteractionsObjectivesObject, [{ + key: 'toJSON', + + /** + * toJSON for cmi.interactions.n.objectives.n + * @return { + * { + * id: string + * } + * } + */ + value: function toJSON() { + this.jsonString = true; + const result = { + 'id': this.id, + }; + delete this.jsonString; + return result; + }, + }, { + key: 'id', + + /** + * Getter for #id + * @return {""} + */ + get: function get() { + return _classPrivateFieldGet(this, _id3); + }, /** + * Setter for #id + * @param {string} id + */ + + set: function set(id) { + if (check12ValidFormat(id, regex.CMIIdentifier)) { + _classPrivateFieldSet(this, _id3, id); + } + }, + }]); + + return CMIInteractionsObjectivesObject; +}(_common.BaseCMI); + /** + * Class representing SCORM 1.2's cmi.interactions.correct_responses.n object + */ + + + exports.CMIInteractionsObjectivesObject = CMIInteractionsObjectivesObject; + + var _id3 = new WeakMap(); + + const CMIInteractionsCorrectResponsesObject = +/* #__PURE__*/ +function(_BaseCMI8) { + _inherits(CMIInteractionsCorrectResponsesObject, _BaseCMI8); + + /** + * Constructor for cmi.interactions.correct_responses.n + */ + function CMIInteractionsCorrectResponsesObject() { + let _this8; + + _classCallCheck(this, CMIInteractionsCorrectResponsesObject); + + _this8 = _possibleConstructorReturn(this, _getPrototypeOf(CMIInteractionsCorrectResponsesObject).call(this)); + + _pattern.set(_assertThisInitialized(_this8), { + writable: true, + value: '', + }); + + return _this8; + } + + _createClass(CMIInteractionsCorrectResponsesObject, [{ + key: 'toJSON', + + /** + * toJSON for cmi.interactions.correct_responses.n + * @return { + * { + * pattern: string + * } + * } + */ + value: function toJSON() { + this.jsonString = true; + const result = { + 'pattern': this.pattern, + }; + delete this.jsonString; + return result; + }, + }, { + key: 'pattern', + + /** + * Getter for #pattern + * @return {string} + */ + get: function get() { + return !this.jsonString ? throwWriteOnlyError() : _classPrivateFieldGet(this, _pattern); + }, /** + * Setter for #pattern + * @param {string} pattern + */ + + set: function set(pattern) { + if (check12ValidFormat(pattern, regex.CMIFeedback)) { + _classPrivateFieldSet(this, _pattern, pattern); + } + }, + }]); + + return CMIInteractionsCorrectResponsesObject; +}(_common.BaseCMI); + + exports.CMIInteractionsCorrectResponsesObject = CMIInteractionsCorrectResponsesObject; + + var _pattern = new WeakMap(); +}, {'../constants/api_constants': 9, '../constants/error_codes': 10, '../constants/regex': 13, '../exceptions': 15, './common': 6}], 8: [function(require, module, exports) { + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true, + }); + exports.ADL = exports.CMIInteractionsCorrectResponsesObject = exports.CMIInteractionsObjectivesObject = exports.CMICommentsFromLMSObject = exports.CMICommentsFromLearnerObject = exports.CMIObjectivesObject = exports.CMIInteractionsObject = exports.CMI = void 0; + + const _common = require('./common'); + + const _api_constants = require('../constants/api_constants'); + + const _regex = require('../constants/regex'); + + const _error_codes = require('../constants/error_codes'); + + const _response_constants = require('../constants/response_constants'); + + const _exceptions = require('../exceptions'); + + function _typeof(obj) { + 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 set(target, property, value, receiver) { + if (typeof Reflect !== 'undefined' && Reflect.set) { + set = Reflect.set; + } else { + set = function set(target, property, value, receiver) { + const base = _superPropBase(target, property); let desc; if (base) { + desc = Object.getOwnPropertyDescriptor(base, property); if (desc.set) { + desc.set.call(receiver, value); return true; + } else if (!desc.writable) { + return false; + } + } desc = Object.getOwnPropertyDescriptor(receiver, property); if (desc) { + if (!desc.writable) { + return false; + } desc.value = value; Object.defineProperty(receiver, property, desc); + } else { + _defineProperty(receiver, property, value); + } return true; + }; + } return set(target, property, value, receiver); + } + + function _set(target, property, value, receiver, isStrict) { + const s = set(target, property, value, receiver || target); if (!s && isStrict) { + throw new Error('failed to set property'); + } return value; + } + + 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 (let i = 0; i < props.length; i++) { + const 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 _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 _get(target, property, receiver) { + if (typeof Reflect !== 'undefined' && Reflect.get) { + _get = Reflect.get; + } else { + _get = function _get(target, property, receiver) { + const base = _superPropBase(target, property); if (!base) return; const 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 _getPrototypeOf(o) { + _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { + return o.__proto__ || Object.getPrototypeOf(o); + }; return _getPrototypeOf(o); + } + + 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 _classPrivateFieldSet(receiver, privateMap, value) { + const descriptor = privateMap.get(receiver); if (!descriptor) { + throw new TypeError('attempted to set private field on non-instance'); + } 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; + } return value; + } + + function _classPrivateFieldGet(receiver, privateMap) { + const descriptor = privateMap.get(receiver); if (!descriptor) { + throw new TypeError('attempted to get private field on non-instance'); + } if (descriptor.get) { + return descriptor.get.call(receiver); + } return descriptor.value; + } + + const constants = _api_constants.scorm2004_constants; + const regex = _regex.scorm2004_regex; + /** + * Helper method for throwing Read Only error + */ + + function throwReadOnlyError() { + throw new _exceptions.ValidationError(_error_codes.scorm2004_error_codes.READ_ONLY_ELEMENT); + } + /** + * Helper method for throwing Write Only error + */ + + + function throwWriteOnlyError() { + throw new _exceptions.ValidationError(_error_codes.scorm2004_error_codes.WRITE_ONLY_ELEMENT); + } + /** + * Helper method for throwing Type Mismatch error + */ + + + function throwTypeMismatchError() { + throw new _exceptions.ValidationError(_error_codes.scorm2004_error_codes.TYPE_MISMATCH); + } + /** + * 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, _error_codes.scorm2004_error_codes.TYPE_MISMATCH, 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, _error_codes.scorm2004_error_codes.VALUE_OUT_OF_RANGE); + } + /** + * Class representing cmi object for SCORM 2004 + */ + + + const CMI = +/* #__PURE__*/ +function(_BaseCMI) { + _inherits(CMI, _BaseCMI); + + /** + * Constructor for the SCORM 2004 cmi object + * @param {boolean} initialized + */ + function CMI(initialized) { + let _this; + + _classCallCheck(this, CMI); + + _this = _possibleConstructorReturn(this, _getPrototypeOf(CMI).call(this)); + + _version2.set(_assertThisInitialized(_this), { + writable: true, + value: '1.0', + }); + + _children2.set(_assertThisInitialized(_this), { + writable: true, + value: 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: '0', + }); + + if (initialized) _this.initialize(); + _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(); + return _this; + } + /** + * Called when the API has been initialized after the CMI has been created + */ + + + _createClass(CMI, [{ + key: 'initialize', + value: function initialize() { + let _this$learner_prefere; let _this$score; let _this$comments_from_l; let _this$comments_from_l2; let _this$interactions; let _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: 'toJSON', + + /** + * 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, + * total_time: string + * } + * } + */ + value: function toJSON() { + this.jsonString = true; + const 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, + 'total_time': this.total_time, + }; + delete this.jsonString; + return result; + }, + }, { + 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, 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, regex.CMIExit)) { + _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, 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, regex.CMIDecimal) && check2004ValidRange(progress_measure, 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, 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, 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, regex.CMIString64000)) { + _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(); + }, + }]); + + return CMI; +}(_common.BaseCMI); + /** + * Class for SCORM 2004's cmi.learner_preference object + */ + + + exports.CMI = CMI; + + 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 CMILearnerPreference = +/* #__PURE__*/ +function(_BaseCMI2) { + _inherits(CMILearnerPreference, _BaseCMI2); + + /** + * Constructor for cmi.learner_preference + */ + function CMILearnerPreference() { + let _this2; + + _classCallCheck(this, CMILearnerPreference); + + _this2 = _possibleConstructorReturn(this, _getPrototypeOf(CMILearnerPreference).call(this)); + + _children3.set(_assertThisInitialized(_this2), { + writable: true, + value: 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: 'toJSON', + + /** + * toJSON for cmi.learner_preference + * + * @return { + * { + * audio_level: string, + * language: string, + * delivery_speed: string, + * audio_captioning: string + * } + * } + */ + value: function toJSON() { + this.jsonString = true; + const result = { + 'audio_level': this.audio_level, + 'language': this.language, + 'delivery_speed': this.delivery_speed, + 'audio_captioning': this.audio_captioning, + }; + delete this.jsonString; + return result; + }, + }, { + 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, regex.CMIDecimal) && check2004ValidRange(audio_level, 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, 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, regex.CMIDecimal) && check2004ValidRange(delivery_speed, 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, regex.CMISInteger) && check2004ValidRange(audio_captioning, regex.text_range)) { + _classPrivateFieldSet(this, _audio_captioning, audio_captioning); + } + }, + }]); + + return CMILearnerPreference; +}(_common.BaseCMI); + /** + * Class representing SCORM 2004's cmi.interactions object + */ + + + var _children3 = new WeakMap(); + + var _audio_level = new WeakMap(); + + var _language = new WeakMap(); + + var _delivery_speed = new WeakMap(); + + var _audio_captioning = new WeakMap(); + + var CMIInteractions = +/* #__PURE__*/ +function(_CMIArray) { + _inherits(CMIInteractions, _CMIArray); + + /** + * Constructor for cmi.objectives Array + */ + function CMIInteractions() { + _classCallCheck(this, CMIInteractions); + + return _possibleConstructorReturn(this, _getPrototypeOf(CMIInteractions).call(this, { + children: constants.interactions_children, + errorCode: _error_codes.scorm2004_error_codes.READ_ONLY_ELEMENT, + })); + } + + return CMIInteractions; +}(_common.CMIArray); + /** + * Class representing SCORM 2004's cmi.objectives object + */ + + + var CMIObjectives = +/* #__PURE__*/ +function(_CMIArray2) { + _inherits(CMIObjectives, _CMIArray2); + + /** + * Constructor for cmi.objectives Array + */ + function CMIObjectives() { + _classCallCheck(this, CMIObjectives); + + return _possibleConstructorReturn(this, _getPrototypeOf(CMIObjectives).call(this, { + children: constants.objectives_children, + errorCode: _error_codes.scorm2004_error_codes.READ_ONLY_ELEMENT, + })); + } + + return CMIObjectives; +}(_common.CMIArray); + /** + * Class representing SCORM 2004's cmi.comments_from_lms object + */ + + + var CMICommentsFromLMS = +/* #__PURE__*/ +function(_CMIArray3) { + _inherits(CMICommentsFromLMS, _CMIArray3); + + /** + * Constructor for cmi.comments_from_lms Array + */ + function CMICommentsFromLMS() { + _classCallCheck(this, CMICommentsFromLMS); + + return _possibleConstructorReturn(this, _getPrototypeOf(CMICommentsFromLMS).call(this, { + children: constants.comments_children, + errorCode: _error_codes.scorm2004_error_codes.READ_ONLY_ELEMENT, + })); + } + + return CMICommentsFromLMS; +}(_common.CMIArray); + /** + * Class representing SCORM 2004's cmi.comments_from_learner object + */ + + + var CMICommentsFromLearner = +/* #__PURE__*/ +function(_CMIArray4) { + _inherits(CMICommentsFromLearner, _CMIArray4); + + /** + * Constructor for cmi.comments_from_learner Array + */ + function CMICommentsFromLearner() { + _classCallCheck(this, CMICommentsFromLearner); + + return _possibleConstructorReturn(this, _getPrototypeOf(CMICommentsFromLearner).call(this, { + children: constants.comments_children, + errorCode: _error_codes.scorm2004_error_codes.READ_ONLY_ELEMENT, + })); + } + + return CMICommentsFromLearner; +}(_common.CMIArray); + /** + * Class for SCORM 2004's cmi.interaction.n object + */ + + + const CMIInteractionsObject = +/* #__PURE__*/ +function(_BaseCMI3) { + _inherits(CMIInteractionsObject, _BaseCMI3); + + /** + * Constructor for cmi.interaction.n + */ + function CMIInteractionsObject() { + let _this3; + + _classCallCheck(this, CMIInteractionsObject); + + _this3 = _possibleConstructorReturn(this, _getPrototypeOf(CMIInteractionsObject).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: _error_codes.scorm2004_error_codes.READ_ONLY_ELEMENT, + children: constants.objectives_children, + }); + _this3.correct_responses = new _common.CMIArray({ + errorCode: _error_codes.scorm2004_error_codes.READ_ONLY_ELEMENT, + children: 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() { + let _this$objectives2; let _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: 'toJSON', + + /** + * 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 + * } + * } + */ + value: function toJSON() { + this.jsonString = true; + const 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; + }, + }, { + key: 'id', + get: function get() { + return _classPrivateFieldGet(this, _id); + }, /** + * Setter for #id + * @param {string} id + */ + + set: function set(id) { + if (check2004ValidFormat(id, 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 (check2004ValidFormat(type, 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 (check2004ValidFormat(timestamp, 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 (check2004ValidFormat(weighting, 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 (typeof this.type === 'undefined') { + throw new _exceptions.ValidationError(_error_codes.scorm2004_error_codes.DEPENDENCY_NOT_ESTABLISHED); + } else { + let nodes = []; + const response_type = _response_constants.learner_responses[this.type]; + + if (response_type.delimiter !== '') { + nodes = learner_response.split(response_type.delimiter); + } else { + nodes[0] = learner_response; + } + + if (nodes.length > 0 && nodes.length <= response_type.max) { + const formatRegex = new RegExp(response_type.format); + + for (let i = 0; i < nodes.length; i++) { + if (typeof response_type.delimiter2 !== 'undefined') { + const 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 (let j = 0; j < i; j++) { + if (nodes[i] === nodes[j]) { + throwTypeMismatchError(); + } + } + } + } + } + } + } else { + throw new _exceptions.ValidationError(_error_codes.scorm2004_error_codes.GENERAL_SET_FAILURE); + } + } + }, + /** + * 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, 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 (check2004ValidFormat(latency, 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 (check2004ValidFormat(description, regex.CMILangString250, true)) { + _classPrivateFieldSet(this, _description, description); + } + }, + }]); + + return CMIInteractionsObject; +}(_common.BaseCMI); + /** + * Class for SCORM 2004's cmi.objectives.n object + */ + + + exports.CMIInteractionsObject = CMIInteractionsObject; + + 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(); + + const CMIObjectivesObject = +/* #__PURE__*/ +function(_BaseCMI4) { + _inherits(CMIObjectivesObject, _BaseCMI4); + + /** + * Constructor for cmi.objectives.n + */ + function CMIObjectivesObject() { + let _this4; + + _classCallCheck(this, CMIObjectivesObject); + + _this4 = _possibleConstructorReturn(this, _getPrototypeOf(CMIObjectivesObject).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() { + let _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: 'toJSON', + + /** + * toJSON for cmi.objectives.n + * + * @return { + * { + * id: string, + * success_status: string, + * completion_status: string, + * progress_measure: string, + * description: string, + * score: Scorm2004CMIScore + * } + * } + */ + value: function toJSON() { + this.jsonString = true; + const 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; + }, + }, { + key: 'id', + get: function get() { + return _classPrivateFieldGet(this, _id2); + }, /** + * Setter for #id + * @param {string} id + */ + + set: function set(id) { + if (check2004ValidFormat(id, 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 (check2004ValidFormat(success_status, 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 (check2004ValidFormat(completion_status, 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 (check2004ValidFormat(progress_measure, regex.CMIDecimal) && check2004ValidRange(progress_measure, 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 (check2004ValidFormat(description, regex.CMILangString250, true)) { + _classPrivateFieldSet(this, _description2, description); + } + }, + }]); + + return CMIObjectivesObject; +}(_common.BaseCMI); + /** + * Class for SCORM 2004's cmi *.score object + */ + + + exports.CMIObjectivesObject = CMIObjectivesObject; + + var _id2 = new WeakMap(); + + var _success_status2 = new WeakMap(); + + var _completion_status2 = new WeakMap(); + + var _progress_measure2 = new WeakMap(); + + var _description2 = new WeakMap(); + + var Scorm2004CMIScore = +/* #__PURE__*/ +function(_CMIScore) { + _inherits(Scorm2004CMIScore, _CMIScore); + + /** + * Constructor for cmi *.score + */ + function Scorm2004CMIScore() { + let _this5; + + _classCallCheck(this, Scorm2004CMIScore); + + _this5 = _possibleConstructorReturn(this, _getPrototypeOf(Scorm2004CMIScore).call(this, { + score_children: constants.score_children, + max: '', + invalidErrorCode: _error_codes.scorm2004_error_codes.INVALID_SET_VALUE, + invalidTypeCode: _error_codes.scorm2004_error_codes.TYPE_MISMATCH, + invalidRangeCode: _error_codes.scorm2004_error_codes.VALUE_OUT_OF_RANGE, + decimalRegex: _regex.scorm2004_regex.CMIDecimal, + })); + + _scaled.set(_assertThisInitialized(_this5), { + writable: true, + value: '', + }); + + return _this5; + } + /** + * Getter for #scaled + * @return {string} + */ + + + _createClass(Scorm2004CMIScore, [{ + key: 'toJSON', + + /** + * toJSON for cmi *.score + * + * @return { + * { + * scaled: string, + * raw: string, + * min: string, + * max: string + * } + * } + */ + value: function toJSON() { + this.jsonString = true; + const 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; + }, + }, { + key: 'scaled', + get: function get() { + return _classPrivateFieldGet(this, _scaled); + }, /** + * Setter for #scaled + * @param {string} scaled + */ + + set: function set(scaled) { + if (check2004ValidFormat(scaled, regex.CMIDecimal) && check2004ValidRange(scaled, regex.scaled_range)) { + _classPrivateFieldSet(this, _scaled, scaled); + } + }, + }]); + + return Scorm2004CMIScore; +}(_common.CMIScore); + /** + * Class representing SCORM 2004's cmi.comments_from_learner.n object + */ + + + var _scaled = new WeakMap(); + + const CMICommentsFromLearnerObject = +/* #__PURE__*/ +function(_BaseCMI5) { + _inherits(CMICommentsFromLearnerObject, _BaseCMI5); + + /** + * Constructor for cmi.comments_from_learner.n + */ + function CMICommentsFromLearnerObject() { + let _this6; + + _classCallCheck(this, CMICommentsFromLearnerObject); + + _this6 = _possibleConstructorReturn(this, _getPrototypeOf(CMICommentsFromLearnerObject).call(this)); + + _comment.set(_assertThisInitialized(_this6), { + writable: true, + value: '', + }); + + _location2.set(_assertThisInitialized(_this6), { + writable: true, + value: '', + }); + + _timestamp2.set(_assertThisInitialized(_this6), { + writable: true, + value: '', + }); + + _classPrivateFieldSet(_assertThisInitialized(_this6), _comment, ''); + + _classPrivateFieldSet(_assertThisInitialized(_this6), _location2, ''); + + _classPrivateFieldSet(_assertThisInitialized(_this6), _timestamp2, ''); + + return _this6; + } + /** + * Getter for #comment + * @return {string} + */ + + + _createClass(CMICommentsFromLearnerObject, [{ + key: 'toJSON', + + /** + * toJSON for cmi.comments_from_learner.n object + * @return { + * { + * comment: string, + * location: string, + * timestamp: string + * } + * } + */ + value: function toJSON() { + this.jsonString = true; + const result = { + 'comment': this.comment, + 'location': this.location, + 'timestamp': this.timestamp, + }; + delete this.jsonString; + return result; + }, + }, { + key: 'comment', + get: function get() { + return _classPrivateFieldGet(this, _comment); + }, /** + * Setter for #comment + * @param {string} comment + */ + + set: function set(comment) { + if (check2004ValidFormat(comment, 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 (check2004ValidFormat(location, 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 (check2004ValidFormat(timestamp, regex.CMITime)) { + _classPrivateFieldSet(this, _timestamp2, timestamp); + } + }, + }]); + + return CMICommentsFromLearnerObject; +}(_common.BaseCMI); + /** + * Class representing SCORM 2004's cmi.comments_from_lms.n object + */ + + + exports.CMICommentsFromLearnerObject = CMICommentsFromLearnerObject; + + var _comment = new WeakMap(); + + var _location2 = new WeakMap(); + + var _timestamp2 = new WeakMap(); + + const CMICommentsFromLMSObject = +/* #__PURE__*/ +function(_CMICommentsFromLearn) { + _inherits(CMICommentsFromLMSObject, _CMICommentsFromLearn); + + /** + * Constructor for cmi.comments_from_lms.n + */ + function CMICommentsFromLMSObject() { + _classCallCheck(this, CMICommentsFromLMSObject); + + return _possibleConstructorReturn(this, _getPrototypeOf(CMICommentsFromLMSObject).call(this)); + } + /** + * Getter for #comment + * @return {string} + */ + + + _createClass(CMICommentsFromLMSObject, [{ + key: 'toJSON', + + /** + * toJSON for cmi.comments_from_lms.n + * @return { + * { + * comment: string, + * location: string, + * timestamp: string + * } + * } + */ + value: function toJSON() { + return _get(_getPrototypeOf(CMICommentsFromLMSObject.prototype), 'toJSON', this).call(this); + }, + }, { + key: 'comment', + get: function get() { + return _get(_getPrototypeOf(CMICommentsFromLMSObject.prototype), 'comment', this); + }, /** + * Setter for #comment. Can only be called before initialization. + * @param {string} comment + */ + + set: function set(comment) { + !this.initialized ? _set(_getPrototypeOf(CMICommentsFromLMSObject.prototype), 'comment', comment, this, true) : throwReadOnlyError(); + }, + /** + * Getter for #location + * @return {string} + */ + + }, { + key: 'location', + get: function get() { + return _get(_getPrototypeOf(CMICommentsFromLMSObject.prototype), 'location', this); + }, /** + * Setter for #location. Can only be called before initialization. + * @param {string} location + */ + + set: function set(location) { + !this.initialized ? _set(_getPrototypeOf(CMICommentsFromLMSObject.prototype), 'location', location, this, true) : throwReadOnlyError(); + }, + /** + * Getter for #timestamp + * @return {string} + */ + + }, { + key: 'timestamp', + get: function get() { + return _get(_getPrototypeOf(CMICommentsFromLMSObject.prototype), 'timestamp', this); + }, /** + * Setter for #timestamp. Can only be called before initialization. + * @param {string} timestamp + */ + + set: function set(timestamp) { + !this.initialized ? _set(_getPrototypeOf(CMICommentsFromLMSObject.prototype), 'timestamp', timestamp, this, true) : throwReadOnlyError(); + }, + }]); + + return CMICommentsFromLMSObject; +}(CMICommentsFromLearnerObject); + /** + * Class representing SCORM 2004's cmi.interactions.n.objectives.n object + */ + + + exports.CMICommentsFromLMSObject = CMICommentsFromLMSObject; + + const CMIInteractionsObjectivesObject = +/* #__PURE__*/ +function(_BaseCMI6) { + _inherits(CMIInteractionsObjectivesObject, _BaseCMI6); + + /** + * Constructor for cmi.interactions.n.objectives.n + */ + function CMIInteractionsObjectivesObject() { + let _this7; + + _classCallCheck(this, CMIInteractionsObjectivesObject); + + _this7 = _possibleConstructorReturn(this, _getPrototypeOf(CMIInteractionsObjectivesObject).call(this)); + + _id3.set(_assertThisInitialized(_this7), { + writable: true, + value: '', + }); + + return _this7; + } + /** + * Getter for #id + * @return {string} + */ + + + _createClass(CMIInteractionsObjectivesObject, [{ + key: 'toJSON', + + /** + * toJSON for cmi.interactions.n.objectives.n + * @return { + * { + * id: string + * } + * } + */ + value: function toJSON() { + this.jsonString = true; + const result = { + 'id': this.id, + }; + delete this.jsonString; + return result; + }, + }, { + key: 'id', + get: function get() { + return _classPrivateFieldGet(this, _id3); + }, /** + * Setter for #id + * @param {string} id + */ + + set: function set(id) { + if (check2004ValidFormat(id, regex.CMILongIdentifier)) { + _classPrivateFieldSet(this, _id3, id); + } + }, + }]); + + return CMIInteractionsObjectivesObject; +}(_common.BaseCMI); + /** + * Class representing SCORM 2004's cmi.interactions.n.correct_responses.n object + */ + + + exports.CMIInteractionsObjectivesObject = CMIInteractionsObjectivesObject; + + var _id3 = new WeakMap(); + + const CMIInteractionsCorrectResponsesObject = +/* #__PURE__*/ +function(_BaseCMI7) { + _inherits(CMIInteractionsCorrectResponsesObject, _BaseCMI7); + + /** + * Constructor for cmi.interactions.n.correct_responses.n + */ + function CMIInteractionsCorrectResponsesObject() { + let _this8; + + _classCallCheck(this, CMIInteractionsCorrectResponsesObject); + + _this8 = _possibleConstructorReturn(this, _getPrototypeOf(CMIInteractionsCorrectResponsesObject).call(this)); + + _pattern.set(_assertThisInitialized(_this8), { + writable: true, + value: '', + }); + + return _this8; + } + /** + * Getter for #pattern + * @return {string} + */ + + + _createClass(CMIInteractionsCorrectResponsesObject, [{ + key: 'toJSON', + + /** + * toJSON cmi.interactions.n.correct_responses.n object + * @return { + * { + * pattern: string + * } + * } + */ + value: function toJSON() { + this.jsonString = true; + const result = { + 'pattern': this.pattern, + }; + delete this.jsonString; + return result; + }, + }, { + key: 'pattern', + get: function get() { + return _classPrivateFieldGet(this, _pattern); + }, /** + * Setter for #pattern + * @param {string} pattern + */ + + set: function set(pattern) { + if (check2004ValidFormat(pattern, regex.CMIFeedback)) { + _classPrivateFieldSet(this, _pattern, pattern); + } + }, + }]); + + return CMIInteractionsCorrectResponsesObject; +}(_common.BaseCMI); + /** + * Class representing SCORM 2004's adl object + */ + + + exports.CMIInteractionsCorrectResponsesObject = CMIInteractionsCorrectResponsesObject; + + var _pattern = new WeakMap(); + + const ADL = +/* #__PURE__*/ +function(_BaseCMI8) { + _inherits(ADL, _BaseCMI8); + + /** + * Constructor for adl + */ + function ADL() { + let _this9; + + _classCallCheck(this, ADL); + + _this9 = _possibleConstructorReturn(this, _getPrototypeOf(ADL).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() { + let _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; + const 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 ADLNav = +/* #__PURE__*/ +function(_BaseCMI9) { + _inherits(ADLNav, _BaseCMI9); + + /** + * Constructor for adl.nav + */ + function ADLNav() { + let _this10; + + _classCallCheck(this, ADLNav); + + _this10 = _possibleConstructorReturn(this, _getPrototypeOf(ADLNav).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() { + let _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: 'toJSON', + + /** + * toJSON for adl.nav + * + * @return { + * { + * request: string + * } + * } + */ + value: function toJSON() { + this.jsonString = true; + const result = { + 'request': this.request, + }; + delete this.jsonString; + return result; + }, + }, { + key: 'request', + get: function get() { + return _classPrivateFieldGet(this, _request); + }, /** + * Setter for #request + * @param {string} request + */ + + set: function set(request) { + if (check2004ValidFormat(request, regex.NAVEvent)) { + _classPrivateFieldSet(this, _request, request); + } + }, + }]); + + return ADLNav; +}(_common.BaseCMI); + /** + * Class representing SCORM 2004's adl.nav.request_valid object + */ + + + var _request = new WeakMap(); + + var ADLNavRequestValid = +/* #__PURE__*/ +function(_BaseCMI10) { + _inherits(ADLNavRequestValid, _BaseCMI10); + + /** + * Constructor for adl.nav.request_valid + */ + function ADLNavRequestValid() { + let _temp; let _temp2; + + let _this11; + + _classCallCheck(this, ADLNavRequestValid); + + _this11 = _possibleConstructorReturn(this, _getPrototypeOf(ADLNavRequestValid).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: 'toJSON', + + /** + * toJSON for adl.nav.request_valid + * + * @return { + * { + * previous: string, + * continue: string + * } + * } + */ + value: function toJSON() { + this.jsonString = true; + const result = { + 'previous': this.previous, + 'continue': this['continue'], + }; + delete this.jsonString; + return result; + }, + }, { + 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(); + }, + }]); + + return ADLNavRequestValid; +}(_common.BaseCMI); + + var _continue = new WeakMap(); + + var _previous = new WeakMap(); +}, {'../constants/api_constants': 9, '../constants/error_codes': 10, '../constants/regex': 13, '../constants/response_constants': 14, '../exceptions': 15, './common': 6}], 9: [function(require, module, exports) { + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true, + }); + exports.scorm2004_constants = exports.aicc_constants = exports.scorm12_constants = void 0; + + function ownKeys(object, enumerableOnly) { + const keys = Object.keys(object); if (Object.getOwnPropertySymbols) { + let 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 (let i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { + ownKeys(source, true).forEach(function(key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(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; + } + + const scorm12_constants = { + // 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.', + }, + }, + }; + exports.scorm12_constants = scorm12_constants; + + const aicc_constants = _objectSpread({}, scorm12_constants, {}, { + cmi_children: 'core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions,evaluation', + student_data_children: 'attempt_number,tries,mastery_score,max_time_allowed,time_limit_action', + tries_children: 'time,status,score', + }); + + exports.aicc_constants = aicc_constants; + const scorm2004_constants = { + // 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.', + }, + }, + }; + exports.scorm2004_constants = scorm2004_constants; +}, {}], 10: [function(require, module, exports) { + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true, + }); + exports.scorm2004_error_codes = exports.scorm12_error_codes = exports.error_codes = void 0; + + function ownKeys(object, enumerableOnly) { + const keys = Object.keys(object); if (Object.getOwnPropertySymbols) { + let 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 (let i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { + ownKeys(source, true).forEach(function(key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(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; + } + + const error_codes = { + 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, + }; + exports.error_codes = error_codes; + + const scorm12_error_codes = _objectSpread({}, error_codes, {}, { + 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, + }); + + exports.scorm12_error_codes = scorm12_error_codes; + + const scorm2004_error_codes = _objectSpread({}, error_codes, {}, { + 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, + }); + + exports.scorm2004_error_codes = scorm2004_error_codes; +}, {}], 11: [function(require, module, exports) { + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true, + }); + exports.scorm2004_values = exports.scorm12_values = void 0; + + function ownKeys(object, enumerableOnly) { + const keys = Object.keys(object); if (Object.getOwnPropertySymbols) { + let 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 (let i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { + ownKeys(source, true).forEach(function(key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(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; + } + + const common_values = { + validResult: ['correct', 'wrong', 'unanticipated', 'neutral'], + invalidResult: ['-10000', '10000', 'invalid'], + valid0To1Range: ['0.0', '0.25', '0.5', '1.0'], + invalid0To1Range: ['-1', '-0.1', '1.1', '.25'], + valid0To100Range: ['1', '50', '100'], + invalid0To100Range: ['invalid', 'a100', '-1'], + validScaledRange: ['1', '0.5', '0', '-0.5', '-1'], + invalidScaledRange: ['-101', '25.1', '50.5', '75', '100'], + validIntegerScaledRange: ['1', '0', '-1'], + invalidIntegerScaledRange: ['-101', '-0.5', '0.5', '25.1', '50.5', '75', '100'], + }; + + const scorm12_values = _objectSpread({}, common_values, {}, { + validLessonStatus: ['passed', 'completed', 'failed', 'incomplete', 'browsed'], + invalidLessonStatus: ['Passed', 'P', 'F', 'p', 'true', 'false', 'complete'], + validExit: ['time-out', 'suspend', 'logout'], + invalidExit: ['close', 'exit', 'crash'], + validType: ['true-false', 'choice', 'fill-in', 'matching', 'performance', 'sequencing', 'likert', 'numeric'], + invalidType: ['correct', 'wrong', 'logout'], + validSpeedRange: ['1', '50', '100', '-1', '-50', '-100'], + invalidSpeedRange: ['invalid', 'a100', '-101', '101', '-100000', '100000'], + validScoreRange: ['1', '50.25', '100'], + invalidScoreRange: ['invalid', 'a100', '-1', '101', '-100000', '100000'], + invalid0To100Range: ['invalid', 'a100', '-2'], + validTime: ['10:06:57', '23:59:59', '00:00:00'], + invalidTime: ['47:59:59', '00:00:01.56', '06:5:13', '23:59:59.123', 'P1DT23H59M59S'], + validTimestamp: ['10:06:57', '00:00:01.56', '23:59:59', '47:59:59'], + invalidTimestamp: ['06:5:13', '23:59:59.123', 'P1DT23H59M59S'], + }); + + exports.scorm12_values = scorm12_values; + + const scorm2004_values = _objectSpread({}, common_values, {}, { + // valid field values + validTimestamps: ['2019-06-25', '2019-06-25T23:59', '2019-06-25T23:59:59.99', '1970-01-01'], + invalidTimestamps: ['2019-06-25T', '2019-06-25T23:59:59.999', '2019-06-25T25:59:59.99', '2019-13-31', '1969-12-31', '-00:00:30', '0:50:30', '23:00:30.'], + validCStatus: ['completed', 'incomplete', 'not attempted', 'unknown'], + invalidCStatus: ['complete', 'passed', 'failed'], + validSStatus: ['passed', 'failed', 'unknown'], + invalidSStatus: ['complete', 'incomplete', 'P', 'f'], + validExit: ['time-out', 'suspend', 'logout', 'normal'], + invalidExit: ['close', 'exit', 'crash'], + validType: ['true-false', 'choice', 'fill-in', 'long-fill-in', 'matching', 'performance', 'sequencing', 'likert', 'numeric', 'other'], + invalidType: ['correct', 'wrong', 'logout'], + validScoreRange: ['1', '50', '100', '-10000', '-1', '10000'], + invalidScoreRange: ['invalid', 'a100', '-100000', '100000'], + validISO8601Durations: ['P1Y34DT23H45M15S', 'PT1M45S', 'P0S', 'PT75M'], + invalidISO8601Durations: ['00:08:45', '-P1H', '1y45D', '0'], + validComment: ['{lang=en-98} learner comment', '{lang=eng-98-9} learner comment', '{lang=eng-98-9fhgj}' + 'x'.repeat(4000), 'learner comment', 'learner comment}', '{lang=i-xx}', '{lang=i}', ''], + invalidComment: ['{lang=i-}', '{lang=i-x}', '{lang=eng-98-9fhgj}{ learner comment', '{learner comment', '{lang=eng-98-9fhgj}' + 'x'.repeat(4001), '{lang=eng-98-9fhgj}{' + 'x'.repeat(3999)], + validDescription: ['{lang=en-98} learner comment', '{lang=eng-98-9} learner comment', '{lang=eng-98-9fhgj}' + 'x'.repeat(250), 'learner comment', 'learner comment}', '{lang=i-xx}', '{lang=i}', ''], + invalidDescription: ['{lang=i-}', '{lang=i-x}', '{lang=eng-98-9fhgj}{ learner comment', '{learner comment', '{lang=eng-98-9fhgj}' + 'x'.repeat(251), '{lang=eng-98-9fhgj}{' + 'x'.repeat(249)], + validNavRequest: ['previous', 'continue', 'exit', 'exitAll', 'abandon', 'abandonAll', 'suspendAll'], + invalidNavRequest: ['close', 'quit', 'next', 'before'], + }); + + exports.scorm2004_values = scorm2004_values; +}, {}], 12: [function(require, module, exports) { + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true, + }); + exports.valid_languages = void 0; + const valid_languages = { + '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', + }; + exports.valid_languages = valid_languages; +}, {}], 13: [function(require, module, exports) { + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true, + }); + exports.scorm2004_regex = exports.aicc_regex = exports.scorm12_regex = void 0; + + const _field_values = require('./field_values'); + + function ownKeys(object, enumerableOnly) { + const keys = Object.keys(object); if (Object.getOwnPropertySymbols) { + let 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 (let i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { + ownKeys(source, true).forEach(function(key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(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; + } + + const scorm12_regex = { + 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]{0,255}$', + CMIFeedback: '^.{0,255}$', + // This must be redefined + CMIIndex: '[._](\\d+).', + // Vocabulary Data Type Definition + CMIStatus: '^(' + _field_values.scorm12_values.validLessonStatus.join('|') + ')$', + CMIStatus2: '^(' + _field_values.scorm12_values.validLessonStatus.join('|') + '|not attempted)$', + CMIExit: '^(' + _field_values.scorm12_values.validExit.join('|') + '|)$', + CMIType: '^(' + _field_values.scorm12_values.validType.join('|') + ')$', + CMIResult: '^(' + _field_values.scorm12_values.validResult.join('|') + '|([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', + }; + exports.scorm12_regex = scorm12_regex; + + const aicc_regex = _objectSpread({}, scorm12_regex, {}, { + CMIIdentifier: '^\\w{1,255}$', + }); + + exports.aicc_regex = aicc_regex; + const scorm2004_regex = { + 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})$', + CMIFeedback: '^.*$', + // This must be redefined + CMIIndex: '[._](\\d+).', + CMIIndexStore: '.N(\\d+).', + // Vocabulary Data Type Definition + CMICStatus: '^(' + _field_values.scorm2004_values.validCStatus.join('|') + ')$', + CMISStatus: '^(' + _field_values.scorm2004_values.validSStatus.join('|') + ')$', + CMIExit: '^(' + _field_values.scorm2004_values.validExit.join('|') + ')$', + CMIType: '^(' + _field_values.scorm2004_values.validType.join('|') + ')$', + CMIResult: '^(' + _field_values.scorm2004_values.validResult.join('|') + '|-?([0-9]{1,4})(\\.[0-9]{1,18})?)$', + NAVEvent: '^(' + _field_values.scorm2004_values.validNavRequest.join('|') + '|\{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', + }; + exports.scorm2004_regex = scorm2004_regex; +}, {'./field_values': 11}], 14: [function(require, module, exports) { + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true, + }); + exports.correct_responses = exports.learner_responses = void 0; + + const _regex = require('./regex'); + + const learner_responses = { + 'true-false': { + format: '^true$|^false$', + max: 1, + delimiter: '', + unique: false, + }, + 'choice': { + format: _regex.scorm2004_regex.CMIShortIdentifier, + max: 36, + delimiter: '[,]', + unique: true, + }, + 'fill-in': { + format: _regex.scorm2004_regex.CMILangString250, + max: 10, + delimiter: '[,]', + unique: false, + }, + 'long-fill-in': { + format: _regex.scorm2004_regex.CMILangString4000, + max: 1, + delimiter: '', + unique: false, + }, + 'matching': { + format: _regex.scorm2004_regex.CMIShortIdentifier, + format2: _regex.scorm2004_regex.CMIShortIdentifier, + max: 36, + delimiter: '[,]', + delimiter2: '[.]', + unique: false, + }, + 'performance': { + format: '^$|' + _regex.scorm2004_regex.CMIShortIdentifier, + format2: _regex.scorm2004_regex.CMIDecimal + '|^$|' + _regex.scorm2004_regex.CMIShortIdentifier, + max: 250, + delimiter: '[,]', + delimiter2: '[.]', + unique: false, + }, + 'sequencing': { + format: _regex.scorm2004_regex.CMIShortIdentifier, + max: 36, + delimiter: '[,]', + unique: false, + }, + 'likert': { + format: _regex.scorm2004_regex.CMIShortIdentifier, + max: 1, + delimiter: '', + unique: false, + }, + 'numeric': { + format: _regex.scorm2004_regex.CMIDecimal, + max: 1, + delimiter: '', + unique: false, + }, + 'other': { + format: _regex.scorm2004_regex.CMIString4000, + max: 1, + delimiter: '', + unique: false, + }, + }; + exports.learner_responses = learner_responses; + const correct_responses = { + 'true-false': { + max: 1, + delimiter: '', + unique: false, + duplicate: false, + format: '^true$|^false$', + limit: 1, + }, + 'choice': { + max: 36, + delimiter: '[,]', + unique: true, + duplicate: false, + format: _regex.scorm2004_regex.CMIShortIdentifier, + }, + 'fill-in': { + max: 10, + delimiter: '[,]', + unique: false, + duplicate: false, + format: _regex.scorm2004_regex.CMILangString250cr, + }, + 'long-fill-in': { + max: 1, + delimiter: '', + unique: false, + duplicate: true, + format: _regex.scorm2004_regex.CMILangString4000, + }, + 'matching': { + max: 36, + delimiter: '[,]', + delimiter2: '[.]', + unique: false, + duplicate: false, + format: _regex.scorm2004_regex.CMIShortIdentifier, + format2: _regex.scorm2004_regex.CMIShortIdentifier, + }, + 'performance': { + max: 250, + delimiter: '[,]', + delimiter2: '[.]', + unique: false, + duplicate: false, + format: '^$|' + _regex.scorm2004_regex.CMIShortIdentifier, + format2: _regex.scorm2004_regex.CMIDecimal + '|^$|' + _regex.scorm2004_regex.CMIShortIdentifier, + }, + 'sequencing': { + max: 36, + delimiter: '[,]', + unique: false, + duplicate: false, + format: _regex.scorm2004_regex.CMIShortIdentifier, + }, + 'likert': { + max: 1, + delimiter: '', + unique: false, + duplicate: false, + format: _regex.scorm2004_regex.CMIShortIdentifier, + limit: 1, + }, + 'numeric': { + max: 2, + delimiter: '[:]', + unique: false, + duplicate: false, + format: _regex.scorm2004_regex.CMIDecimal, + limit: 1, + }, + 'other': { + max: 1, + delimiter: '', + unique: false, + duplicate: false, + format: _regex.scorm2004_regex.CMIString4000, + limit: 1, + }, + }; + exports.correct_responses = correct_responses; +}, {'./regex': 13}], 15: [function(require, module, exports) { + 'use strict'; + + Object.defineProperty(exports, '__esModule', { + value: true, + }); + exports.ValidationError = void 0; + + function _typeof(obj) { + 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 _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError('Cannot call a class as a function'); + } + } + + function _defineProperties(target, props) { + for (let i = 0; i < props.length; i++) { + const 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 _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 _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 _wrapNativeSuper(Class) { + const _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 isNativeReflectConstruct() { + if (typeof Reflect === 'undefined' || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === 'function') return true; try { + Date.prototype.toString.call(Reflect.construct(Date, [], function() {})); return true; + } catch (e) { + return false; + } + } + + function _construct(Parent, args, Class) { + if (isNativeReflectConstruct()) { + _construct = Reflect.construct; + } else { + _construct = function _construct(Parent, args, Class) { + const a = [null]; a.push.apply(a, args); const Constructor = Function.bind.apply(Parent, a); const instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; + }; + } return _construct.apply(null, arguments); + } + + 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) { + const descriptor = privateMap.get(receiver); if (!descriptor) { + throw new TypeError('attempted to get private field on non-instance'); + } if (descriptor.get) { + return descriptor.get.call(receiver); + } return descriptor.value; + } + + function _classPrivateFieldSet(receiver, privateMap, value) { + const descriptor = privateMap.get(receiver); if (!descriptor) { + throw new TypeError('attempted to set private field on non-instance'); + } 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; + } return value; + } + + /** + * Data Validation Exception + */ + const ValidationError = +/* #__PURE__*/ +function(_Error) { + _inherits(ValidationError, _Error); + + /** + * Constructor to take in an error message and code + * @param {number} errorCode + */ + function ValidationError(errorCode) { + let _this; + + _classCallCheck(this, ValidationError); + + _this = _possibleConstructorReturn(this, _getPrototypeOf(ValidationError).call(this, errorCode)); + + _errorCode.set(_assertThisInitialized(_this), { + writable: true, + value: void 0, + }); + + _classPrivateFieldSet(_assertThisInitialized(_this), _errorCode, errorCode); + + return _this; + } + + _createClass(ValidationError, [{ + key: 'errorCode', + + /** + * Getter for #errorCode + * @return {number} + */ + get: function get() { + return _classPrivateFieldGet(this, _errorCode); + }, + /** + * Trying to override the default Error message + * @return {string} + */ + + }, { + key: 'message', + get: function get() { + return _classPrivateFieldGet(this, _errorCode) + ''; + }, + }]); + + return ValidationError; +}(_wrapNativeSuper(Error)); + + exports.ValidationError = ValidationError; + + var _errorCode = new WeakMap(); +}, {}], 16: [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.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) || _nonIterableRest(); + } + + function _nonIterableRest() { + throw new TypeError('Invalid attempt to destructure non-iterable instance'); + } + + function _iterableToArrayLimit(arr, i) { + if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === '[object Arguments]')) { + return; + } const _arr = []; let _n = true; let _d = false; let _e = undefined; try { + for (var _i = arr[Symbol.iterator](), _s; !(_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; + } + + const SECONDS_PER_SECOND = 1.0; + exports.SECONDS_PER_SECOND = SECONDS_PER_SECOND; + const SECONDS_PER_MINUTE = 60; + exports.SECONDS_PER_MINUTE = SECONDS_PER_MINUTE; + const SECONDS_PER_HOUR = 60 * SECONDS_PER_MINUTE; + exports.SECONDS_PER_HOUR = SECONDS_PER_HOUR; + const SECONDS_PER_DAY = 24 * SECONDS_PER_HOUR; + exports.SECONDS_PER_DAY = SECONDS_PER_DAY; + const 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'; + } + + const hours = Math.floor(totalSeconds / SECONDS_PER_HOUR); + const dateObj = new Date(totalSeconds * 1000); + const minutes = dateObj.getUTCMinutes(); // make sure we add any possible decimal value + + const seconds = dateObj.getSeconds() + totalSeconds % 1.0; + return hours.toString().padStart(2, '0') + ':' + minutes.toString().padStart(2, '0') + ':' + seconds.toString().padStart(2, '0'); + } + /** + * 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 'P0S'; + } + + let duration = 'P'; + let remainder = seconds; + designations.forEach(function(_ref) { + const _ref2 = _slicedToArray(_ref, 2); + const sign = _ref2[0]; + const current_seconds = _ref2[1]; + + let value = Math.floor(remainder / current_seconds); + remainder = remainder % current_seconds; // 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) { + 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; + } + + const parts = timeString.split(':'); + const hours = Number(parts[0]); + const minutes = Number(parts[1]); + const 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; + } + + const _ref3 = new RegExp(durationRegex).exec(duration) || []; + const _ref4 = _slicedToArray(_ref3, 8); + const years = _ref4[1]; + const months = _ref4[2]; + const days = _ref4[4]; + const hours = _ref4[5]; + const minutes = _ref4[6]; + const seconds = _ref4[7]; + + const now = new Date(); + const anchor = new Date(now); + anchor.setFullYear(anchor.getFullYear() + Number(years || 0)); + anchor.setMonth(anchor.getMonth() + Number(months || 0)); + anchor.setDate(anchor.getDate() + Number(days || 0)); + anchor.setHours(anchor.getHours() + Number(hours || 0)); + anchor.setMinutes(anchor.getMinutes() + Number(minutes || 0)); + anchor.setSeconds(anchor.getSeconds() + Number(seconds || 0)); + + if (seconds && String(seconds).indexOf('.') > 0) { + const milliseconds = Number(Number(seconds) % 1).toFixed(6) * 1000.0; + anchor.setMilliseconds(anchor.getMilliseconds() + milliseconds); + } + + return (anchor * 1.0 - now) / 1000.0; + } + /** + * Adds together two ISO8601 Duration strings + * + * @param {string} first + * @param {string} second + * @param {RegExp} durationRegex + * @return {string} + */ + + + function addTwoDurations(first, second, durationRegex) { + const firstSeconds = getDurationAsSeconds(first, durationRegex); + const secondSeconds = getDurationAsSeconds(second, durationRegex); + return getSecondsAsISODuration(firstSeconds + secondSeconds); + } + /** + * Add together two HH:MM:SS.DD strings + * + * @param {string} first + * @param {string} second + * @param {RegExp} timeRegex + * @return {string} + */ + + + function addHHMMSSTimeStrings(first, second, timeRegex) { + const firstSeconds = getTimeAsSeconds(first, timeRegex); + const secondSeconds = getTimeAsSeconds(second, timeRegex); + return getSecondsAsHHMMSS(firstSeconds + secondSeconds); + } +}, {}]}, {}, [1, 2, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 3, 4, 16]); +// # sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.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/field_values.js","src/constants/language_constants.js","src/constants/regex.js","src/constants/response_constants.js","src/exceptions.js","src/utilities.js"],"names":[],"mappings":"AAAA;;;;;;;;ACCA;;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;AAOA;;;IAGqB,I;;;;;AACnB;;;AAGA,kBAAc;AAAA;;AAAA;;AACZ;AAEA,UAAK,GAAL,GAAW,IAAI,aAAJ,+BAAX;AACA,UAAK,GAAL,GAAW,IAAI,aAAJ,+BAAX;AAJY;AAKb;AAED;;;;;;;;;;;oCAOgB,U,EAAY,K,EAAO;AACjC,UAAI,QAAQ,6EAAyB,UAAzB,CAAZ;;AAEA,UAAI,CAAC,QAAL,EAAe;AACb,YAAI,KAAK,cAAL,CAAoB,UAApB,EAAgC,yBAAhC,CAAJ,EAAgE;AAC9D,UAAA,QAAQ,GAAG,IAAI,qCAAJ,CAAgC,IAAhC,CAAX;AACD,SAFD,MAEO,IAAI,KAAK,cAAL,CAAoB,UAApB,EAAgC,wBAAhC,CAAJ,EAA+D;AACpE,UAAA,QAAQ,GAAG,IAAI,wBAAJ,CAAmB,IAAnB,CAAX;AACD;AACF;;AAED,aAAO,QAAP;AACD;AAED;;;;;;;;+CAK2B,M,EAAQ;AACjC;AACA,WAAK,GAAL,GAAW,MAAM,CAAC,GAAlB;AACA,WAAK,GAAL,GAAW,MAAM,CAAC,GAAlB;AACD;;;;EAzC+B,uB;;;;;;;;;;;;ACXlC;;;;;;;;;;;;;;AAEA,IAAM,aAAa,GAAG;AACpB,EAAA,UAAU,EAAE,MADQ;AAEpB,EAAA,WAAW,EAAE,OAFO;AAGpB,EAAA,qBAAqB,EAAE,CAHH;AAIpB,EAAA,iBAAiB,EAAE,CAJC;AAKpB,EAAA,gBAAgB,EAAE,CALE;AAMpB,EAAA,eAAe,EAAE,CANG;AAOpB,EAAA,cAAc,EAAE,CAPI;AAQpB,EAAA,iBAAiB,EAAE,CARC;AASpB,EAAA,eAAe,EAAE,CATG;AAUpB,EAAA,cAAc,EAAE;AAVI,CAAtB;AAaA;;;;;IAIqB,O;;;AAKnB;;;;;AAKA,mBAAY,WAAZ,EAAyB;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;;AACvB,SAAK,YAAL,GAAoB,aAAa,CAAC,qBAAlC;AACA,SAAK,WAAL,GAAmB,aAAa,CAAC,eAAjC;AACA,SAAK,aAAL,GAAqB,CAArB;AACA,SAAK,aAAL,GAAqB,EAArB;;AAEA,0CAAgB,IAAhB;;AACA,8CAAoB,WAApB;AACD;AAED;;;;;;;;;;;+BAQI,Y,EACA,iB,EACA,kB,EAA6B;AAC/B,UAAI,WAAW,GAAG,aAAa,CAAC,WAAhC;;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,aAAK,YAAL,GAAoB,aAAa,CAAC,iBAAlC;AACA,aAAK,aAAL,GAAqB,CAArB;AACA,QAAA,WAAW,GAAG,aAAa,CAAC,UAA5B;AACA,aAAK,gBAAL,CAAsB,YAAtB;AACD;;AAED,WAAK,MAAL,CAAY,YAAZ,EAA0B,IAA1B,EAAgC,eAAe,WAA/C,EACI,aAAa,CAAC,cADlB;AAEA,WAAK,eAAL,CAAqB,WAArB;AAEA,aAAO,WAAP;AACD;AAED;;;;;;;;;8BAOI,Y,EACA,e,EAA0B;AAC5B,UAAI,WAAW,GAAG,aAAa,CAAC,WAAhC;;AAEA,UAAI,KAAK,UAAL,CAAgB,eAAhB,EACA,0CAAkB,uBADlB,EAEA,0CAAkB,oBAFlB,CAAJ,EAE6C;AAC3C,YAAI,eAAJ,EAAqB,KAAK,aAAL,GAAqB,CAArB;AACrB,aAAK,YAAL,GAAoB,aAAa,CAAC,gBAAlC;AACA,QAAA,WAAW,GAAG,aAAa,CAAC,UAA5B;AACA,aAAK,gBAAL,CAAsB,YAAtB;AACD;;AAED,WAAK,MAAL,CAAY,YAAZ,EAA0B,IAA1B,EAAgC,eAAe,WAA/C,EACI,aAAa,CAAC,cADlB;AAEA,WAAK,eAAL,CAAqB,WAArB;AAEA,aAAO,WAAP;AACD;AAED;;;;;;;;;;;6BASI,Y,EACA,e,EACA,U,EAAoB;AACtB,UAAI,WAAW,GAAG,EAAlB;;AAEA,UAAI,KAAK,UAAL,CAAgB,eAAhB,EACA,0CAAkB,oBADlB,EAEA,0CAAkB,mBAFlB,CAAJ,EAE4C;AAC1C,YAAI,eAAJ,EAAqB,KAAK,aAAL,GAAqB,CAArB;AACrB,QAAA,WAAW,GAAG,KAAK,WAAL,CAAiB,UAAjB,CAAd;AACA,aAAK,gBAAL,CAAsB,YAAtB,EAAoC,UAApC;AACD;;AAED,WAAK,MAAL,CAAY,YAAZ,EAA0B,UAA1B,EAAsC,iBAAiB,WAAvD,EACI,aAAa,CAAC,cADlB;AAEA,WAAK,eAAL,CAAqB,WAArB;AAEA,aAAO,WAAP;AACD;AAED;;;;;;;;;;;;6BAUI,Y,EACA,e,EACA,U,EACA,K,EAAO;AACT,UAAI,WAAW,GAAG,EAAlB;;AAEA,UAAI,KAAK,UAAL,CAAgB,eAAhB,EAAiC,0CAAkB,iBAAnD,EACA,0CAAkB,gBADlB,CAAJ,EACyC;AACvC,YAAI,eAAJ,EAAqB,KAAK,aAAL,GAAqB,CAArB;AACrB,QAAA,WAAW,GAAG,KAAK,WAAL,CAAiB,UAAjB,EAA6B,KAA7B,CAAd;AACA,aAAK,gBAAL,CAAsB,YAAtB,EAAoC,UAApC,EAAgD,KAAhD;AACD;;AAED,WAAK,MAAL,CAAY,YAAZ,EAA0B,UAA1B,EACI,OAAO,KAAP,GAAe,YAAf,GAA8B,WADlC,EAEI,aAAa,CAAC,cAFlB;AAGA,WAAK,eAAL,CAAqB,WAArB;AAEA,aAAO,WAAP;AACD;AAED;;;;;;;;;2BAOI,Y,EACA,e,EAA0B;AAC5B,UAAI,WAAW,GAAG,aAAa,CAAC,WAAhC;;AAEA,UAAI,KAAK,UAAL,CAAgB,eAAhB,EAAiC,0CAAkB,kBAAnD,EACA,0CAAkB,iBADlB,CAAJ,EAC0C;AACxC,YAAI,eAAJ,EAAqB,KAAK,aAAL,GAAqB,CAArB;AACrB,QAAA,WAAW,GAAG,aAAa,CAAC,UAA5B;AACA,aAAK,gBAAL,CAAsB,YAAtB;AACD;;AAED,WAAK,MAAL,CAAY,YAAZ,EAA0B,IAA1B,EAAgC,eAAe,WAA/C,EACI,aAAa,CAAC,cADlB;AAEA,WAAK,eAAL,CAAqB,WAArB;AAEA,aAAO,WAAP;AACD;AAED;;;;;;;;iCAKa,Y,EAAsB;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,aAAa,CAAC,cADlB;AAGA,aAAO,WAAP;AACD;AAED;;;;;;;;;;mCAOe,Y,EAAsB,Y,EAAc;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,aAAa,CAAC,cADlB;AAGA,aAAO,WAAP;AACD;AAED;;;;;;;;;;kCAOc,Y,EAAsB,Y,EAAc;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,aAAa,CAAC,cADlB;AAGA,aAAO,WAAP;AACD;AAED;;;;;;;;;;;+BASI,e,EACA,e,EACA,c,EAAyB;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;;;;;;;;;;;2BASI,Y,EACA,U,EACA,U,EACA,Y,EAAsB;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,aAAa,CAAC,eAAnB;AACE,YAAA,OAAO,CAAC,KAAR,CAAc,UAAd;AACA;;AACF,eAAK,aAAa,CAAC,iBAAnB;AACE,YAAA,OAAO,CAAC,IAAR,CAAa,UAAb;AACA;;AACF,eAAK,aAAa,CAAC,cAAnB;AACE,YAAA,OAAO,CAAC,IAAR,CAAa,UAAb;AACA;AATJ;AAWD;AACF;AAED;;;;;;;;;;;kCAQc,Y,EAAsB,U,EAAoB,O,EAAiB;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;;;;;;;;;;mCAOe,G,EAAa,M,EAAgB;AAC1C,aAAO,GAAG,CAAC,OAAJ,CAAY,MAAZ,IAAsB,CAAC,CAA9B;AACD;AAED;;;;;;;;;;;8CAQ0B,Y,EAAc,O,EAAS;AAC/C,aAAO,UAAP;AACD;AAED;;;;;;;;;;gCAOY,W,EAAa;AACvB,aAAO,EAAP;AACD;AAED;;;;;;;;;;gCAOY,W,EAAa,M,EAAQ,CAEhC,C,CADC;;AAGF;;;;;;;;;;;;uCAUI,U,EAAoB,S,EAAoB,U,EAAY,K,EAAO;AAC7D,UAAI,CAAC,UAAD,IAAe,UAAU,KAAK,EAAlC,EAAsC;AACpC,eAAO,aAAa,CAAC,WAArB;AACD;;AAED,UAAM,SAAS,GAAG,UAAU,CAAC,KAAX,CAAiB,GAAjB,CAAlB;AACA,UAAI,SAAS,GAAG,IAAhB;AACA,UAAI,WAAW,GAAG,aAAa,CAAC,WAAhC;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,GAAG,cAAH,CAAkB,IAAlB,CAAuB,SAAvB,EAAkC,SAAlC,CAAL,EAAmD;AACxD,iBAAK,eAAL,CAAqB,gBAArB,EAAuC,mBAAvC;AACD,WAFM,MAEA;AACL,gBAAI,KAAK,cAAL,CAAoB,UAApB,EAAgC,oBAAhC,CAAJ,EAA2D;AACzD,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,aAAa,CAAC,UAA5B;AACD;AACF;AACF,SAhBD,MAgBO;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;AACD,eAFD,MAEO;AACL,oBAAM,QAAQ,GAAG,KAAK,eAAL,CAAqB,UAArB,EAAiC,KAAjC,CAAjB;;AAEA,oBAAI,CAAC,QAAL,EAAe;AACb,uBAAK,eAAL,CAAqB,gBAArB,EAAuC,mBAAvC;AACD,iBAFD,MAEO;AACL,kBAAA,SAAS,CAAC,UAAV,CAAqB,IAArB,CAA0B,QAA1B;AACA,kBAAA,SAAS,GAAG,QAAZ;AACD;AACF,eAdgB,CAgBjB;;;AACA,cAAA,CAAC;AACF;AACF;AACF;AACF;;AAED,UAAI,WAAW,KAAK,aAAa,CAAC,WAAlC,EAA+C;AAC7C,aAAK,MAAL,CAAY,UAAZ,EAAwB,IAAxB,sDACiD,UADjD,yBAC0E,KAD1E,GAEI,aAAa,CAAC,iBAFlB;AAGD;;AAED,aAAO,WAAP;AACD;AAED;;;;;;;;;4CAMwB,W,EAAa,M,EAAQ,CAE5C,C,CADC;;AAGF;;;;;;;;;;;oCAQgB,W,EAAa,M,EAAQ;AACnC,aAAO,IAAP;AACD;AAED;;;;;;;;;;;uCAQmB,U,EAAoB,S,EAAoB,U,EAAY;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,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,GAAG,cAAH,CAAkB,IAAlB,CAAuB,SAAvB,EAAkC,SAAlC,CAAL,EAAmD;AACjD,mBAAK,eAAL,CAAqB,GAArB,EACI,2CAA2C,UAD/C;AAED;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,GAAG,cAAH,CAAkB,IAAlB,CAAuB,SAAvB,EAAkC,SAAlC,CAAL,EAAmD;AACxD,iBAAK,eAAL,CAAqB,GAArB,EACI,gDAAgD,UAAhD,GACA,4CAFJ;AAGA,mBAAO,EAAP;AACD;AACF;;AAED,QAAA,SAAS,GAAG,SAAS,CAAC,SAAD,CAArB;AACD;;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,GAArB;AACD,WAFD,MAEO,IAAI,SAAS,KAAK,QAAlB,EAA4B;AACjC,iBAAK,eAAL,CAAqB,GAArB;AACD;AACF;;AACD,eAAO,EAAP;AACD,OATD,MASO;AACL,eAAO,SAAP;AACD;AACF;AAED;;;;;;;;oCAKgB;AACd,aAAO,KAAK,YAAL,KAAsB,aAAa,CAAC,iBAA3C;AACD;AAED;;;;;;;;uCAKmB;AACjB,aAAO,KAAK,YAAL,KAAsB,aAAa,CAAC,qBAA3C;AACD;AAED;;;;;;;;mCAKe;AACb,aAAO,KAAK,YAAL,KAAsB,aAAa,CAAC,gBAA3C;AACD;AAED;;;;;;;;;uBAMG,Y,EAAsB,Q,EAAoB;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;AAKD;AACF;AAED;;;;;;;;;;qCAOiB,Y,EAAsB,U,EAAoB,K,EAAY;AACrE,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,YAAM,gBAAgB,GAAG,QAAQ,CAAC,UAAT,KAAwB,UAAjD;;AAEA,YAAI,cAAc,KAAK,CAAC,qBAAD,IAA0B,gBAA/B,CAAlB,EAAoE;AAClE,UAAA,QAAQ,CAAC,QAAT,CAAkB,UAAlB,EAA8B,KAA9B;AACD;AACF;AACF;AAED;;;;;;;;;oCAMgB,W,EAAqB,O,EAAiB;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,aAAa,CAAC,eADlB;AAGA,WAAK,aAAL,GAAqB,MAAM,CAAC,WAAD,CAA3B;AACD;AAED;;;;;;;;oCAKgB,O,EAAiB;AAC/B,UAAI,OAAO,KAAK,aAAa,CAAC,WAA9B,EAA2C;AACzC,aAAK,aAAL,GAAqB,CAArB;AACD;AACF;AAED;;;;;;;;;iCAMa,I,EAAM,U,EAAY;AAC7B,UAAI,CAAC,KAAK,gBAAL,EAAL,EAA8B;AAC5B,QAAA,OAAO,CAAC,KAAR,CACI,mEADJ;AAEA;AACD;;AAED,MAAA,UAAU,GAAG,UAAU,IAAI,KAA3B;;AAEA,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,UAAU,GAAG,GAAb,GAAmB,GAA7C;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;;;;;;;;sCAKkB;AAChB,UAAM,GAAG,GAAG,KAAK,GAAjB,CADgB,CAEhB;AACA;;AACA,aAAO,IAAI,CAAC,SAAL,CAAe;AAAC,QAAA,GAAG,EAAH;AAAD,OAAf,CAAP;AACD;AAED;;;;;;;;mCAKe,I,EAAc;AAC3B,4CAAgB,IAAI,eAAJ,CAAoB,IAApB,EAA0B,IAA1B,CAAhB;AACD;AAED;;;;;;2CAGuB;AACrB,gCAAI,IAAJ,aAAmB;AACjB,8CAAc,MAAd;;AACA,8CAAgB,IAAhB;AACD;AACF;;;;;AAGH;;;;;;;;;;;IAGM,e;;;AAKJ;;;;;AAKA,2BAAY,GAAZ,EAAsB,IAAtB,EAAoC;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAClC,sCAAY,GAAZ;;AACA,2CAAgB,UAAU,CAAC,KAAK,OAAN,EAAe,IAAf,CAA1B;AACD;AAED;;;;;;;6BAGS;AACP,8CAAkB,IAAlB;;AACA,gCAAI,IAAJ,cAAmB;AACjB,QAAA,YAAY,uBAAC,IAAD,aAAZ;AACD;AACF;AAED;;;;;;8BAGU;AACR,UAAI,uBAAC,IAAD,aAAJ,EAAsB;AACpB,0CAAU,MAAV;AACD;AACF;;;;;;;;;;;;;;;;;;;;AC9uBH;;AACA;;AAOA;;AACA;;AACA;;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,IAAM,SAAS,GAAG,gCAAlB;AAEA;;;;IAGqB,U;;;;;AACnB;;;AAGA,wBAAc;AAAA;;AAAA;;AACZ,oFAAM,gCAAN;AAEA,UAAK,GAAL,GAAW,IAAI,gBAAJ,+BAAX,CAHY,CAIZ;;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;AAZY;AAab;AAED;;;;;;;;;oCAKgB;AACd,aAAO,KAAK,UAAL,CAAgB,eAAhB,EAAiC,8BAAjC,EACH,0BADG,CAAP;AAED;AAED;;;;;;;;gCAKY;AACV,aAAO,KAAK,SAAL,CAAe,WAAf,EAA4B,KAA5B,CAAP;AACD;AAED;;;;;;;;;gCAMY,U,EAAY;AACtB,aAAO,KAAK,QAAL,CAAc,aAAd,EAA6B,KAA7B,EAAoC,UAApC,CAAP;AACD;AAED;;;;;;;;;;gCAOY,U,EAAY,K,EAAO;AAC7B,aAAO,KAAK,QAAL,CAAc,aAAd,EAA6B,KAA7B,EAAoC,UAApC,EAAgD,KAAhD,CAAP;AACD;AAED;;;;;;;;gCAKY;AACV,aAAO,KAAK,MAAL,CAAY,WAAZ,EAAyB,KAAzB,CAAP;AACD;AAED;;;;;;;;sCAKkB;AAChB,aAAO,KAAK,YAAL,CAAkB,iBAAlB,CAAP;AACD;AAED;;;;;;;;;sCAMkB,Y,EAAc;AAC9B,aAAO,KAAK,cAAL,CAAoB,mBAApB,EAAyC,YAAzC,CAAP;AACD;AAED;;;;;;;;;qCAMiB,Y,EAAc;AAC7B,aAAO,KAAK,aAAL,CAAmB,kBAAnB,EAAuC,YAAvC,CAAP;AACD;AAED;;;;;;;;;gCAMY,U,EAAY,K,EAAO;AAC7B,WAAK,kBAAL,CAAwB,aAAxB,EAAuC,KAAvC,EAA8C,UAA9C,EAA0D,KAA1D;AACD;AAED;;;;;;;;;gCAMY,U,EAAY;AACtB,aAAO,KAAK,kBAAL,CAAwB,aAAxB,EAAuC,KAAvC,EAA8C,UAA9C,CAAP;AACD;AAED;;;;;;;;;;oCAOgB,U,EAAY,K,EAAO;AACjC,UAAI,QAAJ;;AAEA,UAAI,KAAK,cAAL,CAAoB,UAApB,EAAgC,gBAAhC,CAAJ,EAAuD;AACrD,QAAA,QAAQ,GAAG,IAAI,gCAAJ,CAAwB,IAAxB,CAAX;AACD,OAFD,MAEO,IAAI,KAAK,cAAL,CAAoB,UAApB,EAAgC,oBAAhC,CAAJ,EAA2D;AAChE,QAAA,QAAQ,GAAG,IAAI,kDAAJ,CAA0C,IAA1C,CAAX;AACD,OAFM,MAEA,IAAI,KAAK,cAAL,CAAoB,UAApB,EAAgC,aAAhC,CAAJ,EAAoD;AACzD,QAAA,QAAQ,GAAG,IAAI,4CAAJ,CAAoC,IAApC,CAAX;AACD,OAFM,MAEA,IAAI,KAAK,cAAL,CAAoB,UAApB,EAAgC,kBAAhC,CAAJ,EAAyD;AAC9D,QAAA,QAAQ,GAAG,IAAI,kCAAJ,CAA0B,IAA1B,CAAX;AACD;;AAED,aAAO,QAAP;AACD;AAED;;;;;;;;;;4CAOwB,U,EAAY,K,EAAO;AACzC,aAAO,IAAP;AACD;AAED;;;;;;;;;;8CAO0B,W,EAAa,M,EAAQ;AAC7C,UAAI,YAAY,GAAG,UAAnB;AACA,UAAI,aAAa,GAAG,UAApB,CAF6C,CAI7C;;AACA,MAAA,WAAW,GAAG,MAAM,CAAC,WAAD,CAApB;;AACA,UAAI,SAAS,CAAC,kBAAV,CAA6B,WAA7B,CAAJ,EAA+C;AAC7C,QAAA,YAAY,GAAG,SAAS,CAAC,kBAAV,CAA6B,WAA7B,EAA0C,YAAzD;AACA,QAAA,aAAa,GAAG,SAAS,CAAC,kBAAV,CAA6B,WAA7B,EAA0C,aAA1D;AACD;;AAED,aAAO,MAAM,GAAG,aAAH,GAAmB,YAAhC;AACD;AAED;;;;;;;;0CAKsB;AACpB,UAAM,SAAS,GAAG,IAAI,MAAJ,CAAW,qBAAc,OAAzB,CAAlB;AAEA,UAAM,SAAS,GAAG,KAAK,GAAL,CAAS,IAAT,CAAc,UAAhC;AACA,UAAM,WAAW,GAAG,KAAK,GAAL,CAAS,IAAT,CAAc,YAAlC;AAEA,aAAO,SAAS,CAAC,oBAAV,CAA+B,SAA/B,EAA0C,WAA1C,EAAuD,SAAvD,CAAP;AACD;AAED;;;;;;;;+CAK2B,M,EAAQ;AACjC;AACA,WAAK,GAAL,GAAW,MAAM,CAAC,GAAlB;AACD;;;;EAlMqC,oB;;;;;;;;;;;;AClBxC;;AACA;;AAUA;;AACA;;AACA;;AACA;;AACA;;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,IAAM,SAAS,GAAG,kCAAlB;AAEA;;;;IAGqB,Y;;;;;AAGnB;;;AAGA,0BAAc;AAAA;;AAAA;;AACZ,sFAAM,kCAAN;;AADY;AAAA;AAAA;AAAA;;AAAA,6EAqQW,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,KA9Qa;;AAGZ,UAAK,GAAL,GAAW,IAAI,kBAAJ,+BAAX;AACA,UAAK,GAAL,GAAW,IAAI,kBAAJ,+BAAX,CAJY,CAMZ;;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;AAdY;AAeb;AAED;;;;;;;;;AAQA;;;oCAGgB;AACd,aAAO,KAAK,UAAL,CAAgB,YAAhB,CAAP;AACD;AAED;;;;;;mCAGe;AACb,aAAO,KAAK,SAAL,CAAe,WAAf,EAA4B,IAA5B,CAAP;AACD;AAED;;;;;;;gCAIY,U,EAAY;AACtB,aAAO,KAAK,QAAL,CAAc,UAAd,EAA0B,IAA1B,EAAgC,UAAhC,CAAP;AACD;AAED;;;;;;;;gCAKY,U,EAAY,K,EAAO;AAC7B,aAAO,KAAK,QAAL,CAAc,UAAd,EAA0B,IAA1B,EAAgC,UAAhC,EAA4C,KAA5C,CAAP;AACD;AAED;;;;;;;;gCAKY;AACV,aAAO,KAAK,MAAL,CAAY,QAAZ,CAAP;AACD;AAED;;;;;;;;sCAKkB;AAChB,aAAO,KAAK,YAAL,CAAkB,cAAlB,CAAP;AACD;AAED;;;;;;;;;sCAMkB,Y,EAAc;AAC9B,aAAO,KAAK,cAAL,CAAoB,gBAApB,EAAsC,YAAtC,CAAP;AACD;AAED;;;;;;;;;qCAMiB,Y,EAAc;AAC7B,aAAO,KAAK,aAAL,CAAmB,eAAnB,EAAoC,YAApC,CAAP;AACD;AAED;;;;;;;;;gCAMY,U,EAAY,K,EAAO;AAC7B,WAAK,kBAAL,CAAwB,UAAxB,EAAoC,IAApC,EAA0C,UAA1C,EAAsD,KAAtD;AACD;AAED;;;;;;;;;;oCAOgB,U,EAAY,K,EAAO;AACjC,UAAI,QAAJ;;AAEA,UAAI,KAAK,cAAL,CAAoB,UAApB,EAAgC,gBAAhC,CAAJ,EAAuD;AACrD,QAAA,QAAQ,GAAG,IAAI,kCAAJ,CAAwB,IAAxB,CAAX;AACD,OAFD,MAEO,IAAI,KAAK,cAAL,CAAoB,UAApB,EAAgC,oBAAhC,CAAJ,EAA2D;AAChE,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,OAAO,WAAW,CAAC,IAAnB,KAA4B,WAAhC,EAA6C;AAC3C,eAAK,eAAL,CAAqB,mCAAsB,0BAA3C;AACD,SAFD,MAEO;AACL,cAAM,gBAAgB,GAAG,WAAW,CAAC,IAArC;AACA,cAAM,iBAAiB,GAAG,WAAW,CAAC,iBAAZ,CAA8B,MAAxD;;AACA,cAAI,gBAAgB,KAAK,QAAzB,EAAmC;AACjC,iBAAK,IAAI,CAAC,GAAG,CAAb,EAAgB,CAAC,GAAG,iBAAJ,IAAyB,KAAK,aAAL,KACzC,CADA,EACG,CAAC,EADJ,EACQ;AACN,kBAAM,QAAQ,GAAG,WAAW,CAAC,iBAAZ,CAA8B,UAA9B,CAAyC,CAAzC,CAAjB;;AACA,kBAAI,QAAQ,CAAC,OAAT,KAAqB,KAAzB,EAAgC;AAC9B,qBAAK,eAAL,CAAqB,mCAAsB,mBAA3C;AACD;AACF;AACF;;AAED,cAAM,aAAa,GAAG,sCAAkB,gBAAlB,CAAtB;AACA,cAAI,KAAK,GAAG,EAAZ;;AACA,cAAI,aAAa,CAAC,SAAd,KAA4B,EAAhC,EAAoC;AAClC,YAAA,KAAK,GAAG,MAAM,CAAC,KAAD,CAAN,CAAc,KAAd,CAAoB,aAAa,CAAC,SAAlC,CAAR;AACD,WAFD,MAEO;AACL,YAAA,KAAK,CAAC,CAAD,CAAL,GAAW,KAAX;AACD;;AAED,cAAI,KAAK,CAAC,MAAN,GAAe,CAAf,IAAoB,KAAK,CAAC,MAAN,IAAgB,aAAa,CAAC,GAAtD,EAA2D;AACzD,iBAAK,yBAAL,CAA+B,gBAA/B,EAAiD,KAAjD,EAAwD,KAAxD;AACD,WAFD,MAEO,IAAI,KAAK,CAAC,MAAN,GAAe,aAAa,CAAC,GAAjC,EAAsC;AAC3C,iBAAK,eAAL,CAAqB,mCAAsB,mBAA3C,EACI,qCADJ;AAED;AACF;;AACD,YAAI,KAAK,aAAL,KAAuB,CAA3B,EAA8B;AAC5B,UAAA,QAAQ,GAAG,IAAI,oDAAJ,CAA0C,IAA1C,CAAX;AACD;AACF,OArCM,MAqCA,IAAI,KAAK,cAAL,CAAoB,UAApB,EAAgC,aAAhC,CAAJ,EAAoD;AACzD,QAAA,QAAQ,GAAG,IAAI,8CAAJ,CAAoC,IAApC,CAAX;AACD,OAFM,MAEA,IAAI,KAAK,cAAL,CAAoB,UAApB,EAAgC,kBAAhC,CAAJ,EAAyD;AAC9D,QAAA,QAAQ,GAAG,IAAI,oCAAJ,CAA0B,IAA1B,CAAX;AACD,OAFM,MAEA,IAAI,KAAK,cAAL,CAAoB,UAApB,EAAgC,2BAAhC,CAAJ,EAAkE;AACvE,QAAA,QAAQ,GAAG,IAAI,2CAAJ,CAAiC,IAAjC,CAAX;AACD,OAFM,MAEA,IAAI,KAAK,cAAL,CAAoB,UAApB,EAAgC,uBAAhC,CAAJ,EAA8D;AACnE,QAAA,QAAQ,GAAG,IAAI,uCAAJ,CAA6B,IAA7B,CAAX;AACD;;AAED,aAAO,QAAP;AACD;AAED;;;;;;;;4CAKwB,U,EAAY,K,EAAO;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,gBAAgB,GAAG,WAAW,CAAC,IAArC;AACA,UAAM,iBAAiB,GAAG,WAAW,CAAC,iBAAZ,CAA8B,MAAxD;;AACA,UAAI,gBAAgB,KAAK,QAAzB,EAAmC;AACjC,aAAK,IAAI,CAAC,GAAG,CAAb,EAAgB,CAAC,GAAG,iBAAJ,IAAyB,KAAK,aAAL,KAAuB,CAAhE,EAAmE,CAAC,EAApE,EAAwE;AACtE,cAAM,QAAQ,GAAG,WAAW,CAAC,iBAAZ,CAA8B,UAA9B,CAAyC,CAAzC,CAAjB;;AACA,cAAI,QAAQ,CAAC,OAAT,KAAqB,KAAzB,EAAgC;AAC9B,iBAAK,eAAL,CAAqB,mCAAsB,mBAA3C;AACD;AACF;AACF;;AAED,UAAM,aAAa,GAAG,mCAAoB,iBAApB,CAAsC,gBAAtC,CAAtB;;AACA,UAAI,OAAO,aAAa,CAAC,KAArB,KAA+B,WAA/B,IAA8C,iBAAiB,GAC/D,aAAa,CAAC,KADlB,EACyB;AACvB,YAAI,KAAK,GAAG,EAAZ;;AACA,YAAI,aAAa,CAAC,SAAd,KAA4B,EAAhC,EAAoC;AAClC,UAAA,KAAK,GAAG,MAAM,CAAC,KAAD,CAAN,CAAc,KAAd,CAAoB,aAAa,CAAC,SAAlC,CAAR;AACD,SAFD,MAEO;AACL,UAAA,KAAK,CAAC,CAAD,CAAL,GAAW,KAAX;AACD;;AAED,YAAI,KAAK,CAAC,MAAN,GAAe,CAAf,IAAoB,KAAK,CAAC,MAAN,IAAgB,aAAa,CAAC,GAAtD,EAA2D;AACzD,eAAK,yBAAL,CAA+B,gBAA/B,EAAiD,KAAjD,EAAwD,KAAxD;AACD,SAFD,MAEO,IAAI,KAAK,CAAC,MAAN,GAAe,aAAa,CAAC,GAAjC,EAAsC;AAC3C,eAAK,eAAL,CAAqB,mCAAsB,mBAA3C,EACI,qCADJ;AAED;;AAED,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,mCAAsB,mBAA3C,EACI,2CADJ;AAED;AACF;AACF,OA5BD,MA4BO;AACL,aAAK,eAAL,CAAqB,mCAAsB,mBAA3C,EACI,6CADJ;AAED;AACF;AAED;;;;;;;;;gCAMY,U,EAAY;AACtB,aAAO,KAAK,kBAAL,CAAwB,UAAxB,EAAoC,IAApC,EAA0C,UAA1C,CAAP;AACD;AAED;;;;;;;;;;8CAO0B,W,EAAa,M,EAAQ;AAC7C,UAAI,YAAY,GAAG,EAAnB;AACA,UAAI,aAAa,GAAG,EAApB,CAF6C,CAI7C;;AACA,MAAA,WAAW,GAAG,MAAM,CAAC,WAAD,CAApB;;AACA,UAAI,SAAS,CAAC,kBAAV,CAA6B,WAA7B,CAAJ,EAA+C;AAC7C,QAAA,YAAY,GAAG,SAAS,CAAC,kBAAV,CAA6B,WAA7B,EAA0C,YAAzD;AACA,QAAA,aAAa,GAAG,SAAS,CAAC,kBAAV,CAA6B,WAA7B,EAA0C,aAA1D;AACD;;AAED,aAAO,MAAM,GAAG,aAAH,GAAmB,YAAhC;AACD;AAED;;;;;;;;;;;AAkBA;;;;;;8CAM0B,gB,EAAkB,K,EAAO,K,EAAO;AACxD,UAAM,QAAQ,GAAG,sCAAkB,gBAAlB,CAAjB;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,QAAQ,CAAC,UAAT,KAAwB,SAA5B,EAAuC;AACrC,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,mCAAsB,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,mCAAsB,aAA3C;AACD;AACF;AACF,WATD,MASO;AACL,iBAAK,eAAL,CAAqB,mCAAsB,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,mCAAsB,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,mCAAsB,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,mCAAsB,aAA3C;AACD;AACF;AACF;AACF;AACF;AACF;AACF;AACF;AAED;;;;;;;;kDAK8B,I,EAAM;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,uBAAgB,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,oCAAgB,IAAI,CAAC,WAAL,EAAhB,MAAwC,SAA5C,EAAuD;AACrD,uBAAK,eAAL,CAAqB,mCAAsB,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,mCAAsB,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,mCAAsB,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;;;;;;;+CAI2B,M,EAAQ;AACjC;AACA,WAAK,GAAL,GAAW,MAAM,CAAC,GAAlB;AACA,WAAK,GAAL,GAAW,MAAM,CAAC,GAAlB;AACD;AAED;;;;;;;;0CAKsB;AACpB,UAAM,SAAS,GAAG,KAAK,GAAL,CAAS,UAA3B;AACA,UAAM,WAAW,GAAG,KAAK,GAAL,CAAS,YAA7B;AAEA,aAAO,IAAI,CAAC,eAAL,CAAqB,SAArB,EAAgC,WAAhC,EACH,uBAAgB,WADb,CAAP;AAED;;;wBA7Xa;AACZ,mCAAO,IAAP;AACD;;;;EA7BuC,oB;;;;;;;;;;;;;;ACxB1C;;AACA;;AACA;;AACA;;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOA,IAAM,SAAS,GAAG,6BAAlB;AACA,IAAM,KAAK,GAAG,iBAAd;AAEA;;;;IAGa,G;;;;;AACX;;;;AAIA,eAAY,WAAZ,EAAkC;AAAA;;AAAA;;AAChC,6EAAM,SAAS,CAAC,YAAhB;AAEA,QAAI,WAAJ,EAAiB,MAAK,UAAL;AAEjB,UAAK,YAAL,GAAoB,IAAI,kBAAJ,EAApB;AACA,UAAK,UAAL,GAAkB,IAAI,aAAJ,EAAlB;AANgC;AAOjC;AAED;;;;;;;iCAGa;AAAA;;AACX;;AACA,iCAAK,YAAL,0EAAmB,UAAnB;AACA,+BAAK,UAAL,sEAAiB,UAAjB;AACD;AAED;;;;;;;;;;;;;;;;;;;;6BAiBS;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,YATR;AAUb,sBAAc,KAAK;AAVN,OAAf;AAYA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;;EAxDsB,UAAU,CAAC,G;AA2DpC;;;;;;;IAGM,a;;;;;AACJ;;;AAGA,2BAAc;AAAA;;AAAA;;AACZ;AAEA,WAAK,QAAL,GAAgB,IAAI,qBAAJ,EAAhB;AAHY;AAIb;AAED;;;;;;;iCAGa;AAAA;;AACX;;AACA,6BAAK,QAAL,kEAAe,UAAf;AACD;AAED;;;;;;;6BAIS;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;;;;;IAGM,qB;;;;;AACJ;;;AAGA,mCAAc;AAAA;;AAAA,8FACN,SAAS,CAAC,iBADJ,EAER,iCAAoB,iBAFZ;AAGb;;;EAPiC,gB;AAUpC;;;;;IAGM,kB;;;;;AACJ;;;AAGA,gCAAc;AAAA;;AAAA;;AACZ,6FAAM,SAAS,CAAC,qBAAhB;;AADY;AAAA;AAAA,aAcS;AAdT;;AAGZ,WAAK,KAAL,GAAa,IAAI,QAAJ,EAAb;AAHY;AAIb;AAED;;;;;;;iCAGa;AAAA;;AACX;;AACA,0BAAK,KAAL,4DAAY,UAAZ;AACD;;;;AAuBD;;;;;;;;;;;6BAWS;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;;;;AAxCD;;;;wBAI0B;AACxB,mCAAO,IAAP;AACD;AAED;;;;;;sBAKwB,mB,EAAqB;AAC3C,OAAC,KAAK,WAAN,yBACI,IADJ,wBACgC,mBADhC,IAEI,oCAFJ;AAGD;;;;EArC8B,UAAU,CAAC,c;AA+D5C;;;;;;;IAGa,Q;;;;;AACX;;;AAGA,sBAAc;AAAA;;AAAA,iFACN,8BAAe,cADT;AAEb;;;EAN2B,gB;AAS9B;;;;;;;IAGa,c;;;;;AACX;;;AAGA,4BAAc;AAAA;;AAAA;;AACZ;;AADY;AAAA;AAAA,aAqBJ;AArBI;;AAAA;AAAA;AAAA,aAsBN;AAtBM;;AAGZ,WAAK,KAAL,GAAa,IAAI,gBAAJ,CACT;AACE,MAAA,cAAc,EAAE,SAAS,CAAC,cAD5B;AAEE,MAAA,WAAW,EAAE,KAAK,CAAC,WAFrB;AAGE,MAAA,gBAAgB,EAAE,iCAAoB,iBAHxC;AAIE,MAAA,eAAe,EAAE,iCAAoB,aAJvC;AAKE,MAAA,gBAAgB,EAAE,iCAAoB;AALxC,KADS,CAAb;AAHY;AAWb;AAED;;;;;;;iCAGa;AAAA;;AACX;;AACA,0BAAK,KAAL,4DAAY,UAAZ;AACD;;;;AAyCD;;;;;;;;;;6BAUS;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;;;;AAvDD;;;;wBAIa;AACX,mCAAO,IAAP;AACD;AAED;;;;;sBAIW,M,EAAQ;AACjB,UAAI,mCAAmB,MAAnB,EAA2B,KAAK,CAAC,UAAjC,CAAJ,EAAkD;AAChD,6CAAe,MAAf;AACD;AACF;AAED;;;;;;;wBAIW;AACT,mCAAO,IAAP;AACD;AAED;;;;;sBAIS,I,EAAM;AACb,UAAI,mCAAmB,IAAnB,EAAyB,KAAK,CAAC,OAA/B,CAAJ,EAA6C;AAC3C,2CAAa,IAAb;AACD;AACF;;;;EA9DiC,e;AAsFpC;;;;;;;;;;;IAGa,2B;;;;;AACX;;;AAGA,yCAAc;AAAA;;AAAA;;AACZ;;AADY;AAAA;AAAA,aAIH;AAJG;;AAAA;AAAA;AAAA,aAKF;AALE;;AAAA;AAAA;AAAA,aAMN;AANM;;AAAA;AAEb;;;;;AA4DD;;;;;;;;;;6BAUS;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;;;;AAzED;;;;wBAIc;AACZ,mCAAO,IAAP;AACD;AAED;;;;;sBAIY,O,EAAS;AACnB,UAAI,mCAAmB,OAAnB,EAA4B,KAAK,CAAC,YAAlC,CAAJ,EAAqD;AACnD,8CAAgB,OAAhB;AACD;AACF;AAED;;;;;;;wBAIe;AACb,mCAAO,IAAP;AACD;AAED;;;;;sBAIa,Q,EAAU;AACrB,UAAI,mCAAmB,QAAnB,EAA6B,KAAK,CAAC,YAAnC,CAAJ,EAAsD;AACpD,+CAAiB,QAAjB;AACD;AACF;AAED;;;;;;;wBAIW;AACT,mCAAO,IAAP;AACD;AAED;;;;;sBAIS,I,EAAM;AACb,UAAI,mCAAmB,IAAnB,EAAyB,KAAK,CAAC,OAA/B,CAAJ,EAA6C;AAC3C,4CAAa,IAAb;AACD;AACF;;;;EAhE8C,e;AAwFjD;;;;;;;;;;;;;IAGa,G;;;;;AACX;;;AAGA,iBAAc;AAAA;;AAAA;;AACZ;;AADY;AAAA;AAAA,aAIL;AAJK;;AAAA;AAEb;;;;;AAsBD;;;;;;;;6BAQS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,iBAAS,KAAK;AADD,OAAf;AAGA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;;AAjCD;;;;wBAIY;AACV,aAAQ,CAAC,KAAK,UAAP,GAAqB,qCAArB,yBAA6C,IAA7C,SAAP;AACD;AAED;;;;;sBAIU,K,EAAO;AACf,UAAI,mCAAmB,KAAnB,EAA0B,KAAK,CAAC,QAAhC,CAAJ,EAA+C;AAC7C,4CAAc,KAAd;AACD;AACF;;;;EA1BsB,e;;;;;;;;;;;;;;;;AChYzB;;AACA;;AACA;;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA;;;;;;;;;AASO,SAAS,gBAAT,CACH,KADG,EAEH,YAFG,EAGH,SAHG,EAIH,gBAJG,EAIyB;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,2BAAJ,CAAoB,SAApB,CAAN;AACD;;AACD,SAAO,IAAP;AACD;AAED;;;;;;;;;;AAQO,SAAS,eAAT,CACH,KADG,EACS,YADT,EAC+B,SAD/B,EACkD;AACvD,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,2BAAJ,CAAoB,SAApB,CAAN;AACD;AACF,GAND,MAMO;AACL,UAAM,IAAI,2BAAJ,CAAoB,SAApB,CAAN;AACD;AACF;AAED;;;;;IAGa,O;;;;;;wCACE,K;;;;aACE;;;;;;;AAUf;;;iCAGa;AACX,gDAAoB,IAApB;AACD;;;;AAbD;;;;wBAIkB;AAChB,mCAAO,IAAP;AACD;;;;;AAUH;;;;;;;;;IAGa,Q;;;;;AACX;;;;;;;;;;AAUA,0BASO;AAAA;;AAAA,QAPD,cAOC,QAPD,cAOC;AAAA,QAND,WAMC,QAND,WAMC;AAAA,QALD,GAKC,QALD,GAKC;AAAA,QAJD,gBAIC,QAJD,gBAIC;AAAA,QAHD,eAGC,QAHD,eAGC;AAAA,QAFD,gBAEC,QAFD,gBAEC;AAAA,QADD,YACC,QADD,YACC;;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,aA4BA;AA5BA;;AAAA;AAAA;AAAA,aA6BA;AA7BA;;AAAA;AAAA;AAAA;AAAA;;AAGL,qEAAkB,cAAc,GAC5B,cAD4B,GAE5B,iCAAkB,cAFtB;;AAGA,uEAAqB,CAAC,WAAD,GAAe,KAAf,GAAuB,qBAAc,WAA1D;;AACA,+DAAa,GAAG,IAAI,GAAG,KAAK,EAAhB,GAAsB,GAAtB,GAA4B,KAAxC;;AACA,8EAA4B,gBAAgB,GACxC,gBADwC,GAExC,iCAAoB,iBAFxB;;AAGA,6EAA2B,eAAe,GACtC,eADsC,GAEtC,iCAAoB,aAFxB;;AAGA,8EAA4B,gBAAgB,GACxC,gBADwC,GAExC,iCAAoB,kBAFxB;;AAGA,yEAAuB,YAAY,GAC/B,YAD+B,GAE/B,qBAAc,UAFlB;;AAjBK;AAoBN;;;;;AAgGD;;;;6BAIS;AACP,aAAO;AACL,eAAO,KAAK,GADP;AAEL,eAAO,KAAK,GAFP;AAGL,eAAO,KAAK;AAHP,OAAP;AAKD;;;;AA9FD;;;;;wBAKgB;AACd,mCAAO,IAAP;AACD;AAED;;;;;;sBAKc,S,EAAW;AACvB,YAAM,IAAI,2BAAJ,uBAAoB,IAApB,uBAAN;AACD;AAED;;;;;;;wBAIU;AACR,mCAAO,IAAP;AACD;AAED;;;;;sBAIQ,G,EAAK;AACX,UAAI,gBAAgB,CAAC,GAAD,wBAAM,IAAN,yCAChB,IADgB,sBAAhB,KAEC,uBAAC,IAAD,mBACG,eAAe,CAAC,GAAD,wBAAM,IAAN,uCACX,IADW,uBAHnB,CAAJ,EAIyC;AACvC,0CAAY,GAAZ;AACD;AACF;AAED;;;;;;;wBAIU;AACR,mCAAO,IAAP;AACD;AAED;;;;;sBAIQ,G,EAAK;AACX,UAAI,gBAAgB,CAAC,GAAD,wBAAM,IAAN,yCAChB,IADgB,sBAAhB,KAEC,uBAAC,IAAD,mBACG,eAAe,CAAC,GAAD,wBAAM,IAAN,uCACX,IADW,uBAHnB,CAAJ,EAIyC;AACvC,0CAAY,GAAZ;AACD;AACF;AAED;;;;;;;wBAIU;AACR,mCAAO,IAAP;AACD;AAED;;;;;sBAIQ,G,EAAK;AACX,UAAI,gBAAgB,CAAC,GAAD,wBAAM,IAAN,yCAChB,IADgB,sBAAhB,KAEC,uBAAC,IAAD,mBACG,eAAe,CAAC,GAAD,wBAAM,IAAN,uCACX,IADW,uBAHnB,CAAJ,EAIyC;AACvC,0CAAY,GAAZ;AACD;AACF;;;;EAtI2B,O;AAqJ9B;;;;;;;;;;;;;;;;;;;;;;;;;IAGa,Q;;;;;AACX;;;;;AAKA,2BAAmC;AAAA;;AAAA,QAAtB,QAAsB,SAAtB,QAAsB;AAAA,QAAZ,SAAY,SAAZ,SAAY;;AAAA;;AACjC;;AADiC;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAEjC,sEAAkB,QAAlB;;AACA,sEAAkB,SAAlB;;AACA,WAAK,UAAL,GAAkB,EAAlB;AAJiC;AAKlC;;;;;AAyCD;;;;6BAIS;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;;;;AAhDD;;;;;wBAKgB;AACd,mCAAO,IAAP;AACD;AAED;;;;;;sBAKc,S,EAAW;AACvB,YAAM,IAAI,2BAAJ,uBAAoB,IAApB,cAAN;AACD;AAED;;;;;;;;wBAKa;AACX,aAAO,KAAK,UAAL,CAAgB,MAAvB;AACD;AAED;;;;;;sBAKW,M,EAAQ;AACjB,YAAM,IAAI,2BAAJ,uBAAoB,IAApB,cAAN;AACD;;;;EAlD2B,O;;;;;;;;;;;;;;;;;;;;ACvO9B;;AAOA;;AACA;;AACA;;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,IAAM,SAAS,GAAG,gCAAlB;AACA,IAAM,KAAK,GAAG,oBAAd;AAEA;;;;AAGO,SAAS,kBAAT,GAA8B;AACnC,QAAM,IAAI,2BAAJ,CAAoB,iCAAoB,iBAAxC,CAAN;AACD;AAED;;;;;AAGO,SAAS,mBAAT,GAA+B;AACpC,QAAM,IAAI,2BAAJ,CAAoB,iCAAoB,kBAAxC,CAAN;AACD;AAED;;;;;AAGA,SAAS,sBAAT,GAAkC;AAChC,QAAM,IAAI,2BAAJ,CAAoB,iCAAoB,iBAAxC,CAAN;AACD;AAED;;;;;;;;AAMO,SAAS,kBAAT,CAA4B,KAA5B,EAA2C,YAA3C,EAAiE;AACtE,SAAO,8BAAiB,KAAjB,EAAwB,YAAxB,EACH,iCAAoB,aADjB,CAAP;AAED;AAED;;;;;;;;AAMO,SAAS,iBAAT,CAA2B,KAA3B,EAAuC,YAAvC,EAA6D;AAClE,SAAO,6BAAgB,KAAhB,EAAuB,YAAvB,EACH,iCAAoB,kBADjB,CAAP;AAED;AAED;;;;;IAGa,G;;;;;AAUX;;;;;;AAMA,eAAY,YAAZ,EAA0B,YAA1B,EAAwC,WAAxC,EAA8D;AAAA;;AAAA;;AAC5D;;AAD4D;AAAA;AAAA,aAfjD;AAeiD;;AAAA;AAAA;AAAA,aAdlD;AAckD;;AAAA;AAAA;AAAA,aAb9C;AAa8C;;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,GAAG,YAAH,GAAkB,SAAS,CAAC,YAA1D;;AACA,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;AAV4D;AAW7D;AAED;;;;;;;iCAGa;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;;;;;;;;;;;;;;;;;;;;6BAiBS;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;;;;;;;;wBAKe;AACb,mCAAO,IAAP;AACD;AAED;;;;;;sBAKa,Q,EAAU;AACrB,MAAA,sBAAsB;AACvB;AAED;;;;;;;;wBAKgB;AACd,mCAAO,IAAP;AACD;AAED;;;;;;sBAKc,S,EAAW;AACvB,MAAA,sBAAsB;AACvB;AAED;;;;;;;wBAImB;AACjB,mCAAO,IAAP;AACD;AAED;;;;;sBAIiB,Y,EAAc;AAC7B,UAAI,kBAAkB,CAAC,YAAD,EAAe,KAAK,CAAC,aAArB,CAAtB,EAA2D;AACzD,mDAAqB,YAArB;AACD;AACF;AAED;;;;;;;wBAIkB;AAChB,mCAAO,IAAP;AACD;AAED;;;;;sBAIgB,W,EAAa;AAC3B,OAAC,KAAK,WAAN,yBAAoB,IAApB,gBAAwC,WAAxC,IAAsD,kBAAkB,EAAxE;AACD;AAED;;;;;;;wBAIe;AACb,mCAAO,IAAP;AACD;AAED;;;;;sBAIa,Q,EAAU;AACrB,UAAI,kBAAkB,CAAC,QAAD,EAAW,KAAK,CAAC,aAAjB,CAAtB,EAAuD;AACrD,+CAAiB,QAAjB;AACD;AACF;AAED;;;;;;;wBAIwB;AACtB,mCAAO,IAAP;AACD;AAED;;;;;sBAIsB,iB,EAAmB;AACvC,OAAC,KAAK,WAAN,yBACI,IADJ,sBAC8B,iBAD9B,IAEI,kBAAkB,EAFtB;AAGD;;;;EAnLsB,e;AAsLzB;;;;;;;;;;;;;;;;;;;IAGM,O;;;;;AACJ;;;AAGA,qBAAc;AAAA;;AAAA;;AACZ;;AADY;AAAA;AAAA,aAqBD,SAAS,CAAC;AArBT;;AAAA;AAAA;AAAA,aAsBA;AAtBA;;AAAA;AAAA;AAAA,aAuBE;AAvBF;;AAAA;AAAA;AAAA,aAwBK;AAxBL;;AAAA;AAAA;AAAA,aAyBJ;AAzBI;;AAAA;AAAA;AAAA,aA0BG;AA1BH;;AAAA;AAAA;AAAA,aA2BL;AA3BK;;AAAA;AAAA;AAAA,aA4BA;AA5BA;;AAAA;AAAA;AAAA,aA6BC;AA7BD;;AAAA;AAAA;AAAA,aA8BN;AA9BM;;AAAA;AAAA;AAAA,aA+BE;AA/BF;;AAGZ,WAAK,KAAL,GAAa,IAAI,gBAAJ,CACT;AACE,MAAA,cAAc,EAAE,SAAS,CAAC,cAD5B;AAEE,MAAA,WAAW,EAAE,KAAK,CAAC,WAFrB;AAGE,MAAA,gBAAgB,EAAE,iCAAoB,iBAHxC;AAIE,MAAA,eAAe,EAAE,iCAAoB,aAJvC;AAKE,MAAA,gBAAgB,EAAE,iCAAoB;AALxC,KADS,CAAb;AAHY;AAWb;AAED;;;;;;;iCAGa;AAAA;;AACX;;AACA,0BAAK,KAAL,4DAAY,UAAZ;AACD;;;;AA0MD;;;;;;;;;;;;;;;;;;;6BAmBS;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,sBAAc,KAAK,UAPN;AAQb,uBAAe,KAAK,WARP;AASb,gBAAQ,KAAK,IATA;AAUb,wBAAgB,KAAK,YAVR;AAWb,iBAAS,KAAK;AAXD,OAAf;AAaA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;;AAhOD;;;;;wBAKgB;AACd,mCAAO,IAAP;AACD;AAED;;;;;;sBAKc,S,EAAW;AACvB,MAAA,sBAAsB;AACvB;AAED;;;;;;;wBAIiB;AACf,mCAAO,IAAP;AACD;AAED;;;;;sBAIe,U,EAAY;AACzB,OAAC,KAAK,WAAN,yBAAoB,IAApB,eAAuC,UAAvC,IAAoD,kBAAkB,EAAtE;AACD;AAED;;;;;;;wBAImB;AACjB,mCAAO,IAAP;AACD;AAED;;;;;sBAIiB,Y,EAAc;AAC7B,OAAC,KAAK,WAAN,yBACI,IADJ,iBACyB,YADzB,IAEI,kBAAkB,EAFtB;AAGD;AAED;;;;;;;wBAIsB;AACpB,mCAAO,IAAP;AACD;AAED;;;;;sBAIoB,e,EAAiB;AACnC,UAAI,kBAAkB,CAAC,eAAD,EAAkB,KAAK,CAAC,YAAxB,CAAtB,EAA6D;AAC3D,sDAAwB,eAAxB;AACD;AACF;AAED;;;;;;;wBAIa;AACX,mCAAO,IAAP;AACD;AAED;;;;;sBAIW,M,EAAQ;AACjB,OAAC,KAAK,WAAN,yBAAoB,IAApB,WAAmC,MAAnC,IAA4C,kBAAkB,EAA9D;AACD;AAED;;;;;;;wBAIoB;AAClB,mCAAO,IAAP;AACD;AAED;;;;;sBAIkB,a,EAAe;AAC/B,UAAI,kBAAkB,CAAC,aAAD,EAAgB,KAAK,CAAC,SAAtB,CAAtB,EAAwD;AACtD,oDAAsB,aAAtB;AACD;AACF;AAED;;;;;;;wBAIY;AACV,mCAAO,IAAP;AACD;AAED;;;;;sBAIU,K,EAAO;AACf,OAAC,KAAK,WAAN,yBAAoB,IAApB,UAAkC,KAAlC,IAA0C,kBAAkB,EAA5D;AACD;AAED;;;;;;;wBAIiB;AACf,mCAAO,IAAP;AACD;AAED;;;;;sBAIe,U,EAAY;AACzB,OAAC,KAAK,WAAN,yBAAoB,IAApB,eAAuC,UAAvC,IAAoD,kBAAkB,EAAtE;AACD;AAED;;;;;;;wBAIkB;AAChB,mCAAO,IAAP;AACD;AAED;;;;;sBAIgB,W,EAAa;AAC3B,OAAC,KAAK,WAAN,yBAAoB,IAApB,gBAAwC,WAAxC,IAAsD,kBAAkB,EAAxE;AACD;AAED;;;;;;;wBAIW;AACT,aAAQ,CAAC,KAAK,UAAP,GAAqB,mBAAmB,EAAxC,yBAA6C,IAA7C,QAAP;AACD;AAED;;;;;sBAIS,I,EAAM;AACb,UAAI,kBAAkB,CAAC,IAAD,EAAO,KAAK,CAAC,OAAb,CAAtB,EAA6C;AAC3C,2CAAa,IAAb;AACD;AACF;AAED;;;;;;;wBAImB;AACjB,aAAQ,CAAC,KAAK,UAAP,GAAqB,mBAAmB,EAAxC,yBAA6C,IAA7C,gBAAP;AACD;AAED;;;;;sBAIiB,Y,EAAc;AAC7B,UAAI,kBAAkB,CAAC,YAAD,EAAe,KAAK,CAAC,WAArB,CAAtB,EAAyD;AACvD,mDAAqB,YAArB;AACD;AACF;;;;EA/NmB,e;AAwQtB;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGM,a;;;;;AACJ;;;AAGA,2BAAc;AAAA;;AAAA,sFACN;AACJ,MAAA,QAAQ,EAAE,SAAS,CAAC,mBADhB;AAEJ,MAAA,SAAS,EAAE,iCAAoB;AAF3B,KADM;AAKb;;;EATyB,gB;AAY5B;;;;;IAGa,c;;;;;AAMX;;;;AAIA,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,SAAS,CAAC,qBAFd;;AAHiC;AAMlC;AAED;;;;;;;;;;AAwEA;;;;;;;;;;;6BAWS;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;;;wBAvFe;AACd,mCAAO,IAAP;AACD;AAED;;;;;;sBAKc,S,EAAW;AACvB,MAAA,sBAAsB;AACvB;AAED;;;;;;;wBAIoB;AAClB,mCAAO,IAAP;AACD;AAED;;;;;sBAIkB,a,EAAe;AAC/B,OAAC,KAAK,WAAN,yBACI,IADJ,kBAC0B,aAD1B,IAEI,kBAAkB,EAFtB;AAGD;AAED;;;;;;;wBAIuB;AACrB,mCAAO,IAAP;AACD;AAED;;;;;sBAIqB,gB,EAAkB;AACrC,OAAC,KAAK,WAAN,yBACI,IADJ,qBAC6B,gBAD7B,IAEI,kBAAkB,EAFtB;AAGD;AAED;;;;;;;wBAIwB;AACtB,mCAAO,IAAP;AACD;AAED;;;;;sBAIsB,iB,EAAmB;AACvC,OAAC,KAAK,WAAN,yBACI,IADJ,sBAC8B,iBAD9B,IAEI,kBAAkB,EAFtB;AAGD;;;;EAxFiC,e;AAiHpC;;;;;;;;;;;;;;;IAGM,oB;;;;;AACJ;;;AAGA,kCAAc;AAAA;;AAAA;;AACZ;;AADY;AAAA;AAAA,aAID,SAAS,CAAC;AAJT;;AAAA;AAAA;AAAA,aAKL;AALK;;AAAA;AAAA;AAAA,aAMF;AANE;;AAAA;AAAA;AAAA,aAOL;AAPK;;AAAA;AAAA;AAAA,aAQN;AARM;;AAAA;AAEb;;;;;AAqGD;;;;;;;;;;;;6BAYS;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;;;;AAnHD;;;;;wBAKgB;AACd,mCAAO,IAAP;AACD;AAED;;;;;;sBAKc,S,EAAW;AACvB,MAAA,sBAAsB;AACvB;AAED;;;;;;;wBAIY;AACV,mCAAO,IAAP;AACD;AAED;;;;;sBAIU,K,EAAO;AACf,UAAI,kBAAkB,CAAC,KAAD,EAAQ,KAAK,CAAC,WAAd,CAAlB,IACA,iBAAiB,CAAC,KAAD,EAAQ,KAAK,CAAC,WAAd,CADrB,EACiD;AAC/C,4CAAc,KAAd;AACD;AACF;AAED;;;;;;;wBAIe;AACb,mCAAO,IAAP;AACD;AAED;;;;;sBAIa,Q,EAAU;AACrB,UAAI,kBAAkB,CAAC,QAAD,EAAW,KAAK,CAAC,YAAjB,CAAtB,EAAsD;AACpD,+CAAiB,QAAjB;AACD;AACF;AAED;;;;;;;wBAIY;AACV,mCAAO,IAAP;AACD;AAED;;;;;sBAIU,K,EAAO;AACf,UAAI,kBAAkB,CAAC,KAAD,EAAQ,KAAK,CAAC,WAAd,CAAlB,IACA,iBAAiB,CAAC,KAAD,EAAQ,KAAK,CAAC,WAAd,CADrB,EACiD;AAC/C,4CAAc,KAAd;AACD;AACF;AAED;;;;;;;wBAIW;AACT,mCAAO,IAAP;AACD;AAED;;;;;sBAIS,I,EAAM;AACb,UAAI,kBAAkB,CAAC,IAAD,EAAO,KAAK,CAAC,WAAb,CAAlB,IACA,iBAAiB,CAAC,IAAD,EAAO,KAAK,CAAC,UAAb,CADrB,EAC+C;AAC7C,2CAAa,IAAb;AACD;AACF;;;;EAzGgC,e;AAoInC;;;;;;;;;;;;;;;IAGM,e;;;;;AACJ;;;AAGA,6BAAc;AAAA;;AAAA,wFACN;AACJ,MAAA,QAAQ,EAAE,SAAS,CAAC,qBADhB;AAEJ,MAAA,SAAS,EAAE,iCAAoB;AAF3B,KADM;AAKb;;;EAT2B,gB;AAY9B;;;;;IAGa,qB;;;;;AACX;;;AAGA,mCAAc;AAAA;;AAAA;;AACZ;;AADY;AAAA;AAAA,aAsBR;AAtBQ;;AAAA;AAAA;AAAA,aAuBN;AAvBM;;AAAA;AAAA;AAAA,aAwBN;AAxBM;;AAAA;AAAA;AAAA,aAyBD;AAzBC;;AAAA;AAAA;AAAA,aA0BM;AA1BN;;AAAA;AAAA;AAAA,aA2BJ;AA3BI;;AAAA;AAAA;AAAA,aA4BH;AA5BG;;AAGZ,WAAK,UAAL,GAAkB,IAAI,gBAAJ,CAAa;AAC7B,MAAA,SAAS,EAAE,iCAAoB,iBADF;AAE7B,MAAA,QAAQ,EAAE,SAAS,CAAC;AAFS,KAAb,CAAlB;AAIA,WAAK,iBAAL,GAAyB,IAAI,gBAAJ,CAAa;AACpC,MAAA,SAAS,EAAE,iCAAoB,iBADK;AAEpC,MAAA,QAAQ,EAAE,SAAS,CAAC;AAFgB,KAAb,CAAzB;AAPY;AAWb;AAED;;;;;;;iCAGa;AAAA;;AACX;;AACA,gCAAK,UAAL,wEAAiB,UAAjB;AACA,oCAAK,iBAAL,gFAAwB,UAAxB;AACD;;;;AA2ID;;;;;;;;;;;;;;;;;6BAiBS;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;;;;AAjKD;;;;wBAIS;AACP,aAAQ,CAAC,KAAK,UAAP,GAAqB,mBAAmB,EAAxC,yBAA6C,IAA7C,MAAP;AACD;AAED;;;;;sBAIO,E,EAAI;AACT,UAAI,kBAAkB,CAAC,EAAD,EAAK,KAAK,CAAC,aAAX,CAAtB,EAAiD;AAC/C,yCAAW,EAAX;AACD;AACF;AAED;;;;;;;wBAIW;AACT,aAAQ,CAAC,KAAK,UAAP,GAAqB,mBAAmB,EAAxC,yBAA6C,IAA7C,QAAP;AACD;AAED;;;;;sBAIS,I,EAAM;AACb,UAAI,kBAAkB,CAAC,IAAD,EAAO,KAAK,CAAC,OAAb,CAAtB,EAA6C;AAC3C,2CAAa,IAAb;AACD;AACF;AAED;;;;;;;wBAIW;AACT,aAAQ,CAAC,KAAK,UAAP,GAAqB,mBAAmB,EAAxC,yBAA6C,IAA7C,QAAP;AACD;AAED;;;;;sBAIS,I,EAAM;AACb,UAAI,kBAAkB,CAAC,IAAD,EAAO,KAAK,CAAC,OAAb,CAAtB,EAA6C;AAC3C,2CAAa,IAAb;AACD;AACF;AAED;;;;;;;wBAIgB;AACd,aAAQ,CAAC,KAAK,UAAP,GACH,mBAAmB,EADhB,yBAEH,IAFG,aAAP;AAGD;AAED;;;;;sBAIc,S,EAAW;AACvB,UAAI,kBAAkB,CAAC,SAAD,EAAY,KAAK,CAAC,UAAlB,CAAlB,IACA,iBAAiB,CAAC,SAAD,EAAY,KAAK,CAAC,eAAlB,CADrB,EACyD;AACvD,gDAAkB,SAAlB;AACD;AACF;AAED;;;;;;;wBAIuB;AACrB,aAAQ,CAAC,KAAK,UAAP,GAAqB,mBAAmB,EAAxC,yBAA6C,IAA7C,oBAAP;AACD;AAED;;;;;sBAIqB,gB,EAAkB;AACrC,UAAI,kBAAkB,CAAC,gBAAD,EAAmB,KAAK,CAAC,WAAzB,CAAtB,EAA6D;AAC3D,uDAAyB,gBAAzB;AACD;AACF;AAED;;;;;;;wBAIa;AACX,aAAQ,CAAC,KAAK,UAAP,GAAqB,mBAAmB,EAAxC,yBAA6C,IAA7C,UAAP;AACD;AAED;;;;;sBAIW,M,EAAQ;AACjB,UAAI,kBAAkB,CAAC,MAAD,EAAS,KAAK,CAAC,SAAf,CAAtB,EAAiD;AAC/C,6CAAe,MAAf;AACD;AACF;AAED;;;;;;;wBAIc;AACZ,aAAQ,CAAC,KAAK,UAAP,GAAqB,mBAAmB,EAAxC,yBAA6C,IAA7C,WAAP;AACD;AAED;;;;;sBAIY,O,EAAS;AACnB,UAAI,kBAAkB,CAAC,OAAD,EAAU,KAAK,CAAC,WAAhB,CAAtB,EAAoD;AAClD,8CAAgB,OAAhB;AACD;AACF;;;;EAjKwC,e;AAsM3C;;;;;;;;;;;;;;;;;;;;;IAGa,mB;;;;;AACX;;;AAGA,iCAAc;AAAA;;AAAA;;AACZ;;AADY;AAAA;AAAA,aAaR;AAbQ;;AAAA;AAAA;AAAA,aAcJ;AAdI;;AAGZ,WAAK,KAAL,GAAa,IAAI,gBAAJ,CACT;AACE,MAAA,cAAc,EAAE,SAAS,CAAC,cAD5B;AAEE,MAAA,WAAW,EAAE,KAAK,CAAC,WAFrB;AAGE,MAAA,gBAAgB,EAAE,iCAAoB,iBAHxC;AAIE,MAAA,eAAe,EAAE,iCAAoB,aAJvC;AAKE,MAAA,gBAAgB,EAAE,iCAAoB;AALxC,KADS,CAAb;AAHY;AAWb;;;;;AAyCD;;;;;;;;;;6BAUS;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;;;;AAvDD;;;;wBAIS;AACP,mCAAO,IAAP;AACD;AAED;;;;;sBAIO,E,EAAI;AACT,UAAI,kBAAkB,CAAC,EAAD,EAAK,KAAK,CAAC,aAAX,CAAtB,EAAiD;AAC/C,0CAAW,EAAX;AACD;AACF;AAED;;;;;;;wBAIa;AACX,mCAAO,IAAP;AACD;AAED;;;;;sBAIW,M,EAAQ;AACjB,UAAI,kBAAkB,CAAC,MAAD,EAAS,KAAK,CAAC,UAAf,CAAtB,EAAkD;AAChD,6CAAe,MAAf;AACD;AACF;;;;EAtDsC,e;AA8EzC;;;;;;;;;;;IAGa,+B;;;;;AACX;;;AAGA,6CAAc;AAAA;;AAAA;;AACZ;;AADY;AAAA;AAAA,aAIR;AAJQ;;AAAA;AAEb;;;;;AAsBD;;;;;;;;6BAQS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,cAAM,KAAK;AADE,OAAf;AAGA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;;AAjCD;;;;wBAIS;AACP,mCAAO,IAAP;AACD;AAED;;;;;sBAIO,E,EAAI;AACT,UAAI,kBAAkB,CAAC,EAAD,EAAK,KAAK,CAAC,aAAX,CAAtB,EAAiD;AAC/C,0CAAW,EAAX;AACD;AACF;;;;EA1BkD,e;AA8CrD;;;;;;;;;IAGa,qC;;;;;AACX;;;AAGA,mDAAc;AAAA;;AAAA;;AACZ;;AADY;AAAA;AAAA,aAIH;AAJG;;AAAA;AAEb;;;;;AAsBD;;;;;;;;6BAQS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,mBAAW,KAAK;AADH,OAAf;AAGA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;;AAjCD;;;;wBAIc;AACZ,aAAQ,CAAC,KAAK,UAAP,GAAqB,mBAAmB,EAAxC,yBAA6C,IAA7C,WAAP;AACD;AAED;;;;;sBAIY,O,EAAS;AACnB,UAAI,kBAAkB,CAAC,OAAD,EAAU,KAAK,CAAC,WAAhB,CAAtB,EAAoD;AAClD,8CAAgB,OAAhB;AACD;AACF;;;;EA1BwD,e;;;;;;;;;;;;;;ACrmC3D;;AAOA;;AACA;;AACA;;AACA;;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,IAAM,SAAS,GAAG,kCAAlB;AACA,IAAM,KAAK,GAAG,sBAAd;AAEA;;;;AAGA,SAAS,kBAAT,GAA8B;AAC5B,QAAM,IAAI,2BAAJ,CAAoB,mCAAsB,iBAA1C,CAAN;AACD;AAED;;;;;AAGA,SAAS,mBAAT,GAA+B;AAC7B,QAAM,IAAI,2BAAJ,CAAoB,mCAAsB,kBAA1C,CAAN;AACD;AAED;;;;;AAGA,SAAS,sBAAT,GAAkC;AAChC,QAAM,IAAI,2BAAJ,CAAoB,mCAAsB,aAA1C,CAAN;AACD;AAED;;;;;;;;;AAOA,SAAS,oBAAT,CACI,KADJ,EAEI,YAFJ,EAGI,gBAHJ,EAGgC;AAC9B,SAAO,8BAAiB,KAAjB,EAAwB,YAAxB,EACH,mCAAsB,aADnB,EACkC,gBADlC,CAAP;AAED;AAED;;;;;;;;AAMA,SAAS,mBAAT,CAA6B,KAA7B,EAAyC,YAAzC,EAA+D;AAC7D,SAAO,6BAAgB,KAAhB,EAAuB,YAAvB,EACH,mCAAsB,kBADnB,CAAP;AAED;AAED;;;;;IAGa,G;;;;;AAsBX;;;;AAIA,eAAY,WAAZ,EAAkC;AAAA;;AAAA;;AAChC;;AADgC;AAAA;AAAA,aAzBtB;AAyBsB;;AAAA;AAAA;AAAA,aAxBrB,SAAS,CAAC;AAwBW;;AAAA;AAAA;AAAA,aAvBb;AAuBa;;AAAA;AAAA;AAAA,aAtBV;AAsBU;;AAAA;AAAA;AAAA,aArBxB;AAqBwB;;AAAA;AAAA;AAAA,aApBzB;AAoByB;;AAAA;AAAA;AAAA,aAnB1B;AAmB0B;;AAAA;AAAA;AAAA,aAlBnB;AAkBmB;;AAAA;AAAA;AAAA,aAjBpB;AAiBoB;;AAAA;AAAA;AAAA,aAhBlB;AAgBkB;;AAAA;AAAA;AAAA,aAftB;AAesB;;AAAA;AAAA;AAAA,aAdd;AAcc;;AAAA;AAAA;AAAA,aAb1B;AAa0B;;AAAA;AAAA;AAAA,aAZd;AAYc;;AAAA;AAAA;AAAA,aAXV;AAWU;;AAAA;AAAA;AAAA,aAVlB;AAUkB;;AAAA;AAAA;AAAA,aAThB;AASgB;;AAAA;AAAA;AAAA,aARlB;AAQkB;;AAAA;AAAA;AAAA,aAPb;AAOa;;AAAA;AAAA;AAAA,aANpB;AAMoB;;AAGhC,QAAI,WAAJ,EAAiB,MAAK,UAAL;AAEjB,UAAK,kBAAL,GAA0B,IAAI,oBAAJ,EAA1B;AACA,UAAK,KAAL,GAAa,IAAI,iBAAJ,EAAb;AACA,UAAK,qBAAL,GAA6B,IAAI,sBAAJ,EAA7B;AACA,UAAK,iBAAL,GAAyB,IAAI,kBAAJ,EAAzB;AACA,UAAK,YAAL,GAAoB,IAAI,eAAJ,EAApB;AACA,UAAK,UAAL,GAAkB,IAAI,aAAJ,EAAlB;AAVgC;AAWjC;AAED;;;;;;;iCAGa;AAAA;;AACX;;AACA,oCAAK,kBAAL,gFAAyB,UAAzB;AACA,0BAAK,KAAL,4DAAY,UAAZ;AACA,oCAAK,qBAAL,gFAA4B,UAA5B;AACA,qCAAK,iBAAL,kFAAwB,UAAxB;AACA,iCAAK,YAAL,0EAAmB,UAAnB;AACA,+BAAK,UAAL,sEAAiB,UAAjB;AACD;AAED;;;;;;;;;AA6VA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAgCS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,iCAAyB,KAAK,qBADjB;AAEb,6BAAqB,KAAK,iBAFb;AAGb,6BAAqB,KAAK,iBAHb;AAIb,gCAAwB,KAAK,oBAJhB;AAKb,kBAAU,KAAK,MALF;AAMb,iBAAS,KAAK,KAND;AAOb,gBAAQ,KAAK,IAPA;AAQb,wBAAgB,KAAK,YARR;AASb,uBAAe,KAAK,WATP;AAUb,sBAAc,KAAK,UAVN;AAWb,wBAAgB,KAAK,YAXR;AAYb,8BAAsB,KAAK,kBAZd;AAab,oBAAY,KAAK,QAbJ;AAcb,4BAAoB,KAAK,gBAdZ;AAeb,gBAAQ,KAAK,IAfA;AAgBb,sBAAc,KAAK,UAhBN;AAiBb,4BAAoB,KAAK,gBAjBZ;AAkBb,gCAAwB,KAAK,oBAlBhB;AAmBb,iBAAS,KAAK,KAnBD;AAoBb,wBAAgB,KAAK,YApBR;AAqBb,0BAAkB,KAAK,cArBV;AAsBb,wBAAgB,KAAK,YAtBR;AAuBb,6BAAqB,KAAK,iBAvBb;AAwBb,sBAAc,KAAK;AAxBN,OAAf;AA0BA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;wBAtZc;AACb,mCAAO,IAAP;AACD;AAED;;;;;;sBAKa,Q,EAAU;AACrB,MAAA,kBAAkB;AACnB;AAED;;;;;;;;wBAKgB;AACd,mCAAO,IAAP;AACD;AAED;;;;;;sBAKc,S,EAAW;AACvB,MAAA,kBAAkB;AACnB;AAED;;;;;;;wBAIwB;AACtB,mCAAO,IAAP;AACD;AAED;;;;;sBAIsB,iB,EAAmB;AACvC,UAAI,oBAAoB,CAAC,iBAAD,EAAoB,KAAK,CAAC,UAA1B,CAAxB,EAA+D;AAC7D,wDAA0B,iBAA1B;AACD;AACF;AAED;;;;;;;wBAI2B;AACzB,mCAAO,IAAP;AACD;AAED;;;;;sBAIyB,oB,EAAsB;AAC7C,OAAC,KAAK,WAAN,yBACI,IADJ,yBACiC,oBADjC,IAEI,kBAAkB,EAFtB;AAGD;AAED;;;;;;;wBAIa;AACX,mCAAO,IAAP;AACD;AAED;;;;;sBAIW,M,EAAQ;AACjB,OAAC,KAAK,WAAN,yBAAoB,IAApB,WAAmC,MAAnC,IAA4C,kBAAkB,EAA9D;AACD;AAED;;;;;;;wBAIY;AACV,mCAAO,IAAP;AACD;AAED;;;;;sBAIU,K,EAAO;AACf,OAAC,KAAK,WAAN,yBAAoB,IAApB,UAAkC,KAAlC,IAA0C,kBAAkB,EAA5D;AACD;AAED;;;;;;;wBAIW;AACT,aAAQ,CAAC,KAAK,UAAP,GAAqB,mBAAmB,EAAxC,yBAA6C,IAA7C,QAAP;AACD;AAED;;;;;sBAIS,I,EAAM;AACb,UAAI,oBAAoB,CAAC,IAAD,EAAO,KAAK,CAAC,OAAb,CAAxB,EAA+C;AAC7C,2CAAa,IAAb;AACD;AACF;AAED;;;;;;;wBAIkB;AAChB,mCAAO,IAAP;AACD;AAED;;;;;sBAIgB,W,EAAa;AAC3B,OAAC,KAAK,WAAN,yBAAoB,IAApB,gBAAwC,WAAxC,IAAsD,kBAAkB,EAAxE;AACD;AAED;;;;;;;wBAIiB;AACf,mCAAO,IAAP;AACD;AAED;;;;;sBAIe,U,EAAY;AACzB,OAAC,KAAK,WAAN,yBAAoB,IAApB,eAAuC,UAAvC,IAAoD,kBAAkB,EAAtE;AACD;AAED;;;;;;;wBAImB;AACjB,mCAAO,IAAP;AACD;AAED;;;;;sBAIiB,Y,EAAc;AAC7B,OAAC,KAAK,WAAN,yBACI,IADJ,iBACyB,YADzB,IAEI,kBAAkB,EAFtB;AAGD;AAED;;;;;;;wBAIe;AACb,mCAAO,IAAP;AACD;AAED;;;;;sBAIa,Q,EAAU;AACrB,UAAI,oBAAoB,CAAC,QAAD,EAAW,KAAK,CAAC,aAAjB,CAAxB,EAAyD;AACvD,+CAAiB,QAAjB;AACD;AACF;AAED;;;;;;;wBAIuB;AACrB,mCAAO,IAAP;AACD;AAED;;;;;sBAIqB,gB,EAAkB;AACrC,OAAC,KAAK,WAAN,yBACI,IADJ,qBAC6B,gBAD7B,IAEI,kBAAkB,EAFtB;AAGD;AAED;;;;;;;wBAIW;AACT,mCAAO,IAAP;AACD;AAED;;;;;sBAIS,I,EAAM;AACb,OAAC,KAAK,WAAN,yBAAoB,IAApB,SAAiC,IAAjC,IAAwC,kBAAkB,EAA1D;AACD;AAED;;;;;;;wBAIuB;AACrB,mCAAO,IAAP;AACD;AAED;;;;;sBAIqB,gB,EAAkB;AACrC,UAAI,oBAAoB,CAAC,gBAAD,EAAmB,KAAK,CAAC,UAAzB,CAApB,IACA,mBAAmB,CAAC,gBAAD,EAAmB,KAAK,CAAC,cAAzB,CADvB,EACiE;AAC/D,uDAAyB,gBAAzB;AACD;AACF;AAED;;;;;;;wBAI2B;AACzB,mCAAO,IAAP;AACD;AAED;;;;;sBAIyB,oB,EAAsB;AAC7C,OAAC,KAAK,WAAN,yBACI,IADJ,yBACiC,oBADjC,IAEI,kBAAkB,EAFtB;AAGD;AAED;;;;;;;wBAImB;AACjB,aAAQ,CAAC,KAAK,UAAP,GAAqB,mBAAmB,EAAxC,yBAA6C,IAA7C,gBAAP;AACD;AAED;;;;;sBAIiB,Y,EAAc;AAC7B,UAAI,oBAAoB,CAAC,YAAD,EAAe,KAAK,CAAC,WAArB,CAAxB,EAA2D;AACzD,mDAAqB,YAArB;AACD;AACF;AAED;;;;;;;wBAIqB;AACnB,mCAAO,IAAP;AACD;AAED;;;;;sBAImB,c,EAAgB;AACjC,UAAI,oBAAoB,CAAC,cAAD,EAAiB,KAAK,CAAC,UAAvB,CAAxB,EAA4D;AAC1D,qDAAuB,cAAvB;AACD;AACF;AAED;;;;;;;wBAImB;AACjB,mCAAO,IAAP;AACD;AAED;;;;;sBAIiB,Y,EAAc;AAC7B,UAAI,oBAAoB,CAAC,YAAD,EAAe,KAAK,CAAC,cAArB,CAAxB,EAA8D;AAC5D,mDAAqB,YAArB;AACD;AACF;AAED;;;;;;;wBAIwB;AACtB,mCAAO,IAAP;AACD;AAED;;;;;sBAIsB,iB,EAAmB;AACvC,OAAC,KAAK,WAAN,yBACI,IADJ,sBAC8B,iBAD9B,IAEI,kBAAkB,EAFtB;AAGD;AAED;;;;;;;wBAIiB;AACf,mCAAO,IAAP;AACD;AAED;;;;;sBAIe,U,EAAY;AACzB,OAAC,KAAK,WAAN,yBAAoB,IAApB,eAAuC,UAAvC,IAAoD,kBAAkB,EAAtE;AACD;;;;EA/YsB,e;AAkdzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGM,oB;;;;;AAOJ;;;AAGA,kCAAc;AAAA;;AAAA;;AACZ;;AADY;AAAA;AAAA,aATD,SAAS,CAAC;AAST;;AAAA;AAAA;AAAA,aARC;AAQD;;AAAA;AAAA;AAAA,aAPF;AAOE;;AAAA;AAAA;AAAA,aANI;AAMJ;;AAAA;AAAA;AAAA,aALM;AAKN;;AAAA;AAEb;AAED;;;;;;;;;;AA6FA;;;;;;;;;;;;6BAYS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,uBAAe,KAAK,WADP;AAEb,oBAAY,KAAK,QAFJ;AAGb,0BAAkB,KAAK,cAHV;AAIb,4BAAoB,KAAK;AAJZ,OAAf;AAMA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;wBA9Ge;AACd,mCAAO,IAAP;AACD;AAED;;;;;;sBAKc,S,EAAW;AACvB,MAAA,kBAAkB;AACnB;AAED;;;;;;;wBAIkB;AAChB,mCAAO,IAAP;AACD;AAED;;;;;sBAIgB,W,EAAa;AAC3B,UAAI,oBAAoB,CAAC,WAAD,EAAc,KAAK,CAAC,UAApB,CAApB,IACA,mBAAmB,CAAC,WAAD,EAAc,KAAK,CAAC,WAApB,CADvB,EACyD;AACvD,kDAAoB,WAApB;AACD;AACF;AAED;;;;;;;wBAIe;AACb,mCAAO,IAAP;AACD;AAED;;;;;sBAIa,Q,EAAU;AACrB,UAAI,oBAAoB,CAAC,QAAD,EAAW,KAAK,CAAC,OAAjB,CAAxB,EAAmD;AACjD,+CAAiB,QAAjB;AACD;AACF;AAED;;;;;;;wBAIqB;AACnB,mCAAO,IAAP;AACD;AAED;;;;;sBAImB,c,EAAgB;AACjC,UAAI,oBAAoB,CAAC,cAAD,EAAiB,KAAK,CAAC,UAAvB,CAApB,IACA,mBAAmB,CAAC,cAAD,EAAiB,KAAK,CAAC,WAAvB,CADvB,EAC4D;AAC1D,qDAAuB,cAAvB;AACD;AACF;AAED;;;;;;;wBAIuB;AACrB,mCAAO,IAAP;AACD;AAED;;;;;sBAIqB,gB,EAAkB;AACrC,UAAI,oBAAoB,CAAC,gBAAD,EAAmB,KAAK,CAAC,WAAzB,CAApB,IACA,mBAAmB,CAAC,gBAAD,EAAmB,KAAK,CAAC,UAAzB,CADvB,EAC6D;AAC3D,uDAAyB,gBAAzB;AACD;AACF;;;;EAzGgC,e;AAoInC;;;;;;;;;;;;;;;IAGM,e;;;;;AACJ;;;AAGA,6BAAc;AAAA;;AAAA,wFACN;AACJ,MAAA,QAAQ,EAAE,SAAS,CAAC,qBADhB;AAEJ,MAAA,SAAS,EAAE,mCAAsB;AAF7B,KADM;AAKb;;;EAT2B,gB;AAY9B;;;;;IAGM,a;;;;;AACJ;;;AAGA,2BAAc;AAAA;;AAAA,sFACN;AACJ,MAAA,QAAQ,EAAE,SAAS,CAAC,mBADhB;AAEJ,MAAA,SAAS,EAAE,mCAAsB;AAF7B,KADM;AAKb;;;EATyB,gB;AAY5B;;;;;IAGM,kB;;;;;AACJ;;;AAGA,gCAAc;AAAA;;AAAA,2FACN;AACJ,MAAA,QAAQ,EAAE,SAAS,CAAC,iBADhB;AAEJ,MAAA,SAAS,EAAE,mCAAsB;AAF7B,KADM;AAKb;;;EAT8B,gB;AAYjC;;;;;IAGM,sB;;;;;AACJ;;;AAGA,oCAAc;AAAA;;AAAA,+FACN;AACJ,MAAA,QAAQ,EAAE,SAAS,CAAC,iBADhB;AAEJ,MAAA,SAAS,EAAE,mCAAsB;AAF7B,KADM;AAKb;;;EATkC,gB;AAYrC;;;;;IAGa,qB;;;;;AAUX;;;AAGA,mCAAc;AAAA;;AAAA;;AACZ;;AADY;AAAA;AAAA,aAZR;AAYQ;;AAAA;AAAA;AAAA,aAXN;AAWM;;AAAA;AAAA;AAAA,aAVD;AAUC;;AAAA;AAAA;AAAA,aATD;AASC;;AAAA;AAAA;AAAA,aARM;AAQN;;AAAA;AAAA;AAAA,aAPJ;AAOI;;AAAA;AAAA;AAAA,aANH;AAMG;;AAAA;AAAA;AAAA,aALC;AAKD;;AAGZ,WAAK,UAAL,GAAkB,IAAI,gBAAJ,CAAa;AAC7B,MAAA,SAAS,EAAE,mCAAsB,iBADJ;AAE7B,MAAA,QAAQ,EAAE,SAAS,CAAC;AAFS,KAAb,CAAlB;AAIA,WAAK,iBAAL,GAAyB,IAAI,gBAAJ,CAAa;AACpC,MAAA,SAAS,EAAE,mCAAsB,iBADG;AAEpC,MAAA,QAAQ,EAAE,SAAS,CAAC;AAFgB,KAAb,CAAzB;AAPY;AAWb;AAED;;;;;;;iCAGa;AAAA;;AACX;;AACA,gCAAK,UAAL,wEAAiB,UAAjB;AACA,oCAAK,iBAAL,gFAAwB,UAAxB;AACD;AAED;;;;;;;;AA4LA;;;;;;;;;;;;;;;;;;6BAkBS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,cAAM,KAAK,EADE;AAEb,gBAAQ,KAAK,IAFA;AAGb,sBAAc,KAAK,UAHN;AAIb,qBAAa,KAAK,SAJL;AAKb,qBAAa,KAAK,SALL;AAMb,4BAAoB,KAAK,gBANZ;AAOb,kBAAU,KAAK,MAPF;AAQb,mBAAW,KAAK,OARH;AASb,uBAAe,KAAK,WATP;AAUb,6BAAqB,KAAK;AAVb,OAAf;AAYA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;wBA1NQ;AACP,mCAAO,IAAP;AACD;AAED;;;;;sBAIO,E,EAAI;AACT,UAAI,oBAAoB,CAAC,EAAD,EAAK,KAAK,CAAC,iBAAX,CAAxB,EAAuD;AACrD,yCAAW,EAAX;AACD;AACF;AAED;;;;;;;wBAIW;AACT,mCAAO,IAAP;AACD;AAED;;;;;sBAIS,I,EAAM;AACb,UAAI,oBAAoB,CAAC,IAAD,EAAO,KAAK,CAAC,OAAb,CAAxB,EAA+C;AAC7C,2CAAa,IAAb;AACD;AACF;AAED;;;;;;;wBAIgB;AACd,mCAAO,IAAP;AACD;AAED;;;;;sBAIc,S,EAAW;AACvB,UAAI,oBAAoB,CAAC,SAAD,EAAY,KAAK,CAAC,OAAlB,CAAxB,EAAoD;AAClD,gDAAkB,SAAlB;AACD;AACF;AAED;;;;;;;wBAIgB;AACd,mCAAO,IAAP;AACD;AAED;;;;;sBAIc,S,EAAW;AACvB,UAAI,oBAAoB,CAAC,SAAD,EAAY,KAAK,CAAC,UAAlB,CAAxB,EAAuD;AACrD,gDAAkB,SAAlB;AACD;AACF;AAED;;;;;;;wBAIuB;AACrB,mCAAO,IAAP;AACD;AAED;;;;;;sBAKqB,gB,EAAkB;AACrC,UAAI,OAAO,KAAK,IAAZ,KAAqB,WAAzB,EAAsC;AACpC,cAAM,IAAI,2BAAJ,CACF,mCAAsB,0BADpB,CAAN;AAED,OAHD,MAGO;AACL,YAAI,KAAK,GAAG,EAAZ;AACA,YAAM,aAAa,GAAG,sCAAkB,KAAK,IAAvB,CAAtB;;AACA,YAAI,aAAa,CAAC,SAAd,KAA4B,EAAhC,EAAoC;AAClC,UAAA,KAAK,GAAG,gBAAgB,CAAC,KAAjB,CAAuB,aAAa,CAAC,SAArC,CAAR;AACD,SAFD,MAEO;AACL,UAAA,KAAK,CAAC,CAAD,CAAL,GAAW,gBAAX;AACD;;AAED,YAAK,KAAK,CAAC,MAAN,GAAe,CAAhB,IAAuB,KAAK,CAAC,MAAN,IAAgB,aAAa,CAAC,GAAzD,EAA+D;AAC7D,cAAM,WAAW,GAAG,IAAI,MAAJ,CAAW,aAAa,CAAC,MAAzB,CAApB;;AACA,eAAK,IAAI,CAAC,GAAG,CAAb,EAAgB,CAAC,GAAG,KAAK,CAAC,MAA1B,EAAkC,CAAC,EAAnC,EAAuC;AACrC,gBAAI,OAAO,aAAa,CAAC,UAArB,KAAoC,WAAxC,EAAqD;AACnD,kBAAM,MAAM,GAAG,KAAK,CAAC,CAAD,CAAL,CAAS,KAAT,CAAe,aAAa,CAAC,UAA7B,CAAf;;AACA,kBAAI,MAAM,CAAC,MAAP,KAAkB,CAAtB,EAAyB;AACvB,oBAAI,CAAC,MAAM,CAAC,CAAD,CAAN,CAAU,KAAV,CAAgB,WAAhB,CAAL,EAAmC;AACjC,kBAAA,sBAAsB;AACvB,iBAFD,MAEO;AACL,sBAAI,CAAC,MAAM,CAAC,CAAD,CAAN,CAAU,KAAV,CAAgB,IAAI,MAAJ,CAAW,aAAa,CAAC,OAAzB,CAAhB,CAAL,EAAyD;AACvD,oBAAA,sBAAsB;AACvB;AACF;AACF,eARD,MAQO;AACL,gBAAA,sBAAsB;AACvB;AACF,aAbD,MAaO;AACL,kBAAI,CAAC,KAAK,CAAC,CAAD,CAAL,CAAS,KAAT,CAAe,WAAf,CAAL,EAAkC;AAChC,gBAAA,sBAAsB;AACvB,eAFD,MAEO;AACL,oBAAI,KAAK,CAAC,CAAD,CAAL,KAAa,EAAb,IAAmB,aAAa,CAAC,MAArC,EAA6C;AAC3C,uBAAK,IAAI,CAAC,GAAG,CAAb,EAAgB,CAAC,GAAG,CAApB,EAAuB,CAAC,EAAxB,EAA4B;AAC1B,wBAAI,KAAK,CAAC,CAAD,CAAL,KAAa,KAAK,CAAC,CAAD,CAAtB,EAA2B;AACzB,sBAAA,sBAAsB;AACvB;AACF;AACF;AACF;AACF;AACF;AACF,SA9BD,MA8BO;AACL,gBAAM,IAAI,2BAAJ,CAAoB,mCAAsB,mBAA1C,CAAN;AACD;AACF;AACF;AAED;;;;;;;wBAIa;AACX,mCAAO,IAAP;AACD;AAED;;;;;sBAIW,M,EAAQ;AACjB,UAAI,oBAAoB,CAAC,MAAD,EAAS,KAAK,CAAC,SAAf,CAAxB,EAAmD;AACjD,6CAAe,MAAf;AACD;AACF;AAED;;;;;;;wBAIc;AACZ,mCAAO,IAAP;AACD;AAED;;;;;sBAIY,O,EAAS;AACnB,UAAI,oBAAoB,CAAC,OAAD,EAAU,KAAK,CAAC,WAAhB,CAAxB,EAAsD;AACpD,8CAAgB,OAAhB;AACD;AACF;AAED;;;;;;;wBAIkB;AAChB,mCAAO,IAAP;AACD;AAED;;;;;sBAIgB,W,EAAa;AAC3B,UAAI,oBAAoB,CAAC,WAAD,EAAc,KAAK,CAAC,gBAApB,EAAsC,IAAtC,CAAxB,EAAqE;AACnE,kDAAoB,WAApB;AACD;AACF;;;;EA7NwC,e;AAoQ3C;;;;;;;;;;;;;;;;;;;;;;;IAGa,mB;;;;;AAOX;;;AAGA,iCAAc;AAAA;;AAAA;;AACZ;;AADY;AAAA;AAAA,aATR;AASQ;;AAAA;AAAA;AAAA,aARI;AAQJ;;AAAA;AAAA;AAAA,aAPO;AAOP;;AAAA;AAAA;AAAA,aANM;AAMN;;AAAA;AAAA;AAAA,aALC;AAKD;;AAGZ,WAAK,KAAL,GAAa,IAAI,iBAAJ,EAAb;AAHY;AAIb;AAED;;;;;;;iCAGa;AAAA;;AACX;;AACA,2BAAK,KAAL,8DAAY,UAAZ;AACD;AAED;;;;;;;;AA2FA;;;;;;;;;;;;;;6BAcS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,cAAM,KAAK,EADE;AAEb,0BAAkB,KAAK,cAFV;AAGb,6BAAqB,KAAK,iBAHb;AAIb,4BAAoB,KAAK,gBAJZ;AAKb,uBAAe,KAAK,WALP;AAMb,iBAAS,KAAK;AAND,OAAf;AAQA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;wBAjHQ;AACP,mCAAO,IAAP;AACD;AAED;;;;;sBAIO,E,EAAI;AACT,UAAI,oBAAoB,CAAC,EAAD,EAAK,KAAK,CAAC,iBAAX,CAAxB,EAAuD;AACrD,0CAAW,EAAX;AACD;AACF;AAED;;;;;;;wBAIqB;AACnB,mCAAO,IAAP;AACD;AAED;;;;;sBAImB,c,EAAgB;AACjC,UAAI,oBAAoB,CAAC,cAAD,EAAiB,KAAK,CAAC,UAAvB,CAAxB,EAA4D;AAC1D,sDAAuB,cAAvB;AACD;AACF;AAED;;;;;;;wBAIwB;AACtB,mCAAO,IAAP;AACD;AAED;;;;;sBAIsB,iB,EAAmB;AACvC,UAAI,oBAAoB,CAAC,iBAAD,EAAoB,KAAK,CAAC,UAA1B,CAAxB,EAA+D;AAC7D,yDAA0B,iBAA1B;AACD;AACF;AAED;;;;;;;wBAIuB;AACrB,mCAAO,IAAP;AACD;AAED;;;;;sBAIqB,gB,EAAkB;AACrC,UAAI,oBAAoB,CAAC,gBAAD,EAAmB,KAAK,CAAC,UAAzB,CAApB,IACA,mBAAmB,CAAC,gBAAD,EAAmB,KAAK,CAAC,cAAzB,CADvB,EACiE;AAC/D,wDAAyB,gBAAzB;AACD;AACF;AAED;;;;;;;wBAIkB;AAChB,mCAAO,IAAP;AACD;AAED;;;;;sBAIgB,W,EAAa;AAC3B,UAAI,oBAAoB,CAAC,WAAD,EAAc,KAAK,CAAC,gBAApB,EAAsC,IAAtC,CAAxB,EAAqE;AACnE,mDAAoB,WAApB;AACD;AACF;;;;EAjHsC,e;AAgJzC;;;;;;;;;;;;;;;;;IAGM,iB;;;;;AAGJ;;;AAGA,+BAAc;AAAA;;AAAA;;AACZ,4FACI;AACE,MAAA,cAAc,EAAE,SAAS,CAAC,cAD5B;AAEE,MAAA,GAAG,EAAE,EAFP;AAGE,MAAA,gBAAgB,EAAE,mCAAsB,iBAH1C;AAIE,MAAA,eAAe,EAAE,mCAAsB,aAJzC;AAKE,MAAA,gBAAgB,EAAE,mCAAsB,kBAL1C;AAME,MAAA,YAAY,EAAE,uBAAgB;AANhC,KADJ;;AADY;AAAA;AAAA,aALJ;AAKI;;AAAA;AAUb;AAED;;;;;;;;;AAmBA;;;;;;;;;;;;6BAYS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,kBAAU,KAAK,MADF;AAEb,8EAFa;AAGb,8EAHa;AAIb;AAJa,OAAf;AAMA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;wBArCY;AACX,mCAAO,IAAP;AACD;AAED;;;;;sBAIW,M,EAAQ;AACjB,UAAI,oBAAoB,CAAC,MAAD,EAAS,KAAK,CAAC,UAAf,CAApB,IACA,mBAAmB,CAAC,MAAD,EAAS,KAAK,CAAC,YAAf,CADvB,EACqD;AACnD,6CAAe,MAAf;AACD;AACF;;;;EAnC6B,gB;AA8DhC;;;;;;;IAGa,4B;;;;;AAKX;;;AAGA,0CAAc;AAAA;;AAAA;;AACZ;;AADY;AAAA;AAAA,aAPH;AAOG;;AAAA;AAAA;AAAA,aANF;AAME;;AAAA;AAAA;AAAA,aALD;AAKC;;AAEZ,oEAAgB,EAAhB;;AACA,sEAAiB,EAAjB;;AACA,uEAAkB,EAAlB;;AAJY;AAKb;AAED;;;;;;;;;AAsDA;;;;;;;;;;6BAUS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,mBAAW,KAAK,OADH;AAEb,oBAAY,KAAK,QAFJ;AAGb,qBAAa,KAAK;AAHL,OAAf;AAKA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;wBArEa;AACZ,mCAAO,IAAP;AACD;AAED;;;;;sBAIY,O,EAAS;AACnB,UAAI,oBAAoB,CAAC,OAAD,EAAU,KAAK,CAAC,iBAAhB,EAAmC,IAAnC,CAAxB,EAAkE;AAChE,8CAAgB,OAAhB;AACD;AACF;AAED;;;;;;;wBAIe;AACb,mCAAO,IAAP;AACD;AAED;;;;;sBAIa,Q,EAAU;AACrB,UAAI,oBAAoB,CAAC,QAAD,EAAW,KAAK,CAAC,YAAjB,CAAxB,EAAwD;AACtD,gDAAiB,QAAjB;AACD;AACF;AAED;;;;;;;wBAIgB;AACd,mCAAO,IAAP;AACD;AAED;;;;;sBAIc,S,EAAW;AACvB,UAAI,oBAAoB,CAAC,SAAD,EAAY,KAAK,CAAC,OAAlB,CAAxB,EAAoD;AAClD,iDAAkB,SAAlB;AACD;AACF;;;;EAnE+C,e;AA2FlD;;;;;;;;;;;;;IAGa,wB;;;;;AACX;;;AAGA,sCAAc;AAAA;;AAAA;AAEb;AAED;;;;;;;;;AAgDA;;;;;;;;;;6BAUS;AACP;AACD;;;wBAxDa;AACZ;AACD;AAED;;;;;sBAIY,O,EAAS;AACnB,OAAC,KAAK,WAAN,wEAAoC,OAApC,gBAA8C,kBAAkB,EAAhE;AACD;AAED;;;;;;;wBAIe;AACb;AACD;AAED;;;;;sBAIa,Q,EAAU;AACrB,OAAC,KAAK,WAAN,yEAAqC,QAArC,gBAAgD,kBAAkB,EAAlE;AACD;AAED;;;;;;;wBAIgB;AACd;AACD;AAED;;;;;sBAIc,S,EAAW;AACvB,OAAC,KAAK,WAAN,0EAAsC,SAAtC,gBAAkD,kBAAkB,EAApE;AACD;;;;EAtD2C,4B;AAuE9C;;;;;;;IAGa,+B;;;;;AAGX;;;AAGA,6CAAc;AAAA;;AAAA;;AACZ;;AADY;AAAA;AAAA,aALR;AAKQ;;AAAA;AAEb;AAED;;;;;;;;;AAkBA;;;;;;;;6BAQS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,cAAM,KAAK;AADE,OAAf;AAGA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;wBA7BQ;AACP,mCAAO,IAAP;AACD;AAED;;;;;sBAIO,E,EAAI;AACT,UAAI,oBAAoB,CAAC,EAAD,EAAK,KAAK,CAAC,iBAAX,CAAxB,EAAuD;AACrD,0CAAW,EAAX;AACD;AACF;;;;EA1BkD,e;AA8CrD;;;;;;;;;IAGa,qC;;;;;AAGX;;;AAGA,mDAAc;AAAA;;AAAA;;AACZ;;AADY;AAAA;AAAA,aALH;AAKG;;AAAA;AAEb;AAED;;;;;;;;;AAkBA;;;;;;;;6BAQS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,mBAAW,KAAK;AADH,OAAf;AAGA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;wBA7Ba;AACZ,mCAAO,IAAP;AACD;AAED;;;;;sBAIY,O,EAAS;AACnB,UAAI,oBAAoB,CAAC,OAAD,EAAU,KAAK,CAAC,WAAhB,CAAxB,EAAsD;AACpD,8CAAgB,OAAhB;AACD;AACF;;;;EA1BwD,e;AA8C3D;;;;;;;;;IAGa,G;;;;;AACX;;;AAGA,iBAAc;AAAA;;AAAA;;AACZ;AAEA,WAAK,GAAL,GAAW,IAAI,MAAJ,EAAX;AAHY;AAIb;AAED;;;;;;;iCAGa;AAAA;;AACX;;AACA,wBAAK,GAAL,wDAAU,UAAV;AACD;AAED;;;;;;;;;;;;;6BAUS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,eAAO,KAAK;AADC,OAAf;AAGA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;;EAnCsB,e;AAsCzB;;;;;;;IAGM,M;;;;;AAGJ;;;AAGA,oBAAc;AAAA;;AAAA;;AACZ;;AADY;AAAA;AAAA,aALH;AAKG;;AAGZ,YAAK,aAAL,GAAqB,IAAI,kBAAJ,EAArB;AAHY;AAIb;AAED;;;;;;;iCAGa;AAAA;;AACX;;AACA,kCAAK,aAAL,4EAAoB,UAApB;AACD;AAED;;;;;;;;AAkBA;;;;;;;;;6BASS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,mBAAW,KAAK;AADH,OAAf;AAGA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;wBA9Ba;AACZ,mCAAO,IAAP;AACD;AAED;;;;;sBAIY,O,EAAS;AACnB,UAAI,oBAAoB,CAAC,OAAD,EAAU,KAAK,CAAC,QAAhB,CAAxB,EAAmD;AACjD,8CAAgB,OAAhB;AACD;AACF;;;;EApCkB,e;AAyDrB;;;;;;;IAGM,kB;;;;;AAoBJ;;;AAGA,gCAAc;AAAA;;AAAA;;AAAA;;AACZ;;AADY;AAAA;AAAA,aAtBF;AAsBE;;AAAA;AAAA;AAAA,aArBF;AAqBE;;AAAA;AAAA;;AAAA,8CAdK,UAAC,OAAD;AAAA,eAAa,SAAb;AAAA,OAcL;AAAA;;AAAA;AAAA;;AAAA,8CANK,UAAC,OAAD;AAAA,eAAa,SAAb;AAAA,OAML;AAAA;;AAAA;AAEb;AAED;;;;;;;;;AAgCA;;;;;;;;;;6BAUS;AACP,WAAK,UAAL,GAAkB,IAAlB;AACA,UAAM,MAAM,GAAG;AACb,oBAAY,KAAK,QADJ;AAEb,oBAAY;AAFC,OAAf;AAIA,aAAO,KAAK,UAAZ;AACA,aAAO,MAAP;AACD;;;wBA9Cc;AACb,mCAAO,IAAP;AACD;AAED;;;;;sBAIa,C,EAAG;AACd,MAAA,kBAAkB;AACnB;AAED;;;;;;;wBAIe;AACb,mCAAO,IAAP;AACD;AAED;;;;;sBAIa,C,EAAG;AACd,MAAA,kBAAkB;AACnB;;;;EAzD8B,e;;;;;;;;;;;;;;;;;;;;ACpiD1B,IAAM,iBAAiB,GAAG;AAC/B;AACA,EAAA,YAAY,EAAE,gGAFiB;AAG/B,EAAA,aAAa,EAAE,mHAHgB;AAI/B,EAAA,cAAc,EAAE,aAJe;AAK/B,EAAA,iBAAiB,EAAE,uBALY;AAM/B,EAAA,mBAAmB,EAAE,iBANU;AAO/B,EAAA,0BAA0B,EAAE,SAPG;AAQ/B,EAAA,qBAAqB,EAAE,kDARQ;AAS/B,EAAA,2BAA2B,EAAE,2BATE;AAU/B,EAAA,qBAAqB,EAAE,qFAVQ;AAY/B,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;AArCW;AAZW,CAA1B;;;AAwDA,IAAM,cAAc,qBACtB,iBADsB,MACA;AACvB,EAAA,YAAY,EAAE,2GADS;AAEvB,EAAA,qBAAqB,EAAE,uEAFA;AAGvB,EAAA,cAAc,EAAE;AAHO,CADA,CAApB;;;AAQA,IAAM,mBAAmB,GAAG;AACjC;AACA,EAAA,YAAY,EAAE,sTAFmB;AAGjC,EAAA,iBAAiB,EAAE,4BAHc;AAIjC,EAAA,cAAc,EAAE,oBAJiB;AAKjC,EAAA,mBAAmB,EAAE,wEALY;AAMjC,EAAA,0BAA0B,EAAE,SANK;AAOjC,EAAA,qBAAqB,EAAE,kDAPU;AAQjC,EAAA,2BAA2B,EAAE,sDARI;AASjC,EAAA,qBAAqB,EAAE,sGATU;AAWjC,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;AAXa,CAA5B;;;;;;;;;;;;;;;;;AChEA,IAAM,WAAW,GAAG;AACzB,EAAA,OAAO,EAAE,GADgB;AAEzB,EAAA,qBAAqB,EAAE,GAFE;AAGzB,EAAA,WAAW,EAAE,GAHY;AAIzB,EAAA,UAAU,EAAE,GAJa;AAKzB,EAAA,mBAAmB,EAAE,GALI;AAMzB,EAAA,uBAAuB,EAAE,GANA;AAOzB,EAAA,oBAAoB,EAAE,GAPG;AAQzB,EAAA,oBAAoB,EAAE,GARG;AASzB,EAAA,mBAAmB,EAAE,GATI;AAUzB,EAAA,iBAAiB,EAAE,GAVM;AAWzB,EAAA,gBAAgB,EAAE,GAXO;AAYzB,EAAA,kBAAkB,EAAE,GAZK;AAazB,EAAA,iBAAiB,EAAE,GAbM;AAczB,EAAA,cAAc,EAAE,GAdS;AAezB,EAAA,cAAc,EAAE,GAfS;AAgBzB,EAAA,WAAW,EAAE,GAhBY;AAiBzB,EAAA,mBAAmB,EAAE,GAjBI;AAkBzB,EAAA,mBAAmB,EAAE,GAlBI;AAmBzB,EAAA,sBAAsB,EAAE,GAnBC;AAoBzB,EAAA,oBAAoB,EAAE,GApBG;AAqBzB,EAAA,qBAAqB,EAAE,GArBE;AAsBzB,EAAA,qBAAqB,EAAE,GAtBE;AAuBzB,EAAA,iBAAiB,EAAE,GAvBM;AAwBzB,EAAA,iBAAiB,EAAE,GAxBM;AAyBzB,EAAA,kBAAkB,EAAE,GAzBK;AA0BzB,EAAA,aAAa,EAAE,GA1BU;AA2BzB,EAAA,kBAAkB,EAAE,GA3BK;AA4BzB,EAAA,0BAA0B,EAAE;AA5BH,CAApB;;;AA+BA,IAAM,mBAAmB,qBAC3B,WAD2B,MACX;AACjB,EAAA,oBAAoB,EAAE,GADL;AAEjB,EAAA,iBAAiB,EAAE,GAFF;AAGjB,EAAA,kBAAkB,EAAE,GAHH;AAIjB,EAAA,cAAc,EAAE,GAJC;AAKjB,EAAA,cAAc,EAAE,GALC;AAMjB,EAAA,WAAW,EAAE,GANI;AAOjB,EAAA,oBAAoB,EAAE,GAPL;AAQjB,EAAA,qBAAqB,EAAE,GARN;AASjB,EAAA,qBAAqB,EAAE,GATN;AAUjB,EAAA,iBAAiB,EAAE,GAVF;AAWjB,EAAA,iBAAiB,EAAE,GAXF;AAYjB,EAAA,kBAAkB,EAAE,GAZH;AAajB,EAAA,aAAa,EAAE,GAbE;AAcjB,EAAA,kBAAkB,EAAE,GAdH;AAejB,EAAA,0BAA0B,EAAE;AAfX,CADW,CAAzB;;;;AAoBA,IAAM,qBAAqB,qBAC7B,WAD6B,MACb;AACjB,EAAA,qBAAqB,EAAE,GADN;AAEjB,EAAA,WAAW,EAAE,GAFI;AAGjB,EAAA,UAAU,EAAE,GAHK;AAIjB,EAAA,mBAAmB,EAAE,GAJJ;AAKjB,EAAA,uBAAuB,EAAE,GALR;AAMjB,EAAA,qBAAqB,EAAE,GANN;AAOjB,EAAA,oBAAoB,EAAE,GAPL;AAQjB,EAAA,mBAAmB,EAAE,GARJ;AASjB,EAAA,iBAAiB,EAAE,GATF;AAUjB,EAAA,gBAAgB,EAAE,GAVD;AAWjB,EAAA,kBAAkB,EAAE,GAXH;AAYjB,EAAA,iBAAiB,EAAE,GAZF;AAajB,EAAA,cAAc,EAAE,GAbC;AAcjB,EAAA,mBAAmB,EAAE,GAdJ;AAejB,EAAA,mBAAmB,EAAE,GAfJ;AAgBjB,EAAA,sBAAsB,EAAE,GAhBP;AAiBjB,EAAA,oBAAoB,EAAE,GAjBL;AAkBjB,EAAA,qBAAqB,EAAE,GAlBN;AAmBjB,EAAA,qBAAqB,EAAE,GAnBN;AAoBjB,EAAA,iBAAiB,EAAE,GApBF;AAqBjB,EAAA,kBAAkB,EAAE,GArBH;AAsBjB,EAAA,aAAa,EAAE,GAtBE;AAuBjB,EAAA,kBAAkB,EAAE,GAvBH;AAwBjB,EAAA,0BAA0B,EAAE;AAxBX,CADa,CAA3B;;;;;;;;;;;;;;;;;;ACpDP,IAAM,aAAa,GAAG;AACpB,EAAA,WAAW,EAAE,CACX,SADW,EAEX,OAFW,EAGX,eAHW,EAIX,SAJW,CADO;AAOpB,EAAA,aAAa,EAAE,CACb,QADa,EAEb,OAFa,EAGb,SAHa,CAPK;AAapB,EAAA,cAAc,EAAE,CACd,KADc,EAEd,MAFc,EAGd,KAHc,EAId,KAJc,CAbI;AAmBpB,EAAA,gBAAgB,EAAE,CAChB,IADgB,EAEhB,MAFgB,EAGhB,KAHgB,EAIhB,KAJgB,CAnBE;AA0BpB,EAAA,gBAAgB,EAAE,CAChB,GADgB,EAEhB,IAFgB,EAGhB,KAHgB,CA1BE;AA+BpB,EAAA,kBAAkB,EAAE,CAClB,SADkB,EAElB,MAFkB,EAGlB,IAHkB,CA/BA;AAqCpB,EAAA,gBAAgB,EAAE,CAChB,GADgB,EAEhB,KAFgB,EAGhB,GAHgB,EAIhB,MAJgB,EAKhB,IALgB,CArCE;AA4CpB,EAAA,kBAAkB,EAAE,CAClB,MADkB,EAElB,MAFkB,EAGlB,MAHkB,EAIlB,IAJkB,EAKlB,KALkB,CA5CA;AAoDpB,EAAA,uBAAuB,EAAE,CACvB,GADuB,EAEvB,GAFuB,EAGvB,IAHuB,CApDL;AAyDpB,EAAA,yBAAyB,EAAE,CACzB,MADyB,EAEzB,MAFyB,EAGzB,KAHyB,EAIzB,MAJyB,EAKzB,MALyB,EAMzB,IANyB,EAOzB,KAPyB;AAzDP,CAAtB;;AAoEO,IAAM,cAAc,qBACtB,aADsB,MACJ;AACnB,EAAA,iBAAiB,EAAE,CACjB,QADiB,EAEjB,WAFiB,EAGjB,QAHiB,EAIjB,YAJiB,EAKjB,SALiB,CADA;AAQnB,EAAA,mBAAmB,EAAE,CACnB,QADmB,EAEnB,GAFmB,EAGnB,GAHmB,EAInB,GAJmB,EAKnB,MALmB,EAMnB,OANmB,EAOnB,UAPmB,CARF;AAkBnB,EAAA,SAAS,EAAE,CACT,UADS,EAET,SAFS,EAGT,QAHS,CAlBQ;AAuBnB,EAAA,WAAW,EAAE,CACX,OADW,EAEX,MAFW,EAGX,OAHW,CAvBM;AA6BnB,EAAA,SAAS,EAAE,CACT,YADS,EAET,QAFS,EAGT,SAHS,EAIT,UAJS,EAKT,aALS,EAMT,YANS,EAOT,QAPS,EAQT,SARS,CA7BQ;AAuCnB,EAAA,WAAW,EAAE,CACX,SADW,EAEX,OAFW,EAGX,QAHW,CAvCM;AA6CnB,EAAA,eAAe,EAAE,CACf,GADe,EAEf,IAFe,EAGf,KAHe,EAIf,IAJe,EAKf,KALe,EAMf,MANe,CA7CE;AAqDnB,EAAA,iBAAiB,EAAE,CACjB,SADiB,EAEjB,MAFiB,EAGjB,MAHiB,EAIjB,KAJiB,EAKjB,SALiB,EAMjB,QANiB,CArDA;AA8DnB,EAAA,eAAe,EAAE,CACf,GADe,EAEf,OAFe,EAGf,KAHe,CA9DE;AAmEnB,EAAA,iBAAiB,EAAE,CACjB,SADiB,EAEjB,MAFiB,EAGjB,IAHiB,EAIjB,KAJiB,EAKjB,SALiB,EAMjB,QANiB,CAnEA;AA2EnB,EAAA,kBAAkB,EAAE,CAClB,SADkB,EAElB,MAFkB,EAGlB,IAHkB,CA3ED;AAiFnB,EAAA,SAAS,EAAE,CACT,UADS,EAET,UAFS,EAGT,UAHS,CAjFQ;AAsFnB,EAAA,WAAW,EAAE,CACX,UADW,EAEX,aAFW,EAGX,SAHW,EAIX,cAJW,EAKX,eALW,CAtFM;AA8FnB,EAAA,cAAc,EAAE,CACd,UADc,EAEd,aAFc,EAGd,UAHc,EAId,UAJc,CA9FG;AAoGnB,EAAA,gBAAgB,EAAE,CAChB,SADgB,EAEhB,cAFgB,EAGhB,eAHgB;AApGC,CADI,CAApB;;;;AA6GA,IAAM,gBAAgB,qBACxB,aADwB,MACN;AACnB;AACA,EAAA,eAAe,EAAE,CACf,YADe,EAEf,kBAFe,EAGf,wBAHe,EAIf,YAJe,CAFE;AAQnB,EAAA,iBAAiB,EAAE,CACjB,aADiB,EAEjB,yBAFiB,EAGjB,wBAHiB,EAIjB,YAJiB,EAKjB,YALiB,EAMjB,WANiB,EAOjB,SAPiB,EAQjB,WARiB,CARA;AAmBnB,EAAA,YAAY,EAAE,CACZ,WADY,EAEZ,YAFY,EAGZ,eAHY,EAIZ,SAJY,CAnBK;AAyBnB,EAAA,cAAc,EAAE,CACd,UADc,EAEd,QAFc,EAGd,QAHc,CAzBG;AA+BnB,EAAA,YAAY,EAAE,CACZ,QADY,EAEZ,QAFY,EAGZ,SAHY,CA/BK;AAoCnB,EAAA,cAAc,EAAE,CACd,UADc,EAEd,YAFc,EAGd,GAHc,EAId,GAJc,CApCG;AA2CnB,EAAA,SAAS,EAAE,CACT,UADS,EAET,SAFS,EAGT,QAHS,EAIT,QAJS,CA3CQ;AAiDnB,EAAA,WAAW,EAAE,CACX,OADW,EAEX,MAFW,EAGX,OAHW,CAjDM;AAuDnB,EAAA,SAAS,EAAE,CACT,YADS,EAET,QAFS,EAGT,SAHS,EAIT,cAJS,EAKT,UALS,EAMT,aANS,EAOT,YAPS,EAQT,QARS,EAST,SATS,EAUT,OAVS,CAvDQ;AAmEnB,EAAA,WAAW,EAAE,CACX,SADW,EAEX,OAFW,EAGX,QAHW,CAnEM;AAyEnB,EAAA,eAAe,EAAE,CACf,GADe,EAEf,IAFe,EAGf,KAHe,EAIf,QAJe,EAKf,IALe,EAMf,OANe,CAzEE;AAiFnB,EAAA,iBAAiB,EAAE,CACjB,SADiB,EAEjB,MAFiB,EAGjB,SAHiB,EAIjB,QAJiB,CAjFA;AAwFnB,EAAA,qBAAqB,EAAE,CACrB,kBADqB,EAErB,SAFqB,EAGrB,KAHqB,EAIrB,OAJqB,CAxFJ;AA8FnB,EAAA,uBAAuB,EAAE,CACvB,UADuB,EAEvB,MAFuB,EAGvB,OAHuB,EAIvB,GAJuB,CA9FN;AAqGnB,EAAA,YAAY,EAAE,CACZ,8BADY,EAEZ,iCAFY,EAGZ,wBAAwB,IAAI,MAAJ,CAAW,IAAX,CAHZ,EAIZ,iBAJY,EAKZ,kBALY,EAMZ,aANY,EAOZ,UAPY,EAQZ,EARY,CArGK;AA+GnB,EAAA,cAAc,EAAE,CACd,WADc,EAEd,YAFc,EAGd,sCAHc,EAId,kBAJc,EAKd,wBAAwB,IAAI,MAAJ,CAAW,IAAX,CALV,EAMd,yBAAyB,IAAI,MAAJ,CAAW,IAAX,CANX,CA/GG;AAwHnB,EAAA,gBAAgB,EAAE,CAChB,8BADgB,EAEhB,iCAFgB,EAGhB,wBAAwB,IAAI,MAAJ,CAAW,GAAX,CAHR,EAIhB,iBAJgB,EAKhB,kBALgB,EAMhB,aANgB,EAOhB,UAPgB,EAQhB,EARgB,CAxHC;AAkInB,EAAA,kBAAkB,EAAE,CAClB,WADkB,EAElB,YAFkB,EAGlB,sCAHkB,EAIlB,kBAJkB,EAKlB,wBAAwB,IAAI,MAAJ,CAAW,GAAX,CALN,EAMlB,yBAAyB,IAAI,MAAJ,CAAW,GAAX,CANP,CAlID;AA2InB,EAAA,eAAe,EAAE,CACf,UADe,EAEf,UAFe,EAGf,MAHe,EAIf,SAJe,EAKf,SALe,EAMf,YANe,EAOf,YAPe,CA3IE;AAoJnB,EAAA,iBAAiB,EAAE,CACjB,OADiB,EAEjB,MAFiB,EAGjB,MAHiB,EAIjB,QAJiB;AApJA,CADM,CAAtB;;;;;;;;;;;ACjLA,IAAM,eAAe,GAAG;AAC7B,QAAM,IADuB;AACjB,QAAM,IADW;AACL,QAAM,IADD;AACO,QAAM,IADb;AACmB,QAAM,IADzB;AAC+B,QAAM,IADrC;AAE7B,QAAM,IAFuB;AAEjB,QAAM,IAFW;AAEL,QAAM,IAFD;AAEO,QAAM,IAFb;AAEmB,QAAM,IAFzB;AAE+B,QAAM,IAFrC;AAG7B,QAAM,IAHuB;AAGjB,QAAM,IAHW;AAGL,QAAM,IAHD;AAGO,QAAM,IAHb;AAGmB,QAAM,IAHzB;AAG+B,QAAM,IAHrC;AAI7B,QAAM,IAJuB;AAIjB,QAAM,IAJW;AAIL,QAAM,IAJD;AAIO,QAAM,IAJb;AAImB,QAAM,IAJzB;AAI+B,QAAM,IAJrC;AAK7B,QAAM,IALuB;AAKjB,QAAM,IALW;AAKL,QAAM,IALD;AAKO,QAAM,IALb;AAKmB,QAAM,IALzB;AAK+B,QAAM,IALrC;AAM7B,QAAM,IANuB;AAMjB,QAAM,IANW;AAML,QAAM,IAND;AAMO,QAAM,IANb;AAMmB,QAAM,IANzB;AAM+B,QAAM,IANrC;AAO7B,QAAM,IAPuB;AAOjB,QAAM,IAPW;AAOL,QAAM,IAPD;AAOO,QAAM,IAPb;AAOmB,QAAM,IAPzB;AAO+B,QAAM,IAPrC;AAQ7B,QAAM,IARuB;AAQjB,QAAM,IARW;AAQL,QAAM,IARD;AAQO,QAAM,IARb;AAQmB,QAAM,IARzB;AAQ+B,QAAM,IARrC;AAS7B,QAAM,IATuB;AASjB,QAAM,IATW;AASL,QAAM,IATD;AASO,QAAM,IATb;AASmB,QAAM,IATzB;AAS+B,QAAM,IATrC;AAU7B,QAAM,IAVuB;AAUjB,QAAM,IAVW;AAUL,QAAM,IAVD;AAUO,QAAM,IAVb;AAUmB,QAAM,IAVzB;AAU+B,QAAM,IAVrC;AAW7B,QAAM,IAXuB;AAWjB,QAAM,IAXW;AAWL,QAAM,IAXD;AAWO,QAAM,IAXb;AAWmB,QAAM,IAXzB;AAW+B,QAAM,IAXrC;AAY7B,QAAM,IAZuB;AAYjB,QAAM,IAZW;AAYL,QAAM,IAZD;AAYO,QAAM,IAZb;AAYmB,QAAM,IAZzB;AAY+B,QAAM,IAZrC;AAa7B,QAAM,IAbuB;AAajB,QAAM,IAbW;AAaL,QAAM,IAbD;AAaO,QAAM,IAbb;AAamB,QAAM,IAbzB;AAa+B,QAAM,IAbrC;AAc7B,QAAM,IAduB;AAcjB,QAAM,IAdW;AAcL,QAAM,IAdD;AAcO,QAAM,IAdb;AAcmB,QAAM,IAdzB;AAc+B,QAAM,IAdrC;AAe7B,QAAM,IAfuB;AAejB,QAAM,IAfW;AAeL,QAAM,IAfD;AAeO,QAAM,IAfb;AAemB,QAAM,IAfzB;AAe+B,QAAM,IAfrC;AAgB7B,QAAM,IAhBuB;AAgBjB,QAAM,IAhBW;AAgBL,QAAM,IAhBD;AAgBO,QAAM,IAhBb;AAgBmB,QAAM,IAhBzB;AAgB+B,QAAM,IAhBrC;AAiB7B,QAAM,IAjBuB;AAiBjB,QAAM,IAjBW;AAiBL,QAAM,IAjBD;AAiBO,QAAM,IAjBb;AAiBmB,QAAM,IAjBzB;AAiB+B,QAAM,IAjBrC;AAkB7B,QAAM,IAlBuB;AAkBjB,QAAM,IAlBW;AAkBL,QAAM,IAlBD;AAkBO,QAAM,IAlBb;AAkBmB,QAAM,IAlBzB;AAkB+B,QAAM,IAlBrC;AAmB7B,QAAM,IAnBuB;AAmBjB,QAAM,IAnBW;AAmBL,QAAM,IAnBD;AAmBO,QAAM,IAnBb;AAmBmB,QAAM,IAnBzB;AAmB+B,QAAM,IAnBrC;AAoB7B,QAAM,IApBuB;AAoBjB,QAAM,IApBW;AAoBL,QAAM,IApBD;AAoBO,QAAM,IApBb;AAoBmB,QAAM,IApBzB;AAoB+B,QAAM,IApBrC;AAqB7B,QAAM,IArBuB;AAqBjB,QAAM,IArBW;AAqBL,QAAM,IArBD;AAqBO,QAAM,IArBb;AAqBmB,QAAM,IArBzB;AAqB+B,QAAM,IArBrC;AAsB7B,QAAM,IAtBuB;AAsBjB,QAAM,IAtBW;AAsBL,QAAM,IAtBD;AAsBO,QAAM,IAtBb;AAsBmB,QAAM,IAtBzB;AAsB+B,QAAM,IAtBrC;AAuB7B,QAAM,IAvBuB;AAuBjB,QAAM,IAvBW;AAuBL,QAAM,IAvBD;AAuBO,QAAM,IAvBb;AAuBmB,QAAM,IAvBzB;AAuB+B,QAAM,IAvBrC;AAwB7B,QAAM,IAxBuB;AAwBjB,QAAM,IAxBW;AAwBL,QAAM,IAxBD;AAwBO,QAAM,IAxBb;AAwBmB,QAAM,IAxBzB;AAwB+B,QAAM,IAxBrC;AAyB7B,QAAM,IAzBuB;AAyBjB,QAAM,IAzBW;AAyBL,QAAM,IAzBD;AAyBO,QAAM,IAzBb;AAyBmB,QAAM,IAzBzB;AAyB+B,QAAM,IAzBrC;AA0B7B,QAAM,IA1BuB;AA0BjB,QAAM,IA1BW;AA0BL,QAAM,IA1BD;AA0BO,QAAM,IA1Bb;AA0BmB,QAAM,IA1BzB;AA0B+B,QAAM,IA1BrC;AA2B7B,QAAM,IA3BuB;AA2BjB,QAAM,IA3BW;AA2BL,QAAM,IA3BD;AA2BO,QAAM,IA3Bb;AA2BmB,QAAM,IA3BzB;AA2B+B,QAAM,IA3BrC;AA4B7B,QAAM,IA5BuB;AA4BjB,QAAM,IA5BW;AA4BL,QAAM,IA5BD;AA4BO,QAAM,IA5Bb;AA4BmB,QAAM,IA5BzB;AA4B+B,QAAM,IA5BrC;AA6B7B,QAAM,IA7BuB;AA6BjB,QAAM,IA7BW;AA6BL,QAAM,IA7BD;AA6BO,QAAM,IA7Bb;AA6BmB,QAAM,IA7BzB;AA6B+B,QAAM,IA7BrC;AA8B7B,QAAM,IA9BuB;AA8BjB,QAAM,IA9BW;AA8BL,QAAM,IA9BD;AA8BO,QAAM,IA9Bb;AA8BmB,QAAM,IA9BzB;AA8B+B,QAAM,IA9BrC;AA+B7B,QAAM,IA/BuB;AA+BjB,QAAM,IA/BW;AA+BL,QAAM,IA/BD;AA+BO,QAAM,IA/Bb;AA+BmB,QAAM,IA/BzB;AA+B+B,QAAM,IA/BrC;AAgC7B,SAAO,KAhCsB;AAgCf,SAAO,KAhCQ;AAgCD,SAAO,KAhCN;AAgCa,SAAO,KAhCpB;AAgC2B,SAAO,KAhClC;AAiC7B,SAAO,KAjCsB;AAiCf,SAAO,KAjCQ;AAiCD,SAAO,KAjCN;AAiCa,SAAO,KAjCpB;AAiC2B,SAAO,KAjClC;AAkC7B,SAAO,KAlCsB;AAkCf,SAAO,KAlCQ;AAkCD,SAAO,KAlCN;AAkCa,SAAO,KAlCpB;AAkC2B,SAAO,KAlClC;AAmC7B,SAAO,KAnCsB;AAmCf,SAAO,KAnCQ;AAmCD,SAAO,KAnCN;AAmCa,SAAO,KAnCpB;AAmC2B,SAAO,KAnClC;AAoC7B,SAAO,KApCsB;AAoCf,SAAO,KApCQ;AAoCD,SAAO,KApCN;AAoCa,SAAO,KApCpB;AAoC2B,SAAO,KApClC;AAqC7B,SAAO,KArCsB;AAqCf,SAAO,KArCQ;AAqCD,SAAO,KArCN;AAqCa,SAAO,KArCpB;AAqC2B,SAAO,KArClC;AAsC7B,SAAO,KAtCsB;AAsCf,SAAO,KAtCQ;AAsCD,SAAO,KAtCN;AAsCa,SAAO,KAtCpB;AAsC2B,SAAO,KAtClC;AAuC7B,SAAO,KAvCsB;AAuCf,SAAO,KAvCQ;AAuCD,SAAO,KAvCN;AAuCa,SAAO,KAvCpB;AAuC2B,SAAO,KAvClC;AAwC7B,SAAO,KAxCsB;AAwCf,SAAO,KAxCQ;AAwCD,SAAO,KAxCN;AAwCa,SAAO,KAxCpB;AAwC2B,SAAO,KAxClC;AAyC7B,SAAO,KAzCsB;AAyCf,SAAO,KAzCQ;AAyCD,SAAO,KAzCN;AAyCa,SAAO,KAzCpB;AAyC2B,SAAO,KAzClC;AA0C7B,SAAO,KA1CsB;AA0Cf,SAAO,KA1CQ;AA0CD,SAAO,KA1CN;AA0Ca,SAAO,KA1CpB;AA0C2B,SAAO,KA1ClC;AA2C7B,SAAO,KA3CsB;AA2Cf,SAAO,KA3CQ;AA2CD,SAAO,KA3CN;AA2Ca,SAAO,KA3CpB;AA2C2B,SAAO,KA3ClC;AA4C7B,SAAO,KA5CsB;AA4Cf,SAAO,KA5CQ;AA4CD,SAAO,KA5CN;AA4Ca,SAAO,KA5CpB;AA4C2B,SAAO,KA5ClC;AA6C7B,SAAO,KA7CsB;AA6Cf,SAAO,KA7CQ;AA6CD,SAAO,KA7CN;AA6Ca,SAAO,KA7CpB;AA6C2B,SAAO,KA7ClC;AA8C7B,SAAO,KA9CsB;AA8Cf,SAAO,KA9CQ;AA8CD,SAAO,KA9CN;AA8Ca,SAAO,KA9CpB;AA8C2B,SAAO,KA9ClC;AA+C7B,SAAO,KA/CsB;AA+Cf,SAAO,KA/CQ;AA+CD,SAAO,KA/CN;AA+Ca,SAAO,KA/CpB;AA+C2B,SAAO,KA/ClC;AAgD7B,SAAO,KAhDsB;AAgDf,SAAO,KAhDQ;AAgDD,SAAO,KAhDN;AAgDa,SAAO,KAhDpB;AAgD2B,SAAO,KAhDlC;AAiD7B,SAAO,KAjDsB;AAiDf,SAAO,KAjDQ;AAiDD,SAAO,KAjDN;AAiDa,SAAO,KAjDpB;AAiD2B,SAAO,KAjDlC;AAkD7B,SAAO,KAlDsB;AAkDf,SAAO,KAlDQ;AAkDD,SAAO,KAlDN;AAkDa,SAAO,KAlDpB;AAkD2B,SAAO,KAlDlC;AAmD7B,SAAO,KAnDsB;AAmDf,SAAO,KAnDQ;AAmDD,SAAO,KAnDN;AAmDa,SAAO,KAnDpB;AAmD2B,SAAO,KAnDlC;AAoD7B,SAAO,KApDsB;AAoDf,SAAO,KApDQ;AAoDD,SAAO,KApDN;AAoDa,SAAO,KApDpB;AAoD2B,SAAO,KApDlC;AAqD7B,SAAO,KArDsB;AAqDf,SAAO,KArDQ;AAqDD,SAAO,KArDN;AAqDa,SAAO,KArDpB;AAqD2B,SAAO,KArDlC;AAsD7B,SAAO,KAtDsB;AAsDf,SAAO,KAtDQ;AAsDD,SAAO,KAtDN;AAsDa,SAAO,KAtDpB;AAsD2B,SAAO,KAtDlC;AAuD7B,SAAO,KAvDsB;AAuDf,SAAO,KAvDQ;AAuDD,SAAO,KAvDN;AAuDa,SAAO,KAvDpB;AAuD2B,SAAO,KAvDlC;AAwD7B,SAAO,KAxDsB;AAwDf,SAAO,KAxDQ;AAwDD,SAAO,KAxDN;AAwDa,SAAO,KAxDpB;AAwD2B,SAAO,KAxDlC;AAyD7B,SAAO,KAzDsB;AAyDf,SAAO,KAzDQ;AAyDD,SAAO,KAzDN;AAyDa,SAAO,KAzDpB;AAyD2B,SAAO,KAzDlC;AA0D7B,SAAO,KA1DsB;AA0Df,SAAO,KA1DQ;AA0DD,SAAO,KA1DN;AA0Da,SAAO,KA1DpB;AA0D2B,SAAO,KA1DlC;AA2D7B,SAAO,KA3DsB;AA2Df,SAAO,KA3DQ;AA2DD,SAAO,KA3DN;AA2Da,SAAO,KA3DpB;AA2D2B,SAAO,KA3DlC;AA4D7B,SAAO,KA5DsB;AA4Df,SAAO,KA5DQ;AA4DD,SAAO,KA5DN;AA4Da,SAAO,KA5DpB;AA4D2B,SAAO,KA5DlC;AA6D7B,SAAO,KA7DsB;AA6Df,SAAO,KA7DQ;AA6DD,SAAO,KA7DN;AA6Da,SAAO,KA7DpB;AA6D2B,SAAO,KA7DlC;AA8D7B,SAAO,KA9DsB;AA8Df,SAAO,KA9DQ;AA8DD,SAAO,KA9DN;AA8Da,SAAO,KA9DpB;AA8D2B,SAAO,KA9DlC;AA+D7B,SAAO,KA/DsB;AA+Df,SAAO,KA/DQ;AA+DD,SAAO,KA/DN;AA+Da,SAAO,KA/DpB;AA+D2B,SAAO,KA/DlC;AAgE7B,SAAO,KAhEsB;AAgEf,SAAO,KAhEQ;AAgED,SAAO,KAhEN;AAgEa,SAAO,KAhEpB;AAgE2B,SAAO,KAhElC;AAiE7B,SAAO,KAjEsB;AAiEf,SAAO,KAjEQ;AAiED,SAAO,KAjEN;AAiEa,SAAO,KAjEpB;AAiE2B,SAAO,KAjElC;AAkE7B,SAAO,KAlEsB;AAkEf,SAAO,KAlEQ;AAkED,SAAO,KAlEN;AAkEa,SAAO,KAlEpB;AAkE2B,SAAO,KAlElC;AAmE7B,SAAO,KAnEsB;AAmEf,SAAO,KAnEQ;AAmED,SAAO,KAnEN;AAmEa,SAAO,KAnEpB;AAmE2B,SAAO,KAnElC;AAoE7B,SAAO,KApEsB;AAoEf,SAAO,KApEQ;AAoED,SAAO,KApEN;AAoEa,SAAO,KApEpB;AAoE2B,SAAO,KApElC;AAqE7B,SAAO,KArEsB;AAqEf,SAAO,KArEQ;AAqED,SAAO,KArEN;AAqEa,SAAO,KArEpB;AAqE2B,SAAO,KArElC;AAsE7B,SAAO,KAtEsB;AAsEf,SAAO,KAtEQ;AAsED,SAAO,KAtEN;AAsEa,SAAO,KAtEpB;AAsE2B,SAAO,KAtElC;AAuE7B,SAAO,KAvEsB;AAuEf,SAAO,KAvEQ;AAuED,SAAO,KAvEN;AAuEa,SAAO,KAvEpB;AAuE2B,SAAO,KAvElC;AAwE7B,SAAO,KAxEsB;AAwEf,SAAO,KAxEQ;AAwED,SAAO,KAxEN;AAwEa,SAAO,KAxEpB;AAwE2B,SAAO;AAxElC,CAAxB;;;;;;;;;;;ACEP;;;;;;;;AAEO,IAAM,aAAa,GAAG;AAC3B,EAAA,YAAY,EAAE,YADa;AAE3B,EAAA,aAAa,EAAE,aAFY;AAG3B,EAAA,OAAO,EAAE,uDAHkB;AAGuC;AAClE,EAAA,WAAW,EAAE,oDAJc;AAIwC;AACnE,EAAA,UAAU,EAAE,QALe;AAM3B,EAAA,WAAW,EAAE,cANc;AAO3B,EAAA,UAAU,EAAE,6BAPe;AAOgB;AAC3C,EAAA,aAAa,EAAE,4BARY;AAS3B,EAAA,WAAW,EAAE,YATc;AASA;AAC3B,EAAA,QAAQ,EAAE,aAViB;AAY3B;AACA,EAAA,SAAS,EAAE,OAAO,6BAAe,iBAAf,CAAiC,IAAjC,CAAsC,GAAtC,CAAP,GAAoD,IAbpC;AAc3B,EAAA,UAAU,EAAE,OAAO,6BAAe,iBAAf,CAAiC,IAAjC,CAAsC,GAAtC,CAAP,GAAoD,kBAdrC;AAe3B,EAAA,OAAO,EAAE,OAAO,6BAAe,SAAf,CAAyB,IAAzB,CAA8B,GAA9B,CAAP,GAA4C,KAf1B;AAgB3B,EAAA,OAAO,EAAE,OAAO,6BAAe,SAAf,CAAyB,IAAzB,CAA8B,GAA9B,CAAP,GAA4C,IAhB1B;AAiB3B,EAAA,SAAS,EAAE,OAAO,6BAAe,WAAf,CAA2B,IAA3B,CAAgC,GAAhC,CAAP,GAA8C,8BAjB9B;AAiB8D;AACzF,EAAA,QAAQ,EAAE,uBAlBiB;AAoB3B;AACA,EAAA,WAAW,EAAE,OArBc;AAsB3B,EAAA,WAAW,EAAE,QAtBc;AAuB3B,EAAA,WAAW,EAAE,UAvBc;AAwB3B,EAAA,eAAe,EAAE,UAxBU;AAyB3B,EAAA,UAAU,EAAE;AAzBe,CAAtB;;;AA4BA,IAAM,UAAU,qBAClB,aADkB,MACA;AACnB,EAAA,aAAa,EAAE;AADI,CADA,CAAhB;;;AAMA,IAAM,eAAe,GAAG;AAC7B,EAAA,YAAY,EAAE,4BADe;AAE7B,EAAA,YAAY,EAAE,4BAFe;AAG7B,EAAA,aAAa,EAAE,6BAHc;AAI7B,EAAA,aAAa,EAAE,6BAJc;AAK7B,EAAA,cAAc,EAAE,8BALa;AAM7B,EAAA,OAAO,EAAE,iDANoB;AAM+B;AAC5D,EAAA,gBAAgB,EAAE,+EAPW;AAOsE;AACnG,EAAA,SAAS,EAAE,iEARkB;AAQiD;AAC9E,EAAA,kBAAkB,EAAE,yEATS;AASkE;AAC/F,EAAA,iBAAiB,EAAE,gFAVU;AAUwE;AACrG,EAAA,OAAO,EAAE,0RAXoB;AAY7B,EAAA,WAAW,EAAE,4HAZgB;AAa7B,EAAA,UAAU,EAAE,QAbiB;AAc7B,EAAA,WAAW,EAAE,cAdgB;AAe7B,EAAA,UAAU,EAAE,mCAfiB;AAgB7B,EAAA,aAAa,EAAE,yBAhBc;AAiB7B,EAAA,kBAAkB,EAAE,kBAjBS;AAiBW;AACxC,EAAA,iBAAiB,EAAE,8DAlBU;AAmB7B,EAAA,WAAW,EAAE,MAnBgB;AAmBR;AACrB,EAAA,QAAQ,EAAE,aApBmB;AAqB7B,EAAA,aAAa,EAAE,WArBc;AAuB7B;AACA,EAAA,UAAU,EAAE,OAAO,+BAAiB,YAAjB,CAA8B,IAA9B,CAAmC,GAAnC,CAAP,GAAiD,IAxBhC;AAyB7B,EAAA,UAAU,EAAE,OAAO,+BAAiB,YAAjB,CAA8B,IAA9B,CAAmC,GAAnC,CAAP,GAAiD,IAzBhC;AA0B7B,EAAA,OAAO,EAAE,OAAO,+BAAiB,SAAjB,CAA2B,IAA3B,CAAgC,GAAhC,CAAP,GAA8C,IA1B1B;AA2B7B,EAAA,OAAO,EAAE,OAAO,+BAAiB,SAAjB,CAA2B,IAA3B,CAAgC,GAAhC,CAAP,GAA8C,IA3B1B;AA4B7B,EAAA,SAAS,EAAE,OAAO,+BAAiB,WAAjB,CAA6B,IAA7B,CAAkC,GAAlC,CAAP,GAAgD,oCA5B9B;AA6B7B,EAAA,QAAQ,EAAE,OAAO,+BAAiB,eAAjB,CAAiC,IAAjC,CAAsC,GAAtC,CAAP,GAAoD,gDA7BjC;AA6BmF;AAChH,EAAA,UAAU,EAAE,wBA9BiB;AA+B7B,EAAA,SAAS,EAAE,6DA/BkB;AAiC7B;AACA,EAAA,YAAY,EAAE,MAlCe;AAmC7B,EAAA,WAAW,EAAE,KAnCgB;AAoC7B,EAAA,WAAW,EAAE,KApCgB;AAqC7B,EAAA,UAAU,EAAE,MArCiB;AAsC7B,EAAA,cAAc,EAAE;AAtCa,CAAxB;;;;;;;;;;;ACrCP;;AAEO,IAAM,iBAAiB,GAAG;AAC/B,gBAAc;AACZ,IAAA,MAAM,EAAE,gBADI;AAEZ,IAAA,GAAG,EAAE,CAFO;AAGZ,IAAA,SAAS,EAAE,EAHC;AAIZ,IAAA,MAAM,EAAE;AAJI,GADiB;AAO/B,YAAU;AACR,IAAA,MAAM,EAAE,uBAAgB,kBADhB;AAER,IAAA,GAAG,EAAE,EAFG;AAGR,IAAA,SAAS,EAAE,KAHH;AAIR,IAAA,MAAM,EAAE;AAJA,GAPqB;AAa/B,aAAW;AACT,IAAA,MAAM,EAAE,uBAAgB,gBADf;AAET,IAAA,GAAG,EAAE,EAFI;AAGT,IAAA,SAAS,EAAE,KAHF;AAIT,IAAA,MAAM,EAAE;AAJC,GAboB;AAmB/B,kBAAgB;AACd,IAAA,MAAM,EAAE,uBAAgB,iBADV;AAEd,IAAA,GAAG,EAAE,CAFS;AAGd,IAAA,SAAS,EAAE,EAHG;AAId,IAAA,MAAM,EAAE;AAJM,GAnBe;AAyB/B,cAAY;AACV,IAAA,MAAM,EAAE,uBAAgB,kBADd;AAEV,IAAA,OAAO,EAAE,uBAAgB,kBAFf;AAGV,IAAA,GAAG,EAAE,EAHK;AAIV,IAAA,SAAS,EAAE,KAJD;AAKV,IAAA,UAAU,EAAE,KALF;AAMV,IAAA,MAAM,EAAE;AANE,GAzBmB;AAiC/B,iBAAe;AACb,IAAA,MAAM,EAAE,QAAQ,uBAAgB,kBADnB;AAEb,IAAA,OAAO,EAAE,uBAAgB,UAAhB,GAA6B,MAA7B,GACL,uBAAgB,kBAHP;AAIb,IAAA,GAAG,EAAE,GAJQ;AAKb,IAAA,SAAS,EAAE,KALE;AAMb,IAAA,UAAU,EAAE,KANC;AAOb,IAAA,MAAM,EAAE;AAPK,GAjCgB;AA0C/B,gBAAc;AACZ,IAAA,MAAM,EAAE,uBAAgB,kBADZ;AAEZ,IAAA,GAAG,EAAE,EAFO;AAGZ,IAAA,SAAS,EAAE,KAHC;AAIZ,IAAA,MAAM,EAAE;AAJI,GA1CiB;AAgD/B,YAAU;AACR,IAAA,MAAM,EAAE,uBAAgB,kBADhB;AAER,IAAA,GAAG,EAAE,CAFG;AAGR,IAAA,SAAS,EAAE,EAHH;AAIR,IAAA,MAAM,EAAE;AAJA,GAhDqB;AAsD/B,aAAW;AACT,IAAA,MAAM,EAAE,uBAAgB,UADf;AAET,IAAA,GAAG,EAAE,CAFI;AAGT,IAAA,SAAS,EAAE,EAHF;AAIT,IAAA,MAAM,EAAE;AAJC,GAtDoB;AA4D/B,WAAS;AACP,IAAA,MAAM,EAAE,uBAAgB,aADjB;AAEP,IAAA,GAAG,EAAE,CAFE;AAGP,IAAA,SAAS,EAAE,EAHJ;AAIP,IAAA,MAAM,EAAE;AAJD;AA5DsB,CAA1B;;AAoEA,IAAM,iBAAiB,GAAG;AAC/B,gBAAc;AACZ,IAAA,GAAG,EAAE,CADO;AAEZ,IAAA,SAAS,EAAE,EAFC;AAGZ,IAAA,MAAM,EAAE,KAHI;AAIZ,IAAA,SAAS,EAAE,KAJC;AAKZ,IAAA,MAAM,EAAE,gBALI;AAMZ,IAAA,KAAK,EAAE;AANK,GADiB;AAS/B,YAAU;AACR,IAAA,GAAG,EAAE,EADG;AAER,IAAA,SAAS,EAAE,KAFH;AAGR,IAAA,MAAM,EAAE,IAHA;AAIR,IAAA,SAAS,EAAE,KAJH;AAKR,IAAA,MAAM,EAAE,uBAAgB;AALhB,GATqB;AAgB/B,aAAW;AACT,IAAA,GAAG,EAAE,EADI;AAET,IAAA,SAAS,EAAE,KAFF;AAGT,IAAA,MAAM,EAAE,KAHC;AAIT,IAAA,SAAS,EAAE,KAJF;AAKT,IAAA,MAAM,EAAE,uBAAgB;AALf,GAhBoB;AAuB/B,kBAAgB;AACd,IAAA,GAAG,EAAE,CADS;AAEd,IAAA,SAAS,EAAE,EAFG;AAGd,IAAA,MAAM,EAAE,KAHM;AAId,IAAA,SAAS,EAAE,IAJG;AAKd,IAAA,MAAM,EAAE,uBAAgB;AALV,GAvBe;AA8B/B,cAAY;AACV,IAAA,GAAG,EAAE,EADK;AAEV,IAAA,SAAS,EAAE,KAFD;AAGV,IAAA,UAAU,EAAE,KAHF;AAIV,IAAA,MAAM,EAAE,KAJE;AAKV,IAAA,SAAS,EAAE,KALD;AAMV,IAAA,MAAM,EAAE,uBAAgB,kBANd;AAOV,IAAA,OAAO,EAAE,uBAAgB;AAPf,GA9BmB;AAuC/B,iBAAe;AACb,IAAA,GAAG,EAAE,GADQ;AAEb,IAAA,SAAS,EAAE,KAFE;AAGb,IAAA,UAAU,EAAE,KAHC;AAIb,IAAA,MAAM,EAAE,KAJK;AAKb,IAAA,SAAS,EAAE,KALE;AAMb,IAAA,MAAM,EAAE,QAAQ,uBAAgB,kBANnB;AAOb,IAAA,OAAO,EAAE,uBAAgB,UAAhB,GAA6B,MAA7B,GACL,uBAAgB;AARP,GAvCgB;AAiD/B,gBAAc;AACZ,IAAA,GAAG,EAAE,EADO;AAEZ,IAAA,SAAS,EAAE,KAFC;AAGZ,IAAA,MAAM,EAAE,KAHI;AAIZ,IAAA,SAAS,EAAE,KAJC;AAKZ,IAAA,MAAM,EAAE,uBAAgB;AALZ,GAjDiB;AAwD/B,YAAU;AACR,IAAA,GAAG,EAAE,CADG;AAER,IAAA,SAAS,EAAE,EAFH;AAGR,IAAA,MAAM,EAAE,KAHA;AAIR,IAAA,SAAS,EAAE,KAJH;AAKR,IAAA,MAAM,EAAE,uBAAgB,kBALhB;AAMR,IAAA,KAAK,EAAE;AANC,GAxDqB;AAgE/B,aAAW;AACT,IAAA,GAAG,EAAE,CADI;AAET,IAAA,SAAS,EAAE,KAFF;AAGT,IAAA,MAAM,EAAE,KAHC;AAIT,IAAA,SAAS,EAAE,KAJF;AAKT,IAAA,MAAM,EAAE,uBAAgB,UALf;AAMT,IAAA,KAAK,EAAE;AANE,GAhEoB;AAwE/B,WAAS;AACP,IAAA,GAAG,EAAE,CADE;AAEP,IAAA,SAAS,EAAE,EAFJ;AAGP,IAAA,MAAM,EAAE,KAHD;AAIP,IAAA,SAAS,EAAE,KAJJ;AAKP,IAAA,MAAM,EAAE,uBAAgB,aALjB;AAMP,IAAA,KAAK,EAAE;AANA;AAxEsB,CAA1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACrEP;;;IAGa,e;;;;;AACX;;;;AAIA,2BAAY,SAAZ,EAA+B;AAAA;;AAAA;;AAC7B,yFAAM,SAAN;;AAD6B;AAAA;AAAA;AAAA;;AAE7B,qEAAkB,SAAlB;;AAF6B;AAG9B;;;;;AAID;;;;wBAIgB;AACd,mCAAO,IAAP;AACD;AAED;;;;;;;wBAIc;AACZ,aAAO,0CAAkB,EAAzB;AACD;;;;mBA1BkC,K;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACJ9B,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;;;;;;;AAMO,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,KAAwB,YAAY,GAAG,GAAvD;AAEA,SAAO,KAAK,CAAC,QAAN,GAAiB,QAAjB,CAA0B,CAA1B,EAA6B,GAA7B,IAAoC,GAApC,GACH,OAAO,CAAC,QAAR,GAAmB,QAAnB,CAA4B,CAA5B,EAA+B,GAA/B,CADG,GACmC,GADnC,GAEH,OAAO,CAAC,QAAR,GAAmB,QAAnB,CAA4B,CAA5B,EAA+B,GAA/B,CAFJ;AAGD;AAED;;;;;;;;AAMO,SAAS,uBAAT,CAAiC,OAAjC,EAAkD;AACvD;AACA,MAAI,CAAC,OAAD,IAAY,OAAO,IAAI,CAA3B,EAA8B;AAC5B,WAAO,KAAP;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,CAHgD,CAIhD;AACA;;AACA,QAAI,IAAI,KAAK,GAAT,IAAgB,SAAS,GAAG,CAAhC,EAAmC;AACjC,MAAA,KAAK,IAAI,SAAT;AACD;;AAED,QAAI,KAAJ,EAAW;AACT,MAAA,QAAQ,cAAO,KAAP,SAAe,IAAf,CAAR;AACD;AACF,GAbD;AAeA,SAAO,QAAP;AACD;AAED;;;;;;;;;AAOO,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;;;;;;;;;AAOO,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;;AAH2E,cAKjB,IAAI,MAAJ,CACvD,aADuD,EACxC,IADwC,CACnC,QADmC,KACtB,EANuC;AAAA;AAAA,MAKnE,KALmE;AAAA,MAK5D,MAL4D;AAAA,MAKlD,IALkD;AAAA,MAK5C,KAL4C;AAAA,MAKrC,OALqC;AAAA,MAK5B,OAL4B;;AAQ5E,MAAM,GAAG,GAAG,IAAI,IAAJ,EAAZ;AACA,MAAM,MAAM,GAAG,IAAI,IAAJ,CAAS,GAAT,CAAf;AACA,EAAA,MAAM,CAAC,WAAP,CAAmB,MAAM,CAAC,WAAP,KAAuB,MAAM,CAAC,KAAK,IAAI,CAAV,CAAhD;AACA,EAAA,MAAM,CAAC,QAAP,CAAgB,MAAM,CAAC,QAAP,KAAoB,MAAM,CAAC,MAAM,IAAI,CAAX,CAA1C;AACA,EAAA,MAAM,CAAC,OAAP,CAAe,MAAM,CAAC,OAAP,KAAmB,MAAM,CAAC,IAAI,IAAI,CAAT,CAAxC;AACA,EAAA,MAAM,CAAC,QAAP,CAAgB,MAAM,CAAC,QAAP,KAAoB,MAAM,CAAC,KAAK,IAAI,CAAV,CAA1C;AACA,EAAA,MAAM,CAAC,UAAP,CAAkB,MAAM,CAAC,UAAP,KAAsB,MAAM,CAAC,OAAO,IAAI,CAAZ,CAA9C;AACA,EAAA,MAAM,CAAC,UAAP,CAAkB,MAAM,CAAC,UAAP,KAAsB,MAAM,CAAC,OAAO,IAAI,CAAZ,CAA9C;;AACA,MAAI,OAAO,IAAI,MAAM,CAAC,OAAD,CAAN,CAAgB,OAAhB,CAAwB,GAAxB,IAA+B,CAA9C,EAAiD;AAC/C,QAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,OAAD,CAAN,GAAkB,CAAnB,CAAN,CAA4B,OAA5B,CAAoC,CAApC,IAAyC,MAA9D;AACA,IAAA,MAAM,CAAC,eAAP,CAAuB,MAAM,CAAC,eAAP,KAA2B,YAAlD;AACD;;AAED,SAAO,CAAE,MAAM,GAAG,GAAV,GAAiB,GAAlB,IAAyB,MAAhC;AACD;AAED;;;;;;;;;;AAQO,SAAS,eAAT,CACH,KADG,EAEH,MAFG,EAGH,aAHG,EAGoB;AACzB,MAAM,YAAY,GAAG,oBAAoB,CAAC,KAAD,EAAQ,aAAR,CAAzC;AACA,MAAM,aAAa,GAAG,oBAAoB,CAAC,MAAD,EAAS,aAAT,CAA1C;AAEA,SAAO,uBAAuB,CAAC,YAAY,GAAG,aAAhB,CAA9B;AACD;AAED;;;;;;;;;;AAQO,SAAS,oBAAT,CACH,KADG,EAEH,MAFG,EAGH,SAHG,EAGgB;AACrB,MAAM,YAAY,GAAG,gBAAgB,CAAC,KAAD,EAAQ,SAAR,CAArC;AACA,MAAM,aAAa,GAAG,gBAAgB,CAAC,MAAD,EAAS,SAAT,CAAtC;AACA,SAAO,kBAAkB,CAAC,YAAY,GAAG,aAAhB,CAAzB;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})()","// @flow\nimport Scorm12API from './Scorm12API';\nimport {\n  CMI,\n  CMIEvaluationCommentsObject,\n  CMITriesObject,\n  NAV,\n} from './cmi/aicc_cmi';\n\n/**\n * The AICC API class\n */\nexport default class AICC extends Scorm12API {\n  /**\n   * Constructor to create AICC API object\n   */\n  constructor() {\n    super();\n\n    this.cmi = new CMI(this);\n    this.nav = new NAV(this);\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   * @return {object}\n   */\n  getChildElement(CMIElement, value) {\n    let newChild = super.getChildElement(CMIElement);\n\n    if (!newChild) {\n      if (this.stringContains(CMIElement, 'cmi.evaluation.comments')) {\n        newChild = new CMIEvaluationCommentsObject(this);\n      } else if (this.stringContains(CMIElement, 'cmi.student_data.tries')) {\n        newChild = new CMITriesObject(this);\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';\n\nconst api_constants = {\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\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  cmi;\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   */\n  constructor(error_codes) {\n    this.currentState = api_constants.STATE_NOT_INITIALIZED;\n    this.apiLogLevel = api_constants.LOG_LEVEL_ERROR;\n    this.lastErrorCode = 0;\n    this.listenerArray = [];\n\n    this.#timeout = null;\n    this.#error_codes = error_codes;\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 = api_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      this.currentState = api_constants.STATE_INITIALIZED;\n      this.lastErrorCode = 0;\n      returnValue = api_constants.SCORM_TRUE;\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        api_constants.LOG_LEVEL_INFO);\n    this.clearSCORMError(returnValue);\n\n    return returnValue;\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 = api_constants.SCORM_FALSE;\n\n    if (this.checkState(checkTerminated,\n        this.#error_codes.TERMINATION_BEFORE_INIT,\n        this.#error_codes.MULTIPLE_TERMINATION)) {\n      if (checkTerminated) this.lastErrorCode = 0;\n      this.currentState = api_constants.STATE_TERMINATED;\n      returnValue = api_constants.SCORM_TRUE;\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        api_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      returnValue = this.getCMIValue(CMIElement);\n      this.processListeners(callbackName, CMIElement);\n    }\n\n    this.apiLog(callbackName, CMIElement, ': returned: ' + returnValue,\n        api_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 {boolean} checkTerminated\n   * @param {string} CMIElement\n   * @param {*} value\n   * @return {string}\n   */\n  setValue(\n      callbackName: String,\n      checkTerminated: boolean,\n      CMIElement,\n      value) {\n    let returnValue = '';\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      returnValue = this.setCMIValue(CMIElement, value);\n      this.processListeners(callbackName, CMIElement, value);\n    }\n\n    this.apiLog(callbackName, CMIElement,\n        ': ' + value + ': result: ' + returnValue,\n        api_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    let returnValue = api_constants.SCORM_FALSE;\n\n    if (this.checkState(checkTerminated, this.#error_codes.COMMIT_BEFORE_INIT,\n        this.#error_codes.COMMIT_AFTER_TERM)) {\n      if (checkTerminated) this.lastErrorCode = 0;\n      returnValue = api_constants.SCORM_TRUE;\n      this.processListeners(callbackName);\n    }\n\n    this.apiLog(callbackName, null, 'returned: ' + returnValue,\n        api_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        api_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        api_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        api_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 api_constants.LOG_LEVEL_ERROR:\n          console.error(logMessage);\n          break;\n        case api_constants.LOG_LEVEL_WARNING:\n          console.warn(logMessage);\n          break;\n        case api_constants.LOG_LEVEL_INFO:\n          console.info(logMessage);\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  stringContains(str: String, tester: String) {\n    return str.indexOf(tester) > -1;\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   */\n  getLmsErrorMessageDetails(_errorNumber, _detail) {\n    return 'No error';\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   */\n  getCMIValue(_CMIElement) {\n    return '';\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   */\n  setCMIValue(_CMIElement, _value) {\n    // just a stub method\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 api_constants.SCORM_FALSE;\n    }\n\n    const structure = CMIElement.split('.');\n    let refObject = this;\n    let returnValue = api_constants.SCORM_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 (!{}.hasOwnProperty.call(refObject, attribute)) {\n          this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n        } else {\n          if (this.stringContains(CMIElement, '.correct_responses')) {\n            this.validateCorrectResponse(CMIElement, value);\n          }\n\n          if (!scorm2004 || this.lastErrorCode === 0) {\n            refObject[attribute] = value;\n            returnValue = api_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            } else {\n              const newChild = this.getChildElement(CMIElement, value);\n\n              if (!newChild) {\n                this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n              } else {\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 === api_constants.SCORM_FALSE) {\n      this.apiLog(methodName, null,\n          `There was an error setting the value for: ${CMIElement}, value of: ${value}`,\n          api_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   * @return {*}\n   */\n  getChildElement(_CMIElement, _value) {\n    return null;\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    for (let i = 0; i < structure.length; i++) {\n      attribute = structure[i];\n\n      if (!scorm2004) {\n        if (i === structure.length - 1) {\n          if (!{}.hasOwnProperty.call(refObject, attribute)) {\n            this.throwSCORMError(101,\n                'getCMIValue did not find a value for: ' + CMIElement);\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 (!{}.hasOwnProperty.call(refObject, attribute)) {\n          this.throwSCORMError(401,\n              'The data model element passed to GetValue (' + CMIElement +\n              ') is not a valid SCORM data model element.');\n          return '';\n        }\n      }\n\n      refObject = refObject[attribute];\n    }\n\n    if (refObject === null || refObject === undefined) {\n      if (!scorm2004) {\n        if (attribute === '_children') {\n          this.throwSCORMError(202);\n        } else if (attribute === '_count') {\n          this.throwSCORMError(203);\n        }\n      }\n      return '';\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 === api_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 === api_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 === api_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  }\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    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      const CMIElementsMatch = listener.CMIElement === CMIElement;\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        api_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 !== api_constants.SCORM_FALSE) {\n      this.lastErrorCode = 0;\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 || 'cmi';\n\n    for (const key in json) {\n      if ({}.hasOwnProperty.call(json, key) && json[key]) {\n        const currentCMIElement = 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  renderCMIToJSON() {\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   * Throws a SCORM error\n   *\n   * @param {number} when - the number of milliseconds to wait before committing\n   */\n  scheduleCommit(when: number) {\n    this.#timeout = new ScheduledCommit(this, when);\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    }\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\n  /**\n   * Constructor for ScheduledCommit\n   * @param {BaseAPI} API\n   * @param {number} when\n   */\n  constructor(API: any, when: number) {\n    this.#API = API;\n    this.#timeout = setTimeout(this.wrapper, when);\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();\n    }\n  }\n}\n","// @flow\nimport BaseAPI from './BaseAPI';\nimport {\n  CMI,\n  CMIInteractionsCorrectResponsesObject,\n  CMIInteractionsObject,\n  CMIInteractionsObjectivesObject,\n  CMIObjectivesObject,\n} from './cmi/scorm12_cmi';\nimport * as Utilities from './utilities';\nimport {scorm12_constants} from './constants/api_constants';\nimport {scorm12_error_codes} from './constants/error_codes';\nimport {scorm12_regex} from './constants/regex';\n\nconst constants = scorm12_constants;\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   */\n  constructor() {\n    super(scorm12_error_codes);\n\n    this.cmi = new CMI(this);\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    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    return this.terminate('LMSFinish', false);\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', 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   */\n  setCMIValue(CMIElement, value) {\n    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   * @return {object}\n   */\n  getChildElement(CMIElement, value) {\n    let newChild;\n\n    if (this.stringContains(CMIElement, 'cmi.objectives')) {\n      newChild = new CMIObjectivesObject(this);\n    } else if (this.stringContains(CMIElement, '.correct_responses')) {\n      newChild = new CMIInteractionsCorrectResponsesObject(this);\n    } else if (this.stringContains(CMIElement, '.objectives')) {\n      newChild = new CMIInteractionsObjectivesObject(this);\n    } else if (this.stringContains(CMIElement, 'cmi.interactions')) {\n      newChild = new CMIInteractionsObject(this);\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 (constants.error_descriptions[errorNumber]) {\n      basicMessage = constants.error_descriptions[errorNumber].basicMessage;\n      detailMessage = constants.error_descriptions[errorNumber].detailMessage;\n    }\n\n    return detail ? detailMessage : basicMessage;\n  }\n\n  /**\n   * Adds the current session time to the existing total time.\n   *\n   * @return {string}\n   */\n  getCurrentTotalTime() {\n    const timeRegex = new RegExp(scorm12_regex.CMITime);\n\n    const totalTime = this.cmi.core.total_time;\n    const sessionTime = this.cmi.core.session_time;\n\n    return Utilities.addHHMMSSTimeStrings(totalTime, sessionTime, timeRegex);\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","// @flow\nimport BaseAPI from './BaseAPI';\nimport {\n  ADL,\n  CMI,\n  CMICommentsFromLearnerObject,\n  CMICommentsFromLMSObject,\n  CMIInteractionsCorrectResponsesObject,\n  CMIInteractionsObject,\n  CMIInteractionsObjectivesObject,\n  CMIObjectivesObject,\n} from './cmi/scorm2004_cmi';\nimport * as Util from './utilities';\nimport {scorm2004_constants} from './constants/api_constants';\nimport {scorm2004_error_codes} from './constants/error_codes';\nimport {correct_responses} from './constants/response_constants';\nimport {valid_languages} from './constants/language_constants';\nimport {scorm2004_regex} from './constants/regex';\n\nconst constants = scorm2004_constants;\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   */\n  constructor() {\n    super(scorm2004_error_codes);\n\n    this.cmi = new CMI(this);\n    this.adl = new ADL(this);\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    return this.initialize('Initialize');\n  }\n\n  /**\n   * @return {string} bool\n   */\n  lmsTerminate() {\n    return this.terminate('Terminate', true);\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', 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   */\n  setCMIValue(CMIElement, value) {\n    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   * @return {any}\n   */\n  getChildElement(CMIElement, value) {\n    let newChild;\n\n    if (this.stringContains(CMIElement, 'cmi.objectives')) {\n      newChild = new CMIObjectivesObject(this);\n    } else if (this.stringContains(CMIElement, '.correct_responses')) {\n      const parts = CMIElement.split('.');\n      const index = Number(parts[2]);\n      const interaction = this.cmi.interactions.childArray[index];\n      if (typeof interaction.type === 'undefined') {\n        this.throwSCORMError(scorm2004_error_codes.DEPENDENCY_NOT_ESTABLISHED);\n      } else {\n        const interaction_type = interaction.type;\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        const response_type = correct_responses[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      if (this.lastErrorCode === 0) {\n        newChild = new CMIInteractionsCorrectResponsesObject(this);\n      }\n    } else if (this.stringContains(CMIElement, '.objectives')) {\n      newChild = new CMIInteractionsObjectivesObject(this);\n    } else if (this.stringContains(CMIElement, 'cmi.interactions')) {\n      newChild = new CMIInteractionsObject(this);\n    } else if (this.stringContains(CMIElement, 'cmi.comments_from_learner')) {\n      newChild = new CMICommentsFromLearnerObject(this);\n    } else if (this.stringContains(CMIElement, 'cmi.comments_from_lms')) {\n      newChild = new CMICommentsFromLMSObject(this);\n    }\n\n    return newChild;\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_type = interaction.type;\n    const interaction_count = interaction.correct_responses._count;\n    if (interaction_type === 'choice') {\n      for (let i = 0; i < interaction_count && this.lastErrorCode === 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    const response_type = scorm2004_constants.correct_responses[interaction_type];\n    if (typeof response_type.limit !== 'undefined' || interaction_count <\n        response_type.limit) {\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      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 (constants.error_descriptions[errorNumber]) {\n      basicMessage = constants.error_descriptions[errorNumber].basicMessage;\n      detailMessage = 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 !== undefined) {\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 (valid_languages[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   * Adds the current session time to the existing total time.\n   *\n   * @return {string} ISO8601 Duration\n   */\n  getCurrentTotalTime() {\n    const totalTime = this.cmi.total_time;\n    const sessionTime = this.cmi.session_time;\n\n    return Util.addTwoDurations(totalTime, sessionTime,\n        scorm2004_regex.CMITimespan);\n  }\n}\n","import * as Scorm12CMI from './scorm12_cmi';\nimport {BaseCMI, CMIArray, CMIScore} from './common';\nimport {aicc_constants} from '../constants/api_constants';\nimport {aicc_regex} from '../constants/regex';\nimport {scorm12_error_codes} from '../constants/error_codes';\nimport {\n  check12ValidFormat,\n  throwReadOnlyError,\n  throwWriteOnlyError,\n} from './scorm12_cmi';\n\nconst constants = aicc_constants;\nconst regex = aicc_regex;\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(constants.cmi_children);\n\n    if (initialized) this.initialize();\n\n    this.student_data = new AICCCMIStudentData();\n    this.evaluation = new CMIEvaluation();\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_data?.initialize();\n    this.evaluation?.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      'evaluation': this.evaluation,\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(constants.comments_children,\n        scorm12_error_codes.INVALID_SET_VALUE);\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(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_data.tries object\n */\nexport class CMITries extends CMIArray {\n  /**\n   * Constructor for inline Tries Array class\n   */\n  constructor() {\n    super(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: constants.score_children,\n          score_range: 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        });\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 (check12ValidFormat(status, 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 (check12ValidFormat(time, 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 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 (check12ValidFormat(content, 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 (check12ValidFormat(location, 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 (check12ValidFormat(time, 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\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.jsonString) ? throwWriteOnlyError() : this.#event;\n  }\n\n  /**\n   * Setter for #event\n   * @param {string} event\n   */\n  set event(event) {\n    if (check12ValidFormat(event, 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 {scorm12_constants} from '../constants/api_constants';\nimport {scorm12_error_codes} from '../constants/error_codes';\nimport {ValidationError} from '../exceptions';\nimport {scorm12_regex} from '../constants/regex';\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 {boolean} allowEmptyString\n * @return {boolean}\n */\nexport function checkValidFormat(\n    value: String,\n    regexPattern: String,\n    errorCode: number,\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 ValidationError(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 * @return {boolean}\n */\nexport function checkValidRange(\n    value: any, rangePattern: String, errorCode: number) {\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 ValidationError(errorCode);\n    }\n  } else {\n    throw new ValidationError(errorCode);\n  }\n}\n\n/**\n * Base class for API cmi objects\n */\nexport class BaseCMI {\n  jsonString = false;\n  #initialized = false;\n\n  /**\n   * Getter for #initialized\n   * @return {boolean}\n   */\n  get initialized() {\n    return this.#initialized;\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/**\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   */\n  constructor(\n      {\n        score_children,\n        score_range,\n        max,\n        invalidErrorCode,\n        invalidTypeCode,\n        invalidRangeCode,\n        decimalRegex,\n      }) {\n    super();\n\n    this.#_children = score_children ?\n        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        invalidErrorCode :\n        scorm12_error_codes.INVALID_SET_VALUE;\n    this.#_invalid_type_code = invalidTypeCode ?\n        invalidTypeCode :\n        scorm12_error_codes.TYPE_MISMATCH;\n    this.#_invalid_range_code = invalidRangeCode ?\n        invalidRangeCode :\n        scorm12_error_codes.VALUE_OUT_OF_RANGE;\n    this.#_decimal_regex = decimalRegex ?\n        decimalRegex :\n        scorm12_regex.CMIDecimal;\n  }\n\n  #_children;\n  #_score_range;\n  #_invalid_error_code;\n  #_invalid_type_code;\n  #_invalid_range_code;\n  #_decimal_regex;\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 ValidationError(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,\n        this.#_invalid_type_code) &&\n        (!this.#_score_range ||\n            checkValidRange(raw, this.#_score_range,\n                this.#_invalid_range_code))) {\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,\n        this.#_invalid_type_code) &&\n        (!this.#_score_range ||\n            checkValidRange(min, this.#_score_range,\n                this.#_invalid_range_code))) {\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,\n        this.#_invalid_type_code) &&\n        (!this.#_score_range ||\n            checkValidRange(max, this.#_score_range,\n                this.#_invalid_range_code))) {\n      this.#max = max;\n    }\n  }\n\n  /**\n   * toJSON for *.score\n   * @return {{min: string, max: string, raw: string}}\n   */\n  toJSON() {\n    return {\n      'raw': this.raw,\n      'min': this.min,\n      'max': this.max,\n    };\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   */\n  constructor({children, errorCode}) {\n    super();\n    this.#_children = children;\n    this.#errorCode = errorCode;\n    this.childArray = [];\n  }\n\n  #errorCode;\n  #_children;\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    throw new ValidationError(this.#errorCode);\n  }\n\n  /**\n   * Getter for _count\n   * @return {number}\n   * @private\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   * @private\n   */\n  set _count(_count) {\n    throw new ValidationError(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 {scorm12_constants} from '../constants/api_constants';\nimport {scorm12_error_codes} from '../constants/error_codes';\nimport {scorm12_regex} from '../constants/regex';\nimport {ValidationError} from '../exceptions';\n\nconst constants = scorm12_constants;\nconst regex = scorm12_regex;\n\n/**\n * Helper method for throwing Read Only error\n */\nexport function throwReadOnlyError() {\n  throw new ValidationError(scorm12_error_codes.READ_ONLY_ELEMENT);\n}\n\n/**\n * Helper method for throwing Write Only error\n */\nexport function throwWriteOnlyError() {\n  throw new ValidationError(scorm12_error_codes.WRITE_ONLY_ELEMENT);\n}\n\n/**\n * Helper method for throwing Invalid Set error\n */\nfunction throwInvalidValueError() {\n  throw new ValidationError(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 * @return {boolean}\n */\nexport function check12ValidFormat(value: String, regexPattern: String) {\n  return checkValidFormat(value, regexPattern,\n      scorm12_error_codes.TYPE_MISMATCH);\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 */\nexport function check12ValidRange(value: any, rangePattern: String) {\n  return checkValidRange(value, rangePattern,\n      scorm12_error_codes.VALUE_OUT_OF_RANGE);\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  #suspend_data = '';\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 ? cmi_children : 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   * @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    throwInvalidValueError();\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 #_version. Just throws an error.\n   * @param {string} _children\n   * @private\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.#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, regex.CMIString4096)) {\n      this.#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, regex.CMIString4096)) {\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/**\n * Class representing the cmi.core object\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: constants.score_children,\n          score_range: 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        });\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 = constants.core_children;\n  #student_id = '';\n  #student_name = '';\n  #lesson_location = '';\n  #credit = '';\n  #lesson_status = '';\n  #entry = '';\n  #total_time = '';\n  #lesson_mode = 'normal';\n  #exit = '';\n  #session_time = '00:00:00';\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, regex.CMIString256)) {\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 (check12ValidFormat(lesson_status, regex.CMIStatus)) {\n      this.#lesson_status = lesson_status;\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, regex.CMIExit)) {\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, regex.CMITimespan)) {\n      this.#session_time = session_time;\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   *      total_time: 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      'total_time': this.total_time,\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 */\nclass CMIObjectives extends CMIArray {\n  /**\n   * Constructor for cmi.objectives\n   */\n  constructor() {\n    super({\n      children: constants.objectives_children,\n      errorCode: scorm12_error_codes.INVALID_SET_VALUE,\n    });\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.student_data object\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        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 */\nclass CMIStudentPreference extends BaseCMI {\n  /**\n   * Constructor for cmi.student_preference\n   */\n  constructor() {\n    super();\n  }\n\n  #_children = constants.student_preference_children;\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, regex.CMISInteger) &&\n        check12ValidRange(audio, 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, 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, regex.CMISInteger) &&\n        check12ValidRange(speed, 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, regex.CMISInteger) &&\n        check12ValidRange(text, 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 */\nclass CMIInteractions extends CMIArray {\n  /**\n   * Constructor for cmi.interactions\n   */\n  constructor() {\n    super({\n      children: constants.interactions_children,\n      errorCode: scorm12_error_codes.INVALID_SET_VALUE,\n    });\n  }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.interactions.n object\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      children: constants.objectives_children,\n    });\n    this.correct_responses = new CMIArray({\n      errorCode: scorm12_error_codes.INVALID_SET_VALUE,\n      children: 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, 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, 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, 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, regex.CMIDecimal) &&\n        check12ValidRange(weighting, 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, regex.CMIFeedback)) {\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, 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, 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 */\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: constants.score_children,\n          score_range: 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        });\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, 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, 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 */\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, 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 */\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, regex.CMIFeedback)) {\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","// @flow\nimport {\n  BaseCMI,\n  checkValidFormat,\n  checkValidRange,\n  CMIArray,\n  CMIScore,\n} from './common';\nimport {scorm2004_constants} from '../constants/api_constants';\nimport {scorm2004_regex} from '../constants/regex';\nimport {scorm2004_error_codes} from '../constants/error_codes';\nimport {learner_responses} from '../constants/response_constants';\nimport {ValidationError} from '../exceptions';\n\nconst constants = scorm2004_constants;\nconst regex = scorm2004_regex;\n\n/**\n * Helper method for throwing Read Only error\n */\nfunction throwReadOnlyError() {\n  throw new ValidationError(scorm2004_error_codes.READ_ONLY_ELEMENT);\n}\n\n/**\n * Helper method for throwing Write Only error\n */\nfunction throwWriteOnlyError() {\n  throw new ValidationError(scorm2004_error_codes.WRITE_ONLY_ELEMENT);\n}\n\n/**\n * Helper method for throwing Type Mismatch error\n */\nfunction throwTypeMismatchError() {\n  throw new ValidationError(scorm2004_error_codes.TYPE_MISMATCH);\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(value, regexPattern,\n      scorm2004_error_codes.TYPE_MISMATCH, allowEmptyString);\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(value, rangePattern,\n      scorm2004_error_codes.VALUE_OUT_OF_RANGE);\n}\n\n/**\n * Class representing cmi object for SCORM 2004\n */\nexport class CMI extends BaseCMI {\n  #_version = '1.0';\n  #_children = 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 = '0';\n\n  /**\n   * Constructor for the SCORM 2004 cmi object\n   * @param {boolean} initialized\n   */\n  constructor(initialized: boolean) {\n    super();\n\n    if (initialized) this.initialize();\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\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, 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, regex.CMIExit)) {\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, 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, regex.CMIDecimal) &&\n        check2004ValidRange(progress_measure, 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, 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, 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, regex.CMIString64000)) {\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   * 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   *      total_time: 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      'total_time': this.total_time,\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 = 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, regex.CMIDecimal) &&\n        check2004ValidRange(audio_level, 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, 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, regex.CMIDecimal) &&\n        check2004ValidRange(delivery_speed, 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, regex.CMISInteger) &&\n        check2004ValidRange(audio_captioning, 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: constants.interactions_children,\n      errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\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: constants.objectives_children,\n      errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\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: constants.comments_children,\n      errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\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: constants.comments_children,\n      errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\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      children: constants.objectives_children,\n    });\n    this.correct_responses = new CMIArray({\n      errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n      children: 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, 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 (check2004ValidFormat(type, regex.CMIType)) {\n      this.#type = type;\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 (check2004ValidFormat(timestamp, regex.CMITime)) {\n      this.#timestamp = timestamp;\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 (check2004ValidFormat(weighting, regex.CMIDecimal)) {\n      this.#weighting = weighting;\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 (typeof this.type === 'undefined') {\n      throw new ValidationError(\n          scorm2004_error_codes.DEPENDENCY_NOT_ESTABLISHED);\n    } else {\n      let nodes = [];\n      const response_type = learner_responses[this.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 (typeof response_type.delimiter2 !== 'undefined') {\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        throw new ValidationError(scorm2004_error_codes.GENERAL_SET_FAILURE);\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, 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 (check2004ValidFormat(latency, regex.CMITimespan)) {\n      this.#latency = latency;\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 (check2004ValidFormat(description, regex.CMILangString250, true)) {\n      this.#description = description;\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, 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 (check2004ValidFormat(success_status, regex.CMISStatus)) {\n      this.#success_status = success_status;\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 (check2004ValidFormat(completion_status, regex.CMICStatus)) {\n      this.#completion_status = completion_status;\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 (check2004ValidFormat(progress_measure, regex.CMIDecimal) &&\n        check2004ValidRange(progress_measure, regex.progress_range)) {\n      this.#progress_measure = progress_measure;\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 (check2004ValidFormat(description, regex.CMILangString250, true)) {\n      this.#description = description;\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: constants.score_children,\n          max: '',\n          invalidErrorCode: scorm2004_error_codes.INVALID_SET_VALUE,\n          invalidTypeCode: scorm2004_error_codes.TYPE_MISMATCH,\n          invalidRangeCode: scorm2004_error_codes.VALUE_OUT_OF_RANGE,\n          decimalRegex: scorm2004_regex.CMIDecimal,\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, regex.CMIDecimal) &&\n        check2004ValidRange(scaled, 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 object\n */\nexport class CMICommentsFromLearnerObject extends BaseCMI {\n  #comment = '';\n  #location = '';\n  #timestamp = '';\n\n  /**\n   * Constructor for cmi.comments_from_learner.n\n   */\n  constructor() {\n    super();\n    this.#comment = '';\n    this.#location = '';\n    this.#timestamp = '';\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 (check2004ValidFormat(comment, regex.CMILangString4000, true)) {\n      this.#comment = comment;\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 (check2004ValidFormat(location, regex.CMIString250)) {\n      this.#location = location;\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 (check2004ValidFormat(timestamp, regex.CMITime)) {\n      this.#timestamp = timestamp;\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.comments_from_lms.n object\n */\nexport class CMICommentsFromLMSObject extends CMICommentsFromLearnerObject {\n  /**\n   * Constructor for cmi.comments_from_lms.n\n   */\n  constructor() {\n    super();\n  }\n\n  /**\n   * Getter for #comment\n   * @return {string}\n   */\n  get comment() {\n    return super.comment;\n  }\n\n  /**\n   * Setter for #comment. Can only be called before  initialization.\n   * @param {string} comment\n   */\n  set comment(comment) {\n    !this.initialized ? super.comment = comment : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #location\n   * @return {string}\n   */\n  get location() {\n    return super.location;\n  }\n\n  /**\n   * Setter for #location. Can only be called before  initialization.\n   * @param {string} location\n   */\n  set location(location) {\n    !this.initialized ? super.location = location : throwReadOnlyError();\n  }\n\n  /**\n   * Getter for #timestamp\n   * @return {string}\n   */\n  get timestamp() {\n    return super.timestamp;\n  }\n\n  /**\n   * Setter for #timestamp. Can only be called before  initialization.\n   * @param {string} timestamp\n   */\n  set timestamp(timestamp) {\n    !this.initialized ? super.timestamp = timestamp : throwReadOnlyError();\n  }\n\n  /**\n   * toJSON for cmi.comments_from_lms.n\n   * @return {\n   *    {\n   *      comment: string,\n   *      location: string,\n   *      timestamp: string\n   *    }\n   *  }\n   */\n  toJSON() {\n    return super.toJSON();\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, 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, 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, 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\nexport const scorm12_constants = {\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  },\n};\n\nexport const aicc_constants = {\n  ...scorm12_constants, ...{\n    cmi_children: 'core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions,evaluation',\n    student_data_children: 'attempt_number,tries,mastery_score,max_time_allowed,time_limit_action',\n    tries_children: 'time,status,score',\n  },\n};\n\nexport const scorm2004_constants = {\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","// @flow\nexport const error_codes = {\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\nexport const scorm12_error_codes = {\n  ...error_codes, ...{\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\nexport const scorm2004_error_codes = {\n  ...error_codes, ...{\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","const common_values = {\n  validResult: [\n    'correct',\n    'wrong',\n    'unanticipated',\n    'neutral',\n  ],\n  invalidResult: [\n    '-10000',\n    '10000',\n    'invalid',\n  ],\n\n  valid0To1Range: [\n    '0.0',\n    '0.25',\n    '0.5',\n    '1.0',\n  ],\n  invalid0To1Range: [\n    '-1',\n    '-0.1',\n    '1.1',\n    '.25',\n  ],\n\n  valid0To100Range: [\n    '1',\n    '50',\n    '100',\n  ],\n  invalid0To100Range: [\n    'invalid',\n    'a100',\n    '-1',\n  ],\n\n  validScaledRange: [\n    '1',\n    '0.5',\n    '0',\n    '-0.5',\n    '-1',\n  ],\n  invalidScaledRange: [\n    '-101',\n    '25.1',\n    '50.5',\n    '75',\n    '100',\n  ],\n\n  validIntegerScaledRange: [\n    '1',\n    '0',\n    '-1',\n  ],\n  invalidIntegerScaledRange: [\n    '-101',\n    '-0.5',\n    '0.5',\n    '25.1',\n    '50.5',\n    '75',\n    '100',\n  ],\n};\n\nexport const scorm12_values = {\n  ...common_values, ...{\n    validLessonStatus: [\n      'passed',\n      'completed',\n      'failed',\n      'incomplete',\n      'browsed',\n    ],\n    invalidLessonStatus: [\n      'Passed',\n      'P',\n      'F',\n      'p',\n      'true',\n      'false',\n      'complete',\n    ],\n\n    validExit: [\n      'time-out',\n      'suspend',\n      'logout',\n    ],\n    invalidExit: [\n      'close',\n      'exit',\n      'crash',\n    ],\n\n    validType: [\n      'true-false',\n      'choice',\n      'fill-in',\n      'matching',\n      'performance',\n      'sequencing',\n      'likert',\n      'numeric',\n    ],\n    invalidType: [\n      'correct',\n      'wrong',\n      'logout',\n    ],\n\n    validSpeedRange: [\n      '1',\n      '50',\n      '100',\n      '-1',\n      '-50',\n      '-100',\n    ],\n    invalidSpeedRange: [\n      'invalid',\n      'a100',\n      '-101',\n      '101',\n      '-100000',\n      '100000',\n    ],\n\n    validScoreRange: [\n      '1',\n      '50.25',\n      '100',\n    ],\n    invalidScoreRange: [\n      'invalid',\n      'a100',\n      '-1',\n      '101',\n      '-100000',\n      '100000',\n    ],\n    invalid0To100Range: [\n      'invalid',\n      'a100',\n      '-2',\n    ],\n\n    validTime: [\n      '10:06:57',\n      '23:59:59',\n      '00:00:00',\n    ],\n    invalidTime: [\n      '47:59:59',\n      '00:00:01.56',\n      '06:5:13',\n      '23:59:59.123',\n      'P1DT23H59M59S',\n    ],\n\n    validTimestamp: [\n      '10:06:57',\n      '00:00:01.56',\n      '23:59:59',\n      '47:59:59',\n    ],\n    invalidTimestamp: [\n      '06:5:13',\n      '23:59:59.123',\n      'P1DT23H59M59S',\n    ],\n  },\n};\n\nexport const scorm2004_values = {\n  ...common_values, ...{\n    // valid field values\n    validTimestamps: [\n      '2019-06-25',\n      '2019-06-25T23:59',\n      '2019-06-25T23:59:59.99',\n      '1970-01-01',\n    ],\n    invalidTimestamps: [\n      '2019-06-25T',\n      '2019-06-25T23:59:59.999',\n      '2019-06-25T25:59:59.99',\n      '2019-13-31',\n      '1969-12-31',\n      '-00:00:30',\n      '0:50:30',\n      '23:00:30.',\n    ],\n\n    validCStatus: [\n      'completed',\n      'incomplete',\n      'not attempted',\n      'unknown',\n    ],\n    invalidCStatus: [\n      'complete',\n      'passed',\n      'failed',\n    ],\n\n    validSStatus: [\n      'passed',\n      'failed',\n      'unknown',\n    ],\n    invalidSStatus: [\n      'complete',\n      'incomplete',\n      'P',\n      'f',\n    ],\n\n    validExit: [\n      'time-out',\n      'suspend',\n      'logout',\n      'normal',\n    ],\n    invalidExit: [\n      'close',\n      'exit',\n      'crash',\n    ],\n\n    validType: [\n      'true-false',\n      'choice',\n      'fill-in',\n      'long-fill-in',\n      'matching',\n      'performance',\n      'sequencing',\n      'likert',\n      'numeric',\n      'other',\n    ],\n    invalidType: [\n      'correct',\n      'wrong',\n      'logout',\n    ],\n\n    validScoreRange: [\n      '1',\n      '50',\n      '100',\n      '-10000',\n      '-1',\n      '10000',\n    ],\n    invalidScoreRange: [\n      'invalid',\n      'a100',\n      '-100000',\n      '100000',\n    ],\n\n    validISO8601Durations: [\n      'P1Y34DT23H45M15S',\n      'PT1M45S',\n      'P0S',\n      'PT75M',\n    ],\n    invalidISO8601Durations: [\n      '00:08:45',\n      '-P1H',\n      '1y45D',\n      '0',\n    ],\n\n    validComment: [\n      '{lang=en-98} learner comment',\n      '{lang=eng-98-9} learner comment',\n      '{lang=eng-98-9fhgj}' + 'x'.repeat(4000),\n      'learner comment',\n      'learner comment}',\n      '{lang=i-xx}',\n      '{lang=i}',\n      '',\n    ],\n    invalidComment: [\n      '{lang=i-}',\n      '{lang=i-x}',\n      '{lang=eng-98-9fhgj}{ learner comment',\n      '{learner comment',\n      '{lang=eng-98-9fhgj}' + 'x'.repeat(4001),\n      '{lang=eng-98-9fhgj}{' + 'x'.repeat(3999),\n    ],\n\n    validDescription: [\n      '{lang=en-98} learner comment',\n      '{lang=eng-98-9} learner comment',\n      '{lang=eng-98-9fhgj}' + 'x'.repeat(250),\n      'learner comment',\n      'learner comment}',\n      '{lang=i-xx}',\n      '{lang=i}',\n      '',\n    ],\n    invalidDescription: [\n      '{lang=i-}',\n      '{lang=i-x}',\n      '{lang=eng-98-9fhgj}{ learner comment',\n      '{learner comment',\n      '{lang=eng-98-9fhgj}' + 'x'.repeat(251),\n      '{lang=eng-98-9fhgj}{' + 'x'.repeat(249),\n    ],\n\n    validNavRequest: [\n      'previous',\n      'continue',\n      'exit',\n      'exitAll',\n      'abandon',\n      'abandonAll',\n      'suspendAll',\n    ],\n    invalidNavRequest: [\n      'close',\n      'quit',\n      'next',\n      'before',\n    ],\n  },\n};\n","export const valid_languages = {\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","// @flow\n\nimport {scorm12_values, scorm2004_values} from './field_values';\n\nexport const scorm12_regex = {\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]{0,255}$',\n  CMIFeedback: '^.{0,255}$', // This must be redefined\n  CMIIndex: '[._](\\\\d+).',\n\n  // Vocabulary Data Type Definition\n  CMIStatus: '^(' + scorm12_values.validLessonStatus.join('|') + ')$',\n  CMIStatus2: '^(' + scorm12_values.validLessonStatus.join('|') + '|not attempted)$',\n  CMIExit: '^(' + scorm12_values.validExit.join('|') + '|)$',\n  CMIType: '^(' + scorm12_values.validType.join('|') + ')$',\n  CMIResult: '^(' + scorm12_values.validResult.join('|') + '|([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\nexport const aicc_regex = {\n  ...scorm12_regex, ...{\n    CMIIdentifier: '^\\\\w{1,255}$',\n  },\n};\n\nexport const scorm2004_regex = {\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})$',\n  CMIFeedback: '^.*$', // This must be redefined\n  CMIIndex: '[._](\\\\d+).',\n  CMIIndexStore: '.N(\\\\d+).',\n\n  // Vocabulary Data Type Definition\n  CMICStatus: '^(' + scorm2004_values.validCStatus.join('|') + ')$',\n  CMISStatus: '^(' + scorm2004_values.validSStatus.join('|') + ')$',\n  CMIExit: '^(' + scorm2004_values.validExit.join('|') + ')$',\n  CMIType: '^(' + scorm2004_values.validType.join('|') + ')$',\n  CMIResult: '^(' + scorm2004_values.validResult.join('|') + '|-?([0-9]{1,4})(\\\\.[0-9]{1,18})?)$',\n  NAVEvent: '^(' + scorm2004_values.validNavRequest.join('|') + '|\\{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","// @flow\nimport {scorm2004_regex} from './regex';\n\nexport const learner_responses = {\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\nexport const correct_responses = {\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","// @flow\n\n/**\n * Data Validation Exception\n */\nexport class ValidationError extends Error {\n  /**\n   * Constructor to take in an error message and code\n   * @param {number} errorCode\n   */\n  constructor(errorCode: number) {\n    super(errorCode);\n    this.#errorCode = errorCode;\n  }\n\n  #errorCode;\n\n  /**\n   * Getter for #errorCode\n   * @return {number}\n   */\n  get errorCode() {\n    return this.#errorCode;\n  }\n\n  /**\n   * Trying to override the default Error message\n   * @return {string}\n   */\n  get message() {\n    return this.#errorCode + '';\n  }\n}\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() + (totalSeconds % 1.0);\n\n  return hours.toString().padStart(2, '0') + ':' +\n      minutes.toString().padStart(2, '0') + ':' +\n      seconds.toString().padStart(2, '0');\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 'P0S';\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 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      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  const now = new Date();\n  const anchor = new Date(now);\n  anchor.setFullYear(anchor.getFullYear() + Number(years || 0));\n  anchor.setMonth(anchor.getMonth() + Number(months || 0));\n  anchor.setDate(anchor.getDate() + Number(days || 0));\n  anchor.setHours(anchor.getHours() + Number(hours || 0));\n  anchor.setMinutes(anchor.getMinutes() + Number(minutes || 0));\n  anchor.setSeconds(anchor.getSeconds() + Number(seconds || 0));\n  if (seconds && String(seconds).indexOf('.') > 0) {\n    const milliseconds = Number(Number(seconds) % 1).toFixed(6) * 1000.0;\n    anchor.setMilliseconds(anchor.getMilliseconds() + milliseconds);\n  }\n\n  return ((anchor * 1.0) - now) / 1000.0;\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  const firstSeconds = getDurationAsSeconds(first, durationRegex);\n  const secondSeconds = getDurationAsSeconds(second, durationRegex);\n\n  return getSecondsAsISODuration(firstSeconds + secondSeconds);\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  const firstSeconds = getTimeAsSeconds(first, timeRegex);\n  const secondSeconds = getTimeAsSeconds(second, timeRegex);\n  return getSecondsAsHHMMSS(firstSeconds + secondSeconds);\n}\n"]} diff --git a/dist/scorm-again.js.map b/dist/scorm-again.js.map new file mode 100644 index 0000000..19564d9 --- /dev/null +++ b/dist/scorm-again.js.map @@ -0,0 +1 @@ +{"version":3,"sources":["node_modules/browser-pack/_prelude.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/field_values.js","src/constants/language_constants.js","src/constants/regex.js","src/constants/response_constants.js","src/exceptions.js","src/utilities.js"],"names":["_Scorm12API2","_interopRequireDefault","require","_aicc_cmi","AICC","_this","_classCallCheck","this","_possibleConstructorReturn","_getPrototypeOf","call","cmi","CMI","_assertThisInitialized","nav","NAV","CMIElement","value","newChild","_get","prototype","stringContains","CMIEvaluationCommentsObject","CMITriesObject","newAPI","Scorm12API","_common","api_constants","SCORM_TRUE","SCORM_FALSE","STATE_NOT_INITIALIZED","STATE_INITIALIZED","STATE_TERMINATED","LOG_LEVEL_DEBUG","LOG_LEVEL_INFO","LOG_LEVEL_WARNING","LOG_LEVEL_ERROR","LOG_LEVEL_NONE","BaseAPI","error_codes","_timeout","set","writable","_error_codes","_defineProperty","currentState","apiLogLevel","lastErrorCode","listenerArray","_classPrivateFieldSet","callbackName","initializeMessage","terminationMessage","returnValue","isInitialized","throwSCORMError","_classPrivateFieldGet","INITIALIZED","isTerminated","TERMINATED","processListeners","apiLog","clearSCORMError","checkTerminated","checkState","TERMINATION_BEFORE_INIT","MULTIPLE_TERMINATION","RETRIEVE_BEFORE_INIT","RETRIEVE_AFTER_TERM","getCMIValue","STORE_BEFORE_INIT","STORE_AFTER_TERM","setCMIValue","COMMIT_BEFORE_INIT","COMMIT_AFTER_TERM","String","CMIErrorCode","getLmsErrorMessageDetails","beforeInitError","afterTermError","isNotInitialized","functionName","logMessage","messageLevel","formatMessage","console","error","warn","info","message","messageString","fillChars","length","i","j","str","tester","indexOf","_errorNumber","_detail","_CMIElement","_value","methodName","scorm2004","structure","split","refObject","invalidErrorMessage","concat","invalidErrorCode","UNDEFINED_DATA_MODEL","GENERAL","attribute","substr","_isTargetValid","READ_ONLY_ELEMENT","hasOwnProperty","validateCorrectResponse","CMIArray","index","parseInt","isNaN","item","childArray","getChildElement","push","target","undefined","listenerName","callback","listenerFunctions","listenerSplit","replace","listener","functionsMatch","listenerHasCMIElement","CMIElementsMatch","errorNumber","success","json","key","currentCMIElement","loadFromJSON","constructor","Object","JSON","stringify","when","ScheduledCommit","cancel","API","_API","_cancelled","_timeout2","setTimeout","wrapper","clearTimeout","commit","_BaseAPI2","_scorm12_cmi","Utilities","_interopRequireWildcard","_api_constants","_regex","constants","scorm12_constants","scorm12_error_codes","LMSInitialize","lmsInitialize","LMSFinish","lmsFinish","LMSGetValue","lmsGetValue","LMSSetValue","lmsSetValue","LMSCommit","lmsCommit","LMSGetLastError","lmsGetLastError","LMSGetErrorString","lmsGetErrorString","LMSGetDiagnostic","lmsGetDiagnostic","initialize","terminate","getValue","setValue","getLastError","getErrorString","getDiagnostic","_commonSetCMIValue","_commonGetCMIValue","CMIObjectivesObject","CMIInteractionsCorrectResponsesObject","CMIInteractionsObjectivesObject","CMIInteractionsObject","detail","basicMessage","detailMessage","error_descriptions","timeRegex","RegExp","scorm12_regex","CMITime","totalTime","core","total_time","sessionTime","session_time","addHHMMSSTimeStrings","_scorm2004_cmi","Util","_response_constants","_language_constants","scorm2004_constants","Scorm2004API","scorm2004_error_codes","_version","correct_response","current_index","found","count","_count","adl","ADL","Initialize","Terminate","lmsTerminate","GetValue","SetValue","Commit","GetLastError","GetErrorString","GetDiagnostic","parts","Number","interaction","interactions","type","DEPENDENCY_NOT_ESTABLISHED","interaction_type","interaction_count","correct_responses","response","pattern","GENERAL_SET_FAILURE","response_type","nodes","delimiter","max","checkCorrectResponseValue","CMICommentsFromLearnerObject","CMICommentsFromLMSObject","pattern_index","limit","duplicate","checkDuplicatedPattern","formatRegex","format","match","removeCorrectResponsePrefixes","delimiter2","values","matches","format2","TYPE_MISMATCH","unique","node","seenOrder","seenCase","seenLang","prefixRegex","langMatches","scorm2004_regex","CMILangcr","lang","valid_languages","toLowerCase","addTwoDurations","CMITimespan","Scorm12CMI","aicc_constants","regex","aicc_regex","initialized","cmi_children","student_data","AICCCMIStudentData","evaluation","CMIEvaluation","_this$student_data","_this$evaluation","jsonString","result","suspend_data","launch_data","comments","comments_from_lms","objectives","student_preference","_this2","CMIEvaluationComments","_this$comments","BaseCMI","comments_children","INVALID_SET_VALUE","_this3","student_data_children","_tries_during_lesson","tries","CMITries","_this$tries","mastery_score","max_time_allowed","time_limit_action","tries_during_lesson","throwReadOnlyError","CMIStudentData","tries_children","_this4","_status","_time","score","CMIScore","score_children","score_range","invalidTypeCode","invalidRangeCode","VALUE_OUT_OF_RANGE","_this$score","status","time","check12ValidFormat","CMIStatus2","_this5","_content","_location","_time2","content","location","CMIString256","_this6","_event","event","throwWriteOnlyError","NAVEvent","checkValidFormat","regexPattern","errorCode","allowEmptyString","ValidationError","checkValidRange","rangePattern","ranges","_exceptions","_initialized","_ref","decimalRegex","_children2","_score_range","_invalid_error_code","_invalid_type_code","_invalid_range_code","_decimal_regex","_raw","_min","_max","CMIDecimal","raw","min","_children","_ref2","children","_errorCode","_children3","WRITE_ONLY_ELEMENT","throwInvalidValueError","check12ValidRange","_version2","_suspend_data","_launch_data","_comments","_comments_from_lms","CMICore","CMIObjectives","CMIStudentPreference","CMIInteractions","_this$core","_this$objectives","_this$student_prefere","_this$interactions","CMIString4096","core_children","_student_id","_student_name","_lesson_location","_credit","_lesson_status","_entry","_total_time","_lesson_mode","_exit","_session_time","student_id","student_name","lesson_location","credit","lesson_status","entry","lesson_mode","exit","CMIStatus","CMIExit","objectives_children","_children4","_mastery_score","_max_time_allowed","_time_limit_action","_children5","student_preference_children","_audio","_language","_speed","_text","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","weighting","student_response","latency","CMIIdentifier","CMIType","weighting_range","CMIFeedback","CMIResult","_id2","_this7","_id3","_this8","_pattern","throwTypeMismatchError","check2004ValidFormat","check2004ValidRange","_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","completion_status","completion_threshold","learner_id","learner_name","mode","progress_measure","scaled_passing_score","success_status","CMICStatus","CMIString1000","progress_range","CMISStatus","CMIString64000","_audio_level","_delivery_speed","_audio_captioning","audio_level","delivery_speed","audio_captioning","CMILang","_timestamp","_learner_response","_description","timestamp","learner_response","description","CMILongIdentifier","learner_responses","CMILangString250","_success_status2","_completion_status2","_progress_measure2","_description2","_this$score2","_scaled","scaled","scaled_range","_comment","_location2","_timestamp2","comment","CMILangString4000","CMIString250","_set","_this9","ADLNav","_this$nav","_this10","_request","request_valid","ADLNavRequestValid","_this$request_valid","request","_this11","_continue","_previous","_temp","_target","_temp2","previous","continue","_","101","201","202","203","301","401","402","403","404","405","_objectSpread","0","102","103","104","111","112","113","122","123","132","133","142","143","351","391","406","407","408","INITIALIZATION_FAILED","TERMINATION_FAILURE","ARGUMENT_ERROR","CHILDREN_ERROR","COUNT_ERROR","GENERAL_GET_FAILURE","GENERAL_COMMIT_FAILURE","UNIMPLEMENTED_ELEMENT","VALUE_NOT_INITIALIZED","MULTIPLE_TERMINATIONS","common_values","validResult","invalidResult","valid0To1Range","invalid0To1Range","valid0To100Range","invalid0To100Range","validScaledRange","invalidScaledRange","validIntegerScaledRange","invalidIntegerScaledRange","scorm12_values","validLessonStatus","invalidLessonStatus","validExit","invalidExit","validType","invalidType","validSpeedRange","invalidSpeedRange","validScoreRange","invalidScoreRange","validTime","invalidTime","validTimestamp","invalidTimestamp","scorm2004_values","validTimestamps","invalidTimestamps","validCStatus","invalidCStatus","validSStatus","invalidSStatus","validISO8601Durations","invalidISO8601Durations","validComment","repeat","invalidComment","validDescription","invalidDescription","validNavRequest","invalidNavRequest","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","_field_values","CMIInteger","CMIIndex","join","CMIString200","CMIString4000","CMILangString250cr","CMIShortIdentifier","CMIIndexStore","NAVBoolean","NAVTarget","true-false","choice","fill-in","long-fill-in","matching","performance","sequencing","likert","numeric","other","Error","getSecondsAsHHMMSS","totalSeconds","hours","Math","floor","SECONDS_PER_HOUR","dateObj","Date","minutes","getUTCMinutes","seconds","getSeconds","toString","padStart","getSecondsAsISODuration","duration","remainder","designations","forEach","_slicedToArray","sign","current_seconds","getTimeAsSeconds","timeString","getDurationAsSeconds","durationRegex","_ref3","exec","_ref4","years","months","days","now","anchor","setFullYear","getFullYear","setMonth","getMonth","setDate","getDate","setHours","getHours","setMinutes","getMinutes","setSeconds","milliseconds","toFixed","setMilliseconds","getMilliseconds","first","second","SECONDS_PER_SECOND","SECONDS_PER_MINUTE","SECONDS_PER_DAY"],"mappings":"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ACvB7f,qBAAsB,IACtBC,oBAAqB,IACrBE,kBAAmB,IACnBC,iBAAkB,IAClBE,mBAAoB,IACpBC,kBAAmB,IACnB+e,eAAgB,IAChBG,oBAAqB,IACrBvU,oBAAqB,IACrBwU,uBAAwB,IACxB/c,qBAAsB,IACtBgd,sBAAuB,IACvBC,sBAAuB,IACvB5c,kBAAmB,IACnBoQ,mBAAoB,IACpB9G,cAAe,IACf+D,mBAAoB,IACpBzF,2BAA4B;;q1BC7EhC,IAAMkV,gBACJC,aACE,UACA,QACA,gBACA,WAEFC,eACE,SACA,QACA,WAGFC,gBACE,MACA,OACA,MACA,OAEFC,kBACE,KACA,OACA,MACA,OAGFC,kBACE,IACA,KACA,OAEFC,oBACE,UACA,OACA,MAGFC,kBACE,IACA,MACA,IACA,OACA,MAEFC,oBACE,OACA,OACA,OACA,KACA,OAGFC,yBACE,IACA,IACA,MAEFC,2BACE,OACA,OACA,MACA,OACA,OACA,KACA,QAISC,eAAcxC,iBACtB6B,kBACDY,mBACE,SACA,YACA,SACA,aACA,WAEFC,qBACE,SACA,IACA,IACA,IACA,OACA,QACA,YAGFC,WACE,WACA,UACA,UAEFC,aACE,QACA,OACA,SAGFC,WACE,aACA,SACA,UACA,WACA,cACA,aACA,SACA,WAEFC,aACE,UACA,QACA,UAGFC,iBACE,IACA,KACA,MACA,KACA,MACA,QAEFC,mBACE,UACA,OACA,OACA,MACA,UACA,UAGFC,iBACE,IACA,QACA,OAEFC,mBACE,UACA,OACA,KACA,MACA,UACA,UAEFf,oBACE,UACA,OACA,MAGFgB,WACE,WACA,WACA,YAEFC,aACE,WACA,cACA,UACA,eACA,iBAGFC,gBACE,WACA,cACA,WACA,YAEFC,kBACE,UACA,eACA,wDAKC,IAAMC,kBAAgBvD,iBACxB6B,kBAED2B,iBACE,aACA,mBACA,yBACA,cAEFC,mBACE,cACA,0BACA,yBACA,aACA,aACA,YACA,UACA,aAGFC,cACE,YACA,aACA,gBACA,WAEFC,gBACE,WACA,SACA,UAGFC,cACE,SACA,SACA,WAEFC,gBACE,WACA,aACA,IACA,KAGFlB,WACE,WACA,UACA,SACA,UAEFC,aACE,QACA,OACA,SAGFC,WACE,aACA,SACA,UACA,eACA,WACA,cACA,aACA,SACA,UACA,SAEFC,aACE,UACA,QACA,UAGFG,iBACE,IACA,KACA,MACA,SACA,KACA,SAEFC,mBACE,UACA,OACA,UACA,UAGFY,uBACE,mBACA,UACA,MACA,SAEFC,yBACE,WACA,OACA,QACA,KAGFC,cACE,+BACA,kCACA,sBAAwB,IAAIC,OAAO,KACnC,kBACA,mBACA,cACA,WACA,IAEFC,gBACE,YACA,aACA,uCACA,mBACA,sBAAwB,IAAID,OAAO,MACnC,uBAAyB,IAAIA,OAAO,OAGtCE,kBACE,+BACA,kCACA,sBAAwB,IAAIF,OAAO,KACnC,kBACA,mBACA,cACA,WACA,IAEFG,oBACE,YACA,aACA,uCACA,mBACA,sBAAwB,IAAIH,OAAO,KACnC,uBAAyB,IAAIA,OAAO,MAGtCI,iBACE,WACA,WACA,OACA,UACA,UACA,aACA,cAEFC,mBACE,QACA,OACA,OACA;;kGC1UC,IAAMtV,kBACXuV,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,KAAMjP,GAAM,KAClEkP,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,MAAO75B,IAAO,MAAO85B,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,MA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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= this.apiLogLevel) {\n switch (messageLevel) {\n case api_constants.LOG_LEVEL_ERROR:\n console.error(logMessage);\n break;\n case api_constants.LOG_LEVEL_WARNING:\n console.warn(logMessage);\n break;\n case api_constants.LOG_LEVEL_INFO:\n console.info(logMessage);\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 stringContains(str: String, tester: String) {\n return str.indexOf(tester) > -1;\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 */\n getLmsErrorMessageDetails(_errorNumber, _detail) {\n return 'No error';\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 */\n getCMIValue(_CMIElement) {\n return '';\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 */\n setCMIValue(_CMIElement, _value) {\n // just a stub method\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 api_constants.SCORM_FALSE;\n }\n\n const structure = CMIElement.split('.');\n let refObject = this;\n let returnValue = api_constants.SCORM_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 (!{}.hasOwnProperty.call(refObject, attribute)) {\n this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n } else {\n if (this.stringContains(CMIElement, '.correct_responses')) {\n this.validateCorrectResponse(CMIElement, value);\n }\n\n if (!scorm2004 || this.lastErrorCode === 0) {\n refObject[attribute] = value;\n returnValue = api_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 } else {\n const newChild = this.getChildElement(CMIElement, value);\n\n if (!newChild) {\n this.throwSCORMError(invalidErrorCode, invalidErrorMessage);\n } else {\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 === api_constants.SCORM_FALSE) {\n this.apiLog(methodName, null,\n `There was an error setting the value for: ${CMIElement}, value of: ${value}`,\n api_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 * @return {*}\n */\n getChildElement(_CMIElement, _value) {\n return null;\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 for (let i = 0; i < structure.length; i++) {\n attribute = structure[i];\n\n if (!scorm2004) {\n if (i === structure.length - 1) {\n if (!{}.hasOwnProperty.call(refObject, attribute)) {\n this.throwSCORMError(101,\n 'getCMIValue did not find a value for: ' + CMIElement);\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 (!{}.hasOwnProperty.call(refObject, attribute)) {\n this.throwSCORMError(401,\n 'The data model element passed to GetValue (' + CMIElement +\n ') is not a valid SCORM data model element.');\n return '';\n }\n }\n\n refObject = refObject[attribute];\n }\n\n if (refObject === null || refObject === undefined) {\n if (!scorm2004) {\n if (attribute === '_children') {\n this.throwSCORMError(202);\n } else if (attribute === '_count') {\n this.throwSCORMError(203);\n }\n }\n return '';\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 === api_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 === api_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 === api_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 }\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 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 const CMIElementsMatch = listener.CMIElement === CMIElement;\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 api_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 !== api_constants.SCORM_FALSE) {\n this.lastErrorCode = 0;\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 || 'cmi';\n\n for (const key in json) {\n if ({}.hasOwnProperty.call(json, key) && json[key]) {\n const currentCMIElement = 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 renderCMIToJSON() {\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 * Throws a SCORM error\n *\n * @param {number} when - the number of milliseconds to wait before committing\n */\n scheduleCommit(when: number) {\n this.#timeout = new ScheduledCommit(this, when);\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 }\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\n /**\n * Constructor for ScheduledCommit\n * @param {BaseAPI} API\n * @param {number} when\n */\n constructor(API: any, when: number) {\n this.#API = API;\n this.#timeout = setTimeout(this.wrapper, when);\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();\n }\n }\n}\n","// @flow\nimport BaseAPI from './BaseAPI';\nimport {\n CMI,\n CMIInteractionsCorrectResponsesObject,\n CMIInteractionsObject,\n CMIInteractionsObjectivesObject,\n CMIObjectivesObject,\n} from './cmi/scorm12_cmi';\nimport * as Utilities from './utilities';\nimport {scorm12_constants} from './constants/api_constants';\nimport {scorm12_error_codes} from './constants/error_codes';\nimport {scorm12_regex} from './constants/regex';\n\nconst constants = scorm12_constants;\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 */\n constructor() {\n super(scorm12_error_codes);\n\n this.cmi = new CMI(this);\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 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 return this.terminate('LMSFinish', false);\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', 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 */\n setCMIValue(CMIElement, value) {\n 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 * @return {object}\n */\n getChildElement(CMIElement, value) {\n let newChild;\n\n if (this.stringContains(CMIElement, 'cmi.objectives')) {\n newChild = new CMIObjectivesObject(this);\n } else if (this.stringContains(CMIElement, '.correct_responses')) {\n newChild = new CMIInteractionsCorrectResponsesObject(this);\n } else if (this.stringContains(CMIElement, '.objectives')) {\n newChild = new CMIInteractionsObjectivesObject(this);\n } else if (this.stringContains(CMIElement, 'cmi.interactions')) {\n newChild = new CMIInteractionsObject(this);\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 (constants.error_descriptions[errorNumber]) {\n basicMessage = constants.error_descriptions[errorNumber].basicMessage;\n detailMessage = constants.error_descriptions[errorNumber].detailMessage;\n }\n\n return detail ? detailMessage : basicMessage;\n }\n\n /**\n * Adds the current session time to the existing total time.\n *\n * @return {string}\n */\n getCurrentTotalTime() {\n const timeRegex = new RegExp(scorm12_regex.CMITime);\n\n const totalTime = this.cmi.core.total_time;\n const sessionTime = this.cmi.core.session_time;\n\n return Utilities.addHHMMSSTimeStrings(totalTime, sessionTime, timeRegex);\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","// @flow\nimport BaseAPI from './BaseAPI';\nimport {\n ADL,\n CMI,\n CMICommentsFromLearnerObject,\n CMICommentsFromLMSObject,\n CMIInteractionsCorrectResponsesObject,\n CMIInteractionsObject,\n CMIInteractionsObjectivesObject,\n CMIObjectivesObject,\n} from './cmi/scorm2004_cmi';\nimport * as Util from './utilities';\nimport {scorm2004_constants} from './constants/api_constants';\nimport {scorm2004_error_codes} from './constants/error_codes';\nimport {correct_responses} from './constants/response_constants';\nimport {valid_languages} from './constants/language_constants';\nimport {scorm2004_regex} from './constants/regex';\n\nconst constants = scorm2004_constants;\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 */\n constructor() {\n super(scorm2004_error_codes);\n\n this.cmi = new CMI(this);\n this.adl = new ADL(this);\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 return this.initialize('Initialize');\n }\n\n /**\n * @return {string} bool\n */\n lmsTerminate() {\n return this.terminate('Terminate', true);\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', 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 */\n setCMIValue(CMIElement, value) {\n 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 * @return {any}\n */\n getChildElement(CMIElement, value) {\n let newChild;\n\n if (this.stringContains(CMIElement, 'cmi.objectives')) {\n newChild = new CMIObjectivesObject(this);\n } else if (this.stringContains(CMIElement, '.correct_responses')) {\n const parts = CMIElement.split('.');\n const index = Number(parts[2]);\n const interaction = this.cmi.interactions.childArray[index];\n if (typeof interaction.type === 'undefined') {\n this.throwSCORMError(scorm2004_error_codes.DEPENDENCY_NOT_ESTABLISHED);\n } else {\n const interaction_type = interaction.type;\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 const response_type = correct_responses[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 if (this.lastErrorCode === 0) {\n newChild = new CMIInteractionsCorrectResponsesObject(this);\n }\n } else if (this.stringContains(CMIElement, '.objectives')) {\n newChild = new CMIInteractionsObjectivesObject(this);\n } else if (this.stringContains(CMIElement, 'cmi.interactions')) {\n newChild = new CMIInteractionsObject(this);\n } else if (this.stringContains(CMIElement, 'cmi.comments_from_learner')) {\n newChild = new CMICommentsFromLearnerObject(this);\n } else if (this.stringContains(CMIElement, 'cmi.comments_from_lms')) {\n newChild = new CMICommentsFromLMSObject(this);\n }\n\n return newChild;\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_type = interaction.type;\n const interaction_count = interaction.correct_responses._count;\n if (interaction_type === 'choice') {\n for (let i = 0; i < interaction_count && this.lastErrorCode === 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 const response_type = scorm2004_constants.correct_responses[interaction_type];\n if (typeof response_type.limit !== 'undefined' || interaction_count <\n response_type.limit) {\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 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 (constants.error_descriptions[errorNumber]) {\n basicMessage = constants.error_descriptions[errorNumber].basicMessage;\n detailMessage = 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 !== undefined) {\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 (valid_languages[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 * Adds the current session time to the existing total time.\n *\n * @return {string} ISO8601 Duration\n */\n getCurrentTotalTime() {\n const totalTime = this.cmi.total_time;\n const sessionTime = this.cmi.session_time;\n\n return Util.addTwoDurations(totalTime, sessionTime,\n scorm2004_regex.CMITimespan);\n }\n}\n","import * as Scorm12CMI from './scorm12_cmi';\nimport {BaseCMI, CMIArray, CMIScore} from './common';\nimport {aicc_constants} from '../constants/api_constants';\nimport {aicc_regex} from '../constants/regex';\nimport {scorm12_error_codes} from '../constants/error_codes';\nimport {\n check12ValidFormat,\n throwReadOnlyError,\n throwWriteOnlyError,\n} from './scorm12_cmi';\n\nconst constants = aicc_constants;\nconst regex = aicc_regex;\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(constants.cmi_children);\n\n if (initialized) this.initialize();\n\n this.student_data = new AICCCMIStudentData();\n this.evaluation = new CMIEvaluation();\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_data?.initialize();\n this.evaluation?.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 'evaluation': this.evaluation,\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(constants.comments_children,\n scorm12_error_codes.INVALID_SET_VALUE);\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(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_data.tries object\n */\nexport class CMITries extends CMIArray {\n /**\n * Constructor for inline Tries Array class\n */\n constructor() {\n super(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: constants.score_children,\n score_range: 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 });\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 (check12ValidFormat(status, 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 (check12ValidFormat(time, 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 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 (check12ValidFormat(content, 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 (check12ValidFormat(location, 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 (check12ValidFormat(time, 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\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.jsonString) ? throwWriteOnlyError() : this.#event;\n }\n\n /**\n * Setter for #event\n * @param {string} event\n */\n set event(event) {\n if (check12ValidFormat(event, 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 {scorm12_constants} from '../constants/api_constants';\nimport {scorm12_error_codes} from '../constants/error_codes';\nimport {ValidationError} from '../exceptions';\nimport {scorm12_regex} from '../constants/regex';\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 {boolean} allowEmptyString\n * @return {boolean}\n */\nexport function checkValidFormat(\n value: String,\n regexPattern: String,\n errorCode: number,\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 ValidationError(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 * @return {boolean}\n */\nexport function checkValidRange(\n value: any, rangePattern: String, errorCode: number) {\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 ValidationError(errorCode);\n }\n } else {\n throw new ValidationError(errorCode);\n }\n}\n\n/**\n * Base class for API cmi objects\n */\nexport class BaseCMI {\n jsonString = false;\n #initialized = false;\n\n /**\n * Getter for #initialized\n * @return {boolean}\n */\n get initialized() {\n return this.#initialized;\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/**\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 */\n constructor(\n {\n score_children,\n score_range,\n max,\n invalidErrorCode,\n invalidTypeCode,\n invalidRangeCode,\n decimalRegex,\n }) {\n super();\n\n this.#_children = score_children ?\n 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 invalidErrorCode :\n scorm12_error_codes.INVALID_SET_VALUE;\n this.#_invalid_type_code = invalidTypeCode ?\n invalidTypeCode :\n scorm12_error_codes.TYPE_MISMATCH;\n this.#_invalid_range_code = invalidRangeCode ?\n invalidRangeCode :\n scorm12_error_codes.VALUE_OUT_OF_RANGE;\n this.#_decimal_regex = decimalRegex ?\n decimalRegex :\n scorm12_regex.CMIDecimal;\n }\n\n #_children;\n #_score_range;\n #_invalid_error_code;\n #_invalid_type_code;\n #_invalid_range_code;\n #_decimal_regex;\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 ValidationError(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,\n this.#_invalid_type_code) &&\n (!this.#_score_range ||\n checkValidRange(raw, this.#_score_range,\n this.#_invalid_range_code))) {\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,\n this.#_invalid_type_code) &&\n (!this.#_score_range ||\n checkValidRange(min, this.#_score_range,\n this.#_invalid_range_code))) {\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,\n this.#_invalid_type_code) &&\n (!this.#_score_range ||\n checkValidRange(max, this.#_score_range,\n this.#_invalid_range_code))) {\n this.#max = max;\n }\n }\n\n /**\n * toJSON for *.score\n * @return {{min: string, max: string, raw: string}}\n */\n toJSON() {\n return {\n 'raw': this.raw,\n 'min': this.min,\n 'max': this.max,\n };\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 */\n constructor({children, errorCode}) {\n super();\n this.#_children = children;\n this.#errorCode = errorCode;\n this.childArray = [];\n }\n\n #errorCode;\n #_children;\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 throw new ValidationError(this.#errorCode);\n }\n\n /**\n * Getter for _count\n * @return {number}\n * @private\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 * @private\n */\n set _count(_count) {\n throw new ValidationError(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 {scorm12_constants} from '../constants/api_constants';\nimport {scorm12_error_codes} from '../constants/error_codes';\nimport {scorm12_regex} from '../constants/regex';\nimport {ValidationError} from '../exceptions';\n\nconst constants = scorm12_constants;\nconst regex = scorm12_regex;\n\n/**\n * Helper method for throwing Read Only error\n */\nexport function throwReadOnlyError() {\n throw new ValidationError(scorm12_error_codes.READ_ONLY_ELEMENT);\n}\n\n/**\n * Helper method for throwing Write Only error\n */\nexport function throwWriteOnlyError() {\n throw new ValidationError(scorm12_error_codes.WRITE_ONLY_ELEMENT);\n}\n\n/**\n * Helper method for throwing Invalid Set error\n */\nfunction throwInvalidValueError() {\n throw new ValidationError(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 * @return {boolean}\n */\nexport function check12ValidFormat(value: String, regexPattern: String) {\n return checkValidFormat(value, regexPattern,\n scorm12_error_codes.TYPE_MISMATCH);\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 */\nexport function check12ValidRange(value: any, rangePattern: String) {\n return checkValidRange(value, rangePattern,\n scorm12_error_codes.VALUE_OUT_OF_RANGE);\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 #suspend_data = '';\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 ? cmi_children : 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 * @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 throwInvalidValueError();\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 #_version. Just throws an error.\n * @param {string} _children\n * @private\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.#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, regex.CMIString4096)) {\n this.#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, regex.CMIString4096)) {\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/**\n * Class representing the cmi.core object\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: constants.score_children,\n score_range: 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 });\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 = constants.core_children;\n #student_id = '';\n #student_name = '';\n #lesson_location = '';\n #credit = '';\n #lesson_status = '';\n #entry = '';\n #total_time = '';\n #lesson_mode = 'normal';\n #exit = '';\n #session_time = '00:00:00';\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, regex.CMIString256)) {\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 (check12ValidFormat(lesson_status, regex.CMIStatus)) {\n this.#lesson_status = lesson_status;\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, regex.CMIExit)) {\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, regex.CMITimespan)) {\n this.#session_time = session_time;\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 * total_time: 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 'total_time': this.total_time,\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 */\nclass CMIObjectives extends CMIArray {\n /**\n * Constructor for cmi.objectives\n */\n constructor() {\n super({\n children: constants.objectives_children,\n errorCode: scorm12_error_codes.INVALID_SET_VALUE,\n });\n }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.student_data object\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 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 */\nclass CMIStudentPreference extends BaseCMI {\n /**\n * Constructor for cmi.student_preference\n */\n constructor() {\n super();\n }\n\n #_children = constants.student_preference_children;\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, regex.CMISInteger) &&\n check12ValidRange(audio, 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, 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, regex.CMISInteger) &&\n check12ValidRange(speed, 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, regex.CMISInteger) &&\n check12ValidRange(text, 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 */\nclass CMIInteractions extends CMIArray {\n /**\n * Constructor for cmi.interactions\n */\n constructor() {\n super({\n children: constants.interactions_children,\n errorCode: scorm12_error_codes.INVALID_SET_VALUE,\n });\n }\n}\n\n/**\n * Class representing SCORM 1.2's cmi.interactions.n object\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 children: constants.objectives_children,\n });\n this.correct_responses = new CMIArray({\n errorCode: scorm12_error_codes.INVALID_SET_VALUE,\n children: 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, 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, 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, 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, regex.CMIDecimal) &&\n check12ValidRange(weighting, 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, regex.CMIFeedback)) {\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, 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, 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 */\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: constants.score_children,\n score_range: 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 });\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, 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, 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 */\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, 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 */\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, regex.CMIFeedback)) {\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","// @flow\nimport {\n BaseCMI,\n checkValidFormat,\n checkValidRange,\n CMIArray,\n CMIScore,\n} from './common';\nimport {scorm2004_constants} from '../constants/api_constants';\nimport {scorm2004_regex} from '../constants/regex';\nimport {scorm2004_error_codes} from '../constants/error_codes';\nimport {learner_responses} from '../constants/response_constants';\nimport {ValidationError} from '../exceptions';\n\nconst constants = scorm2004_constants;\nconst regex = scorm2004_regex;\n\n/**\n * Helper method for throwing Read Only error\n */\nfunction throwReadOnlyError() {\n throw new ValidationError(scorm2004_error_codes.READ_ONLY_ELEMENT);\n}\n\n/**\n * Helper method for throwing Write Only error\n */\nfunction throwWriteOnlyError() {\n throw new ValidationError(scorm2004_error_codes.WRITE_ONLY_ELEMENT);\n}\n\n/**\n * Helper method for throwing Type Mismatch error\n */\nfunction throwTypeMismatchError() {\n throw new ValidationError(scorm2004_error_codes.TYPE_MISMATCH);\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(value, regexPattern,\n scorm2004_error_codes.TYPE_MISMATCH, allowEmptyString);\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(value, rangePattern,\n scorm2004_error_codes.VALUE_OUT_OF_RANGE);\n}\n\n/**\n * Class representing cmi object for SCORM 2004\n */\nexport class CMI extends BaseCMI {\n #_version = '1.0';\n #_children = 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 = '0';\n\n /**\n * Constructor for the SCORM 2004 cmi object\n * @param {boolean} initialized\n */\n constructor(initialized: boolean) {\n super();\n\n if (initialized) this.initialize();\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\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, 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, regex.CMIExit)) {\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, 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, regex.CMIDecimal) &&\n check2004ValidRange(progress_measure, 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, 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, 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, regex.CMIString64000)) {\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 * 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 * total_time: 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 'total_time': this.total_time,\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 = 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, regex.CMIDecimal) &&\n check2004ValidRange(audio_level, 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, 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, regex.CMIDecimal) &&\n check2004ValidRange(delivery_speed, 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, regex.CMISInteger) &&\n check2004ValidRange(audio_captioning, 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: constants.interactions_children,\n errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\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: constants.objectives_children,\n errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\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: constants.comments_children,\n errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\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: constants.comments_children,\n errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\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 children: constants.objectives_children,\n });\n this.correct_responses = new CMIArray({\n errorCode: scorm2004_error_codes.READ_ONLY_ELEMENT,\n children: 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, 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 (check2004ValidFormat(type, regex.CMIType)) {\n this.#type = type;\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 (check2004ValidFormat(timestamp, regex.CMITime)) {\n this.#timestamp = timestamp;\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 (check2004ValidFormat(weighting, regex.CMIDecimal)) {\n this.#weighting = weighting;\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 (typeof this.type === 'undefined') {\n throw new ValidationError(\n scorm2004_error_codes.DEPENDENCY_NOT_ESTABLISHED);\n } else {\n let nodes = [];\n const response_type = learner_responses[this.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 (typeof response_type.delimiter2 !== 'undefined') {\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 throw new ValidationError(scorm2004_error_codes.GENERAL_SET_FAILURE);\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, 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 (check2004ValidFormat(latency, regex.CMITimespan)) {\n this.#latency = latency;\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 (check2004ValidFormat(description, regex.CMILangString250, true)) {\n this.#description = description;\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, 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 (check2004ValidFormat(success_status, regex.CMISStatus)) {\n this.#success_status = success_status;\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 (check2004ValidFormat(completion_status, regex.CMICStatus)) {\n this.#completion_status = completion_status;\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 (check2004ValidFormat(progress_measure, regex.CMIDecimal) &&\n check2004ValidRange(progress_measure, regex.progress_range)) {\n this.#progress_measure = progress_measure;\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 (check2004ValidFormat(description, regex.CMILangString250, true)) {\n this.#description = description;\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: constants.score_children,\n max: '',\n invalidErrorCode: scorm2004_error_codes.INVALID_SET_VALUE,\n invalidTypeCode: scorm2004_error_codes.TYPE_MISMATCH,\n invalidRangeCode: scorm2004_error_codes.VALUE_OUT_OF_RANGE,\n decimalRegex: scorm2004_regex.CMIDecimal,\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, regex.CMIDecimal) &&\n check2004ValidRange(scaled, 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 object\n */\nexport class CMICommentsFromLearnerObject extends BaseCMI {\n #comment = '';\n #location = '';\n #timestamp = '';\n\n /**\n * Constructor for cmi.comments_from_learner.n\n */\n constructor() {\n super();\n this.#comment = '';\n this.#location = '';\n this.#timestamp = '';\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 (check2004ValidFormat(comment, regex.CMILangString4000, true)) {\n this.#comment = comment;\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 (check2004ValidFormat(location, regex.CMIString250)) {\n this.#location = location;\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 (check2004ValidFormat(timestamp, regex.CMITime)) {\n this.#timestamp = timestamp;\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.comments_from_lms.n object\n */\nexport class CMICommentsFromLMSObject extends CMICommentsFromLearnerObject {\n /**\n * Constructor for cmi.comments_from_lms.n\n */\n constructor() {\n super();\n }\n\n /**\n * Getter for #comment\n * @return {string}\n */\n get comment() {\n return super.comment;\n }\n\n /**\n * Setter for #comment. Can only be called before initialization.\n * @param {string} comment\n */\n set comment(comment) {\n !this.initialized ? super.comment = comment : throwReadOnlyError();\n }\n\n /**\n * Getter for #location\n * @return {string}\n */\n get location() {\n return super.location;\n }\n\n /**\n * Setter for #location. Can only be called before initialization.\n * @param {string} location\n */\n set location(location) {\n !this.initialized ? super.location = location : throwReadOnlyError();\n }\n\n /**\n * Getter for #timestamp\n * @return {string}\n */\n get timestamp() {\n return super.timestamp;\n }\n\n /**\n * Setter for #timestamp. Can only be called before initialization.\n * @param {string} timestamp\n */\n set timestamp(timestamp) {\n !this.initialized ? super.timestamp = timestamp : throwReadOnlyError();\n }\n\n /**\n * toJSON for cmi.comments_from_lms.n\n * @return {\n * {\n * comment: string,\n * location: string,\n * timestamp: string\n * }\n * }\n */\n toJSON() {\n return super.toJSON();\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, 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, 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, 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\nexport const scorm12_constants = {\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 },\n};\n\nexport const aicc_constants = {\n ...scorm12_constants, ...{\n cmi_children: 'core,suspend_data,launch_data,comments,objectives,student_data,student_preference,interactions,evaluation',\n student_data_children: 'attempt_number,tries,mastery_score,max_time_allowed,time_limit_action',\n tries_children: 'time,status,score',\n },\n};\n\nexport const scorm2004_constants = {\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","// @flow\nexport const error_codes = {\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\nexport const scorm12_error_codes = {\n ...error_codes, ...{\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\nexport const scorm2004_error_codes = {\n ...error_codes, ...{\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","const common_values = {\n validResult: [\n 'correct',\n 'wrong',\n 'unanticipated',\n 'neutral',\n ],\n invalidResult: [\n '-10000',\n '10000',\n 'invalid',\n ],\n\n valid0To1Range: [\n '0.0',\n '0.25',\n '0.5',\n '1.0',\n ],\n invalid0To1Range: [\n '-1',\n '-0.1',\n '1.1',\n '.25',\n ],\n\n valid0To100Range: [\n '1',\n '50',\n '100',\n ],\n invalid0To100Range: [\n 'invalid',\n 'a100',\n '-1',\n ],\n\n validScaledRange: [\n '1',\n '0.5',\n '0',\n '-0.5',\n '-1',\n ],\n invalidScaledRange: [\n '-101',\n '25.1',\n '50.5',\n '75',\n '100',\n ],\n\n validIntegerScaledRange: [\n '1',\n '0',\n '-1',\n ],\n invalidIntegerScaledRange: [\n '-101',\n '-0.5',\n '0.5',\n '25.1',\n '50.5',\n '75',\n '100',\n ],\n};\n\nexport const scorm12_values = {\n ...common_values, ...{\n validLessonStatus: [\n 'passed',\n 'completed',\n 'failed',\n 'incomplete',\n 'browsed',\n ],\n invalidLessonStatus: [\n 'Passed',\n 'P',\n 'F',\n 'p',\n 'true',\n 'false',\n 'complete',\n ],\n\n validExit: [\n 'time-out',\n 'suspend',\n 'logout',\n ],\n invalidExit: [\n 'close',\n 'exit',\n 'crash',\n ],\n\n validType: [\n 'true-false',\n 'choice',\n 'fill-in',\n 'matching',\n 'performance',\n 'sequencing',\n 'likert',\n 'numeric',\n ],\n invalidType: [\n 'correct',\n 'wrong',\n 'logout',\n ],\n\n validSpeedRange: [\n '1',\n '50',\n '100',\n '-1',\n '-50',\n '-100',\n ],\n invalidSpeedRange: [\n 'invalid',\n 'a100',\n '-101',\n '101',\n '-100000',\n '100000',\n ],\n\n validScoreRange: [\n '1',\n '50.25',\n '100',\n ],\n invalidScoreRange: [\n 'invalid',\n 'a100',\n '-1',\n '101',\n '-100000',\n '100000',\n ],\n invalid0To100Range: [\n 'invalid',\n 'a100',\n '-2',\n ],\n\n validTime: [\n '10:06:57',\n '23:59:59',\n '00:00:00',\n ],\n invalidTime: [\n '47:59:59',\n '00:00:01.56',\n '06:5:13',\n '23:59:59.123',\n 'P1DT23H59M59S',\n ],\n\n validTimestamp: [\n '10:06:57',\n '00:00:01.56',\n '23:59:59',\n '47:59:59',\n ],\n invalidTimestamp: [\n '06:5:13',\n '23:59:59.123',\n 'P1DT23H59M59S',\n ],\n },\n};\n\nexport const scorm2004_values = {\n ...common_values, ...{\n // valid field values\n validTimestamps: [\n '2019-06-25',\n '2019-06-25T23:59',\n '2019-06-25T23:59:59.99',\n '1970-01-01',\n ],\n invalidTimestamps: [\n '2019-06-25T',\n '2019-06-25T23:59:59.999',\n '2019-06-25T25:59:59.99',\n '2019-13-31',\n '1969-12-31',\n '-00:00:30',\n '0:50:30',\n '23:00:30.',\n ],\n\n validCStatus: [\n 'completed',\n 'incomplete',\n 'not attempted',\n 'unknown',\n ],\n invalidCStatus: [\n 'complete',\n 'passed',\n 'failed',\n ],\n\n validSStatus: [\n 'passed',\n 'failed',\n 'unknown',\n ],\n invalidSStatus: [\n 'complete',\n 'incomplete',\n 'P',\n 'f',\n ],\n\n validExit: [\n 'time-out',\n 'suspend',\n 'logout',\n 'normal',\n ],\n invalidExit: [\n 'close',\n 'exit',\n 'crash',\n ],\n\n validType: [\n 'true-false',\n 'choice',\n 'fill-in',\n 'long-fill-in',\n 'matching',\n 'performance',\n 'sequencing',\n 'likert',\n 'numeric',\n 'other',\n ],\n invalidType: [\n 'correct',\n 'wrong',\n 'logout',\n ],\n\n validScoreRange: [\n '1',\n '50',\n '100',\n '-10000',\n '-1',\n '10000',\n ],\n invalidScoreRange: [\n 'invalid',\n 'a100',\n '-100000',\n '100000',\n ],\n\n validISO8601Durations: [\n 'P1Y34DT23H45M15S',\n 'PT1M45S',\n 'P0S',\n 'PT75M',\n ],\n invalidISO8601Durations: [\n '00:08:45',\n '-P1H',\n '1y45D',\n '0',\n ],\n\n validComment: [\n '{lang=en-98} learner comment',\n '{lang=eng-98-9} learner comment',\n '{lang=eng-98-9fhgj}' + 'x'.repeat(4000),\n 'learner comment',\n 'learner comment}',\n '{lang=i-xx}',\n '{lang=i}',\n '',\n ],\n invalidComment: [\n '{lang=i-}',\n '{lang=i-x}',\n '{lang=eng-98-9fhgj}{ learner comment',\n '{learner comment',\n '{lang=eng-98-9fhgj}' + 'x'.repeat(4001),\n '{lang=eng-98-9fhgj}{' + 'x'.repeat(3999),\n ],\n\n validDescription: [\n '{lang=en-98} learner comment',\n '{lang=eng-98-9} learner comment',\n '{lang=eng-98-9fhgj}' + 'x'.repeat(250),\n 'learner comment',\n 'learner comment}',\n '{lang=i-xx}',\n '{lang=i}',\n '',\n ],\n invalidDescription: [\n '{lang=i-}',\n '{lang=i-x}',\n '{lang=eng-98-9fhgj}{ learner comment',\n '{learner comment',\n '{lang=eng-98-9fhgj}' + 'x'.repeat(251),\n '{lang=eng-98-9fhgj}{' + 'x'.repeat(249),\n ],\n\n validNavRequest: [\n 'previous',\n 'continue',\n 'exit',\n 'exitAll',\n 'abandon',\n 'abandonAll',\n 'suspendAll',\n ],\n invalidNavRequest: [\n 'close',\n 'quit',\n 'next',\n 'before',\n ],\n },\n};\n","export const valid_languages = {\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","// @flow\n\nimport {scorm12_values, scorm2004_values} from './field_values';\n\nexport const scorm12_regex = {\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]{0,255}$',\n CMIFeedback: '^.{0,255}$', // This must be redefined\n CMIIndex: '[._](\\\\d+).',\n\n // Vocabulary Data Type Definition\n CMIStatus: '^(' + scorm12_values.validLessonStatus.join('|') + ')$',\n CMIStatus2: '^(' + scorm12_values.validLessonStatus.join('|') + '|not attempted)$',\n CMIExit: '^(' + scorm12_values.validExit.join('|') + '|)$',\n CMIType: '^(' + scorm12_values.validType.join('|') + ')$',\n CMIResult: '^(' + scorm12_values.validResult.join('|') + '|([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\nexport const aicc_regex = {\n ...scorm12_regex, ...{\n CMIIdentifier: '^\\\\w{1,255}$',\n },\n};\n\nexport const scorm2004_regex = {\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})$',\n CMIFeedback: '^.*$', // This must be redefined\n CMIIndex: '[._](\\\\d+).',\n CMIIndexStore: '.N(\\\\d+).',\n\n // Vocabulary Data Type Definition\n CMICStatus: '^(' + scorm2004_values.validCStatus.join('|') + ')$',\n CMISStatus: '^(' + scorm2004_values.validSStatus.join('|') + ')$',\n CMIExit: '^(' + scorm2004_values.validExit.join('|') + ')$',\n CMIType: '^(' + scorm2004_values.validType.join('|') + ')$',\n CMIResult: '^(' + scorm2004_values.validResult.join('|') + '|-?([0-9]{1,4})(\\\\.[0-9]{1,18})?)$',\n NAVEvent: '^(' + scorm2004_values.validNavRequest.join('|') + '|\\{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","// @flow\nimport {scorm2004_regex} from './regex';\n\nexport const learner_responses = {\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\nexport const correct_responses = {\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","// @flow\n\n/**\n * Data Validation Exception\n */\nexport class ValidationError extends Error {\n /**\n * Constructor to take in an error message and code\n * @param {number} errorCode\n */\n constructor(errorCode: number) {\n super(errorCode);\n this.#errorCode = errorCode;\n }\n\n #errorCode;\n\n /**\n * Getter for #errorCode\n * @return {number}\n */\n get errorCode() {\n return this.#errorCode;\n }\n\n /**\n * Trying to override the default Error message\n * @return {string}\n */\n get message() {\n return this.#errorCode + '';\n }\n}\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() + (totalSeconds % 1.0);\n\n return hours.toString().padStart(2, '0') + ':' +\n minutes.toString().padStart(2, '0') + ':' +\n seconds.toString().padStart(2, '0');\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 'P0S';\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 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 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 const now = new Date();\n const anchor = new Date(now);\n anchor.setFullYear(anchor.getFullYear() + Number(years || 0));\n anchor.setMonth(anchor.getMonth() + Number(months || 0));\n anchor.setDate(anchor.getDate() + Number(days || 0));\n anchor.setHours(anchor.getHours() + Number(hours || 0));\n anchor.setMinutes(anchor.getMinutes() + Number(minutes || 0));\n anchor.setSeconds(anchor.getSeconds() + Number(seconds || 0));\n if (seconds && String(seconds).indexOf('.') > 0) {\n const milliseconds = Number(Number(seconds) % 1).toFixed(6) * 1000.0;\n anchor.setMilliseconds(anchor.getMilliseconds() + milliseconds);\n }\n\n return ((anchor * 1.0) - now) / 1000.0;\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 const firstSeconds = getDurationAsSeconds(first, durationRegex);\n const secondSeconds = getDurationAsSeconds(second, durationRegex);\n\n return getSecondsAsISODuration(firstSeconds + secondSeconds);\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 const firstSeconds = getTimeAsSeconds(first, timeRegex);\n const secondSeconds = getTimeAsSeconds(second, timeRegex);\n return getSecondsAsHHMMSS(firstSeconds + secondSeconds);\n}\n"]} \ No newline at end of file diff --git a/dist/scorm-again.min.js b/dist/scorm-again.min.js new file mode 100644 index 0000000..b9d4e6f --- /dev/null +++ b/dist/scorm-again.min.js @@ -0,0 +1,36 @@ +(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=this.apiLogLevel)switch(i){case api_constants.LOG_LEVEL_ERROR:console.error(r);break;case api_constants.LOG_LEVEL_WARNING:console.warn(r);break;case api_constants.LOG_LEVEL_INFO:console.info(r)}}},{key:"formatMessage",value:function(e,t,r){var i="";i+=e;for(var s=20-i.length,a=0;a-1}},{key:"getLmsErrorMessageDetails",value:function(e,t){return"No error"}},{key:"getCMIValue",value:function(e){return""}},{key:"setCMIValue",value:function(e,t){}},{key:"_commonSetCMIValue",value:function(e,t,r,i){if(!r||""===r)return api_constants.SCORM_FALSE;for(var s=r.split("."),a=this,n=api_constants.SCORM_FALSE,o="The data model element passed to ".concat(e," (").concat(r,") is not a valid SCORM data model element."),l=t?_classPrivateFieldGet(this,_error_codes).UNDEFINED_DATA_MODEL:_classPrivateFieldGet(this,_error_codes).GENERAL,c=0;c1&&(n=e.replace(a+".","")),this.listenerArray.push({functionName:a,CMIElement:n,callback:t})}}},{key:"processListeners",value:function(e,t,r){for(var i=0;i0&&u.length<=_.max?this.checkCorrectResponseValue(n,u,r):u.length>_.max&&this.throwSCORMError(_error_codes.scorm2004_error_codes.GENERAL_SET_FAILURE,"Data Model Element Pattern Too Long")}0===this.lastErrorCode&&(t=new _scorm2004_cmi.CMIInteractionsCorrectResponsesObject(this))}else this.stringContains(e,".objectives")?t=new _scorm2004_cmi.CMIInteractionsObjectivesObject(this):this.stringContains(e,"cmi.interactions")?t=new _scorm2004_cmi.CMIInteractionsObject(this):this.stringContains(e,"cmi.comments_from_learner")?t=new _scorm2004_cmi.CMICommentsFromLearnerObject(this):this.stringContains(e,"cmi.comments_from_lms")&&(t=new _scorm2004_cmi.CMICommentsFromLMSObject(this));return t}},{key:"validateCorrectResponse",value:function(e,r){var t=e.split("."),o=Number(t[2]),s=Number(t[4]),i=this.cmi.interactions.childArray[o],n=i.type,c=i.correct_responses._count;if("choice"===n)for(var a=0;a0&&u.length<=_.max?this.checkCorrectResponseValue(n,u,r):u.length>_.max&&this.throwSCORMError(_error_codes.scorm2004_error_codes.GENERAL_SET_FAILURE,"Data Model Element Pattern Too Long"),0===this.lastErrorCode&&(!_.duplicate||!this.checkDuplicatedPattern(i.correct_responses,s,r))||0===this.lastErrorCode&&""===r||0===this.lastErrorCode&&this.throwSCORMError(_error_codes.scorm2004_error_codes.GENERAL_SET_FAILURE,"Data Model Element Pattern Already Exists")}else this.throwSCORMError(_error_codes.scorm2004_error_codes.GENERAL_SET_FAILURE,"Data Model Element Collection Limit Reached")}},{key:"getCMIValue",value:function(e){return this._commonGetCMIValue("GetValue",!0,e)}},{key:"getLmsErrorMessageDetails",value:function(e,r){var t="",o="";return e=String(e),constants.error_descriptions[e]&&(t=constants.error_descriptions[e].basicMessage,o=constants.error_descriptions[e].detailMessage),r?o:t}},{key:"checkCorrectResponseValue",value:function(e,r,t){for(var o=_response_constants.correct_responses[e],s=new RegExp(o.format),i=0;i1)Number(r[0])>Number(r[1])&&this.throwSCORMError(_error_codes.scorm2004_error_codes.TYPE_MISMATCH);else if(""!==r[i]&&o.unique)for(var l=0;l0&&void 0===_language_constants.valid_languages[c.toLowerCase()]&&this.throwSCORMError(_error_codes.scorm2004_error_codes.TYPE_MISMATCH)}o=!0;break;case"case_matters":o||r||t||"true"!==i[3]&&"false"!==i[3]&&this.throwSCORMError(_error_codes.scorm2004_error_codes.TYPE_MISMATCH),t=!0;break;case"order_matters":t||o||r||"true"!==i[3]&&"false"!==i[3]&&this.throwSCORMError(_error_codes.scorm2004_error_codes.TYPE_MISMATCH),r=!0}e=e.substr(i[1].length),i=e.match(s)}return e}},{key:"replaceWithAnotherScormAPI",value:function(e){this.cmi=e.cmi,this.adl=e.adl}},{key:"getCurrentTotalTime",value:function(){var e=this.cmi.total_time,r=this.cmi.session_time;return Util.addTwoDurations(e,r,_regex.scorm2004_regex.CMITimespan)}},{key:"version",get:function(){return _classPrivateFieldGet(this,_version)}}]),r}(_BaseAPI2.default);exports.default=Scorm2004API;var _version=new WeakMap; +},{"./BaseAPI":2,"./cmi/scorm2004_cmi":8,"./constants/api_constants":9,"./constants/error_codes":10,"./constants/language_constants":12,"./constants/regex":13,"./constants/response_constants":14,"./utilities":16}],5:[function(require,module,exports){ +"use strict";function _getRequireWildcardCache(){if("function"!=typeof WeakMap)return null;var t=new WeakMap;return _getRequireWildcardCache=function(){return t},t}function _interopRequireWildcard(t){if(t&&t.__esModule)return t;if(null===t||"object"!==_typeof(t)&&"function"!=typeof t)return{default:t};var e=_getRequireWildcardCache();if(e&&e.has(t))return e.get(t);var r={},i=Object.defineProperty&&Object.getOwnPropertyDescriptor;for(var n in t)if(Object.prototype.hasOwnProperty.call(t,n)){var o=i?Object.getOwnPropertyDescriptor(t,n):null;o&&(o.get||o.set)?Object.defineProperty(r,n,o):r[n]=t[n]}return r.default=t,e&&e.set(t,r),r}function _typeof(t){return(_typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}function _classPrivateFieldSet(t,e,r){var i=e.get(t);if(!i)throw new TypeError("attempted to set private field on non-instance");if(i.set)i.set.call(t,r);else{if(!i.writable)throw new TypeError("attempted to set read only private field");i.value=r}return r}function _classPrivateFieldGet(t,e){var r=e.get(t);if(!r)throw new TypeError("attempted to get private field on non-instance");return r.get?r.get.call(t):r.value}function _classCallCheck(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function _defineProperties(t,e){for(var r=0;r=r[0]){if("*"===r[1]||e<=r[1])return!0;throw new _exceptions.ValidationError(i)}throw new _exceptions.ValidationError(i)}Object.defineProperty(exports,"__esModule",{value:!0}),exports.checkValidFormat=checkValidFormat,exports.checkValidRange=checkValidRange,exports.CMIArray=exports.CMIScore=exports.BaseCMI=void 0;var _api_constants=require("../constants/api_constants"),_error_codes=require("../constants/error_codes"),_exceptions=require("../exceptions"),_regex=require("../constants/regex"),BaseCMI=function(){function e(){_classCallCheck(this,e),_defineProperty(this,"jsonString",!1),_initialized.set(this,{writable:!0,value:!1})}return _createClass(e,[{key:"initialize",value:function(){_classPrivateFieldSet(this,_initialized,!0)}},{key:"initialized",get:function(){return _classPrivateFieldGet(this,_initialized)}}]),e}();exports.BaseCMI=BaseCMI;var _initialized=new WeakMap,CMIScore=function(e){function t(e){var i,r=e.score_children,a=e.score_range,s=e.max,n=e.invalidErrorCode,o=e.invalidTypeCode,l=e.invalidRangeCode,_=e.decimalRegex;return _classCallCheck(this,t),i=_possibleConstructorReturn(this,_getPrototypeOf(t).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}),_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,r||_api_constants.scorm12_constants.score_children),_classPrivateFieldSet(_assertThisInitialized(i),_score_range,!!a&&_regex.scorm12_regex.score_range),_classPrivateFieldSet(_assertThisInitialized(i),_max,s||""===s?s:"100"),_classPrivateFieldSet(_assertThisInitialized(i),_invalid_error_code,n||_error_codes.scorm12_error_codes.INVALID_SET_VALUE),_classPrivateFieldSet(_assertThisInitialized(i),_invalid_type_code,o||_error_codes.scorm12_error_codes.TYPE_MISMATCH),_classPrivateFieldSet(_assertThisInitialized(i),_invalid_range_code,l||_error_codes.scorm12_error_codes.VALUE_OUT_OF_RANGE),_classPrivateFieldSet(_assertThisInitialized(i),_decimal_regex,_||_regex.scorm12_regex.CMIDecimal),i}return _inherits(t,e),_createClass(t,[{key:"toJSON",value:function(){return{raw:this.raw,min:this.min,max:this.max}}},{key:"_children",get:function(){return _classPrivateFieldGet(this,_children2)},set:function(e){throw new _exceptions.ValidationError(_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,_score_range)&&!checkValidRange(e,_classPrivateFieldGet(this,_score_range),_classPrivateFieldGet(this,_invalid_range_code))||_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,_score_range)&&!checkValidRange(e,_classPrivateFieldGet(this,_score_range),_classPrivateFieldGet(this,_invalid_range_code))||_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,_score_range)&&!checkValidRange(e,_classPrivateFieldGet(this,_score_range),_classPrivateFieldGet(this,_invalid_range_code))||_classPrivateFieldSet(this,_max,e)}}]),t}(BaseCMI);exports.CMIScore=CMIScore;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,_raw=new WeakMap,_min=new WeakMap,_max=new WeakMap,CMIArray=function(e){function t(e){var i,r=e.children,a=e.errorCode;return _classCallCheck(this,t),i=_possibleConstructorReturn(this,_getPrototypeOf(t).call(this)),_errorCode.set(_assertThisInitialized(i),{writable:!0,value:void 0}),_children3.set(_assertThisInitialized(i),{writable:!0,value:void 0}),_classPrivateFieldSet(_assertThisInitialized(i),_children3,r),_classPrivateFieldSet(_assertThisInitialized(i),_errorCode,a),i.childArray=[],i}return _inherits(t,e),_createClass(t,[{key:"toJSON",value:function(){this.jsonString=!0;for(var e={},t=0;t0&&t.length<=i.max))throw new _exceptions.ValidationError(_error_codes.scorm2004_error_codes.GENERAL_SET_FAILURE);for(var r=new RegExp(i.format),s=0;s0&&(s+=r),s&&(t+="".concat(s).concat(o))}),t}function getTimeAsSeconds(e,t){if(!e||"string"!=typeof e||!e.match(t))return 0;var r=e.split(":");return 3600*Number(r[0])+60*Number(r[1])+Number(r[2])}function getDurationAsSeconds(e,t){if(!e||!e.match(t))return 0;var r=new RegExp(t).exec(e)||[],n=_slicedToArray(r,8),o=n[1],S=n[2],s=n[4],i=n[5],a=n[6],u=n[7],E=new Date,_=new Date(E);if(_.setFullYear(_.getFullYear()+Number(o||0)),_.setMonth(_.getMonth()+Number(S||0)),_.setDate(_.getDate()+Number(s||0)),_.setHours(_.getHours()+Number(i||0)),_.setMinutes(_.getMinutes()+Number(a||0)),_.setSeconds(_.getSeconds()+Number(u||0)),u&&String(u).indexOf(".")>0){var c=1e3*Number(Number(u)%1).toFixed(6);_.setMilliseconds(_.getMilliseconds()+c)}return(1*_-E)/1e3}function addTwoDurations(e,t,r){return getSecondsAsISODuration(getDurationAsSeconds(e,r)+getDurationAsSeconds(t,r))}function addHHMMSSTimeStrings(e,t,r){return getSecondsAsHHMMSS(getTimeAsSeconds(e,r)+getTimeAsSeconds(t,r))}Object.defineProperty(exports,"__esModule",{value:!0}),exports.getSecondsAsHHMMSS=getSecondsAsHHMMSS,exports.getSecondsAsISODuration=getSecondsAsISODuration,exports.getTimeAsSeconds=getTimeAsSeconds,exports.getDurationAsSeconds=getDurationAsSeconds,exports.addTwoDurations=addTwoDurations,exports.addHHMMSSTimeStrings=addHHMMSSTimeStrings,exports.SECONDS_PER_DAY=exports.SECONDS_PER_HOUR=exports.SECONDS_PER_MINUTE=exports.SECONDS_PER_SECOND=void 0;var SECONDS_PER_SECOND=1;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]]; +},{}]},{},[1,2,5,6,7,8,9,10,11,12,13,14,15,3,4,16]) + + +//# sourceMappingURL=scorm-again.js.map \ No newline at end of file diff --git a/gruntfile.js b/gruntfile.js new file mode 100644 index 0000000..2da4308 --- /dev/null +++ b/gruntfile.js @@ -0,0 +1,61 @@ +module.exports = function(grunt) { + grunt.initConfig({ + browserify: { + development: { + src: [ + './src/**/*.js', + ], + dest: './dist/scorm-again.js', + options: { + browserifyOptions: {debug: true}, + transform: [ + [ + 'babelify', { + 'presets': ['@babel/preset-env', '@babel/preset-flow'], + 'plugins': [ + '@babel/plugin-proposal-class-properties', + '@babel/plugin-proposal-private-methods', + '@babel/plugin-proposal-optional-chaining', + ], + }, + ], + ], + }, + }, + production: { + src: [ + './src/**/*.js', + ], + dest: './dist/scorm-again.min.js', + options: { + browserifyOptions: {debug: true}, + transform: [ + [ + 'babelify', { + 'presets': ['@babel/preset-env', '@babel/preset-flow'], + 'plugins': [ + '@babel/plugin-proposal-class-properties', + '@babel/plugin-proposal-private-methods', + '@babel/plugin-proposal-optional-chaining', + ], + }, + ], + ], + plugin: [ + ['minifyify', + { + map: 'scorm-again.js.map', + output: './dist/scorm-again.js.map', + }], + ], + }, + }, + }, + + }); + + grunt.loadNpmTasks('grunt-browserify'); + + grunt.registerTask('default', + ['browserify:development', 'browserify:production']); +}; diff --git a/package-lock.json b/package-lock.json index d4cc0e9..e44478c 100644 --- a/package-lock.json +++ b/package-lock.json @@ -985,6 +985,22 @@ "integrity": "sha512-YvbLiIc0DbbhiANrfVObdkLEHJksQZVq0Uvfg550SRAKVYaEJy+V70j65BVe2WNp6E3HtKsUczeijHFCjba3og==", "dev": true }, + "JSONStream": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/JSONStream/-/JSONStream-1.3.5.tgz", + "integrity": "sha512-E+iruNOY8VV9s4JEbe1aNEm6MiszPRr/UfcHMz0TQh1BXSxHK+ASV1R6W4HpjBhSeS+54PIsAMCBmwD06LLsqQ==", + "dev": true, + "requires": { + "jsonparse": "^1.2.0", + "through": ">=2.2.7 <3" + } + }, + "abbrev": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz", + "integrity": "sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==", + "dev": true + }, "acorn": { "version": "7.1.0", "resolved": "https://registry.npmjs.org/acorn/-/acorn-7.1.0.tgz", @@ -997,6 +1013,23 @@ "integrity": "sha512-tMUqwBWfLFbJbizRmEcWSLw6HnFzfdJs2sOJEOwwtVPMoH/0Ay+E703oZz78VSXZiiDcZrQ5XKjPIUQixhmgVw==", "dev": true }, + "acorn-node": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/acorn-node/-/acorn-node-1.8.2.tgz", + "integrity": "sha512-8mt+fslDufLYntIoPAaIMUe/lrbrehIiwmR3t2k9LljIzoigEPF27eLk2hy8zSGzmR/ogr7zbRKINMo1u0yh5A==", + "dev": true, + "requires": { + "acorn": "^7.0.0", + "acorn-walk": "^7.0.0", + "xtend": "^4.0.2" + } + }, + "acorn-walk": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-7.0.0.tgz", + "integrity": "sha512-7Bv1We7ZGuU79zZbb6rRqcpxo3OY+zrdtloZWoyD8fmGX+FeXRjE+iuGkZjSXLVovLzrsvMGMy0EkwA0E0umxg==", + "dev": true + }, "ajv": { "version": "6.10.2", "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.10.2.tgz", @@ -1009,6 +1042,28 @@ "uri-js": "^4.2.2" } }, + "align-text": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/align-text/-/align-text-0.1.4.tgz", + "integrity": "sha1-DNkKVhCT810KmSVsIrcGlDP60Rc=", + "dev": true, + "requires": { + "kind-of": "^3.0.2", + "longest": "^1.0.1", + "repeat-string": "^1.5.2" + }, + "dependencies": { + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "dev": true, + "requires": { + "is-buffer": "^1.1.5" + } + } + } + }, "ansi-colors": { "version": "3.2.3", "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-3.2.3.tgz", @@ -1044,7 +1099,6 @@ "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-2.0.0.tgz", "integrity": "sha512-5teOsQWABXHHBFP9y3skS5P3d/WfWXpv3FUpy+LorMrNYaT9pI4oLMQX7jzQ2KklNpGpWHzdCXTDT2Y3XGlZBw==", "dev": true, - "optional": true, "requires": { "micromatch": "^3.1.4", "normalize-path": "^2.1.1" @@ -1055,7 +1109,6 @@ "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-2.1.1.tgz", "integrity": "sha1-GrKLVW4Zg2Oowab35vogE3/mrtk=", "dev": true, - "optional": true, "requires": { "remove-trailing-separator": "^1.0.1" } @@ -1090,22 +1143,37 @@ "version": "4.0.0", "resolved": "https://registry.npmjs.org/arr-diff/-/arr-diff-4.0.0.tgz", "integrity": "sha1-1kYQdP6/7HHn4VI1dhoyml3HxSA=", - "dev": true, - "optional": true + "dev": true }, "arr-flatten": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/arr-flatten/-/arr-flatten-1.1.0.tgz", "integrity": "sha512-L3hKV5R/p5o81R7O02IGnwpDmkp6E982XhtbuwSe3O4qOtMMMtodicASA1Cny2U+aCXcNpml+m4dPsvsJ3jatg==", - "dev": true, - "optional": true + "dev": true }, "arr-union": { "version": "3.1.0", "resolved": "https://registry.npmjs.org/arr-union/-/arr-union-3.1.0.tgz", "integrity": "sha1-45sJrqne+Gao8gbiiK9jkZuuOcQ=", - "dev": true, - "optional": true + "dev": true + }, + "array-differ": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/array-differ/-/array-differ-1.0.0.tgz", + "integrity": "sha1-7/UuN1gknTO+QCuLuOVkuytdQDE=", + "dev": true + }, + "array-each": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/array-each/-/array-each-1.0.1.tgz", + "integrity": "sha1-p5SvDAWrF1KEbudTofIRoFugxE8=", + "dev": true + }, + "array-find-index": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/array-find-index/-/array-find-index-1.0.2.tgz", + "integrity": "sha1-3wEKoSh+Fku9pvlyOwqWoexBh6E=", + "dev": true }, "array-includes": { "version": "3.0.3", @@ -1117,12 +1185,76 @@ "es-abstract": "^1.7.0" } }, + "array-slice": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/array-slice/-/array-slice-1.1.0.tgz", + "integrity": "sha512-B1qMD3RBP7O8o0H2KbrXDyB0IccejMF15+87Lvlor12ONPRHP6gTjXMNkt/d3ZuOGbAe66hFmaCfECI24Ufp6w==", + "dev": true + }, + "array-union": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/array-union/-/array-union-1.0.2.tgz", + "integrity": "sha1-mjRBDk9OPaI96jdb5b5w8kd47Dk=", + "dev": true, + "requires": { + "array-uniq": "^1.0.1" + } + }, + "array-uniq": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/array-uniq/-/array-uniq-1.0.3.tgz", + "integrity": "sha1-r2rId6Jcx/dOBYiUdThY39sk/bY=", + "dev": true + }, "array-unique": { "version": "0.3.2", "resolved": "https://registry.npmjs.org/array-unique/-/array-unique-0.3.2.tgz", "integrity": "sha1-qJS3XUvE9s1nnvMkSp/Y9Gri1Cg=", + "dev": true + }, + "arrify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/arrify/-/arrify-1.0.1.tgz", + "integrity": "sha1-iYUI2iIm84DfkEcoRWhJwVAaSw0=", + "dev": true + }, + "asn1.js": { + "version": "4.10.1", + "resolved": "https://registry.npmjs.org/asn1.js/-/asn1.js-4.10.1.tgz", + "integrity": "sha512-p32cOF5q0Zqs9uBiONKYLm6BClCoBCM5O9JfeUSlnQLBTxYdTK+pW+nXflm8UkKd2UYlEbYz5qEi0JuZR9ckSw==", "dev": true, - "optional": true + "requires": { + "bn.js": "^4.0.0", + "inherits": "^2.0.1", + "minimalistic-assert": "^1.0.0" + } + }, + "assert": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/assert/-/assert-1.5.0.tgz", + "integrity": "sha512-EDsgawzwoun2CZkCgtxJbv392v4nbk9XDD06zI+kQYoBM/3RBWLlEyJARDOmhAAosBjWACEkKL6S+lIZtcAubA==", + "dev": true, + "requires": { + "object-assign": "^4.1.1", + "util": "0.10.3" + }, + "dependencies": { + "inherits": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.1.tgz", + "integrity": "sha1-sX0I0ya0Qj5Wjv9xn5GwscvfafE=", + "dev": true + }, + "util": { + "version": "0.10.3", + "resolved": "https://registry.npmjs.org/util/-/util-0.10.3.tgz", + "integrity": "sha1-evsa/lCAUkZInj23/g7TeTNqwPk=", + "dev": true, + "requires": { + "inherits": "2.0.1" + } + } + } }, "assertion-error": { "version": "1.1.0", @@ -1134,8 +1266,7 @@ "version": "1.0.0", "resolved": "https://registry.npmjs.org/assign-symbols/-/assign-symbols-1.0.0.tgz", "integrity": "sha1-WWZ/QfrdTyDMvCu5a41Pf3jsA2c=", - "dev": true, - "optional": true + "dev": true }, "astral-regex": { "version": "1.0.0", @@ -1143,19 +1274,23 @@ "integrity": "sha512-+Ryf6g3BKoRc7jfp7ad8tM4TtMiaWvbF/1/sQcZPkkS7ag3D5nMBCe2UfOTONtAkaG0tO0ij3C5Lwmf1EiyjHg==", "dev": true }, + "async": { + "version": "1.5.2", + "resolved": "https://registry.npmjs.org/async/-/async-1.5.2.tgz", + "integrity": "sha1-7GphrlZIDAw8skHJVhjiCJL5Zyo=", + "dev": true + }, "async-each": { "version": "1.0.3", "resolved": "https://registry.npmjs.org/async-each/-/async-each-1.0.3.tgz", "integrity": "sha512-z/WhQ5FPySLdvREByI2vZiTWwCnF0moMJ1hK9YQwDTHKh6I7/uSckMetoRGb5UBZPC1z0jlw+n/XCgjeH7y1AQ==", - "dev": true, - "optional": true + "dev": true }, "atob": { "version": "2.1.2", "resolved": "https://registry.npmjs.org/atob/-/atob-2.1.2.tgz", "integrity": "sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg==", - "dev": true, - "optional": true + "dev": true }, "babel-eslint": { "version": "11.0.0-beta.0", @@ -1189,6 +1324,12 @@ "object.assign": "^4.1.0" } }, + "babelify": { + "version": "10.0.0", + "resolved": "https://registry.npmjs.org/babelify/-/babelify-10.0.0.tgz", + "integrity": "sha512-X40FaxyH7t3X+JFAKvb1H9wooWKLRCi8pg3m8poqtdZaIng+bjzp9RvKQCvRjF9isHiPkXspbbXT/zwXLtwgwg==", + "dev": true + }, "balanced-match": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz", @@ -1200,7 +1341,6 @@ "resolved": "https://registry.npmjs.org/base/-/base-0.11.2.tgz", "integrity": "sha512-5T6P4xPgpp0YDFvSWwEZ4NoE3aM4QBQXDzmVbraCkFj8zHM+mba8SyqB5DbZWyR7mYHo6Y7BdQo3MoA4m0TeQg==", "dev": true, - "optional": true, "requires": { "cache-base": "^1.0.1", "class-utils": "^0.3.5", @@ -1216,7 +1356,6 @@ "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz", "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=", "dev": true, - "optional": true, "requires": { "is-descriptor": "^1.0.0" } @@ -1226,7 +1365,6 @@ "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz", "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==", "dev": true, - "optional": true, "requires": { "kind-of": "^6.0.0" } @@ -1236,7 +1374,6 @@ "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz", "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==", "dev": true, - "optional": true, "requires": { "kind-of": "^6.0.0" } @@ -1246,7 +1383,6 @@ "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz", "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==", "dev": true, - "optional": true, "requires": { "is-accessor-descriptor": "^1.0.0", "is-data-descriptor": "^1.0.0", @@ -1255,12 +1391,17 @@ } } }, + "base64-js": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.3.1.tgz", + "integrity": "sha512-mLQ4i2QO1ytvGWFWmcngKO//JXAQueZvwEKtjgQFM4jIK0kU+ytMfplL8j+n5mspOfjHwoAg+9yhb7BwAHm36g==", + "dev": true + }, "binary-extensions": { "version": "1.13.1", "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-1.13.1.tgz", "integrity": "sha512-Un7MIEDdUC5gNpcGDV97op1Ywk748MpHcFTHoYs6qnj1Z3j7I53VG3nwZhKzoBZmbdRNnb6WRdFlwl7tSDuZGw==", - "dev": true, - "optional": true + "dev": true }, "bluebird": { "version": "3.7.1", @@ -1268,6 +1409,12 @@ "integrity": "sha512-DdmyoGCleJnkbp3nkbxTLJ18rjDsE4yCggEwKNXkeV123sPNfOCYeDoeuOY+F2FrSjO1YXcTU+dsy96KMy+gcg==", "dev": true }, + "bn.js": { + "version": "4.11.8", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.11.8.tgz", + "integrity": "sha512-ItfYfPLkWHUjckQCk8xC+LwxgK8NYcXywGigJgSwOP8Y2iyWT4f2vsZnoOXTTbo+o5yXmIUJ4gn5538SO5S3gA==", + "dev": true + }, "brace-expansion": { "version": "1.1.11", "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", @@ -1283,7 +1430,6 @@ "resolved": "https://registry.npmjs.org/braces/-/braces-2.3.2.tgz", "integrity": "sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w==", "dev": true, - "optional": true, "requires": { "arr-flatten": "^1.1.0", "array-unique": "^0.3.2", @@ -1302,19 +1448,231 @@ "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", "dev": true, - "optional": true, "requires": { "is-extendable": "^0.1.0" } } } }, + "brorand": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/brorand/-/brorand-1.1.0.tgz", + "integrity": "sha1-EsJe/kCkXjwyPrhnWgoM5XsiNx8=", + "dev": true + }, + "browser-pack": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/browser-pack/-/browser-pack-6.1.0.tgz", + "integrity": "sha512-erYug8XoqzU3IfcU8fUgyHqyOXqIE4tUTTQ+7mqUjQlvnXkOO6OlT9c/ZoJVHYoAaqGxr09CN53G7XIsO4KtWA==", + "dev": true, + "requires": { + "JSONStream": "^1.0.3", + "combine-source-map": "~0.8.0", + "defined": "^1.0.0", + "safe-buffer": "^5.1.1", + "through2": "^2.0.0", + "umd": "^3.0.0" + } + }, + "browser-resolve": { + "version": "1.11.3", + "resolved": "https://registry.npmjs.org/browser-resolve/-/browser-resolve-1.11.3.tgz", + "integrity": "sha512-exDi1BYWB/6raKHmDTCicQfTkqwN5fioMFV4j8BsfMU4R2DK/QfZfK7kOVkmWCNANf0snkBzqGqAJBao9gZMdQ==", + "dev": true, + "requires": { + "resolve": "1.1.7" + }, + "dependencies": { + "resolve": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.1.7.tgz", + "integrity": "sha1-IDEU2CrSxe2ejgQRs5ModeiJ6Xs=", + "dev": true + } + } + }, "browser-stdout": { "version": "1.3.1", "resolved": "https://registry.npmjs.org/browser-stdout/-/browser-stdout-1.3.1.tgz", "integrity": "sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==", "dev": true }, + "browserify": { + "version": "16.5.0", + "resolved": "https://registry.npmjs.org/browserify/-/browserify-16.5.0.tgz", + "integrity": "sha512-6bfI3cl76YLAnCZ75AGu/XPOsqUhRyc0F/olGIJeCxtfxF2HvPKEcmjU9M8oAPxl4uBY1U7Nry33Q6koV3f2iw==", + "dev": true, + "requires": { + "JSONStream": "^1.0.3", + "assert": "^1.4.0", + "browser-pack": "^6.0.1", + "browser-resolve": "^1.11.0", + "browserify-zlib": "~0.2.0", + "buffer": "^5.0.2", + "cached-path-relative": "^1.0.0", + "concat-stream": "^1.6.0", + "console-browserify": "^1.1.0", + "constants-browserify": "~1.0.0", + "crypto-browserify": "^3.0.0", + "defined": "^1.0.0", + "deps-sort": "^2.0.0", + "domain-browser": "^1.2.0", + "duplexer2": "~0.1.2", + "events": "^2.0.0", + "glob": "^7.1.0", + "has": "^1.0.0", + "htmlescape": "^1.1.0", + "https-browserify": "^1.0.0", + "inherits": "~2.0.1", + "insert-module-globals": "^7.0.0", + "labeled-stream-splicer": "^2.0.0", + "mkdirp": "^0.5.0", + "module-deps": "^6.0.0", + "os-browserify": "~0.3.0", + "parents": "^1.0.1", + "path-browserify": "~0.0.0", + "process": "~0.11.0", + "punycode": "^1.3.2", + "querystring-es3": "~0.2.0", + "read-only-stream": "^2.0.0", + "readable-stream": "^2.0.2", + "resolve": "^1.1.4", + "shasum": "^1.0.0", + "shell-quote": "^1.6.1", + "stream-browserify": "^2.0.0", + "stream-http": "^3.0.0", + "string_decoder": "^1.1.1", + "subarg": "^1.0.0", + "syntax-error": "^1.1.1", + "through2": "^2.0.0", + "timers-browserify": "^1.0.1", + "tty-browserify": "0.0.1", + "url": "~0.11.0", + "util": "~0.10.1", + "vm-browserify": "^1.0.0", + "xtend": "^4.0.0" + }, + "dependencies": { + "punycode": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.4.1.tgz", + "integrity": "sha1-wNWmOycYgArY4esPpSachN1BhF4=", + "dev": true + } + } + }, + "browserify-aes": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/browserify-aes/-/browserify-aes-1.2.0.tgz", + "integrity": "sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA==", + "dev": true, + "requires": { + "buffer-xor": "^1.0.3", + "cipher-base": "^1.0.0", + "create-hash": "^1.1.0", + "evp_bytestokey": "^1.0.3", + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" + } + }, + "browserify-cache-api": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/browserify-cache-api/-/browserify-cache-api-3.0.1.tgz", + "integrity": "sha1-liR+hT8Gj9bg1FzHPwuyzZd47wI=", + "dev": true, + "requires": { + "async": "^1.5.2", + "through2": "^2.0.0", + "xtend": "^4.0.0" + } + }, + "browserify-cipher": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/browserify-cipher/-/browserify-cipher-1.0.1.tgz", + "integrity": "sha512-sPhkz0ARKbf4rRQt2hTpAHqn47X3llLkUGn+xEJzLjwY8LRs2p0v7ljvI5EyoRO/mexrNunNECisZs+gw2zz1w==", + "dev": true, + "requires": { + "browserify-aes": "^1.0.4", + "browserify-des": "^1.0.0", + "evp_bytestokey": "^1.0.0" + } + }, + "browserify-des": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/browserify-des/-/browserify-des-1.0.2.tgz", + "integrity": "sha512-BioO1xf3hFwz4kc6iBhI3ieDFompMhrMlnDFC4/0/vd5MokpuAc3R+LYbwTA9A5Yc9pq9UYPqffKpW2ObuwX5A==", + "dev": true, + "requires": { + "cipher-base": "^1.0.1", + "des.js": "^1.0.0", + "inherits": "^2.0.1", + "safe-buffer": "^5.1.2" + } + }, + "browserify-incremental": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/browserify-incremental/-/browserify-incremental-3.1.1.tgz", + "integrity": "sha1-BxPLdYckemMqnwjPG9FpuHi2Koo=", + "dev": true, + "requires": { + "JSONStream": "^0.10.0", + "browserify-cache-api": "^3.0.0", + "through2": "^2.0.0", + "xtend": "^4.0.0" + }, + "dependencies": { + "JSONStream": { + "version": "0.10.0", + "resolved": "https://registry.npmjs.org/JSONStream/-/JSONStream-0.10.0.tgz", + "integrity": "sha1-dDSdDYlSK3HzDwoD/5vSDKbxKsA=", + "dev": true, + "requires": { + "jsonparse": "0.0.5", + "through": ">=2.2.7 <3" + } + }, + "jsonparse": { + "version": "0.0.5", + "resolved": "https://registry.npmjs.org/jsonparse/-/jsonparse-0.0.5.tgz", + "integrity": "sha1-MwVCrT8KZUZlt3jz6y2an6UHrGQ=", + "dev": true + } + } + }, + "browserify-rsa": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/browserify-rsa/-/browserify-rsa-4.0.1.tgz", + "integrity": "sha1-IeCr+vbyApzy+vsTNWenAdQTVSQ=", + "dev": true, + "requires": { + "bn.js": "^4.1.0", + "randombytes": "^2.0.1" + } + }, + "browserify-sign": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/browserify-sign/-/browserify-sign-4.0.4.tgz", + "integrity": "sha1-qk62jl17ZYuqa/alfmMMvXqT0pg=", + "dev": true, + "requires": { + "bn.js": "^4.1.1", + "browserify-rsa": "^4.0.0", + "create-hash": "^1.1.0", + "create-hmac": "^1.1.2", + "elliptic": "^6.0.0", + "inherits": "^2.0.1", + "parse-asn1": "^5.0.0" + } + }, + "browserify-zlib": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/browserify-zlib/-/browserify-zlib-0.2.0.tgz", + "integrity": "sha512-Z942RysHXmJrhqk88FmKBVq/v5tqmSkDz7p54G/MGyjMnCFFnC79XWNbg+Vta8W6Wb2qtSZTSxIGkJrRpCFEiA==", + "dev": true, + "requires": { + "pako": "~1.0.5" + } + }, "browserslist": { "version": "4.7.2", "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.7.2.tgz", @@ -1326,18 +1684,39 @@ "node-releases": "^1.1.38" } }, + "buffer": { + "version": "5.4.3", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.4.3.tgz", + "integrity": "sha512-zvj65TkFeIt3i6aj5bIvJDzjjQQGs4o/sNoezg1F1kYap9Nu2jcUdpwzRSJTHMMzG0H7bZkn4rNQpImhuxWX2A==", + "dev": true, + "requires": { + "base64-js": "^1.0.2", + "ieee754": "^1.1.4" + } + }, "buffer-from": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.1.tgz", "integrity": "sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A==", "dev": true }, + "buffer-xor": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/buffer-xor/-/buffer-xor-1.0.3.tgz", + "integrity": "sha1-JuYe0UIvtw3ULm42cp7VHYVf6Nk=", + "dev": true + }, + "builtin-status-codes": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/builtin-status-codes/-/builtin-status-codes-3.0.0.tgz", + "integrity": "sha1-hZgoeOIbmOHGZCXgPQF0eI9Wnug=", + "dev": true + }, "cache-base": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/cache-base/-/cache-base-1.0.1.tgz", "integrity": "sha512-AKcdTnFSWATd5/GCPRxr2ChwIJ85CeyrEyjRHlKxQ56d4XJMGym0uAiKn0xbLOGOl3+yRpOTi484dVCEc5AUzQ==", "dev": true, - "optional": true, "requires": { "collection-visit": "^1.0.0", "component-emitter": "^1.2.1", @@ -1350,6 +1729,12 @@ "unset-value": "^1.0.0" } }, + "cached-path-relative": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/cached-path-relative/-/cached-path-relative-1.0.2.tgz", + "integrity": "sha512-5r2GqsoEb4qMTTN9J+WzXfjov+hjxT+j3u5K+kIVNIwAd99DLCJE9pBIMP1qVeybV6JiijL385Oz0DcYxfbOIg==", + "dev": true + }, "caching-transform": { "version": "3.0.2", "resolved": "https://registry.npmjs.org/caching-transform/-/caching-transform-3.0.2.tgz", @@ -1374,6 +1759,24 @@ "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==", "dev": true }, + "camelcase-keys": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/camelcase-keys/-/camelcase-keys-2.1.0.tgz", + "integrity": "sha1-MIvur/3ygRkFHvodkyITyRuPkuc=", + "dev": true, + "requires": { + "camelcase": "^2.0.0", + "map-obj": "^1.0.0" + }, + "dependencies": { + "camelcase": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-2.1.1.tgz", + "integrity": "sha1-fB0W1nmhu+WcoCys7PsBHiAfWh8=", + "dev": true + } + } + }, "caniuse-lite": { "version": "1.0.30001008", "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001008.tgz", @@ -1389,6 +1792,16 @@ "lodash": "^4.17.14" } }, + "center-align": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/center-align/-/center-align-0.1.3.tgz", + "integrity": "sha1-qg0yYptu6XIgBBHL1EYckHvCt60=", + "dev": true, + "requires": { + "align-text": "^0.1.3", + "lazy-cache": "^1.0.3" + } + }, "chai": { "version": "4.2.0", "resolved": "https://registry.npmjs.org/chai/-/chai-4.2.0.tgz", @@ -1445,7 +1858,6 @@ "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-2.1.8.tgz", "integrity": "sha512-ZmZUazfOzf0Nve7duiCKD23PFSCs4JPoYyccjUFF3aQkQadqBhfzhjkwBH2mNOG9cTBwhamM37EIsIkZw3nRgg==", "dev": true, - "optional": true, "requires": { "anymatch": "^2.0.0", "async-each": "^1.0.1", @@ -1461,12 +1873,21 @@ "upath": "^1.1.1" } }, + "cipher-base": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/cipher-base/-/cipher-base-1.0.4.tgz", + "integrity": "sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==", + "dev": true, + "requires": { + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" + } + }, "class-utils": { "version": "0.3.6", "resolved": "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz", "integrity": "sha512-qOhPa/Fj7s6TY8H8esGu5QNpMMQxz79h+urzrNYN6mn+9BnxlDGf5QZ+XeCDsxSjPqsSR56XOZOJmpeurnLMeg==", "dev": true, - "optional": true, "requires": { "arr-union": "^3.1.0", "define-property": "^0.2.5", @@ -1479,7 +1900,6 @@ "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", "dev": true, - "optional": true, "requires": { "is-descriptor": "^0.1.0" } @@ -1540,12 +1960,17 @@ } } }, + "coffeescript": { + "version": "1.10.0", + "resolved": "https://registry.npmjs.org/coffeescript/-/coffeescript-1.10.0.tgz", + "integrity": "sha1-56qDAZF+9iGzXYo580jc3R234z4=", + "dev": true + }, "collection-visit": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/collection-visit/-/collection-visit-1.0.0.tgz", "integrity": "sha1-S8A3PBZLwykbTTaMgpzxqApZ3KA=", "dev": true, - "optional": true, "requires": { "map-visit": "^1.0.0", "object-visit": "^1.0.0" @@ -1566,6 +1991,32 @@ "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=", "dev": true }, + "colors": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/colors/-/colors-1.1.2.tgz", + "integrity": "sha1-FopHAXVran9RoSzgyXv6KMCE7WM=", + "dev": true + }, + "combine-source-map": { + "version": "0.8.0", + "resolved": "https://registry.npmjs.org/combine-source-map/-/combine-source-map-0.8.0.tgz", + "integrity": "sha1-pY0N8ELBhvz4IqjoAV9UUNLXmos=", + "dev": true, + "requires": { + "convert-source-map": "~1.1.0", + "inline-source-map": "~0.6.0", + "lodash.memoize": "~3.0.3", + "source-map": "~0.5.3" + }, + "dependencies": { + "convert-source-map": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.1.3.tgz", + "integrity": "sha1-SCnId+n+SbMWHzvzZziI4gRpmGA=", + "dev": true + } + } + }, "commondir": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/commondir/-/commondir-1.0.1.tgz", @@ -1576,8 +2027,7 @@ "version": "1.3.0", "resolved": "https://registry.npmjs.org/component-emitter/-/component-emitter-1.3.0.tgz", "integrity": "sha512-Rd3se6QB+sO1TwqZjscQrurpEPIfO0/yYnSin6Q/rD3mOutHvUrCAhJub3r90uNb+SESBuE0QYoB90YdfatsRg==", - "dev": true, - "optional": true + "dev": true }, "concat-map": { "version": "0.0.1", @@ -1585,6 +2035,30 @@ "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=", "dev": true }, + "concat-stream": { + "version": "1.6.2", + "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.2.tgz", + "integrity": "sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==", + "dev": true, + "requires": { + "buffer-from": "^1.0.0", + "inherits": "^2.0.3", + "readable-stream": "^2.2.2", + "typedarray": "^0.0.6" + } + }, + "console-browserify": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/console-browserify/-/console-browserify-1.2.0.tgz", + "integrity": "sha512-ZMkYO/LkF17QvCPqM0gxw8yUzigAOZOSWSHg91FH6orS7vcEj5dVZTidN2fQ14yBSdg97RqhSNwLUXInd52OTA==", + "dev": true + }, + "constants-browserify": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/constants-browserify/-/constants-browserify-1.0.0.tgz", + "integrity": "sha1-wguW2MYXdIqvHBYCF2DNJ/y4y3U=", + "dev": true + }, "contains-path": { "version": "0.1.0", "resolved": "https://registry.npmjs.org/contains-path/-/contains-path-0.1.0.tgz", @@ -1604,8 +2078,7 @@ "version": "0.1.1", "resolved": "https://registry.npmjs.org/copy-descriptor/-/copy-descriptor-0.1.1.tgz", "integrity": "sha1-Z29us8OZl8LuGsOpJP1hJHSPV40=", - "dev": true, - "optional": true + "dev": true }, "core-js-compat": { "version": "3.4.0", @@ -1629,8 +2102,7 @@ "version": "1.0.2", "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz", "integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=", - "dev": true, - "optional": true + "dev": true }, "cp-file": { "version": "6.2.0", @@ -1645,6 +2117,43 @@ "safe-buffer": "^5.0.1" } }, + "create-ecdh": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/create-ecdh/-/create-ecdh-4.0.3.tgz", + "integrity": "sha512-GbEHQPMOswGpKXM9kCWVrremUcBmjteUaQ01T9rkKCPDXfUHX0IoP9LpHYo2NPFampa4e+/pFDc3jQdxrxQLaw==", + "dev": true, + "requires": { + "bn.js": "^4.1.0", + "elliptic": "^6.0.0" + } + }, + "create-hash": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/create-hash/-/create-hash-1.2.0.tgz", + "integrity": "sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==", + "dev": true, + "requires": { + "cipher-base": "^1.0.1", + "inherits": "^2.0.1", + "md5.js": "^1.3.4", + "ripemd160": "^2.0.1", + "sha.js": "^2.4.0" + } + }, + "create-hmac": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/create-hmac/-/create-hmac-1.1.7.tgz", + "integrity": "sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==", + "dev": true, + "requires": { + "cipher-base": "^1.0.3", + "create-hash": "^1.1.0", + "inherits": "^2.0.1", + "ripemd160": "^2.0.0", + "safe-buffer": "^5.0.1", + "sha.js": "^2.4.8" + } + }, "cross-spawn": { "version": "6.0.5", "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-6.0.5.tgz", @@ -1664,6 +2173,40 @@ "integrity": "sha1-iNf/fsDfuG9xPch7u0LQRNPmxBs=", "dev": true }, + "crypto-browserify": { + "version": "3.12.0", + "resolved": "https://registry.npmjs.org/crypto-browserify/-/crypto-browserify-3.12.0.tgz", + "integrity": "sha512-fz4spIh+znjO2VjL+IdhEpRJ3YN6sMzITSBijk6FK2UvTqruSQW+/cCZTSNsMiZNvUeq0CqurF+dAbyiGOY6Wg==", + "dev": true, + "requires": { + "browserify-cipher": "^1.0.0", + "browserify-sign": "^4.0.0", + "create-ecdh": "^4.0.0", + "create-hash": "^1.1.0", + "create-hmac": "^1.1.0", + "diffie-hellman": "^5.0.0", + "inherits": "^2.0.1", + "pbkdf2": "^3.0.3", + "public-encrypt": "^4.0.0", + "randombytes": "^2.0.0", + "randomfill": "^1.0.3" + } + }, + "currently-unhandled": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/currently-unhandled/-/currently-unhandled-0.4.1.tgz", + "integrity": "sha1-mI3zP+qxke95mmE2nddsF635V+o=", + "dev": true, + "requires": { + "array-find-index": "^1.0.1" + } + }, + "dash-ast": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/dash-ast/-/dash-ast-1.0.0.tgz", + "integrity": "sha512-Vy4dx7gquTeMcQR/hDkYLGUnwVil6vk4FOOct+djUnHOUWt+zJPJAaRIXaAFkPXtJjvlY7o3rfRu0/3hpnwoUA==", + "dev": true + }, "dateformat": { "version": "3.0.3", "resolved": "https://registry.npmjs.org/dateformat/-/dateformat-3.0.3.tgz", @@ -1689,8 +2232,7 @@ "version": "0.2.0", "resolved": "https://registry.npmjs.org/decode-uri-component/-/decode-uri-component-0.2.0.tgz", "integrity": "sha1-6zkTMzRYd1y4TNGh+uBiEGu4dUU=", - "dev": true, - "optional": true + "dev": true }, "deep-eql": { "version": "3.0.1", @@ -1730,7 +2272,6 @@ "resolved": "https://registry.npmjs.org/define-property/-/define-property-2.0.2.tgz", "integrity": "sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ==", "dev": true, - "optional": true, "requires": { "is-descriptor": "^1.0.2", "isobject": "^3.0.1" @@ -1741,7 +2282,6 @@ "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz", "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==", "dev": true, - "optional": true, "requires": { "kind-of": "^6.0.0" } @@ -1751,7 +2291,6 @@ "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz", "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==", "dev": true, - "optional": true, "requires": { "kind-of": "^6.0.0" } @@ -1761,7 +2300,6 @@ "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz", "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==", "dev": true, - "optional": true, "requires": { "is-accessor-descriptor": "^1.0.0", "is-data-descriptor": "^1.0.0", @@ -1770,12 +2308,68 @@ } } }, + "defined": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/defined/-/defined-1.0.0.tgz", + "integrity": "sha1-yY2bzvdWdBiOEQlpFRGZ45sfppM=", + "dev": true + }, + "deps-sort": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/deps-sort/-/deps-sort-2.0.1.tgz", + "integrity": "sha512-1orqXQr5po+3KI6kQb9A4jnXT1PBwggGl2d7Sq2xsnOeI9GPcE/tGcF9UiSZtZBM7MukY4cAh7MemS6tZYipfw==", + "dev": true, + "requires": { + "JSONStream": "^1.0.3", + "shasum-object": "^1.0.0", + "subarg": "^1.0.0", + "through2": "^2.0.0" + } + }, + "des.js": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/des.js/-/des.js-1.0.1.tgz", + "integrity": "sha512-Q0I4pfFrv2VPd34/vfLrFOoRmlYj3OV50i7fskps1jZWK1kApMWWT9G6RRUeYedLcBDIhnSDaUvJMb3AhUlaEA==", + "dev": true, + "requires": { + "inherits": "^2.0.1", + "minimalistic-assert": "^1.0.0" + } + }, + "detect-file": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/detect-file/-/detect-file-1.0.0.tgz", + "integrity": "sha1-8NZtA2cqglyxtzvbP+YjEMjlUrc=", + "dev": true + }, + "detective": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/detective/-/detective-5.2.0.tgz", + "integrity": "sha512-6SsIx+nUUbuK0EthKjv0zrdnajCCXVYGmbYYiYjFVpzcjwEs/JMDZ8tPRG29J/HhN56t3GJp2cGSWDRjjot8Pg==", + "dev": true, + "requires": { + "acorn-node": "^1.6.1", + "defined": "^1.0.0", + "minimist": "^1.1.1" + } + }, "diff": { "version": "4.0.1", "resolved": "https://registry.npmjs.org/diff/-/diff-4.0.1.tgz", "integrity": "sha512-s2+XdvhPCOF01LRQBC8hf4vhbVmI2CGS5aZnxLJlT5FtdhPCDFq80q++zK2KlrVorVDdL5BOGZ/VfLrVtYNF+Q==", "dev": true }, + "diffie-hellman": { + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/diffie-hellman/-/diffie-hellman-5.0.3.tgz", + "integrity": "sha512-kqag/Nl+f3GwyK25fhUMYj81BUOrZ9IuJsjIcDE5icNM9FJHAVm3VcUDxdLPoQtTuUylWm6ZIknYJwwaPxsUzg==", + "dev": true, + "requires": { + "bn.js": "^4.1.0", + "miller-rabin": "^4.0.0", + "randombytes": "^2.0.0" + } + }, "doctrine": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz", @@ -1785,12 +2379,42 @@ "esutils": "^2.0.2" } }, + "domain-browser": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/domain-browser/-/domain-browser-1.2.0.tgz", + "integrity": "sha512-jnjyiM6eRyZl2H+W8Q/zLMA481hzi0eszAaBUzIVnmYVDBbnLxVNnfu1HgEBvCbL+71FrxMl3E6lpKH7Ge3OXA==", + "dev": true + }, + "duplexer2": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/duplexer2/-/duplexer2-0.1.4.tgz", + "integrity": "sha1-ixLauHjA1p4+eJEFFmKjL8a93ME=", + "dev": true, + "requires": { + "readable-stream": "^2.0.2" + } + }, "electron-to-chromium": { "version": "1.3.306", "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.3.306.tgz", "integrity": "sha512-frDqXvrIROoYvikSKTIKbHbzO6M3/qC6kCIt/1FOa9kALe++c4VAJnwjSFvf1tYLEUsP2n9XZ4XSCyqc3l7A/A==", "dev": true }, + "elliptic": { + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.5.1.tgz", + "integrity": "sha512-xvJINNLbTeWQjrl6X+7eQCrIy/YPv5XCpKW6kB5mKvtnGILoLDcySuwomfdzt0BMdLNVnuRNTuzKNHj0bva1Cg==", + "dev": true, + "requires": { + "bn.js": "^4.4.0", + "brorand": "^1.0.1", + "hash.js": "^1.0.0", + "hmac-drbg": "^1.0.0", + "inherits": "^2.0.1", + "minimalistic-assert": "^1.0.0", + "minimalistic-crypto-utils": "^1.0.0" + } + }, "emoji-regex": { "version": "7.0.3", "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz", @@ -2234,12 +2858,39 @@ "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==", "dev": true }, + "eventemitter2": { + "version": "0.4.14", + "resolved": "https://registry.npmjs.org/eventemitter2/-/eventemitter2-0.4.14.tgz", + "integrity": "sha1-j2G3XN4BKy6esoTUVFWDtWQ7Yas=", + "dev": true + }, + "events": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/events/-/events-2.1.0.tgz", + "integrity": "sha512-3Zmiobend8P9DjmKAty0Era4jV8oJ0yGYe2nJJAxgymF9+N8F2m0hhZiMoWtcfepExzNKZumFU3ksdQbInGWCg==", + "dev": true + }, + "evp_bytestokey": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/evp_bytestokey/-/evp_bytestokey-1.0.3.tgz", + "integrity": "sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==", + "dev": true, + "requires": { + "md5.js": "^1.3.4", + "safe-buffer": "^5.1.1" + } + }, + "exit": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/exit/-/exit-0.1.2.tgz", + "integrity": "sha1-BjJjj42HfMghB9MKD/8aF8uhzQw=", + "dev": true + }, "expand-brackets": { "version": "2.1.4", "resolved": "https://registry.npmjs.org/expand-brackets/-/expand-brackets-2.1.4.tgz", "integrity": "sha1-t3c14xXOMPa27/D4OwQVGiJEliI=", "dev": true, - "optional": true, "requires": { "debug": "^2.3.3", "define-property": "^0.2.5", @@ -2255,7 +2906,6 @@ "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", "dev": true, - "optional": true, "requires": { "is-descriptor": "^0.1.0" } @@ -2265,19 +2915,32 @@ "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", "dev": true, - "optional": true, "requires": { "is-extendable": "^0.1.0" } } } }, + "expand-tilde": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/expand-tilde/-/expand-tilde-2.0.2.tgz", + "integrity": "sha1-l+gBqgUt8CRU3kawK/YhZCzchQI=", + "dev": true, + "requires": { + "homedir-polyfill": "^1.0.1" + } + }, + "extend": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz", + "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==", + "dev": true + }, "extend-shallow": { "version": "3.0.2", "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz", "integrity": "sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=", "dev": true, - "optional": true, "requires": { "assign-symbols": "^1.0.0", "is-extendable": "^1.0.1" @@ -2288,7 +2951,6 @@ "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz", "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==", "dev": true, - "optional": true, "requires": { "is-plain-object": "^2.0.4" } @@ -2311,7 +2973,6 @@ "resolved": "https://registry.npmjs.org/extglob/-/extglob-2.0.4.tgz", "integrity": "sha512-Nmb6QXkELsuBr24CJSkilo6UHHgbekK5UiZgfE6UHD3Eb27YC6oD+bhcT+tJ6cl8dmsgdQxnWlcry8ksBIBLpw==", "dev": true, - "optional": true, "requires": { "array-unique": "^0.3.2", "define-property": "^1.0.0", @@ -2328,7 +2989,6 @@ "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz", "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=", "dev": true, - "optional": true, "requires": { "is-descriptor": "^1.0.0" } @@ -2338,7 +2998,6 @@ "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", "dev": true, - "optional": true, "requires": { "is-extendable": "^0.1.0" } @@ -2348,7 +3007,6 @@ "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz", "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==", "dev": true, - "optional": true, "requires": { "kind-of": "^6.0.0" } @@ -2358,7 +3016,6 @@ "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz", "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==", "dev": true, - "optional": true, "requires": { "kind-of": "^6.0.0" } @@ -2368,7 +3025,6 @@ "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz", "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==", "dev": true, - "optional": true, "requires": { "is-accessor-descriptor": "^1.0.0", "is-data-descriptor": "^1.0.0", @@ -2395,6 +3051,12 @@ "integrity": "sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=", "dev": true }, + "fast-safe-stringify": { + "version": "2.0.7", + "resolved": "https://registry.npmjs.org/fast-safe-stringify/-/fast-safe-stringify-2.0.7.tgz", + "integrity": "sha512-Utm6CdzT+6xsDk2m8S6uL8VHxNwI6Jub+e9NYTcAms28T84pTa25GJQV9j0CY0N1rM8hK4x6grpF2BQf+2qwVA==", + "dev": true + }, "figures": { "version": "3.1.0", "resolved": "https://registry.npmjs.org/figures/-/figures-3.1.0.tgz", @@ -2418,7 +3080,6 @@ "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-4.0.0.tgz", "integrity": "sha1-1USBHUKPmOsGpj3EAtJAPDKMOPc=", "dev": true, - "optional": true, "requires": { "extend-shallow": "^2.0.1", "is-number": "^3.0.0", @@ -2431,7 +3092,6 @@ "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", "dev": true, - "optional": true, "requires": { "is-extendable": "^0.1.0" } @@ -2458,6 +3118,49 @@ "locate-path": "^3.0.0" } }, + "findup-sync": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/findup-sync/-/findup-sync-0.3.0.tgz", + "integrity": "sha1-N5MKpdgWt3fANEXhlmzGeQpMCxY=", + "dev": true, + "requires": { + "glob": "~5.0.0" + }, + "dependencies": { + "glob": { + "version": "5.0.15", + "resolved": "https://registry.npmjs.org/glob/-/glob-5.0.15.tgz", + "integrity": "sha1-G8k2ueAvSmA/zCIuz3Yz0wuLk7E=", + "dev": true, + "requires": { + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "2 || 3", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + } + } + } + }, + "fined": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/fined/-/fined-1.2.0.tgz", + "integrity": "sha512-ZYDqPLGxDkDhDZBjZBb+oD1+j0rA4E0pXY50eplAAOPg2N/gUBSSk5IM1/QhPfyVo19lJ+CvXpqfvk+b2p/8Ng==", + "dev": true, + "requires": { + "expand-tilde": "^2.0.2", + "is-plain-object": "^2.0.3", + "object.defaults": "^1.1.0", + "object.pick": "^1.2.0", + "parse-filepath": "^1.0.1" + } + }, + "flagged-respawn": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/flagged-respawn/-/flagged-respawn-1.0.1.tgz", + "integrity": "sha512-lNaHNVymajmk0OJMBn8fVUAU1BtDeKIqKoVhk4xAALB57aALg6b4W0MfJ/cUE0g9YBXy5XhSlPIpYIJ7HaY/3Q==", + "dev": true + }, "flat": { "version": "4.1.0", "resolved": "https://registry.npmjs.org/flat/-/flat-4.1.0.tgz", @@ -2507,8 +3210,16 @@ "version": "1.0.2", "resolved": "https://registry.npmjs.org/for-in/-/for-in-1.0.2.tgz", "integrity": "sha1-gQaNKVqBQuwKxybG4iAMMPttXoA=", + "dev": true + }, + "for-own": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/for-own/-/for-own-1.0.0.tgz", + "integrity": "sha1-xjMy9BXO3EsE2/5wz4NklMU8tEs=", "dev": true, - "optional": true + "requires": { + "for-in": "^1.0.1" + } }, "foreground-child": { "version": "1.5.6", @@ -2537,7 +3248,6 @@ "resolved": "https://registry.npmjs.org/fragment-cache/-/fragment-cache-0.2.1.tgz", "integrity": "sha1-QpD60n8T6Jvn8zeZxrxaCr//DRk=", "dev": true, - "optional": true, "requires": { "map-cache": "^0.2.2" } @@ -3131,6 +3841,12 @@ "integrity": "sha1-GwqzvVU7Kg1jmdKcDj6gslIHgyc=", "dev": true }, + "get-assigned-identifiers": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/get-assigned-identifiers/-/get-assigned-identifiers-1.2.0.tgz", + "integrity": "sha512-mBBwmeGTrxEMO4pMaaf/uUEFHnYtwr8FTe8Y/mer4rcV/bye0qGm6pw1bGZFGStxC5O76c5ZAVBGnqHmOaJpdQ==", + "dev": true + }, "get-caller-file": { "version": "2.0.5", "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", @@ -3143,12 +3859,23 @@ "integrity": "sha1-6td0q+5y4gQJQzoGY2YCPdaIekE=", "dev": true }, + "get-stdin": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/get-stdin/-/get-stdin-4.0.1.tgz", + "integrity": "sha1-uWjGsKBDhDJJAui/Gl3zJXmkUP4=", + "dev": true + }, "get-value": { "version": "2.0.6", "resolved": "https://registry.npmjs.org/get-value/-/get-value-2.0.6.tgz", "integrity": "sha1-3BXKHGcjh8p2vTesCjlbogQqLCg=", - "dev": true, - "optional": true + "dev": true + }, + "getobject": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/getobject/-/getobject-0.1.0.tgz", + "integrity": "sha1-BHpEl4n6Fg0Bj1SG7ZEyC27HiFw=", + "dev": true }, "glob": { "version": "7.1.6", @@ -3169,7 +3896,6 @@ "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-3.1.0.tgz", "integrity": "sha1-nmr2KZ2NO9K9QEMIMr0RPfkGxa4=", "dev": true, - "optional": true, "requires": { "is-glob": "^3.1.0", "path-dirname": "^1.0.0" @@ -3180,13 +3906,36 @@ "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-3.1.0.tgz", "integrity": "sha1-e6WuJCF4BKxwcHuWkiVnSGzD6Eo=", "dev": true, - "optional": true, "requires": { "is-extglob": "^2.1.0" } } } }, + "global-modules": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/global-modules/-/global-modules-1.0.0.tgz", + "integrity": "sha512-sKzpEkf11GpOFuw0Zzjzmt4B4UZwjOcG757PPvrfhxcLFbq0wpsgpOqxpxtxFiCG4DtG93M6XRVbF2oGdev7bg==", + "dev": true, + "requires": { + "global-prefix": "^1.0.1", + "is-windows": "^1.0.1", + "resolve-dir": "^1.0.0" + } + }, + "global-prefix": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/global-prefix/-/global-prefix-1.0.2.tgz", + "integrity": "sha1-2/dDxsFJklk8ZVVoy2btMsASLr4=", + "dev": true, + "requires": { + "expand-tilde": "^2.0.2", + "homedir-polyfill": "^1.0.1", + "ini": "^1.3.4", + "is-windows": "^1.0.1", + "which": "^1.2.14" + } + }, "globals": { "version": "11.12.0", "resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz", @@ -3205,6 +3954,194 @@ "integrity": "sha512-qBr4OuELkhPenW6goKVXiv47US3clb3/IbuWF9KNKEijAy9oeHxU9IgzjvJhHkUzhaj7rOUD7+YGWqUjLp5oSA==", "dev": true }, + "grunt": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/grunt/-/grunt-1.0.4.tgz", + "integrity": "sha512-PYsMOrOC+MsdGEkFVwMaMyc6Ob7pKmq+deg1Sjr+vvMWp35sztfwKE7qoN51V+UEtHsyNuMcGdgMLFkBHvMxHQ==", + "dev": true, + "requires": { + "coffeescript": "~1.10.0", + "dateformat": "~1.0.12", + "eventemitter2": "~0.4.13", + "exit": "~0.1.1", + "findup-sync": "~0.3.0", + "glob": "~7.0.0", + "grunt-cli": "~1.2.0", + "grunt-known-options": "~1.1.0", + "grunt-legacy-log": "~2.0.0", + "grunt-legacy-util": "~1.1.1", + "iconv-lite": "~0.4.13", + "js-yaml": "~3.13.0", + "minimatch": "~3.0.2", + "mkdirp": "~0.5.1", + "nopt": "~3.0.6", + "path-is-absolute": "~1.0.0", + "rimraf": "~2.6.2" + }, + "dependencies": { + "dateformat": { + "version": "1.0.12", + "resolved": "https://registry.npmjs.org/dateformat/-/dateformat-1.0.12.tgz", + "integrity": "sha1-nxJLZ1lMk3/3BpMuSmQsyo27/uk=", + "dev": true, + "requires": { + "get-stdin": "^4.0.1", + "meow": "^3.3.0" + } + }, + "glob": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.0.6.tgz", + "integrity": "sha1-IRuvr0nlJbjNkyYNFKsTYVKz9Xo=", + "dev": true, + "requires": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.0.2", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + } + }, + "grunt-cli": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/grunt-cli/-/grunt-cli-1.2.0.tgz", + "integrity": "sha1-VisRnrsGndtGSs4oRVAb6Xs1tqg=", + "dev": true, + "requires": { + "findup-sync": "~0.3.0", + "grunt-known-options": "~1.1.0", + "nopt": "~3.0.6", + "resolve": "~1.1.0" + } + }, + "resolve": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.1.7.tgz", + "integrity": "sha1-IDEU2CrSxe2ejgQRs5ModeiJ6Xs=", + "dev": true + }, + "rimraf": { + "version": "2.6.3", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.3.tgz", + "integrity": "sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA==", + "dev": true, + "requires": { + "glob": "^7.1.3" + }, + "dependencies": { + "glob": { + "version": "7.1.6", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.6.tgz", + "integrity": "sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==", + "dev": true, + "requires": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.0.4", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + } + } + } + } + } + }, + "grunt-browserify": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/grunt-browserify/-/grunt-browserify-5.3.0.tgz", + "integrity": "sha1-R/2M+LrFj+LeaDr9xX9/OoDKeS0=", + "dev": true, + "requires": { + "async": "^2.5.0", + "browserify": "^16.0.0", + "browserify-incremental": "^3.1.1", + "glob": "^7.1.2", + "lodash": "^4.17.4", + "resolve": "^1.1.6", + "watchify": "^3.6.1" + }, + "dependencies": { + "async": { + "version": "2.6.3", + "resolved": "https://registry.npmjs.org/async/-/async-2.6.3.tgz", + "integrity": "sha512-zflvls11DCy+dQWzTW2dzuilv8Z5X/pjfmZOWba6TNIVDm+2UDaJmXSOXlasHKfNBs8oo3M0aT50fDEWfKZjXg==", + "dev": true, + "requires": { + "lodash": "^4.17.14" + } + } + } + }, + "grunt-cli": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/grunt-cli/-/grunt-cli-1.3.2.tgz", + "integrity": "sha512-8OHDiZZkcptxVXtMfDxJvmN7MVJNE8L/yIcPb4HB7TlyFD1kDvjHrb62uhySsU14wJx9ORMnTuhRMQ40lH/orQ==", + "dev": true, + "requires": { + "grunt-known-options": "~1.1.0", + "interpret": "~1.1.0", + "liftoff": "~2.5.0", + "nopt": "~4.0.1", + "v8flags": "~3.1.1" + }, + "dependencies": { + "nopt": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/nopt/-/nopt-4.0.1.tgz", + "integrity": "sha1-0NRoWv1UFRk8jHUFYC0NF81kR00=", + "dev": true, + "requires": { + "abbrev": "1", + "osenv": "^0.1.4" + } + } + } + }, + "grunt-known-options": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/grunt-known-options/-/grunt-known-options-1.1.1.tgz", + "integrity": "sha512-cHwsLqoighpu7TuYj5RonnEuxGVFnztcUqTqp5rXFGYL4OuPFofwC4Ycg7n9fYwvK6F5WbYgeVOwph9Crs2fsQ==", + "dev": true + }, + "grunt-legacy-log": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/grunt-legacy-log/-/grunt-legacy-log-2.0.0.tgz", + "integrity": "sha512-1m3+5QvDYfR1ltr8hjiaiNjddxGdQWcH0rw1iKKiQnF0+xtgTazirSTGu68RchPyh1OBng1bBUjLmX8q9NpoCw==", + "dev": true, + "requires": { + "colors": "~1.1.2", + "grunt-legacy-log-utils": "~2.0.0", + "hooker": "~0.2.3", + "lodash": "~4.17.5" + } + }, + "grunt-legacy-log-utils": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/grunt-legacy-log-utils/-/grunt-legacy-log-utils-2.0.1.tgz", + "integrity": "sha512-o7uHyO/J+i2tXG8r2bZNlVk20vlIFJ9IEYyHMCQGfWYru8Jv3wTqKZzvV30YW9rWEjq0eP3cflQ1qWojIe9VFA==", + "dev": true, + "requires": { + "chalk": "~2.4.1", + "lodash": "~4.17.10" + } + }, + "grunt-legacy-util": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/grunt-legacy-util/-/grunt-legacy-util-1.1.1.tgz", + "integrity": "sha512-9zyA29w/fBe6BIfjGENndwoe1Uy31BIXxTH3s8mga0Z5Bz2Sp4UCjkeyv2tI449ymkx3x26B+46FV4fXEddl5A==", + "dev": true, + "requires": { + "async": "~1.5.2", + "exit": "~0.1.1", + "getobject": "~0.1.0", + "hooker": "~0.2.3", + "lodash": "~4.17.10", + "underscore.string": "~3.3.4", + "which": "~1.3.0" + } + }, "handlebars": { "version": "4.5.1", "resolved": "https://registry.npmjs.org/handlebars/-/handlebars-4.5.1.tgz", @@ -3251,7 +4188,6 @@ "resolved": "https://registry.npmjs.org/has-value/-/has-value-1.0.0.tgz", "integrity": "sha1-GLKB2lhbHFxR3vJMkw7SmgvmsXc=", "dev": true, - "optional": true, "requires": { "get-value": "^2.0.6", "has-values": "^1.0.0", @@ -3263,7 +4199,6 @@ "resolved": "https://registry.npmjs.org/has-values/-/has-values-1.0.0.tgz", "integrity": "sha1-lbC2P+whRmGab+V/51Yo1aOe/k8=", "dev": true, - "optional": true, "requires": { "is-number": "^3.0.0", "kind-of": "^4.0.0" @@ -3274,13 +4209,32 @@ "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-4.0.0.tgz", "integrity": "sha1-IIE989cSkosgc3hpGkUGb65y3Vc=", "dev": true, - "optional": true, "requires": { "is-buffer": "^1.1.5" } } } }, + "hash-base": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/hash-base/-/hash-base-3.0.4.tgz", + "integrity": "sha1-X8hoaEfs1zSZQDMZprCj8/auSRg=", + "dev": true, + "requires": { + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" + } + }, + "hash.js": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/hash.js/-/hash.js-1.1.7.tgz", + "integrity": "sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==", + "dev": true, + "requires": { + "inherits": "^2.0.3", + "minimalistic-assert": "^1.0.1" + } + }, "hasha": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/hasha/-/hasha-3.0.0.tgz", @@ -3304,6 +4258,17 @@ "integrity": "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==", "dev": true }, + "hmac-drbg": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/hmac-drbg/-/hmac-drbg-1.0.1.tgz", + "integrity": "sha1-0nRXAQJabHdabFRXk+1QL8DGSaE=", + "dev": true, + "requires": { + "hash.js": "^1.0.3", + "minimalistic-assert": "^1.0.0", + "minimalistic-crypto-utils": "^1.0.1" + } + }, "homedir-polyfill": { "version": "1.0.3", "resolved": "https://registry.npmjs.org/homedir-polyfill/-/homedir-polyfill-1.0.3.tgz", @@ -3313,12 +4278,30 @@ "parse-passwd": "^1.0.0" } }, + "hooker": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/hooker/-/hooker-0.2.3.tgz", + "integrity": "sha1-uDT3I8xKJCqmWWNFnfbZhMXT2Vk=", + "dev": true + }, "hosted-git-info": { "version": "2.8.5", "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.8.5.tgz", "integrity": "sha512-kssjab8CvdXfcXMXVcvsXum4Hwdq9XGtRD3TteMEvEbq0LXyiNQr6AprqKqfeaDXze7SxWvRxdpwE6ku7ikLkg==", "dev": true }, + "htmlescape": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/htmlescape/-/htmlescape-1.1.1.tgz", + "integrity": "sha1-OgPtwiFLyjtmQko+eVk0lQnLA1E=", + "dev": true + }, + "https-browserify": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/https-browserify/-/https-browserify-1.0.0.tgz", + "integrity": "sha1-7AbBDgo0wPL68Zn3/X/Hj//QPHM=", + "dev": true + }, "iconv-lite": { "version": "0.4.24", "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", @@ -3328,6 +4311,12 @@ "safer-buffer": ">= 2.1.2 < 3" } }, + "ieee754": { + "version": "1.1.13", + "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.1.13.tgz", + "integrity": "sha512-4vf7I2LYV/HaWerSo3XmlMkp5eZ83i+/CDluXi/IGTs/O1sejBNhTtnxzmRZfvOUqj7lZjqHkeTvpgSFDlWZTg==", + "dev": true + }, "ignore": { "version": "4.0.6", "resolved": "https://registry.npmjs.org/ignore/-/ignore-4.0.6.tgz", @@ -3350,6 +4339,15 @@ "integrity": "sha1-khi5srkoojixPcT7a21XbyMUU+o=", "dev": true }, + "indent-string": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-2.1.0.tgz", + "integrity": "sha1-ji1INIdCEhtKghi3oTfppSBJ3IA=", + "dev": true, + "requires": { + "repeating": "^2.0.0" + } + }, "inflight": { "version": "1.0.6", "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", @@ -3366,6 +4364,21 @@ "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", "dev": true }, + "ini": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.5.tgz", + "integrity": "sha512-RZY5huIKCMRWDUqZlEi72f/lmXKMvuszcMBduliQ3nnWbx9X/ZBQO7DijMEYS9EhHBb2qacRUMtC7svLwe0lcw==", + "dev": true + }, + "inline-source-map": { + "version": "0.6.2", + "resolved": "https://registry.npmjs.org/inline-source-map/-/inline-source-map-0.6.2.tgz", + "integrity": "sha1-+Tk0ccGKedFyT4Y/o4tYY3Ct4qU=", + "dev": true, + "requires": { + "source-map": "~0.5.3" + } + }, "inquirer": { "version": "7.0.0", "resolved": "https://registry.npmjs.org/inquirer/-/inquirer-7.0.0.tgz", @@ -3427,6 +4440,30 @@ } } }, + "insert-module-globals": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/insert-module-globals/-/insert-module-globals-7.2.0.tgz", + "integrity": "sha512-VE6NlW+WGn2/AeOMd496AHFYmE7eLKkUY6Ty31k4og5vmA3Fjuwe9v6ifH6Xx/Hz27QvdoMoviw1/pqWRB09Sw==", + "dev": true, + "requires": { + "JSONStream": "^1.0.3", + "acorn-node": "^1.5.2", + "combine-source-map": "^0.8.0", + "concat-stream": "^1.6.1", + "is-buffer": "^1.1.0", + "path-is-absolute": "^1.0.1", + "process": "~0.11.0", + "through2": "^2.0.0", + "undeclared-identifiers": "^1.1.2", + "xtend": "^4.0.0" + } + }, + "interpret": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/interpret/-/interpret-1.1.0.tgz", + "integrity": "sha1-ftGxQQxqDg94z5XTuEQMY/eLhhQ=", + "dev": true + }, "invariant": { "version": "2.2.4", "resolved": "https://registry.npmjs.org/invariant/-/invariant-2.2.4.tgz", @@ -3436,12 +4473,21 @@ "loose-envify": "^1.0.0" } }, + "is-absolute": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-absolute/-/is-absolute-1.0.0.tgz", + "integrity": "sha512-dOWoqflvcydARa360Gvv18DZ/gRuHKi2NU/wU5X1ZFzdYfH29nkiNZsF3mp4OJ3H4yo9Mx8A/uAGNzpzPN3yBA==", + "dev": true, + "requires": { + "is-relative": "^1.0.0", + "is-windows": "^1.0.1" + } + }, "is-accessor-descriptor": { "version": "0.1.6", "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz", "integrity": "sha1-qeEss66Nh2cn7u84Q/igiXtcmNY=", "dev": true, - "optional": true, "requires": { "kind-of": "^3.0.2" }, @@ -3451,7 +4497,6 @@ "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", "dev": true, - "optional": true, "requires": { "is-buffer": "^1.1.5" } @@ -3469,7 +4514,6 @@ "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-1.0.1.tgz", "integrity": "sha1-dfFmQrSA8YenEcgUFh/TpKdlWJg=", "dev": true, - "optional": true, "requires": { "binary-extensions": "^1.0.0" } @@ -3491,7 +4535,6 @@ "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz", "integrity": "sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y=", "dev": true, - "optional": true, "requires": { "kind-of": "^3.0.2" }, @@ -3501,7 +4544,6 @@ "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", "dev": true, - "optional": true, "requires": { "is-buffer": "^1.1.5" } @@ -3519,7 +4561,6 @@ "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-0.1.6.tgz", "integrity": "sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg==", "dev": true, - "optional": true, "requires": { "is-accessor-descriptor": "^0.1.6", "is-data-descriptor": "^0.1.4", @@ -3530,8 +4571,7 @@ "version": "5.1.0", "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-5.1.0.tgz", "integrity": "sha512-NGEErnH6F2vUuXDh+OlbcKW7/wOcfdRHaZ7VWtqCztfHri/++YKmP51OdWeGPuqCOba6kk2OTe5d02VmTB80Pw==", - "dev": true, - "optional": true + "dev": true } } }, @@ -3539,8 +4579,7 @@ "version": "0.1.1", "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz", "integrity": "sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=", - "dev": true, - "optional": true + "dev": true }, "is-extglob": { "version": "2.1.1", @@ -3548,6 +4587,15 @@ "integrity": "sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=", "dev": true }, + "is-finite": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-finite/-/is-finite-1.0.2.tgz", + "integrity": "sha1-zGZ3aVYCvlUO8R6LSqYwU0K20Ko=", + "dev": true, + "requires": { + "number-is-nan": "^1.0.0" + } + }, "is-fullwidth-code-point": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz", @@ -3568,7 +4616,6 @@ "resolved": "https://registry.npmjs.org/is-number/-/is-number-3.0.0.tgz", "integrity": "sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=", "dev": true, - "optional": true, "requires": { "kind-of": "^3.0.2" }, @@ -3578,7 +4625,6 @@ "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", "dev": true, - "optional": true, "requires": { "is-buffer": "^1.1.5" } @@ -3590,7 +4636,6 @@ "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", "dev": true, - "optional": true, "requires": { "isobject": "^3.0.1" } @@ -3610,6 +4655,15 @@ "has": "^1.0.1" } }, + "is-relative": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-relative/-/is-relative-1.0.0.tgz", + "integrity": "sha512-Kw/ReK0iqwKeu0MITLFuj0jbPAmEiOsIwyIXvvbfa6QfmN9pkD1M+8pdk7Rl/dTKbH34/XBFMbgD4iMJhLQbGA==", + "dev": true, + "requires": { + "is-unc-path": "^1.0.0" + } + }, "is-symbol": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.2.tgz", @@ -3619,12 +4673,26 @@ "has-symbols": "^1.0.0" } }, + "is-unc-path": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-unc-path/-/is-unc-path-1.0.0.tgz", + "integrity": "sha512-mrGpVd0fs7WWLfVsStvgF6iEJnbjDFZh9/emhRDcGWTduTfNHd9CHeUwH3gYIjdbwo4On6hunkztwOaAw0yllQ==", + "dev": true, + "requires": { + "unc-path-regex": "^0.1.2" + } + }, + "is-utf8": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/is-utf8/-/is-utf8-0.2.1.tgz", + "integrity": "sha1-Sw2hRCEE0bM2NA6AeX6GXPOffXI=", + "dev": true + }, "is-windows": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/is-windows/-/is-windows-1.0.2.tgz", "integrity": "sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==", - "dev": true, - "optional": true + "dev": true }, "isarray": { "version": "1.0.0", @@ -3642,8 +4710,7 @@ "version": "3.0.1", "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz", "integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=", - "dev": true, - "optional": true + "dev": true }, "istanbul-lib-coverage": { "version": "2.0.5", @@ -3851,6 +4918,15 @@ "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", "dev": true }, + "json-stable-stringify": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/json-stable-stringify/-/json-stable-stringify-0.0.1.tgz", + "integrity": "sha1-YRwj6BTbN1Un34URk9tZ3Sryf0U=", + "dev": true, + "requires": { + "jsonify": "~0.0.0" + } + }, "json-stable-stringify-without-jsonify": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz", @@ -3881,12 +4957,23 @@ "graceful-fs": "^4.1.6" } }, + "jsonify": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/jsonify/-/jsonify-0.0.0.tgz", + "integrity": "sha1-LHS27kHZPKUbe1qu6PUDYx0lKnM=", + "dev": true + }, + "jsonparse": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/jsonparse/-/jsonparse-1.3.1.tgz", + "integrity": "sha1-P02uSpH6wxX3EGL4UhzCOfE2YoA=", + "dev": true + }, "kind-of": { "version": "6.0.2", "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.2.tgz", "integrity": "sha512-s5kLOcnH0XqDO+FvuaLX8DDjZ18CGFk7VygH40QoKPUQhW4e2rvM0rwUq0t8IQDOwYSeLK01U90OjzBTme2QqA==", - "dev": true, - "optional": true + "dev": true }, "klaw": { "version": "3.0.0", @@ -3897,6 +4984,22 @@ "graceful-fs": "^4.1.9" } }, + "labeled-stream-splicer": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/labeled-stream-splicer/-/labeled-stream-splicer-2.0.2.tgz", + "integrity": "sha512-Ca4LSXFFZUjPScRaqOcFxneA0VpKZr4MMYCljyQr4LIewTLb3Y0IUTIsnBBsVubIeEfxeSZpSjSsRM8APEQaAw==", + "dev": true, + "requires": { + "inherits": "^2.0.1", + "stream-splicer": "^2.0.0" + } + }, + "lazy-cache": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/lazy-cache/-/lazy-cache-1.0.4.tgz", + "integrity": "sha1-odePw6UEdMuAhF07O24dpJpEbo4=", + "dev": true + }, "levn": { "version": "0.3.0", "resolved": "https://registry.npmjs.org/levn/-/levn-0.3.0.tgz", @@ -3907,6 +5010,45 @@ "type-check": "~0.3.2" } }, + "liftoff": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/liftoff/-/liftoff-2.5.0.tgz", + "integrity": "sha1-IAkpG7Mc6oYbvxCnwVooyvdcMew=", + "dev": true, + "requires": { + "extend": "^3.0.0", + "findup-sync": "^2.0.0", + "fined": "^1.0.1", + "flagged-respawn": "^1.0.0", + "is-plain-object": "^2.0.4", + "object.map": "^1.0.0", + "rechoir": "^0.6.2", + "resolve": "^1.1.7" + }, + "dependencies": { + "findup-sync": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/findup-sync/-/findup-sync-2.0.0.tgz", + "integrity": "sha1-kyaxSIwi0aYIhlCoaQGy2akKLLw=", + "dev": true, + "requires": { + "detect-file": "^1.0.0", + "is-glob": "^3.1.0", + "micromatch": "^3.0.4", + "resolve-dir": "^1.0.1" + } + }, + "is-glob": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-3.1.0.tgz", + "integrity": "sha1-e6WuJCF4BKxwcHuWkiVnSGzD6Eo=", + "dev": true, + "requires": { + "is-extglob": "^2.1.0" + } + } + } + }, "linkify-it": { "version": "2.2.0", "resolved": "https://registry.npmjs.org/linkify-it/-/linkify-it-2.2.0.tgz", @@ -3952,12 +5094,36 @@ "integrity": "sha512-8xOcRHvCjnocdS5cpwXQXVzmmh5e5+saE2QGoeQmbKmRS6J3VQppPOIt0MnmE+4xlZoumy0GPG0D0MVIQbNA1A==", "dev": true }, + "lodash.assign": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/lodash.assign/-/lodash.assign-4.2.0.tgz", + "integrity": "sha1-DZnzzNem0mHRm9rrkkUAXShYCOc=", + "dev": true + }, + "lodash.bind": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/lodash.bind/-/lodash.bind-4.2.1.tgz", + "integrity": "sha1-euMBfpOWIqwxt9fX3LGzTbFpDTU=", + "dev": true + }, + "lodash.defaults": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/lodash.defaults/-/lodash.defaults-4.2.0.tgz", + "integrity": "sha1-0JF4cW/+pN3p5ft7N/bwgCJ0WAw=", + "dev": true + }, "lodash.flattendeep": { "version": "4.4.0", "resolved": "https://registry.npmjs.org/lodash.flattendeep/-/lodash.flattendeep-4.4.0.tgz", "integrity": "sha1-+wMJF/hqMTTlvJvsDWngAT3f7bI=", "dev": true }, + "lodash.foreach": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/lodash.foreach/-/lodash.foreach-4.5.0.tgz", + "integrity": "sha1-Gmo16s5AEoDH8G3d7DUWWrJ+PlM=", + "dev": true + }, "lodash.isempty": { "version": "4.4.0", "resolved": "https://registry.npmjs.org/lodash.isempty/-/lodash.isempty-4.4.0.tgz", @@ -3982,6 +5148,12 @@ "integrity": "sha1-1SfftUVuynzJu5XV2ur4i6VKVFE=", "dev": true }, + "lodash.memoize": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/lodash.memoize/-/lodash.memoize-3.0.4.tgz", + "integrity": "sha1-LcvSwofLwKVcxCMovQxzYVDVPj8=", + "dev": true + }, "log-symbols": { "version": "2.2.0", "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-2.2.0.tgz", @@ -3991,6 +5163,12 @@ "chalk": "^2.0.1" } }, + "longest": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/longest/-/longest-1.0.1.tgz", + "integrity": "sha1-MKCy2jj3N3DoKUoNIuZiXtd9AJc=", + "dev": true + }, "loose-envify": { "version": "1.4.0", "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz", @@ -4000,6 +5178,16 @@ "js-tokens": "^3.0.0 || ^4.0.0" } }, + "loud-rejection": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/loud-rejection/-/loud-rejection-1.6.0.tgz", + "integrity": "sha1-W0b4AUft7leIcPCG0Eghz5mOVR8=", + "dev": true, + "requires": { + "currently-unhandled": "^0.4.1", + "signal-exit": "^3.0.0" + } + }, "lru-cache": { "version": "4.1.5", "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-4.1.5.tgz", @@ -4020,19 +5208,32 @@ "semver": "^5.6.0" } }, + "make-iterator": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/make-iterator/-/make-iterator-1.0.1.tgz", + "integrity": "sha512-pxiuXh0iVEq7VM7KMIhs5gxsfxCux2URptUQaXo4iZZJxBAzTPOLE2BumO5dbfVYq/hBJFBR/a1mFDmOx5AGmw==", + "dev": true, + "requires": { + "kind-of": "^6.0.2" + } + }, "map-cache": { "version": "0.2.2", "resolved": "https://registry.npmjs.org/map-cache/-/map-cache-0.2.2.tgz", "integrity": "sha1-wyq9C9ZSXZsFFkW7TyasXcmKDb8=", - "dev": true, - "optional": true + "dev": true + }, + "map-obj": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/map-obj/-/map-obj-1.0.1.tgz", + "integrity": "sha1-2TPOuSBdgr3PSIb2dCvcK03qFG0=", + "dev": true }, "map-visit": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/map-visit/-/map-visit-1.0.0.tgz", "integrity": "sha1-7Nyo8TFE5mDxtb1B8S80edmN+48=", "dev": true, - "optional": true, "requires": { "object-visit": "^1.0.0" } @@ -4073,12 +5274,131 @@ "is-buffer": "~1.1.1" } }, + "md5.js": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/md5.js/-/md5.js-1.3.5.tgz", + "integrity": "sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg==", + "dev": true, + "requires": { + "hash-base": "^3.0.0", + "inherits": "^2.0.1", + "safe-buffer": "^5.1.2" + } + }, "mdurl": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/mdurl/-/mdurl-1.0.1.tgz", "integrity": "sha1-/oWy7HWlkDfyrf7BAP1sYBdhFS4=", "dev": true }, + "meow": { + "version": "3.7.0", + "resolved": "https://registry.npmjs.org/meow/-/meow-3.7.0.tgz", + "integrity": "sha1-cstmi0JSKCkKu/qFaJJYcwioAfs=", + "dev": true, + "requires": { + "camelcase-keys": "^2.0.0", + "decamelize": "^1.1.2", + "loud-rejection": "^1.0.0", + "map-obj": "^1.0.1", + "minimist": "^1.1.3", + "normalize-package-data": "^2.3.4", + "object-assign": "^4.0.1", + "read-pkg-up": "^1.0.1", + "redent": "^1.0.0", + "trim-newlines": "^1.0.0" + }, + "dependencies": { + "find-up": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-1.1.2.tgz", + "integrity": "sha1-ay6YIrGizgpgq2TWEOzK1TyyTQ8=", + "dev": true, + "requires": { + "path-exists": "^2.0.0", + "pinkie-promise": "^2.0.0" + } + }, + "load-json-file": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/load-json-file/-/load-json-file-1.1.0.tgz", + "integrity": "sha1-lWkFcI1YtLq0wiYbBPWfMcmTdMA=", + "dev": true, + "requires": { + "graceful-fs": "^4.1.2", + "parse-json": "^2.2.0", + "pify": "^2.0.0", + "pinkie-promise": "^2.0.0", + "strip-bom": "^2.0.0" + } + }, + "parse-json": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-2.2.0.tgz", + "integrity": "sha1-9ID0BDTvgHQfhGkJn43qGPVaTck=", + "dev": true, + "requires": { + "error-ex": "^1.2.0" + } + }, + "path-exists": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-2.1.0.tgz", + "integrity": "sha1-D+tsZPD8UY2adU3V77YscCJ2H0s=", + "dev": true, + "requires": { + "pinkie-promise": "^2.0.0" + } + }, + "path-type": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-1.1.0.tgz", + "integrity": "sha1-WcRPfuSR2nBNpBXaWkBwuk+P5EE=", + "dev": true, + "requires": { + "graceful-fs": "^4.1.2", + "pify": "^2.0.0", + "pinkie-promise": "^2.0.0" + } + }, + "pify": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", + "integrity": "sha1-7RQaasBDqEnqWISY59yosVMw6Qw=", + "dev": true + }, + "read-pkg": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-1.1.0.tgz", + "integrity": "sha1-9f+qXs0pyzHAR0vKfXVra7KePyg=", + "dev": true, + "requires": { + "load-json-file": "^1.0.0", + "normalize-package-data": "^2.3.2", + "path-type": "^1.0.0" + } + }, + "read-pkg-up": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-1.0.1.tgz", + "integrity": "sha1-nWPBMnbAZZGNV/ACpX9AobZD+wI=", + "dev": true, + "requires": { + "find-up": "^1.0.0", + "read-pkg": "^1.0.0" + } + }, + "strip-bom": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-2.0.0.tgz", + "integrity": "sha1-YhmoVhZSBJHzV4i9vxRHqZx+aw4=", + "dev": true, + "requires": { + "is-utf8": "^0.2.0" + } + } + } + }, "merge-source-map": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/merge-source-map/-/merge-source-map-1.1.0.tgz", @@ -4101,7 +5421,6 @@ "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-3.1.10.tgz", "integrity": "sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==", "dev": true, - "optional": true, "requires": { "arr-diff": "^4.0.0", "array-unique": "^0.3.2", @@ -4118,12 +5437,111 @@ "to-regex": "^3.0.2" } }, + "miller-rabin": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/miller-rabin/-/miller-rabin-4.0.1.tgz", + "integrity": "sha512-115fLhvZVqWwHPbClyntxEVfVDfl9DLLTuJvq3g2O/Oxi8AiNouAHvDSzHS0viUJc+V5vm3eq91Xwqn9dp4jRA==", + "dev": true, + "requires": { + "bn.js": "^4.0.0", + "brorand": "^1.0.1" + } + }, "mimic-fn": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz", "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==", "dev": true }, + "minifyify": { + "version": "7.3.5", + "resolved": "https://registry.npmjs.org/minifyify/-/minifyify-7.3.5.tgz", + "integrity": "sha1-n0uwyGklAkeNjuhbEL1ySFcGKa4=", + "dev": true, + "requires": { + "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" + }, + "dependencies": { + "camelcase": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-1.2.1.tgz", + "integrity": "sha1-m7UwTS4LVmmLLHWLCKPqqdqlijk=", + "dev": true + }, + "cliui": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-2.1.0.tgz", + "integrity": "sha1-S0dXYP+AJkx2LDoXGQMukcf+oNE=", + "dev": true, + "requires": { + "center-align": "^0.1.1", + "right-align": "^0.1.1", + "wordwrap": "0.0.2" + } + }, + "tmp": { + "version": "0.0.28", + "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.0.28.tgz", + "integrity": "sha1-Fyc1t/YU6nrzlmT6hM8N5OUV0SA=", + "dev": true, + "requires": { + "os-tmpdir": "~1.0.1" + } + }, + "uglify-js": { + "version": "2.8.29", + "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-2.8.29.tgz", + "integrity": "sha1-KcVzMUgFe7Th913zW3qcty5qWd0=", + "dev": true, + "requires": { + "source-map": "~0.5.1", + "uglify-to-browserify": "~1.0.0", + "yargs": "~3.10.0" + } + }, + "wordwrap": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-0.0.2.tgz", + "integrity": "sha1-t5Zpu0LstAn4PVg8rVLKF+qhZD8=", + "dev": true + }, + "yargs": { + "version": "3.10.0", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-3.10.0.tgz", + "integrity": "sha1-9+572FfdfB0tOMDnTvvWgdFDH9E=", + "dev": true, + "requires": { + "camelcase": "^1.0.2", + "cliui": "^2.1.0", + "decamelize": "^1.0.0", + "window-size": "0.1.0" + } + } + } + }, + "minimalistic-assert": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz", + "integrity": "sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==", + "dev": true + }, + "minimalistic-crypto-utils": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz", + "integrity": "sha1-9sAMHAsIIkblxNmd+4x8CDsrWCo=", + "dev": true + }, "minimatch": { "version": "3.0.4", "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz", @@ -4144,7 +5562,6 @@ "resolved": "https://registry.npmjs.org/mixin-deep/-/mixin-deep-1.3.2.tgz", "integrity": "sha512-WRoDn//mXBiJ1H40rqa3vH0toePwSsGb45iInWlTySa+Uu4k3tYUSxa2v1KqAiLtvlrSzaExqS1gtk96A9zvEA==", "dev": true, - "optional": true, "requires": { "for-in": "^1.0.2", "is-extendable": "^1.0.1" @@ -4155,7 +5572,6 @@ "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz", "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==", "dev": true, - "optional": true, "requires": { "is-plain-object": "^2.0.4" } @@ -4341,12 +5757,47 @@ "yargs": "^13.2.2" } }, + "module-deps": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/module-deps/-/module-deps-6.2.1.tgz", + "integrity": "sha512-UnEn6Ah36Tu4jFiBbJVUtt0h+iXqxpLqDvPS8nllbw5RZFmNJ1+Mz5BjYnM9ieH80zyxHkARGLnMIHlPK5bu6A==", + "dev": true, + "requires": { + "JSONStream": "^1.0.3", + "browser-resolve": "^1.7.0", + "cached-path-relative": "^1.0.2", + "concat-stream": "~1.6.0", + "defined": "^1.0.0", + "detective": "^5.0.2", + "duplexer2": "^0.1.2", + "inherits": "^2.0.1", + "parents": "^1.0.0", + "readable-stream": "^2.0.2", + "resolve": "^1.4.0", + "stream-combiner2": "^1.1.1", + "subarg": "^1.0.0", + "through2": "^2.0.0", + "xtend": "^4.0.0" + } + }, "ms": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=", "dev": true }, + "multimatch": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/multimatch/-/multimatch-2.1.0.tgz", + "integrity": "sha1-nHkGoi+0wCkZ4vX3UWG0zb1LKis=", + "dev": true, + "requires": { + "array-differ": "^1.0.0", + "array-union": "^1.0.1", + "arrify": "^1.0.0", + "minimatch": "^3.0.0" + } + }, "mute-stream": { "version": "0.0.8", "resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-0.0.8.tgz", @@ -4365,7 +5816,6 @@ "resolved": "https://registry.npmjs.org/nanomatch/-/nanomatch-1.2.13.tgz", "integrity": "sha512-fpoe2T0RbHwBTBUOftAfBPaDEi06ufaUai0mE6Yn1kacc3SnTErfb/h+X94VXzI64rKFHYImXSvdwGGCmwOqCA==", "dev": true, - "optional": true, "requires": { "arr-diff": "^4.0.0", "array-unique": "^0.3.2", @@ -4437,6 +5887,15 @@ } } }, + "nopt": { + "version": "3.0.6", + "resolved": "https://registry.npmjs.org/nopt/-/nopt-3.0.6.tgz", + "integrity": "sha1-xkZdvwirzU2zWTF/eaxopkayj/k=", + "dev": true, + "requires": { + "abbrev": "1" + } + }, "normalize-package-data": { "version": "2.5.0", "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.5.0.tgz", @@ -4453,8 +5912,13 @@ "version": "3.0.0", "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", - "dev": true, - "optional": true + "dev": true + }, + "number-is-nan": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/number-is-nan/-/number-is-nan-1.0.1.tgz", + "integrity": "sha1-CXtgK1NCKlIsGvuHkDGDNpQaAR0=", + "dev": true }, "nyc": { "version": "14.1.1", @@ -4500,7 +5964,6 @@ "resolved": "https://registry.npmjs.org/object-copy/-/object-copy-0.1.0.tgz", "integrity": "sha1-fn2Fi3gb18mRpBupde04EnVOmYw=", "dev": true, - "optional": true, "requires": { "copy-descriptor": "^0.1.0", "define-property": "^0.2.5", @@ -4512,7 +5975,6 @@ "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", "dev": true, - "optional": true, "requires": { "is-descriptor": "^0.1.0" } @@ -4522,7 +5984,6 @@ "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", "dev": true, - "optional": true, "requires": { "is-buffer": "^1.1.5" } @@ -4546,7 +6007,6 @@ "resolved": "https://registry.npmjs.org/object-visit/-/object-visit-1.0.1.tgz", "integrity": "sha1-95xEk68MU3e1n+OdOV5BBC3QRbs=", "dev": true, - "optional": true, "requires": { "isobject": "^3.0.0" } @@ -4563,6 +6023,18 @@ "object-keys": "^1.0.11" } }, + "object.defaults": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/object.defaults/-/object.defaults-1.1.0.tgz", + "integrity": "sha1-On+GgzS0B96gbaFtiNXNKeQ1/s8=", + "dev": true, + "requires": { + "array-each": "^1.0.1", + "array-slice": "^1.0.0", + "for-own": "^1.0.0", + "isobject": "^3.0.0" + } + }, "object.getownpropertydescriptors": { "version": "2.0.3", "resolved": "https://registry.npmjs.org/object.getownpropertydescriptors/-/object.getownpropertydescriptors-2.0.3.tgz", @@ -4573,12 +6045,21 @@ "es-abstract": "^1.5.1" } }, + "object.map": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/object.map/-/object.map-1.0.1.tgz", + "integrity": "sha1-z4Plncj8wK1fQlDh94s7gb2AHTc=", + "dev": true, + "requires": { + "for-own": "^1.0.0", + "make-iterator": "^1.0.0" + } + }, "object.pick": { "version": "1.3.0", "resolved": "https://registry.npmjs.org/object.pick/-/object.pick-1.3.0.tgz", "integrity": "sha1-h6EKxMFpS9Lhy/U1kaZhQftd10c=", "dev": true, - "optional": true, "requires": { "isobject": "^3.0.1" } @@ -4651,6 +6132,12 @@ "word-wrap": "~1.2.3" } }, + "os-browserify": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/os-browserify/-/os-browserify-0.3.0.tgz", + "integrity": "sha1-hUNzx/XCMVkU/Jv8a9gjj92h7Cc=", + "dev": true + }, "os-homedir": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/os-homedir/-/os-homedir-1.0.2.tgz", @@ -4663,6 +6150,25 @@ "integrity": "sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ=", "dev": true }, + "osenv": { + "version": "0.1.5", + "resolved": "https://registry.npmjs.org/osenv/-/osenv-0.1.5.tgz", + "integrity": "sha512-0CWcCECdMVc2Rw3U5w9ZjqX6ga6ubk1xDVKxtBQPK7wis/0F2r9T6k4ydGYhecl7YUBxBVxhL5oisPsNxAPe2g==", + "dev": true, + "requires": { + "os-homedir": "^1.0.0", + "os-tmpdir": "^1.0.0" + } + }, + "outpipe": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/outpipe/-/outpipe-1.1.1.tgz", + "integrity": "sha1-UM+GFjZeh+Ax4ppeyTOaPaRyX6I=", + "dev": true, + "requires": { + "shell-quote": "^1.4.2" + } + }, "p-limit": { "version": "2.2.1", "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.2.1.tgz", @@ -4699,6 +6205,12 @@ "release-zalgo": "^1.0.0" } }, + "pako": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/pako/-/pako-1.0.10.tgz", + "integrity": "sha512-0DTvPVU3ed8+HNXOu5Bs+o//Mbdj9VNQMUOe9oKCwh8l0GNwpTDMKCWbRjgtD291AWnkAgkqA/LOnQS8AmS1tw==", + "dev": true + }, "parent-module": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz", @@ -4708,6 +6220,40 @@ "callsites": "^3.0.0" } }, + "parents": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/parents/-/parents-1.0.1.tgz", + "integrity": "sha1-/t1NK/GTp3dF/nHjcdc8MwfZx1E=", + "dev": true, + "requires": { + "path-platform": "~0.11.15" + } + }, + "parse-asn1": { + "version": "5.1.5", + "resolved": "https://registry.npmjs.org/parse-asn1/-/parse-asn1-5.1.5.tgz", + "integrity": "sha512-jkMYn1dcJqF6d5CpU689bq7w/b5ALS9ROVSpQDPrZsqqesUJii9qutvoT5ltGedNXMO2e16YUWIghG9KxaViTQ==", + "dev": true, + "requires": { + "asn1.js": "^4.0.0", + "browserify-aes": "^1.0.0", + "create-hash": "^1.1.0", + "evp_bytestokey": "^1.0.0", + "pbkdf2": "^3.0.3", + "safe-buffer": "^5.1.1" + } + }, + "parse-filepath": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/parse-filepath/-/parse-filepath-1.0.2.tgz", + "integrity": "sha1-pjISf1Oq89FYdvWHLz/6x2PWyJE=", + "dev": true, + "requires": { + "is-absolute": "^1.0.0", + "map-cache": "^0.2.0", + "path-root": "^0.1.1" + } + }, "parse-json": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-4.0.0.tgz", @@ -4728,15 +6274,19 @@ "version": "0.1.1", "resolved": "https://registry.npmjs.org/pascalcase/-/pascalcase-0.1.1.tgz", "integrity": "sha1-s2PlXoAGym/iF4TS2yK9FdeRfxQ=", - "dev": true, - "optional": true + "dev": true + }, + "path-browserify": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/path-browserify/-/path-browserify-0.0.1.tgz", + "integrity": "sha512-BapA40NHICOS+USX9SN4tyhq+A2RrN/Ws5F0Z5aMHDp98Fl86lX8Oti8B7uN93L4Ifv4fHOEA+pQw87gmMO/lQ==", + "dev": true }, "path-dirname": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/path-dirname/-/path-dirname-1.0.2.tgz", "integrity": "sha1-zDPSTVJeCZpTiMAzbG4yuRYGCeA=", - "dev": true, - "optional": true + "dev": true }, "path-exists": { "version": "3.0.0", @@ -4762,6 +6312,27 @@ "integrity": "sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==", "dev": true }, + "path-platform": { + "version": "0.11.15", + "resolved": "https://registry.npmjs.org/path-platform/-/path-platform-0.11.15.tgz", + "integrity": "sha1-6GQhf3TDaFDwhSt43Hv31KVyG/I=", + "dev": true + }, + "path-root": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/path-root/-/path-root-0.1.1.tgz", + "integrity": "sha1-mkpoFMrBwM1zNgqV8yCDyOpHRbc=", + "dev": true, + "requires": { + "path-root-regex": "^0.1.0" + } + }, + "path-root-regex": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/path-root-regex/-/path-root-regex-0.1.2.tgz", + "integrity": "sha1-v8zcjfWxLcUsi0PsONGNcsBLqW0=", + "dev": true + }, "path-type": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/path-type/-/path-type-3.0.0.tgz", @@ -4785,12 +6356,40 @@ "integrity": "sha1-uULm1L3mUwBe9rcTYd74cn0GReA=", "dev": true }, + "pbkdf2": { + "version": "3.0.17", + "resolved": "https://registry.npmjs.org/pbkdf2/-/pbkdf2-3.0.17.tgz", + "integrity": "sha512-U/il5MsrZp7mGg3mSQfn742na2T+1/vHDCG5/iTI3X9MKUuYUZVLQhyRsg06mCgDBTd57TxzgZt7P+fYfjRLtA==", + "dev": true, + "requires": { + "create-hash": "^1.1.2", + "create-hmac": "^1.1.4", + "ripemd160": "^2.0.1", + "safe-buffer": "^5.0.1", + "sha.js": "^2.4.8" + } + }, "pify": { "version": "4.0.1", "resolved": "https://registry.npmjs.org/pify/-/pify-4.0.1.tgz", "integrity": "sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==", "dev": true }, + "pinkie": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/pinkie/-/pinkie-2.0.4.tgz", + "integrity": "sha1-clVrgM+g1IqXToDnckjoDtT3+HA=", + "dev": true + }, + "pinkie-promise": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/pinkie-promise/-/pinkie-promise-2.0.1.tgz", + "integrity": "sha1-ITXW36ejWMBprJsXh3YogihFD/o=", + "dev": true, + "requires": { + "pinkie": "^2.0.0" + } + }, "pirates": { "version": "4.0.1", "resolved": "https://registry.npmjs.org/pirates/-/pirates-4.0.1.tgz", @@ -4813,8 +6412,7 @@ "version": "0.1.1", "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz", "integrity": "sha1-AerA/jta9xoqbAL+q7jB/vfgDqs=", - "dev": true, - "optional": true + "dev": true }, "prelude-ls": { "version": "1.1.2", @@ -4828,12 +6426,17 @@ "integrity": "sha512-VvivMrbvd2nKkiG38qjULzlc+4Vx4wm/whI9pQD35YrARNnhxeiRktSOhSukRLFNlzg6Br/cJPet5J/u19r/mg==", "dev": true }, + "process": { + "version": "0.11.10", + "resolved": "https://registry.npmjs.org/process/-/process-0.11.10.tgz", + "integrity": "sha1-czIwDoQBYb2j5podHZGn1LwW8YI=", + "dev": true + }, "process-nextick-args": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz", "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==", - "dev": true, - "optional": true + "dev": true }, "progress": { "version": "2.0.3", @@ -4858,12 +6461,57 @@ "integrity": "sha1-8FKijacOYYkX7wqKw0wa5aaChrM=", "dev": true }, + "public-encrypt": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/public-encrypt/-/public-encrypt-4.0.3.tgz", + "integrity": "sha512-zVpa8oKZSz5bTMTFClc1fQOnyyEzpl5ozpi1B5YcvBrdohMjH2rfsBtyXcuNuwjsDIXmBYlF2N5FlJYhR29t8Q==", + "dev": true, + "requires": { + "bn.js": "^4.1.0", + "browserify-rsa": "^4.0.0", + "create-hash": "^1.1.0", + "parse-asn1": "^5.0.0", + "randombytes": "^2.0.1", + "safe-buffer": "^5.1.2" + } + }, "punycode": { "version": "2.1.1", "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.1.1.tgz", "integrity": "sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==", "dev": true }, + "querystring": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/querystring/-/querystring-0.2.0.tgz", + "integrity": "sha1-sgmEkgO7Jd+CDadW50cAWHhSFiA=", + "dev": true + }, + "querystring-es3": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/querystring-es3/-/querystring-es3-0.2.1.tgz", + "integrity": "sha1-nsYfeQSYdXB9aUFFlv2Qek1xHnM=", + "dev": true + }, + "randombytes": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz", + "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==", + "dev": true, + "requires": { + "safe-buffer": "^5.1.0" + } + }, + "randomfill": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/randomfill/-/randomfill-1.0.4.tgz", + "integrity": "sha512-87lcbR8+MhcWcUiQ+9e+Rwx8MyR2P7qnt15ynUlbm3TU/fjbgz4GsvfSUDTemtCCtVCqb4ZcEFlyPNTh9bBTLw==", + "dev": true, + "requires": { + "randombytes": "^2.0.5", + "safe-buffer": "^5.1.0" + } + }, "react": { "version": "16.11.0", "resolved": "https://registry.npmjs.org/react/-/react-16.11.0.tgz", @@ -4893,6 +6541,15 @@ "integrity": "sha512-gbBVYR2p8mnriqAwWx9LbuUrShnAuSCNnuPGyc7GJrMVQtPDAh8iLpv7FRuMPFb56KkaVZIYSz1PrjI9q0QPCw==", "dev": true }, + "read-only-stream": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/read-only-stream/-/read-only-stream-2.0.0.tgz", + "integrity": "sha1-JyT9aoET1zdkrCiNQ4YnDB2/F/A=", + "dev": true, + "requires": { + "readable-stream": "^2.0.2" + } + }, "read-pkg": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-3.0.0.tgz", @@ -4919,7 +6576,6 @@ "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz", "integrity": "sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==", "dev": true, - "optional": true, "requires": { "core-util-is": "~1.0.0", "inherits": "~2.0.3", @@ -4935,13 +6591,31 @@ "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-2.2.1.tgz", "integrity": "sha512-1JU/8q+VgFZyxwrJ+SVIOsh+KywWGpds3NTqikiKpDMZWScmAYyKIgqkO+ARvNWJfXeXR1zxz7aHF4u4CyH6vQ==", "dev": true, - "optional": true, "requires": { "graceful-fs": "^4.1.11", "micromatch": "^3.1.10", "readable-stream": "^2.0.2" } }, + "rechoir": { + "version": "0.6.2", + "resolved": "https://registry.npmjs.org/rechoir/-/rechoir-0.6.2.tgz", + "integrity": "sha1-hSBLVNuoLVdC4oyWdW70OvUOM4Q=", + "dev": true, + "requires": { + "resolve": "^1.1.6" + } + }, + "redent": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/redent/-/redent-1.0.0.tgz", + "integrity": "sha1-z5Fqsf1fHxbfsggi3W7H9zDCr94=", + "dev": true, + "requires": { + "indent-string": "^2.1.0", + "strip-indent": "^1.0.1" + } + }, "regenerate": { "version": "1.4.0", "resolved": "https://registry.npmjs.org/regenerate/-/regenerate-1.4.0.tgz", @@ -4977,7 +6651,6 @@ "resolved": "https://registry.npmjs.org/regex-not/-/regex-not-1.0.2.tgz", "integrity": "sha512-J6SDjUgDxQj5NusnOtdFxDwN/+HWykR8GELwctJ7mdqhcyy1xEc4SRFHUXvxTp661YaVKAjfRLZ9cCqS6tn32A==", "dev": true, - "optional": true, "requires": { "extend-shallow": "^3.0.2", "safe-regex": "^1.1.0" @@ -5039,22 +6712,28 @@ "version": "1.1.0", "resolved": "https://registry.npmjs.org/remove-trailing-separator/-/remove-trailing-separator-1.1.0.tgz", "integrity": "sha1-wkvOKig62tW8P1jg1IJJuSN52O8=", - "dev": true, - "optional": true + "dev": true }, "repeat-element": { "version": "1.1.3", "resolved": "https://registry.npmjs.org/repeat-element/-/repeat-element-1.1.3.tgz", "integrity": "sha512-ahGq0ZnV5m5XtZLMb+vP76kcAM5nkLqk0lpqAuojSKGgQtn4eRi4ZZGm2olo2zKFH+sMsWaqOCW1dqAnOru72g==", - "dev": true, - "optional": true + "dev": true }, "repeat-string": { "version": "1.6.1", "resolved": "https://registry.npmjs.org/repeat-string/-/repeat-string-1.6.1.tgz", "integrity": "sha1-jcrkcOHIirwtYA//Sndihtp15jc=", + "dev": true + }, + "repeating": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/repeating/-/repeating-2.0.1.tgz", + "integrity": "sha1-UhTFOpJtNVJwdSf7q0FdvAjQbdo=", "dev": true, - "optional": true + "requires": { + "is-finite": "^1.0.0" + } }, "require-directory": { "version": "2.1.1", @@ -5086,6 +6765,16 @@ "path-parse": "^1.0.6" } }, + "resolve-dir": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/resolve-dir/-/resolve-dir-1.0.1.tgz", + "integrity": "sha1-eaQGRMNivoLybv/nOcm7U4IEb0M=", + "dev": true, + "requires": { + "expand-tilde": "^2.0.0", + "global-modules": "^1.0.0" + } + }, "resolve-from": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz", @@ -5096,8 +6785,7 @@ "version": "0.2.1", "resolved": "https://registry.npmjs.org/resolve-url/-/resolve-url-0.2.1.tgz", "integrity": "sha1-LGN/53yJOv0qZj/iGqkIAGjiBSo=", - "dev": true, - "optional": true + "dev": true }, "restore-cursor": { "version": "3.1.0", @@ -5113,8 +6801,16 @@ "version": "0.1.15", "resolved": "https://registry.npmjs.org/ret/-/ret-0.1.15.tgz", "integrity": "sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg==", + "dev": true + }, + "right-align": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/right-align/-/right-align-0.1.3.tgz", + "integrity": "sha1-YTObci/mo1FWiSENJOFMlhSGE+8=", "dev": true, - "optional": true + "requires": { + "align-text": "^0.1.1" + } }, "rimraf": { "version": "2.7.1", @@ -5125,6 +6821,16 @@ "glob": "^7.1.3" } }, + "ripemd160": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/ripemd160/-/ripemd160-2.0.2.tgz", + "integrity": "sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==", + "dev": true, + "requires": { + "hash-base": "^3.0.0", + "inherits": "^2.0.1" + } + }, "run-async": { "version": "2.3.0", "resolved": "https://registry.npmjs.org/run-async/-/run-async-2.3.0.tgz", @@ -5154,7 +6860,6 @@ "resolved": "https://registry.npmjs.org/safe-regex/-/safe-regex-1.1.0.tgz", "integrity": "sha1-QKNmnzsHfR6UPURinhV91IAjvy4=", "dev": true, - "optional": true, "requires": { "ret": "~0.1.10" } @@ -5192,7 +6897,6 @@ "resolved": "https://registry.npmjs.org/set-value/-/set-value-2.0.1.tgz", "integrity": "sha512-JxHc1weCN68wRY0fhCoXpyK55m/XPHafOmK4UWD7m2CI14GMcFypt4w/0+NV5f/ZMby2F6S2wwA7fgynh9gWSw==", "dev": true, - "optional": true, "requires": { "extend-shallow": "^2.0.1", "is-extendable": "^0.1.1", @@ -5205,13 +6909,41 @@ "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", "dev": true, - "optional": true, "requires": { "is-extendable": "^0.1.0" } } } }, + "sha.js": { + "version": "2.4.11", + "resolved": "https://registry.npmjs.org/sha.js/-/sha.js-2.4.11.tgz", + "integrity": "sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==", + "dev": true, + "requires": { + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" + } + }, + "shasum": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/shasum/-/shasum-1.0.2.tgz", + "integrity": "sha1-5wEjENj0F/TetXEhUOVni4euVl8=", + "dev": true, + "requires": { + "json-stable-stringify": "~0.0.0", + "sha.js": "~2.4.4" + } + }, + "shasum-object": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/shasum-object/-/shasum-object-1.0.0.tgz", + "integrity": "sha512-Iqo5rp/3xVi6M4YheapzZhhGPVs0yZwHj7wvwQ1B9z8H6zk+FEnI7y3Teq7qwnekfEhu8WmG2z0z4iWZaxLWVg==", + "dev": true, + "requires": { + "fast-safe-stringify": "^2.0.7" + } + }, "shebang-command": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-1.2.0.tgz", @@ -5227,12 +6959,24 @@ "integrity": "sha1-2kL0l0DAtC2yypcoVxyxkMmO/qM=", "dev": true }, + "shell-quote": { + "version": "1.7.2", + "resolved": "https://registry.npmjs.org/shell-quote/-/shell-quote-1.7.2.tgz", + "integrity": "sha512-mRz/m/JVscCrkMyPqHc/bczi3OQHkLTqXHEFu0zDhK/qfv3UcOA4SVmRCLmos4bhjr9ekVQubj/R7waKapmiQg==", + "dev": true + }, "signal-exit": { "version": "3.0.2", "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.2.tgz", "integrity": "sha1-tf3AjxKH6hF4Yo5BXiUTK3NkbG0=", "dev": true }, + "simple-concat": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/simple-concat/-/simple-concat-1.0.0.tgz", + "integrity": "sha1-c0TLuLbib7J9ZrL8hvn21Zl1IcY=", + "dev": true + }, "slash": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/slash/-/slash-2.0.0.tgz", @@ -5255,7 +6999,6 @@ "resolved": "https://registry.npmjs.org/snapdragon/-/snapdragon-0.8.2.tgz", "integrity": "sha512-FtyOnWN/wCHTVXOMwvSv26d+ko5vWlIDD6zoUJ7LW8vh+ZBC8QdljveRP+crNrtBwioEUWy/4dMtbBjA4ioNlg==", "dev": true, - "optional": true, "requires": { "base": "^0.11.1", "debug": "^2.2.0", @@ -5272,7 +7015,6 @@ "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", "dev": true, - "optional": true, "requires": { "is-descriptor": "^0.1.0" } @@ -5282,7 +7024,6 @@ "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", "dev": true, - "optional": true, "requires": { "is-extendable": "^0.1.0" } @@ -5294,7 +7035,6 @@ "resolved": "https://registry.npmjs.org/snapdragon-node/-/snapdragon-node-2.1.1.tgz", "integrity": "sha512-O27l4xaMYt/RSQ5TR3vpWCAB5Kb/czIcqUFOM/C4fYcLnbZUc1PkjTAMjof2pBWaSTwOUd6qUHcFGVGj7aIwnw==", "dev": true, - "optional": true, "requires": { "define-property": "^1.0.0", "isobject": "^3.0.0", @@ -5306,7 +7046,6 @@ "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz", "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=", "dev": true, - "optional": true, "requires": { "is-descriptor": "^1.0.0" } @@ -5316,7 +7055,6 @@ "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz", "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==", "dev": true, - "optional": true, "requires": { "kind-of": "^6.0.0" } @@ -5326,7 +7064,6 @@ "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz", "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==", "dev": true, - "optional": true, "requires": { "kind-of": "^6.0.0" } @@ -5336,7 +7073,6 @@ "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz", "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==", "dev": true, - "optional": true, "requires": { "is-accessor-descriptor": "^1.0.0", "is-data-descriptor": "^1.0.0", @@ -5350,7 +7086,6 @@ "resolved": "https://registry.npmjs.org/snapdragon-util/-/snapdragon-util-3.0.1.tgz", "integrity": "sha512-mbKkMdQKsjX4BAL4bRYTj21edOf8cN7XHdYUJEe+Zn99hVEYcMvKPct1IqNe7+AZPirn8BCDOQBHQZknqmKlZQ==", "dev": true, - "optional": true, "requires": { "kind-of": "^3.2.0" }, @@ -5360,7 +7095,6 @@ "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", "dev": true, - "optional": true, "requires": { "is-buffer": "^1.1.5" } @@ -5378,7 +7112,6 @@ "resolved": "https://registry.npmjs.org/source-map-resolve/-/source-map-resolve-0.5.2.tgz", "integrity": "sha512-MjqsvNwyz1s0k81Goz/9vRBe9SZdB09Bdw+/zYyO+3CuPk6fouTaxscHkgtE8jKvf01kVfl8riHzERQ/kefaSA==", "dev": true, - "optional": true, "requires": { "atob": "^2.1.1", "decode-uri-component": "^0.2.0", @@ -5409,8 +7142,7 @@ "version": "0.4.0", "resolved": "https://registry.npmjs.org/source-map-url/-/source-map-url-0.4.0.tgz", "integrity": "sha1-PpNdfd1zYxuXZZlW1VEo6HtQhKM=", - "dev": true, - "optional": true + "dev": true }, "spawn-wrap": { "version": "1.4.3", @@ -5463,7 +7195,6 @@ "resolved": "https://registry.npmjs.org/split-string/-/split-string-3.1.0.tgz", "integrity": "sha512-NzNVhJDYpwceVVii8/Hu6DKfD2G+NrQHlS/V/qgv763EYudVwEcMQNxd2lh+0VrUByXN/oJkl5grOhYWvQUYiw==", "dev": true, - "optional": true, "requires": { "extend-shallow": "^3.0.0" } @@ -5479,7 +7210,6 @@ "resolved": "https://registry.npmjs.org/static-extend/-/static-extend-0.1.2.tgz", "integrity": "sha1-YICcOcv/VTNyJv1eC1IPNB8ftcY=", "dev": true, - "optional": true, "requires": { "define-property": "^0.2.5", "object-copy": "^0.1.0" @@ -5490,13 +7220,67 @@ "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz", "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=", "dev": true, - "optional": true, "requires": { "is-descriptor": "^0.1.0" } } } }, + "stream-browserify": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/stream-browserify/-/stream-browserify-2.0.2.tgz", + "integrity": "sha512-nX6hmklHs/gr2FuxYDltq8fJA1GDlxKQCz8O/IM4atRqBH8OORmBNgfvW5gG10GT/qQ9u0CzIvr2X5Pkt6ntqg==", + "dev": true, + "requires": { + "inherits": "~2.0.1", + "readable-stream": "^2.0.2" + } + }, + "stream-combiner2": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/stream-combiner2/-/stream-combiner2-1.1.1.tgz", + "integrity": "sha1-+02KFCDqNidk4hrUeAOXvry0HL4=", + "dev": true, + "requires": { + "duplexer2": "~0.1.0", + "readable-stream": "^2.0.2" + } + }, + "stream-http": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/stream-http/-/stream-http-3.1.0.tgz", + "integrity": "sha512-cuB6RgO7BqC4FBYzmnvhob5Do3wIdIsXAgGycHJnW+981gHqoYcYz9lqjJrk8WXRddbwPuqPYRl+bag6mYv4lw==", + "dev": true, + "requires": { + "builtin-status-codes": "^3.0.0", + "inherits": "^2.0.1", + "readable-stream": "^3.0.6", + "xtend": "^4.0.0" + }, + "dependencies": { + "readable-stream": { + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.4.0.tgz", + "integrity": "sha512-jItXPLmrSR8jmTRmRWJXCnGJsfy85mB3Wd/uINMXA65yrnFo0cPClFIUWzo2najVNSl+mx7/4W8ttlLWJe99pQ==", + "dev": true, + "requires": { + "inherits": "^2.0.3", + "string_decoder": "^1.1.1", + "util-deprecate": "^1.0.1" + } + } + } + }, + "stream-splicer": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/stream-splicer/-/stream-splicer-2.0.1.tgz", + "integrity": "sha512-Xizh4/NPuYSyAXyT7g8IvdJ9HJpxIGL9PjyhtywCZvvP0OPIdqyrr4dMikeuvY8xahpdKEBlBTySe583totajg==", + "dev": true, + "requires": { + "inherits": "^2.0.1", + "readable-stream": "^2.0.2" + } + }, "string-width": { "version": "2.1.1", "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz", @@ -5532,7 +7316,6 @@ "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", "dev": true, - "optional": true, "requires": { "safe-buffer": "~5.1.0" } @@ -5552,12 +7335,30 @@ "integrity": "sha1-IzTBjpx1n3vdVv3vfprj1YjmjtM=", "dev": true }, + "strip-indent": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/strip-indent/-/strip-indent-1.0.1.tgz", + "integrity": "sha1-DHlipq3vp7vUrDZkYKY4VSrhoKI=", + "dev": true, + "requires": { + "get-stdin": "^4.0.1" + } + }, "strip-json-comments": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz", "integrity": "sha1-PFMZQukIwml8DsNEhYwobHygpgo=", "dev": true }, + "subarg": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/subarg/-/subarg-1.0.0.tgz", + "integrity": "sha1-9izxdYHplrSPyWVpn1TAauJouNI=", + "dev": true, + "requires": { + "minimist": "^1.1.0" + } + }, "supports-color": { "version": "5.5.0", "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", @@ -5567,6 +7368,15 @@ "has-flag": "^3.0.0" } }, + "syntax-error": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/syntax-error/-/syntax-error-1.4.0.tgz", + "integrity": "sha512-YPPlu67mdnHGTup2A8ff7BC2Pjq0e0Yp/IyTFN03zWO0RcK07uLcbi7C2KpGR2FvWbaB0+bfE27a+sBKebSo7w==", + "dev": true, + "requires": { + "acorn-node": "^1.2.0" + } + }, "table": { "version": "5.4.6", "resolved": "https://registry.npmjs.org/table/-/table-5.4.6.tgz", @@ -5652,6 +7462,25 @@ "integrity": "sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=", "dev": true }, + "through2": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/through2/-/through2-2.0.5.tgz", + "integrity": "sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ==", + "dev": true, + "requires": { + "readable-stream": "~2.3.6", + "xtend": "~4.0.1" + } + }, + "timers-browserify": { + "version": "1.4.2", + "resolved": "https://registry.npmjs.org/timers-browserify/-/timers-browserify-1.4.2.tgz", + "integrity": "sha1-ycWLV1voQHN1y14kYtrO50NZ9B0=", + "dev": true, + "requires": { + "process": "~0.11.0" + } + }, "tmp": { "version": "0.0.33", "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.0.33.tgz", @@ -5672,7 +7501,6 @@ "resolved": "https://registry.npmjs.org/to-object-path/-/to-object-path-0.3.0.tgz", "integrity": "sha1-KXWIt7Dn4KwI4E5nL4XB9JmeF68=", "dev": true, - "optional": true, "requires": { "kind-of": "^3.0.2" }, @@ -5682,7 +7510,6 @@ "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", "dev": true, - "optional": true, "requires": { "is-buffer": "^1.1.5" } @@ -5694,7 +7521,6 @@ "resolved": "https://registry.npmjs.org/to-regex/-/to-regex-3.0.2.tgz", "integrity": "sha512-FWtleNAtZ/Ki2qtqej2CXTOayOH9bHDQF+Q48VpWyDXjbYxA4Yz8iDB31zXOBUlOHHKidDbqGVrTUvQMPmBGBw==", "dev": true, - "optional": true, "requires": { "define-property": "^2.0.2", "extend-shallow": "^3.0.2", @@ -5707,18 +7533,39 @@ "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-2.1.1.tgz", "integrity": "sha1-fIDBe53+vlmeJzZ+DU3VWQFB2zg=", "dev": true, - "optional": true, "requires": { "is-number": "^3.0.0", "repeat-string": "^1.6.1" } }, + "transform-filter": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/transform-filter/-/transform-filter-0.1.1.tgz", + "integrity": "sha1-gG+FG25ECyN4j9OMoEMbUCAlulk=", + "dev": true, + "requires": { + "multimatch": "^2.0.0", + "through": "^2.3.6" + } + }, + "trim-newlines": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/trim-newlines/-/trim-newlines-1.0.0.tgz", + "integrity": "sha1-WIeWa7WCpFA6QetST301ARgVphM=", + "dev": true + }, "tslib": { "version": "1.10.0", "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.10.0.tgz", "integrity": "sha512-qOebF53frne81cf0S9B41ByenJ3/IuH8yJKngAX35CmiZySA0khhkovshKK+jGCaMnVomla7gVlIcc3EvKPbTQ==", "dev": true }, + "tty-browserify": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/tty-browserify/-/tty-browserify-0.0.1.tgz", + "integrity": "sha512-C3TaO7K81YvjCgQH9Q1S3R3P3BtN3RIM8n+OvX4il1K1zgE8ZhI0op7kClgkxtutIE8hQrcrHBXvIheqKUUCxw==", + "dev": true + }, "type-check": { "version": "0.3.2", "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.3.2.tgz", @@ -5740,6 +7587,12 @@ "integrity": "sha512-DWkS49EQKVX//Tbupb9TFa19c7+MK1XmzkrZUR8TAktmE/DizXoaoJV6TZ/tSIPXipqNiRI6CyAe7x69Jb6RSw==", "dev": true }, + "typedarray": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz", + "integrity": "sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=", + "dev": true + }, "uc.micro": { "version": "1.0.6", "resolved": "https://registry.npmjs.org/uc.micro/-/uc.micro-1.0.6.tgz", @@ -5773,12 +7626,54 @@ } } }, + "uglify-to-browserify": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/uglify-to-browserify/-/uglify-to-browserify-1.0.2.tgz", + "integrity": "sha1-bgkk1r2mta/jSeOabWMoUKD4grc=", + "dev": true, + "optional": true + }, + "umd": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/umd/-/umd-3.0.3.tgz", + "integrity": "sha512-4IcGSufhFshvLNcMCV80UnQVlZ5pMOC8mvNPForqwA4+lzYQuetTESLDQkeLmihq8bRcnpbQa48Wb8Lh16/xow==", + "dev": true + }, + "unc-path-regex": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/unc-path-regex/-/unc-path-regex-0.1.2.tgz", + "integrity": "sha1-5z3T17DXxe2G+6xrCufYxqadUPo=", + "dev": true + }, + "undeclared-identifiers": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/undeclared-identifiers/-/undeclared-identifiers-1.1.3.tgz", + "integrity": "sha512-pJOW4nxjlmfwKApE4zvxLScM/njmwj/DiUBv7EabwE4O8kRUy+HIwxQtZLBPll/jx1LJyBcqNfB3/cpv9EZwOw==", + "dev": true, + "requires": { + "acorn-node": "^1.3.0", + "dash-ast": "^1.0.0", + "get-assigned-identifiers": "^1.2.0", + "simple-concat": "^1.0.0", + "xtend": "^4.0.1" + } + }, "underscore": { "version": "1.9.1", "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.9.1.tgz", "integrity": "sha512-5/4etnCkd9c8gwgowi5/om/mYO5ajCaOgdzj/oW+0eQV9WxKBDZw5+ycmKmeaTXjInS/W0BzpGLo2xR2aBwZdg==", "dev": true }, + "underscore.string": { + "version": "3.3.5", + "resolved": "https://registry.npmjs.org/underscore.string/-/underscore.string-3.3.5.tgz", + "integrity": "sha512-g+dpmgn+XBneLmXXo+sGlW5xQEt4ErkS3mgeN2GFbremYeMBSJKr9Wf2KJplQVaiPY/f7FN6atosWYNm9ovrYg==", + "dev": true, + "requires": { + "sprintf-js": "^1.0.3", + "util-deprecate": "^1.0.2" + } + }, "unicode-canonical-property-names-ecmascript": { "version": "1.0.4", "resolved": "https://registry.npmjs.org/unicode-canonical-property-names-ecmascript/-/unicode-canonical-property-names-ecmascript-1.0.4.tgz", @@ -5812,7 +7707,6 @@ "resolved": "https://registry.npmjs.org/union-value/-/union-value-1.0.1.tgz", "integrity": "sha512-tJfXmxMeWYnczCVs7XAEvIV7ieppALdyepWMkHkwciRpZraG/xwT+s2JN8+pr1+8jCRf80FFzvr+MpQeeoF4Xg==", "dev": true, - "optional": true, "requires": { "arr-union": "^3.1.0", "get-value": "^2.0.6", @@ -5831,7 +7725,6 @@ "resolved": "https://registry.npmjs.org/unset-value/-/unset-value-1.0.0.tgz", "integrity": "sha1-g3aHP30jNRef+x5vw6jtDfyKtVk=", "dev": true, - "optional": true, "requires": { "has-value": "^0.3.1", "isobject": "^3.0.0" @@ -5842,7 +7735,6 @@ "resolved": "https://registry.npmjs.org/has-value/-/has-value-0.3.1.tgz", "integrity": "sha1-ex9YutpiyoJ+wKIHgCVlSEWZXh8=", "dev": true, - "optional": true, "requires": { "get-value": "^2.0.3", "has-values": "^0.1.4", @@ -5854,7 +7746,6 @@ "resolved": "https://registry.npmjs.org/isobject/-/isobject-2.1.0.tgz", "integrity": "sha1-8GVWEJaj8dou9GJy+BXIQNh+DIk=", "dev": true, - "optional": true, "requires": { "isarray": "1.0.0" } @@ -5865,8 +7756,7 @@ "version": "0.1.4", "resolved": "https://registry.npmjs.org/has-values/-/has-values-0.1.4.tgz", "integrity": "sha1-bWHeldkd/Km5oCCJrThL/49it3E=", - "dev": true, - "optional": true + "dev": true } } }, @@ -5874,8 +7764,7 @@ "version": "1.2.0", "resolved": "https://registry.npmjs.org/upath/-/upath-1.2.0.tgz", "integrity": "sha512-aZwGpamFO61g3OlfT7OQCHqhGnW43ieH9WZeP7QxN/G/jS4jfqUkZxoryvJgVPEcrl5NL/ggHsSmLMHuH64Lhg==", - "dev": true, - "optional": true + "dev": true }, "uri-js": { "version": "4.2.2", @@ -5890,22 +7779,54 @@ "version": "0.1.0", "resolved": "https://registry.npmjs.org/urix/-/urix-0.1.0.tgz", "integrity": "sha1-2pN/emLiH+wf0Y1Js1wpNQZ6bHI=", + "dev": true + }, + "url": { + "version": "0.11.0", + "resolved": "https://registry.npmjs.org/url/-/url-0.11.0.tgz", + "integrity": "sha1-ODjpfPxgUh63PFJajlW/3Z4uKPE=", "dev": true, - "optional": true + "requires": { + "punycode": "1.3.2", + "querystring": "0.2.0" + }, + "dependencies": { + "punycode": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.3.2.tgz", + "integrity": "sha1-llOgNvt8HuQjQvIyXM7v6jkmxI0=", + "dev": true + } + } }, "use": { "version": "3.1.1", "resolved": "https://registry.npmjs.org/use/-/use-3.1.1.tgz", "integrity": "sha512-cwESVXlO3url9YWlFW/TA9cshCEhtu7IKJ/p5soJ/gGpj7vbvFrAY/eIioQ6Dw23KjZhYgiIo8HOs1nQ2vr/oQ==", + "dev": true + }, + "util": { + "version": "0.10.4", + "resolved": "https://registry.npmjs.org/util/-/util-0.10.4.tgz", + "integrity": "sha512-0Pm9hTQ3se5ll1XihRic3FDIku70C+iHUdT/W926rSgHV5QgXsYbKZN8MSC3tJtSkhuROzvsQjAaFENRXr+19A==", "dev": true, - "optional": true + "requires": { + "inherits": "2.0.3" + }, + "dependencies": { + "inherits": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz", + "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=", + "dev": true + } + } }, "util-deprecate": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=", - "dev": true, - "optional": true + "dev": true }, "uuid": { "version": "3.3.3", @@ -5944,6 +7865,27 @@ "integrity": "sha512-X/p3UZerAIsbBfN/IwahhYaBbY68EN/UQBWHtsbXGT5bfrH/p4NQzUCG1kF/rtKaNpnJ7jAu6NGTdSNtyNIXMw==", "dev": true }, + "vm-browserify": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/vm-browserify/-/vm-browserify-1.1.2.tgz", + "integrity": "sha512-2ham8XPWTONajOR0ohOKOHXkm3+gaBmGut3SRuu75xLd/RRaY6vqgh8NBYYk7+RW3u5AtzPQZG8F10LHkl0lAQ==", + "dev": true + }, + "watchify": { + "version": "3.11.1", + "resolved": "https://registry.npmjs.org/watchify/-/watchify-3.11.1.tgz", + "integrity": "sha512-WwnUClyFNRMB2NIiHgJU9RQPQNqVeFk7OmZaWf5dC5EnNa0Mgr7imBydbaJ7tGTuPM2hz1Cb4uiBvK9NVxMfog==", + "dev": true, + "requires": { + "anymatch": "^2.0.0", + "browserify": "^16.1.0", + "chokidar": "^2.1.1", + "defined": "^1.0.0", + "outpipe": "^1.1.0", + "through2": "^2.0.0", + "xtend": "^4.0.0" + } + }, "which": { "version": "1.3.1", "resolved": "https://registry.npmjs.org/which/-/which-1.3.1.tgz", @@ -5968,6 +7910,12 @@ "string-width": "^1.0.2 || 2" } }, + "window-size": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/window-size/-/window-size-0.1.0.tgz", + "integrity": "sha1-VDjNLqk7IC76Ohn+iIeu58lPnJ0=", + "dev": true + }, "word-wrap": { "version": "1.2.3", "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.3.tgz", @@ -6057,6 +8005,12 @@ "integrity": "sha512-MjGsXhKG8YjTKrDCXseFo3ClbMGvUD4en29H2Cev1dv4P/chlpw6KdYmlCWDkhosBVKRDjM836+3e3pm1cBNJA==", "dev": true }, + "xtend": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz", + "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==", + "dev": true + }, "y18n": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/y18n/-/y18n-4.0.0.tgz", diff --git a/package.json b/package.json index ffdfcff..29eeed5 100644 --- a/package.json +++ b/package.json @@ -18,12 +18,18 @@ "@babel/register": "^7.7.0", "@types/chai": "^4.2.5", "babel-eslint": "^11.0.0-beta.0", + "babelify": "^10.0.0", + "browserify": "^16.5.0", "chai": "^4.2.0", "eslint": "^6.6.0", "eslint-config-google": "^0.14.0", "eslint-plugin-import": "^2.18.2", + "grunt": "^1.0.4", + "grunt-browserify": "^5.3.0", + "grunt-cli": "^1.3.2", "jsdoc": "^3.6.3", "jsdoc-babel": "^0.5.0", + "minifyify": "^7.3.5", "mocha": "^6.2.2", "mocha-junit-reporter": "^1.23.1", "mochawesome": "^4.1.0",