@magic-xpa/utils 4.801.0-dev481.242 → 4.801.0-dev481.248

package/esm2020/src/StrUtil.mjs

@@ -0,0 +1,456 @@
+import { NString, RefParam, StringBuilder, isNullOrUndefined } from "@magic-xpa/mscorelib";
+import { UtilStrByteMode } from "./UtilStrByteMode";
+import { Rtf } from "./Rtf";
+const HTML_BACKSLASH = "\";
+const HTML_COMMA = ",";
+const HTML_HYPHEN = "-";
+const STR_2_HTML = 1;
+const TASK_PATH_DELIMITER = "@@||@@";
+export const SEQ_2_HTML = 2;
+export const HTML_2_STR = 3;
+const HTML_2_SEQ = 4;
+export const SEQ_2_STR = 5;
+export class StrUtil {
+    static mem_trim(str, len) {
+        let result;
+        if (len > 0) {
+            if (len > str.length) {
+                result = -1;
+                return result;
+            }
+            while (len > 0 && str[len - 1] === ' ') {
+                len = len - 1;
+            }
+        }
+        result = len;
+        return result;
+    }
+    static memmove(dest, destCount, src, srcCount, len) {
+        let stringBuilder = new StringBuilder(dest.length + len);
+        if (UtilStrByteMode.isLocaleDefLangJPN() && dest.length < destCount) {
+            stringBuilder.Append(NString.FromChar(' ', destCount));
+        }
+        else {
+            stringBuilder.Append(dest.substr(0, destCount));
+        }
+        stringBuilder.Append(src.substr(srcCount, len));
+        if (stringBuilder.Length < dest.length) {
+            stringBuilder.Append(dest.substr(stringBuilder.Length));
+        }
+        return stringBuilder.ToString();
+    }
+    static memcpy(dest, destCount, src, scrCountOrSrcCount, count) {
+        if (arguments.length === 5 && (dest === null || dest.constructor === String) && (destCount === null || destCount.constructor === Number) && (src === null || src.constructor === String) && (scrCountOrSrcCount === null || scrCountOrSrcCount.constructor === Number) && (count === null || count.constructor === Number)) {
+            return StrUtil.memcpy_0(dest, destCount, src, scrCountOrSrcCount, count);
+        }
+        StrUtil.memcpy_1(dest, destCount, src, scrCountOrSrcCount, count);
+    }
+    static memcpy_0(dest, destCount, src, scrCount, count) {
+        let stringBuilder = new StringBuilder(dest.substr(0, destCount));
+        if (scrCount + count < src.length) {
+            stringBuilder.Append(src.substr(scrCount, count - scrCount));
+        }
+        else {
+            stringBuilder.Append(src.substr(scrCount));
+        }
+        let size = dest.length - destCount - count;
+        if (size > 0) {
+            stringBuilder.Append(dest.substr(destCount + count));
+        }
+        return stringBuilder.ToString();
+    }
+    static memcpy_1(dest, destCount, src, srcCount, count) {
+        while (count > 0 && destCount < dest.length && srcCount < src.length) {
+            dest[destCount++] = src[srcCount++];
+            count = count - 1;
+        }
+    }
+    static memset(dest, destCount, inVal, counter) {
+        if (arguments.length === 4 && (dest === null || dest.constructor === String) && (destCount === null || destCount.constructor === Number) && (inVal === null || inVal.constructor === Number) && (counter === null || counter.constructor === Number)) {
+            return StrUtil.memset_0(dest, destCount, inVal, counter);
+        }
+        StrUtil.memset_1(dest, destCount, inVal, counter);
+    }
+    static memset_0(dest, destCount, inVal, counter) {
+        let first = new StringBuilder(dest.substr(0, destCount));
+        while (counter > 0) {
+            first.Append(inVal);
+            counter = counter - 1;
+        }
+        if (first.Length < dest.length) {
+            first.Append(dest.substr(first.Length));
+        }
+        return first.ToString();
+    }
+    static memset_1(dest, destCount, inVal, counter) {
+        while (counter > 0 && destCount < dest.length) {
+            dest[destCount++] = inVal;
+            counter = counter - 1;
+        }
+    }
+    static strstr(str, substr) {
+        let from = str.indexOf(substr);
+        let result;
+        if (from < 0) {
+            result = null;
+        }
+        else {
+            result = str.substr(from);
+        }
+        return result;
+    }
+    static ReverseString(text) {
+        let array = NString.ToCharArray(text.ToString());
+        array.reverse();
+        return new StringBuilder(NString.FromChars(array));
+    }
+    static rtrim(str) {
+        return StrUtil.rtrimWithNull(str, false);
+    }
+    static rtrimWithNull(str, trimNullChars) {
+        let result;
+        if (typeof str === "undefined" || str === null || str.length === 0) {
+            result = str;
+        }
+        else {
+            let idx = str.length - 1;
+            if (trimNullChars) {
+                while (idx >= 0 && (str[idx] === ' ' || str[idx] === String.fromCharCode(0))) {
+                    idx = idx - 1;
+                }
+            }
+            else {
+                while (idx >= 0 && str[idx] === ' ') {
+                    idx = idx - 1;
+                }
+            }
+            idx = idx + 1;
+            if (idx < str.length) {
+                result = str.substr(0, idx);
+            }
+            else {
+                result = str;
+            }
+        }
+        return result;
+    }
+    static ltrim(str) {
+        let length = str.length;
+        let i = 0;
+        let result;
+        if (str === null || length === 0) {
+            result = str;
+        }
+        else {
+            while (i < length && str[i] === ' ') {
+                i = i + 1;
+            }
+            if (i > 0) {
+                str = str.substr(i);
+            }
+            result = str;
+        }
+        return result;
+    }
+    static DeleteStringsFromEnds(str, strToDelete) {
+        if (str.startsWith(strToDelete)) {
+            str = str.substr(strToDelete.length);
+        }
+        if (str.endsWith(strToDelete)) {
+            str = str.substr(0, str.length - strToDelete.length);
+        }
+        let result;
+        if (str.length === 0) {
+            result = null;
+        }
+        else {
+            result = str;
+        }
+        return result;
+    }
+    static padStr(str, len) {
+        let padLen = len - str.length;
+        if (padLen > 0) {
+            if (StrUtil._paddingSpaces === null || StrUtil._paddingSpaces.length < padLen) {
+                StrUtil._paddingSpaces = NString.FromChar(' ', padLen);
+            }
+            let stringBuilder = new StringBuilder(len);
+            stringBuilder.Append(str);
+            stringBuilder.Append(StrUtil._paddingSpaces, 0, padLen);
+            str = stringBuilder.ToString();
+        }
+        return str;
+    }
+    static tokenize(source, delim) {
+        return source.split(delim);
+    }
+    static stringToHexaDump(str, minLength) {
+        let stringBuilder = new StringBuilder(str.length * minLength);
+        for (let indx = 0; indx < str.length; indx = indx + 1) {
+            let currInt = str.charCodeAt(indx);
+            let hexStr = currInt.toString(16);
+            while (hexStr.length < minLength) {
+                hexStr = "0" + hexStr;
+            }
+            stringBuilder.Append(hexStr);
+        }
+        return stringBuilder.ToString().toUpperCase();
+    }
+    static searchAndReplace(str, from, to) {
+        if (arguments.length === 3 && (str === null || str.constructor === String) && (from === null || from.constructor === String) && (to === null || to.constructor === String)) {
+            return StrUtil.searchAndReplace_0(str, from, to);
+        }
+        return StrUtil.searchAndReplace_1(str, from, to);
+    }
+    static searchAndReplace_0(str, from, to) {
+        let lastSubStr = 0;
+        let startSubStr;
+        let result;
+        if ((startSubStr = str.indexOf(from)) === -1) {
+            result = str;
+        }
+        else {
+            let stringBuilder = new StringBuilder(str.length);
+            while (startSubStr !== -1) {
+                stringBuilder.Append(str.substr(lastSubStr, startSubStr - lastSubStr) + to);
+                startSubStr = startSubStr + from.length;
+                lastSubStr = startSubStr;
+                startSubStr = str.indexOf(from, lastSubStr);
+            }
+            stringBuilder.Append(str.substr(lastSubStr));
+            result = stringBuilder.ToString();
+        }
+        return result;
+    }
+    static searchAndReplace_1(str, from, to) {
+        let lastSubStr = 0;
+        let sarIndex = 0;
+        let fromCopy = from.slice();
+        let startSubStr;
+        let SARindex = new RefParam(0);
+        startSubStr = StrUtil.indexOf(str, fromCopy, lastSubStr, SARindex);
+        sarIndex = SARindex.value;
+        if (startSubStr === -1)
+            return str;
+        let result;
+        let tmpBuf = new StringBuilder(str.length);
+        while (startSubStr !== -1) {
+            tmpBuf.Append(str.substr(lastSubStr, startSubStr - lastSubStr) + to[sarIndex]);
+            startSubStr += fromCopy[sarIndex].length;
+            lastSubStr = startSubStr;
+            startSubStr = StrUtil.indexOf(str, fromCopy, lastSubStr, SARindex);
+            sarIndex = SARindex.value;
+        }
+        ;
+        tmpBuf.Append(str.substr(lastSubStr));
+        result = tmpBuf.ToString();
+        return result;
+    }
+    static indexOf(str, strings, offset, SARindex) {
+        let minOffset = -1;
+        for (let i = 0; i < strings.length; i = i + 1) {
+            let flag = strings[i] === null;
+            if (!(strings[i] === null)) {
+                let resultOffset = str.indexOf(strings[i], offset);
+                if (resultOffset === -1) {
+                    strings[i] = null;
+                }
+                else {
+                    if (resultOffset < minOffset || minOffset === -1) {
+                        minOffset = resultOffset;
+                        SARindex.value = i;
+                    }
+                }
+            }
+        }
+        let result;
+        if (minOffset > -1) {
+            result = minOffset;
+        }
+        else {
+            SARindex.value = -1;
+            result = -1;
+        }
+        return result;
+    }
+    static replaceStringTokens(userString, token, occurrence, val) {
+        let tokenLen = token.length;
+        let currPosition = 0;
+        let newString = userString;
+        if (val !== null) {
+            let num2 = 0;
+            while (num2 < occurrence && currPosition !== -1) {
+                currPosition = userString.indexOf(token, currPosition + ((num2 === 0) ? 0 : tokenLen));
+                num2 = num2 + 1;
+            }
+            if (currPosition !== -1) {
+                newString = userString.substr(0, currPosition) + val + userString.substr(currPosition + tokenLen, userString.length - (currPosition + tokenLen));
+            }
+        }
+        return newString;
+    }
+    static makePrintableTokens(source, type) {
+        if (arguments.length === 2 && (source === null || source.constructor === String) && (type === null || type.constructor === Number)) {
+            return StrUtil.makePrintableTokens_0(source, type);
+        }
+        StrUtil.makePrintableTokens_1(source, type);
+    }
+    static makePrintableTokens_0(source, type) {
+        let escStr = [
+            "\\", "-", ","
+        ];
+        let escSeq = [
+            "\\\\", "\\-", "\\,"
+        ];
+        let escHtm = [
+            HTML_BACKSLASH, HTML_HYPHEN, HTML_COMMA
+        ];
+        let result;
+        switch (type) {
+            case STR_2_HTML:
+                result = StrUtil.searchAndReplace(source, escStr, escHtm);
+                break;
+            case SEQ_2_HTML:
+                result = StrUtil.searchAndReplace(source, escSeq, escHtm);
+                break;
+            case HTML_2_SEQ:
+                result = StrUtil.searchAndReplace(source, escHtm, escSeq);
+                break;
+            case HTML_2_STR:
+                result = StrUtil.searchAndReplace(source, escHtm, escStr);
+                break;
+            case SEQ_2_STR:
+                result = StrUtil.searchAndReplace(source, escSeq, escStr);
+                break;
+            default:
+                result = source;
+                break;
+        }
+        return result;
+    }
+    static makePrintableTokens_1(source, type) {
+        if (source !== null) {
+            let length = source.length;
+            for (let i = 0; i < length; i = i + 1) {
+                let currElm = source.get_Item(i);
+                source.set_Item(i, StrUtil.makePrintableTokens_0(currElm, type));
+            }
+        }
+    }
+    static makePrintable(source) {
+        let from = [
+            "\n", "\r", "'", "\\", "\"", "\0"
+        ];
+        let to = [
+            "\\n", "\\r", "\\'", "\\\\", "\\\"", "\\0"
+        ];
+        return StrUtil.searchAndReplace(source, from, to);
+    }
+    static makePrintable2(source) {
+        let from = [
+            "\n", "\r", "\0"
+        ];
+        let to = [
+            "\\n", "\\r", "\\0"
+        ];
+        return StrUtil.searchAndReplace(source, from, to);
+    }
+    static ZstringMake(s, len) {
+        len = StrUtil.mem_trim(s, len);
+        return s.substr(0, len);
+    }
+    static GetPlainTextfromRtf(rtfText) {
+        if (Rtf.isRtf(rtfText)) {
+            let rtf = new Rtf();
+            let outputTxt = new StringBuilder("");
+            rtf.toTxt(rtfText, outputTxt);
+            rtfText = outputTxt.ToString();
+        }
+        return rtfText;
+    }
+    static StringsArraysEqual(str1, str2) {
+        let result;
+        if (str1 === null && str2 === null) {
+            result = true;
+        }
+        else {
+            if (str1 === null || str2 === null) {
+                result = false;
+            }
+            else {
+                if (str1.length !== str2.length) {
+                    result = false;
+                }
+                else {
+                    for (let index = 0; index < str1.length; index = index + 1) {
+                        if ((str1[index] !== str2[index])) {
+                            result = false;
+                            return result;
+                        }
+                    }
+                    result = true;
+                }
+            }
+        }
+        return result;
+    }
+    static SearchAndReplaceWildChars(buf, len, filler) {
+        buf = NString.PadRight(buf, len);
+        let escChar = false;
+        let stopSearch = false;
+        let tmpBuf = new StringBuilder(len);
+        for (let i = 0; i < len; i = i + 1) {
+            switch (buf[i]) {
+                case ('\\'):
+                    {
+                        let isNextCharWild = true;
+                        if ((i + 1 < len) && (buf[i + 1] != '*' && buf[i + 1] != '\\'))
+                            isNextCharWild = false;
+                        if (escChar || !isNextCharWild)
+                            tmpBuf.Append(buf[i]);
+                        escChar = !escChar;
+                    }
+                    break;
+                case ('*'):
+                    if (escChar)
+                        tmpBuf.Append(buf[i]);
+                    else {
+                        tmpBuf.Append(filler, len - tmpBuf.Length);
+                        stopSearch = true;
+                    }
+                    escChar = false;
+                    break;
+                case '?':
+                    tmpBuf.Append(filler);
+                    escChar = false;
+                    break;
+                default:
+                    tmpBuf.Append(buf[i]);
+                    escChar = false;
+                    break;
+            }
+        }
+        let text = tmpBuf.ToString();
+        return NString.TrimEnd(NString.TrimEnd(text, ['\0']));
+    }
+    static getConsoleErorString(source) {
+        let consoleErorString = "";
+        if (!isNullOrUndefined(source))
+            consoleErorString = this.searchAndReplace(source, TASK_PATH_DELIMITER, "");
+        return consoleErorString;
+    }
+    static getMsgBoxErorString(source) {
+        let tokens;
+        let msgBoxErorString = new StringBuilder("");
+        if (!isNullOrUndefined(source)) {
+            tokens = this.tokenize(source, TASK_PATH_DELIMITER);
+            for (let i = 0; i < tokens.length; i++) {
+                msgBoxErorString.Append(tokens[i]);
+                i++;
+            }
+        }
+        return msgBoxErorString.toString();
+    }
+}
+StrUtil._paddingSpaces = null;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"StrUtil.js","sourceRoot":"","sources":["../../../../../projects/utils/src/StrUtil.ts"],"names":[],"mappings":"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","sourcesContent":["import {List, NString, RefParam, StringBuilder, isNullOrUndefined} from \"@magic-xpa/mscorelib\";\r\nimport {UtilStrByteMode} from \"./UtilStrByteMode\";\r\nimport {Rtf} from \"./Rtf\";\r\n\r\nconst HTML_BACKSLASH: string = \"&#092;\";\r\nconst HTML_COMMA: string = \"&#044;\";\r\nconst HTML_HYPHEN: string = \"&#045;\";\r\nconst STR_2_HTML: number = 1;\r\nconst TASK_PATH_DELIMITER: string = \"@@||@@\";\r\nexport const SEQ_2_HTML: number = 2;\r\nexport const HTML_2_STR: number = 3;\r\nconst HTML_2_SEQ: number = 4;\r\nexport const SEQ_2_STR: number = 5;\r\n\r\nexport class StrUtil {\r\n  private static _paddingSpaces: string = null;\r\n\r\n  /// <summary> trim the end of the string</summary>\r\n  static mem_trim(str: string, len: number): number {\r\n    let result: number;\r\n    if (len > 0) {\r\n      if (len > str.length) {\r\n        result = -1;\r\n        return result;\r\n      }\r\n      while (len > 0 && str[len - 1] === ' ') {\r\n        len = len - 1;\r\n      }\r\n    }\r\n    result = len;\r\n    return result;\r\n  }\r\n\r\n  static memmove(dest: string, destCount: number, src: string, srcCount: number, len: number): string {\r\n    let stringBuilder: StringBuilder = new StringBuilder(dest.length + len);\r\n    if (UtilStrByteMode.isLocaleDefLangJPN() && dest.length < destCount) {\r\n      stringBuilder.Append(NString.FromChar(' ', destCount));\r\n    }\r\n    else {\r\n      stringBuilder.Append(dest.substr(0, destCount));\r\n    }\r\n    stringBuilder.Append(src.substr(srcCount, len));\r\n\r\n    if (stringBuilder.Length < dest.length) {\r\n        stringBuilder.Append(dest.substr(stringBuilder.Length));\r\n    }\r\n    return stringBuilder.ToString();\r\n  }\r\n\r\n  static memcpy(dest: string, destCount: number, src: string, scrCount: number, count: number): string;\r\n  static memcpy(dest: string[], destCount: number, src: string[], srcCount: number, count: number): void;\r\n  static memcpy(dest: any, destCount: number, src: any, scrCountOrSrcCount: number, count: number): string {\r\n    if (arguments.length === 5 && (dest === null || dest.constructor === String) && (destCount === null || destCount.constructor === Number) && (src === null || src.constructor === String) && (scrCountOrSrcCount === null || scrCountOrSrcCount.constructor === Number) && (count === null || count.constructor === Number)) {\r\n      return StrUtil.memcpy_0(dest, destCount, src, scrCountOrSrcCount, count);\r\n    }\r\n    StrUtil.memcpy_1(dest, destCount, src, scrCountOrSrcCount, count);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   copy part of string into another string, like memcpy of C, but 4 string only\r\n  /// </summary>\r\n  /// <param name = \"dest\">string</param>\r\n  /// <param name = \"destCount\">of counter start from in destignation string</param>\r\n  /// <param name = \"src\">string</param>\r\n  /// <param name = \"scrCount\">of counter start from in source string</param>\r\n  /// <param name = \"count\"></param>\r\n  /// <returns> new value of destignation string</returns>\r\n  private static memcpy_0(dest: string, destCount: number, src: string, scrCount: number, count: number): string {\r\n    let stringBuilder: StringBuilder = new StringBuilder(dest.substr(0, destCount));\r\n\r\n    if (scrCount + count < src.length) {\r\n      stringBuilder.Append(src.substr(scrCount, count - scrCount));\r\n    }\r\n    else {\r\n      stringBuilder.Append(src.substr(scrCount));\r\n    }\r\n    let size: number = dest.length - destCount - count;\r\n    if (size > 0) {\r\n      stringBuilder.Append(dest.substr(destCount + count));\r\n    }\r\n    return stringBuilder.ToString();\r\n  }\r\n\r\n  private static memcpy_1(dest: string[], destCount: number, src: string[], srcCount: number, count: number): void {\r\n    while (count > 0 && destCount < dest.length && srcCount < src.length) {\r\n      dest[destCount++] = src[srcCount++];\r\n      count = count - 1;\r\n    }\r\n  }\r\n\r\n  static memset(dest: string, destCount: number, inVal: string, counter: number): string;\r\n  static memset(dest: string[], destCount: number, inVal: string, counter: number): void;\r\n  static memset(dest: any, destCount: number, inVal: string, counter: number): string {\r\n    if (arguments.length === 4 && (dest === null || dest.constructor === String) && (destCount === null || destCount.constructor === Number) && (inVal === null || inVal.constructor === Number) && (counter === null || counter.constructor === Number)) {\r\n      return StrUtil.memset_0(dest, destCount, inVal, counter);\r\n    }\r\n    StrUtil.memset_1(dest, destCount, inVal, counter);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   insert to string chars n times\r\n  /// </summary>\r\n  /// <param name = \"dest\">string</param>\r\n  /// <param name = \"destCount\">of counter start from in destignation string to start insertion of char from</param>\r\n  /// <param name = \"inVal\">2 insert</param>\r\n  /// <param name = \"counter\">- number of times to insert the char</param>\r\n  /// <returns> new value of destignation string</returns>\r\n  private static memset_0(dest: string, destCount: number, inVal: string, counter: number): string {\r\n    let first: StringBuilder = new StringBuilder(dest.substr(0, destCount));\r\n    while (counter > 0) {\r\n      first.Append(inVal);\r\n      counter = counter - 1;\r\n    }\r\n\r\n    if (first.Length < dest.length) {\r\n      first.Append(dest.substr(first.Length));\r\n    }\r\n    return first.ToString();\r\n  }\r\n\r\n  private static memset_1(dest: string[], destCount: number, inVal: string, counter: number): void {\r\n    while (counter > 0 && destCount < dest.length) {\r\n      dest[destCount++] = inVal;\r\n      counter = counter - 1;\r\n    }\r\n  }\r\n\r\n  static strstr(str: string, substr: string): string {\r\n    let from: number = str.indexOf(substr);\r\n    let result: string;\r\n    if (from < 0) {\r\n      result = null;\r\n    }\r\n    else {\r\n      result = str.substr(from);\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /*******************************/\r\n  /// <summary>\r\n  /// Reverses string values.\r\n  /// </summary>\r\n  /// <param name=\"text\">The StringBuilder object containing the string to be reversed.</param>\r\n  /// <returns>The reversed string contained in a StringBuilder object.</returns>\r\n  static ReverseString(text: StringBuilder): StringBuilder {\r\n    // TODO: use string.Reverse()\r\n    let array: string[] = NString.ToCharArray(text.ToString());\r\n    array.reverse();\r\n    return new StringBuilder(NString.FromChars(array));\r\n  }\r\n\r\n  /// <summary> remove spaces from the right side of string</summary>\r\n  /// <param name=\"str\">the string to trim\r\n  /// </param>\r\n  static rtrim(str: string): string {\r\n    return StrUtil.rtrimWithNull(str, false);\r\n  }\r\n\r\n  /// <summary> remove spaces and/or Null chars from the right side of string</summary>\r\n  /// <param name=\"str\">the string to trim\r\n  /// </param>\r\n  /// <param name=\"trimNullChars\">Whether to remove NULL characters or not\r\n  /// </param>\r\n  static rtrimWithNull(str: string, trimNullChars: boolean): string {\r\n    let result: string;\r\n    if (typeof str === \"undefined\" || str === null || str.length === 0) {\r\n      result = str;\r\n    }\r\n    else {\r\n      let idx: number = str.length - 1;\r\n      if (trimNullChars) {\r\n\r\n        while (idx >= 0 && (str[idx] === ' ' || str[idx] === String.fromCharCode(0)/*'\u0000'*/)) {\r\n          idx = idx - 1;\r\n        }\r\n      }\r\n      else {\r\n        while (idx >= 0 && str[idx] === ' ') {\r\n          idx = idx - 1;\r\n        }\r\n      }\r\n      idx = idx + 1;\r\n\r\n      if (idx < str.length) {\r\n        result = str.substr(0, idx);\r\n      }\r\n      else {\r\n        result = str;\r\n      }\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /// <summary> remove spaces from the left side of string</summary>\r\n  /// <param name=\"str\">the string to trim\r\n  /// </param>\r\n  static ltrim(str: string): string {\r\n    let length: number = str.length;\r\n    let i: number = 0;\r\n    let result: string;\r\n    if (str === null || length === 0) {\r\n      result = str;\r\n    }\r\n    else {\r\n      while (i < length && str[i] === ' '/*' '*/) {\r\n        i = i + 1;\r\n      }\r\n\r\n      if (i > 0) {\r\n        str = str.substr(i);\r\n      }\r\n      result = str;\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /// <summary>This function for Deleting String from end & start of input\r\n  /// String\r\n  /// </summary>\r\n  /// <param name=\"str\">String , which can include strToDelete spaces on input\r\n  /// </param>\r\n  /// <param name=\"strToDelete\">need delete this String from start/end of str.\r\n  /// </param>\r\n  /// <returns> String without strToDelete on end & start,\r\n  /// or 'null' if Sting hasn't not  characters inside\r\n  /// </returns>\r\n  static DeleteStringsFromEnds(str: string, strToDelete: string): string {\r\n    if (str.startsWith(strToDelete)) {\r\n      str = str.substr(strToDelete.length);\r\n    }\r\n    if (str.endsWith(strToDelete)) {\r\n      str = str.substr(0, str.length - strToDelete.length);\r\n    }\r\n    let result: string;\r\n    if (str.length === 0) {\r\n      result = null;\r\n    }\r\n    else {\r\n      result = str;\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /// <summary> pad a string with trailing spaces up to the given length</summary>\r\n  /// <param name=\"str\">the string to pad\r\n  /// </param>\r\n  /// <param name=\"len\">the expected length after padding\r\n  /// </param>\r\n  static padStr(str: string, len: number): string {\r\n    let padLen: number = len - str.length;\r\n\r\n    if (padLen > 0) {\r\n      if (StrUtil._paddingSpaces === null || StrUtil._paddingSpaces.length < padLen) {\r\n        StrUtil._paddingSpaces = NString.FromChar(' ', padLen);\r\n      }\r\n      let stringBuilder: StringBuilder = new StringBuilder(len);\r\n      stringBuilder.Append(str);\r\n      stringBuilder.Append(StrUtil._paddingSpaces, 0, padLen);\r\n      str = stringBuilder.ToString();\r\n    }\r\n    return str;\r\n  }\r\n\r\n  /// <summary> this method will serve as a string tokenizer instead of using the c# split method\r\n  /// since there are diffrences btween java tokenizer and c# split\r\n  /// the implimentation given by the conversion tool is not Sufficient\r\n  /// </summary>\r\n  /// <param name=\"source\">- the source string to be converted\r\n  /// </param>\r\n  /// <param name=\"delim\">- the string of delimiters used to split the string (each character in the String is a delimiter\r\n  /// </param>\r\n  /// <returns> array of token according which is the same as string tokenizer in java\r\n  /// </returns>\r\n  static tokenize(source: string, delim: string|RegExp): string[] {\r\n    // It is mentioned in the comment that we should not use String.Split()\r\n    // because its behavior is different than Java's tokenizer.\r\n    // So, we were suppose to use our own implementation (the commented code below).\r\n    // But all these years, we were calling XmlParser.getToken() which was actually\r\n    // using String.Split(). And we didn't face any problem.\r\n    // So, it seems that we do not have problem in using String.Split().\r\n    // But now, we can improve the performance here...\r\n    // XmlParser.getTokens() was getting a String[] using String.Split().\r\n    // It was then creating a List<String> from this String[] and was returning it to\r\n    // tokenize().\r\n    // tokenize() was again converting this List<String> back to String[].\r\n    // So why not call String.Split() directly?\r\n    return source.split(delim);\r\n    /*\r\nString [] tokens = null;\r\n\r\nchar [] delimArry = delim.toCharArray();\r\n\r\n//since java discards delimiters from the start and end of the string and c# does not\r\n//we need to remove them manually\r\n//       source = source.TrimEnd(delimArry);\r\n//     source = source.TrimStart(delimArry);\r\nsource = source.trim();\r\n\r\n//now that we have remove starting and ending delimiters we can split\r\ntokens = source.Split(delimArry);\r\n\r\n/*\r\n* only one problem: if we have two Subsequent delimiters for example :\r\n* the delimiter is ';' and the string is: \"first;;second;third\"\r\n* then in java String tokenizer will give us only 3 tokens :first,second and third\r\n* while is c# split wethod will return 4 tokens: first,empty string,second and third\r\n* we need to deal with that\r\n*/\r\n    /*\r\n    List res  = new List();\r\n    for (int i = 0 ; i < tokens.length; i++)\r\n    {\r\n    if (tokens[i] != \"\" )\r\n    res.addItem(tokens[i]);\r\n    }\r\n\r\n    return (String [])(res.getAllItems (String.class));*/\r\n\r\n\r\n  }\r\n\r\n  /// <summary>\r\n  ///   translate from string to hexa dump char by char\r\n  /// </summary>\r\n  /// <param name = \"string\">to translate it to the byte stream</param>\r\n  /// <param name = \"minLength\">the minimal length of hexa digits for each char</param>\r\n  /// <returns> the byte stream in form of string</returns>\r\n  static stringToHexaDump(str: string, minLength: number): string {\r\n    let stringBuilder: StringBuilder = new StringBuilder(str.length * minLength);\r\n    for (let indx: number = 0; indx < str.length; indx = indx + 1) {\r\n      let currInt: number = str.charCodeAt(indx);\r\n      let hexStr: string = currInt.toString(16);\r\n      while (hexStr.length < minLength) {\r\n        hexStr = \"0\" + hexStr;\r\n      }\r\n      stringBuilder.Append(hexStr);\r\n    }\r\n    return stringBuilder.ToString().toUpperCase();\r\n  }\r\n\r\n  static searchAndReplace(str: string, from: string, to: string): string;\r\n  static searchAndReplace(str: string, from: string[], to: string[]): string;\r\n  static searchAndReplace(str: string, from: any, to: any): string {\r\n    if (arguments.length === 3 && (str === null || str.constructor === String) && (from === null || from.constructor === String) && (to === null || to.constructor === String)) {\r\n      return StrUtil.searchAndReplace_0(str, from, to);\r\n    }\r\n    return StrUtil.searchAndReplace_1(str, from, to);\r\n  }\r\n\r\n  /// <summary> replace every appearance of 'from' in 'str' with 'to'</summary>\r\n  /// <param name=\"str\">the working base source string </param>\r\n  /// <param name=\"from\">the string to replace </param>\r\n  /// <param name=\"to\">the string use instead 'from' </param>\r\n  /// <returns> modified String </returns>\r\n  private static searchAndReplace_0(str: string, from: string, to: string): string {\r\n    let lastSubStr: number = 0;\r\n    let startSubStr: number;\r\n    let result: string;\r\n\r\n    if ((startSubStr = str.indexOf(from)) === -1) {\r\n      result = str;\r\n    }\r\n    else {\r\n      let stringBuilder: StringBuilder = new StringBuilder(str.length);\r\n      while (startSubStr !== -1) {\r\n        stringBuilder.Append(str.substr(lastSubStr, startSubStr - lastSubStr) + to);\r\n        startSubStr = startSubStr + from.length;\r\n        lastSubStr = startSubStr;\r\n        startSubStr = str.indexOf(from, lastSubStr);\r\n      }\r\n      stringBuilder.Append(str.substr(lastSubStr));\r\n      result = stringBuilder.ToString();\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /// <summary> replace every appearance of strings of 'from' in 'str' with the according string in 'to'</summary>\r\n  /// <param name=\"str\">the working base source string </param>\r\n  /// <param name=\"from\">the string to replace </param>\r\n  /// <param name=\"to\">the string use instead 'from' </param>\r\n  /// <returns> modified String </returns>\r\n  private static searchAndReplace_1(str: string, from: string[], to: string[]): string {\r\n    let lastSubStr: number = 0;\r\n    let sarIndex: number = 0;\r\n    let fromCopy: string[] = from.slice();\r\n    let startSubStr: number;\r\n    let SARindex: RefParam<number> = new RefParam(0);\r\n    startSubStr = StrUtil.indexOf(str, fromCopy, lastSubStr, SARindex);\r\n    sarIndex = SARindex.value;\r\n    if (startSubStr === -1)\r\n      return str;\r\n\r\n    let result: string;\r\n    let tmpBuf: StringBuilder = new StringBuilder(str.length);\r\n    while (startSubStr !== -1) {\r\n      tmpBuf.Append(str.substr(lastSubStr, startSubStr - lastSubStr) + to[sarIndex]);\r\n      startSubStr += fromCopy[sarIndex].length;\r\n      lastSubStr = startSubStr;\r\n      startSubStr = StrUtil.indexOf(str, fromCopy, lastSubStr, SARindex);\r\n      sarIndex = SARindex.value;\r\n      };\r\n    tmpBuf.Append(str.substr(lastSubStr));\r\n    result = tmpBuf.ToString();\r\n\r\n    return result;\r\n  }\r\n\r\n  /// <summary> this functions is for use by the searchAndReplace() function -\r\n  /// searches the offset of the strings from the array in the given string\r\n  /// and returns the minimum offset found and sets the index of the found string\r\n  /// to SARindex\r\n  /// </summary>\r\n  /// <param name=\"str\">the string to search in </param>\r\n  /// <param name=\"strings\">an array of strings to search for </param>\r\n  /// <param name=\"offset\">where to start the search </param>\r\n  private static indexOf(str: string, strings: string[], offset: number, SARindex: RefParam<number>): number {\r\n    let minOffset: number = -1;\r\n    for (let i: number = 0; i < strings.length; i = i + 1) {\r\n      let flag: boolean = strings[i] === null;\r\n      if (!(strings[i] === null)) {\r\n        let resultOffset: number = str.indexOf(strings[i], offset);\r\n\r\n        if (resultOffset === -1) {\r\n          strings[i] = null;\r\n        }\r\n        else {\r\n          if (resultOffset < minOffset || minOffset === -1) {\r\n            minOffset = resultOffset;\r\n            SARindex.value = i;\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    let result: number;\r\n    if (minOffset > -1) {\r\n      result = minOffset;\r\n    }\r\n    else {\r\n      SARindex.value = -1;\r\n      result = -1;\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /// <summary> replace tokens in user string by vector values </summary>\r\n  /// <param name=\"userString\">- user buffer like \"User %d, %d string\"\r\n  /// </param>\r\n  /// <param name=\"token\">- token used in user string - i.e. \"%d\"\r\n  /// </param>\r\n  /// <param name=\"occurrence\">- number of token where replace will take part (1 for first occurrence)\r\n  /// </param>\r\n  /// <param name=\"value\">- value to be inserted insted of token\r\n  /// </param>\r\n  static replaceStringTokens(userString: string, token: string, occurrence: number, val: string): string {\r\n    let tokenLen: number = token.length;\r\n    let currPosition: number = 0;\r\n    let newString: string = userString;\r\n\r\n    if (val !== null) {\r\n      let num2: number = 0;\r\n      while (num2 < occurrence && currPosition !== -1) {\r\n        currPosition = userString.indexOf(token, currPosition + ((num2 === 0) ? 0 : tokenLen));\r\n        num2 = num2 + 1;\r\n      }\r\n\r\n      if (currPosition !== -1) {\r\n        newString = userString.substr(0, currPosition) + val + userString.substr(currPosition + tokenLen, userString.length - (currPosition + tokenLen));\r\n      }\r\n    }\r\n    return newString;\r\n  }\r\n\r\n  static makePrintableTokens(source: string, type: string): string;\r\n  static makePrintableTokens(source: string, type: number): string;\r\n  static makePrintableTokens(source: List<string>, type: number): string;\r\n  static makePrintableTokens(source: any, type: any): string | void{\r\n    if (arguments.length === 2 && (source === null || source.constructor === String) && (type === null || type.constructor === Number)) {\r\n      return StrUtil.makePrintableTokens_0(source, type);\r\n    }\r\n    StrUtil.makePrintableTokens_1(source, type);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   converts special characters in a token to a printable format\r\n  /// </summary>\r\n  /// <param name = \"source\">a token </param>\r\n  /// <param name = \"type\">type of conversion: STR_2_HTML, SEQ_2_HTML, HTML_2_SEQ, HTML_2_STR, SEQ_2_STR </param>\r\n  /// <returns> token with converted special characters </returns>\r\n  static makePrintableTokens_0(source: string, type: number): string {\r\n    let escStr: string[] = [\r\n      \"\\\\\", \"-\", \",\"\r\n    ];\r\n    let escSeq: string[] = [\r\n      \"\\\\\\\\\", \"\\\\-\", \"\\\\,\"\r\n    ];\r\n    let escHtm: string[] = [\r\n      HTML_BACKSLASH, HTML_HYPHEN, HTML_COMMA\r\n    ];\r\n    let result: string;\r\n    switch (type) {\r\n      case STR_2_HTML:\r\n        result = StrUtil.searchAndReplace(source, escStr, escHtm);\r\n        break;\r\n      case SEQ_2_HTML:\r\n        result = StrUtil.searchAndReplace(source, escSeq, escHtm);\r\n        break;\r\n      case HTML_2_SEQ:\r\n        result = StrUtil.searchAndReplace(source, escHtm, escSeq);\r\n        break;\r\n      case HTML_2_STR:\r\n        result = StrUtil.searchAndReplace(source, escHtm, escStr);\r\n        break;\r\n      case SEQ_2_STR:\r\n        result = StrUtil.searchAndReplace(source, escSeq, escStr);\r\n        break;\r\n      default:\r\n        result = source;\r\n        break;\r\n    }\r\n\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   converts special characters in a tokens collection to a printable format\r\n  /// </summary>\r\n  /// <param name = \"source\">vector of strings before tokenaizer </param>\r\n  /// <param name = \"type\">type of conversion: STR_2_HTML, SEQ_2_HTML, HTML_2_SEQ, HTML_2_STR </param>\r\n  private static makePrintableTokens_1(source: List<string>, type: number): void {\r\n    if (source !== null) {\r\n      let length: number = source.length;\r\n      for (let i: number = 0; i < length; i = i + 1) {\r\n        let currElm: string = source.get_Item(i);\r\n        source.set_Item(i, StrUtil.makePrintableTokens_0(currElm, type));\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   change non-printable characters like \"new line\" and \"line feed\" to their\r\n  ///   printable representation\r\n  /// </summary>\r\n  /// <param name = \"source\">is the string with non-printable characters </param>\r\n  /// <returns> the new string where all the non-printable characters are converted </returns>\r\n  static makePrintable(source: string): string {\r\n    let from: string[] = [\r\n      \"\\n\", \"\\r\", \"'\", \"\\\\\", \"\\\"\", \"\\0\"\r\n    ];\r\n    let to: string[] = [\r\n      \"\\\\n\", \"\\\\r\", \"\\\\'\", \"\\\\\\\\\", \"\\\\\\\"\", \"\\\\0\"\r\n    ];\r\n    return StrUtil.searchAndReplace(source, from, to);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   change non-printable characters like \"new line\" and \"line feed\" to their\r\n  ///   printable representation (simplified version for range error message)\r\n  /// </summary>\r\n  /// <param name = \"source\">is the string with non-printable characters </param>\r\n  /// <returns> the new string where all the non-printable characters are converted </returns>\r\n  static makePrintable2(source: string): string {\r\n    let from: string[] = [\r\n      \"\\n\", \"\\r\", \"\\0\"\r\n    ];\r\n    let to: string[] = [\r\n      \"\\\\n\", \"\\\\r\", \"\\\\0\"\r\n    ];\r\n    return StrUtil.searchAndReplace(source, from, to);\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <param name=\"s\"></param>\r\n  /// <param name=\"len\"></param>\r\n  /// <returns></returns>\r\n  static ZstringMake(s: string, len: number): string {\r\n    len = StrUtil.mem_trim(s, len);\r\n    return s.substr(0, len);\r\n  }\r\n\r\n  /// <summary>(public)\r\n  /// returns plain text from rtf text\r\n  /// </summary>\r\n  /// <param name=\"rtfText\">refer to the summary</param>\r\n  /// <returns>refer to the summary</returns>\r\n  static GetPlainTextfromRtf(rtfText: string): string {\r\n    if (Rtf.isRtf(rtfText)) {\r\n      let rtf: Rtf = new Rtf();\r\n      let outputTxt: StringBuilder = new StringBuilder(\"\");\r\n      rtf.toTxt(rtfText, outputTxt);\r\n      rtfText = outputTxt.ToString();\r\n    }\r\n    return rtfText;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Returns true if the string arrays str1 & str2 are equal\r\n  /// </summary>\r\n  /// <param name=\"str1\"></param>\r\n  /// <param name=\"str2\"></param>\r\n  /// <returns></returns>\r\n  static StringsArraysEqual(str1: string[], str2: string[]): boolean {\r\n    let result: boolean;\r\n    if (str1 === null && str2 === null) {\r\n      result = true;\r\n    }\r\n    else {\r\n      if (str1 === null || str2 === null) {\r\n        result = false;\r\n      }\r\n      else {\r\n        if (str1.length !== str2.length) {\r\n          result = false;\r\n        }\r\n        else {\r\n          for (let index: number = 0; index < <number>str1.length; index = index + 1) {\r\n            if ((str1[index] !== str2[index])) {\r\n              result = false;\r\n              return result;\r\n            }\r\n          }\r\n          result = true;\r\n        }\r\n      }\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  /// The code is copied from tsk_open_bnd_wild and SearchAndReplaceWildChars\r\n  /// The refactoring is not performed for backwards compatibility\r\n  /// The code replaces special charachters :* ? with recieved filler\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  static SearchAndReplaceWildChars(buf: string, len: number, filler: string): string {\r\n    buf = NString.PadRight(buf, len);\r\n\r\n    let escChar: boolean = false;\r\n    let stopSearch: boolean = false;\r\n    let tmpBuf: StringBuilder = new StringBuilder(len);\r\n    for (let i: number = 0; i < len; i = i + 1) {\r\n      switch (buf[i]) {\r\n        case ('\\\\'): {\r\n          let isNextCharWild: boolean = true;\r\n\r\n          //If next char is not wild , then copy '\\', if this is first char.\r\n          if ((i + 1 < len) && (buf[i + 1] != '*' && buf[i + 1] != '\\\\'))\r\n            isNextCharWild = false;\r\n          if (escChar || !isNextCharWild)\r\n            tmpBuf.Append(buf[i]);\r\n          escChar = !escChar;\r\n        }\r\n          break;\r\n        case ('*'):\r\n          if (escChar)\r\n            tmpBuf.Append(buf[i]);\r\n          else {\r\n            tmpBuf.Append(filler, len - tmpBuf.Length);\r\n            stopSearch = true;\r\n          }\r\n          escChar = false;\r\n          break;\r\n        case '?':\r\n          tmpBuf.Append(filler);\r\n          escChar = false;\r\n          break;\r\n        default:\r\n          tmpBuf.Append(buf[i]);\r\n          escChar = false;\r\n          break;\r\n      }\r\n    }\r\n\r\n    let text: string = tmpBuf.ToString();\r\n    return NString.TrimEnd(NString.TrimEnd(text, ['\\0']));\r\n  }\r\n\r\n  /// <summary>\r\n  /// Remove the task path delimiter from the error string.\r\n  /// </summary>\r\n  /// <param name = \"source\">string with delimiter </param>\r\n  /// <returns> string for console error </returns>\r\n  static getConsoleErorString(source: string): string {\r\n    let consoleErorString: string = \"\";\r\n\r\n    if (!isNullOrUndefined(source))\r\n      consoleErorString = this.searchAndReplace(source, TASK_PATH_DELIMITER, \"\");\r\n\r\n    return consoleErorString;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Remove the task path from the error string.\r\n  /// </summary>\r\n  /// <param name = \"source\">string with delimiter </param>\r\n  /// <returns> string for console error </returns>\r\n  static getMsgBoxErorString(source: string): string {\r\n    let tokens: string [];\r\n    let msgBoxErorString: StringBuilder = new StringBuilder(\"\");\r\n\r\n    if (!isNullOrUndefined(source)){\r\n      tokens = this.tokenize(source, TASK_PATH_DELIMITER);\r\n\r\n      for (let i:number = 0; i < tokens.length; i++)\r\n      {\r\n        msgBoxErorString.Append(tokens[i]);\r\n        i++;\r\n      }\r\n    }\r\n\r\n\r\n\r\n    return msgBoxErorString.toString();\r\n  }\r\n}\r\n"]}

package/fesm2015/{magic-xpa-utils.js → magic-xpa-utils.mjs}

@@ -1,5 +1,4 @@
-import { StringBuilder, Encoding, Hashtable, Stack, NChar, NNumber, NString, RefParam, DateTime, ISO_8859_1_Encoding, ApplicationException, Int32, Exception, List, Thread, Debug } from '@magic-xpa/mscorelib';
-import { isNullOrUndefined } from 'util';
+import { StringBuilder, Encoding, 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';
 
 class UtilStrByteMode {
@@ -5379,4 +5378,4 @@ class XmlParser {
 XmlParser.endOfNameChar = [' ', '>'];
 
 export { APGDisplayMode, APGFormSize, APGInvokedFrom, APGMode, APGOption, APGType, Access, AlignmentTypeHori, AlignmentTypeVert, AllowedDirectionType, Area, AutoFit, Axis, Base64, BindingLevel, BlobContent, BlockTypes, BorderType, BottomPositionInterval, BoxDir, BrkLevel, BrkScope, BrkType, CacheStrategy, CallComOption, CallOperationMode, CallOsShow, CallUDPType, CallUdpConvention, CallWsStyle, CallbackType, CharacterSet, CheckExist, CheckboxMainStyle, ChoiceControlStyle, ChoiceUtils, ColumnUpdateStyle, CompTypes, ComponentItemType, Constants, ControlStyle, CtrlButtonType, CtrlButtonTypeGui, CtrlHotspotType, CtrlImageStyle, CtrlLineDirection, CtrlLineType, CtrlOleDisplayType, CtrlOleStoreType, CtrlTextType, DBHCache, DBHRowIdentifier, DataTranslation, DataViewHeaderType, DataViewOperationType, DataViewOutputType, DatabaseDataType, DatabaseDefinitionType, DatabaseFilters, DatabaseOperations, DataviewType, DateTimeUtils, DateUtil, DbDelUpdMode, DbOpen, DbShare, DbhKeyDirection, DbhKeyIndexType, DbhKeyMode, DbhKeyRangeMode, DbhSegmentDirection, DefaultMsgDetails, DisplayTextType, DitAttribute, DitType, DriverDB, DspInterface, EndMode, EngineDirect, EnterAnimation, ErrStrategy, ErrorClassific, ExeState, ExecOn, ExitAnimation, ExportType, FieldComAlloc, FieldComType, FieldViewModelType, FldStorage, FldStyle, FlowDirection, FlwMode, ForceExit, FormDelimiter, FormExpandType, FormOperationType, FormPage, FrameLayoutTypes, GradientStyle, HTML_2_STR, HelpCommand, HelpType, HtmlAlignmentType, HttpStatusCode, ImageEffects, InitialMode, InternalInterface, ItemMasks, JSON_Utils, KeyMode, KeyboardReturnKeys, KeyboardTypes, LDir, LineDirection, LineManipulationType, ListboxSelectionMode, LnkEval_Cond, LnkMode, LoadedValues, LockingStrategy, LogType, Logger, Logger_LogLevels, Logger_MessageDirection, LogicHeaderAction, LogicHeaderType, LogicLevel, LogicOperationType, LogicUnit, MagicProperties, MediaAccess, MediaFormat, MediaOrientation, MediaType, MgControlType, MgModelType, Misc, ModelAttGuiFrame, ModelAttMerge, ModelAttRichClientFrameSet, ModelAttrBrowser, ModelAttrField, ModelAttrFramesetForm, ModelAttrGui0, ModelAttrGui1, ModelAttrHelp, ModelAttrRichClient, ModelAttrText, ModelClass, MsgInterface, NotifyCollectionChangedAction, NullArithmetic, OSEnvironment, OSType, OpenEditDialog, Opr, Order, OrientationLock, PICInterface, PaperSize, PaperSizePdfDisabled, PaperSizePdfEnabled, PositionUsage, PrgExecPlace, Priority, Queue, RaiseAt, Randomizer, RangeMode, RbAppearance, Recursion, RemarkType, RequestInfo, Resident, RowType, Rtf, Rtf_ACTN, Rtf_ErrorRtf, Rtf_IDEST, Rtf_IPFN, Rtf_IPROP, Rtf_KWD, Rtf_PROP, Rtf_PROPTYPE, Rtf_RDS, Rtf_RIS, Rtf_RtfChar, Rtf_SYMBOL, SEQ_2_HTML, SEQ_2_STR, ScrollBarThumbType, SelprgMode, SideType, SliderType, SourceContextType, SplitPrimaryDisplay, SplitWindowType, StartupMode, Storage, StorageAttribute, StorageAttributeCheck, StorageAttributeType, StrUtil, SubformType, SyncExecutionHelper, TabControlTabsWidth, TabbingCycleType, TabbingOrderType, TableBehaviour, TableType, TaskFlow, TransBegin, TransMode, TriggerType, TrueFalseValues, UndoRedoAction, UniqueTskSort, UpdateMode, UseSQLCursor, UtilDateJpn, UtilImeJpn, UtilStrByteMode, ValType, VeeDiffUpdate, VeeMode, VeePartOfDataview, VerifyButtons, VerifyDisplay, VerifyImage, VerifyMode, ViewRefreshMode, ViewSelectType, WinCptn, WinHtmlType, WinUom, WindowPosition, WindowType, XMLConstants, XmlParser, YesNoValues };
-//# sourceMappingURL=magic-xpa-utils.js.map
+//# sourceMappingURL=magic-xpa-utils.mjs.map