@magic-xpa/utils
Version:
magic utils package
1,313 lines (1,310 loc) • 909 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@magic-xpa/mscorelib'), require('util'), require('xml2js')) :
typeof define === 'function' && define.amd ? define('@magic-xpa/utils', ['exports', '@magic-xpa/mscorelib', 'util', 'xml2js'], factory) :
(factory((global['magic-xpa'] = global['magic-xpa'] || {}, global['magic-xpa'].utils = {}),null,null,null));
}(this, (function (exports,mscorelib,util,xml2js) { 'use strict';
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var Base64$$1 = (function () {
function Base64$$1() {
}
/**
* @param {?} strOrData
* @param {?=} encodingOrIsUseEnvCharset
* @param {?=} encoding
* @return {?}
*/
Base64$$1.encode = /**
* @param {?} strOrData
* @param {?=} encodingOrIsUseEnvCharset
* @param {?=} encoding
* @return {?}
*/
function (strOrData, encodingOrIsUseEnvCharset, encoding) {
if (arguments.length === 2)
return Base64$$1.encode_0(strOrData, encodingOrIsUseEnvCharset);
else if (arguments.length === 3)
return Base64$$1.encode_1(strOrData, encodingOrIsUseEnvCharset, encoding);
else
return Base64$$1.encode_2(strOrData);
};
/**
* @param {?} str
* @param {?} encoding
* @return {?}
*/
Base64$$1.encode_0 = /**
* @param {?} str
* @param {?} encoding
* @return {?}
*/
function (str, encoding) {
return Base64$$1.encode(str, false, encoding);
};
/**
* @param {?} str
* @param {?} isUseEnvCharset
* @param {?} encoding
* @return {?}
*/
Base64$$1.encode_1 = /**
* @param {?} str
* @param {?} isUseEnvCharset
* @param {?} encoding
* @return {?}
*/
function (str, isUseEnvCharset, encoding) {
/** @type {?} */
var result;
if (str === null) {
result = null;
}
else {
if (str === "") {
result = str;
}
else {
try {
/** @type {?} */
var instance = mscorelib.ISO_8859_1_Encoding.ISO_8859_1;
/** @type {?} */
var encoding2 = isUseEnvCharset ? encoding : instance;
/** @type {?} */
var ba = Base64$$1.encode(encoding2.GetBytes(str));
result = instance.GetString(ba, 0, ba.length);
}
catch (ex) {
throw new mscorelib.ApplicationException(ex.Message);
}
}
}
return result;
};
/**
* @param {?} data
* @return {?}
*/
Base64$$1.encode_2 = /**
* @param {?} data
* @return {?}
*/
function (data) {
if (data === null)
return null;
/** @type {?} */
var dest = new Uint8Array(Math.floor((data.length + 2) / 3) * 4);
/** @type {?} */
var sidx = 0;
/** @type {?} */
var didx = 0;
// 3-byte to 4-byte conversion + 0-63 to ASCII printable conversion
while (sidx < data.length - 2) {
dest[didx++] = Base64$$1._base64EncMap[Misc.URShift(/** @type {?} */ (data[sidx]), 2) & 63];
dest[didx++] = Base64$$1._base64EncMap[(Misc.URShift(/** @type {?} */ (data[sidx + 1]), 4) & 15) | ((data[sidx]) << 4 & 63)];
dest[didx++] = Base64$$1._base64EncMap[(Misc.URShift(/** @type {?} */ (data[sidx + 2]), 6) & 3) | ((data[sidx + 1]) << 2 & 63)];
dest[didx++] = Base64$$1._base64EncMap[((data[sidx + 2] & 63))];
sidx = sidx + 3;
}
if (sidx < data.length) {
dest[didx++] = Base64$$1._base64EncMap[Misc.URShift(/** @type {?} */ (data[sidx]), 2) & 63];
if (sidx < data.length - 1) {
dest[didx++] = Base64$$1._base64EncMap[(Misc.URShift(/** @type {?} */ (data[sidx + 1]), 4) & 15) | ((data[sidx]) << 4 & 63)];
dest[didx++] = Base64$$1._base64EncMap[(data[sidx + 1]) << 2 & 63];
}
else {
dest[didx++] = Base64$$1._base64EncMap[(data[sidx]) << 4 & 63];
}
}
// add padding
while (didx < dest.length) {
dest[didx] = 61;
didx = didx + 1;
}
return dest;
};
/**
* @param {?} strOrData
* @param {?=} encoding
* @return {?}
*/
Base64$$1.decode = /**
* @param {?} strOrData
* @param {?=} encoding
* @return {?}
*/
function (strOrData, encoding) {
if (arguments.length === 1 && (strOrData === null || strOrData.constructor === String))
return Base64$$1.decode_0(strOrData);
else if (arguments.length === 2)
return Base64$$1.decode_1(strOrData, encoding);
else
return Base64$$1.decode_2(strOrData);
};
/**
* @param {?} str
* @return {?}
*/
Base64$$1.decode_0 = /**
* @param {?} str
* @return {?}
*/
function (str) {
return Base64$$1.decode(str, null);
};
/**
* @param {?} str
* @param {?} encoding
* @return {?}
*/
Base64$$1.decode_1 = /**
* @param {?} str
* @param {?} encoding
* @return {?}
*/
function (str, encoding) {
/** @type {?} */
var result;
if (str === null) {
result = null;
}
else {
if (str === "") {
result = str;
}
else {
try {
/** @type {?} */
var instance = mscorelib.ISO_8859_1_Encoding.ISO_8859_1;
/** @type {?} */
var array = Base64$$1.decode(instance.GetBytes(str));
/** @type {?} */
var encoding2 = (encoding !== null) ? encoding : instance;
result = encoding2.GetString(array, 0, array.length);
}
catch (ex) {
throw new mscorelib.ApplicationException(ex.Message);
}
}
}
return result;
};
/**
* @param {?} data
* @return {?}
*/
Base64$$1.decode_2 = /**
* @param {?} data
* @return {?}
*/
function (data) {
if (data === null)
return null;
/** @type {?} */
var tail = data.length;
while (data[tail - 1] === '='.charCodeAt(0)) {
tail = tail - 1;
}
/** @type {?} */
var dest = new Uint8Array(tail - Math.floor(data.length / 4));
// ASCII printable to 0-63 conversion
for (var idx = 0; idx < data.length; idx = idx + 1) {
data[idx] = Base64$$1._base64DecMap[data[idx]];
}
/** @type {?} */
var sidx = 0;
/** @type {?} */
var didx;
for (didx = 0; didx < dest.length - 2; didx = didx + 3) {
dest[didx] = (((data[sidx] << 2) & 255) | (Misc.URShift(data[sidx + 1], 4) & 3));
dest[didx + 1] = (((data[sidx + 1] << 4) & 255) | (Misc.URShift(data[sidx + 2], 2) & 15));
dest[didx + 2] = (((data[sidx + 2] << 6) & 255) | (data[sidx + 3] & 63));
sidx = sidx + 4;
}
if (didx < dest.length)
dest[didx] = (((data[sidx] << 2) & 255) | (Misc.URShift(data[sidx + 1], 4) & 3));
if ((didx = didx + 1) < dest.length)
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>
/**
* @param {?} str
* @return {?}
*/
Base64$$1.decodeToHex = /**
* @param {?} str
* @return {?}
*/
function (str) {
if (str === null)
return null;
if (str === "")
return str;
return StrUtil.stringToHexaDump(Base64$$1.decode(str), 2);
};
/// <summary> decodes a string to byte array</summary>
/**
* @param {?} str
* @return {?}
*/
Base64$$1.decodeToByte = /**
* @param {?} str
* @return {?}
*/
function (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 {
/** @type {?} */
var instance = mscorelib.ISO_8859_1_Encoding.ISO_8859_1;
return Base64$$1.decode(instance.GetBytes(str));
}
catch (ex) {
throw new mscorelib.ApplicationException(ex.Message);
}
};
/**
* @return {?}
*/
Base64$$1.initializeEncMap = /**
* @return {?}
*/
function () {
return new Uint8Array([
65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
84, 85, 86, 87, 88, 89, 90, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54,
55, 56, 57, 43, 47
]);
};
/**
* @return {?}
*/
Base64$$1.initializeDecMap = /**
* @return {?}
*/
function () {
/** @type {?} */
var decMap = new Uint8Array(128);
for (var i = 0; i < Base64$$1._base64EncMap.length; i = i + 1) {
decMap[Base64$$1._base64EncMap[i]] = i;
}
return decMap;
};
Base64$$1._base64EncMap = Base64$$1.initializeEncMap();
Base64$$1._base64DecMap = Base64$$1.initializeDecMap();
return Base64$$1;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var UtilStrByteMode = (function () {
function UtilStrByteMode() {
}
/// <summary> Checks the environment whether it is running on DBCS environment
/// Returns true if the language code for the current default Locale is
/// DBCS language (in non-Unicode encoding).
///
/// </summary>
/// <returns> true if DBCS, or false if SBCS
/// </returns>
/**
* @return {?}
*/
UtilStrByteMode.isLocaleDefLangDBCS = /**
* @return {?}
*/
function () {
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>
/**
* @return {?}
*/
UtilStrByteMode.isLocaleDefLangJPN = /**
* @return {?}
*/
function () {
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>
/**
* @return {?}
*/
UtilStrByteMode.isLocaleDefLangKOR = /**
* @return {?}
*/
function () {
return UtilStrByteMode._bLocaleDefLangKOR;
};
/**
* @param {?} c
* @return {?}
*/
UtilStrByteMode.isKoreanCharacter = /**
* @param {?} c
* @return {?}
*/
function (c) {
return (44032 <= /*'가'*/ c && c <= 55203 /*'힣'*/) || (4352 <= /*'ᄀ'*/ c && c <= 4607 /*'ᇿ'*/) || (12592 <= /*''*/ c && c <= 12687 /*''*/) || (43360 <= /*'ꥠ'*/ c && c <= 43391 /*''*/) || (55216 <= /*'ힰ'*/ c && c <= 55295 /*''*/);
};
/// <summary> Length of String
/// Returns the number of bytes (in default encoding).
///
/// </summary>
/// <param name="strVal:">string (in Unicode)
/// </param>
/// <returns> the number of bytes (in default encoding)
///
/// Example: lenB("abXYc")
/// Where 'a', 'b' and 'c' are SBCS, and 'X' and 'Y' are DBCS, it returns
/// 7.
/// </returns>
/**
* @param {?} strVal
* @return {?}
*/
UtilStrByteMode.lenB = /**
* @param {?} strVal
* @return {?}
*/
function (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>
/**
* @param {?} strVal
* @param {?} ofs
* @param {?} len
* @return {?}
*/
UtilStrByteMode.midB = /**
* @param {?} strVal
* @param {?} ofs
* @param {?} len
* @return {?}
*/
function (strVal, ofs, len) {
/** @type {?} */
var intValidMaxIndex = -1;
/** @type {?} */
var intValidMinIndex = -1;
/** @type {?} */
var bHeadSpace = false;
/** @type {?} */
var bEndSpace = false;
/** @type {?} */
var strRet;
// check and modify ofs & len
if (len <= 0)
return "";
if (ofs <= 0) {
ofs = 0;
intValidMinIndex = 0;
bHeadSpace = false;
}
/** @type {?} */
var intByteLength = UtilStrByteMode.lenB(strVal);
if (intByteLength < ofs)
return "";
/** @type {?} */
var LenMax = intByteLength - ofs;
if (LenMax < len)
len = LenMax;
// set MinIndex and MaxIndex for substring
intByteLength = 0;
for (var intIndex = 0; intIndex < strVal.length; intIndex = intIndex + 1) {
/** @type {?} */
var s = strVal.substr(intIndex, 1);
intByteLength = intByteLength + UtilStrByteMode.Encoding.GetByteCount(s);
if (intValidMinIndex === -1) {
if (intByteLength === ofs) {
intValidMinIndex = intIndex + 1;
bHeadSpace = false;
}
else if (intByteLength > ofs) {
intValidMinIndex = intIndex + 1;
bHeadSpace = true;
}
}
if (intValidMaxIndex === -1) {
if (intByteLength === ofs + len) {
intValidMaxIndex = intIndex;
bEndSpace = false;
break;
}
else if (intByteLength > ofs + len) {
intValidMaxIndex = intIndex - 1;
bEndSpace = true;
break;
}
}
}
/** @type {?} */
var strbufAddingBuf = new mscorelib.StringBuilder(len);
// execute Mid
if (bHeadSpace) {
strbufAddingBuf.Append(' ');
}
if (intValidMinIndex <= intValidMaxIndex) {
strbufAddingBuf.Append(strVal.substr(intValidMinIndex, intValidMaxIndex + 1 - intValidMinIndex));
}
if (bEndSpace) {
strbufAddingBuf.Append(' ');
}
strRet = strbufAddingBuf.ToString();
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>
/**
* @param {?} strVal
* @param {?} len
* @return {?}
*/
UtilStrByteMode.leftB = /**
* @param {?} strVal
* @param {?} len
* @return {?}
*/
function (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>
/**
* @param {?} strVal
* @param {?} len
* @return {?}
*/
UtilStrByteMode.rightB = /**
* @param {?} strVal
* @param {?} len
* @return {?}
*/
function (strVal, len) {
/** @type {?} */
var byteFldsValLen = UtilStrByteMode.lenB(strVal);
if (len < 0) {
len = 0;
}
/** @type {?} */
var ofs = byteFldsValLen - len;
if (ofs < 0) {
ofs = 0;
}
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>
/**
* @param {?} strTarget
* @param {?} strSource
* @param {?} ofs
* @param {?} len
* @return {?}
*/
UtilStrByteMode.insB = /**
* @param {?} strTarget
* @param {?} strSource
* @param {?} ofs
* @param {?} len
* @return {?}
*/
function (strTarget, strSource, ofs, len) {
if (ofs < 0) {
ofs = 0;
}
else {
if (ofs >= 1) {
ofs = ofs - 1;
}
}
if (len < 0) {
len = 0;
}
/** @type {?} */
var intTargetLenB = UtilStrByteMode.lenB(strTarget);
/** @type {?} */
var intSourceLenB = UtilStrByteMode.lenB(strSource);
/** @type {?} */
var strbufRetVal = new mscorelib.StringBuilder(ofs + len);
strbufRetVal.Append(UtilStrByteMode.leftB(strTarget, ofs));
for (var intAddSpaceLen = ofs - intTargetLenB; intAddSpaceLen > 0; intAddSpaceLen = intAddSpaceLen - 1) {
strbufRetVal.Append(' ');
}
strbufRetVal.Append(UtilStrByteMode.leftB(strSource, len));
for (var i = len - intSourceLenB; i > 0; i = i - 1) {
strbufRetVal.Append(' ');
}
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>
/**
* @param {?} strVal
* @param {?} ofs
* @param {?} len
* @return {?}
*/
UtilStrByteMode.delB = /**
* @param {?} strVal
* @param {?} ofs
* @param {?} len
* @return {?}
*/
function (strVal, ofs, len) {
if (ofs < 0) {
ofs = 0;
}
else {
if (ofs >= 1) {
ofs = ofs - 1;
}
}
/** @type {?} */
var intValLenB = UtilStrByteMode.lenB(strVal);
if (ofs + len > intValLenB) {
len = intValLenB - ofs;
}
/** @type {?} */
var strRet;
if (len <= 0) {
strRet = strVal;
}
else {
/** @type {?} */
var intRightSideLenB = intValLenB - ofs - len;
if (intRightSideLenB < 0) {
strRet = strVal;
}
else {
/** @type {?} */
var strbufRetVal = new mscorelib.StringBuilder(ofs + intRightSideLenB);
strbufRetVal.Append(UtilStrByteMode.leftB(strVal, ofs));
strbufRetVal.Append(UtilStrByteMode.rightB(strVal, intRightSideLenB));
strRet = strbufRetVal.ToString();
}
}
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>
/**
* @param {?} strTarget
* @param {?} strSearch
* @return {?}
*/
UtilStrByteMode.instrB = /**
* @param {?} strTarget
* @param {?} strSearch
* @return {?}
*/
function (strTarget, strSearch) {
if (strSearch.length === 0) {
// nothing to look for
return 0;
}
/** @type {?} */
var 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>
/**
* @param {?} strTarget
* @param {?} strOrigin
* @param {?} ofs
* @param {?} len
* @return {?}
*/
UtilStrByteMode.repB = /**
* @param {?} strTarget
* @param {?} strOrigin
* @param {?} ofs
* @param {?} len
* @return {?}
*/
function (strTarget, strOrigin, ofs, len) {
/** @type {?} */
var strbufAddingBuf = new mscorelib.StringBuilder();
if (ofs < 0) {
ofs = 0;
}
else {
if (ofs >= 1) {
ofs = ofs - 1;
}
}
if (len < 0) {
len = 0;
}
strbufAddingBuf.Append(UtilStrByteMode.leftB(strTarget, ofs));
/** @type {?} */
var intAddSpaceLen = ofs - UtilStrByteMode.lenB(strTarget);
for (; intAddSpaceLen > 0; intAddSpaceLen--)
strbufAddingBuf.Append(' ');
strbufAddingBuf.Append(UtilStrByteMode.leftB(strOrigin, len));
/** @type {?} */
var intRightLen = UtilStrByteMode.lenB(strTarget) - (ofs + len);
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>
/**
* @param {?} strTarget
* @param {?} strOrigin
* @param {?} ofs
* @param {?} len
* @return {?}
*/
UtilStrByteMode.repC = /**
* @param {?} strTarget
* @param {?} strOrigin
* @param {?} ofs
* @param {?} len
* @return {?}
*/
function (strTarget, strOrigin, ofs, len) {
/** @type {?} */
var strbufAddingBuf = new mscorelib.StringBuilder();
if (ofs < 0) {
ofs = 0;
}
else {
if (ofs >= 1) {
ofs = ofs - 1;
}
}
if (len < 0) {
len = 0;
}
strbufAddingBuf.Append(strTarget.substr(0, ofs));
/** @type {?} */
var intAddSpaceLen = ofs - strTarget.length;
for (; intAddSpaceLen > 0; intAddSpaceLen--)
strbufAddingBuf.Append(' ');
strbufAddingBuf.Append(strOrigin.substr(0, len));
/** @type {?} */
var intRightLen = strTarget.length - (ofs + len);
if (intRightLen > 0) {
strbufAddingBuf.Append(strTarget.substr(ofs + len));
}
for (var i = len - strOrigin.length; i > 0; i = i - 1) {
strbufAddingBuf.Append(' ');
}
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>
/**
* @param {?} str
* @return {?}
*/
UtilStrByteMode.isHalfWidth = /**
* @param {?} str
* @return {?}
*/
function (str) {
/** @type {?} */
var letter = str.charCodeAt(0);
if (32 <= /*' '*/ letter && letter <= 126 /*'~'*/) {
return true;
}
else {
/** @type {?} */
var len = UtilStrByteMode.lenB(str);
if (len === 1)
return true;
}
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>
/**
* @param {?} letter
* @return {?}
*/
UtilStrByteMode.isDigit = /**
* @param {?} letter
* @return {?}
*/
function (letter) {
return 48 <= /*'0'*/ /*'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>
/**
* @param {?} letter
* @return {?}
*/
UtilStrByteMode.asNumeric = /**
* @param {?} letter
* @return {?}
*/
function (letter) {
/** @type {?} */
var result;
switch (letter.charCodeAt(0)) {
case 42: /*'*'*/
case 43: /*'+'*/
case 44: /*','*/
case 45: /*'-'*/
case 46: /*'.'*/
case 47:
/*'/'*/
result = true;
break;
default:
result = false;
break;
}
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>
/**
* @param {?} strSource
* @param {?} strDest
* @param {?} pos
* @param {?} isAdvance
* @return {?}
*/
UtilStrByteMode.convPos = /**
* @param {?} strSource
* @param {?} strDest
* @param {?} pos
* @param {?} isAdvance
* @return {?}
*/
function (strSource, strDest, pos, isAdvance) {
/** @type {?} */
var retPos;
if (pos < 0)
return 0;
if (pos > strSource.length)
pos = strSource.length;
/** @type {?} */
var diffLen = UtilStrByteMode.lenB(strSource) - UtilStrByteMode.lenB(strDest);
if (diffLen > 0) {
/** @type {?} */
var stringBuilder = new mscorelib.StringBuilder(strDest);
for (; diffLen > 0; diffLen--)
stringBuilder.Append(' ');
strDest = stringBuilder.ToString();
}
/** @type {?} */
var byteSource = UtilStrByteMode.Encoding.GetBytes(strSource.substr(0, pos));
/** @type {?} */
var strLeftB = UtilStrByteMode.leftB(strDest, byteSource.length);
retPos = strLeftB.length;
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)
/**
* @param {?} str
* @param {?} picture
* @return {?}
*/
UtilStrByteMode.getMinLenPicture = /**
* @param {?} str
* @param {?} picture
* @return {?}
*/
function (str, picture) {
/** @type {?} */
var len = 0;
if (UtilStrByteMode.lenB(picture) - UtilStrByteMode.lenB(str) > 0) {
len = UtilStrByteMode.convPos(str, picture, str.length, false);
}
else
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>
/**
* @param {?} str1
* @param {?} str2
* @return {?}
*/
UtilStrByteMode.strcmp = /**
* @param {?} str1
* @param {?} str2
* @return {?}
*/
function (str1, str2) {
/** @type {?} */
var array1 = UtilStrByteMode.Encoding.GetBytes(str1);
/** @type {?} */
var array2 = UtilStrByteMode.Encoding.GetBytes(str2);
for (var i = 0; i < array1.length && i < array2.length; i++) {
if (array1[i] > array2[i]) {
return 1;
}
else if (array1[i] < array2[i]) {
return -1;
}
}
if (array1.length > array2.length)
return 1;
if (array1.length < array2.length)
return -1;
else
return 0;
};
UtilStrByteMode.Encoding = mscorelib.Encoding.UTF8;
// TODO : need to check what to do with CultureInfo
UtilStrByteMode.twoLetterISOLanguageName = " ";
UtilStrByteMode._bLocaleDefLangJPN = (UtilStrByteMode.twoLetterISOLanguageName === "ja");
UtilStrByteMode._bLocaleDefLangCHN = (UtilStrByteMode.twoLetterISOLanguageName === "zh");
UtilStrByteMode._bLocaleDefLangKOR = (UtilStrByteMode.twoLetterISOLanguageName === "ko");
return UtilStrByteMode;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
var Rtf_SYMBOL = (function () {
/* index into property table if kwd == kwdProp */
/* index into destination table if kwd == kwdDest */
/* character to print if kwd == kwdChar */
function Rtf_SYMBOL(keyWord, kwd, idxInRgprop) {
this.szKeyword = null;
/* RTF keyword */
this.kwd = null;
/* base action to take */
this.idxInRgprop = null;
this.szKeyword = keyWord;
this.kwd = kwd;
this.idxInRgprop = idxInRgprop;
}
return Rtf_SYMBOL;
}());
var Rtf_PROP = (function () {
/* structure containing value */
function Rtf_PROP(actn, prop) {
this.actn = null;
/* size of value */
this.prop = null;
this.actn = actn;
this.prop = prop;
}
return Rtf_PROP;
}());
var Rtf_StackSave = (function () {
function Rtf_StackSave() {
this.rds = null;
this.ris = null;
}
return Rtf_StackSave;
}());
/** @enum {number} */
var Rtf_KWD = {
CHAR: 0,
DEST: 1,
PROP: 2,
SPEC: 3,
};
Rtf_KWD[Rtf_KWD.CHAR] = 'CHAR';
Rtf_KWD[Rtf_KWD.DEST] = 'DEST';
Rtf_KWD[Rtf_KWD.PROP] = 'PROP';
Rtf_KWD[Rtf_KWD.SPEC] = 'SPEC';
/** @enum {number} */
var Rtf_PROPTYPE = {
CHP: 0,
PAP: 1,
SEP: 2,
DOP: 3,
};
Rtf_PROPTYPE[Rtf_PROPTYPE.CHP] = 'CHP';
Rtf_PROPTYPE[Rtf_PROPTYPE.PAP] = 'PAP';
Rtf_PROPTYPE[Rtf_PROPTYPE.SEP] = 'SEP';
Rtf_PROPTYPE[Rtf_PROPTYPE.DOP] = 'DOP';
/** @enum {number} */
var Rtf_ACTN = {
SPEC: 0,
BYTE: 1,
WORD: 2,
};
Rtf_ACTN[Rtf_ACTN.SPEC] = 'SPEC';
Rtf_ACTN[Rtf_ACTN.BYTE] = 'BYTE';
Rtf_ACTN[Rtf_ACTN.WORD] = 'WORD';
/** @enum {number} */
var Rtf_IPFN = {
BIN: 0,
HEX: 1,
SKIP_DEST: 2,
BREAK: 3,
NEW: 4,
FONT: 5,
CHARSET: 6,
UNICODE: 7,
};
Rtf_IPFN[Rtf_IPFN.BIN] = 'BIN';
Rtf_IPFN[Rtf_IPFN.HEX] = 'HEX';
Rtf_IPFN[Rtf_IPFN.SKIP_DEST] = 'SKIP_DEST';
Rtf_IPFN[Rtf_IPFN.BREAK] = 'BREAK';
Rtf_IPFN[Rtf_IPFN.NEW] = 'NEW';
Rtf_IPFN[Rtf_IPFN.FONT] = 'FONT';
Rtf_IPFN[Rtf_IPFN.CHARSET] = 'CHARSET';
Rtf_IPFN[Rtf_IPFN.UNICODE] = 'UNICODE';
/** @enum {number} */
var Rtf_IDEST = {
PICT: 0,
COLOR: 1,
SKIP: 2,
};
Rtf_IDEST[Rtf_IDEST.PICT] = 'PICT';
Rtf_IDEST[Rtf_IDEST.COLOR] = 'COLOR';
Rtf_IDEST[Rtf_IDEST.SKIP] = 'SKIP';
/** @enum {number} */
var Rtf_IPROP = {
BOLD: 0,
ITALIC: 1,
UNDERLINE: 2,
FONT: 3,
SIZE: 4,
COLOR: 5,
RED: 6,
GREEN: 7,
BLUE: 8,
LEFT_IND: 9,
RIGHT_IND: 10,
FIRST_IND: 11,
COLS: 12,
PGN_X: 13,
PGN_Y: 14,
XA_PAGE: 15,
YA_PAGE: 16,
XA_LEFT: 17,
XA_RIGHT: 18,
YA_TOP: 19,
YA_BOTTOM: 20,
PGN_START: 21,
SBK: 22,
PGN_FORMAT: 23,
FACING_P: 24,
LANDSCAPE: 25,
JUST: 26,
PARD: 27,
PLAIN: 28,
SECTD: 29,
BULLET: 30,
XA_BULLET: 31,
MAX: 32,
};
Rtf_IPROP[Rtf_IPROP.BOLD] = 'BOLD';
Rtf_IPROP[Rtf_IPROP.ITALIC] = 'ITALIC';
Rtf_IPROP[Rtf_IPROP.UNDERLINE] = 'UNDERLINE';
Rtf_IPROP[Rtf_IPROP.FONT] = 'FONT';
Rtf_IPROP[Rtf_IPROP.SIZE] = 'SIZE';
Rtf_IPROP[Rtf_IPROP.COLOR] = 'COLOR';
Rtf_IPROP[Rtf_IPROP.RED] = 'RED';
Rtf_IPROP[Rtf_IPROP.GREEN] = 'GREEN';
Rtf_IPROP[Rtf_IPROP.BLUE] = 'BLUE';
Rtf_IPROP[Rtf_IPROP.LEFT_IND] = 'LEFT_IND';
Rtf_IPROP[Rtf_IPROP.RIGHT_IND] = 'RIGHT_IND';
Rtf_IPROP[Rtf_IPROP.FIRST_IND] = 'FIRST_IND';
Rtf_IPROP[Rtf_IPROP.COLS] = 'COLS';
Rtf_IPROP[Rtf_IPROP.PGN_X] = 'PGN_X';
Rtf_IPROP[Rtf_IPROP.PGN_Y] = 'PGN_Y';
Rtf_IPROP[Rtf_IPROP.XA_PAGE] = 'XA_PAGE';
Rtf_IPROP[Rtf_IPROP.YA_PAGE] = 'YA_PAGE';
Rtf_IPROP[Rtf_IPROP.XA_LEFT] = 'XA_LEFT';
Rtf_IPROP[Rtf_IPROP.XA_RIGHT] = 'XA_RIGHT';
Rtf_IPROP[Rtf_IPROP.YA_TOP] = 'YA_TOP';
Rtf_IPROP[Rtf_IPROP.YA_BOTTOM] = 'YA_BOTTOM';
Rtf_IPROP[Rtf_IPROP.PGN_START] = 'PGN_START';
Rtf_IPROP[Rtf_IPROP.SBK] = 'SBK';
Rtf_IPROP[Rtf_IPROP.PGN_FORMAT] = 'PGN_FORMAT';
Rtf_IPROP[Rtf_IPROP.FACING_P] = 'FACING_P';
Rtf_IPROP[Rtf_IPROP.LANDSCAPE] = 'LANDSCAPE';
Rtf_IPROP[Rtf_IPROP.JUST] = 'JUST';
Rtf_IPROP[Rtf_IPROP.PARD] = 'PARD';
Rtf_IPROP[Rtf_IPROP.PLAIN] = 'PLAIN';
Rtf_IPROP[Rtf_IPROP.SECTD] = 'SECTD';
Rtf_IPROP[Rtf_IPROP.BULLET] = 'BULLET';
Rtf_IPROP[Rtf_IPROP.XA_BULLET] = 'XA_BULLET';
Rtf_IPROP[Rtf_IPROP.MAX] = 'MAX';
/** @enum {number} */
var Rtf_RDS = {
NORM: 0,
COLOR: 1,
SKIP: 2,
NEW: 3,
};
Rtf_RDS[Rtf_RDS.NORM] = 'NORM';
Rtf_RDS[Rtf_RDS.COLOR] = 'COLOR';
Rtf_RDS[Rtf_RDS.SKIP] = 'SKIP';
Rtf_RDS[Rtf_RDS.NEW] = 'NEW';
/** @enum {number} */
var Rtf_ErrorRtf = {
OK: 0,
STACK_UNDERFLOW: 1,
STACK_OVERFLOW: 2,
UNMATCHED_BRACE: 3,
INVALID_HEX: 4,
BAD_TABLE: 5,
ASSERTION: 6,
END_OF_FILE: 7,
BUFFER_TOO_SMALL: 8,
};
Rtf_ErrorRtf[Rtf_ErrorRtf.OK] = 'OK';
Rtf_ErrorRtf[Rtf_ErrorRtf.STACK_UNDERFLOW] = 'STACK_UNDERFLOW';
Rtf_ErrorRtf[Rtf_ErrorRtf.STACK_OVERFLOW] = 'STACK_OVERFLOW';
Rtf_ErrorRtf[Rtf_ErrorRtf.UNMATCHED_BRACE] = 'UNMATCHED_BRACE';
Rtf_ErrorRtf[Rtf_ErrorRtf.INVALID_HEX] = 'INVALID_HEX';
Rtf_ErrorRtf[Rtf_ErrorRtf.BAD_TABLE] = 'BAD_TABLE';
Rtf_ErrorRtf[Rtf_ErrorRtf.ASSERTION] = 'ASSERTION';
Rtf_ErrorRtf[Rtf_ErrorRtf.END_OF_FILE] = 'END_OF_FILE';
Rtf_ErrorRtf[Rtf_ErrorRtf.BUFFER_TOO_SMALL] = 'BUFFER_TOO_SMALL';
var Rtf_RtfChar = (function () {
function Rtf_RtfChar() {
}
Rtf_RtfChar.CR = String.fromCharCode(0x0d);
Rtf_RtfChar.LF = String.fromCharCode(0x0A);
Rtf_RtfChar.TAB = String.fromCharCode(0x09);
Rtf_RtfChar.BULLET = String.fromCharCode(0x95);
Rtf_RtfChar.TILDA = String.fromCharCode(0xA0);
Rtf_RtfChar.DASH = String.fromCharCode(0xAD);
Rtf_RtfChar.DASH_CHAR = '-';
Rtf_RtfChar.QUOTE = '\'';
Rtf_RtfChar.DBLQUOTE = '"';
Rtf_RtfChar.OPENINGBRACE = '{';
Rtf_RtfChar.CLOSINGB