scorm-again 3.0.4 → 3.1.0

package/dist/esm/scorm2004.js

@@ -210,6 +210,15 @@ function parseNavigationRequest(navRequest) {
   };
 }
 
+const appendQueryParam = (url, name, value) => {
+  const fragmentIndex = url.indexOf("#");
+  const baseUrl = fragmentIndex === -1 ? url : url.slice(0, fragmentIndex);
+  const fragment = fragmentIndex === -1 ? "" : url.slice(fragmentIndex);
+  const separator = baseUrl.includes("?") ? baseUrl.endsWith("?") || baseUrl.endsWith("&") ? "" : "&" : "?";
+  const queryParam = `${encodeURIComponent(name)}=${encodeURIComponent(String(value))}`;
+  return `${baseUrl}${separator}${queryParam}${fragment}`;
+};
+
 class BaseCMI {
   /**
    * Flag used during JSON serialization to allow getter access without initialization checks.
@@ -583,7 +592,10 @@ const scorm12_errors = {
   INVALID_SET_VALUE: 402,
   READ_ONLY_ELEMENT: 403,
   TYPE_MISMATCH: 405,
-  VALUE_OUT_OF_RANGE: 407};
+  // SCORM 1.2 has no out-of-range error code; an out-of-range value is reported
+  // as 405 (incorrect data type), per the SCORM 1.2 RTE error table and the ADL
+  // 1.2 CTS (DataModelValidator.checkScoreDecimal failure -> CMICategory 405).
+  VALUE_OUT_OF_RANGE: 405};
 const scorm2004_errors = {
   ...global_errors,
   INITIALIZATION_FAILED: 102,
@@ -729,6 +741,7 @@ const DefaultSettings = {
   xhrWithCredentials: false,
   fetchMode: "cors",
   asyncModeBeaconBehavior: "never",
+  includeCommitSequence: false,
   responseHandler: async function(response) {
     if (typeof response !== "undefined") {
       let httpResult = null;
@@ -940,6 +953,11 @@ const scorm2004_regex = {
   progress_range: "0#1"
 };
 
+const PERFORMANCE_STEP_NAME = "^$|" + scorm2004_regex.CMIShortIdentifier;
+const PERFORMANCE_CHARACTERSTRING = "(?![\\s\\S]*(?:\\[,\\]|\\[\\.\\]|\\[:\\]))[\\s\\S]{1,250}";
+const PERFORMANCE_NUMERIC_RANGE = "(?:-?\\d+(?:\\.\\d+)?)?\\[:\\](?:-?\\d+(?:\\.\\d+)?)?";
+const CR_PERFORMANCE_STEP_ANSWER = "^(?:|" + PERFORMANCE_NUMERIC_RANGE + "|" + PERFORMANCE_CHARACTERSTRING + ")$";
+const LR_PERFORMANCE_STEP_ANSWER = "^(?:|" + PERFORMANCE_CHARACTERSTRING + ")$";
 const LearnerResponses = {
   "true-false": {
     format: "^true$|^false$",
@@ -974,8 +992,8 @@ const LearnerResponses = {
     unique: false
   },
   performance: {
-    format: "^$|" + scorm2004_regex.CMIShortIdentifier,
-    format2: scorm2004_regex.CMIDecimal + "|^$|" + scorm2004_regex.CMIShortIdentifier,
+    format: PERFORMANCE_STEP_NAME,
+    format2: LR_PERFORMANCE_STEP_ANSWER,
     max: 250,
     delimiter: "[,]",
     delimiter2: "[.]",
@@ -1051,10 +1069,10 @@ const CorrectResponses = {
     delimiter2: "[.]",
     unique: false,
     duplicate: false,
-    // step_name must be a non-empty short identifier
-    format: scorm2004_regex.CMIShortIdentifier,
-    // step_answer may be short identifier or numeric range (<decimal>[:<decimal>])
-    format2: `^(${scorm2004_regex.CMIShortIdentifier})$|^(?:\\d+(?:\\.\\d+)?(?::\\d+(?:\\.\\d+)?)?)$`
+    // step_name: optional short_identifier_type
+    format: PERFORMANCE_STEP_NAME,
+    // step_answer: optional characterstring (spaces allowed) or numeric range
+    format2: CR_PERFORMANCE_STEP_ANSWER
   },
   sequencing: {
     max: 36,
@@ -1514,7 +1532,7 @@ class ScheduledCommit {
   wrapper() {
     if (!this._cancelled) {
       if (this._API.isInitialized()) {
-        (async () => await this._API.commit(this._callback))();
+        (async () => await this._API.commit(this._callback, false, "autocommit"))();
       }
     }
   }
@@ -4859,6 +4877,7 @@ class ActivityDeliveryService {
 }
 
 class AsynchronousHttpService {
+  reportsRequestCompletion = true;
   settings;
   error_codes;
   /**
@@ -4883,10 +4902,20 @@ class AsynchronousHttpService {
    * @param {boolean} immediate - Whether to send the request immediately without waiting
    * @param {Function} apiLog - Function to log API messages with appropriate levels
    * @param {Function} processListeners - Function to trigger event listeners for commit events
+   * @param {CommitMetadata} metadata - Metadata describing the captured commit
+   * @param {Function} onRequestComplete - Callback invoked after the background request settles
    * @return {ResultObject} - Immediate optimistic success result
    */
-  processHttpRequest(url, params, immediate = false, apiLog, processListeners) {
-    this._performAsyncRequest(url, params, immediate, apiLog, processListeners);
+  processHttpRequest(url, params, immediate = false, apiLog, processListeners, metadata, onRequestComplete) {
+    this._performAsyncRequest(
+      url,
+      params,
+      immediate,
+      apiLog,
+      processListeners,
+      metadata,
+      onRequestComplete
+    );
     return {
       result: global_constants.SCORM_TRUE,
       errorCode: 0
@@ -4899,11 +4928,14 @@ class AsynchronousHttpService {
    * @param {boolean} immediate - Whether this is an immediate request
    * @param apiLog - Function to log API messages
    * @param {Function} processListeners - Function to process event listeners
+   * @param {CommitMetadata} metadata - Metadata describing the captured commit
+   * @param {Function} onRequestComplete - Callback invoked after the request settles
    * @private
    */
-  async _performAsyncRequest(url, params, immediate, apiLog, processListeners) {
+  async _performAsyncRequest(url, params, immediate, apiLog, processListeners, metadata, onRequestComplete) {
     try {
-      const processedParams = this.settings.requestHandler(params);
+      const handledParams = metadata === void 0 ? this.settings.requestHandler(params) : this.settings.requestHandler(params, metadata);
+      const processedParams = handledParams;
       let response;
       if (immediate && this.settings.asyncModeBeaconBehavior !== "never") {
         response = await this.performBeacon(url, processedParams);
@@ -4919,7 +4951,9 @@ class AsynchronousHttpService {
     } catch (e) {
       const message = e instanceof Error ? e.message : String(e);
       apiLog("processHttpRequest", `Async request failed: ${message}`, LogLevelEnum.ERROR);
-      processListeners("CommitError");
+      processListeners("CommitError", void 0, this.error_codes.GENERAL_COMMIT_FAILURE || 391);
+    } finally {
+      onRequestComplete?.();
     }
   }
   /**
@@ -5062,10 +5096,13 @@ class CMIValueAccessService {
   }
   /**
    * Gets the appropriate error code for undefined data model elements.
-   * SCORM 2004 uses UNDEFINED_DATA_MODEL, SCORM 1.2 uses GENERAL.
+   * Both SCORM 2004 and SCORM 1.2 use UNDEFINED_DATA_MODEL (401): an
+   * unrecognized element is "Not implemented", not a general exception. SCORM
+   * 1.2 previously returned GENERAL (101) here, which is non-conformant — the
+   * ADL 1.2 CTS and the SCORM 1.2 RTE spec expect 401 for an unknown element.
    */
-  getUndefinedDataModelErrorCode(scorm2004) {
-    return scorm2004 ? getErrorCode(this.context.errorCodes, "UNDEFINED_DATA_MODEL") : getErrorCode(this.context.errorCodes, "GENERAL");
+  getUndefinedDataModelErrorCode() {
+    return getErrorCode(this.context.errorCodes, "UNDEFINED_DATA_MODEL");
   }
   /**
    * Sets a value on a CMI element path
@@ -5093,7 +5130,7 @@ class CMIValueAccessService {
     let returnValue = global_constants.SCORM_FALSE;
     let foundFirstIndex = false;
     const invalidErrorMessage = `The data model element passed to ${methodName} (${CMIElement}) is not a valid SCORM data model element.`;
-    const invalidErrorCode = this.getUndefinedDataModelErrorCode(scorm2004);
+    const invalidErrorCode = this.getUndefinedDataModelErrorCode();
     for (let idx = 0; idx < structure.length; idx++) {
       const attribute = structure[idx];
       if (idx === structure.length - 1) {
@@ -5163,12 +5200,13 @@ class CMIValueAccessService {
       );
       return "";
     }
+    this.context.setLastErrorCode("0");
     const structure = CMIElement.split(".");
     let refObject = this.context.getDataModel();
     let attribute = null;
     const uninitializedErrorMessage = `The data model element passed to ${methodName} (${CMIElement}) has not been initialized.`;
     const invalidErrorMessage = `The data model element passed to ${methodName} (${CMIElement}) is not a valid SCORM data model element.`;
-    const invalidErrorCode = this.getUndefinedDataModelErrorCode(scorm2004);
+    const invalidErrorCode = this.getUndefinedDataModelErrorCode();
     for (let idx = 0; idx < structure.length; idx++) {
       attribute = structure[idx];
       const validationResult = this.validateGetAttribute(
@@ -5363,7 +5401,19 @@ class CMIValueAccessService {
     if (!scorm2004) {
       if (isFinalAttribute) {
         if (typeof attribute === "undefined" || !this.context.checkObjectHasProperty(refObject, attribute)) {
-          this.context.throwSCORMError(CMIElement, invalidErrorCode, invalidErrorMessage);
+          if (attribute === "_children") {
+            this.context.throwSCORMError(
+              CMIElement,
+              getErrorCode(this.context.errorCodes, "CHILDREN_ERROR")
+            );
+          } else if (attribute === "_count") {
+            this.context.throwSCORMError(
+              CMIElement,
+              getErrorCode(this.context.errorCodes, "COUNT_ERROR")
+            );
+          } else {
+            this.context.throwSCORMError(CMIElement, invalidErrorCode, invalidErrorMessage);
+          }
           return { error: true };
         }
       }
@@ -5868,8 +5918,9 @@ class EventService {
    * @param {string} functionName - The name of the function that triggered the event
    * @param {string} CMIElement - The CMI element that was affected
    * @param {any} value - The value that was set
+   * @param {CommitEventContext} context - Optional context for commit lifecycle events
    */
-  processListeners(functionName, CMIElement, value) {
+  processListeners(functionName, CMIElement, value, context) {
     this.apiLog(functionName, value, LogLevelEnum.INFO, CMIElement);
     const listeners = this.listenerMap.get(functionName);
     if (!listeners) return;
@@ -5894,9 +5945,17 @@ class EventService {
         if (functionName.startsWith("Sequence")) {
           listener.callback(value);
         } else if (functionName === "CommitError") {
-          listener.callback(value);
+          if (context !== void 0) {
+            listener.callback(value, context);
+          } else {
+            listener.callback(value);
+          }
         } else if (functionName === "CommitSuccess") {
-          listener.callback();
+          if (context !== void 0) {
+            listener.callback(context);
+          } else {
+            listener.callback();
+          }
         } else {
           listener.callback(CMIElement, value);
         }
@@ -6030,16 +6089,19 @@ class OfflineStorageService {
    * Store commit data offline
    * @param {string} courseId - Identifier for the course
    * @param {CommitObject} commitData - The data to store offline
+   * @param {OfflineCommitMetadata} metadata - Metadata captured with the original commit
    * @returns {ResultObject} - Result of the storage operation
    */
-  storeOffline(courseId, commitData) {
+  storeOffline(courseId, commitData, metadata) {
     try {
       const queueItem = {
         id: `${courseId}_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
         courseId,
         timestamp: Date.now(),
         data: commitData,
-        syncAttempts: 0
+        syncAttempts: 0,
+        ...metadata?.isTerminateCommit !== void 0 ? { isTerminateCommit: metadata.isTerminateCommit } : {},
+        ...metadata?.sequence !== void 0 ? { sequence: metadata.sequence } : {}
       };
       const currentQueue = this.getFromStorage(this.syncQueue) || [];
       currentQueue.push(queueItem);
@@ -6118,7 +6180,10 @@ class OfflineStorageService {
           continue;
         }
         try {
-          const syncResult = await this.sendDataToLMS(item.data);
+          const syncResult = await this.sendDataToLMS(item.data, {
+            ...item.isTerminateCommit !== void 0 ? { isTerminateCommit: item.isTerminateCommit } : {},
+            ...item.sequence !== void 0 ? { sequence: item.sequence } : {}
+          });
           if (syncResult.result === true || syncResult.result === global_constants.SCORM_TRUE) {
             this.apiLog(
               "OfflineStorageService",
@@ -6165,17 +6230,25 @@ class OfflineStorageService {
   /**
    * Send data to the LMS when online
    * @param {CommitObject} data - The data to send to the LMS
+   * @param {OfflineCommitMetadata} metadata - Metadata captured with the original commit
    * @returns {Promise<ResultObject>} - Result of the sync operation
    */
-  async sendDataToLMS(data) {
-    if (!this.settings.lmsCommitUrl) {
+  async sendDataToLMS(data, metadata) {
+    const configuredCommitUrl = this.settings.lmsCommitUrl;
+    if (!configuredCommitUrl) {
       return {
         result: global_constants.SCORM_FALSE,
         errorCode: this.error_codes.GENERAL || 101
       };
     }
     try {
-      const processedData = this.settings.requestHandler(data);
+      const lmsCommitUrl = String(configuredCommitUrl);
+      const processedData = this.settings.requestHandler(data, {
+        isTerminateCommit: metadata?.isTerminateCommit ?? false,
+        trigger: "offline-replay",
+        ...metadata?.sequence !== void 0 ? { sequence: metadata.sequence } : {}
+      });
+      const requestUrl = metadata?.isTerminateCommit && this.settings.terminateCommitParam ? appendQueryParam(lmsCommitUrl, this.settings.terminateCommitParam, "true") : lmsCommitUrl;
       const init = {
         method: "POST",
         mode: this.settings.fetchMode,
@@ -6188,7 +6261,7 @@ class OfflineStorageService {
       if (this.settings.xhrWithCredentials) {
         init.credentials = "include";
       }
-      const response = await fetch(this.settings.lmsCommitUrl, init);
+      const response = await fetch(requestUrl, init);
       const result = typeof this.settings.responseHandler === "function" ? await this.settings.responseHandler(response) : await response.json();
       if (response.status >= 200 && response.status <= 299 && (result.result === true || result.result === global_constants.SCORM_TRUE)) {
         if (!Object.hasOwnProperty.call(result, "errorCode")) {
@@ -15153,6 +15226,8 @@ class SynchronousHttpService {
    * @param {boolean} immediate - Whether this is a termination commit (use sendBeacon)
    * @param {Function} _apiLog - Function to log API messages (unused in synchronous mode - errors returned directly)
    * @param {Function} _processListeners - Function to trigger event listeners (unused in synchronous mode - no async events)
+   * @param {CommitMetadata} metadata - Metadata describing the captured commit
+   * @param {Function} _onRequestComplete - Completion callback (unused because requests settle before return)
    * @return {ResultObject} - The result of the request (synchronous)
    *
    * @remarks
@@ -15162,21 +15237,23 @@ class SynchronousHttpService {
    * - No async events need to be triggered (CommitSuccess/CommitError) since results are synchronous
    * - AsynchronousHttpService uses these parameters to handle background request results
    */
-  processHttpRequest(url, params, immediate = false, _apiLog, _processListeners) {
+  processHttpRequest(url, params, immediate = false, _apiLog, _processListeners, metadata, _onRequestComplete) {
     if (immediate) {
-      return this._handleImmediateRequest(url, params);
+      return this._handleImmediateRequest(url, params, metadata);
     }
-    return this._performSyncXHR(url, params);
+    return this._performSyncXHR(url, params, metadata);
   }
   /**
    * Handles an immediate request using sendBeacon
    * @param {string} url - The URL to send the request to
    * @param {CommitObject|StringKeyMap|Array} params - The parameters to include in the request
+   * @param {CommitMetadata} metadata - Metadata describing the captured commit
    * @return {ResultObject} - The result based on beacon success
    * @private
    */
-  _handleImmediateRequest(url, params) {
-    const requestPayload = this.settings.requestHandler(params) ?? params;
+  _handleImmediateRequest(url, params, metadata) {
+    const handledPayload = metadata === void 0 ? this.settings.requestHandler(params) : this.settings.requestHandler(params, metadata);
+    const requestPayload = handledPayload ?? params;
     const { body } = this._prepareRequestBody(requestPayload);
     const beaconSuccess = navigator.sendBeacon(
       url,
@@ -15191,11 +15268,13 @@ class SynchronousHttpService {
    * Performs a synchronous XMLHttpRequest
    * @param {string} url - The URL to send the request to
    * @param {CommitObject|StringKeyMap|Array} params - The parameters to include in the request
+   * @param {CommitMetadata} metadata - Metadata describing the captured commit
    * @return {ResultObject} - The result of the request
    * @private
    */
-  _performSyncXHR(url, params) {
-    const requestPayload = this.settings.requestHandler(params) ?? params;
+  _performSyncXHR(url, params, metadata) {
+    const handledPayload = metadata === void 0 ? this.settings.requestHandler(params) : this.settings.requestHandler(params, metadata);
+    const requestPayload = handledPayload ?? params;
     const { body, contentType } = this._prepareRequestBody(requestPayload);
     const xhr = new XMLHttpRequest();
     xhr.open("POST", url, false);
@@ -15274,9 +15353,15 @@ class ValidationService {
    * @param {number} invalidTypeCode - The error code for invalid type
    * @param {number} invalidRangeCode - The error code for invalid range
    * @param {typeof BaseScormValidationError} errorClass - The error class to use for validation errors
+   * @param {boolean} allowEmptyString - When true, an empty string is accepted (clears the value).
+   *                                     SCORM 1.2 score elements may be blank per the ADL 1.2 CTS
+   *                                     (DataModelValidator.checkScoreDecimal treats blank as valid).
    * @return {boolean} - True if validation passes, throws an error otherwise
    */
-  validateScore(CMIElement, value, decimalRegex, scoreRange, invalidTypeCode, invalidRangeCode, errorClass) {
+  validateScore(CMIElement, value, decimalRegex, scoreRange, invalidTypeCode, invalidRangeCode, errorClass, allowEmptyString = false) {
+    if (allowEmptyString && value === "") {
+      return true;
+    }
     return checkValidFormat(CMIElement, value, decimalRegex, invalidTypeCode, errorClass) && (!scoreRange || checkValidRange(CMIElement, value, scoreRange, invalidRangeCode, errorClass));
   }
   /**
@@ -15350,6 +15435,21 @@ class BaseAPI {
   _offlineStorageService;
   _cmiValueAccessService;
   _courseId = "";
+  _pendingCommitCount = 0;
+  /**
+   * Monotonic sequence for commits captured by this API instance. It is
+   * intentionally not reset by reset().
+   */
+  _commitSequence = 0;
+  _commitSettleWaiters = [];
+  /**
+   * Canonical paths of every CMI element that has been explicitly assigned a
+   * value via SetValue / loadFromJSON (both funnel through _commonSetCMIValue).
+   * Used by standards that must tell "implemented but never set" apart from a
+   * legitimately empty value when answering GetValue (SCORM 2004 error 403).
+   * Cleared on reset so a fresh SCO attempt starts with nothing "set".
+   */
+  _setCMIElements = /* @__PURE__ */ new Set();
   /**
    * Constructor for Base API class. Sets some shared API fields, as well as
    * sets up options for the API.
@@ -15535,6 +15635,7 @@ class BaseAPI {
     this.lastErrorCode = "0";
     this._eventService.reset();
     this.startingData = {};
+    this._setCMIElements.clear();
     if (this._offlineStorageService) {
       this._offlineStorageService.updateSettings(this.settings);
       if (settings?.courseId) {
@@ -15619,6 +15720,52 @@ class BaseAPI {
       this._loggingService?.setLogHandler(settings.onLogMessage);
     }
   }
+  /**
+   * Gets the number of captured commit requests that have not yet settled.
+   *
+   * @return {number} The number of in-flight commits
+   */
+  get pendingCommitCount() {
+    return this._pendingCommitCount;
+  }
+  /**
+   * Resolves when all currently in-flight commits have settled. A timeout is
+   * best-effort: the promise resolves when it elapses even if commits remain,
+   * and callers can inspect pendingCommitCount afterward to detect that case.
+   *
+   * @param {Object} [options] - Settle options
+   * @param {number} [options.timeoutMs] - Maximum time to wait in milliseconds
+   * @return {Promise<void>} A promise that resolves after the drain or timeout
+   */
+  whenCommitsSettled(options) {
+    if (this._pendingCommitCount === 0) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      const waiter = { resolve };
+      if (options?.timeoutMs !== void 0) {
+        waiter.timeoutId = setTimeout(() => {
+          const waiterIndex = this._commitSettleWaiters.indexOf(waiter);
+          if (waiterIndex === -1) {
+            return;
+          }
+          this._commitSettleWaiters.splice(waiterIndex, 1);
+          resolve();
+        }, options.timeoutMs);
+      }
+      this._commitSettleWaiters.push(waiter);
+    });
+  }
+  /** Resolve and clear every waiter after the pending count reaches zero. */
+  _flushCommitSettleWaiters() {
+    const waiters = this._commitSettleWaiters.splice(0);
+    for (const waiter of waiters) {
+      if (waiter.timeoutId !== void 0) {
+        clearTimeout(waiter.timeoutId);
+      }
+      waiter.resolve();
+    }
+  }
   /**
    * Terminates the current run of the API
    * @param {string} callbackName
@@ -15639,7 +15786,7 @@ class BaseAPI {
     } else {
       stateCheckPassed = true;
       this.processListeners("BeforeTerminate");
-      const result = this.storeData(true);
+      const result = this.storeData(true, "terminate");
       if ((result.errorCode ?? 0) > 0) {
         if (result.errorMessage) {
           this.apiLog(
@@ -15691,6 +15838,9 @@ class BaseAPI {
       } catch (e) {
         returnValue = this.handleValueAccessException(CMIElement, e, returnValue);
       }
+      if (this.lastErrorCode === "0") {
+        this.checkUninitializedGet(CMIElement, returnValue);
+      }
       this.processListeners(callbackName, CMIElement);
     }
     this.apiLog(callbackName, ": returned: " + returnValue, LogLevelEnum.INFO, CMIElement);
@@ -15700,6 +15850,10 @@ class BaseAPI {
     if (this.lastErrorCode === "0") {
       this.clearSCORMError(returnValue);
     }
+    const rawReturn = returnValue;
+    if (typeof rawReturn === "number" || typeof rawReturn === "boolean") {
+      return String(rawReturn);
+    }
     return returnValue;
   }
   /**
@@ -15752,9 +15906,10 @@ class BaseAPI {
    * Orders LMS to store all content parameters
    * @param {string} callbackName
    * @param {boolean} checkTerminated
+   * @param {CommitTrigger} trigger - What initiated the commit
    * @return {string}
    */
-  commit(callbackName, checkTerminated = false) {
+  commit(callbackName, checkTerminated = false, trigger = "manual") {
     this.clearScheduledCommit();
     let returnValue = global_constants.SCORM_TRUE;
     if (this.isNotInitialized()) {
@@ -15766,8 +15921,9 @@ class BaseAPI {
       this.throwSCORMError("api", errorCode);
       if (errorCode === 143) returnValue = global_constants.SCORM_FALSE;
     } else {
-      const result = this.storeData(false);
-      if ((result.errorCode ?? 0) > 0) {
+      const result = this.storeData(false, trigger);
+      const errorCode = result.errorCode ?? 0;
+      if (errorCode > 0) {
         if (result.errorMessage) {
           this.apiLog(
             "commit",
@@ -15782,12 +15938,12 @@ class BaseAPI {
             LogLevelEnum.DEBUG
           );
         }
-        this.throwSCORMError("api", result.errorCode);
+        this.throwSCORMError("api", errorCode);
       }
       const resultValue = result?.result ?? global_constants.SCORM_FALSE;
       returnValue = typeof resultValue === "boolean" ? String(resultValue) : resultValue;
       this.apiLog(callbackName, " Result: " + returnValue, LogLevelEnum.DEBUG, "HttpRequest");
-      if (checkTerminated) this.lastErrorCode = "0";
+      if (checkTerminated && errorCode === 0) this.lastErrorCode = "0";
       this.processListeners(callbackName);
       if (this.settings.enableOfflineSupport && this._offlineStorageService && this._offlineStorageService.isDeviceOnline() && this._courseId) {
         this._offlineStorageService.hasPendingOfflineData(this._courseId).then((hasPendingData) => {
@@ -15996,7 +16152,16 @@ class BaseAPI {
    * @return {string}
    */
   _commonSetCMIValue(methodName, scorm2004, CMIElement, value) {
-    return this._cmiValueAccessService.setCMIValue(methodName, scorm2004, CMIElement, value);
+    const result = this._cmiValueAccessService.setCMIValue(
+      methodName,
+      scorm2004,
+      CMIElement,
+      value
+    );
+    if (result === global_constants.SCORM_TRUE) {
+      this._setCMIElements.add(CMIElement);
+    }
+    return result;
   }
   /**
    * Gets a value from the CMI Object.
@@ -16010,6 +16175,18 @@ class BaseAPI {
   _commonGetCMIValue(methodName, scorm2004, CMIElement) {
     return this._cmiValueAccessService.getCMIValue(methodName, scorm2004, CMIElement);
   }
+  /**
+   * Hook invoked by getValue after a successful resolution. Standards that must
+   * distinguish "implemented but never set, no default value" from a
+   * legitimately empty value override this to raise VALUE_NOT_INITIALIZED.
+   * Default is a no-op, so SCORM 1.2 / AICC keep returning "" with code 0.
+   *
+   * @param {string} _CMIElement - the element that was read
+   * @param {any} _returnValue - the value getCMIValue resolved
+   * @protected
+   */
+  checkUninitializedGet(_CMIElement, _returnValue) {
+  }
   /**
    * Returns true if the API's current state is STATE_INITIALIZED
    *
@@ -16092,9 +16269,14 @@ class BaseAPI {
    * @param {string} functionName - The name of the function/event that occurred
    * @param {string} CMIElement - Optional CMI element involved in the event
    * @param {any} value - Optional value associated with the event
+   * @param {CommitEventContext} context - Optional context for commit lifecycle events
    */
-  processListeners(functionName, CMIElement, value) {
-    this._eventService.processListeners(functionName, CMIElement, value);
+  processListeners(functionName, CMIElement, value, context) {
+    if (context !== void 0) {
+      this._eventService.processListeners(functionName, CMIElement, value, context);
+    } else {
+      this._eventService.processListeners(functionName, CMIElement, value);
+    }
   }
   /**
    * Throws a SCORM error with the specified error number and optional message.
@@ -16227,36 +16409,106 @@ class BaseAPI {
    * @param {string} url - The URL to send the request to
    * @param {CommitObject | StringKeyMap | Array<any>} params - The parameters to send
    * @param {boolean} immediate - Whether to send the request immediately without waiting
+   * @param {CommitTrigger} [trigger] - What initiated the commit
    * @returns {ResultObject} - The result of the request
    */
-  processHttpRequest(url, params, immediate = false) {
-    if (this.settings.enableOfflineSupport && this._offlineStorageService && !this._offlineStorageService.isDeviceOnline() && this._courseId) {
-      this.apiLog(
-        "processHttpRequest",
-        "Device is offline, storing data locally",
-        LogLevelEnum.INFO
-      );
-      if (params && typeof params === "object" && "cmi" in params) {
-        return this._offlineStorageService.storeOffline(this._courseId, params);
-      } else {
+  processHttpRequest(url, params, immediate = false, trigger) {
+    const sequence = ++this._commitSequence;
+    this._pendingCommitCount += 1;
+    let settled = false;
+    let completionDeferred = false;
+    const settle = () => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      this._pendingCommitCount -= 1;
+      if (this._pendingCommitCount === 0) {
+        this._flushCommitSettleWaiters();
+      }
+    };
+    try {
+      const resolvedTrigger = trigger ?? (immediate ? "terminate" : "manual");
+      let finalParams = params;
+      if (immediate && this.settings.terminateCommitPayloadField) {
+        const field = this.settings.terminateCommitPayloadField;
+        if (Array.isArray(finalParams)) {
+          finalParams = [...finalParams, `${encodeURIComponent(field)}=true`];
+        } else if (finalParams && typeof finalParams === "object") {
+          finalParams = { ...finalParams, [field]: true };
+        }
+      }
+      if (this.settings.includeCommitSequence === true) {
+        if (Array.isArray(finalParams)) {
+          finalParams = [...finalParams, `commitSequence=${sequence}`];
+        } else if (finalParams && typeof finalParams === "object") {
+          finalParams = { ...finalParams, commitSequence: sequence };
+        }
+      }
+      const finalUrl = immediate && this.settings.terminateCommitParam ? appendQueryParam(url, this.settings.terminateCommitParam, "true") : url;
+      const metadata = {
+        isTerminateCommit: immediate,
+        trigger: resolvedTrigger,
+        sequence
+      };
+      const context = {
+        url: finalUrl,
+        trigger: resolvedTrigger,
+        isTerminateCommit: immediate,
+        sequence
+      };
+      if (this.settings.enableOfflineSupport && this._offlineStorageService && !this._offlineStorageService.isDeviceOnline() && this._courseId) {
         this.apiLog(
           "processHttpRequest",
-          "Invalid commit data format for offline storage",
-          LogLevelEnum.ERROR
+          "Device is offline, storing data locally",
+          LogLevelEnum.INFO
         );
-        return {
-          result: global_constants.SCORM_FALSE,
-          errorCode: this._error_codes.GENERAL ?? 101
-        };
+        if (finalParams && typeof finalParams === "object" && "cmi" in finalParams) {
+          return this._offlineStorageService.storeOffline(
+            this._courseId,
+            finalParams,
+            { isTerminateCommit: immediate, sequence }
+          );
+        } else {
+          this.apiLog(
+            "processHttpRequest",
+            "Invalid commit data format for offline storage",
+            LogLevelEnum.ERROR
+          );
+          return {
+            result: global_constants.SCORM_FALSE,
+            errorCode: this._error_codes.GENERAL ?? 101
+          };
+        }
+      }
+      const apiLog = (functionName, message, level, element) => this.apiLog(functionName, message, level, element);
+      const processListeners = (functionName, CMIElement, value) => {
+        if (functionName === "CommitSuccess" || functionName === "CommitError") {
+          if (functionName === "CommitError" && typeof value === "number") {
+            context.errorCode = value;
+          }
+          settle();
+          this.processListeners(functionName, CMIElement, value, context);
+        } else {
+          this.processListeners(functionName, CMIElement, value);
+        }
+      };
+      const result = this._httpService.processHttpRequest(
+        finalUrl,
+        finalParams,
+        immediate,
+        apiLog,
+        processListeners,
+        metadata,
+        settle
+      );
+      completionDeferred = this._httpService.reportsRequestCompletion === true;
+      return result;
+    } finally {
+      if (!completionDeferred) {
+        settle();
       }
     }
-    return this._httpService.processHttpRequest(
-      url,
-      params,
-      immediate,
-      (functionName, message, level, element) => this.apiLog(functionName, message, level, element),
-      (functionName, CMIElement, value) => this.processListeners(functionName, CMIElement, value)
-    );
   }
   /**
    * Schedules a commit operation to occur after a specified delay.
@@ -16559,6 +16811,49 @@ class CMILearnerPreference extends BaseCMI {
   }
 }
 
+function stripBrackets(delim) {
+  return delim.replace(/[[\]]/g, "");
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function splitDelimited(value, bracketed) {
+  if (!bracketed) {
+    return [value];
+  }
+  if (value.includes(bracketed)) {
+    return value.split(bracketed);
+  }
+  const bare = stripBrackets(bracketed);
+  if (!bare) {
+    return [value];
+  }
+  const splitRe = new RegExp(`(?<!\\\\)${escapeRegex(bare)}`, "g");
+  const unescapeRe = new RegExp(`\\\\${escapeRegex(bare)}`, "g");
+  return value.split(splitRe).map((part) => part.replace(unescapeRe, bare));
+}
+function splitFirstDelimited(value, bracketed) {
+  if (!bracketed) {
+    return [value];
+  }
+  if (value.includes(bracketed)) {
+    const idx = value.indexOf(bracketed);
+    return [value.slice(0, idx), value.slice(idx + bracketed.length)];
+  }
+  const bare = stripBrackets(bracketed);
+  if (!bare) {
+    return [value];
+  }
+  const splitRe = new RegExp(`(?<!\\\\)${escapeRegex(bare)}`);
+  const unescapeRe = new RegExp(`\\\\${escapeRegex(bare)}`, "g");
+  const parts = value.split(splitRe);
+  const first = (parts[0] ?? "").replace(unescapeRe, bare);
+  if (parts.length === 1) {
+    return [first];
+  }
+  return [first, parts.slice(1).join(bare).replace(unescapeRe, bare)];
+}
+
 class CMIInteractions extends CMIArray {
   /**
    * Constructor for `cmi.interactions` Array
@@ -16768,8 +17063,7 @@ class CMIInteractionsObject extends BaseCMI {
       const response_type = LearnerResponses[this.type];
       if (response_type) {
         if (response_type?.delimiter) {
-          const delimiter = response_type.delimiter === "[,]" ? "," : response_type.delimiter;
-          nodes = learner_response.split(delimiter);
+          nodes = splitDelimited(learner_response, response_type.delimiter);
         } else {
           nodes[0] = learner_response;
         }
@@ -16777,10 +17071,10 @@ class CMIInteractionsObject extends BaseCMI {
           const formatRegex = new RegExp(response_type.format);
           for (let i = 0; i < nodes.length; i++) {
             if (response_type?.delimiter2) {
-              const delimiter2 = response_type.delimiter2 === "[.]" ? "." : response_type.delimiter2;
-              const values = nodes[i]?.split(delimiter2);
+              const node = nodes[i] ?? "";
+              const values = this.type === "performance" ? splitFirstDelimited(node, response_type.delimiter2) : splitDelimited(node, response_type.delimiter2);
               if (values?.length === 2) {
-                if (this.type === "performance" && (values[0] === "" || values[1] === "")) {
+                if (this.type === "performance" && values[0] === "" && values[1] === "") {
                   throw new Scorm2004ValidationError(
                     this._cmi_element + ".learner_response",
                     scorm2004_errors.TYPE_MISMATCH
@@ -16999,30 +17293,13 @@ class CMIInteractionsObjectivesObject extends BaseCMI {
     return result;
   }
 }
-function stripBrackets(delim) {
-  return delim.replace(/[[\]]/g, "");
-}
-function escapeRegex(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function splitUnescaped(text, delim) {
-  const reDelim = escapeRegex(delim);
-  const splitRe = new RegExp(`(?<!\\\\)${reDelim}`, "g");
-  const unescapeRe = new RegExp(`\\\\${reDelim}`, "g");
-  return text.split(splitRe).map((part) => part.replace(unescapeRe, delim));
-}
-function splitFirstUnescaped(text, delim) {
-  const reDelim = escapeRegex(delim);
-  const splitRe = new RegExp(`(?<!\\\\)${reDelim}`);
-  const unescapeRe = new RegExp(`\\\\${reDelim}`, "g");
-  const parts = text.split(splitRe);
-  const firstPart = parts[0] ?? "";
-  if (parts.length === 1) {
-    return [firstPart.replace(unescapeRe, delim)];
+const RESPONSE_PREFIX_RE = /^\{(?:lang|case_matters|order_matters)=[^}]+\}/;
+function stripResponsePrefixes(node) {
+  let result = node;
+  while (RESPONSE_PREFIX_RE.test(result)) {
+    result = result.replace(RESPONSE_PREFIX_RE, "");
   }
-  const part1 = firstPart.replace(unescapeRe, delim);
-  const part2 = parts.slice(1).join(delim).replace(unescapeRe, delim);
-  return [part1, part2];
+  return result;
 }
 function validatePattern(type, pattern, responseDef) {
   if (pattern.trim() !== pattern) {
@@ -17031,8 +17308,7 @@ function validatePattern(type, pattern, responseDef) {
       scorm2004_errors.TYPE_MISMATCH
     );
   }
-  const subDelim1 = responseDef.delimiter ? stripBrackets(responseDef.delimiter) : null;
-  const rawNodes = subDelim1 ? splitUnescaped(pattern, subDelim1) : [pattern];
+  const rawNodes = responseDef.delimiter ? splitDelimited(pattern, responseDef.delimiter) : [pattern];
   for (const raw of rawNodes) {
     if (raw.trim() !== raw) {
       throw new Scorm2004ValidationError(
@@ -17044,20 +17320,14 @@ function validatePattern(type, pattern, responseDef) {
   if (type === "fill-in" && pattern === "") {
     return;
   }
-  const delim1 = responseDef.delimiter ? stripBrackets(responseDef.delimiter) : null;
-  let nodes;
-  if (delim1) {
-    nodes = splitUnescaped(pattern, delim1);
-  } else {
-    nodes = [pattern];
-  }
+  const nodes = responseDef.delimiter ? splitDelimited(pattern, responseDef.delimiter) : [pattern];
   if (!responseDef.delimiter && pattern.includes(",")) {
     throw new Scorm2004ValidationError(
       "cmi.interactions.n.correct_responses.n.pattern",
       scorm2004_errors.TYPE_MISMATCH
     );
   }
-  if (responseDef.unique || responseDef.duplicate === false) {
+  if (type !== "numeric" && (responseDef.unique || responseDef.duplicate === false)) {
     const seen = new Set(nodes);
     if (seen.size !== nodes.length) {
       throw new Scorm2004ValidationError(
@@ -17089,8 +17359,7 @@ function validatePattern(type, pattern, responseDef) {
         scorm2004_errors.TYPE_MISMATCH
       );
     }
-    const delim = stripBrackets(delimBracketed);
-    const parts = value.split(new RegExp(`(?<!\\\\)${escapeRegex(delim)}`, "g")).map((n) => n.replace(new RegExp(`\\\\${escapeRegex(delim)}`, "g"), delim));
+    const parts = splitDelimited(value, delimBracketed);
     if (parts.length !== 2 || parts[0] === "" || parts[1] === "") {
       throw new Scorm2004ValidationError(
         "cmi.interactions.n.correct_responses.n.pattern",
@@ -17107,15 +17376,17 @@ function validatePattern(type, pattern, responseDef) {
   for (const node of nodes) {
     switch (type) {
       case "numeric": {
-        const numDelim = responseDef.delimiter ? stripBrackets(responseDef.delimiter) : ":";
-        const nums = node.split(numDelim);
-        if (nums.length < 1 || nums.length > 2) {
-          throw new Scorm2004ValidationError(
-            "cmi.interactions.n.correct_responses.n.pattern",
-            scorm2004_errors.TYPE_MISMATCH
-          );
+        if (node === "") {
+          const bracketedRange = nodes.length >= 2 && !!responseDef.delimiter && pattern.includes(responseDef.delimiter);
+          if (!bracketedRange) {
+            throw new Scorm2004ValidationError(
+              "cmi.interactions.n.correct_responses.n.pattern",
+              scorm2004_errors.TYPE_MISMATCH
+            );
+          }
+          break;
         }
-        nums.forEach(checkSingle);
+        checkSingle(node);
         break;
       }
       case "performance": {
@@ -17126,8 +17397,8 @@ function validatePattern(type, pattern, responseDef) {
             scorm2004_errors.TYPE_MISMATCH
           );
         }
-        const delim = stripBrackets(delimBracketed);
-        const parts = splitFirstUnescaped(node, delim);
+        const record = stripResponsePrefixes(node);
+        const parts = splitFirstDelimited(record, delimBracketed);
         if (parts.length !== 2) {
           throw new Scorm2004ValidationError(
             "cmi.interactions.n.correct_responses.n.pattern",
@@ -17135,7 +17406,7 @@ function validatePattern(type, pattern, responseDef) {
           );
         }
         const [part1, part2] = parts;
-        if (part1 === "" || part2 === "" || part1 === part2) {
+        if (part1 === "" && part2 === "") {
           throw new Scorm2004ValidationError(
             "cmi.interactions.n.correct_responses.n.pattern",
             scorm2004_errors.TYPE_MISMATCH
@@ -17221,6 +17492,11 @@ class CMIScore extends BaseCMI {
   __invalid_range_code;
   __decimal_regex;
   __error_class;
+  /**
+   * When true, an empty string is a valid value (clears the element). SCORM 1.2
+   * score elements may be blank per the ADL 1.2 CTS; SCORM 2004 leaves this off.
+   */
+  __allow_empty_string;
   _raw = "";
   _min = "";
   _max;
@@ -17255,6 +17531,7 @@ class CMIScore extends BaseCMI {
     this.__invalid_range_code = params.invalidRangeCode || scorm12_errors.VALUE_OUT_OF_RANGE;
     this.__decimal_regex = params.decimalRegex || scorm12_regex.CMIDecimal;
     this.__error_class = params.errorClass;
+    this.__allow_empty_string = params.allowEmptyString ?? false;
   }
   /**
    * Called when the API has been reset
@@ -17301,7 +17578,8 @@ class CMIScore extends BaseCMI {
       this.__score_range,
       this.__invalid_type_code,
       this.__invalid_range_code,
-      this.__error_class
+      this.__error_class,
+      this.__allow_empty_string
     )) {
       this._raw = raw;
     }
@@ -17325,7 +17603,8 @@ class CMIScore extends BaseCMI {
       this.__score_range,
       this.__invalid_type_code,
       this.__invalid_range_code,
-      this.__error_class
+      this.__error_class,
+      this.__allow_empty_string
     )) {
       this._min = min;
     }
@@ -17349,7 +17628,8 @@ class CMIScore extends BaseCMI {
       this.__score_range,
       this.__invalid_type_code,
       this.__invalid_range_code,
-      this.__error_class
+      this.__error_class,
+      this.__allow_empty_string
     )) {
       this._max = max;
     }
@@ -20199,7 +20479,7 @@ class Scorm2004ResponseValidator {
   checkValidResponseType(CMIElement, response_type, value, interaction_type) {
     let nodes = [];
     if (response_type?.delimiter) {
-      nodes = String(value).split(response_type.delimiter);
+      nodes = splitDelimited(String(value), response_type.delimiter);
     } else {
       nodes[0] = value;
     }
@@ -20321,22 +20601,30 @@ class Scorm2004ResponseValidator {
         nodes[i] = this.removeCorrectResponsePrefixes(CMIElement, nodes[i]);
       }
       if (response?.delimiter2) {
-        const values = nodes[i].split(response.delimiter2);
+        const values = interaction_type === "performance" ? splitFirstDelimited(nodes[i], response.delimiter2) : splitDelimited(nodes[i], response.delimiter2);
         if (values.length === 2) {
-          const matches = values[0].match(formatRegex);
-          if (!matches) {
+          if (interaction_type === "performance" && values[0] === "" && values[1] === "") {
             this.context.throwSCORMError(
               CMIElement,
               scorm2004_errors.TYPE_MISMATCH,
               `${interaction_type}: ${value}`
             );
           } else {
-            if (!response.format2 || !values[1].match(new RegExp(response.format2))) {
+            const matches = values[0]?.match(formatRegex);
+            if (!matches) {
               this.context.throwSCORMError(
                 CMIElement,
                 scorm2004_errors.TYPE_MISMATCH,
                 `${interaction_type}: ${value}`
               );
+            } else {
+              if (!response.format2 || !values[1]?.match(new RegExp(response.format2))) {
+                this.context.throwSCORMError(
+                  CMIElement,
+                  scorm2004_errors.TYPE_MISMATCH,
+                  `${interaction_type}: ${value}`
+                );
+              }
             }
           }
         } else {
@@ -20347,6 +20635,9 @@ class Scorm2004ResponseValidator {
           );
         }
       } else {
+        if (interaction_type === "numeric" && nodes.length > 1 && nodes[i] === "" && !!response.delimiter && String(value).includes(response.delimiter)) {
+          continue;
+        }
         const matches = nodes[i].match(formatRegex);
         if (!matches && value !== "" || !matches && interaction_type === "true-false") {
           this.context.throwSCORMError(
@@ -20356,7 +20647,7 @@ class Scorm2004ResponseValidator {
           );
         } else {
           if (interaction_type === "numeric" && nodes.length > 1) {
-            if (Number(nodes[0]) > Number(nodes[1])) {
+            if (nodes[0] !== "" && nodes[1] !== "" && Number(nodes[0]) > Number(nodes[1])) {
               this.context.throwSCORMError(
                 CMIElement,
                 scorm2004_errors.TYPE_MISMATCH,
@@ -22132,6 +22423,35 @@ class Scorm2004DataSerializer {
   }
 }
 
+const NO_DEFAULT_2004_ELEMENTS = /* @__PURE__ */ new Set([
+  "cmi.suspend_data",
+  "cmi.location",
+  "cmi.scaled_passing_score",
+  "cmi.max_time_allowed",
+  "cmi.completion_threshold",
+  "cmi.progress_measure",
+  "cmi.score.scaled",
+  "cmi.score.raw",
+  "cmi.score.min",
+  "cmi.score.max",
+  "cmi.objectives.N.score.scaled",
+  "cmi.objectives.N.score.raw",
+  "cmi.objectives.N.score.min",
+  "cmi.objectives.N.score.max",
+  "cmi.objectives.N.progress_measure",
+  "cmi.objectives.N.description",
+  "cmi.interactions.N.weighting",
+  "cmi.interactions.N.type",
+  "cmi.interactions.N.timestamp",
+  "cmi.interactions.N.result",
+  "cmi.interactions.N.latency",
+  "cmi.interactions.N.learner_response",
+  "cmi.interactions.N.description",
+  "cmi.comments_from_learner.N.timestamp"
+]);
+function normalizeCMIIndices(CMIElement) {
+  return CMIElement.replace(/\.\d+(?=\.|$)/g, ".N");
+}
 class Scorm2004API extends BaseAPI {
   _version = "1.0";
   _sequencing;
@@ -22657,6 +22977,39 @@ class Scorm2004API extends BaseAPI {
   getCMIValue(CMIElement) {
     return this._commonGetCMIValue("GetValue", true, CMIElement);
   }
+  /**
+   * Raises 403 (VALUE_NOT_INITIALIZED) when an implemented, no-default element is
+   * read before it has ever been set, per IEEE 1484.11.2 / SCORM 2004 RTE.
+   *
+   * Invoked by BaseAPI.getValue after an otherwise-successful resolution, so it
+   * only sees values the data model already returned cleanly. The decision is
+   * deliberately gated to this public boundary (never the getters) to keep
+   * serialization/commit/rollup — which read the getters directly — unaffected.
+   *
+   * A 403 is raised only when all hold:
+   *  - the resolved value is "" — any non-empty value is by definition set,
+   *    including values written by internal sequencing/activity-tree paths that
+   *    bypass _commonSetCMIValue (those only ever write non-empty values);
+   *  - the element was never set — _setCMIElements records every successful
+   *    SetValue, loadFromJSON, and global-objective restore (all route through
+   *    _commonSetCMIValue), so an explicit SetValue(x, "") still reads back as
+   *    "" with code 0; and
+   *  - the element has no spec-defined default ({@link NO_DEFAULT_2004_ELEMENTS}).
+   *
+   * @param {string} CMIElement
+   * @param {*} returnValue - the value getCMIValue resolved
+   * @protected
+   */
+  checkUninitializedGet(CMIElement, returnValue) {
+    if (returnValue !== "") return;
+    if (this._setCMIElements.has(CMIElement)) return;
+    if (!NO_DEFAULT_2004_ELEMENTS.has(normalizeCMIIndices(CMIElement))) return;
+    this.throwSCORMError(
+      CMIElement,
+      this._error_codes.VALUE_NOT_INITIALIZED ?? 403,
+      `The data model element passed to GetValue (${CMIElement}) has not been initialized.`
+    );
+  }
   /**
    * Returns the message that corresponds to errorNumber.
    * @param {(string|number)} errorNumber
@@ -22703,9 +23056,10 @@ class Scorm2004API extends BaseAPI {
   /**
    * Attempts to store the data to the LMS
    * @param {boolean} terminateCommit
+   * @param {CommitTrigger} [trigger] - What initiated the commit
    * @return {ResultObject}
    */
-  storeData(terminateCommit) {
+  storeData(terminateCommit, trigger) {
     if (terminateCommit) {
       if (this.cmi.mode === "normal") {
         if (this.cmi.credit === "credit") {
@@ -22753,7 +23107,8 @@ class Scorm2004API extends BaseAPI {
       const result = this.processHttpRequest(
         this.settings.lmsCommitUrl,
         commitObject,
-        terminateCommit
+        terminateCommit,
+        trigger
       );
       if (navRequest && result.navRequest !== void 0 && result.navRequest !== "" && typeof result.navRequest === "string") {
         const parsed = parseNavigationRequest(result.navRequest);