@magic-xpa/utils 4.800.0-dev480.22 → 4.800.0-dev480.220

package/fesm2015/magic-xpa-utils.js

@@ -2,79 +2,28 @@ import { StringBuilder, Encoding, Hashtable, Stack, NChar, NNumber, NString, Ref
 import { isNullOrUndefined } from 'util';
 import { parseString } from 'xml2js';
 
-/// <summary>JPN: DBCS support
 class UtilStrByteMode {
-    /// <summary> Checks the environment whether it is running on DBCS environment
-    /// Returns true if the language code for the current default Locale is
-    /// DBCS language (in non-Unicode encoding).
-    ///
-    /// </summary>
-    /// <returns> true if DBCS, or false if SBCS
-    /// </returns>
     static isLocaleDefLangDBCS() {
         return UtilStrByteMode._bLocaleDefLangJPN || UtilStrByteMode._bLocaleDefLangCHN || UtilStrByteMode._bLocaleDefLangKOR;
     }
-    /// <summary> Checks whether the language code for the current default Locale
-    /// is JAPANESE.
-    ///
-    /// </summary>
-    /// <returns> true if JAPANESE, or false if not
-    /// </returns>
     static isLocaleDefLangJPN() {
         return UtilStrByteMode._bLocaleDefLangJPN;
     }
-    /// <summary> Checks whether the language code for the current default Locale
-    /// is KOREAN.
-    ///
-    /// </summary>
-    /// <returns> true if KOREAN, or false if not
-    /// </returns>
     static isLocaleDefLangKOR() {
         return UtilStrByteMode._bLocaleDefLangKOR;
     }
     static isKoreanCharacter(c) {
-        return (44032 <= /*'가'*/ c && c <= 55203 /*'힣'*/) || (4352 <= /*'ᄀ'*/ c && c <= 4607 /*'ᇿ'*/) || (12592 <= /*'㄰'*/ c && c <= 12687 /*'㆏'*/) || (43360 <= /*'ꥠ'*/ c && c <= 43391 /*'꥿'*/) || (55216 <= /*'ힰ'*/ c && c <= 55295 /*'퟿'*/);
-    }
-    /// <summary> Length of String
-    /// Returns the number of bytes (in default encoding).
-    ///
-    /// </summary>
-    /// <param name="strVal:">string (in Unicode)
-    /// </param>
-    /// <returns> the number of bytes (in default encoding)
-    ///
-    /// Example: lenB("abXYc")
-    /// Where 'a', 'b' and  'c' are SBCS, and 'X' and 'Y' are DBCS, it returns
-    /// 7.
-    /// </returns>
+        return (44032 <= c && c <= 55203) || (4352 <= c && c <= 4607) || (12592 <= c && c <= 12687) || (43360 <= c && c <= 43391) || (55216 <= c && c <= 55295);
+    }
     static lenB(strVal) {
-        // convert to byte[] by default-encoding
         return UtilStrByteMode.Encoding.GetByteCount(strVal);
     }
-    /// <summary> Substring of String
-    /// Extracts a specified number of characters (a substring) from a string.
-    /// If a DBCS character is divided in two, it will be replace to a space.
-    ///
-    /// </summary>
-    /// <param name="strVal:">string (in Unicode)
-    /// </param>
-    /// <param name="ofs:">starting position (byte) of the substring
-    /// </param>
-    /// <param name="len:">number of bytes to be extracted (i.e. bytes of substring)
-    /// </param>
-    /// <returns> substring
-    ///
-    /// Example: midB("abXYc", 2, 4)
-    /// Where 'a', 'b' and  'c' are SBCS, and 'X' and 'Y' are DBCS, it returns
-    /// "bX ".
-    /// </returns>
     static midB(strVal, ofs, len) {
-        let intValidMaxIndex = -1; // param #1 of substring
-        let intValidMinIndex = -1; // param #2 of substring
-        let bHeadSpace = false; // flag: need to add space
-        let bEndSpace = false; // flag: need to add space
+        let intValidMaxIndex = -1;
+        let intValidMinIndex = -1;
+        let bHeadSpace = false;
+        let bEndSpace = false;
         let strRet;
-        // check and modify ofs & len
         if (len <= 0)
             return "";
         if (ofs <= 0) {
@@ -88,7 +37,6 @@ class UtilStrByteMode {
         let LenMax = intByteLength - ofs;
         if (LenMax < len)
             len = LenMax;
-        // set MinIndex and MaxIndex for substring
         intByteLength = 0;
         for (let intIndex = 0; intIndex < strVal.length; intIndex = intIndex + 1) {
             let s = strVal.substr(intIndex, 1);
@@ -116,9 +64,7 @@ class UtilStrByteMode {
                 }
             }
         }
-        // prepare for substring
         let strbufAddingBuf = new StringBuilder(len);
-        // execute Mid
         if (bHeadSpace) {
             strbufAddingBuf.Append(' ');
         }
@@ -132,39 +78,9 @@ class UtilStrByteMode {
         strbufAddingBuf = null;
         return strRet;
     }
-    /// <summary> Get Characters from Left of String
-    /// Returns a specified number of bytes from the left side of a string.
-    /// If a DBCS character is divided in two, it will be replace to a space.
-    ///
-    /// </summary>
-    /// <param name="strVal:">string (in Unicode)
-    /// </param>
-    /// <param name="len:">number of bytes to be retured
-    /// </param>
-    /// <returns> output string
-    ///
-    /// Example: leftB("abXYc", 4)
-    /// Where 'a', 'b' and  'c' are SBCS, and 'X' and 'Y' are DBCS, it returns
-    /// "abX".
-    /// </returns>
     static leftB(strVal, len) {
         return UtilStrByteMode.midB(strVal, 0, len);
     }
-    /// <summary> Get Characters from Right of String
-    /// Returns a specified number of bytes from the right side of a string.
-    /// If a DBCS character is divided in two, it will be replace to a space.
-    ///
-    /// </summary>
-    /// <param name="strVal:">string (in Unicode)
-    /// </param>
-    /// <param name="len:">number of bytes to be retured
-    /// </param>
-    /// <returns> output string
-    ///
-    /// Example: rightB("abXYc", 4)
-    /// Where 'a', 'b' and  'c' are SBCS, and 'X' and 'Y' are DBCS, it returns
-    /// " Yc".
-    /// </returns>
     static rightB(strVal, len) {
         let byteFldsValLen = UtilStrByteMode.lenB(strVal);
         if (len < 0) {
@@ -176,27 +92,6 @@ class UtilStrByteMode {
         }
         return UtilStrByteMode.midB(strVal, ofs, len);
     }
-    /// <summary> Insert String
-    /// Inserts one string into another.
-    /// If a DBCS character is divided in two, it will be replace to a space.
-    ///
-    /// </summary>
-    /// <param name="strTarget:">A string that represents the target string.
-    /// </param>
-    /// <param name="strSource:">A string that represents the source string.
-    /// </param>
-    /// <param name="ofs:">A number that represents the starting position (byte) in
-    /// the target.
-    /// </param>
-    /// <param name="len:">A number that represents the number of bytes from the
-    /// source that will be inserted into the target.
-    /// </param>
-    /// <returns> output string
-    ///
-    /// Example: insB("abXYc", "de", 4, 1)
-    /// Where 'a', 'b', 'c', 'd' and 'e' are SBCS, and 'X' and 'Y' are DBCS,
-    /// it returns "ab d Yc".
-    /// </returns>
     static insB(strTarget, strSource, ofs, len) {
         if (ofs < 0) {
             ofs = 0;
@@ -223,24 +118,6 @@ class UtilStrByteMode {
         strbufRetVal.Append(UtilStrByteMode.rightB(strTarget, intTargetLenB - ofs));
         return strbufRetVal.ToString();
     }
-    /// <summary> Delete Characters
-    /// Delete characters from a string.
-    /// If a DBCS character is divided in two, it will be replace to a space.
-    ///
-    /// </summary>
-    /// <param name="strVal:">string (in Unicode)
-    /// </param>
-    /// <param name="ofs:">The position (byte) of the first character to be deleted.
-    /// </param>
-    /// <param name="len:">The number of characters to be deleted, beginning with
-    /// position start and proceeding rightward.
-    /// </param>
-    /// <returns> output string
-    ///
-    /// Example: delB("abXYc", 2, 4)
-    /// Where 'a', 'b' and  'c' are SBCS, and 'X' and 'Y' are DBCS, it returns
-    /// "a c".
-    /// </returns>
     static delB(strVal, ofs, len) {
         if (ofs < 0) {
             ofs = 0;
@@ -272,55 +149,16 @@ class UtilStrByteMode {
         }
         return strRet;
     }
-    /// <summary> In-String Search
-    /// Returns a number that represents the first position (byte) of a
-    /// substring within a string.
-    ///
-    /// </summary>
-    /// <param name="strTarget:">string (in Unicode)
-    /// </param>
-    /// <param name="strSearch:">string which will be the search argument in string
-    /// </param>
-    /// <returns> number, 0 if not found
-    ///
-    /// Example: instrB("abXYc", "Y")
-    /// Where 'a', 'b' and  'c' are SBCS, and 'X' and 'Y' are DBCS, it returns
-    /// 5.
-    /// </returns>
     static instrB(strTarget, strSearch) {
         if (strSearch.length === 0) {
-            // nothing to look for
             return 0;
         }
         let ofs = strTarget.indexOf(strSearch);
         if (ofs < 0) {
-            // not found
             return 0;
         }
         return UtilStrByteMode.lenB(strTarget.substr(0, ofs)) + 1;
     }
-    /// <summary> Replace Substring Within a String (Byte Mode)
-    /// Replaces a substring within a string with another substring.
-    /// If a DBCS character is divided in two, it will be replace to a space.
-    ///
-    /// </summary>
-    /// <param name="strTarget:">target string where the replacement will take place.
-    /// </param>
-    /// <param name="strOrigin:">string that provides the substring to be copied to
-    /// target.
-    /// </param>
-    /// <param name="ofs:">the first position (byte) in the target string that will
-    /// receive the substring from origin.
-    /// </param>
-    /// <param name="len:">the number of bytes that will be moved from origin to
-    /// target, starting from the leftmost character of origin.
-    /// </param>
-    /// <returns> string containing modified target string
-    ///
-    /// Example: repB("abXYc", "de", 4, 2)
-    /// Where 'a', 'b', 'c', 'd' and 'e' are SBCS, and 'X' and 'Y' are DBCS,
-    /// it returns "ab de c".
-    /// </returns>
     static repB(strTarget, strOrigin, ofs, len) {
         let strbufAddingBuf = new StringBuilder();
         if (ofs < 0) {
@@ -343,33 +181,12 @@ class UtilStrByteMode {
         if (intRightLen > 0) {
             strbufAddingBuf.Append(UtilStrByteMode.rightB(strTarget, intRightLen));
         }
-        // add blanks to the end
         intAddSpaceLen = len - UtilStrByteMode.lenB(strOrigin);
         for (; intAddSpaceLen > 0; intAddSpaceLen--) {
             strbufAddingBuf.Append(' ');
         }
         return strbufAddingBuf.ToString();
     }
-    /// <summary> Replace Substring Within a String (Character Mode)
-    /// Replaces a substring within a string with another substring.
-    ///
-    /// </summary>
-    /// <param name="strTarget:">target string where the replacement will take place.
-    /// </param>
-    /// <param name="strOrigin:">string that provides the substring to be copied to
-    /// target.
-    /// </param>
-    /// <param name="ofs:">the first position (character) in the target string that
-    /// will receive the substring from origin.
-    /// </param>
-    /// <param name="len:">the number of characters that will be moved from origin
-    /// to target, starting from the leftmost character of origin.
-    /// </param>
-    /// <returns> string containing modified target string
-    ///
-    /// Example: repB("abXYc", "de", 4, 2)
-    /// Whether each character is SBCS or DBCS, it returns "abXde".
-    /// </returns>
     static repC(strTarget, strOrigin, ofs, len) {
         let strbufAddingBuf = new StringBuilder();
         if (ofs < 0) {
@@ -384,7 +201,6 @@ class UtilStrByteMode {
             len = 0;
         }
         strbufAddingBuf.Append(strTarget.substr(0, ofs));
-        // add blanks between strTarget and strOrigin
         let intAddSpaceLen = ofs - strTarget.length;
         for (; intAddSpaceLen > 0; intAddSpaceLen--)
             strbufAddingBuf.Append(' ');
@@ -398,18 +214,9 @@ class UtilStrByteMode {
         }
         return strbufAddingBuf.ToString();
     }
-    /// <summary> Checks whether a character is 1 byte (halfwidth) or not (fullwidth)
-    /// Returns true if the character is represented by 1 byte in non-Unicode
-    /// encoding.
-    /// </summary>
-    /// <param name="letter:">a character to be checked.
-    /// </param>
-    /// <returns> true if the character is halfwidth (SBCS), or false if it is
-    /// fullwidth (DBCS).
-    /// </returns>
     static isHalfWidth(str) {
         let letter = str.charCodeAt(0);
-        if (32 <= /*' '*/ letter && letter <= 126 /*'~'*/) {
+        if (32 <= letter && letter <= 126) {
             return true;
         }
         else {
@@ -419,33 +226,18 @@ class UtilStrByteMode {
         }
         return false;
     }
-    /// <summary> Checks whether a character is halfwidth digit letter
-    /// Do not use "Character.isDigit" which cannot distinguish between
-    /// halfwidth digit letter(SBCS) and fullwidth difit letter(DBCS).
-    /// </summary>
-    /// <param name="letter:">a character to be checked.
-    /// </param>
-    /// <returns> true if the character is halfwidth digit letter, or
-    /// false if it is DBCS or not digit letter.
-    /// </returns>
     static isDigit(letter) {
-        return 48 <= /*'0'*/ letter.charCodeAt(0) && letter.charCodeAt(0) <= 57 /*'9'*/;
-    }
-    /// <summary>Checks whether a character is one of those supported for # Alpha Mask</summary>
-    /// <param name="letter:">a character to be checked.
-    /// </param>
-    /// <returns> true if the character is halfwidth digit letter, or
-    /// false if it is DBCS or not digit letter.
-    /// </returns>
+        return 48 <= letter.charCodeAt(0) && letter.charCodeAt(0) <= 57;
+    }
     static asNumeric(letter) {
         let result;
         switch (letter.charCodeAt(0)) {
-            case 42: /*'*'*/
-            case 43: /*'+'*/
-            case 44: /*','*/
-            case 45: /*'-'*/
-            case 46: /*'.'*/
-            case 47: /*'/'*/
+            case 42:
+            case 43:
+            case 44:
+            case 45:
+            case 46:
+            case 47:
                 result = true;
                 break;
             default:
@@ -454,47 +246,12 @@ class UtilStrByteMode {
         }
         return result;
     }
-    /// <summary> Converts a position for the 1st string (Source) to a position for
-    /// the 2nd string (Dest).
-    /// If a double byte character exists in the strings, the position for the
-    /// Source could be different from the position for the Dest.
-    /// (DBCS Support)
-    ///
-    /// </summary>
-    /// <param name="strSource:">Source string
-    /// </param>
-    /// <param name="strDest:">Dest string
-    /// </param>
-    /// <param name="pos:">position in the Source string
-    /// </param>
-    /// <param name="isAdvance:">advance or retreat the ret pos if a DBCS char is split
-    /// </param>
-    /// <returns> position in the Dest string
-    ///
-    /// Example: convPos("abcYZ", "YZabc", 4)
-    /// It returns 4, if the all characters in the strings are SBCS.
-    ///
-    /// If 'a', 'b' and 'c' are SBCS, and 'Y' and 'Z' are DBCS, it
-    /// returns 3.
-    /// pos
-    /// Unicode index  0 1 2  3  [4]
-    /// +-------------+
-    /// Source string |a|b|c| Y | Z |
-    /// +-------------+
-    /// ANSI index     0 1 2 3 4[5]6
-    /// +-------------+
-    /// Dest string   | Y | Z |a|b|c|
-    /// +-------------+
-    /// Unicode index   0   1  2[3]4
-    /// ret
-    /// </returns>
     static convPos(strSource, strDest, pos, isAdvance) {
         let retPos;
         if (pos < 0)
             return 0;
         if (pos > strSource.length)
             pos = strSource.length;
-        // add blanks to the Dest string if it is shorter than the Src string
         let diffLen = UtilStrByteMode.lenB(strSource) - UtilStrByteMode.lenB(strDest);
         if (diffLen > 0) {
             let stringBuilder = new StringBuilder(strDest);
@@ -505,23 +262,11 @@ class UtilStrByteMode {
         let byteSource = UtilStrByteMode.Encoding.GetBytes(strSource.substr(0, pos));
         let strLeftB = UtilStrByteMode.leftB(strDest, byteSource.length);
         retPos = strLeftB.length;
-        if (!isAdvance && retPos > 0 && strLeftB.charCodeAt(retPos - 1) === 32 /*' '*/ && strDest.charCodeAt(retPos - 1) !== 32 /*' '*/) {
+        if (!isAdvance && retPos > 0 && strLeftB.charCodeAt(retPos - 1) === 32 && strDest.charCodeAt(retPos - 1) !== 32) {
             retPos = retPos - 1;
         }
         return retPos;
     }
-    /// <summary> return the number of characters of picture which corresponds to
-    /// given string.
-    /// </summary>
-    /// <param name="str:">given string
-    /// </param>
-    /// <param name="picture:">picture
-    /// </param>
-    /// <returns> minimal length of picture
-    /// Example: getMinLenPicture("ZZ20/11/", "JJJJYY/MM/DD") [ZZ is DBCS]
-    /// It returns 10.
-    /// </returns>
-    /// (DBCS Support)
     static getMinLenPicture(str, picture) {
         let len = 0;
         if (UtilStrByteMode.lenB(picture) - UtilStrByteMode.lenB(str) > 0) {
@@ -531,18 +276,6 @@ class UtilStrByteMode {
             len = picture.length;
         return len;
     }
-    /// <summary>
-    /// </summary> Compares two specified strings in the DBCS sort order and returns an integer
-    /// that indicates their relative position.
-    /// <param name="str1:">The first string to compare.
-    /// </param>
-    /// <param name="str2:">The second string to compare.
-    /// </param>
-    /// <returns>an integer that indicates the lexical relationship between the two strings.
-    ///  -1: str1 is less than str2.
-    ///   0: str1 equals str2.
-    ///   1: str1 is greater than str2.
-    /// </returns>
     static strcmp(str1, str2) {
         let array1 = UtilStrByteMode.Encoding.GetBytes(str1);
         let array2 = UtilStrByteMode.Encoding.GetBytes(str2);
@@ -563,34 +296,24 @@ class UtilStrByteMode {
     }
 }
 UtilStrByteMode.Encoding = Encoding.UTF8;
-// TODO : need to check what to do with CultureInfo
 UtilStrByteMode.strNavigatorLang = window.navigator.language;
 UtilStrByteMode._bLocaleDefLangJPN = UtilStrByteMode.strNavigatorLang.startsWith('ja');
 UtilStrByteMode._bLocaleDefLangCHN = UtilStrByteMode.strNavigatorLang.startsWith('zh');
 UtilStrByteMode._bLocaleDefLangKOR = UtilStrByteMode.strNavigatorLang.startsWith('ko');
 
-//@dynamic
 class Rtf_SYMBOL {
-    /* index into property table if kwd == kwdProp */
-    /* index into destination table if kwd == kwdDest  */
-    /* character to print if kwd == kwdChar            */
     constructor(keyWord, kwd, idxInRgprop) {
         this.szKeyword = null;
-        /* RTF keyword */
         this.kwd = null;
-        /* base action to take */
         this.idxInRgprop = null;
         this.szKeyword = keyWord;
         this.kwd = kwd;
         this.idxInRgprop = idxInRgprop;
     }
 }
-// @dynamic
 class Rtf_PROP {
-    /* structure containing value */
     constructor(actn, prop) {
         this.actn = null;
-        /* size of value */
         this.prop = null;
         this.actn = actn;
         this.prop = prop;
@@ -639,7 +362,6 @@ var Rtf_IDEST;
     Rtf_IDEST[Rtf_IDEST["COLOR"] = 1] = "COLOR";
     Rtf_IDEST[Rtf_IDEST["SKIP"] = 2] = "SKIP";
 })(Rtf_IDEST || (Rtf_IDEST = {}));
-/* types of properties */
 var Rtf_IPROP;
 (function (Rtf_IPROP) {
     Rtf_IPROP[Rtf_IPROP["BOLD"] = 0] = "BOLD";
@@ -676,7 +398,6 @@ var Rtf_IPROP;
     Rtf_IPROP[Rtf_IPROP["XA_BULLET"] = 31] = "XA_BULLET";
     Rtf_IPROP[Rtf_IPROP["MAX"] = 32] = "MAX";
 })(Rtf_IPROP || (Rtf_IPROP = {}));
-/* Rtf Destination State */
 var Rtf_RDS;
 (function (Rtf_RDS) {
     Rtf_RDS[Rtf_RDS["NORM"] = 0] = "NORM";
@@ -696,15 +417,6 @@ var Rtf_ErrorRtf;
     Rtf_ErrorRtf[Rtf_ErrorRtf["END_OF_FILE"] = 7] = "END_OF_FILE";
     Rtf_ErrorRtf[Rtf_ErrorRtf["BUFFER_TOO_SMALL"] = 8] = "BUFFER_TOO_SMALL";
 })(Rtf_ErrorRtf || (Rtf_ErrorRtf = {}));
-// TODO :
-// Rtf_RtfChar should actually be enum.
-// But computed string values are not allowed to be defined in enum.
-// So, we cannot have String.fromCharCode(XXX).
-// We have 2 options:
-// 1. Convert this enum into a class with all static readonly items.
-// 2. Keep it as enum with numeric values (char codes).
-// Going with #1 now, since @2 makes the code ugly.
-// Will evalaute later if required.
 class Rtf_RtfChar {
 }
 Rtf_RtfChar.CR = String.fromCharCode(0x0d);
@@ -727,8 +439,6 @@ var Rtf_RIS;
     Rtf_RIS[Rtf_RIS["UNICODE"] = 3] = "UNICODE";
 })(Rtf_RIS || (Rtf_RIS = {}));
 class Rtf {
-    /// <summary> Constructor
-    /// </summary>
     constructor() {
         this._group = 0;
         this._cbBin = 0;
@@ -757,13 +467,6 @@ class Rtf {
             this.setCodePageTable();
         }
     }
-    /// <summary> Checks if the blob has a Rtf data or not
-    ///
-    /// </summary>
-    /// <param name="str">
-    /// </param>
-    /// <returns>
-    /// </returns>
     static isRtf(str) {
         let isRtf = false;
         if (str !== null && str.startsWith(this.RTF_PREFIX)) {
@@ -771,17 +474,6 @@ class Rtf {
         }
         return isRtf;
     }
-    /// <summary> Converts Rtf Text to Plain Text
-    /// Step 1: Isolate RTF keywords and send them to ParseKeyword; Push and pop state at the start and end of
-    /// RTF groups Send text to ParseChar for further processing.
-    ///
-    /// </summary>
-    /// <param name="rtfTxt">
-    /// </param>
-    /// <param name="outputTxt">
-    /// </param>
-    /// <returns>
-    /// </returns>
     toTxt(rtfTxt, outputTxt) {
         let cNibble = 2;
         let b = 0;
@@ -807,7 +499,6 @@ class Rtf {
             this._index++;
             if (this._group < 0)
                 return Rtf_ErrorRtf.STACK_UNDERFLOW;
-            /* if we're parsing binary data, handle it directly */
             if (this._internalState === Rtf_RIS.BIN) {
                 if ((ec = this.ParseChar(blobChar, outputTxt)) !== Rtf_ErrorRtf.OK)
                     return ec;
@@ -830,22 +521,16 @@ class Rtf {
                             return ec;
                         break;
                     case Rtf_RtfChar.LF:
-                    case Rtf_RtfChar.CR: /* cr and lf are noise characters... */
+                    case Rtf_RtfChar.CR:
                         if (this._processCrlfSpecial) {
-                            /* Once we reach the 0x0a while ProcessCRLFSpecial_, reset the ProcessCRLFSpecial_ */
                             if (blobChar === Rtf_RtfChar.LF) {
                                 this._processCrlfSpecial = false;
                             }
                         }
                         else {
-                            /*---------------------------------------------------------------*/
-                            /* skip new lines coming only from the RTF header 1/1/98 - #2390 */
-                            /*---------------------------------------------------------------*/
-                            /* Skip the LF (0x0a) if we are not in the ProcessCRLFSpecial_ */
                             if (blobChar === Rtf_RtfChar.LF || (blobChar === Rtf_RtfChar.CR && skipNewline && !this._outputOnce))
                                 break;
                         }
-                    /* falls through */
                     default:
                         if (blobChar !== Rtf_RtfChar.CR)
                             skipNewline = false;
@@ -859,7 +544,6 @@ class Rtf {
                             this._internalState = Rtf_RIS.NORM;
                         }
                         else {
-                            /* parsing hex data */
                             if (this._internalState !== Rtf_RIS.HEX)
                                 return Rtf_ErrorRtf.ASSERTION;
                             b = b << 4;
@@ -881,22 +565,18 @@ class Rtf {
                             if (cNibble === 0) {
                                 if (UtilStrByteMode.isLocaleDefLangDBCS()) {
                                     charset = this.getCharset(this._fontNum);
-                                    // leading byte of a double-byte character
                                     if (!skipParseChar && Rtf.is1stByte(b, charset)) {
                                         dbcsBytes[0] = b;
                                         dbcsBytes[1] = 0;
                                         skipParseChar = true;
                                     }
                                     else {
-                                        // trailing byte of a double-byte character
                                         if (skipParseChar && Rtf.is2ndByte(b, charset))
                                             dbcsBytes[1] = b;
-                                        // single-byte character
                                         else {
                                             dbcsBytes[0] = b;
                                             dbcsBytes[1] = 0;
                                         }
-                                        // convert DBCS to Unicode
                                         codePage = this.getCodePage(charset);
                                         let workStr = Encoding.GetEncoding(codePage).GetString(dbcsBytes, 0, 2);
                                         b = workStr.charCodeAt(0);
@@ -912,36 +592,19 @@ class Rtf {
                                 this._internalState = Rtf_RIS.NORM;
                             }
                         }
-                        /* end else (ris != risNorm) */
                         break;
                 }
-                /* switch */
             }
-            /* else (ris != risBin) */
         }
-        /* while */
         if (this._group < 0)
             return Rtf_ErrorRtf.STACK_UNDERFLOW;
         if (this._group > 0)
             return Rtf_ErrorRtf.UNMATCHED_BRACE;
-        /*-------------------------------------------------------------------*/
-        /* Eliminate suffix of carrige return + line feed                    */
-        /* (Check last characters - just in case format is not the expected) */
-        /*-------------------------------------------------------------------*/
         currPos = outputTxt.Length;
         if (currPos >= 3 && (outputTxt.get_Item(currPos - 3) === Rtf_RtfChar.CR && outputTxt.get_Item(currPos - 2) === Rtf_RtfChar.LF && outputTxt.get_Item(currPos - 1) === Rtf_RtfChar.CR || outputTxt.get_Item(currPos - 3) === Rtf_RtfChar.LF && outputTxt.get_Item(currPos - 2) === Rtf_RtfChar.CR && outputTxt.get_Item(currPos - 1) === Rtf_RtfChar.CR))
             outputTxt.Remove(currPos - 3, 3);
         return Rtf_ErrorRtf.OK;
     }
-    /// <summary> Route the character to the appropriate destination stream.
-    ///
-    /// </summary>
-    /// <param name="ch">
-    /// </param>
-    /// <param name="outputTxt">
-    /// </param>
-    /// <returns>
-    /// </returns>
     ParseChar(ch, outputTxt) {
         let ret = Rtf_ErrorRtf.OK;
         if (this._internalState === Rtf_RIS.BIN && --this._cbBin <= 0) {
@@ -949,28 +612,14 @@ class Rtf {
         }
         if (this._destState === Rtf_RDS.SKIP) {
         }
-        /* Toss this character. */
         else if (this._destState === Rtf_RDS.NORM) {
-            /* Output a character. Properties are valid at this point. */
             ret = this.PrintChar(ch, outputTxt);
         }
         else {
-            /* handle other destinations.... */
         }
         return ret;
     }
-    /// <summary> Send a character to the output file.
-    ///
-    /// </summary>
-    /// <param name="ch">
-    /// </param>
-    /// <param name="outputTxt">
-    /// </param>
-    /// <returns>
-    /// </returns>
     PrintChar(ch, outputTxt) {
-        /* Allow carrige return + line feed in text, but remove bullet sign */
-        /*------------------------------------------------------------------*/
         if ((ch >= ' ' || ch === Rtf_RtfChar.CR || ch === Rtf_RtfChar.LF) && ch !== String.fromCharCode(183)) {
             outputTxt.Append(ch);
         }
@@ -979,11 +628,6 @@ class Rtf {
         }
         return Rtf_ErrorRtf.OK;
     }
-    /// <summary> Save relevant info on a linked list of SAVE structures.
-    ///
-    /// </summary>
-    /// <returns>
-    /// </returns>
     PushState() {
         let stackSave = new Rtf_StackSave();
         if (stackSave === null) {
@@ -996,11 +640,6 @@ class Rtf {
         this._group++;
         return Rtf_ErrorRtf.OK;
     }
-    /// <summary> Always restore relevant info from the top of the SAVE list.
-    ///
-    /// </summary>
-    /// <returns>
-    /// </returns>
     PopState() {
         let savedPop = this._stack.pop();
         if (savedPop === null) {
@@ -1011,15 +650,6 @@ class Rtf {
         this._group--;
         return Rtf_ErrorRtf.OK;
     }
-    /// <summary> Step 2: get a control word (and its associated value) and call TranslateKeyword to dispatch the control.
-    ///
-    /// </summary>
-    /// <param name="rtfTxt">
-    /// </param>
-    /// <param name="outputTxt">
-    /// </param>
-    /// <returns>
-    /// </returns>
     ParseKeyword(rtfTxt, outputTxt) {
         let ch;
         let fNeg = false;
@@ -1028,7 +658,6 @@ class Rtf {
         if ((ch = rtfTxt[this._index++]) === String.fromCharCode(0)) {
             return Rtf_ErrorRtf.END_OF_FILE;
         }
-        /* a control symbol; no delimiter. */
         if (!NChar.IsLetter(ch)) {
             szKeyword = szKeyword + ch;
             return this.TranslateKeyword(szKeyword, outputTxt);
@@ -1050,13 +679,6 @@ class Rtf {
         if (ch !== ' ')
             this._index--;
         if (szKeyword === Rtf.CHAR_PAR) {
-            /* if we get a RTF sequence of \par[0xd][0xa], ie a \par kwd followed   */
-            /* immidiately by the CR and LF, then ignore the \par kwd. otherwise    */
-            /* we will translate the \par - which translates to a LF (0xa) and also */
-            /* the following 0x0d is translated to 0x0a, thus resulting in TWO LF's */
-            /* being inserted instead of just one LF. So by skipping [\par] and     */
-            /* translating only the [0xd 0xa] will result in only one LF appearing  */
-            /* - which is the desired behaviour                                     */
             if (rtfTxt[this._index] === Rtf_RtfChar.CR && rtfTxt[this._index + 1] === Rtf_RtfChar.LF)
                 this._processCrlfSpecial = true;
         }
@@ -1067,37 +689,22 @@ class Rtf {
             return this.TranslateKeyword(szKeyword, outputTxt);
         }
     }
-    /// <summary> Step 3. Search rgsymRtf for szKeyword and evaluate it appropriately.
-    ///
-    /// </summary>
-    /// <param name="szKeyword">
-    /// </param>
-    /// <param name="outputTxt">
-    /// </param>
-    /// <returns>
-    /// </returns>
     TranslateKeyword(szKeyword, outputTxt) {
         let result = Rtf_ErrorRtf.OK;
         let isym;
-        /* search for szKeyword in rgsymRtf */
         for (isym = 0; isym < Rtf.rgsymRtf.length; isym++) {
             if (szKeyword === Rtf.rgsymRtf[isym].szKeyword) {
                 break;
             }
         }
-        /* control word not found */
         if (isym === Rtf.rgsymRtf.length) {
             if (this._skipDestIfUnk) {
-                /* if this is a new destination */
                 this._destState = Rtf_RDS.SKIP;
-                /* skip the destination */
             }
-            /* else just discard it */
             this._skipDestIfUnk = false;
         }
         else {
             result = Rtf_ErrorRtf.BAD_TABLE;
-            /* found it! use kwd and idxInRgprop to determine what to do with it. */
             this._skipDestIfUnk = false;
             if (Rtf.rgsymRtf[isym].kwd === Rtf_KWD.PROP) {
                 result = this.validateProp(Rtf.rgsymRtf[isym].idxInRgprop);
@@ -1114,21 +721,11 @@ class Rtf {
         }
         return result;
     }
-    /// <summary> Validate the property identified by _iprop_ to the value _val_.
-    /// previously called Applypropchange
-    /// </summary>
-    /// <param name="iprop">
-    /// </param>
-    /// <returns>
-    /// </returns>
     validateProp(iprop) {
         let ret = Rtf_ErrorRtf.OK;
         if (this._destState === Rtf_RDS.SKIP) {
-            /* If we're skipping text, */
             return ret;
-            /* don't do anything. */
         }
-        /* validate prop */
         if (Rtf.rgprop[iprop].prop !== Rtf_PROPTYPE.DOP && Rtf.rgprop[iprop].prop !== Rtf_PROPTYPE.SEP &&
             Rtf.rgprop[iprop].prop !== Rtf_PROPTYPE.PAP && Rtf.rgprop[iprop].prop !== Rtf_PROPTYPE.CHP &&
             Rtf.rgprop[iprop].actn !== Rtf_ACTN.SPEC) {
@@ -1139,35 +736,18 @@ class Rtf {
         }
         return ret;
     }
-    /// <summary> Change to the destination state.
-    /// previously called ChangeDest
-    /// </summary>
-    /// <returns>
-    /// </returns>
     changeDestState() {
         if (this._destState === Rtf_RDS.SKIP) {
-            /* if we're skipping text, */
             return Rtf_ErrorRtf.OK;
-            /* don't do anything */
         }
         this._destState = Rtf_RDS.SKIP;
-        /* when in doubt, skip it... */
         return Rtf_ErrorRtf.OK;
     }
-    /// <summary> Evaluate an RTF control that needs special processing.
-    ///
-    /// </summary>
-    /// <param name="ipfn">
-    /// </param>
-    /// <returns>
-    /// </returns>
     ParseSpecialKeyword(ipfn) {
         let ret = Rtf_ErrorRtf.OK;
         if (!UtilStrByteMode.isLocaleDefLangDBCS()) {
             if (this._destState === Rtf_RDS.SKIP && ipfn !== Rtf_IPFN.BIN) {
-                /* if we're skipping, and it's not */
                 return ret;
-                /* the \bin keyword, ignore it. */
             }
             if (ipfn === Rtf_IPFN.FONT || ipfn === Rtf_IPFN.CHARSET || ipfn === Rtf_IPFN.UNICODE) {
                 return ret;
@@ -1221,15 +801,6 @@ class Rtf {
         }
         return ret;
     }
-    /// <summary> Checks if the byte is within the trailing byte range.
-    ///
-    /// </summary>
-    /// <param name="dbcsBytes">
-    /// </param>
-    /// <param name="charset">
-    /// </param>
-    /// <returns>
-    /// </returns>
     static is2ndByte(dbcsBytes, charset) {
         let ret = false;
         if (dbcsBytes > 255)
@@ -1248,35 +819,21 @@ class Rtf {
         }
         return ret;
     }
-    /// <summary> Create a hashtable of codepage associated with charset.
-    ///
-    /// </summary>
-    /// <param>
-    /// <returns>
-    /// </returns>
     setCodePageTable() {
-        // add elements with key (charset) and value (codepage) into the table.
-        this._codePageTable.set_Item(0, 1252); // ANSI_CHARSET
-        this._codePageTable.set_Item(128, 932); // SHIFTJIS_CHARSET
-        this._codePageTable.set_Item(129, 949); // HANGUL_CHARSET
-        this._codePageTable.set_Item(134, 936); // GB2312_CHARSET
-        this._codePageTable.set_Item(136, 950); // CHINESEBIG5_CHARSET
-        this._codePageTable.set_Item(161, 1253); // GREEK_CHARSET
-        this._codePageTable.set_Item(162, 1254); // TURKISH_CHARSET
-        this._codePageTable.set_Item(177, 1255); // HEBREW_CHARSET
-        this._codePageTable.set_Item(178, 1256); // ARABIC _CHARSET
-        this._codePageTable.set_Item(186, 1257); // BALTIC_CHARSET
-        this._codePageTable.set_Item(204, 1251); // RUSSIAN_CHARSET
-        this._codePageTable.set_Item(222, 874); // THAI_CHARSET
-        this._codePageTable.set_Item(238, 1250); // EASTEUROPE_CHARSET
-    }
-    /// <summary> Get codepage corresponding to the specified charset.
-    ///
-    /// </summary>
-    /// <param name="charset">
-    /// </param>
-    /// <returns>
-    /// </returns>
+        this._codePageTable.set_Item(0, 1252);
+        this._codePageTable.set_Item(128, 932);
+        this._codePageTable.set_Item(129, 949);
+        this._codePageTable.set_Item(134, 936);
+        this._codePageTable.set_Item(136, 950);
+        this._codePageTable.set_Item(161, 1253);
+        this._codePageTable.set_Item(162, 1254);
+        this._codePageTable.set_Item(177, 1255);
+        this._codePageTable.set_Item(178, 1256);
+        this._codePageTable.set_Item(186, 1257);
+        this._codePageTable.set_Item(204, 1251);
+        this._codePageTable.set_Item(222, 874);
+        this._codePageTable.set_Item(238, 1250);
+    }
     getCodePage(charset) {
         let codePage = 0;
         if (this._codePageTable.ContainsKey(charset)) {
@@ -1284,13 +841,6 @@ class Rtf {
         }
         return codePage;
     }
-    /// <summary> Get charset corresponding to the specified font index.
-    ///
-    /// </summary>
-    /// <param name="font">
-    /// </param>
-    /// <returns>
-    /// </returns>
     getCharset(font) {
         let charset = 0;
         if (this._charsetTable.ContainsKey(font)) {
@@ -1301,7 +851,6 @@ class Rtf {
 }
 Rtf.RTF_PREFIX = "{\\rtf";
 Rtf.CHAR_PAR = "par";
-/* Property descriptions */
 Rtf.rgprop = [
     new Rtf_PROP(Rtf_ACTN.BYTE, Rtf_PROPTYPE.CHP), new Rtf_PROP(Rtf_ACTN.BYTE, Rtf_PROPTYPE.CHP),
     new Rtf_PROP(Rtf_ACTN.BYTE, Rtf_PROPTYPE.CHP), new Rtf_PROP(Rtf_ACTN.BYTE, Rtf_PROPTYPE.CHP),
@@ -1319,7 +868,6 @@ Rtf.rgprop = [
     new Rtf_PROP(Rtf_ACTN.BYTE, Rtf_PROPTYPE.PAP), new Rtf_PROP(Rtf_ACTN.SPEC, Rtf_PROPTYPE.PAP),
     new Rtf_PROP(Rtf_ACTN.SPEC, Rtf_PROPTYPE.CHP), new Rtf_PROP(Rtf_ACTN.SPEC, Rtf_PROPTYPE.SEP)
 ];
-/* Keyword descriptions */
 Rtf.rgsymRtf = [
     new Rtf_SYMBOL("b", Rtf_KWD.PROP, Rtf_IPROP.BOLD), new Rtf_SYMBOL("ul", Rtf_KWD.PROP, Rtf_IPROP.UNDERLINE),
     new Rtf_SYMBOL("i", Rtf_KWD.PROP, Rtf_IPROP.ITALIC), new Rtf_SYMBOL("li", Rtf_KWD.PROP, Rtf_IPROP.LEFT_IND),
@@ -1377,7 +925,6 @@ const HTML_2_STR = 3;
 const HTML_2_SEQ = 4;
 const SEQ_2_STR = 5;
 class StrUtil {
-    /// <summary> trim the end of the string</summary>
     static mem_trim(str, len) {
         let result;
         if (len > 0) {
@@ -1412,15 +959,6 @@ class StrUtil {
         }
         StrUtil.memcpy_1(dest, destCount, src, scrCountOrSrcCount, count);
     }
-    /// <summary>
-    ///   copy part of string into another string, like memcpy of C, but 4 string only
-    /// </summary>
-    /// <param name = "dest">string</param>
-    /// <param name = "destCount">of counter start from in destignation string</param>
-    /// <param name = "src">string</param>
-    /// <param name = "scrCount">of counter start from in source string</param>
-    /// <param name = "count"></param>
-    /// <returns> new value of destignation string</returns>
     static memcpy_0(dest, destCount, src, scrCount, count) {
         let stringBuilder = new StringBuilder(dest.substr(0, destCount));
         if (scrCount + count < src.length) {
@@ -1447,14 +985,6 @@ class StrUtil {
         }
         StrUtil.memset_1(dest, destCount, inVal, counter);
     }
-    /// <summary>
-    ///   insert to string chars n times
-    /// </summary>
-    /// <param name = "dest">string</param>
-    /// <param name = "destCount">of counter start from in destignation string to start insertion of char from</param>
-    /// <param name = "inVal">2 insert</param>
-    /// <param name = "counter">- number of times to insert the char</param>
-    /// <returns> new value of destignation string</returns>
     static memset_0(dest, destCount, inVal, counter) {
         let first = new StringBuilder(dest.substr(0, destCount));
         while (counter > 0) {
@@ -1483,29 +1013,14 @@ class StrUtil {
         }
         return result;
     }
-    /*******************************/
-    /// <summary>
-    /// Reverses string values.
-    /// </summary>
-    /// <param name="text">The StringBuilder object containing the string to be reversed.</param>
-    /// <returns>The reversed string contained in a StringBuilder object.</returns>
     static ReverseString(text) {
-        // TODO: use string.Reverse()
         let array = NString.ToCharArray(text.ToString());
         array.reverse();
         return new StringBuilder(NString.FromChars(array));
     }
-    /// <summary> remove spaces from the right side of string</summary>
-    /// <param name="str">the string to trim
-    /// </param>
     static rtrim(str) {
         return StrUtil.rtrimWithNull(str, false);
     }
-    /// <summary> remove spaces and/or Null chars from the right side of string</summary>
-    /// <param name="str">the string to trim
-    /// </param>
-    /// <param name="trimNullChars">Whether to remove NULL characters or not
-    /// </param>
     static rtrimWithNull(str, trimNullChars) {
         let result;
         if (typeof str === "undefined" || str === null || str.length === 0) {
@@ -1514,7 +1029,7 @@ class StrUtil {
         else {
             let idx = str.length - 1;
             if (trimNullChars) {
-                while (idx >= 0 && (str[idx] === ' ' || str[idx] === String.fromCharCode(0) /*''*/)) {
+                while (idx >= 0 && (str[idx] === ' ' || str[idx] === String.fromCharCode(0))) {
                     idx = idx - 1;
                 }
             }
@@ -1533,9 +1048,6 @@ class StrUtil {
         }
         return result;
     }
-    /// <summary> remove spaces from the left side of string</summary>
-    /// <param name="str">the string to trim
-    /// </param>
     static ltrim(str) {
         let length = str.length;
         let i = 0;
@@ -1544,7 +1056,7 @@ class StrUtil {
             result = str;
         }
         else {
-            while (i < length && str[i] === ' ' /*' '*/) {
+            while (i < length && str[i] === ' ') {
                 i = i + 1;
             }
             if (i > 0) {
@@ -1554,16 +1066,6 @@ class StrUtil {
         }
         return result;
     }
-    /// <summary>This function for Deleting String from end & start of input
-    /// String
-    /// </summary>
-    /// <param name="str">String , which can include strToDelete spaces on input
-    /// </param>
-    /// <param name="strToDelete">need delete this String from start/end of str.
-    /// </param>
-    /// <returns> String without strToDelete on end & start,
-    /// or 'null' if Sting hasn't not  characters inside
-    /// </returns>
     static DeleteStringsFromEnds(str, strToDelete) {
         if (str.startsWith(strToDelete)) {
             str = str.substr(strToDelete.length);
@@ -1580,11 +1082,6 @@ class StrUtil {
         }
         return result;
     }
-    /// <summary> pad a string with trailing spaces up to the given length</summary>
-    /// <param name="str">the string to pad
-    /// </param>
-    /// <param name="len">the expected length after padding
-    /// </param>
     static padStr(str, len) {
         let padLen = len - str.length;
         if (padLen > 0) {
@@ -1598,67 +1095,9 @@ class StrUtil {
         }
         return str;
     }
-    /// <summary> this method will serve as a string tokenizer instead of using the c# split method
-    /// since there are diffrences btween java tokenizer and c# split
-    /// the implimentation given by the conversion tool is not Sufficient
-    /// </summary>
-    /// <param name="source">- the source string to be converted
-    /// </param>
-    /// <param name="delim">- the string of delimiters used to split the string (each character in the String is a delimiter
-    /// </param>
-    /// <returns> array of token according which is the same as string tokenizer in java
-    /// </returns>
     static tokenize(source, delim) {
-        // It is mentioned in the comment that we should not use String.Split()
-        // because its behavior is different than Java's tokenizer.
-        // So, we were suppose to use our own implementation (the commented code below).
-        // But all these years, we were calling XmlParser.getToken() which was actually
-        // using String.Split(). And we didn't face any problem.
-        // So, it seems that we do not have problem in using String.Split().
-        // But now, we can improve the performance here...
-        // XmlParser.getTokens() was getting a String[] using String.Split().
-        // It was then creating a List<String> from this String[] and was returning it to
-        // tokenize().
-        // tokenize() was again converting this List<String> back to String[].
-        // So why not call String.Split() directly?
         return source.split(delim);
-        /*
-    String [] tokens = null;
-    
-    char [] delimArry = delim.toCharArray();
-    
-    //since java discards delimiters from the start and end of the string and c# does not
-    //we need to remove them manually
-    //       source = source.TrimEnd(delimArry);
-    //     source = source.TrimStart(delimArry);
-    source = source.trim();
-    
-    //now that we have remove starting and ending delimiters we can split
-    tokens = source.Split(delimArry);
-    
-    /*
-    * only one problem: if we have two Subsequent delimiters for example :
-    * the delimiter is ';' and the string is: "first;;second;third"
-    * then in java String tokenizer will give us only 3 tokens :first,second and third
-    * while is c# split wethod will return 4 tokens: first,empty string,second and third
-    * we need to deal with that
-    */
-        /*
-        List res  = new List();
-        for (int i = 0 ; i < tokens.length; i++)
-        {
-        if (tokens[i] != "" )
-        res.addItem(tokens[i]);
-        }
-    
-        return (String [])(res.getAllItems (String.class));*/
-    }
-    /// <summary>
-    ///   translate from string to hexa dump char by char
-    /// </summary>
-    /// <param name = "string">to translate it to the byte stream</param>
-    /// <param name = "minLength">the minimal length of hexa digits for each char</param>
-    /// <returns> the byte stream in form of string</returns>
+    }
     static stringToHexaDump(str, minLength) {
         let stringBuilder = new StringBuilder(str.length * minLength);
         for (let indx = 0; indx < str.length; indx = indx + 1) {
@@ -1677,11 +1116,6 @@ class StrUtil {
         }
         return StrUtil.searchAndReplace_1(str, from, to);
     }
-    /// <summary> replace every appearance of 'from' in 'str' with 'to'</summary>
-    /// <param name="str">the working base source string </param>
-    /// <param name="from">the string to replace </param>
-    /// <param name="to">the string use instead 'from' </param>
-    /// <returns> modified String </returns>
     static searchAndReplace_0(str, from, to) {
         let lastSubStr = 0;
         let startSubStr;
@@ -1702,11 +1136,6 @@ class StrUtil {
         }
         return result;
     }
-    /// <summary> replace every appearance of strings of 'from' in 'str' with the according string in 'to'</summary>
-    /// <param name="str">the working base source string </param>
-    /// <param name="from">the string to replace </param>
-    /// <param name="to">the string use instead 'from' </param>
-    /// <returns> modified String </returns>
     static searchAndReplace_1(str, from, to) {
         let lastSubStr = 0;
         let sarIndex = 0;
@@ -1731,14 +1160,6 @@ class StrUtil {
         result = tmpBuf.ToString();
         return result;
     }
-    /// <summary> this functions is for use by the searchAndReplace() function -
-    /// searches the offset of the strings from the array in the given string
-    /// and returns the minimum offset found and sets the index of the found string
-    /// to SARindex
-    /// </summary>
-    /// <param name="str">the string to search in </param>
-    /// <param name="strings">an array of strings to search for </param>
-    /// <param name="offset">where to start the search </param>
     static indexOf(str, strings, offset, SARindex) {
         let minOffset = -1;
         for (let i = 0; i < strings.length; i = i + 1) {
@@ -1766,15 +1187,6 @@ class StrUtil {
         }
         return result;
     }
-    /// <summary> replace tokens in user string by vector values </summary>
-    /// <param name="userString">- user buffer like "User %d, %d string"
-    /// </param>
-    /// <param name="token">- token used in user string - i.e. "%d"
-    /// </param>
-    /// <param name="occurrence">- number of token where replace will take part (1 for first occurrence)
-    /// </param>
-    /// <param name="value">- value to be inserted insted of token
-    /// </param>
     static replaceStringTokens(userString, token, occurrence, val) {
         let tokenLen = token.length;
         let currPosition = 0;
@@ -1797,12 +1209,6 @@ class StrUtil {
         }
         StrUtil.makePrintableTokens_1(source, type);
     }
-    /// <summary>
-    ///   converts special characters in a token to a printable format
-    /// </summary>
-    /// <param name = "source">a token </param>
-    /// <param name = "type">type of conversion: STR_2_HTML, SEQ_2_HTML, HTML_2_SEQ, HTML_2_STR, SEQ_2_STR </param>
-    /// <returns> token with converted special characters </returns>
     static makePrintableTokens_0(source, type) {
         let escStr = [
             "\\", "-", ","
@@ -1836,11 +1242,6 @@ class StrUtil {
         }
         return result;
     }
-    /// <summary>
-    ///   converts special characters in a tokens collection to a printable format
-    /// </summary>
-    /// <param name = "source">vector of strings before tokenaizer </param>
-    /// <param name = "type">type of conversion: STR_2_HTML, SEQ_2_HTML, HTML_2_SEQ, HTML_2_STR </param>
     static makePrintableTokens_1(source, type) {
         if (source !== null) {
             let length = source.length;
@@ -1850,12 +1251,6 @@ class StrUtil {
             }
         }
     }
-    /// <summary>
-    ///   change non-printable characters like "new line" and "line feed" to their
-    ///   printable representation
-    /// </summary>
-    /// <param name = "source">is the string with non-printable characters </param>
-    /// <returns> the new string where all the non-printable characters are converted </returns>
     static makePrintable(source) {
         let from = [
             "\n", "\r", "'", "\\", "\"", "\0"
@@ -1865,12 +1260,6 @@ class StrUtil {
         ];
         return StrUtil.searchAndReplace(source, from, to);
     }
-    /// <summary>
-    ///   change non-printable characters like "new line" and "line feed" to their
-    ///   printable representation (simplified version for range error message)
-    /// </summary>
-    /// <param name = "source">is the string with non-printable characters </param>
-    /// <returns> the new string where all the non-printable characters are converted </returns>
     static makePrintable2(source) {
         let from = [
             "\n", "\r", "\0"
@@ -1880,21 +1269,10 @@ class StrUtil {
         ];
         return StrUtil.searchAndReplace(source, from, to);
     }
-    /// <summary>
-    ///
-    /// </summary>
-    /// <param name="s"></param>
-    /// <param name="len"></param>
-    /// <returns></returns>
     static ZstringMake(s, len) {
         len = StrUtil.mem_trim(s, len);
         return s.substr(0, len);
     }
-    /// <summary>(public)
-    /// returns plain text from rtf text
-    /// </summary>
-    /// <param name="rtfText">refer to the summary</param>
-    /// <returns>refer to the summary</returns>
     static GetPlainTextfromRtf(rtfText) {
         if (Rtf.isRtf(rtfText)) {
             let rtf = new Rtf();
@@ -1904,12 +1282,6 @@ class StrUtil {
         }
         return rtfText;
     }
-    /// <summary>
-    /// Returns true if the string arrays str1 & str2 are equal
-    /// </summary>
-    /// <param name="str1"></param>
-    /// <param name="str2"></param>
-    /// <returns></returns>
     static StringsArraysEqual(str1, str2) {
         let result;
         if (str1 === null && str2 === null) {
@@ -1936,12 +1308,6 @@ class StrUtil {
         }
         return result;
     }
-    /// <summary>
-    /// The code is copied from tsk_open_bnd_wild and SearchAndReplaceWildChars
-    /// The refactoring is not performed for backwards compatibility
-    /// The code replaces special charachters :* ? with recieved filler
-    /// </summary>
-    /// <returns></returns>
     static SearchAndReplaceWildChars(buf, len, filler) {
         buf = NString.PadRight(buf, len);
         let escChar = false;
@@ -1952,7 +1318,6 @@ class StrUtil {
                 case ('\\'):
                     {
                         let isNextCharWild = true;
-                        //If next char is not wild , then copy '\', if this is first char.
                         if ((i + 1 < len) && (buf[i + 1] != '*' && buf[i + 1] != '\\'))
                             isNextCharWild = false;
                         if (escChar || !isNextCharWild)
@@ -1982,22 +1347,12 @@ class StrUtil {
         let text = tmpBuf.ToString();
         return NString.TrimEnd(NString.TrimEnd(text, ['\0']));
     }
-    /// <summary>
-    /// Remove the task path delimiter from the error string.
-    /// </summary>
-    /// <param name = "source">string with delimiter </param>
-    /// <returns> string for console error </returns>
     static getConsoleErorString(source) {
         let consoleErorString = "";
         if (!isNullOrUndefined(source))
             consoleErorString = this.searchAndReplace(source, TASK_PATH_DELIMITER, "");
         return consoleErorString;
     }
-    /// <summary>
-    /// Remove the task path from the error string.
-    /// </summary>
-    /// <param name = "source">string with delimiter </param>
-    /// <returns> string for console error </returns>
     static getMsgBoxErorString(source) {
         let tokens;
         let msgBoxErorString = new StringBuilder("");
@@ -2013,25 +1368,11 @@ class StrUtil {
 }
 StrUtil._paddingSpaces = null;
 
-// In order to convert some functionality to Visual C#, the Java Language Conversion Assistant
-/// <summary>
-/// Contains conversion support elements such as classes, interfaces and static methods.
-/// </summary>
 class Misc {
-    /// <summary>
-    /// Writes the exception stack trace to the received stream
-    /// </summary>
-    /// <param name="throwable">Exception to obtain information from</param>
-    /// <param name="stream">Output sream used to write to</param>
     static WriteStackTrace(throwable) {
         console.log(throwable.Message);
         console.log(throwable.StackTrace);
     }
-    /// <summary>
-    /// Receives a byte array and returns it transformed in an byte array
-    /// </summary>
-    /// <param name="byteArray">Byte array to process</param>
-    /// <returns>The transformed array</returns>
     static ToSByteArray(byteArray) {
         let sbyteArray = null;
         if (byteArray !== null) {
@@ -2042,11 +1383,6 @@ class Misc {
         }
         return sbyteArray;
     }
-    /// <summary>
-    /// Receives sbyte array and returns it transformed in a byte array
-    /// </summary>
-    /// <param name="sbyteArray">sbyte array to process</param>
-    /// <returns>The transformed array</returns>
     static ToByteArray(sbyteArray) {
         let byteArray = null;
         if (sbyteArray !== null) {
@@ -2057,11 +1393,6 @@ class Misc {
         }
         return byteArray;
     }
-    /// <summary> Compares number of bytes in two byte arrays</summary>
-    /// <param name="source"></param>
-    /// <param name="destination"></param>
-    /// <param name="numberOfBytes"></param>
-    /// <returns> boolen true if equal</returns>
     static CompareByteArray(source, destination, numberOfBytes) {
         if (source.length >= numberOfBytes && destination.length >= numberOfBytes) {
             for (let len = 0; len < numberOfBytes; len++) {
@@ -2073,13 +1404,6 @@ class Misc {
             return false;
         return true;
     }
-    /// <summary>
-    /// Performs an unsigned bitwise right shift with the specified number
-    /// </summary>
-    /// <param name="number">Number to operate on</param>
-    /// <param name="bits">Ammount of bits to shift</param>
-    /// <returns>The resulting number from the shift operation</returns>
-    // TODO: instead of calling URShift(number, bits), we can use((uint)number) >> bits.
     static URShift(number, bits) {
         let result;
         if (number >= 0) {
@@ -2090,20 +1414,9 @@ class Misc {
         }
         return result;
     }
-    /// <summary>
-    /// get system's time in milliseconds
-    /// </summary>
-    /// <returns></returns>
     static getSystemMilliseconds() {
-        // TODO - check if we need this adjustment
         return Math.floor((DateTime.Now.Ticks - 621355968000000000) / 10000);
     }
-    /// <summary>
-    /// Compares 2 int arrays
-    /// </summary>
-    /// <param name="arrayOne"></param>
-    /// <param name="arrayTwo"></param>
-    /// <returns>true if arrays are equal else false</returns>
     static CompareIntArrays(arrayOne, arrayTwo) {
         let areEqual = false;
         if (arrayOne === arrayTwo) {
@@ -2123,11 +1436,6 @@ class Misc {
         }
         return areEqual;
     }
-    /// <summary>
-    /// Returns the comma separated string for the values passed in int array.
-    /// </summary>
-    /// <param name="values">Integer array</param>
-    /// <returns>comma separated string</returns>
     static GetCommaSeperatedString(intArray) {
         let temp = new StringBuilder();
         for (let val = 0; val < intArray.length; val = val + 1) {
@@ -2139,11 +1447,6 @@ class Misc {
         }
         return temp.ToString();
     }
-    /// <summary>
-    /// Returns int array out of comma separated string
-    /// </summary>
-    /// <param name="value">comma separated string</param>
-    /// <returns>Integer array</returns>
     static GetIntArray(commaSeparatedValue) {
         let intArray = new Array(0);
         if (!NString.IsNullOrEmpty(commaSeparatedValue)) {
@@ -2171,24 +1474,9 @@ class Base64 {
         else
             return Base64.encode_2(strOrData);
     }
-    /// <summary> This method encodes the given string using the base64-encoding
-    /// specified in RFC-2045 (Section 6.8). It's used for example in the
-    /// "Basic" authorization scheme.
-    /// </summary>
-    /// <param name="str">the string </param>
-    /// <param name="encoding"> Environment.Encoding </param>
-    /// <returns> the base64-encoded str </returns>
     static encode_0(str, encoding) {
         return Base64.encode(str, false, encoding);
     }
-    /// <summary> Encodes string using the base64-encoding.
-    /// If isUseEnvCharset is true, use the specific charset when converting
-    /// string to byte array. (DBCS support)
-    /// </summary>
-    /// <param name="str">the string </param>
-    /// <param name="isUseEnvCharset"> </param>
-    /// <param name="encoding"> Environment.Encoding </param>
-    /// <returns> the base64-encoded str </returns>
     static encode_1(str, isUseEnvCharset, encoding) {
         let result;
         if (str === null) {
@@ -2212,18 +1500,12 @@ class Base64 {
         }
         return result;
     }
-    /// <summary> This method encodes the given byte[] using the base64-encoding
-    /// specified in RFC-2045 (Section 6.8).
-    /// </summary>
-    /// <param name="data">the data </param>
-    /// <returns> the base64-encoded data </returns>
     static encode_2(data) {
         if (data === null)
             return null;
         let dest = new Uint8Array(Math.floor((data.length + 2) / 3) * 4);
         let sidx = 0;
         let didx = 0;
-        // 3-byte to 4-byte conversion + 0-63 to ASCII printable conversion
         while (sidx < data.length - 2) {
             dest[didx++] = Base64._base64EncMap[Misc.URShift(data[sidx], 2) & 63];
             dest[didx++] = Base64._base64EncMap[(Misc.URShift(data[sidx + 1], 4) & 15) | (data[sidx] << 4 & 63)];
@@ -2241,7 +1523,6 @@ class Base64 {
                 dest[didx++] = Base64._base64EncMap[data[sidx] << 4 & 63];
             }
         }
-        // add padding
         while (didx < dest.length) {
             dest[didx] = 61;
             didx = didx + 1;
@@ -2256,20 +1537,9 @@ class Base64 {
         else
             return Base64.decode_2(strOrData);
     }
-    /// <summary> This method decodes the given string using the base64-encoding
-    /// specified in RFC-2045 (Section 6.8).
-    /// </summary>
-    /// <param name="str">the base64-encoded string. </param>
-    /// <returns> the decoded str.</returns>
     static decode_0(str) {
         return Base64.decode(str, null);
     }
-    /// <summary> This method decodes the given string using the base64-encoding
-    /// specified in RFC-2045 (Section 6.8).
-    /// </summary>
-    /// <param name="str">the base64-encoded string. </param>
-    /// <param name="encoding">Environment.Encoding or null.</param>
-    /// <returns> the decoded str.</returns>
     static decode_1(str, encoding) {
         let result;
         if (str === null) {
@@ -2293,11 +1563,6 @@ class Base64 {
         }
         return result;
     }
-    /// <summary> This method decodes the given byte[] using the base64-encoding
-    /// specified in RFC-2045 (Section 6.8).
-    /// </summary>
-    /// <param name="data">the base64-encoded data.</param>
-    /// <returns> the decoded <var>data</va
     static decode_2(data) {
         if (data === null)
             return null;
@@ -2306,11 +1571,9 @@ class Base64 {
             tail = tail - 1;
         }
         let dest = new Uint8Array(tail - Math.floor(data.length / 4));
-        // ASCII printable to 0-63 conversion
         for (let idx = 0; idx < data.length; idx = idx + 1) {
             data[idx] = Base64._base64DecMap[data[idx]];
         }
-        // 4-byte to 3-byte conversion
         let sidx = 0;
         let didx;
         for (didx = 0; didx < dest.length - 2; didx = didx + 3) {
@@ -2325,7 +1588,6 @@ class Base64 {
             dest[didx] = (((data[sidx + 1] << 4) & 255) | (Misc.URShift(data[sidx + 2], 2) & 15));
         return dest;
     }
-    /// <summary> decoded and return an hex representation of the data</summary>
     static decodeToHex(str) {
         if (str === null)
             return null;
@@ -2333,13 +1595,9 @@ class Base64 {
             return str;
         return StrUtil.stringToHexaDump(Base64.decode(str), 2);
     }
-    /// <summary> decodes a string to byte array</summary>
     static decodeToByte(str) {
         if (str === null)
             return null;
-        // QCR 740918 if we have and empty expression it is sent from the server as empty string
-        // and changed locally to a string with one blank either way they are not valid base64 encoded
-        // string and should not be decoded.
         if (str === "" || str === " ")
             return new Uint8Array(0);
         try {
@@ -2370,18 +1628,6 @@ Base64._base64EncMap = Base64.initializeEncMap();
 Base64._base64DecMap = Base64.initializeDecMap();
 
 class ChoiceUtils {
-    /// <summary>
-    ///   init the display Value from string
-    /// </summary>
-    /// <param name = "choiceDispStr">the all substring separated with comma.
-    ///   The behavior:
-    ///   a. when have "\" before char a-z need to ignore the \ put the a-z char
-    ///   b. when "\," -> ","
-    ///   c. when "\-" -> "-"
-    ///   d. when "\\" -> "\"
-    ///   e. when "\\\\" -> "\\"
-    ///   the display can be all string. and we don't need to check validation according to the dataType(as we do in Link
-    /// </param>
     static GetDisplayListFromString(choiceDispStr, removeAccelerators, shouldMakePrintable, shouldTrimOptions) {
         let fromHelp = new Array("\\\\", "\\-", "\\,");
         let toHelp = new Array("XX", "XX", "XX");
@@ -2458,19 +1704,15 @@ class ChoiceUtils {
     }
 }
 
-//This class contains all the constants which are used in MgxpaRIA.exe as well as in MgGui.dll.
 class Constants {
     constructor() {
     }
 }
-/// <summary> Null Arithmetic values</summary>
 Constants.NULL_ARITH_NULLIFY = 'N';
 Constants.NULL_ARITH_USE_DEF = 'U';
-/// <summary> select program : select mode property</summary>
 Constants.SELPRG_MODE_BEFORE = 'B';
 Constants.SELPRG_MODE_AFTER = 'A';
 Constants.SELPRG_MODE_PROMPT = 'P';
-/// <summary> move in View</summary>
 Constants.MOVE_UNIT_TABLE = 'T';
 Constants.MOVE_UNIT_PAGE = 'P';
 Constants.MOVE_UNIT_ROW = 'R';
@@ -2484,7 +1726,6 @@ Constants.MOVE_DIRECTION_PARENT = 'A';
 Constants.MOVE_DIRECTION_FIRST_SON = 'F';
 Constants.MOVE_DIRECTION_NEXT_SIBLING = 'X';
 Constants.MOVE_DIRECTION_PREV_SIBLING = 'V';
-/// <summary> refresh types for a task form</summary>
 Constants.TASK_REFRESH_FORM = 'F';
 Constants.TASK_REFRESH_TABLE = 'T';
 Constants.TASK_REFRESH_TREE_AND_FORM = 'R';
@@ -2495,15 +1736,12 @@ Constants.TASK_MODE_MODIFY = 'M';
 Constants.TASK_MODE_CREATE = 'C';
 Constants.TASK_MODE_DELETE = 'D';
 Constants.TASK_MODE_NONE = ' ';
-/// <summary> task level</summary>
 Constants.TASK_LEVEL_NONE = ' ';
 Constants.TASK_LEVEL_TASK = 'T';
 Constants.TASK_LEVEL_RECORD = 'R';
 Constants.TASK_LEVEL_CONTROL = 'C';
-/// <summary> special records constants</summary>
 Constants.MG_DATAVIEW_FIRST_RECORD = Int32.MinValue;
 Constants.MG_DATAVIEW_LAST_RECORD = Int32.MaxValue;
-/// <summary> action states for keyboard mapping</summary>
 Constants.ACT_STT_TBL_SCREEN_MODE = 0x0001;
 Constants.ACT_STT_TBL_LEFT_TO_RIGHT = 0x0002;
 Constants.ACT_STT_TBL_SCREEN_TOP = 0x0004;
@@ -2518,17 +1756,13 @@ Constants.ACT_STT_EDT_LINE_END = 0x0400;
 Constants.ACT_STT_EDT_EDITING = 0x0800;
 Constants.ACT_STT_TREE_PARK = 0x1000;
 Constants.ACT_STT_TREE_EDITING = 0x2000;
-Constants.ForwardSlashWebUsage = "web"; // refer to a forward slash as a relative web url.
+Constants.ForwardSlashWebUsage = "web";
 Constants.HTTP_PROTOCOL = "http://";
 Constants.HTTPS_PROTOCOL = "https://";
 Constants.FILE_PROTOCOL = "file://";
-/// <summary>threads constants</summary>
 Constants.MG_GUI_THREAD = "MG_GUI_THREAD";
 Constants.MG_WORK_THREAD = "MG_WORK_THREAD";
 Constants.MG_TIMER_THREAD = "MG_TIMER_THREAD";
-/// <summary>
-/// property name for the runtime designer
-/// </summary>
 Constants.ConfigurationFilePropertyName = "Configuration file";
 Constants.WinPropText = "Text";
 Constants.WinPropLayer = "Layer";
@@ -2562,12 +1796,9 @@ XMLConstants.MG_TAG_OPEN = XMLConstants.TAG_OPEN + XMLConstants.MG_TAG_XML + " "
 XMLConstants.MG_TAG_TASK = "task";
 XMLConstants.MG_TAG_TASK_END = "/task";
 XMLConstants.MG_TAG_RECOMPUTE = "recompute";
-//TODO: this class contains the constants which are used for XML parsing.
-//Check if we can move it to Util.dll
 XMLConstants.MG_ATTR_VB_VIEW_ROWIDX = "db_view_rowidx";
 XMLConstants.MG_ATTR_CONTROL_ISN = "controlIsn";
 XMLConstants.MG_HOR_ALIGMENT_IS_INHERITED = "horizontalAlignmentIsFromSystemDefault";
-// MainHeaders
 XMLConstants.MAX_PATH = 260;
 XMLConstants.FILE_NAME_SIZE = XMLConstants.MAX_PATH + 1;
 XMLConstants.CDATA_START = "<![CDATA[";
@@ -2653,13 +1884,11 @@ XMLConstants.MG_ATTR_ISSPECIFIC = "isSpecific";
 XMLConstants.MG_ATTR_IS_GUI_THREAD_EXECUTION = "isGuiThreadExecution";
 XMLConstants.MG_TAG_TASKDEFINITIONID_ENTRY = "taskDefinitionId";
 XMLConstants.MG_TAG_OBJECT_REFERENCE = "objectRef";
-//Help types
 XMLConstants.MG_ATTR_HLP_TYP_TOOLTIP = "T";
 XMLConstants.MG_ATTR_HLP_TYP_PROMPT = "P";
 XMLConstants.MG_ATTR_HLP_TYP_URL = "U";
 XMLConstants.MG_ATTR_HLP_TYP_INTERNAL = "I";
 XMLConstants.MG_ATTR_HLP_TYP_WINDOWS = "W";
-//Internal help attributes.
 XMLConstants.MG_ATTR_INTERNAL_HELP_TYPE = "type";
 XMLConstants.MG_ATTR_INTERNAL_HELP_NAME = "name";
 XMLConstants.MG_ATTR_INTERNAL_HELP_FRAMEX = "framex";
@@ -2674,26 +1903,20 @@ XMLConstants.MG_ATTR_INTERNAL_HELP_BORDERSTYLE = "borderstyle";
 XMLConstants.MG_ATTR_INTERNAL_TITLE_BAR = "titlebar";
 XMLConstants.MG_ATTR_INTERNAL_HELP_SYSTEM_MENU = "sysmenu";
 XMLConstants.MG_ATTR_INTERNAL_HELP_FONT_TABLE_INDEX = "fonttableindex";
-//Windows help attributes.
 XMLConstants.MG_ATTR_WINDOWS_HELP_FILE = "file";
 XMLConstants.MG_ATTR_WINDOWS_HELP_COMMAND = "command";
 XMLConstants.MG_ATTR_WINDOWS_HELP_KEY = "key";
-//Print data attributes.
 XMLConstants.MG_TAG_PRINT_DATA = "Print_data";
 XMLConstants.MG_TAG_PRINT_DATA_END = "/Print_data";
 XMLConstants.MG_TAG_RECORD = "Record";
 XMLConstants.MG_TAG_RECORD_END = "/Record";
-//Custom Validators  attributes.
 XMLConstants.MG_TAG_CUSTOM_VALIDATORS = "CustomValidators";
 XMLConstants.MG_TAG_CUSTOM_VALIDATORS_END = "/CustomValidators";
 XMLConstants.MG_TAG_CUSTOM_VALIDATOR = "CustomValidator";
-// date/time formats for DateTimeUtils
-//TODO: isolate to a different file?
 XMLConstants.ERROR_LOG_TIME_FORMAT = "HH:mm:ss.S";
 XMLConstants.ERROR_LOG_DATE_FORMAT = "DD/MM/YYYY";
 XMLConstants.HTTP_ERROR_TIME_FORMAT = "HH:mm:ss";
 XMLConstants.CACHED_DATE_TIME_FORMAT = "DD/MM/YYYY HH:mm:ss";
-//webs constants
 XMLConstants.MG_TAG_WS_READ_REQUEST = "Read";
 XMLConstants.MG_TAG_WS_CREATE_REQUEST = "Create";
 XMLConstants.MG_TAG_WS_CREATE_REQUEST_END = "/Create";
@@ -2724,7 +1947,6 @@ XMLConstants.MG_TAG_MENUS_CLOSE = "/Menus";
 XMLConstants.MG_TAG_MENU = "Menu";
 
 class DateTimeUtils {
-    /// <summary> returns the number in a 2 digit string
     static int2str(n) {
         return (n > 9) ? n.toString() : ("0" + n);
     }
@@ -2776,16 +1998,10 @@ class DateTimeUtils {
     }
 }
 
-/// <summary>
-///   An interface to define the constantes used by the Picture mechanism.
-/// </summary>
 class PICInterface {
     constructor() {
     }
 }
-//--------------------------------------------------------------------------
-// TEMP!
-//--------------------------------------------------------------------------
 PICInterface.PIC_X = 1;
 PICInterface.PIC_U = 2;
 PICInterface.PIC_L = 3;
@@ -2803,32 +2019,30 @@ PICInterface.PIC_HH = 14;
 PICInterface.PIC_MMT = 15;
 PICInterface.PIC_SS = 16;
 PICInterface.PIC_PM = 17;
-PICInterface.PIC_HYYYYY = 18; // Hebrew year
-PICInterface.PIC_HL = 19; // Hebrew thousand year
-PICInterface.PIC_HDD = 20; // Hebrew day of month
-PICInterface.PIC_MS = 21; // Milliseconds
-PICInterface.PIC_LOCAL = 23; // the space between PIC_LOCAL and PIC_MAX_OP
+PICInterface.PIC_HYYYYY = 18;
+PICInterface.PIC_HL = 19;
+PICInterface.PIC_HDD = 20;
+PICInterface.PIC_MS = 21;
+PICInterface.PIC_LOCAL = 23;
 PICInterface.PIC_MAX_MSK_LEN = 100;
-// JPN: Japanese date picture support
-PICInterface.PIC_JY1 = PICInterface.PIC_LOCAL + 0; // the name of an era (1 byte)
-PICInterface.PIC_JY2 = PICInterface.PIC_LOCAL + 1; // the name of an era (2 bytes)
-PICInterface.PIC_JY4 = PICInterface.PIC_LOCAL + 2; // the name of an era (4 bytes)
-PICInterface.PIC_YJ = PICInterface.PIC_LOCAL + 3; // a year of an era
-PICInterface.PIC_BB = PICInterface.PIC_LOCAL + 4; // a day of the week (2, 4 or 6 bytes)
-// DBCS pictures for iSeries
-PICInterface.PIC_J = PICInterface.PIC_LOCAL + 5; // DBCS only (with SO/SI)
-PICInterface.PIC_T = PICInterface.PIC_LOCAL + 6; // All SBCS or All DBCS (with SO/SI)
-PICInterface.PIC_G = PICInterface.PIC_LOCAL + 7; // DBCS only (without SO/SI)
-PICInterface.PIC_S = PICInterface.PIC_LOCAL + 8; // SBCS only
-PICInterface.PIC_MAX_OP = 31; // is reserved for DLL"s picture
+PICInterface.PIC_JY1 = PICInterface.PIC_LOCAL + 0;
+PICInterface.PIC_JY2 = PICInterface.PIC_LOCAL + 1;
+PICInterface.PIC_JY4 = PICInterface.PIC_LOCAL + 2;
+PICInterface.PIC_YJ = PICInterface.PIC_LOCAL + 3;
+PICInterface.PIC_BB = PICInterface.PIC_LOCAL + 4;
+PICInterface.PIC_J = PICInterface.PIC_LOCAL + 5;
+PICInterface.PIC_T = PICInterface.PIC_LOCAL + 6;
+PICInterface.PIC_G = PICInterface.PIC_LOCAL + 7;
+PICInterface.PIC_S = PICInterface.PIC_LOCAL + 8;
+PICInterface.PIC_MAX_OP = 31;
 PICInterface.NULL_CHAR = -1;
 PICInterface.DB_STR_MAX = 255;
-PICInterface.DAYSINFOURCENT = 146097; // ((365*4+1)*25-1)*4+1 */
-PICInterface.DAYSINCENTURY = 36524; // (365*4+1)*25-1 */
-PICInterface.DAYSINFOURYEAR = 1461; // 365*4+1 */
+PICInterface.DAYSINFOURCENT = 146097;
+PICInterface.DAYSINCENTURY = 36524;
+PICInterface.DAYSINFOURYEAR = 1461;
 PICInterface.DAYSINYEAR = 365;
 PICInterface.DAYSINMONTH = 31;
-PICInterface.DATE_BUDDHIST_GAP = 543; // years above the gregorian date
+PICInterface.DATE_BUDDHIST_GAP = 543;
 PICInterface.DEFAULT_DATE = "693961";
 PICInterface.DEFAULT_TIME = "0";
 PICInterface.date_day_tab = [
@@ -2840,9 +2054,6 @@ PICInterface.date_month_str = [
 PICInterface.date_dow_str = [
     "          ", "Sunday    ", "Monday    ", "Tuesday   ", "Wednesday ", "Thursday  ", "Friday    ", "Saturday  "
 ];
-//public final static readonly int    DEF_century       = 1920;
-//public final static readonly Nchar   DEF_date_mode     = 'E';
-// vec of pictures that can be given a numeric char only
 PICInterface.NumDirective = [
     4, 5, 6, 7, 9, 10, 11, 12, 14, 15, 16
 ];
@@ -2850,15 +2061,9 @@ PICInterface.NumDirective = [
 const DATE_MONTH_LEN = 10;
 const DATE_DOW_LEN = 10;
 class DateUtil {
-    /// <summary>
-    ///  extract the vector which contains the names of the months, as specified by the
-    ///  language CAB
-    /// </summary>
     static getLocalMonths(names) {
         let monthLen = DATE_MONTH_LEN;
-        // if it's the first time then access the language CAB and take the values
         if (typeof DateUtil._localMonths[0] === "undefined") {
-            //cut the string into separate values
             if (names !== null) {
                 DateUtil._localMonths[0] = PICInterface.date_month_str[0];
                 for (let i = 1; i < DateUtil._localMonths.length; i = i + 1) {
@@ -2881,15 +2086,9 @@ class DateUtil {
         }
         return DateUtil._localMonths;
     }
-    /// <summary>
-    ///   extract the vector which contains the names of the days, as specified by the
-    ///   language CAB
-    /// </summary>
     static getLocalDays(names) {
         let dowLen = DATE_DOW_LEN;
-        // if it's the first time then access the language CAB and take the values
         if (typeof DateUtil._localDays[0] === "undefined") {
-            //cut the string into separate values
             if (names !== null) {
                 DateUtil._localDays[0] = PICInterface.date_dow_str[0];
                 for (let i = 1; i < DateUtil._localDays.length; i = i + 1) {
@@ -4679,7 +3878,6 @@ var NotifyCollectionChangedAction;
     NotifyCollectionChangedAction[NotifyCollectionChangedAction["Reset"] = 4] = "Reset";
 })(NotifyCollectionChangedAction || (NotifyCollectionChangedAction = {}));
 
-/// <summary> this interface defines the internal events codes</summary>
 class InternalInterface {
     constructor() {
     }
@@ -4953,7 +4151,6 @@ InternalInterface.MG_ACT_TREE_RENAME_RT_EXIT = 413;
 InternalInterface.MG_ACT_SERVER_TERMINATION = 420;
 InternalInterface.MG_ACT_SUBFORM_REFRESH = 432;
 InternalInterface.MG_ACT_CONTEXT_MENU = 439;
-InternalInterface.MG_ACT_DEFAULT_BUTTON = 459;
 InternalInterface.MG_ACT_NEXT_RT_WINDOW = 462;
 InternalInterface.MG_ACT_PREV_RT_WINDOW = 463;
 InternalInterface.MG_ACT_EMPTY_DATAVIEW = 521;
@@ -4987,8 +4184,8 @@ InternalInterface.MG_ACT_NO_PROG_EXE_RIGHTS = 619;
 InternalInterface.MG_ACT_CRELINE_ABOVE = 634;
 InternalInterface.MG_ACT_CONTEXT_TERMINATION = 635;
 InternalInterface.MG_ACT_CONTEXT_TIMEOUT_RESET = 636;
-InternalInterface.MG_ACT_TOT_CNT = 637;
-// NEW INTERNAL EVENTS
+InternalInterface.MG_ACT_CONTEXT_REMOVE = 647;
+InternalInterface.MG_ACT_TOT_CNT = 648;
 InternalInterface.MG_ACT_TASK_PREFIX = 1001;
 InternalInterface.MG_ACT_TASK_SUFFIX = 1002;
 InternalInterface.MG_ACT_REC_PREFIX = 1003;
@@ -5005,7 +4202,6 @@ InternalInterface.MG_ACT_CYCLE_NEXT_REC = 1017;
 InternalInterface.MG_ACT_CYCLE_NEXT_DELETE_REC = 1018;
 InternalInterface.MG_ACT_COMPUTE = 1020;
 InternalInterface.MG_ACT_DUMMY = 1111;
-// INTERNAL EVENTS for WebClient
 InternalInterface.MG_ACT_CTRL_FOCUS = 2001;
 InternalInterface.MG_ACT_CTRL_MOUSEUP = 2002;
 InternalInterface.MG_ACT_CTRL_KEYDOWN = 2003;
@@ -5015,13 +4211,12 @@ InternalInterface.MG_ACT_RESIZE = 2006;
 InternalInterface.MG_ACT_ROW_DATA_CURR_PAGE = 2007;
 InternalInterface.MG_ACT_DV_TO_GUI = 2008;
 InternalInterface.MG_ACT_DISABLE_EVENTS = 2010;
-// toggle insert is temp 539 , it should match the code in online once it will be created.
 InternalInterface.MG_ACT_TOGGLE_INSERT = 2011;
 InternalInterface.MG_ACT_INCREMENTAL_LOCATE = 2017;
 InternalInterface.MG_ACT_MOVE_TO_FIRST_CTRL = 2018;
 InternalInterface.MG_ACT_SET_EXTERNAL_VALUE = 2019;
 InternalInterface.MG_ACT_CTRL_FOCUS_ON_NON_MAGIC_CONTROL = 2020;
-InternalInterface.MG_ACT_FETCH_RECORDS_AHEAD_FROM_SERVER = 2021; // for paginated table, fetch records in background depending on PROP_TYPE_SERVER_READ_AHEAD
+InternalInterface.MG_ACT_FETCH_RECORDS_AHEAD_FROM_SERVER = 2021;
 
 class JSON_Utils {
     static JSONFromXML(xml, onComplete) {
@@ -5032,16 +4227,13 @@ class JSON_Utils {
 class OSEnvironment {
     static getStackTrace() {
         let ex = new Exception();
-        ex.errorLevel++; // we need to remove the line which contains call to this method
+        ex.errorLevel++;
         return ex.StackTrace;
     }
 }
 OSEnvironment.EolSeq = "\n";
 OSEnvironment.TabSeq = "\t";
 
-/// <summary>
-/// The class is responsible to maintain the Request information while sending a request to server
-/// </summary>
 class RequestInfo {
     constructor() {
         this.runtimeTaskTree = new List();
@@ -5073,16 +4265,9 @@ var LogType;
     LogType[LogType["warning"] = 2] = "warning";
     LogType[LogType["error"] = 3] = "error";
 })(LogType || (LogType = {}));
-/// <summary>
-/// Logger class will take care of client side logging . It will check for various log levels and accordingly will write messages in log file.
-/// </summary>
-//@dynamic
 class Logger {
     constructor() {
-        this.LogLevel = 0; // InternalLogLevel
-        /// <summary>
-        /// While writing the error messages in the file play the beep.
-        /// </summary>
+        this.LogLevel = 0;
         this.ShouldBeep = false;
     }
     static set Instance(value) {
@@ -5094,26 +4279,10 @@ class Logger {
         }
         return Logger.instance;
     }
-    /// <summary>
-    /// Initialize logger
-    /// </summary>
-    /// <param name="logLevel"></param>
-    /// <param name="internalLogSync"></param>
     Initialize(logLevel, internalLogSync, shouldBeep) {
         try {
-            // let logSync: LogSyncMode  = LogSyncMode.Session;
             this.LogLevel = logLevel;
             this.ShouldBeep = shouldBeep;
-            // TODO: implement
-            //   String strLogSync = internalLogSync;
-            //   if (!string.IsNullOrEmpty(strLogSync))
-            // {
-            //   if (strLogSync.StartsWith("M", StringComparison.CurrentCultureIgnoreCase))
-            //   logSync = LogSyncMode.Message;
-            //   else if (strLogSync.StartsWith("F", StringComparison.CurrentCultureIgnoreCase))
-            //   logSync = LogSyncMode.Flush;
-            // }
-            //
         }
         catch (e) {
             this.WriteDevToLog("ClientManager.init(): " + e.Message);
@@ -5137,9 +4306,6 @@ class Logger {
     ShouldLogExtendedServerRelatedMessages() {
         return (Logger.Instance.ShouldLog(Logger_LogLevels.ServerMessages) || Logger.Instance.ShouldLog(Logger_LogLevels.Support) || Logger.Instance.ShouldLog(Logger_LogLevels.Development)) && this.LogLevel !== Logger_LogLevels.Basic;
     }
-    /// <summary></summary>
-    /// <param name="msg"></param>
-    /// <param name="openIfNecessary">open the log file if not opened yet</param>
     WriteToLog(msg, openIfNecessary, logType = LogType.info) {
         if (this.LogLevel > Logger_LogLevels.None || openIfNecessary) {
             msg = NString.Format("{0} {1}", (this.LogLevel === Logger_LogLevels.Basic) ? new Date().toISOString() : DateTimeUtils.ToString(DateTime.Now, XMLConstants.ERROR_LOG_TIME_FORMAT, this), msg);
@@ -5155,26 +4321,16 @@ class Logger {
             }
         }
     }
-    /// <summary>
-    /// write a server access to the log
-    /// </summary>
-    /// <param name="msg">the message to write to the log</param>
     WriteServerToLog(msg) {
         if (this.ShouldLogServerRelatedMessages()) {
             this.WriteToLog(NString.Format("Server, Thread={0}: ", Thread.CurrentThread.ManagedThreadId) + msg, false, LogType.info);
         }
     }
-    /// <summary>
-    /// write a server access to the log, including the content
-    /// </summary>
-    /// <param name="msg">the message to write to the log</param>
     WriteServerMessagesToLog(msg) {
         if (this.ShouldLogExtendedServerRelatedMessages()) {
             this.WriteToLog("Server#: " + msg, false, LogType.info);
         }
     }
-    /// <summary>Write a QC message to the log</summary>
-    /// <param name="msg">the message to write to the log</param>
     WriteSupportToLog(msg, skipLine) {
         if (this.LogLevel >= Logger_LogLevels.Support && this.LogLevel !== Logger_LogLevels.Basic) {
             if (skipLine) {
@@ -5185,31 +4341,16 @@ class Logger {
             }
         }
     }
-    /// <summary>
-    /// write a performance message to the log
-    /// </summary>
-    /// <param name="msg">the message to write to the log</param>
     WriteGuiToLog(msg) {
         if (this.LogLevel >= Logger_LogLevels.Gui && this.LogLevel !== Logger_LogLevels.Basic) {
             this.WriteToLog(msg, false, LogType.info);
         }
     }
-    /// <summary>
-    /// write a developer message to the log
-    /// </summary>
-    /// <param name="msg">the message to write to the log</param>
     WriteDevToLog(msg) {
         if (this.LogLevel >= Logger_LogLevels.Development && this.LogLevel !== Logger_LogLevels.Basic) {
             this.WriteToLog("DEV: " + msg, false, LogType.info);
         }
     }
-    /// <summary>
-    /// Writes a basic level entry to log
-    /// </summary>
-    /// <param name="messageDirection">message direction relative to the current module (RIA client). Can be either MessageEntering or MessageLeaving</param>
-    /// <param name="statusCode">HTTP status code</param>
-    /// <param name="contentLength">length of the http message</param>
-    /// <param name="httpHeaders">HTTP headers</param>
     WriteBasicToLog(messageDirection, contextID, sessionCounter, clientID, serverID, responseTime, statusCode, httpHeaders, contentLength) {
         if (this.LogLevel === Logger_LogLevels.Basic) {
             let text = httpHeaders;
@@ -5217,8 +4358,6 @@ class Logger {
             text = NString.Replace(text, "\r\n", "|");
             let arg_E4_0 = "RIA,{0}_{1},{2},{3},{4},{5},-,{6},{7},{8},{9},{10},{11}";
             let expr_3E = new Array(12);
-            // TODO : need to check How to handle Process class.
-            // expr_3E[0] = Process.GetCurrentProcess().Id;
             expr_3E[1] = Thread.CurrentThread.ManagedThreadId;
             expr_3E[2] = new Date().toISOString();
             expr_3E[3] = ((messageDirection === Logger_MessageDirection.MessageLeaving) ? "MSGL" : "MSGE");
@@ -5237,37 +4376,14 @@ class Logger {
             console.log(value);
         }
     }
-    /// <summary>
-    /// Writes request information to log
-    /// </summary>
-    /// <param name="clientSession">The clientSession object to be logged</param>
     WriteRequestInfoToLog(requestInfo, extraMessageStr) {
         if (this.LogLevel === Logger_LogLevels.RequestInfo) {
-            // Chrome debugger automatically recomputes logged objects.
-            // Hence, clone the requestInfo object to print the details at the time of logging
             console.log(extraMessageStr, RequestInfo.clone(requestInfo));
         }
     }
-    /// <summary>
-    /// Writes a request exception basic level entry to log
-    /// </summary>
-    /// <param name="contextID"></param>
-    /// <param name="sessionCounter"></param>
-    /// <param name="clientID"></param>
-    /// <param name="serverID"></param>
-    /// <param name="ex">the logged exception</param>
     WriteBasicErrorToLog(contextID, sessionCounter, clientID, serverID, ex) {
         Debug.Assert(this.LogLevel === Logger_LogLevels.Basic);
-        // TODO : Need to check how to handle Process
-        // let value: string = NString.Format("RIA,{0}_{1},{2},{3},{4},{5},-,{6},{7},-,-,-,{8} {9}", [
-        // Process.GetCurrentProcess().Id, Thread.CurrentThread.ManagedThreadId, DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss.fffffffZ"), "RES", contextID, sessionCounter, clientID, serverID, ex.GetType(), ex.Message
-        // ]);
-        // NConsole.WriteLine(value);
-    }
-    /// <summary>
-    /// Write an error to the log
-    /// </summary>
-    /// <param name="msg">the message to write to the log</param>
+    }
     WriteErrorToLog(msg) {
         this.WriteToLog("MagicWeb [ERROR]: " + StrUtil.getConsoleErorString(msg), true, LogType.error);
     }
@@ -5347,9 +4463,6 @@ class Logger {
         }
         this.WriteToLog(stringBuilder.ToString(), true);
     }
-    /// <summary>
-    /// Flush the log writer.
-    /// </summary>
     Flush() {
     }
 }
@@ -5559,14 +4672,11 @@ MsgInterface.DefaultMessages = [
     new DefaultMsgDetails("STR_MOBILE_TAB_CONTROL_LAYER_0", "Controls cannot be linked to layer 0 of the tab control."), new DefaultMsgDetails("STR_MOBILE_TAB_DISPLAY_LIST_ERROR", "The number of entries in the Display List property must be zero or match the number of entries in the Items List property."), new DefaultMsgDetails("RC_ERROR_ARG_TYPE_STRING_NUMBER_MISMATCH", "The number of characters in the argument type string does not match the number of total arguments"), new DefaultMsgDetails("RC_ERROR_ILLEGAL_ARG_ATTR_TYPE", "Illegal argument attribute type"), new DefaultMsgDetails("RC_ERROR_ILLEGAL_RETURN_VAL_ATTR_TYPE", "Illegal return value attribute type"), new DefaultMsgDetails("STR_ERR_WEBCLIENT_PROGRAM_RELOADED", "Changes were done at the server side. Browser will be refreshed in order to get the latest changes."), new DefaultMsgDetails("STR_ERR_EXECUTED_PROGRAM_CHANGED", "Executed program changed at the server side. Browser will be refreshed in order to get the latest changes.")
 ];
 
-/// <summary> implementation of a general queue</summary>
 class Queue {
-    /// <summary> </summary>
     constructor() {
         this._queueVec = null;
         this._queueVec = new List();
     }
-    /// <summary> returns the first object in the queue</summary>
     get() {
         let returnValue = null;
         if (this._queueVec.length > 0) {
@@ -5575,20 +4685,15 @@ class Queue {
         }
         return returnValue;
     }
-    /// <summary> add an object to the end of the queue</summary>
-    /// <param name="obj">the object to add
     put(obj) {
         this._queueVec.push(obj);
     }
-    /// <summary> remove all the objects from the queue</summary>
     clear() {
         this._queueVec.Clear();
     }
-    /// <summary> returns true if the queue is empty</summary>
     isEmpty() {
         return this._queueVec.length === 0;
     }
-    /// <summary> returns size of the queue</summary>
     Size() {
         return this._queueVec.length;
     }
@@ -5628,15 +4733,7 @@ Randomizer._mod = 0.0;
 Randomizer._mul = 0.0;
 Randomizer._seed = 0.0;
 
-/// <summary>
-/// type checking for enum 'StorageAttribute'
-/// </summary>
 class StorageAttributeCheck {
-    /// <summary>
-    /// is the both types belong to the same inner data types
-    /// </summary>
-    /// <param name = "type1">data type</param>
-    /// <param name = "type2">data type</param>
     static isTheSameType(type1, type2) {
         return type1 === type2 || (StorageAttributeCheck.isTypeNumeric(type1) && StorageAttributeCheck.isTypeNumeric(type2)) || (StorageAttributeCheck.isTypeLogical(type1) && StorageAttributeCheck.isTypeLogical(type2)) || (StorageAttributeCheck.IsTypeAlphaOrUnicode(type1) && StorageAttributeCheck.IsTypeAlphaOrUnicode(type2)) || (StorageAttributeCheck.isTypeBlob(type1) && StorageAttributeCheck.isTypeBlob(type2)) || (StorageAttributeCheck.isTypeDotNet(type1) && StorageAttributeCheck.isTypeDotNet(type2));
     }
@@ -5646,36 +4743,18 @@ class StorageAttributeCheck {
     static isTypeAlpha(type) {
         return type === StorageAttribute.ALPHA || type === StorageAttribute.MEMO;
     }
-    /// <summary>
-    /// is the both types belong to the NUMERIC inner type
-    /// </summary>
     static isTypeNumeric(type) {
         return type === StorageAttribute.DATE || type === StorageAttribute.TIME || type === StorageAttribute.NUMERIC;
     }
-    /// <summary>
-    /// is the both types belong to the LOGICAL inner type
-    /// </summary>
     static isTypeLogical(type) {
         return type === StorageAttribute.BOOLEAN;
     }
-    /// <summary>
-    /// is the type is DOTNET
-    /// </summary>
     static isTypeDotNet(type) {
         return type === StorageAttribute.DOTNET;
     }
-    /// <summary>
-    /// is the type ALPHA or UNICODE
-    /// </summary>
-    /// <param name = "type">data type</param>
     static IsTypeAlphaOrUnicode(type) {
         return type === StorageAttribute.ALPHA || type === StorageAttribute.UNICODE;
     }
-    /// <summary>
-    /// is the inner type ALPHA or UNICODE
-    /// </summary>
-    /// <param name = "type1">data type</param>
-    /// <param name = "type2">data type</param>
     static StorageFldAlphaOrUnicode(type1, type2) {
         return StorageAttributeCheck.IsTypeAlphaOrUnicode(type1) && StorageAttributeCheck.IsTypeAlphaOrUnicode(type2);
     }
@@ -5691,12 +4770,6 @@ class StorageAttributeCheck {
             return ((type1AlphaOrUnicode && type2Blob) || (type2AlphaOrUnicode && type1Blob));
         }
     }
-    /// <summary>
-    /// Check if types are compatible or not.
-    /// </summary>
-    /// <param name="sourceAttribute"></param>
-    /// <param name="destinationAttribute"></param>
-    /// <returns></returns>
     static IsTypeCompatibile(sourceAttribute, destinationAttribute) {
         let isTypeCompatible = false;
         switch (sourceAttribute) {
@@ -5743,36 +4816,21 @@ class StorageAttributeCheck {
     }
 }
 
-/// <summary>
-/// Helper class for synchronized execution.
-/// It works by creating a promise and then waiting for the promise to be completed
-/// </summary>
-// @dynamic
 class SyncExecutionHelper {
     constructor() {
-        // resolver is caller when promise is fullfilled
         this.resolver = null;
     }
-    /// <summary>
-    /// get instance of SyncExecutionHelper
-    /// </summary>
     static get Instance() {
         if (SyncExecutionHelper._instance === null)
             SyncExecutionHelper._instance = new SyncExecutionHelper();
         return SyncExecutionHelper._instance;
     }
-    /// <summary>
-    /// To wait, create a promise and add wait for it to complete
-    /// </summary>
     Wait() {
         Logger.Instance.WriteDevToLog("SyncExecutionHelper.Wait()");
         return new Promise((resolve, reject) => {
             this.resolver = resolve;
         }).then();
     }
-    /// <summary>
-    /// To resume call the resolver
-    /// </summary>
     Pulse() {
         let resolver = this.resolver;
         if (resolver != null) {
@@ -5793,13 +4851,6 @@ const IDX_DAY = 2;
 const IDX_DOY = 3;
 class UtilDateJpn {
     constructor() {
-        /// <summary>
-        ///   JPN: Japanese date picture support
-        ///   Utility Class for Japanese date
-        /// </summary>
-        /// <author>  Toshiro Nakayoshi (MSJ)
-        /// </author>
-        // ---- gengo (the name of an era)  ---------------------------------------
         this.MaxGengo = MAX_GENGO;
     }
     static getInstance() {
@@ -5825,18 +4876,6 @@ class UtilDateJpn {
         }
         return UtilDateJpn.JmonthStr[month];
     }
-    /// <summary>
-    ///   Convert a year (A.D.) into Japanese year of an era
-    ///   This method is modeled after "date_jpn_year_ofs" function in
-    ///   "\mglocal\jpn\jpndate_jpn.cpp".
-    /// </summary>
-    /// <param name = "intYear:">year (A.D.)
-    /// </param>
-    /// <param name = "intDoy:">DOY
-    /// </param>
-    /// <returns> year of an era.
-    ///   if either param is invalid, it returns 0.
-    /// </returns>
     date_jpn_year_ofs(intYear, intDoy) {
         let result;
         if (intYear < 1 || intDoy < 1) {
@@ -5854,20 +4893,6 @@ class UtilDateJpn {
         }
         return result;
     }
-    /// <summary>
-    ///   Convert a year (A.D.) into a name of a Japanese era
-    ///   This method is modeled after "date_jpn_yr_2_a" function in
-    ///   "\mglocal\jpn\jpndate_jpn.cpp".
-    /// </summary>
-    /// <param name = "intYear:">year (A.D.)
-    /// </param>
-    /// <param name = "intDoy:">DOY
-    /// </param>
-    /// <param name = "isKanji:">return a full name (true) or the first letter (false).
-    /// </param>
-    /// <returns> name of an era
-    ///   if either param is invalid, it returns "?".
-    /// </returns>
     date_jpn_yr_2_a(intYear, intDoy, isKanji) {
         let num;
         if (intYear < 1 || intDoy < 1) {
@@ -5891,17 +4916,6 @@ class UtilDateJpn {
         }
         return result;
     }
-    /// <summary>
-    ///   Get the first year (A.D.) of a specified Japanese era
-    ///   This method is modeled after "date_jpn_yr_4_a" function in
-    ///   "\mglocal\jpn\jpndate_jpn.cpp".
-    /// </summary>
-    /// <param name = "ucp_str:">name of a specified Japanese era
-    /// </param>
-    /// <param name = "s_len:">length (the number of bytes) of ucp_str
-    /// </param>
-    /// <returns> year (A.D.)
-    /// </returns>
     date_jpn_yr_4_a(ucp_str, s_len) {
         let i = this.MaxGengo - 1;
         if (s_len > 0) {
@@ -5940,17 +4954,6 @@ class UtilDateJpn {
         }
         return result;
     }
-    /// <summary>
-    ///   Get the name of an era in date string
-    /// </summary>
-    /// <param name = "strDate:">string of input strDate
-    /// </param>
-    /// <param name = "strPicture:">string of picture
-    /// </param>
-    /// <param name = "intStartPos:">start position to search
-    /// </param>
-    /// <returns> name of an era
-    /// </returns>
     static getEraNameStrInDate(strDate, strPicture, intStartPos) {
         let result = null;
         let intPicIdxOfs = 0;
@@ -5969,7 +4972,6 @@ class UtilDateJpn {
                         intLetters = 2;
                     }
                     else {
-                        // If "strDate" contains DBCS, the position of "strPicture" has to skip next index.
                         if (i < strDate.length) {
                             if (!UtilStrByteMode.isHalfWidth(strDate[i]) && UtilStrByteMode.isHalfWidth(strPicture[i + intPicIdxOfs])) {
                                 intPicIdxOfs = intPicIdxOfs + 1;
@@ -5981,19 +4983,10 @@ class UtilDateJpn {
                 }
             }
             result = strDate.substr(i, intLetters);
-            break; // exit loop
+            break;
         }
         return result;
     }
-    /// <summary>
-    ///   Get the length of the name of an era in picture
-    /// </summary>
-    /// <param name = "strPicture">string of picture
-    /// </param>
-    /// <param name = "intStartPos">start position to search
-    /// </param>
-    /// <returns> length of the name (the number of bytes)
-    /// </returns>
     static getEraNameLenInPicture(strPicture, intStartPos) {
         let intLetters = 0;
         for (let i = intStartPos; i < strPicture.length; i = i + 1) {
@@ -6016,15 +5009,6 @@ class UtilDateJpn {
         }
         return intLetters;
     }
-    /// <summary>
-    ///   Get the start year of an era in picture
-    /// </summary>
-    /// <param name = "strDate:">string of input strDate
-    /// </param>
-    /// <param name = "strPicture:">string of picture
-    /// </param>
-    /// <returns> start year of the era
-    /// </returns>
     getStartYearOfEra(strDate, strPicture) {
         let eraNameStrInDate = UtilDateJpn.getEraNameStrInDate(strDate, strPicture, 0);
         let result;
@@ -6043,13 +5027,7 @@ class UtilDateJpn {
         }
         return result;
     }
-    /// <summary> Add extra Gengo data into the Gengo tables</summary>
-    /// <param name="strExtraGengo:">
-    /// </param>
-    /// <returns>
-    /// </returns>
     addExtraGengo(strExtraGengo) {
-        // e.g. strExtraGengo = "2012/04/01,092,AaABCD;2013/04/01,091,WwWXYZ;"
         let strGengoInfo = strExtraGengo.split(';');
         for (let i = 0; i < strGengoInfo.length; i = i + 1) {
             if (strGengoInfo[i].length > 0) {
@@ -6057,13 +5035,13 @@ class UtilDateJpn {
                 if (strTok.length === 3 && strTok[0].length > 0 && strTok[1].length > 0 && strTok[2].length > 0) {
                     let strDate = strTok[0].split('/');
                     if (strDate.length === 3 && strDate[0].length > 0 && strDate[1].length > 0 && strDate[2].length > 0) {
-                        UtilDateJpn.GengoStr[MAX_GENGO + i][0] = strTok[2].substr(0, 1); // symbol name (upper case): A
-                        UtilDateJpn.GengoStr[MAX_GENGO + i][1] = strTok[2].substr(1, 1); // symbol name (lower case): a
-                        UtilDateJpn.GengoStr[MAX_GENGO + i][2] = strTok[2].substr(2); // gengo name: ABCD
-                        UtilDateJpn.StartDayOfGengo[MAX_GENGO + i][0] = NNumber.Parse(strDate[0]); // start year: 2012
-                        UtilDateJpn.StartDayOfGengo[MAX_GENGO + i][1] = NNumber.Parse(strDate[1]); // start month: 4
-                        UtilDateJpn.StartDayOfGengo[MAX_GENGO + i][2] = NNumber.Parse(strDate[2]); // start day: 1
-                        UtilDateJpn.StartDayOfGengo[MAX_GENGO + i][3] = NNumber.Parse(strTok[1]); // days since January 1: 92
+                        UtilDateJpn.GengoStr[MAX_GENGO + i][0] = strTok[2].substr(0, 1);
+                        UtilDateJpn.GengoStr[MAX_GENGO + i][1] = strTok[2].substr(1, 1);
+                        UtilDateJpn.GengoStr[MAX_GENGO + i][2] = strTok[2].substr(2);
+                        UtilDateJpn.StartDayOfGengo[MAX_GENGO + i][0] = NNumber.Parse(strDate[0]);
+                        UtilDateJpn.StartDayOfGengo[MAX_GENGO + i][1] = NNumber.Parse(strDate[1]);
+                        UtilDateJpn.StartDayOfGengo[MAX_GENGO + i][2] = NNumber.Parse(strDate[2]);
+                        UtilDateJpn.StartDayOfGengo[MAX_GENGO + i][3] = NNumber.Parse(strTok[1]);
                         this.MaxGengo++;
                     }
                 }
@@ -6101,70 +5079,42 @@ UtilDateJpn.StartDayOfGengo = [
     [0, 0, 0, 0]
 ];
 
-/// <summary>JPN: IME support
-/// Utility Class for Input Method Editor
-/// </summary>
-/// <author>  Toshiro Nakayoshi (MSJ)
-/// </author>
 class UtilImeJpn {
     constructor() {
         this.ImeAutoOff = false;
         this.StrImeRead = null;
     }
-    /// <summary> check if the IME mode is within valid range
-    /// </summary>
-    /// <param name="imeMode">(IME mode in Magic)
-    /// </param>
-    /// <returns> bool
-    /// </returns>
     isValid(imeMode) {
         return (0 <= imeMode && imeMode <= 9) || imeMode === 15 || imeMode === 10;
     }
-    /// <summary> convert the input method editor mode
-    /// </summary>
-    /// <param name="imeMode">(IME mode in Magic)
-    /// </param>
-    /// <returns> imeConvMode (IME conversion mode in imm32.lib)
-    /// </returns>
     static imeMode2imeConvMode(imeMode) {
         let result;
         switch (imeMode) {
-            // IME_ZEN_HIRAGANA_ROMAN
             case 1:
                 result = 25;
                 break;
-            // IME_ZEN_HIRAGANA
             case 2:
                 result = 9;
                 break;
-            // IME_ZEN_KATAKANA_ROMAN
             case 3:
                 result = 27;
                 break;
-            // IME_ZEN_KATAKANA
             case 4:
                 result = 11;
                 break;
-            // IME_HAN_KATAKANA_ROMAN
             case 5:
                 result = 19;
                 break;
-            // IME_HAN_KATAKANA
             case 6:
                 result = 3;
                 break;
-            // IME_ZEN_ALPHANUMERIC
             case 7:
                 result = 8;
                 break;
-            // IME_HAN_ALPHANUMERIC
             case 8:
             case 9:
                 result = 0;
                 break;
-            // case 0:
-            // case IME_DISABLE:
-            // case IME_FORCE_OFF:
             default:
                 result = 256;
                 break;
@@ -6180,28 +5130,17 @@ UtilImeJpn.IME_CMODE_ROMAN = 16;
 UtilImeJpn.IME_CMODE_NOCONVERSION = 256;
 UtilImeJpn.IME_NOT_INITIALIZED = -1;
 UtilImeJpn.IME_ZEN_HIRAGANA_ROMAN = 1;
-UtilImeJpn.IME_FORCE_OFF = 15; // if (ImeMode property == 0 and (picture has K0 or PIC_S)) or
-// (attribute is not alpha, unicode, nor blob), set IME_FORCE_OFF.
-UtilImeJpn.IME_DISABLE = 10; // to completely disable IME (even not allowing to change the mode)
+UtilImeJpn.IME_FORCE_OFF = 15;
+UtilImeJpn.IME_DISABLE = 10;
 
-/// <summary> a helper class for the parsing of the XML</summary>
 class XmlParser {
-    /// <summary>
-    ///
-    /// </summary>
-    /// <param name="data"></param>
     constructor(data = NString.Empty) {
         this._currIndex = 0;
         this._xmLdata = "";
-        this._history = new List(); // In order to allow recursive parsing we save prev data
+        this._history = new List();
         this.setXMLdata(data);
         this.setCurrIndex(0);
     }
-    /// <summary> parse a string according to a set of delimiters and return the result in a vector</summary>
-    /// <param name="str">the String which need be parted </param>
-    /// <param name="delimiter">the delimiter which part different parts of str </param>
-    /// <param name="isMagicXML">is needed tokenizer working on Magic XML, so the "=" sign will be delited in the end of every first token </param>
-    /// <returns> tmpVector dynamically array, which consist tokens in every element, every token is String </returns>
     static getTokens(str, delimiter, isMagicXML = true) {
         let tokensVec = new List();
         let token = null;
@@ -6210,22 +5149,17 @@ class XmlParser {
         }
         let strTok = str.split(delimiter.charAt(0));
         for (let i = 0; i < strTok.length; i = i + 1) {
-            // Split in C# creates a last empty string token if the source string ends with
-            // the delimiter or if the string is empty (as opposed to Java that will ignore it)
-            // therefore we have to break this loop if such case occurs.
             if (isMagicXML && i === strTok.length - 1 && strTok.length % 2 === 1) {
                 break;
             }
             token = strTok[i];
             if (isMagicXML) {
-                // the 1st token in the pair comes with "=", remove it.
                 if (i % 2 === 0) {
                     token = token.trim();
                     if (token.endsWith("=")) {
                         token = token.substr(0, token.length - 1);
                     }
                 }
-                // 2nd token in the pair can be an empty string, in that case set it to " ".
                 else if (token === "")
                     token = " ";
             }
@@ -6235,11 +5169,6 @@ class XmlParser {
         }
         return tokensVec;
     }
-    /// <summary>unscape from:
-    /// {"&amp;",\\, \q, \o, \l, \g, \e, \\r, \\n}, to:
-    /// {"&",     \,  ",  ',  <,  >,  =,  \r,  \n}
-    /// <param name="str">String to be converted</param>
-    /// <returns>unescaped string</returns>
     static unescape(str) {
         let unescapedString = new StringBuilder(str.length);
         for (let i = 0; i < str.length; i++) {
@@ -6276,11 +5205,6 @@ class XmlParser {
         }
         return (unescapedString.ToString());
     }
-    /// <summary>escape from:
-    /// {\,  ",  ',  <,   >,  =,  \r,  \n}, to:
-    /// {\\, \q, \0, \l,  \g, \e, \\r, \\n}
-    /// <param name="str">String to be converted</param>
-    /// <returns>escaped string</returns>
     static escape(str) {
         let escapedString = new StringBuilder(str.length * 2);
         for (let i = 0; i < str.length; i++) {
@@ -6316,23 +5240,15 @@ class XmlParser {
         }
         return (escapedString.ToString());
     }
-    /// <summary>
-    /// here we only need to take care of "&" so that Sax parser will be able to handle url
-    /// </summary>
-    /// <param name="str"></param>
-    /// <returns></returns>
     static escapeUrl(str) {
         return NString.Replace(str, "&", "&amp;");
     }
-    /// <summary>get next tag name from current index in XML string</summary>
-    /// <returns> next tag name </returns>
     getNextTag() {
         if (this._xmLdata.length - this._currIndex <= 1) {
-            return null; // end of XML string
+            return null;
         }
         for (let tmpIndx = this._currIndex + 1; tmpIndx < this._xmLdata.length; tmpIndx++) {
             let tmpChar = this._xmLdata[tmpIndx];
-            // a letter starts an element and ends with " ". "/" starts an element closing and ends with '>'.
             if (NChar.IsLetter(tmpChar) || tmpChar === '/') {
                 let endOfTag = NString.IndexOfAny(this._xmLdata, XmlParser.endOfNameChar, tmpIndx, this._xmLdata.length - tmpIndx);
                 if (endOfTag === -1)
@@ -6343,34 +5259,25 @@ class XmlParser {
         }
         return null;
     }
-    /// <summary>Substring of XMLstring</summary>
-    /// <returns> substring of XML string -from currIndex to endContext </returns>
     getXMLsubstring(endContext) {
         return this._xmLdata.substr(this._currIndex, endContext - this._currIndex);
     }
-    /// <summary>get current element value</summary>
-    /// <returns> element's value </returns>
     GetCurrentElementValue() {
         this.setCurrIndex2EndOfTag();
         let endContext = this.getXMLdata().indexOf(XMLConstants.TAG_OPEN, this.getCurrIndex());
-        // read value of xml element
         let value = this.getXMLsubstring(endContext);
         this.setCurrIndex2EndOfTag();
         return value;
     }
-    /// <summary>set current index (on parsing time) to the end of current tag</summary>
     setCurrIndex2EndOfTag() {
         this._currIndex = this._xmLdata.indexOf(XMLConstants.TAG_CLOSE, this._currIndex) + 1;
     }
-    /// <summary>get int from string at parsing time</summary>
     static getInt(valueStr) {
         return NNumber.Parse(valueStr.trim());
     }
-    /// <summary>get boolean from string at parsing time</summary>
     static getBoolean(valueStr) {
         return valueStr[0] === '1';
     }
-    /// <summary>get/set functions 4 XMLstring & currIndex, for parser</summary>
     getCurrIndex() {
         return this._currIndex;
     }
@@ -6391,81 +5298,46 @@ class XmlParser {
             this.setCurrIndex(0);
         }
     }
-    /// <summary>
-    /// prepare the parser to read from the newXmlString
-    /// </summary>
-    /// <param name="newXmlString"></param>
     PrepareFormReadString(newXmlString) {
         this.setXMLdata(newXmlString);
         this.setCurrIndex(0);
     }
-    /// <summary> push the current parsing information into the history stack</summary>
     push() {
         this._history.push(this._currIndex);
         this._history.push(this._xmLdata);
     }
-    /// <summary> restore the previous parsing information from the history stack</summary>
     pop() {
         let count = this._history.length;
         this._xmLdata = this._history.get_Item(count - 1);
         this._currIndex = this._history.get_Item(count - 2);
         this._history.SetSize(count - 2);
     }
-    /// <summary>gets a table cache xml and set the xmlparser data and index accordingly</summary>
     loadTableCacheData(data) {
         this.setXMLdata(data);
         this.setCurrIndex(0);
     }
-    /// <summary>
-    /// Reads the XML from the element at the current position until the end of
-    /// the element, returning the contents as a string. This allows deferring the
-    /// processing of an element until the time is right to do so.<br/>
-    /// The returned string contains the element tag itself. For example:<br/>
-    /// - Assuming that the current element is 'element1', with 2 'innerElement' elements, the
-    /// resulting string will look like this:<br/>
-    /// <element1>
-    ///   <innerelement/>
-    ///   <innerelement/>
-    /// </element1>
-    ///
-    /// This makes the result valid for processing by this XML parser.
-    /// </summary>
-    /// <returns></returns>
     ReadToEndOfCurrentElement() {
-        // Get the current tag according to the value of _currIndex.
         let currentTag = this.getNextTag();
         let currentTagIndex = this._xmLdata.indexOf(XMLConstants.TAG_OPEN + currentTag, this.getCurrIndex());
-        // Find the end of the element's block in the XML.
-        // find next open tag
         let nextOpenTagIndex = this._xmLdata.indexOf(XMLConstants.TAG_OPEN, currentTagIndex + 1);
         if (nextOpenTagIndex === -1)
             nextOpenTagIndex = this._xmLdata.length;
-        // find a close tag BEFORE the next open tag
         let elementEndIndex = NString.IndexOf(this._xmLdata, XMLConstants.TAG_TERM, this.getCurrIndex(), nextOpenTagIndex - this.getCurrIndex());
         if (elementEndIndex === -1)
-            // close tag was not found in range - we have inner elements, look for the full close tag
             elementEndIndex = this._xmLdata.indexOf("/" + currentTag, this.getCurrIndex()) + currentTag.length + XMLConstants.TAG_TERM.length;
         else
             elementEndIndex = elementEndIndex + XMLConstants.TAG_TERM.length;
-        // Copy the element data so it can be returned.
         let elementBlock = this.getXMLsubstring(elementEndIndex);
-        // Move the parser to the end of the element block.
         this.setCurrIndex(elementEndIndex);
         return elementBlock;
     }
     ReadContentOfCurrentElement() {
-        // Get the current tag according to the value of _currIndex.
         let currentTag = this.getNextTag();
-        // Find the end of the element's block in the XML.
         let elementEndIndex = this._xmLdata.indexOf("</" + currentTag + ">", this.getCurrIndex());
         if (elementEndIndex === -1)
-            // Can't find the end of the current element - either XML is faulty or the element is empty.
             return NString.Empty;
-        // Move to the end of the opening tag
         this.setCurrIndex2EndOfTag();
-        // Copy the content of the element (from the end of the opening tag to the beginning of the closing tag).
         let elementBlock = this.getXMLsubstring(elementEndIndex);
-        // Move the parser to the end of the element block.
         this.setCurrIndex(elementEndIndex);
         this.setCurrIndex2EndOfTag();
         return elementBlock;
@@ -6476,29 +5348,9 @@ class XmlParser {
         }
         return this.ToString_1(headCharCount, tailCharCount);
     }
-    /// <summary>
-    /// Generates a string that visualizes the XML parser state (e.g. for debug watch list.)<br/>
-    /// The method will show the XML data, trimming it to 20 characters before the
-    /// current position (_currIndex) and up to 50 characters after the current position.
-    /// The current position itself will be marked with a marker that looks like:
-    /// |-{current index}-| <br/>
-    /// The marker will be placed immediately before _xmlData[_currIndex].
-    /// </summary>
-    /// <returns></returns>
     ToString_0() {
         return this.toString(20, 50);
     }
-    /// <summary>
-    /// Generates a string that visualizes the XML parser state (e.g. for debug watch list.)<br/>
-    /// The method will show the XML data, trimming it to headCharCount characters before the
-    /// current position (_currIndex) and up to tailCharCount characters after the current position.
-    /// The current position itself will be marked with a marker that looks like:
-    /// |-{current index}-| <br/>
-    /// The marker will be placed immediately before _xmlData[_currIndex].
-    /// </summary>
-    /// <param name="headCharCount">Number of characters to show before the current position marker.</param>
-    /// <param name="tailCharCount">Number of characters to show after the current position marker.</param>
-    /// <returns></returns>
     ToString_1(headCharCount, tailCharCount) {
         let markerPosition = Math.min(this._currIndex, this._xmLdata.length);
         let segmentStartIndex = Math.max(0, markerPosition - headCharCount);
@@ -6526,9 +5378,5 @@ class XmlParser {
 }
 XmlParser.endOfNameChar = [' ', '>'];
 
-/**
- * Generated bundle index. Do not edit.
- */
-
 export { APGDisplayMode, APGFormSize, APGInvokedFrom, APGMode, APGOption, APGType, Access, AlignmentTypeHori, AlignmentTypeVert, AllowedDirectionType, Area, AutoFit, Axis, Base64, BindingLevel, BlobContent, BlockTypes, BorderType, BottomPositionInterval, BoxDir, BrkLevel, BrkScope, BrkType, CacheStrategy, CallComOption, CallOperationMode, CallOsShow, CallUDPType, CallUdpConvention, CallWsStyle, CallbackType, CharacterSet, CheckExist, CheckboxMainStyle, ChoiceControlStyle, ChoiceUtils, ColumnUpdateStyle, CompTypes, ComponentItemType, Constants, ControlStyle, CtrlButtonType, CtrlButtonTypeGui, CtrlHotspotType, CtrlImageStyle, CtrlLineDirection, CtrlLineType, CtrlOleDisplayType, CtrlOleStoreType, CtrlTextType, DBHCache, DBHRowIdentifier, DataTranslation, DataViewHeaderType, DataViewOperationType, DataViewOutputType, DatabaseDataType, DatabaseDefinitionType, DatabaseFilters, DatabaseOperations, DataviewType, DateTimeUtils, DateUtil, DbDelUpdMode, DbOpen, DbShare, DbhKeyDirection, DbhKeyIndexType, DbhKeyMode, DbhKeyRangeMode, DbhSegmentDirection, DefaultMsgDetails, DisplayTextType, DitAttribute, DitType, DriverDB, DspInterface, EndMode, EngineDirect, EnterAnimation, ErrStrategy, ErrorClassific, ExeState, ExecOn, ExitAnimation, ExportType, FieldComAlloc, FieldComType, FieldViewModelType, FldStorage, FldStyle, FlowDirection, FlwMode, ForceExit, FormDelimiter, FormExpandType, FormOperationType, FormPage, FrameLayoutTypes, GradientStyle, HTML_2_STR, HelpCommand, HelpType, HtmlAlignmentType, HttpStatusCode, ImageEffects, InitialMode, InternalInterface, ItemMasks, JSON_Utils, KeyMode, KeyboardReturnKeys, KeyboardTypes, LDir, LineDirection, LineManipulationType, ListboxSelectionMode, LnkEval_Cond, LnkMode, LoadedValues, LockingStrategy, LogType, Logger, Logger_LogLevels, Logger_MessageDirection, LogicHeaderAction, LogicHeaderType, LogicLevel, LogicOperationType, LogicUnit, MagicProperties, MediaAccess, MediaFormat, MediaOrientation, MediaType, MgControlType, MgModelType, Misc, ModelAttGuiFrame, ModelAttMerge, ModelAttRichClientFrameSet, ModelAttrBrowser, ModelAttrField, ModelAttrFramesetForm, ModelAttrGui0, ModelAttrGui1, ModelAttrHelp, ModelAttrRichClient, ModelAttrText, ModelClass, MsgInterface, NotifyCollectionChangedAction, NullArithmetic, OSEnvironment, OSType, OpenEditDialog, Opr, Order, OrientationLock, PICInterface, PaperSize, PaperSizePdfDisabled, PaperSizePdfEnabled, PositionUsage, PrgExecPlace, Priority, Queue, RaiseAt, Randomizer, RangeMode, RbAppearance, Recursion, RemarkType, RequestInfo, Resident, RowType, Rtf, Rtf_ACTN, Rtf_ErrorRtf, Rtf_IDEST, Rtf_IPFN, Rtf_IPROP, Rtf_KWD, Rtf_PROP, Rtf_PROPTYPE, Rtf_RDS, Rtf_RIS, Rtf_RtfChar, Rtf_SYMBOL, SEQ_2_HTML, SEQ_2_STR, ScrollBarThumbType, SelprgMode, SideType, SliderType, SourceContextType, SplitPrimaryDisplay, SplitWindowType, StartupMode, Storage, StorageAttribute, StorageAttributeCheck, StorageAttributeType, StrUtil, SubformType, SyncExecutionHelper, TabControlTabsWidth, TabbingCycleType, TabbingOrderType, TableBehaviour, TableType, TaskFlow, TransBegin, TransMode, TriggerType, TrueFalseValues, UndoRedoAction, UniqueTskSort, UpdateMode, UseSQLCursor, UtilDateJpn, UtilImeJpn, UtilStrByteMode, ValType, VeeDiffUpdate, VeeMode, VeePartOfDataview, VerifyButtons, VerifyDisplay, VerifyImage, VerifyMode, ViewRefreshMode, ViewSelectType, WinCptn, WinHtmlType, WinUom, WindowPosition, WindowType, XMLConstants, XmlParser, YesNoValues };
 //# sourceMappingURL=magic-xpa-utils.js.map