@magic-xpa/utils 4.1200.0-dev4120.34 → 4.1200.0-dev4120.35

package/fesm2022/magic-xpa-utils.mjs

@@ -1,33 +1,90 @@
 import { Encoding, StringBuilder, Hashtable, Stack, NChar, NNumber, NString, RefParam, isNullOrUndefined, DateTime, ISO_8859_1_Encoding, ApplicationException, Int32, Exception, List, Thread, Debug } from '@magic-xpa/mscorelib';
 import { parseString } from 'xml2js';
 
+/// <summary>JPN: DBCS support
+/// Utility Class for String
+/// In this class, considering DBCS, strings are counted by the number
+/// of bytes, not the number of characters.
+/// </summary>
+/// <author>  Toshiro Nakayoshi (MSJ) </author>
 class UtilStrByteMode {
     static Encoding = Encoding.UTF8;
+    // TODO : need to check what to do with CultureInfo
     static strNavigatorLang = window.navigator.language;
     static _bLocaleDefLangJPN = UtilStrByteMode.strNavigatorLang.startsWith('ja');
     static _bLocaleDefLangCHN = UtilStrByteMode.strNavigatorLang.startsWith('zh');
     static _bLocaleDefLangKOR = UtilStrByteMode.strNavigatorLang.startsWith('ko');
+    /// <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);
-    }
+        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>
     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;
-        let intValidMinIndex = -1;
-        let bHeadSpace = false;
-        let bEndSpace = false;
+        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 strRet;
+        // check and modify ofs & len
         if (len <= 0)
             return "";
         if (ofs <= 0) {
@@ -41,6 +98,7 @@ 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);
@@ -68,7 +126,9 @@ class UtilStrByteMode {
                 }
             }
         }
+        // prepare for substring
         let strbufAddingBuf = new StringBuilder(len);
+        // execute Mid
         if (bHeadSpace) {
             strbufAddingBuf.Append(' ');
         }
@@ -82,9 +142,39 @@ 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) {
@@ -96,6 +186,27 @@ 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;
@@ -122,6 +233,24 @@ 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;
@@ -153,16 +282,55 @@ 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) {
@@ -185,12 +353,33 @@ 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) {
@@ -205,6 +394,7 @@ 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(' ');
@@ -218,9 +408,18 @@ 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 {
@@ -230,18 +429,33 @@ 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 <= letter.charCodeAt(0) && letter.charCodeAt(0) <= 57;
-    }
+        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>
     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:
@@ -250,12 +464,47 @@ 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);
@@ -266,11 +515,23 @@ 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) {
@@ -280,6 +541,18 @@ 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);
@@ -300,19 +573,28 @@ class UtilStrByteMode {
     }
 }
 
+//@dynamic
 class Rtf_SYMBOL {
     szKeyword = null;
+    /* RTF keyword */
     kwd = null;
+    /* base action to take */
     idxInRgprop = null;
+    /* 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 = keyWord;
         this.kwd = kwd;
         this.idxInRgprop = idxInRgprop;
     }
 }
+// @dynamic
 class Rtf_PROP {
     actn = null;
+    /* size of value */
     prop = null;
+    /* structure containing value */
     constructor(actn, prop) {
         this.actn = actn;
         this.prop = prop;
@@ -359,6 +641,7 @@ 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";
@@ -395,6 +678,7 @@ 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";
@@ -414,6 +698,15 @@ 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 {
     static CR = String.fromCharCode(0x0d);
     static LF = String.fromCharCode(0x0A);
@@ -451,6 +744,7 @@ class Rtf {
     _codePageTable = new Hashtable();
     static RTF_PREFIX = "{\\rtf";
     static CHAR_PAR = "par";
+    /* Property descriptions */
     static 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),
@@ -468,6 +762,7 @@ class Rtf {
         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 */
     static 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),
@@ -514,6 +809,8 @@ class Rtf {
         new Rtf_SYMBOL("title", Rtf_KWD.DEST, Rtf_IDEST.SKIP), new Rtf_SYMBOL("txe", Rtf_KWD.DEST, Rtf_IDEST.SKIP),
         new Rtf_SYMBOL("xe", Rtf_KWD.DEST, Rtf_IDEST.SKIP)
     ];
+    /// <summary> Constructor
+    /// </summary>
     constructor() {
         this._stack = new Stack();
         this._group = 0;
@@ -529,6 +826,13 @@ 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)) {
@@ -536,6 +840,17 @@ 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;
@@ -561,6 +876,7 @@ 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;
@@ -583,16 +899,22 @@ class Rtf {
                             return ec;
                         break;
                     case Rtf_RtfChar.LF:
-                    case Rtf_RtfChar.CR:
+                    case Rtf_RtfChar.CR: /* cr and lf are noise characters... */
                         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;
@@ -606,6 +928,7 @@ class Rtf {
                             this._internalState = Rtf_RIS.NORM;
                         }
                         else {
+                            /* parsing hex data */
                             if (this._internalState !== Rtf_RIS.HEX)
                                 return Rtf_ErrorRtf.ASSERTION;
                             b = b << 4;
@@ -627,18 +950,22 @@ 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);
@@ -654,19 +981,36 @@ 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) {
@@ -674,14 +1018,28 @@ 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);
         }
@@ -690,6 +1048,11 @@ 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) {
@@ -702,6 +1065,11 @@ 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) {
@@ -712,6 +1080,15 @@ 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;
@@ -720,6 +1097,7 @@ 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);
@@ -741,6 +1119,13 @@ 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;
         }
@@ -751,22 +1136,37 @@ 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);
@@ -783,11 +1183,21 @@ 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) {
@@ -798,18 +1208,35 @@ 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;
@@ -863,6 +1290,15 @@ 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)
@@ -881,21 +1317,35 @@ class Rtf {
         }
         return ret;
     }
+    /// <summary> Create a hashtable of codepage associated with charset.
+    ///
+    /// </summary>
+    /// <param>
+    /// <returns>
+    /// </returns>
     setCodePageTable() {
-        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);
-    }
+        // 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>
     getCodePage(charset) {
         let codePage = 0;
         if (this._codePageTable.ContainsKey(charset)) {
@@ -903,6 +1353,13 @@ 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)) {
@@ -923,6 +1380,7 @@ const HTML_2_SEQ = 4;
 const SEQ_2_STR = 5;
 class StrUtil {
     static _paddingSpaces = null;
+    /// <summary> trim the end of the string</summary>
     static mem_trim(str, len) {
         let result;
         if (len > 0) {
@@ -957,6 +1415,15 @@ 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) {
@@ -983,6 +1450,14 @@ 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) {
@@ -1011,14 +1486,29 @@ 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) {
@@ -1027,7 +1517,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;
                 }
             }
@@ -1046,6 +1536,9 @@ 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;
@@ -1054,7 +1547,7 @@ class StrUtil {
             result = str;
         }
         else {
-            while (i < length && str[i] === ' ') {
+            while (i < length && str[i] === ' ' /*' '*/) {
                 i = i + 1;
             }
             if (i > 0) {
@@ -1064,6 +1557,16 @@ 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);
@@ -1080,6 +1583,11 @@ 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) {
@@ -1093,9 +1601,67 @@ 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) {
@@ -1114,6 +1680,11 @@ 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;
@@ -1134,6 +1705,11 @@ 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;
@@ -1158,6 +1734,14 @@ 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) {
@@ -1184,6 +1768,15 @@ 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;
@@ -1206,6 +1799,12 @@ 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 = [
             "\\", "-", ","
@@ -1239,6 +1838,11 @@ 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;
@@ -1248,6 +1852,12 @@ 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"
@@ -1257,6 +1867,12 @@ 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"
@@ -1266,10 +1882,21 @@ 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();
@@ -1279,6 +1906,12 @@ 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) {
@@ -1305,6 +1938,12 @@ 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;
@@ -1314,6 +1953,7 @@ 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)
@@ -1342,12 +1982,22 @@ 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("");
@@ -1362,11 +2012,32 @@ class StrUtil {
     }
 }
 
+// In order to convert some functionality to Visual C#, the Java Language Conversion Assistant
+// creates "support classes" that duplicate the original functionality.
+//
+// Support classes replicate the functionality of the original code, but in some cases they are
+// substantially different architecturally. Although every effort is made to preserve the
+// original architecture of the application in the converted project, the user should be aware that
+// the primary goal of these support classes is to replicate functionality, and that at times
+// the architecture of the resulting solution may differ somewhat.
+/// <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) {
@@ -1377,6 +2048,11 @@ 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) {
@@ -1387,6 +2063,11 @@ 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++) {
@@ -1398,6 +2079,13 @@ 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) {
@@ -1408,9 +2096,20 @@ 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) {
@@ -1430,6 +2129,11 @@ 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) {
@@ -1441,6 +2145,11 @@ 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)) {
@@ -1468,6 +2177,14 @@ class Base64 {
         else
             return Base64.encode_1(str, isUseEnvCharset, 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) {
@@ -1496,12 +2213,18 @@ 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 encodeBytes(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)];
@@ -1519,6 +2242,7 @@ class Base64 {
                 dest[didx++] = Base64._base64EncMap[data[sidx] << 4 & 63];
             }
         }
+        // add padding
         while (didx < dest.length) {
             dest[didx] = 61;
             didx = didx + 1;
@@ -1530,6 +2254,12 @@ class Base64 {
             encoding = null;
         return Base64.decode_1(str, encoding);
     }
+    /// <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) {
@@ -1558,6 +2288,11 @@ 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 decodeBytes(data) {
         if (data === null)
             return null;
@@ -1566,9 +2301,11 @@ 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) {
@@ -1583,6 +2320,7 @@ 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;
@@ -1590,9 +2328,13 @@ 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 {
@@ -1621,6 +2363,18 @@ class Base64 {
 }
 
 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");
@@ -1697,12 +2451,16 @@ class ChoiceUtils {
     }
 }
 
+//This class contains all the constants which are used in MgxpaRIA.exe as well as in MgGui.dll.
 class Constants {
+    /// <summary> Null Arithmetic values</summary>
     static NULL_ARITH_NULLIFY = 'N';
     static NULL_ARITH_USE_DEF = 'U';
+    /// <summary> select program : select mode property</summary>
     static SELPRG_MODE_BEFORE = 'B';
     static SELPRG_MODE_AFTER = 'A';
     static SELPRG_MODE_PROMPT = 'P';
+    /// <summary> move in View</summary>
     static MOVE_UNIT_TABLE = 'T';
     static MOVE_UNIT_PAGE = 'P';
     static MOVE_UNIT_ROW = 'R';
@@ -1716,6 +2474,7 @@ class Constants {
     static MOVE_DIRECTION_FIRST_SON = 'F';
     static MOVE_DIRECTION_NEXT_SIBLING = 'X';
     static MOVE_DIRECTION_PREV_SIBLING = 'V';
+    /// <summary> refresh types for a task form</summary>
     static TASK_REFRESH_FORM = 'F';
     static TASK_REFRESH_TABLE = 'T';
     static TASK_REFRESH_TREE_AND_FORM = 'R';
@@ -1726,12 +2485,15 @@ class Constants {
     static TASK_MODE_CREATE = 'C';
     static TASK_MODE_DELETE = 'D';
     static TASK_MODE_NONE = ' ';
+    /// <summary> task level</summary>
     static TASK_LEVEL_NONE = ' ';
     static TASK_LEVEL_TASK = 'T';
     static TASK_LEVEL_RECORD = 'R';
     static TASK_LEVEL_CONTROL = 'C';
+    /// <summary> special records constants</summary>
     static MG_DATAVIEW_FIRST_RECORD = Int32.MinValue;
     static MG_DATAVIEW_LAST_RECORD = Int32.MaxValue;
+    /// <summary> action states for keyboard mapping</summary>
     static ACT_STT_TBL_SCREEN_MODE = 0x0001;
     static ACT_STT_TBL_LEFT_TO_RIGHT = 0x0002;
     static ACT_STT_TBL_SCREEN_TOP = 0x0004;
@@ -1746,13 +2508,17 @@ class Constants {
     static ACT_STT_EDT_EDITING = 0x0800;
     static ACT_STT_TREE_PARK = 0x1000;
     static ACT_STT_TREE_EDITING = 0x2000;
-    static ForwardSlashWebUsage = "web";
+    static ForwardSlashWebUsage = "web"; // refer to a forward slash as a relative web url.
     static HTTP_PROTOCOL = "http://";
     static HTTPS_PROTOCOL = "https://";
     static FILE_PROTOCOL = "file://";
+    /// <summary>threads constants</summary>
     static MG_GUI_THREAD = "MG_GUI_THREAD";
     static MG_WORK_THREAD = "MG_WORK_THREAD";
     static MG_TIMER_THREAD = "MG_TIMER_THREAD";
+    /// <summary>
+    /// property name for the runtime designer
+    /// </summary>
     static ConfigurationFilePropertyName = "Configuration file";
     static WinPropText = "Text";
     static WinPropLayer = "Layer";
@@ -1786,9 +2552,12 @@ class XMLConstants {
     static MG_TAG_TASK = "task";
     static MG_TAG_TASK_END = "/task";
     static 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
     static MG_ATTR_VB_VIEW_ROWIDX = "db_view_rowidx";
     static MG_ATTR_CONTROL_ISN = "controlIsn";
     static MG_HOR_ALIGMENT_IS_INHERITED = "horizontalAlignmentIsFromSystemDefault";
+    // MainHeaders
     static MAX_PATH = 260;
     static FILE_NAME_SIZE = XMLConstants.MAX_PATH + 1;
     static CDATA_START = "<![CDATA[";
@@ -1874,11 +2643,13 @@ class XMLConstants {
     static MG_ATTR_IS_GUI_THREAD_EXECUTION = "isGuiThreadExecution";
     static MG_TAG_TASKDEFINITIONID_ENTRY = "taskDefinitionId";
     static MG_TAG_OBJECT_REFERENCE = "objectRef";
+    //Help types
     static MG_ATTR_HLP_TYP_TOOLTIP = "T";
     static MG_ATTR_HLP_TYP_PROMPT = "P";
     static MG_ATTR_HLP_TYP_URL = "U";
     static MG_ATTR_HLP_TYP_INTERNAL = "I";
     static MG_ATTR_HLP_TYP_WINDOWS = "W";
+    //Internal help attributes.
     static MG_ATTR_INTERNAL_HELP_TYPE = "type";
     static MG_ATTR_INTERNAL_HELP_NAME = "name";
     static MG_ATTR_INTERNAL_HELP_FRAMEX = "framex";
@@ -1893,20 +2664,26 @@ class XMLConstants {
     static MG_ATTR_INTERNAL_TITLE_BAR = "titlebar";
     static MG_ATTR_INTERNAL_HELP_SYSTEM_MENU = "sysmenu";
     static MG_ATTR_INTERNAL_HELP_FONT_TABLE_INDEX = "fonttableindex";
+    //Windows help attributes.
     static MG_ATTR_WINDOWS_HELP_FILE = "file";
     static MG_ATTR_WINDOWS_HELP_COMMAND = "command";
     static MG_ATTR_WINDOWS_HELP_KEY = "key";
+    //Print data attributes.
     static MG_TAG_PRINT_DATA = "Print_data";
     static MG_TAG_PRINT_DATA_END = "/Print_data";
     static MG_TAG_RECORD = "Record";
     static MG_TAG_RECORD_END = "/Record";
+    //Custom Validators  attributes.
     static MG_TAG_CUSTOM_VALIDATORS = "CustomValidators";
     static MG_TAG_CUSTOM_VALIDATORS_END = "/CustomValidators";
     static MG_TAG_CUSTOM_VALIDATOR = "CustomValidator";
+    // date/time formats for DateTimeUtils
+    //TODO: isolate to a different file?
     static ERROR_LOG_TIME_FORMAT = "HH:mm:ss.S";
     static ERROR_LOG_DATE_FORMAT = "DD/MM/YYYY";
     static HTTP_ERROR_TIME_FORMAT = "HH:mm:ss";
     static CACHED_DATE_TIME_FORMAT = "DD/MM/YYYY HH:mm:ss";
+    //webs constants
     static MG_TAG_WS_READ_REQUEST = "Read";
     static MG_TAG_WS_CREATE_REQUEST = "Create";
     static MG_TAG_WS_CREATE_REQUEST_END = "/Create";
@@ -1940,6 +2717,7 @@ class XMLConstants {
 }
 
 class DateTimeUtils {
+    /// <summary> returns the number in a 2 digit string
     static int2str(n) {
         return (n > 9) ? n.toString() : ("0" + n);
     }
@@ -1991,7 +2769,13 @@ class DateTimeUtils {
     }
 }
 
+/// <summary>
+///   An interface to define the constantes used by the Picture mechanism.
+/// </summary>
 class PICInterface {
+    //--------------------------------------------------------------------------
+    // TEMP!
+    //--------------------------------------------------------------------------
     static PIC_X = 1;
     static PIC_U = 2;
     static PIC_L = 3;
@@ -2009,30 +2793,32 @@ class PICInterface {
     static PIC_MMT = 15;
     static PIC_SS = 16;
     static PIC_PM = 17;
-    static PIC_HYYYYY = 18;
-    static PIC_HL = 19;
-    static PIC_HDD = 20;
-    static PIC_MS = 21;
-    static PIC_LOCAL = 23;
+    static PIC_HYYYYY = 18; // Hebrew year
+    static PIC_HL = 19; // Hebrew thousand year
+    static PIC_HDD = 20; // Hebrew day of month
+    static PIC_MS = 21; // Milliseconds
+    static PIC_LOCAL = 23; // the space between PIC_LOCAL and PIC_MAX_OP
     static PIC_MAX_MSK_LEN = 100;
-    static PIC_JY1 = PICInterface.PIC_LOCAL + 0;
-    static PIC_JY2 = PICInterface.PIC_LOCAL + 1;
-    static PIC_JY4 = PICInterface.PIC_LOCAL + 2;
-    static PIC_YJ = PICInterface.PIC_LOCAL + 3;
-    static PIC_BB = PICInterface.PIC_LOCAL + 4;
-    static PIC_J = PICInterface.PIC_LOCAL + 5;
-    static PIC_T = PICInterface.PIC_LOCAL + 6;
-    static PIC_G = PICInterface.PIC_LOCAL + 7;
-    static PIC_S = PICInterface.PIC_LOCAL + 8;
-    static PIC_MAX_OP = 31;
+    // JPN: Japanese date picture support
+    static PIC_JY1 = PICInterface.PIC_LOCAL + 0; // the name of an era (1 byte)
+    static PIC_JY2 = PICInterface.PIC_LOCAL + 1; // the name of an era (2 bytes)
+    static PIC_JY4 = PICInterface.PIC_LOCAL + 2; // the name of an era (4 bytes)
+    static PIC_YJ = PICInterface.PIC_LOCAL + 3; // a year of an era
+    static PIC_BB = PICInterface.PIC_LOCAL + 4; // a day of the week (2, 4 or 6 bytes)
+    // DBCS pictures for iSeries
+    static PIC_J = PICInterface.PIC_LOCAL + 5; // DBCS only (with SO/SI)
+    static PIC_T = PICInterface.PIC_LOCAL + 6; // All SBCS or All DBCS (with SO/SI)
+    static PIC_G = PICInterface.PIC_LOCAL + 7; // DBCS only (without SO/SI)
+    static PIC_S = PICInterface.PIC_LOCAL + 8; // SBCS only
+    static PIC_MAX_OP = 31; // is reserved for DLL"s picture
     static NULL_CHAR = -1;
     static DB_STR_MAX = 255;
-    static DAYSINFOURCENT = 146097;
-    static DAYSINCENTURY = 36524;
-    static DAYSINFOURYEAR = 1461;
+    static DAYSINFOURCENT = 146097; // ((365*4+1)*25-1)*4+1 */
+    static DAYSINCENTURY = 36524; // (365*4+1)*25-1 */
+    static DAYSINFOURYEAR = 1461; // 365*4+1 */
     static DAYSINYEAR = 365;
     static DAYSINMONTH = 31;
-    static DATE_BUDDHIST_GAP = 543;
+    static DATE_BUDDHIST_GAP = 543; // years above the gregorian date
     static DEFAULT_DATE = "693961";
     static DEFAULT_TIME = "0";
     static date_day_tab = [
@@ -2044,6 +2830,9 @@ class PICInterface {
     static 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
     static NumDirective = [
         4, 5, 6, 7, 9, 10, 11, 12, 14, 15, 16
     ];
@@ -2056,9 +2845,15 @@ const DATE_DOW_LEN = 10;
 class DateUtil {
     static _localMonths = new Array(13);
     static _localDays = new Array(8);
+    /// <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) {
@@ -2081,9 +2876,15 @@ 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) {
@@ -3871,6 +4672,7 @@ var NotifyCollectionChangedAction;
     NotifyCollectionChangedAction[NotifyCollectionChangedAction["Reset"] = 4] = "Reset";
 })(NotifyCollectionChangedAction || (NotifyCollectionChangedAction = {}));
 
+/// <summary> this interface defines the internal events codes</summary>
 class InternalInterface {
     static MG_ACT_NONE = 0;
     static MG_ACT_CHAR = 1;
@@ -4174,6 +4976,7 @@ class InternalInterface {
     static MG_ACT_CONTEXT_REMOVE = 647;
     static MG_ACT_DUMP_ENVIRONMENT = 653;
     static MG_ACT_TOT_CNT = 654;
+    // NEW INTERNAL EVENTS
     static MG_ACT_TASK_PREFIX = 1001;
     static MG_ACT_TASK_SUFFIX = 1002;
     static MG_ACT_REC_PREFIX = 1003;
@@ -4190,6 +4993,7 @@ class InternalInterface {
     static MG_ACT_CYCLE_NEXT_DELETE_REC = 1018;
     static MG_ACT_COMPUTE = 1020;
     static MG_ACT_DUMMY = 1111;
+    // INTERNAL EVENTS for WebClient
     static MG_ACT_CTRL_FOCUS = 2001;
     static MG_ACT_CTRL_MOUSEUP = 2002;
     static MG_ACT_CTRL_KEYDOWN = 2003;
@@ -4199,12 +5003,13 @@ class InternalInterface {
     static MG_ACT_ROW_DATA_CURR_PAGE = 2007;
     static MG_ACT_DV_TO_GUI = 2008;
     static MG_ACT_DISABLE_EVENTS = 2010;
+    // toggle insert is temp 539 , it should match the code in online once it will be created.
     static MG_ACT_TOGGLE_INSERT = 2011;
     static MG_ACT_INCREMENTAL_LOCATE = 2017;
     static MG_ACT_MOVE_TO_FIRST_CTRL = 2018;
     static MG_ACT_SET_EXTERNAL_VALUE = 2019;
     static MG_ACT_CTRL_FOCUS_ON_NON_MAGIC_CONTROL = 2020;
-    static MG_ACT_FETCH_RECORDS_AHEAD_FROM_SERVER = 2021;
+    static MG_ACT_FETCH_RECORDS_AHEAD_FROM_SERVER = 2021; // for paginated table, fetch records in background depending on PROP_TYPE_SERVER_READ_AHEAD
     static BuiltinEvent(eventCode) {
         return eventCode >= 1000 || eventCode === InternalInterface.MG_ACT_POST_REFRESH_BY_PARENT;
     }
@@ -4223,11 +5028,14 @@ class OSEnvironment {
     static TabSeq = "\t";
     static getStackTrace() {
         let ex = new Exception();
-        ex.errorLevel++;
+        ex.errorLevel++; // we need to remove the line which contains call to this method
         return ex.StackTrace;
     }
 }
 
+/// <summary>
+/// The class is responsible to maintain the Request information while sending a request to server
+/// </summary>
 class RequestInfo {
     serverCallAt;
     runtimeTaskTree = new List();
@@ -4261,9 +5069,16 @@ 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 {
     static instance = null;
-    LogLevel = 0;
+    LogLevel = 0; // InternalLogLevel
+    /// <summary>
+    /// While writing the error messages in the file play the beep.
+    /// </summary>
     ShouldBeep = false;
     static set Instance(value) {
         Logger.instance = value;
@@ -4274,10 +5089,26 @@ class Logger {
         }
         return Logger.instance;
     }
+    /// <summary>
+    /// Initialize logger
+    /// </summary>
+    /// <param name="logLevel"></param>
+    /// <param name="internalLogSync"></param>
     Initialize(logLevel, 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);
@@ -4301,6 +5132,9 @@ 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);
@@ -4316,16 +5150,26 @@ 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) {
@@ -4336,16 +5180,31 @@ 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;
@@ -4353,6 +5212,8 @@ 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");
@@ -4371,14 +5232,37 @@ 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() {
         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);
     }
@@ -4458,6 +5342,9 @@ class Logger {
         }
         this.WriteToLog(stringBuilder.ToString(), true);
     }
+    /// <summary>
+    /// Flush the log writer.
+    /// </summary>
     Flush() {
     }
     constructor() {
@@ -4670,11 +5557,14 @@ class MsgInterface {
     }
 }
 
+/// <summary> implementation of a general queue</summary>
 class Queue {
     _queueVec = null;
+    /// <summary> </summary>
     constructor() {
         this._queueVec = new List();
     }
+    /// <summary> returns the first object in the queue</summary>
     get() {
         let returnValue = null;
         if (this._queueVec.length > 0) {
@@ -4683,15 +5573,20 @@ 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;
     }
@@ -4731,7 +5626,15 @@ class Randomizer {
     }
 }
 
+/// <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));
     }
@@ -4741,18 +5644,36 @@ 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);
     }
@@ -4768,6 +5689,12 @@ 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) {
@@ -4814,22 +5741,39 @@ 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 {
     static _instance = null;
+    /// <summary>
+    /// get instance of SyncExecutionHelper
+    /// </summary>
     static get Instance() {
         if (SyncExecutionHelper._instance === null)
             SyncExecutionHelper._instance = new SyncExecutionHelper();
         return SyncExecutionHelper._instance;
     }
+    // resolver is caller when promise is fullfilled
     resolver = null;
+    /// <summary>
+    /// To wait, create a promise and add wait for it to complete
+    /// </summary>
     Wait() {
+        // Logger.Instance.WriteDevToLog("SyncExecutionHelper.Wait()");
         return new Promise((resolve) => {
             this.resolver = resolve;
         }).then();
     }
+    /// <summary>
+    /// To resume call the resolver
+    /// </summary>
     Pulse() {
         let resolver = this.resolver;
         if (resolver != null) {
+            // Logger.Instance.WriteDevToLog("SyncExecutionHelper.Pulse()");
             resolver();
         }
     }
@@ -4837,6 +5781,12 @@ class SyncExecutionHelper {
 
 const MAX_GENGO = 6;
 class UtilDateJpn {
+    /// <summary>
+    ///   JPN: Japanese date picture support
+    ///   Utility Class for Japanese date
+    /// </summary>
+    /// <author>  Toshiro Nakayoshi (MSJ)
+    /// </author>
     static _instance = null;
     static JweekStr = [
         "   ", "日曜日", "月曜日", "火曜日", "水曜日", "木曜日", "金曜日", "土曜日"
@@ -4862,10 +5812,11 @@ class UtilDateJpn {
         [1926, 12, 25, 359],
         [1989, 1, 8, 8],
         [2019, 5, 1, 121],
-        [0, 0, 0, 0],
+        [0, 0, 0, 0], // reserve for extra gengo x 3
         [0, 0, 0, 0],
         [0, 0, 0, 0]
     ];
+    // ---- gengo (the name of an era)  ---------------------------------------
     MaxGengo = MAX_GENGO;
     static getInstance() {
         if (UtilDateJpn._instance === null) {
@@ -4890,6 +5841,18 @@ 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) {
@@ -4907,6 +5870,20 @@ 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) {
@@ -4930,6 +5907,17 @@ 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) {
@@ -4968,6 +5956,17 @@ 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;
@@ -4986,6 +5985,7 @@ 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;
@@ -4997,10 +5997,19 @@ class UtilDateJpn {
                 }
             }
             result = strDate.substr(i, intLetters);
-            break;
+            break; // exit loop
         }
         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) {
@@ -5023,6 +6032,15 @@ 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;
@@ -5041,7 +6059,13 @@ 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) {
@@ -5049,13 +6073,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);
-                        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]);
+                        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
                         this.MaxGengo++;
                     }
                 }
@@ -5064,12 +6088,24 @@ class UtilDateJpn {
     }
 }
 
+/// <summary>JPN: IME support
+/// Utility Class for Input Method Editor
+/// </summary>
+/// <author>  Toshiro Nakayoshi (MSJ)
+/// </author>
 class UtilImeJpn {
     static IME_ZEN_HIRAGANA_ROMAN = 1;
-    static IME_FORCE_OFF = 15;
-    static IME_DISABLE = 10;
+    static 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.
+    static IME_DISABLE = 10; // to completely disable IME (even not allowing to change the mode)
     ImeAutoOff = false;
     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;
     }
@@ -5077,15 +6113,25 @@ class UtilImeJpn {
     }
 }
 
+/// <summary> a helper class for the parsing of the XML</summary>
 class XmlParser {
     static endOfNameChar = [' ', '>'];
     _currIndex = 0;
     _xmLdata = "";
-    _history = new List();
+    _history = new List(); // In order to allow recursive parsing we save prev data
+    /// <summary>
+    ///
+    /// </summary>
+    /// <param name="data"></param>
     constructor(data = NString.Empty) {
         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;
@@ -5094,17 +6140,22 @@ 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 = " ";
             }
@@ -5114,6 +6165,11 @@ 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++) {
@@ -5150,6 +6206,11 @@ 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++) {
@@ -5185,15 +6246,23 @@ 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;
+            return null; // end of XML string
         }
         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)
@@ -5204,25 +6273,34 @@ 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;
     }
@@ -5243,46 +6321,81 @@ 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;
@@ -5293,9 +6406,29 @@ 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);
@@ -5322,5 +6455,13 @@ class XmlParser {
     }
 }
 
+/**
+ * @file Automatically generated by barrelsby.
+ */
+
+/**
+ * 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.mjs.map