@magic-xpa/engine 4.1200.0-dev4120.99 → 4.1200.0

package/fesm2022/magic-xpa-engine.mjs

@@ -3,6 +3,7 @@ import { XMLConstants, StorageAttribute, ViewRefreshMode, InternalInterface, Log
 import { RecordUtils, GuiFieldBase, ExpVal, BlobType, FieldDef, GuiTaskBase, MgControlBase, PropInterface, GuiDataCollection, CommandType, Commands, HtmlProperties, ControlTable, Modifiers, KeyboardItem, TaskDefinitionIdTableSaxHandler, DisplayConvertor, VectorType, PIC, MgTimer, GuiConstants, RuntimeContextBase, UsernamePasswordCredentials, Styles, Manager, NUM_TYPE, GuiExpressionEvaluator, ExpressionInterface, DataModificationTypes, GuiDataViewBase, ObjectReferencesCollection, EMPTY_DCREF, ObjectReferenceBase, PropTable, FieldsTable as FieldsTable$1, DcValuesBuilderBase, MgFormBase, GuiEnvironment, TaskDefinitionId, Events, Helps, FocusManager, EventsProcessor, UIBridge } from '@magic-xpa/gui';
 import { HttpHeaders, HttpErrorResponse } from '@angular/common/http';
 import { timer, Subject } from 'rxjs';
+import * as CryptoJS from 'crypto-js';
 
 ///
 /// This class is used to hold references to global objects, using their interfaces/base classes. This allows other objects to access those global objects
@@ -288,6 +289,9 @@ class ConstInterface {
     static MG_ATTR_CPY_GLB_PRMS = "copy_global_params";
     static MG_TAG_GLOBALPARAMS = "globalparams";
     static MG_TAG_GLOBALPARAMSCHANGES = "globalParamChanges";
+    static MG_ATTR_FILE_PATH = "filepath";
+    static MG_TAG_CACHED_FILE = "cachedFile";
+    static MG_ATTR_CACHE_URL = "cacheUrl";
     static MG_TAG_PARAM = "param";
     static MG_ATTR_IME_AUTO_OFF = "imeAutoOff";
     static MG_ATTR_LOCAL_AS400SET = "local_as400set";
@@ -312,6 +316,7 @@ class ConstInterface {
     static MG_ATTR_HANDLER_ONFORM = "HandlerOnForm";
     static MG_ATTR_DROP_USERFORMATS = "dropuserformats";
     static MG_ATTR_CONTROL_NAME = "ControlName";
+    static MG_ATTR_SEARCH_STR = "searchStr";
     static MG_TAG_HIDDEN_CONTOLS = "HiddenControls";
     static MG_ATTR_ISNS = "Isns";
     static MG_ATTR_SPECIAL_CANCEL_ON_CREATE = "SpecialCancelOnCreate";
@@ -583,6 +588,7 @@ class ConstInterface {
     static MG_ATTR_VAL_EVENT = "event";
     static MG_ATTR_VAL_EXEC_OPER = "execoper";
     static MG_ATTR_VAL_QUERY = "query";
+    static MG_ATTR_VAL_QUERY_CACHED_FILE = "cachedFile";
     static MG_ATTR_VAL_QUERY_GLOBAL_PARAMS = "globalparams";
     static MG_ATTR_VAL_QUERY_TYPE = "query_type";
     static MG_ATTR_VAL_RECOMP = "recompute";
@@ -599,6 +605,7 @@ class ConstInterface {
     static MG_ATTR_SPECIAL_DOTNET_ALLOW_ZERO_DATE = "SpecialDotNetAllowZeroDate";
     static MG_ATTR_SPECIAL_REUSE_TABLE_EDITOR = "SpecialReuseTableEditor";
     static MG_TAG_LAST_ROUTE = "LastRoute";
+    static RC_TOKEN_CACHED_FILE = "CACHE=";
 }
 
 /// <summary>
@@ -5467,6 +5474,12 @@ class CommandsProcessorBase {
     /// <param name="requestedURL">URL to be accessed.</param>
     /// <returns>response (from the server).</returns>
     async GetContent(requestedURL, useCache) {
+        return Promise.resolve(null);
+    }
+    /// <summary> Invoke the request URL & return the response.</summary>
+    /// <param name="requestedURL">URL to be accessed.</param>
+    /// <returns>response (from the server).</returns>
+    async GetContentAsString(requestedURL, useCache) {
         return Promise.resolve('');
     }
     /// <summary> unscramble servers response</summary>
@@ -5788,12 +5801,7 @@ class HttpClientAsync extends HttpClientBase {
         return httpHeaders;
     }
     async sendRequestToServer(httpMethod, urlString, httpHeaders, requestContent, contentFromServer) {
-        let contents = requestContent;
-        let responseType = "text";
-        if (requestContent instanceof ArrayBuffer) {
-            responseType = "arraybuffer";
-        }
-        let httpResponse = await this.httpClient.request(RequestMethod[httpMethod], urlString, { headers: httpHeaders, responseType: responseType, observe: "response", body: contents }).toPromise();
+        let httpResponse = await this.httpClient.request(RequestMethod[httpMethod], urlString, { headers: httpHeaders, responseType: "arraybuffer", observe: "response", body: requestContent }).toPromise();
         contentFromServer.value = httpResponse.body;
         return httpResponse;
     }
@@ -5933,10 +5941,19 @@ class HttpManager {
     /// <returns>if the response contains the error indicator - the error indicator is truncated and the remaining is returned.
     /// otherwise - null (indicating that the 'http Response' didn't contain an error).</returns>
     static CheckAndGetErrorResponse(httpResponse) {
+        const errorResponseIndicator = Encoding.UTF8.GetBytes(ConstInterface.V24_RIA_ERROR_PREFIX);
         let errorResponse = null;
-        httpResponse = httpResponse instanceof ArrayBuffer ? new TextDecoder('utf-8').decode(httpResponse) : httpResponse;
-        if (httpResponse.startsWith(ConstInterface.V24_RIA_ERROR_PREFIX))
-            errorResponse = httpResponse.substr(ConstInterface.V24_RIA_ERROR_PREFIX.length);
+        const httpResponseBytes = new Uint8Array(httpResponse);
+        // Find 'errorResponseIndicator' in 'httpResponse', starting from the start index
+        let i;
+        for (i = 0; i < errorResponseIndicator.length; i++) {
+            if (httpResponseBytes[i] !== errorResponseIndicator[i]) {
+                break;
+            }
+        }
+        if (i === errorResponseIndicator.length) {
+            errorResponse = httpResponse.slice(errorResponseIndicator.length);
+        }
         return errorResponse;
     }
     static LogAccessToServer(msg, requestContent) {
@@ -5944,7 +5961,6 @@ class HttpManager {
             if (!NString.IsNullOrEmpty(msg)) {
                 msg = msg + "; accessing server ...";
             }
-            requestContent = requestContent instanceof ArrayBuffer ? new TextDecoder('utf-8').decode(requestContent) : requestContent;
             if (requestContent === null) {
                 if (!NString.IsNullOrEmpty(msg)) {
                     Logger.Instance.WriteServerToLog(msg);
@@ -5954,11 +5970,24 @@ class HttpManager {
                 if (!NString.IsNullOrEmpty(msg)) {
                     msg = msg + " ";
                 }
-                msg = msg + "uploading " + requestContent.length + " bytes";
+                msg = msg + "uploading " + HttpManager.GetRequestContentLength(requestContent) + " bytes";
                 Logger.Instance.WriteServerToLog(msg);
             }
         }
     }
+    /// <summary>
+    /// <returns>the length of 'requestContent'.</returns>
+    /// <summary>
+    static GetRequestContentLength(requestContent) {
+        let length = 0;
+        if (requestContent instanceof ArrayBuffer) {
+            length = requestContent.byteLength;
+        }
+        else {
+            length = requestContent.length;
+        }
+        return length;
+    }
 }
 
 class ServerConfig {
@@ -6614,6 +6643,12 @@ class RemoteCommandsProcessor extends CommandsProcessorBase {
     SessionId;
     DelayCommandExecution = false;
     _requestInfo = new RequestInfo();
+    // After the expression is evaluated, we obtain local file path. But to fetch this resource from server,
+    // cache path is needed. If cache path isn't found in cachedFilesMap, then query server for cachedFile.
+    // Later again if the expression is evaluated to the same path, no need to query server for cache path.
+    // e.g. for server-file path = "C:\\Blue_hills.jpg"
+    // cache path = "/MagicScripts/mgrqispi.dll?CTX=10430335172368&CACHE=agent_3572_C__Blue_hills.jpg|06/10/2009%2016:36:16"
+    serverFilesToClientFiles = new Map(); // Map between server-file path and cachedFileUrl
     static GetInstance() {
         if (RemoteCommandsProcessor._instance === null) {
             RemoteCommandsProcessor._instance = new RemoteCommandsProcessor();
@@ -7279,6 +7314,45 @@ class RemoteCommandsProcessor extends CommandsProcessorBase {
         }
         return response;
     }
+    async DownloadFileFromServer(serverFileName) {
+        let fileContent = new ArrayBuffer(0);
+        let cmd = CommandFactory.CreateQueryCachedFileCommand(serverFileName);
+        AccessHelper.mgDataTable.getCurrMGData().CmdsToServer.Add(cmd);
+        this.serverFilesToClientFiles.delete(serverFileName);
+        await this.Execute(CommandsProcessorBase_SendingInstruction.ONLY_COMMANDS);
+        //Check what url value is getting in the below line.(file path or the url starts with ?)
+        let serverCachedFilePath = this.serverFilesToClientFiles.has(serverFileName) ? this.serverFilesToClientFiles.get(serverFileName) : null;
+        if (serverCachedFilePath) {
+            // let url: string = serverCachedFilePath;
+            fileContent = await this.GetContent(serverCachedFilePath, false);
+        }
+        return fileContent;
+    }
+    fillCacheFilesMap(parser) {
+        const xmlData = parser.getXMLdata();
+        let endContext = xmlData.indexOf(XMLConstants.TAG_TERM, parser.getCurrIndex());
+        if (endContext !== -1 && endContext < xmlData.length) {
+            // Find last position of its tag
+            const tag = parser.getXMLsubstring(endContext);
+            parser.add2CurrIndex(tag.indexOf(ConstInterface.MG_TAG_CACHED_FILE) + ConstInterface.MG_TAG_CACHED_FILE.length);
+            const tokensVector = XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM);
+            // Verify token names
+            console.assert(tokensVector[0] === ConstInterface.MG_ATTR_FILE_PATH, 'Invalid token for file path');
+            console.assert(tokensVector[2] === ConstInterface.MG_ATTR_CACHE_URL, 'Invalid token for cache URL');
+            // Get token values
+            const fileName = tokensVector[1];
+            const fileUrl = tokensVector[3];
+            if (fileUrl.trim() !== '') {
+                // Store file path and cache retrieval URL in dictionary
+                this.serverFilesToClientFiles.set(fileName, fileUrl);
+            }
+            endContext = xmlData.indexOf(XMLConstants.TAG_OPEN, endContext);
+            if (endContext === -1) {
+                endContext = xmlData.length;
+            }
+            parser.setCurrIndex(endContext);
+        }
+    }
     // <summary> If any items are stored on local storage clear it now as session cannot continued.
     // Clearing only the local storage items which are stored by magic library.
     clearLocalStorage() {
@@ -7296,30 +7370,28 @@ class RemoteCommandsProcessor extends CommandsProcessorBase {
     /// an xml/html error</summary>
     /// <param name="response"></param>
     HandleErrorResponse(response) {
-        if (response instanceof ArrayBuffer)
-            response = this.ArrayBufferToString(response);
+        let responseStr = this.ArrayBufferToString(response);
         try {
             // error responses are always scrambled by the web server.
-            Logger.Instance.WriteServerMessagesToLog("MESSAGE FROM SERVER: " + response);
-            response = CommandsProcessorBase.UnScramble(response);
-            Logger.Instance.WriteServerMessagesToLog("MESSAGE FROM SERVER: " + StrUtil.getConsoleErorString(response));
+            Logger.Instance.WriteServerMessagesToLog("MESSAGE FROM SERVER: " + responseStr);
+            responseStr = CommandsProcessorBase.UnScramble(responseStr);
+            Logger.Instance.WriteServerMessagesToLog("MESSAGE FROM SERVER: " + StrUtil.getConsoleErorString(responseStr));
         }
         catch (ex) {
         }
-        if (response.startsWith("<xmlerr")) {
-            let errorMessageXml = new ErrorMessageXml(response, this._lastRequestTime, AccessHelper.environment.getContextInactivityTimeout());
+        if (responseStr.startsWith("<xmlerr")) {
+            let errorMessageXml = new ErrorMessageXml(responseStr, this._lastRequestTime, AccessHelper.environment.getContextInactivityTimeout());
             throw new ServerError(errorMessageXml.GetMessage(), errorMessageXml.GetCode());
         }
-        else if (response.toUpperCase().startsWith("<HTML")) {
-            throw new ServerError(response);
+        else if (responseStr.toUpperCase().startsWith("<HTML")) {
+            throw new ServerError(responseStr);
         }
     }
     // <summary>
     // Converts an ArrayBuffer to a UTF-8 encoded string.
     // </summary>
     ArrayBufferToString(arrayBuffer) {
-        const decoder = new TextDecoder('utf-8');
-        return decoder.decode(arrayBuffer);
+        return Encoding.UTF8.GetString(new Uint8Array(arrayBuffer), 0, arrayBuffer.byteLength);
     }
     /// <summary>send 'encodedBody' to 'url' and receive a response.
     /// </summary>
@@ -7327,29 +7399,36 @@ class RemoteCommandsProcessor extends CommandsProcessorBase {
     /// <param name="encodedBody">In case of POST, content to be sent to server. For other methods, null.</param>
     /// <returns>the response from the server</returns>
     async ExecuteRequest(url, encodedBody) {
-        let response = await this.GetContent(url, false, encodedBody);
-        return response instanceof ArrayBuffer ? this.ArrayBufferToString(response) : response;
+        return await this.GetContentAsString(url, false, encodedBody);
+    }
+    async GetContentAsString(requestedURL, useCache, requestContent, requestContentType) {
+        let response = await this.GetContent(requestedURL, useCache, requestContent, requestContentType);
+        return this.ArrayBufferToString(response);
     }
     async GetContent(requestedURL, useCache, requestContent, requestContentType) {
         if (isUndefined(requestContent))
             requestContent = null;
         if (isUndefined(requestContentType))
             requestContentType = null;
-        let responseStr;
+        let response;
         try {
             // if relative, prefix with the 'protocol://server/' from which the rich-client was activated
             if (requestedURL.startsWith("/"))
                 requestedURL = ServerConfig.Instance.getProtocol() + "://" + ServerConfig.Instance.getServer() + requestedURL;
+            else if (requestedURL.startsWith("?")) {
+                requestedURL = this.ServerUrl + requestedURL;
+                requestedURL = this.validateURL(requestedURL, this._sessionCounter, this.SessionId);
+            }
             var spinnerTimer = timer(50, 50);
             var spinnerTimerSubscription = spinnerTimer.subscribe(() => {
                 AccessHelper.eventsManager.CheckAndShowSpinner(true);
             });
             let isError = new RefParam(false);
-            responseStr = await HttpManager.GetInstance().GetContent(requestedURL, requestContent, requestContentType, useCache, isError);
+            response = await HttpManager.GetInstance().GetContent(requestedURL, requestContent, requestContentType, useCache, isError);
             spinnerTimerSubscription.unsubscribe();
             spinnerTimerSubscription = null;
             if (isError.value) {
-                this.HandleErrorResponse(responseStr);
+                this.HandleErrorResponse(response);
             }
         }
         catch (ex) {
@@ -7367,7 +7446,75 @@ class RemoteCommandsProcessor extends CommandsProcessorBase {
             if (spinnerTimerSubscription != null)
                 spinnerTimerSubscription.unsubscribe();
         }
-        return responseStr;
+        return response;
+    }
+    validateURL(url, sessionCounter, sessionId) {
+        // const utf8Encoding = 'utf-8';  // UTF-8 encoding is used in the context of web APIs, but not directly needed in JavaScript/TypeScript
+        // Create URL object from string
+        const u = new URL(url);
+        // Assert protocol (http, https, or file)
+        if (!(u.protocol === "http:" || u.protocol === "https:" || u.protocol === "file:")) {
+            throw new Error("Invalid protocol. Expected http, https, or file.");
+        }
+        // Add protocol as is
+        let validURL = u.protocol + "//";
+        // Encode host
+        validURL += encodeURIComponent(u.hostname);
+        // If port is specified, append it
+        const port = u.port;
+        if (port) {
+            validURL += `:${port}`;
+        }
+        // Get path (e.g., alias/dir1/dir2/file)
+        let path = u.pathname;
+        if (!path.startsWith("/")) {
+            validURL += "/";
+        }
+        // Tokenize the path and encode each part
+        const pathParts = path.split("/");
+        // Recompose the URL (path is already encoded by `encodeURIComponent`)
+        for (let i = 0; i < pathParts.length; i++) {
+            validURL += encodeURIComponent(pathParts[i]) + "/";
+        }
+        // Remove last "/"
+        if (validURL.endsWith("/")) {
+            validURL = validURL.slice(0, validURL.length - 1);
+        }
+        // Replace "+" with "%20" (standard for spaces in URLs)
+        validURL = validURL.replace(/\+/g, "%20");
+        // Add the query string
+        if (u.search) {
+            let modifiedQuery = u.search;
+            const CTX_ID_PLACEHOLDER = "CTX=&";
+            const ctxIdIdx = u.search.indexOf(CTX_ID_PLACEHOLDER);
+            if (ctxIdIdx > -1) {
+                // Add context ID
+                // const queryString = `${ClientManager.Instance.RuntimeCtx.ContextID}`;
+                // Append session ID if provided
+                let queryParams = `${ClientManager.Instance.GetRuntimeCtxID()}`;
+                if (sessionId) {
+                    queryParams += `&${ConstInterface.RC_TOKEN_SESSION_ID}=${sessionId}`;
+                }
+                queryParams += `&${ConstInterface.RC_TOKEN_SESSION_COUNT}${sessionCounter}`;
+                // Insert query parameters in the query string
+                modifiedQuery = u.search.substring(0, ctxIdIdx + CTX_ID_PLACEHOLDER.length - 1) + queryParams + u.search.substring(ctxIdIdx + CTX_ID_PLACEHOLDER.length - 1);
+                // modifiedQuery is updated with file name with base64 encoded.
+                let indexOfCacheToken = modifiedQuery.indexOf(ConstInterface.RC_TOKEN_CACHED_FILE);
+                if (indexOfCacheToken !== -1) {
+                    let url = modifiedQuery;
+                    const cacheRegex = /CACHE=([^&]+)/;
+                    const match = url.match(cacheRegex);
+                    if (match && match[1]) {
+                        const cacheFileName = match[1].split('|')[0];
+                        const base64CacheFileName = btoa(cacheFileName);
+                        modifiedQuery = url.replace(`CACHE=${match[1]}`, `CACHE=${base64CacheFileName}`);
+                    }
+                }
+            }
+            validURL += modifiedQuery;
+            validURL = validURL.replace(/\|/g, "%7C");
+        }
+        return validURL;
     }
     // <summary> Upload contents to a file on server </summary>
     // <param name="serverFileName">filename to be saved on the server.</param>
@@ -7383,11 +7530,8 @@ class RemoteCommandsProcessor extends CommandsProcessorBase {
         queryStr += `${ConstInterface.REQ_ARG_SEPARATOR}${ConstInterface.RC_TOKEN_SESSION_COUNT}${this.GetSessionCounter()}${ConstInterface.REQ_ARG_SEPARATOR}${ConstInterface.RC_TOKEN_TARGET_FILE}${encodedName}`;
         const url = ServerConfig.Instance.getServerURL() + queryStr;
         let response = await this.GetContent(url, false, fileContent, contentType);
-        if (response instanceof ArrayBuffer) {
-            let uInt8Array = new Uint8Array(response);
-            return uInt8Array[0];
-        }
-        return response;
+        let uInt8Array = new Uint8Array(response);
+        return uInt8Array[0];
     }
     ClientActivated() {
         // log the values as client is active again
@@ -8032,8 +8176,15 @@ class CommandsProcessorManager {
     /// <param name="requestedURL"></param>
     /// <returns></returns>
     static async GetContent(requestedURL, useCache) {
-        let ret = await (CommandsProcessorManager.GetCommandsProcessor().GetContent(requestedURL, useCache));
-        return ret;
+        return await (CommandsProcessorManager.GetCommandsProcessor().GetContent(requestedURL, useCache));
+    }
+    /// <summary>
+    /// get the URL content according to the active commands processor
+    /// </summary>
+    /// <param name="requestedURL"></param>
+    /// <returns></returns>
+    static async GetContentString(requestedURL, useCache) {
+        return await (CommandsProcessorManager.GetCommandsProcessor().GetContentAsString(requestedURL, useCache));
     }
     /// <summary>
     /// Start session
@@ -8187,7 +8338,7 @@ class LanguageData {
                 if (this._constMessagesUrl != null) {
                     try {
                         // get the content from the server
-                        msgsInCommentString = await CommandsProcessorManager.GetContent(this._constMessagesUrl, true);
+                        msgsInCommentString = await CommandsProcessorManager.GetContentString(this._constMessagesUrl, true);
                     }
                     catch (err) {
                         Logger.Instance.WriteExceptionToLogWithMsg(NString.Format("Unknown message file: \"{0}\"", this._constMessagesUrl));
@@ -8198,7 +8349,6 @@ class LanguageData {
                     msgsInCommentString = this._constMessagesContent;
                 }
                 if (msgsInCommentString != null) {
-                    msgsInCommentString = msgsInCommentString instanceof ArrayBuffer ? new TextDecoder('utf-8').decode(msgsInCommentString) : msgsInCommentString;
                     // ignore the comment wrapper
                     let startData = msgsInCommentString.indexOf(START_TAG);
                     let endData = msgsInCommentString.indexOf(END_TAG) + END_TAG.length;
@@ -8288,9 +8438,9 @@ class LanguageData {
             else if (this._mlsFileUrl != null) {
                 if (this._mlsFileUrl.startsWith("./"))
                     this._mlsFileUrl = NString.Replace(this._mlsFileUrl, './', ClientManager.GetAssetsURL() + '/cache/');
-                let buffer = await CommandsProcessorManager.GetContent(this._mlsFileUrl, true);
-                buffer = buffer instanceof ArrayBuffer ? new TextDecoder('utf-8').decode(buffer) : buffer;
-                if (buffer != null && buffer.length > 0) {
+                let arrayBuffer = await CommandsProcessorManager.GetContent(this._mlsFileUrl, true);
+                if (arrayBuffer != null && arrayBuffer.byteLength > 0) {
+                    let buffer = Encoding.Unicode.GetString(new Uint8Array(arrayBuffer), 0, arrayBuffer.byteLength);
                     let contentLen = buffer.length;
                     this._mlsStrings = new Hashtable();
                     // read the last line
@@ -9587,6 +9737,17 @@ class ExpressionDict {
         new ExpDesc('B', 0, 1, 1, 'A', false), /* 703- Delete_Cookie */
         null,
         new ExpDesc('U', 0, 0, 0, '', false), /* 705- RouteGet */
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        new ExpDesc('NO', 0, 2, 2, 'A', false), /* 716- Hash */
     ];
 }
 
@@ -9953,6 +10114,7 @@ class RefreshEventCommand extends EventCommand {
 /// </summary>
 class FetchDataControlValuesEventCommand extends EventCommand {
     ControlName = null;
+    FilterData = null;
     constructor() {
         super(InternalInterface.MG_ACT_FETCH_DATA_CONTROL_VALUES);
     }
@@ -9961,6 +10123,8 @@ class FetchDataControlValuesEventCommand extends EventCommand {
         helper.SerializeTaskTag(this.TaskTag);
         helper.SerializeMagicEvent(this.MagicEvent);
         helper.SerializeAttribute(ConstInterface.MG_ATTR_CONTROL_NAME, this.ControlName);
+        if (this.FilterData != null && this.FilterData != "")
+            helper.SerializeAttribute(ConstInterface.MG_ATTR_SEARCH_STR, this.FilterData);
         return helper.GetString();
     }
     getCommandInfo() {
@@ -10409,11 +10573,30 @@ class SelectProgramCommand extends ExecOperCommand {
 /// </summary>
 class ControlItemsRefreshCommand extends DataviewCommand {
     Control = null;
+    FilterData = null;
     constructor() {
         super();
     }
 }
 
+class CachedFileQueryCommand extends QueryCommand {
+    text;
+    constructor(text) {
+        super();
+        this.text = text;
+    }
+    /**
+     * Serializes the query command data
+     */
+    SerializeQueryCommandData() {
+        let message = ConstInterface.MG_ATTR_VAL_QUERY_CACHED_FILE + '"';
+        let helper = new CommandSerializationHelper();
+        helper.SerializeAttribute(ConstInterface.MG_ATTR_FILE_PATH, this.text);
+        message += helper.GetString();
+        return message;
+    }
+}
+
 /// <summary>
 /// factory class for creating commands
 /// </summary>
@@ -10461,11 +10644,12 @@ class CommandFactory {
     /// <param name="taskId"></param>
     /// <param name="control"></param>
     /// <returns></returns>
-    static CreateControlItemsRefreshCommand(taskId, control) {
+    static CreateControlItemsRefreshCommand(taskId, control, filterData) {
         let command = new ControlItemsRefreshCommand();
         command.CommandType = DataViewCommandType.ControlItemsRefresh;
         command.TaskTag = taskId;
         command.Control = control;
+        command.FilterData = filterData;
         return command;
     }
     /// <summary>
@@ -10570,10 +10754,11 @@ class CommandFactory {
     /// <param name="controlName"></param>
     /// <param name="generationParam"></param>
     /// <returns></returns>
-    static CreatecFetchDataControlValuesCommand(taskTag, controlName) {
+    static CreatecFetchDataControlValuesCommand(taskTag, controlName, filterData) {
         let fetchDataControlValuesEventCommand = new FetchDataControlValuesEventCommand();
         fetchDataControlValuesEventCommand.TaskTag = taskTag;
         fetchDataControlValuesEventCommand.ControlName = controlName;
+        fetchDataControlValuesEventCommand.FilterData = filterData;
         return fetchDataControlValuesEventCommand;
     }
     static CreateSubformRefreshCommand(taskTag, subformTaskTag, explicitSubformRefresh) {
@@ -10810,6 +10995,9 @@ class CommandFactory {
         iniputForceWriteCommand.Text = param;
         return iniputForceWriteCommand;
     }
+    static CreateQueryCachedFileCommand(cachedFileName) {
+        return new CachedFileQueryCommand(cachedFileName);
+    }
 }
 
 var ParamParseResult;
@@ -11306,13 +11494,12 @@ class Environment {
                 // in which case the current error message will be matched with an error in the xpa server's log file (GeneralErrorLog=)).
                 Logger.Instance.WriteErrorToLog(NString.Format("Empty cached file URL: '{0}'", tagAndAttributes.trim()));
             else {
-                let Content = await CommandsProcessorManager.GetContent(cachedFileUrl, true);
+                let Content = await CommandsProcessorManager.GetContentString(cachedFileUrl, true);
                 try {
                     switch (tagName) {
                         case ConstInterface.MG_TAG_KBDMAP_URL:
                             break;
                         case ConstInterface.MG_TAG_ENV_PARAM_URL:
-                            Content = Content instanceof ArrayBuffer ? new TextDecoder('utf-8').decode(Content) : Content;
                             let innerXmlParser = new XmlParser(Content);
                             while (AccessHelper.envParamsTable.mirrorFromXML(innerXmlParser.getNextTag(), innerXmlParser)) {
                             }
@@ -12047,6 +12234,7 @@ class Operation {
     _undo = true;
     _isRoute = false;
     _routerPath = null;
+    _subformExp = null;
     _originalRouterOutletName = null;
     _routeParams = null;
     constructor() {
@@ -12250,6 +12438,10 @@ class Operation {
                 case XMLConstants.MG_ATTR_ROUTER_PATH:
                     this._routerPath = XmlParser.unescape(valueStr);
                     break;
+                case XMLConstants.MG_ATTR_SUBFORM_EXP:
+                    expId = XmlParser.getInt(valueStr);
+                    this._subformExp = taskRef.getExpById(expId);
+                    break;
                 default:
                     Logger.Instance.WriteExceptionToLogWithMsg("There is no such tag in Operation class. Insert case to Operation.initElements for " + attribute);
                     break;
@@ -12312,7 +12504,7 @@ class Operation {
     /// </param>
     /// <param name = "returnedFromServer">true if the server returned the execution to this operation</param>
     /// <returns> boolean for verify and block operations</returns>
-    async execute(returnedFromServer) {
+    async execute(returnedFromServer, desiredRouteName = null) {
         let lastRtEvent = AccessHelper.eventsManager.getLastRtEvent();
         let mprgCreator = null;
         let flowMonitor = FlowMonitorQueue.Instance;
@@ -12357,6 +12549,17 @@ class Operation {
                     await this.operServer(mprgCreator);
                     break;
                 case ConstInterface.MG_OPER_CALL:
+                    if (this._subformExp != null) {
+                        const subformName = await this._subformExp.evaluateWithResultTypeAndLength(StorageAttribute.ALPHA, 30);
+                        if (!subformName || subformName.length > 30) {
+                            const messageKey = !subformName ? MsgInterface.STR_ERR_BLANK_SUBFORM_NAME : MsgInterface.STR_ERR_SUBFORM_NAME_EXCEEDS_LIMIT;
+                            let message = LanguageData.Instance.getConstMessage(messageKey);
+                            message = LanguageData.Instance.translate(message);
+                            this._task.WriteToMessagePane(message);
+                            return false;
+                        }
+                        this._subformCtrlName = subformName;
+                    }
                     if (this._publicName != null) {
                         this.operCallParallel();
                     }
@@ -12386,8 +12589,16 @@ class Operation {
                                     let canRoute = false;
                                     let rtEvnt = AccessHelper.eventsManager.getLastRtEvent();
                                     if (rtEvnt !== null) {
-                                        this._routeParams = rtEvnt.getRouteParamList();
-                                        if ((await rtEvnt.getArgList().getArg(0).getValue(StorageAttribute.ALPHA, 0)).trim() === this._routerPath &&
+                                        // If we are here for default route path, set the routeParams as null because those are relevant only for the original route.
+                                        if (!this._evtHandler.isExecutingDefaultRoute()) {
+                                            desiredRouteName = (await rtEvnt.getArgList().getArg(0).getValue(StorageAttribute.ALPHA, 0)).trim();
+                                            this._routeParams = rtEvnt.getRouteParamList();
+                                        }
+                                        else {
+                                            desiredRouteName = this._evtHandler.getDefaultRouteName();
+                                            this._routeParams = null;
+                                        }
+                                        if (desiredRouteName === this._routerPath &&
                                             ((rtEvnt.getArgList().getArg(1).skipArg() && destSubForm === this._task.getForm().DefaultRouterOutlet) ||
                                                 (!rtEvnt.getArgList().getArg(1).skipArg() && (await rtEvnt.getArgList().getArg(1).getValue(StorageAttribute.ALPHA, 0)).trim() === this._originalRouterOutletName)))
                                             canRoute = true;
@@ -12895,7 +13106,18 @@ class Operation {
     /// </summary>
     /// <returns></returns>
     async canExecute() {
-        return await this.getCondVal();
+        return (this.isOperationAllowedWhileExecutingDefaultRoute() && await this.getCondVal());
+    }
+    isOperationAllowedWhileExecutingDefaultRoute() {
+        let isAllowed = true;
+        if (this._evtHandler.isExecutingDefaultRoute()) {
+            if (this._type == ConstInterface.MG_OPER_BLOCK || this._type == ConstInterface.MG_OPER_ELSE ||
+                (this._type == ConstInterface.MG_OPER_CALL && this._isRoute))
+                return true;
+            else
+                return false;
+        }
+        return isAllowed;
     }
     /// <summary>
     /// </summary>
@@ -13607,6 +13829,9 @@ class ExpressionEvaluator extends GuiExpressionEvaluator {
     static PARENT_LEN = 2; // 2 bytes
     static SHORT_OBJECT_LEN = 2; // 2 bytes
     static LONG_OBJECT_LEN = 4; // 4 bytes
+    static MD5_ALGO_NUM = 1;
+    static SHA1_ALGO_NUM = 2;
+    static SHA2_ALGO_NUM = 3;
     static _recursiveExpCalcCount = 0;
     _charsToTrim = [' ', '\0'];
     _expressionLocalJpn = null;
@@ -15230,6 +15455,12 @@ class ExpressionEvaluator extends GuiExpressionEvaluator {
             case ExpressionInterface.EXP_OP_ROUTEGET:
                 this.eval_op_route_get(resVal);
                 break;
+            case ExpressionInterface.EXP_OP_HASH:
+                val2 = valStack.pop();
+                val1 = valStack.pop();
+                this.eval_op_Hash(val1, val2, resVal);
+                expStrTracker.resetNullResult();
+                break;
             default:
                 return;
         }
@@ -16681,7 +16912,7 @@ class ExpressionEvaluator extends GuiExpressionEvaluator {
                 let control = tsk.getForm().GetCtrl(val1.StrVal);
                 //This function is applicable only for Combo box, List box etc. i.e. for choice controls. Also it will refresh items only if Source table is attached to the data control.
                 if (control != null && control.isChoiceControl() && control.isDataCtrl()) {
-                    let command = CommandFactory.CreateControlItemsRefreshCommand(tsk.getTaskTag(), control);
+                    let command = CommandFactory.CreateControlItemsRefreshCommand(tsk.getTaskTag(), control, "");
                     await tsk.DataviewManager.CurrentDataviewManager.Execute(command);
                     success = true;
                 }
@@ -18196,7 +18427,7 @@ class ExpressionEvaluator extends GuiExpressionEvaluator {
         if (!isNullOrUndefined(args)) {
             // TODO: This is a patch fix put for MXPA-30360. Problem is that the lazy loading components are not loaded in an async way.
             // Hence for the first record cycle the CallJS operation was not working. So, async loading of lazy loaded comps should be
-            // handled. 
+            // handled.
             resVal.StrVal = Commands.addCallJS(form, form.UniqueName, methodName, args);
             resVal.Attr = StorageAttribute.ALPHA;
         }
@@ -18293,6 +18524,35 @@ class ExpressionEvaluator extends GuiExpressionEvaluator {
         }
         return attr;
     }
+    eval_op_Hash(val1, val2, resVal) {
+        resVal.Attr = StorageAttribute.ALPHA;
+        resVal.StrVal = '';
+        if (val1.IsNull || val2.IsNull)
+            return;
+        let str = '';
+        const byteArray = BlobType.getBytes(val2.StrVal);
+        const wordArray = this.toWordArray(byteArray);
+        if (val1.MgNumVal.NUM_2_LONG() === ExpressionEvaluator.MD5_ALGO_NUM)
+            str = CryptoJS.MD5(wordArray).toString();
+        else if (val1.MgNumVal.NUM_2_LONG() === ExpressionEvaluator.SHA1_ALGO_NUM)
+            str = CryptoJS.SHA1(wordArray).toString();
+        else if (val1.MgNumVal.NUM_2_LONG() === ExpressionEvaluator.SHA2_ALGO_NUM)
+            str = CryptoJS.SHA256(wordArray).toString();
+        else
+            Logger.Instance.WriteErrorToLog(LanguageData.Instance.getConstMessage(MsgInterface.STR_ERR_INVALID_HASH_ALGO_NUMBER));
+        resVal.StrVal = str;
+    }
+    // Convert Uint8Array to WordArray
+    toWordArray(u8) {
+        const words = [];
+        for (let i = 0; i < u8.length; i += 4) {
+            words.push(((u8[i] || 0) << 24) |
+                ((u8[i + 1] || 0) << 16) |
+                ((u8[i + 2] || 0) << 8) |
+                (u8[i + 3] || 0));
+        }
+        return CryptoJS.lib.WordArray.create(words, u8.length);
+    }
 }
 /// <summary>
 ///   This exception used when at least one of the operands is null
@@ -24979,13 +25239,15 @@ class ResultValue {
 
 class RemoteControlItemsRefreshCommand extends RemoteDataViewCommandBase {
     control = null;
+    filterData = null;
     constructor(command) {
         super(command);
         this.control = command.Control;
+        this.filterData = command.FilterData;
     }
     async Execute() {
         let res = new ResultValue();
-        let cmd = CommandFactory.CreatecFetchDataControlValuesCommand(this.Task.getTaskTag(), this.control.getName());
+        let cmd = CommandFactory.CreatecFetchDataControlValuesCommand(this.Task.getTaskTag(), this.control.getName(), this.filterData);
         this.Task.getMGData().CmdsToServer.Add(cmd);
         // Fetch data control values from server.
         await RemoteCommandsProcessor.GetInstance().Execute_1(CommandsProcessorBase_SendingInstruction.TASKS_AND_COMMANDS, CommandsProcessorBase_SessionStage.NORMAL, res);
@@ -27202,9 +27464,8 @@ class TableCacheManager {
             // get the table
             let current = this._tables.get_Item(tableUId);
             try {
-                let residentTableContentStr = await server.GetContent(tableUId, true);
+                let residentTableContentStr = await server.GetContentAsString(tableUId, true);
                 try {
-                    residentTableContentStr = residentTableContentStr instanceof ArrayBuffer ? new TextDecoder('utf-8').decode(residentTableContentStr) : residentTableContentStr;
                     RuntimeContextBase.Instance.Parser.loadTableCacheData(residentTableContentStr);
                 }
                 catch (innerException) {
@@ -27870,6 +28131,8 @@ class EventHandler {
     _scope = null; // Task|Subtask|Global
     _task = null;
     _taskMgdID = -1;
+    _defRouteName = null;
+    _isExecutingDefaultRoute = false;
     /// <summary>
     ///   CTOR
     /// </summary>
@@ -27998,6 +28261,9 @@ class EventHandler {
                 case ConstInterface.MG_ATTR_HANDLER_ONFORM:
                     this._isHandlerOnForm = XmlParser.getBoolean(valueStr);
                     break;
+                case XMLConstants.MG_ATTR_DEF_ROUTER_NAME:
+                    this._defRouteName = XmlParser.unescape(valueStr);
+                    break;
                 default:
                     Logger.Instance.WriteExceptionToLogWithMsg("There is no such tag in EventHandler class. Insert case to EventHandler.initElements for " + attribute);
                     break;
@@ -28226,8 +28492,15 @@ class EventHandler {
                 await this.resetLocalVariables(args);
                 initialLoopStackSize = this._task.getLoopStackSize();
                 let retVals = null;
-                if (this._operationTab.getSize() > 0)
+                if (this._operationTab.getSize() > 0) {
                     retVals = await this.executeOperations(0, this._operationTab.getSize() - 1, taskEnd, mgdID, depth, isChangedCurrWndRef, false, false, -1);
+                    if (retVals == null && this.isRouteHandler() && this.getDefaultRouteName() != null) {
+                        this._isExecutingDefaultRoute = true;
+                        // call again with an additional param Default Route Name
+                        retVals = await this.executeOperations(0, this._operationTab.getSize() - 1, taskEnd, mgdID, depth, isChangedCurrWndRef, false, false, -1);
+                        this._isExecutingDefaultRoute = false;
+                    }
+                }
                 isChangedCurrWnd = isChangedCurrWndRef.value;
                 if (retVals !== null)
                     return retVals;
@@ -28307,6 +28580,9 @@ class EventHandler {
         }
         return new RetVals(retVal, true);
     }
+    isExecutingDefaultRoute() {
+        return this._isExecutingDefaultRoute;
+    }
     /// <summary>
     ///   execute the operations starting from fromIdx and ending at endIdx.
     /// </summary>
@@ -28646,6 +28922,12 @@ class EventHandler {
     getEvent() {
         return this._evt;
     }
+    isRouteHandler() {
+        return (this._evt.getType() == ConstInterface.EVENT_TYPE_INTERNAL && this._evt.getInternalCode() === InternalInterface.MG_ACT_WEBCLIENT_ROUTE);
+    }
+    getDefaultRouteName() {
+        return this._defRouteName;
+    }
     /// <summary>
     ///   get the Id of the event handler
     /// </summary>
@@ -32839,8 +33121,7 @@ class Task extends TaskBase {
             // bring the data
             if (taskCacheURL.startsWith("./"))
                 taskCacheURL = NString.Replace(taskCacheURL, './', ClientManager.GetAssetsURL() + '/cache/');
-            taskContentOriginal = await Task.CommandsProcessor.GetContent(taskCacheURL, true);
-            taskContentOriginal = taskContentOriginal instanceof ArrayBuffer ? new TextDecoder('utf-8').decode(taskContentOriginal) : taskContentOriginal;
+            taskContentOriginal = await Task.CommandsProcessor.GetContentAsString(taskCacheURL, true);
         }
         // prefix the original data till the start of the current <taskURL>
         let taskContentFinal = new StringBuilder(xmlData.substr(0, RuntimeContextBase.Instance.Parser.getCurrIndex() - (ConstInterface.MG_TAG_TASKURL.length + 1)), taskContentOriginal.length);
@@ -33358,6 +33639,9 @@ class MGData {
                 Logger.Instance.WriteDevToLog("processing base64 encoded image of all global params from the server");
                 this.fillGlobalParams(parser);
                 break;
+            case ConstInterface.MG_TAG_CACHED_FILE:
+                RemoteCommandsProcessor.GetInstance().fillCacheFilesMap(parser);
+                break;
             case ConstInterface.MG_TAG_ENV_PARAM_URL:
                 Logger.Instance.WriteDevToLog("goes to env params name ");
                 await Environment.Instance.fillFromUrl(foundTagName, parser);
@@ -37164,6 +37448,13 @@ class EventsManager {
                 case InternalInterface.MG_ACT_SET_EXTERNAL_VALUE:
                     let refreshDisplay = await evt.getArgList().getArgValue(1, StorageAttribute.BOOLEAN, 0) === '1' ? true : false;
                     await ctrl.validateAndSetValueIfAllowed(evt.getValue(), refreshDisplay);
+                    //We will be here if we type in character(s)
+                    //And if the control has Autocomplete Mode and On Demand property set to true, we need to display the autocomplete list
+                    //based on whatever value user has typed. So, excute ControlItemsRefresh command to fetch the data control's values.
+                    if (ctrl.isOnDemandSelectionList()) {
+                        let command = CommandFactory.CreateControlItemsRefreshCommand(task.getTaskTag(), ctrl, evt.getValue());
+                        await task.DataviewManager.CurrentDataviewManager.Execute(command);
+                    }
                     break;
             }
         }
@@ -39338,7 +39629,7 @@ class CommandsTable {
     }
 }
 
-let CurrentClientVersion = '4.1200.0-dev4120.99';
+let CurrentClientVersion = '4.1200.0';
 
 // @dynamic
 class ClientManager {
@@ -39692,13 +39983,8 @@ class ClientManager {
             // isError cannot be true here, because it is returned by runtime engine and to read execution properties, we do not reach the engine.
             let isError = new RefParam(false);
             response = await HttpManager.GetInstance().GetContent(ClientManager._executionPropertiesFileName, null, null, false, isError);
-            if (response instanceof ArrayBuffer) {
-                const decoder = new TextDecoder('utf-8');
-                ServerConfig.Instance.Init(JSON.parse(decoder.decode(response)));
-            }
-            else {
-                ServerConfig.Instance.Init(JSON.parse(response));
-            }
+            const responseStr = Encoding.UTF8.GetString((new Uint8Array(response)), 0, response.byteLength);
+            ServerConfig.Instance.Init(JSON.parse(responseStr));
             let assetsURL = ServerConfig.Instance.getAssetsURL();
             if (assetsURL !== null) {
                 ClientManager.assetsURL = assetsURL;
@@ -39735,6 +40021,9 @@ class ClientManager {
     static UploadFileToServer(fileContent, serverFileName) {
         return RemoteCommandsProcessor.GetInstance().UploadFileToServer(fileContent, serverFileName);
     }
+    static async DownloadFileFromServer(serverFileName) {
+        return await RemoteCommandsProcessor.GetInstance().DownloadFileFromServer(serverFileName);
+    }
     /// <summary>
     ///   Get formatted value
     /// </summary>
@@ -39885,6 +40174,9 @@ class MagicBridge {
     static UploadFileToServer(fileContent, serverFileName) {
         return ClientManager.UploadFileToServer(fileContent, serverFileName);
     }
+    static async DownloadFileFromServer(serverFileName) {
+        return await ClientManager.DownloadFileFromServer(serverFileName);
+    }
     static GetFormattedValue(taskId, controlName, value, rowId) {
         return ClientManager.GetFormattedValue(taskId, controlName, value, rowId);
     }
@@ -39951,5 +40243,5 @@ class DataSourceIdKey {
  * Generated bundle index. Do not edit.
  */
 
-export { AbortCommand, AccessHelper, ActionManager, AddLocateCommand, AddRangeCommand, AddSortCommand, AddUserLocateDataViewCommand, AddUserLocateRemoteDataViewCommand, AddUserRangeDataviewCommand, AddUserRangeRemoteDataViewCommand, AddUserSortDataViewCommand, AddUserSortRemoteDataViewCommand, Argument, ArgumentsList, Boundary, BrowserEscEventCommand, ClearEventsOnStopExecution, ClientManager, ClientOriginatedCommand, ClientOriginatedCommandSerializer, ClientOriginatedCommandTaskTag, ClientRefreshCommand, ClientTargetedCommandBase, ClientTargetedCommandType, ColumnSortEventCommand, CommandFactory, CommandSerializationHelper, CommandsProcessorBase, CommandsProcessorBase_SendingInstruction, CommandsProcessorBase_SessionStage, CommandsProcessorManager, CommandsTable, CompMainPrgTable, ComputeEventCommand, ConstInterface, ConstUtils, ContextTerminationEventCommand, ContextTimeoutResetCommand, ControlItemsRefreshCommand, CookieService, CreatedFormVector, CurrentClientVersion, DataSourceIdKey, DataView, DataViewBase, DataViewCommandBase, DataViewCommandType, DataViewOutputCommand, DataviewCommand, DataviewHeaderBase, DataviewHeaderFactory, DataviewHeaders, DataviewHeadersSaxHandler, DataviewManager, DataviewManagerBase, DcValuesReference, DummyDataViewCommand, DvCache, EnhancedVerifyCommand, EnvParamsTable, Environment, EnvironmentDetails, EvaluateCommand, Event, EventCommand, EventHandler, EventHandlerPosition, EventSubType, EventsAllowedType, EventsManager, ExecOperCommand, ExecutionStack, ExecutionStackEntry, ExpDesc, ExpStrTracker, ExpTable, Expression, ExpressionDict, ExpressionEvaluator, ExpressionLocalJpn, Expression_ReturnValue, FetchDataControlValuesEventCommand, Field, FieldBase, FieldsTable as FieldsTableExt, FlowMonitorInterface, FlowMonitorQueue, FormsTable, GUIManager, GlobalCommandsManager, GlobalParams, GlobalParamsQueryCommand, GuiEventsProcessor, HandlersTable, HeapSort, HttpClientAsync, HttpClientBase, HttpClientEvents, HttpClientSync, HttpManager, HttpUtility, IClientTargetedCommand, IndexChangeEventCommand, IniputForceWriteCommand, InteractiveCommunicationsFailureHandler, Key, LanguageData, LastFocusedManager, MGData, MGDataCollection, MagicBridge, MgControl, MgForm, MgPriorityBlockingQueue, MgPriorityQueue, MirrorExpVal, MirrorPrmMap, MirrorString, NonReversibleExitEventCommand, NullValueException, OpenURLCommand, OpeningTaskDetails, Operation, OperationTable, ParamParseResult, PrmMap, QueryCommand, RCTimer, Recompute, RecomputeCommand, RecomputeTable, Recompute_RcmpBy, Record, RecordOutOfDataViewException, RecordOutOfDataViewException_ExceptionType, RecordsTable, RefreshEventCommand, RefreshScreenEventCommand, RemoteCommandsProcessor, RemoteControlItemsRefreshCommand, RemoteDataViewCommandBase, RemoteDataViewCommandFactory, RemoteDataViewCommandUpdateNonModifiable, RemoteDataviewHeader, RemoteDataviewManager, RemoteTaskService, RequestMethod, ResetLocateCommand, ResetRangeCommand, ResetSortCommand, ResetUserLocateRemoteDataviewCommand, ResetUserRangeRemoteDataviewCommand, ResetUserSortRemoteDataviewCommand, ResultCommand, ResultValue, RetVals, ReturnResult, ReturnResultBase, RollbackEventCommand, RollbackEventCommand_RollbackType, RunTimeEvent, RunTimeEventBase, SET_DISPLAYLINE_BY_DV, Scrambler, SelectProgramCommand, ServerConfig, ServerError, SetTransactionStateDataviewCommand, SetTransactionStateRemoteDataViewCommand, Sort, SortCollection, SubformOpenEventCommand, SubformRefreshEventCommand, TableCache, TableCacheManager, Task, TaskBase, TaskServiceBase, TaskTransactionManager, Task_Direction, Task_Flow, Task_SubformExecModeEnum, TasksTable, Transaction, TransactionCommand, UniqueIDUtils, UnloadCommand, UserDetails, UserEventsTable, UserRange, VerifyCommand, WriteMessageToServerLogCommand, XMLBasedCommandBuilder, XMLBasedDcValuesBuilder, YesNoExp, getGuiEventObj };
+export { AbortCommand, AccessHelper, ActionManager, AddLocateCommand, AddRangeCommand, AddSortCommand, AddUserLocateDataViewCommand, AddUserLocateRemoteDataViewCommand, AddUserRangeDataviewCommand, AddUserRangeRemoteDataViewCommand, AddUserSortDataViewCommand, AddUserSortRemoteDataViewCommand, Argument, ArgumentsList, Boundary, BrowserEscEventCommand, CachedFileQueryCommand, ClearEventsOnStopExecution, ClientManager, ClientOriginatedCommand, ClientOriginatedCommandSerializer, ClientOriginatedCommandTaskTag, ClientRefreshCommand, ClientTargetedCommandBase, ClientTargetedCommandType, ColumnSortEventCommand, CommandFactory, CommandSerializationHelper, CommandsProcessorBase, CommandsProcessorBase_SendingInstruction, CommandsProcessorBase_SessionStage, CommandsProcessorManager, CommandsTable, CompMainPrgTable, ComputeEventCommand, ConstInterface, ConstUtils, ContextTerminationEventCommand, ContextTimeoutResetCommand, ControlItemsRefreshCommand, CookieService, CreatedFormVector, CurrentClientVersion, DataSourceIdKey, DataView, DataViewBase, DataViewCommandBase, DataViewCommandType, DataViewOutputCommand, DataviewCommand, DataviewHeaderBase, DataviewHeaderFactory, DataviewHeaders, DataviewHeadersSaxHandler, DataviewManager, DataviewManagerBase, DcValuesReference, DummyDataViewCommand, DvCache, EnhancedVerifyCommand, EnvParamsTable, Environment, EnvironmentDetails, EvaluateCommand, Event, EventCommand, EventHandler, EventHandlerPosition, EventSubType, EventsAllowedType, EventsManager, ExecOperCommand, ExecutionStack, ExecutionStackEntry, ExpDesc, ExpStrTracker, ExpTable, Expression, ExpressionDict, ExpressionEvaluator, ExpressionLocalJpn, Expression_ReturnValue, FetchDataControlValuesEventCommand, Field, FieldBase, FieldsTable as FieldsTableExt, FlowMonitorInterface, FlowMonitorQueue, FormsTable, GUIManager, GlobalCommandsManager, GlobalParams, GlobalParamsQueryCommand, GuiEventsProcessor, HandlersTable, HeapSort, HttpClientAsync, HttpClientBase, HttpClientEvents, HttpClientSync, HttpManager, HttpUtility, IClientTargetedCommand, IndexChangeEventCommand, IniputForceWriteCommand, InteractiveCommunicationsFailureHandler, Key, LanguageData, LastFocusedManager, MGData, MGDataCollection, MagicBridge, MgControl, MgForm, MgPriorityBlockingQueue, MgPriorityQueue, MirrorExpVal, MirrorPrmMap, MirrorString, NonReversibleExitEventCommand, NullValueException, OpenURLCommand, OpeningTaskDetails, Operation, OperationTable, ParamParseResult, PrmMap, QueryCommand, RCTimer, Recompute, RecomputeCommand, RecomputeTable, Recompute_RcmpBy, Record, RecordOutOfDataViewException, RecordOutOfDataViewException_ExceptionType, RecordsTable, RefreshEventCommand, RefreshScreenEventCommand, RemoteCommandsProcessor, RemoteControlItemsRefreshCommand, RemoteDataViewCommandBase, RemoteDataViewCommandFactory, RemoteDataViewCommandUpdateNonModifiable, RemoteDataviewHeader, RemoteDataviewManager, RemoteTaskService, RequestMethod, ResetLocateCommand, ResetRangeCommand, ResetSortCommand, ResetUserLocateRemoteDataviewCommand, ResetUserRangeRemoteDataviewCommand, ResetUserSortRemoteDataviewCommand, ResultCommand, ResultValue, RetVals, ReturnResult, ReturnResultBase, RollbackEventCommand, RollbackEventCommand_RollbackType, RunTimeEvent, RunTimeEventBase, SET_DISPLAYLINE_BY_DV, Scrambler, SelectProgramCommand, ServerConfig, ServerError, SetTransactionStateDataviewCommand, SetTransactionStateRemoteDataViewCommand, Sort, SortCollection, SubformOpenEventCommand, SubformRefreshEventCommand, TableCache, TableCacheManager, Task, TaskBase, TaskServiceBase, TaskTransactionManager, Task_Direction, Task_Flow, Task_SubformExecModeEnum, TasksTable, Transaction, TransactionCommand, UniqueIDUtils, UnloadCommand, UserDetails, UserEventsTable, UserRange, VerifyCommand, WriteMessageToServerLogCommand, XMLBasedCommandBuilder, XMLBasedDcValuesBuilder, YesNoExp, getGuiEventObj };
 //# sourceMappingURL=magic-xpa-engine.mjs.map