scorm-again 2.6.0 → 2.6.2

package/dist/types/constants/response_constants.d.ts

@@ -0,0 +1,16 @@
+export declare const LearnerResponses: Responses;
+export declare const CorrectResponses: Responses;
+export type ResponseType = {
+    format: string;
+    max: number;
+    delimiter: string;
+    unique: boolean;
+    duplicate?: boolean;
+    format2?: string;
+    delimiter2?: string;
+    limit?: number;
+    delimiter3?: string;
+};
+export type Responses = {
+    [key: string]: ResponseType;
+};

package/dist/types/exceptions/aicc_exceptions.d.ts

@@ -0,0 +1,4 @@
+import { ValidationError } from "../exceptions";
+export declare class AICCValidationError extends ValidationError {
+    constructor(errorCode: number);
+}

package/dist/types/exceptions/scorm12_exceptions.d.ts

@@ -0,0 +1,4 @@
+import { ValidationError } from "../exceptions";
+export declare class Scorm12ValidationError extends ValidationError {
+    constructor(errorCode: number);
+}

package/dist/types/exceptions/scorm2004_exceptions.d.ts

@@ -0,0 +1,4 @@
+import { ValidationError } from "../exceptions";
+export declare class Scorm2004ValidationError extends ValidationError {
+    constructor(errorCode: number);
+}

package/dist/types/exceptions.d.ts

@@ -0,0 +1,18 @@
+type APIError = {
+    errorCode: number;
+    errorMessage: string;
+    detailedMessage: string;
+};
+export declare class BaseScormValidationError extends Error {
+    constructor(errorCode: number);
+    private readonly _errorCode;
+    get errorCode(): number;
+}
+export declare class ValidationError extends BaseScormValidationError implements APIError {
+    constructor(errorCode: number, errorMessage: string, detailedMessage?: string);
+    private readonly _errorMessage;
+    private readonly _detailedMessage;
+    get errorMessage(): string;
+    get detailedMessage(): string;
+}
+export {};

package/dist/types/helpers/scheduled_commit.d.ts

@@ -0,0 +1,10 @@
+import BaseAPI from "../BaseAPI";
+export declare class ScheduledCommit {
+    private _API;
+    private _cancelled;
+    private readonly _timeout;
+    private readonly _callback;
+    constructor(API: BaseAPI, when: number, callback: string);
+    cancel(): void;
+    wrapper(): void;
+}

package/dist/types/interfaces/IBaseAPI.d.ts

@@ -0,0 +1,22 @@
+import { RefObject, ResultObject } from "../types/api_types";
+import { BaseCMI } from "../cmi/common/base_cmi";
+export interface IBaseAPI {
+    cmi: BaseCMI;
+    startingData?: RefObject;
+    initialize(callbackName: string, initializeMessage?: string, terminationMessage?: string): string;
+    lmsInitialize(): string;
+    lmsFinish(): string;
+    lmsGetValue(CMIElement: string): string;
+    lmsSetValue(CMIElement: string, value: any): string;
+    lmsCommit(): string;
+    lmsGetLastError(): string;
+    lmsGetErrorString(CMIErrorCode: string | number): string;
+    lmsGetDiagnostic(CMIErrorCode: string | number): string;
+    storeData(_calculateTotalTime: boolean): Promise<ResultObject>;
+    renderCommitCMI(_terminateCommit: boolean): RefObject | Array<any>;
+    getLmsErrorMessageDetails(_errorNumber: string | number, _detail?: boolean): string;
+    getCMIValue(_CMIElement: string): string;
+    setCMIValue(_CMIElement: string, _value: any): string;
+    validateCorrectResponse(_CMIElement: string, _value: any): void;
+    getChildElement(_CMIElement: string, _value: any, _foundFirstIndex: boolean): BaseCMI | null;
+}

package/dist/types/types/api_types.d.ts

@@ -0,0 +1,73 @@
+import { CompletionStatus, LogLevelEnum, SuccessStatus } from "../constants/enums";
+export type Settings = {
+    autocommit?: boolean;
+    autocommitSeconds?: number;
+    asyncCommit?: boolean;
+    sendFullCommit?: boolean;
+    lmsCommitUrl?: boolean | string;
+    dataCommitFormat?: string;
+    commitRequestDataType?: string;
+    autoProgress?: boolean;
+    logLevel?: LogLevel;
+    selfReportSessionTime?: boolean;
+    alwaysSendTotalTime?: boolean;
+    strict_errors?: boolean;
+    xhrHeaders?: RefObject;
+    xhrWithCredentials?: boolean;
+    fetchMode?: "cors" | "no-cors" | "same-origin" | "navigate";
+    responseHandler?: (response: Response) => Promise<ResultObject>;
+    requestHandler?: (commitObject: any) => any;
+    onLogMessage?: (messageLevel: LogLevel, logMessage: string) => void;
+    mastery_override?: boolean;
+    renderCommonCommitFields?: boolean;
+    scoItemIds?: string[];
+    scoItemIdValidator?: false | ((scoItemId: string) => boolean);
+    globalObjectiveIds?: string[];
+};
+export type InternalSettings = {
+    autocommit: boolean;
+    autocommitSeconds: number;
+    asyncCommit: boolean;
+    sendFullCommit: boolean;
+    lmsCommitUrl: boolean | string;
+    dataCommitFormat: string;
+    commitRequestDataType: string;
+    autoProgress: boolean;
+    logLevel: LogLevel;
+    selfReportSessionTime: boolean;
+    renderCommonCommitFields?: boolean;
+    scoItemIds?: string[];
+    scoItemIdValidator?: false | ((scoItemId: string) => boolean);
+    globalObjectiveIds?: string[];
+    alwaysSendTotalTime: boolean;
+    strict_errors: boolean;
+    xhrHeaders: RefObject;
+    xhrWithCredentials: boolean;
+    mastery_override?: boolean;
+    fetchMode: "cors" | "no-cors" | "same-origin" | "navigate";
+    responseHandler: (response: Response) => Promise<ResultObject>;
+    requestHandler: (commitObject: any) => any;
+    onLogMessage: (messageLevel: LogLevel, logMessage: string) => void;
+};
+export type RefObject = {
+    [key: string]: any;
+};
+export type ResultObject = {
+    result: string;
+    errorCode: number;
+    navRequest?: string;
+};
+export type ScoreObject = {
+    raw?: number;
+    min?: number;
+    max?: number;
+    scaled?: number;
+};
+export type CommitObject = {
+    successStatus: SuccessStatus;
+    completionStatus: CompletionStatus;
+    totalTimeSeconds: number;
+    runtimeData: RefObject;
+    score?: ScoreObject;
+};
+export type LogLevel = 1 | 2 | 3 | 4 | 5 | "1" | "2" | "3" | "4" | "5" | "DEBUG" | "INFO" | "WARN" | "ERROR" | "NONE" | LogLevelEnum;

package/dist/types/utilities.d.ts

@@ -0,0 +1,19 @@
+export declare const SECONDS_PER_SECOND = 1;
+export declare const SECONDS_PER_MINUTE = 60;
+export declare const SECONDS_PER_HOUR: number;
+export declare const SECONDS_PER_DAY: number;
+type StringKeyMap = {
+    [key: string]: any;
+};
+export declare function getSecondsAsHHMMSS(totalSeconds: number | null): string;
+export declare function getSecondsAsISODuration(seconds: number | null): string;
+export declare function getTimeAsSeconds(timeString: string | number | boolean | null, timeRegex: RegExp | string): number;
+export declare function getDurationAsSeconds(duration: string | null, durationRegex: RegExp | string): number;
+export declare function addTwoDurations(first: string, second: string, durationRegex: RegExp | string): string;
+export declare function addHHMMSSTimeStrings(first: string, second: string, timeRegex: RegExp | string): string;
+export declare function flatten(data: StringKeyMap): object;
+export declare function unflatten(data: StringKeyMap): object;
+export declare function countDecimals(num: number): number;
+export declare function formatMessage(functionName: string, message: string, CMIElement?: string): string;
+export declare function stringMatches(str: string, tester: string): boolean;
+export {};

package/dist_test.html

@@ -0,0 +1,208 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>SCORM-Again Distribution Test</title>
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+            margin: 20px;
+        }
+
+        h1 {
+            color: #333;
+        }
+
+        .test-container {
+            display: flex;
+            flex-wrap: wrap;
+            gap: 20px;
+        }
+
+        .test-frame {
+            border: 1px solid #ccc;
+            padding: 15px;
+            width: 300px;
+            margin-bottom: 20px;
+            border-radius: 5px;
+        }
+
+        .test-frame h3 {
+            margin-top: 0;
+            border-bottom: 1px solid #eee;
+            padding-bottom: 10px;
+        }
+
+        .success {
+            background-color: #d4edda;
+            color: #155724;
+            padding: 10px;
+            border-radius: 4px;
+            margin-top: 10px;
+        }
+
+        .error {
+            background-color: #f8d7da;
+            color: #721c24;
+            padding: 10px;
+            border-radius: 4px;
+            margin-top: 10px;
+        }
+
+        .section {
+            margin-bottom: 30px;
+        }
+    </style>
+</head>
+<body>
+<h1>SCORM-Again Distribution Test</h1>
+
+<div class="section">
+    <h2>Regular JavaScript Files</h2>
+    <div class="test-container" id="regular-container"></div>
+</div>
+
+<div class="section">
+    <h2>ESM Module Files</h2>
+    <div class="test-container" id="esm-container"></div>
+</div>
+
+<script>
+    const dists = [
+        {
+            file: 'aicc.js',
+            api: ['AICC']
+        },
+        {
+            file: 'aicc.min.js',
+            api: ['AICC']
+        },
+        {
+            file: 'scorm12.js',
+            api: ['Scorm12API']
+        },
+        {
+            file: 'scorm12.min.js',
+            api: ['Scorm12API']
+        },
+        {
+            file: 'scorm2004.js',
+            api: ['Scorm2004API']
+        },
+        {
+            file: 'scorm2004.min.js',
+            api: ['Scorm2004API']
+        },
+        {
+            file: 'scorm-again.js',
+            api: ['Scorm12API', 'Scorm2004API', 'AICC']
+        },
+        {
+            file: 'scorm-again.min.js',
+            api: ['Scorm12API', 'Scorm2004API', 'AICC']
+        }
+    ];
+
+    // Create test frames for regular JS files
+    const regularContainer = document.getElementById('regular-container');
+    dists.forEach(dist => {
+        const frame = document.createElement('div');
+        frame.className = 'test-frame';
+        frame.innerHTML = `
+                <h3>${dist.file}</h3>
+                <div id="dist-${dist.file.replace(/\//g, '-').replace(/\./g, '-')}-result"></div>
+            `;
+        regularContainer.appendChild(frame);
+
+        // Create iframe to load the script
+        const iframe = document.createElement('iframe');
+        iframe.style.display = 'none';
+        document.body.appendChild(iframe);
+
+        // Create HTML content for the iframe with script
+        const html = `
+                <!DOCTYPE html>
+                <html>
+                <head>
+                    <script src="dist/${dist.file}"><\/script>
+                    <script>
+                        try {
+                            window.parent.postMessage({
+                                file: "dist-${dist.file}",
+                                success: !!(${dist.api.map(api => `window.${api}`).join(' || ')})
+                            }, "*");
+                        } catch (error) {
+                            window.parent.postMessage({
+                                file: "dist-${dist.file}",
+                                success: false,
+                                error: error.message
+                            }, "*");
+                        }
+                    <\/script>
+                </head>
+                <body></body>
+                </html>
+            `;
+
+        iframe.srcdoc = html;
+    });
+
+    // Create test frames for ESM module files
+    const esmContainer = document.getElementById('esm-container');
+    dists.forEach(dist => {
+        const frame = document.createElement('div');
+        frame.className = 'test-frame';
+        frame.innerHTML = `
+                <h3>${dist.file}</h3>
+                <div id="dist-esm-${dist.file.replace(/\//g, '-').replace(/\./g, '-')}-result"></div>
+            `;
+        esmContainer.appendChild(frame);
+
+        // Create iframe to load the module
+        const iframe = document.createElement('iframe');
+        iframe.style.display = 'none';
+        document.body.appendChild(iframe);
+
+        // Create HTML content for the iframe with module import
+        const html = `
+                <!DOCTYPE html>
+                <html>
+                <head>
+                    <script type="module">
+                        try {
+                            const module = await import('/dist/esm/${dist.file}');
+                            window.parent.postMessage({
+                                file: "dist-esm-${dist.file}",
+                                success: !!(${dist.api.map(api => `module.${api}`).join(' || ')})
+                            }, "*");
+                        } catch (error) {
+                            window.parent.postMessage({
+                                file: "dist-esm-${dist.file}",
+                                success: false,
+                                error: error.message
+                            }, "*");
+                        }
+                    <\/script>
+                </head>
+                <body></body>
+                </html>
+            `;
+
+        iframe.srcdoc = html;
+    });
+
+    // Listen for messages from iframes
+    window.addEventListener('message', (event) => {
+        const {file, success, error} = event.data;
+        const resultElement = document.getElementById(`${file.replace(/\//g, '-').replace(/\./g, '-')}-result`);
+
+        if (success) {
+            resultElement.innerHTML = `<div class="success">Successfully loaded</div>`;
+        } else {
+            resultElement.innerHTML = `<div class="error">Failed to load: ${error || 'Library objects not found'}</div>`;
+        }
+    });
+</script>
+</body>
+</html>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scorm-again",
-  "version": "2.6.0",
+  "version": "2.6.2",
   "description": "A modern SCORM JavaScript run-time library for AICC, SCORM 1.2, and SCORM 2004",
   "main": "dist/scorm-again.js",
   "types": "index.d.ts",
@@ -65,10 +65,11 @@
     "webpack": "^5.97.1",
     "webpack-cli": "^5.1.4"
   },
+  "sideEffects": false,
   "scripts": {
     "test": "./node_modules/.bin/mocha --import=tsx --bdd --recursive --reporter list",
     "test:coverage": "./node_modules/.bin/c8 ./node_modules/.bin/mocha --import=tsx --recursive --timeout=10000 --exit --reporter json --reporter-option output=test-results.json",
-    "compile": "./node_modules/.bin/webpack --bail --config webpack.config.js --mode production",
+    "compile": "./node_modules/.bin/webpack --bail --config webpack.config.js --mode production && tsc --emitDeclarationOnly --declaration --outDir dist/types",
     "fix": "./node_modules/.bin/eslint ./src --fix",
     "prettier": "./node_modules/.bin/prettier --write src/**/*.ts test/**/*.ts src/*.ts test/*.ts"
   },

package/src/AICC.ts

@@ -1,4 +1,4 @@
-import { Scorm12Impl } from "./Scorm12API";
+import { Scorm12API } from "./Scorm12API";
 import { CMI } from "./cmi/aicc/cmi";
 
 import { BaseCMI } from "./cmi/common/base_cmi";
@@ -13,7 +13,7 @@ import { stringMatches } from "./utilities";
 /**
  * The AICC API class
  */
-class AICCImpl extends Scorm12Impl {
+class AICCImpl extends Scorm12API {
   /**
    * Constructor to create AICC API object
    * @param {Settings} settings
@@ -74,4 +74,4 @@ class AICCImpl extends Scorm12Impl {
   }
 }
 
-export { AICCImpl };
+export { AICCImpl as AICC };

package/src/BaseAPI.ts

@@ -4,13 +4,7 @@ import { ErrorCode } from "./constants/error_codes";
 import { global_constants } from "./constants/api_constants";
 import { formatMessage, stringMatches, unflatten } from "./utilities";
 import { BaseCMI } from "./cmi/common/base_cmi";
-import {
-  CommitObject,
-  LogLevel,
-  RefObject,
-  ResultObject,
-  Settings,
-} from "./types/api_types";
+import { CommitObject, InternalSettings, LogLevel, RefObject, ResultObject, Settings } from "./types/api_types";
 import { DefaultSettings } from "./constants/default_settings";
 import { IBaseAPI } from "./interfaces/IBaseAPI";
 import { ScheduledCommit } from "./helpers/scheduled_commit";
@@ -21,9 +15,9 @@ import { LogLevelEnum } from "./constants/enums";
  * abstract, and never initialized on its own.
  */
 export default abstract class BaseAPI implements IBaseAPI {
-  private _timeout?: ScheduledCommit;
+  private _timeout?: ScheduledCommit | undefined;
   private readonly _error_codes: ErrorCode;
-  private _settings: Settings = DefaultSettings;
+  private _settings: InternalSettings = DefaultSettings;
 
   /**
    * Constructor for Base API class. Sets some shared API fields, as well as
@@ -42,14 +36,13 @@ export default abstract class BaseAPI implements IBaseAPI {
     this._error_codes = error_codes;
 
     if (settings) {
-      this.settings = settings;
-    }
-    this.apiLogLevel = this.settings.logLevel;
-    this.selfReportSessionTime = this.settings.selfReportSessionTime;
-
-    if (this.apiLogLevel === undefined) {
-      this.apiLogLevel = LogLevelEnum.NONE;
+      this.settings = {
+        ...DefaultSettings,
+        ...settings,
+      } as InternalSettings;
     }
+    this.apiLogLevel = this.settings.logLevel ?? LogLevelEnum.ERROR;
+    this.selfReportSessionTime = this.settings.selfReportSessionTime ?? false;
   }
 
   public abstract cmi: BaseCMI;
@@ -77,7 +70,7 @@ export default abstract class BaseAPI implements IBaseAPI {
     this.currentState = global_constants.STATE_NOT_INITIALIZED;
     this.lastErrorCode = "0";
     this.listenerArray = [];
-    this.startingData = undefined;
+    this.startingData = {};
   }
 
   /**
@@ -215,7 +208,7 @@ export default abstract class BaseAPI implements IBaseAPI {
    * Getter for _settings
    * @return {Settings}
    */
-  get settings(): Settings {
+  get settings(): InternalSettings {
     return this._settings;
   }
 
@@ -1048,6 +1041,15 @@ export default abstract class BaseAPI implements IBaseAPI {
    * @param {string} CMIElement
    */
   loadFromJSON(json: RefObject, CMIElement: string = "") {
+    if (
+      (!CMIElement || CMIElement === "") &&
+      !Object.hasOwnProperty.call(json, "cmi") &&
+      !Object.hasOwnProperty.call(json, "adl")
+    ) {
+      // providing a backward compatibility for the old v1 API
+      CMIElement = "cmi";
+    }
+
     if (!this.isNotInitialized()) {
       console.error(
         "loadFromJSON can only be called before the call to lmsInitialize.",
@@ -1136,7 +1138,7 @@ export default abstract class BaseAPI implements IBaseAPI {
     const process = async (
       url: string,
       params: CommitObject | RefObject | Array<any>,
-      settings: Settings,
+      settings: InternalSettings,
     ): Promise<ResultObject> => {
       try {
         params = settings.requestHandler(params);
@@ -1255,7 +1257,7 @@ export default abstract class BaseAPI implements IBaseAPI {
     url: string,
     params: RefObject | Array<any>,
   ): Promise<Response> {
-    return fetch(url, {
+    let init = {
       method: "POST",
       mode: this.settings.fetchMode,
       body: params instanceof Array ? params.join("&") : JSON.stringify(params),
@@ -1263,9 +1265,17 @@ export default abstract class BaseAPI implements IBaseAPI {
         ...this.settings.xhrHeaders,
         "Content-Type": this.settings.commitRequestDataType,
       },
-      credentials: this.settings.xhrWithCredentials ? "include" : undefined,
       keepalive: true,
-    });
+    } as RequestInit;
+
+    if (this.settings.xhrWithCredentials) {
+      init = {
+        ...init,
+        credentials: "include",
+      };
+    }
+
+    return fetch(url, init);
   }
 
   /**

package/src/Scorm12API.ts

@@ -9,16 +9,10 @@ import { CMIObjectivesObject } from "./cmi/scorm12/objectives";
 import {
   CMIInteractionsCorrectResponsesObject,
   CMIInteractionsObject,
-  CMIInteractionsObjectivesObject,
+  CMIInteractionsObjectivesObject
 } from "./cmi/scorm12/interactions";
 import { NAV } from "./cmi/scorm12/nav";
-import {
-  CommitObject,
-  RefObject,
-  ResultObject,
-  ScoreObject,
-  Settings,
-} from "./types/api_types";
+import { CommitObject, RefObject, ResultObject, ScoreObject, Settings } from "./types/api_types";
 import { CompletionStatus, SuccessStatus } from "./constants/enums";
 import BaseAPI from "./BaseAPI";
 import { scorm12_regex } from "./constants/regex";
@@ -360,10 +354,8 @@ class Scorm12Impl extends BaseAPI {
     }
 
     const score = this.cmi.core.score;
-    let scoreObject: ScoreObject = null;
+    const scoreObject: ScoreObject = {};
     if (score) {
-      scoreObject = {};
-
       if (!Number.isNaN(Number.parseFloat(score.raw))) {
         scoreObject.raw = Number.parseFloat(score.raw);
       }
@@ -444,4 +436,4 @@ class Scorm12Impl extends BaseAPI {
   }
 }
 
-export { Scorm12Impl };
+export { Scorm12Impl as Scorm12API };

package/src/Scorm2004API.ts

@@ -2,10 +2,7 @@ import BaseAPI from "./BaseAPI";
 import { CMI } from "./cmi/scorm2004/cmi";
 import * as Utilities from "./utilities";
 import { stringMatches } from "./utilities";
-import {
-  global_constants,
-  scorm2004_constants,
-} from "./constants/api_constants";
+import { global_constants, scorm2004_constants } from "./constants/api_constants";
 import { scorm2004_errors } from "./constants/error_codes";
 import { CorrectResponses, ResponseType } from "./constants/response_constants";
 import ValidLanguages from "./constants/language_constants";
@@ -14,18 +11,12 @@ import { BaseCMI } from "./cmi/common/base_cmi";
 import {
   CMIInteractionsCorrectResponsesObject,
   CMIInteractionsObject,
-  CMIInteractionsObjectivesObject,
+  CMIInteractionsObjectivesObject
 } from "./cmi/scorm2004/interactions";
 import { CMICommentsObject } from "./cmi/scorm2004/comments";
 import { CMIObjectivesObject } from "./cmi/scorm2004/objectives";
 import { ADL, ADLDataObject } from "./cmi/scorm2004/adl";
-import {
-  CommitObject,
-  RefObject,
-  ResultObject,
-  ScoreObject,
-  Settings,
-} from "./types/api_types";
+import { CommitObject, RefObject, ResultObject, ScoreObject, Settings } from "./types/api_types";
 import { CompletionStatus, SuccessStatus } from "./constants/enums";
 import { scorm2004_regex } from "./constants/regex";
 
@@ -168,13 +159,18 @@ class Scorm2004Impl extends BaseAPI {
       "^adl\\.nav\\.request_valid\\.(choice|jump)\\.{target=\\S{0,}([a-zA-Z0-9-_]+)}$";
     if (stringMatches(CMIElement, adlNavRequestRegex)) {
       const matches = CMIElement.match(adlNavRequestRegex);
-      const request = matches[1];
-      const target = matches[2].replace("{target=", "").replace("}", "");
-      if (request === "choice" || request === "jump") {
-        if (this.settings.scoItemIdValidator) {
-          return String(this.settings.scoItemIdValidator(target));
+      if (matches) {
+        const request = matches[1];
+        const target = matches[2].replace("{target=", "").replace("}", "");
+        if (request === "choice" || request === "jump") {
+          if (this.settings.scoItemIdValidator) {
+            return String(this.settings.scoItemIdValidator(target));
+          }
+          if (this.settings.scoItemIds) {
+            return String(this.settings.scoItemIds?.includes(target));
+          }
+          return String(request);
         }
-        return String(this.settings.scoItemIds.includes(target));
       }
     }
     return this.getValue("GetValue", true, CMIElement);
@@ -266,7 +262,8 @@ class Scorm2004Impl extends BaseAPI {
 
       // Check if the objective ID matches a global objective
       const is_global =
-        objective_id && this.settings.globalObjectiveIds.includes(objective_id);
+        objective_id &&
+        this.settings.globalObjectiveIds?.includes(objective_id);
 
       if (is_global) {
         // Locate or create an entry in _globalObjectives for the global objective
@@ -726,10 +723,8 @@ class Scorm2004Impl extends BaseAPI {
     }
 
     const score = this.cmi.score;
-    let scoreObject: ScoreObject = null;
+    const scoreObject: ScoreObject = {};
     if (score) {
-      scoreObject = {};
-
       if (!Number.isNaN(Number.parseFloat(score.raw))) {
         scoreObject.raw = Number.parseFloat(score.raw);
       }
@@ -820,4 +815,4 @@ class Scorm2004Impl extends BaseAPI {
   }
 }
 
-export { Scorm2004Impl };
+export { Scorm2004Impl as Scorm2004API };