@magic-xpa/utils
Version:
magic utils package
1,455 lines (1,452 loc) • 799 kB
JavaScript
import { ApplicationException, ISO_8859_1_Encoding, Encoding, StringBuilder, Hashtable, NChar, NNumber, Stack, NString, RefParam, Int32, Exception, DateTime, Debug, Thread, List } from '@magic-xpa/mscorelib';
import { isNullOrUndefined } from 'util';
import { parseString } from 'xml2js';
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class Base64$$1 {
/**
* @param {?} strOrData
* @param {?=} encodingOrIsUseEnvCharset
* @param {?=} encoding
* @return {?}
*/
static encode(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 {?}
*/
static encode_0(str, encoding) {
return Base64$$1.encode(str, false, encoding);
}
/**
* @param {?} str
* @param {?} isUseEnvCharset
* @param {?} encoding
* @return {?}
*/
static encode_1(str, isUseEnvCharset, encoding) {
/** @type {?} */
let result;
if (str === null) {
result = null;
}
else {
if (str === "") {
result = str;
}
else {
try {
/** @type {?} */
let instance = ISO_8859_1_Encoding.ISO_8859_1;
/** @type {?} */
let encoding2 = isUseEnvCharset ? encoding : instance;
/** @type {?} */
let ba = Base64$$1.encode(encoding2.GetBytes(str));
result = instance.GetString(ba, 0, ba.length);
}
catch (ex) {
throw new ApplicationException(ex.Message);
}
}
}
return result;
}
/**
* @param {?} data
* @return {?}
*/
static encode_2(data) {
if (data === null)
return null;
/** @type {?} */
let dest = new Uint8Array(Math.floor((data.length + 2) / 3) * 4);
/** @type {?} */
let sidx = 0;
/** @type {?} */
let 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) | (/** @type {?} */ (data[sidx]) << 4 & 63)];
dest[didx++] = Base64$$1._base64EncMap[(Misc.URShift(/** @type {?} */ (data[sidx + 2]), 6) & 3) | (/** @type {?} */ (data[sidx + 1]) << 2 & 63)];
dest[didx++] = Base64$$1._base64EncMap[/** @type {?} */ ((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) | (/** @type {?} */ (data[sidx]) << 4 & 63)];
dest[didx++] = Base64$$1._base64EncMap[/** @type {?} */ (data[sidx + 1]) << 2 & 63];
}
else {
dest[didx++] = Base64$$1._base64EncMap[/** @type {?} */ (data[sidx]) << 4 & 63];
}
}
// add padding
while (didx < dest.length) {
dest[didx] = 61;
didx = didx + 1;
}
return dest;
}
/**
* @param {?} strOrData
* @param {?=} encoding
* @return {?}
*/
static decode(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 {?}
*/
static decode_0(str) {
return Base64$$1.decode(str, null);
}
/**
* @param {?} str
* @param {?} encoding
* @return {?}
*/
static decode_1(str, encoding) {
/** @type {?} */
let result;
if (str === null) {
result = null;
}
else {
if (str === "") {
result = str;
}
else {
try {
/** @type {?} */
let instance = ISO_8859_1_Encoding.ISO_8859_1;
/** @type {?} */
let array = Base64$$1.decode(instance.GetBytes(str));
/** @type {?} */
let encoding2 = (encoding !== null) ? encoding : instance;
result = encoding2.GetString(array, 0, array.length);
}
catch (ex) {
throw new ApplicationException(ex.Message);
}
}
}
return result;
}
/**
* @param {?} data
* @return {?}
*/
static decode_2(data) {
if (data === null)
return null;
/** @type {?} */
let tail = data.length;
while (data[tail - 1] === '='.charCodeAt(0)) {
tail = tail - 1;
}
/** @type {?} */
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$$1._base64DecMap[data[idx]];
}
/** @type {?} */
let sidx = 0;
/** @type {?} */
let 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;
}
/**
* @param {?} str
* @return {?}
*/
static decodeToHex(str) {
if (str === null)
return null;
if (str === "")
return str;
return StrUtil.stringToHexaDump(Base64$$1.decode(str), 2);
}
/**
* @param {?} str
* @return {?}
*/
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 {
/** @type {?} */
let instance = ISO_8859_1_Encoding.ISO_8859_1;
return Base64$$1.decode(instance.GetBytes(str));
}
catch (ex) {
throw new ApplicationException(ex.Message);
}
}
/**
* @return {?}
*/
static initializeEncMap() {
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 {?}
*/
static initializeDecMap() {
/** @type {?} */
let decMap = new Uint8Array(128);
for (let 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();
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class UtilStrByteMode {
/**
* @return {?}
*/
static isLocaleDefLangDBCS() {
return UtilStrByteMode._bLocaleDefLangJPN || UtilStrByteMode._bLocaleDefLangCHN || UtilStrByteMode._bLocaleDefLangKOR;
}
/**
* @return {?}
*/
static isLocaleDefLangJPN() {
return UtilStrByteMode._bLocaleDefLangJPN;
}
/**
* @return {?}
*/
static isLocaleDefLangKOR() {
return UtilStrByteMode._bLocaleDefLangKOR;
}
/**
* @param {?} c
* @return {?}
*/
static isKoreanCharacter(c) {
return (44032 <= /*'가'*/ c && c <= 55203 /*'힣'*/) || (4352 <= /*'ᄀ'*/ c && c <= 4607 /*'ᇿ'*/) || (12592 <= /*''*/ c && c <= 12687 /*''*/) || (43360 <= /*'ꥠ'*/ c && c <= 43391 /*''*/) || (55216 <= /*'ힰ'*/ c && c <= 55295 /*''*/);
}
/**
* @param {?} strVal
* @return {?}
*/
static lenB(strVal) {
// convert to byte[] by default-encoding
return UtilStrByteMode.Encoding.GetByteCount(strVal);
}
/**
* @param {?} strVal
* @param {?} ofs
* @param {?} len
* @return {?}
*/
static midB(strVal, ofs, len) {
/** @type {?} */
let intValidMaxIndex = -1;
/** @type {?} */
let intValidMinIndex = -1;
/** @type {?} */
let bHeadSpace = false;
/** @type {?} */
let bEndSpace = false;
/** @type {?} */
let strRet;
// check and modify ofs & len
if (len <= 0)
return "";
if (ofs <= 0) {
ofs = 0;
intValidMinIndex = 0;
bHeadSpace = false;
}
/** @type {?} */
let intByteLength = UtilStrByteMode.lenB(strVal);
if (intByteLength < ofs)
return "";
/** @type {?} */
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) {
/** @type {?} */
let 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 {?} */
let strbufAddingBuf = new 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;
}
/**
* @param {?} strVal
* @param {?} len
* @return {?}
*/
static leftB(strVal, len) {
return UtilStrByteMode.midB(strVal, 0, len);
}
/**
* @param {?} strVal
* @param {?} len
* @return {?}
*/
static rightB(strVal, len) {
/** @type {?} */
let byteFldsValLen = UtilStrByteMode.lenB(strVal);
if (len < 0) {
len = 0;
}
/** @type {?} */
let ofs = byteFldsValLen - len;
if (ofs < 0) {
ofs = 0;
}
return UtilStrByteMode.midB(strVal, ofs, len);
}
/**
* @param {?} strTarget
* @param {?} strSource
* @param {?} ofs
* @param {?} len
* @return {?}
*/
static insB(strTarget, strSource, ofs, len) {
if (ofs < 0) {
ofs = 0;
}
else {
if (ofs >= 1) {
ofs = ofs - 1;
}
}
if (len < 0) {
len = 0;
}
/** @type {?} */
let intTargetLenB = UtilStrByteMode.lenB(strTarget);
/** @type {?} */
let intSourceLenB = UtilStrByteMode.lenB(strSource);
/** @type {?} */
let strbufRetVal = new StringBuilder(ofs + len);
strbufRetVal.Append(UtilStrByteMode.leftB(strTarget, ofs));
for (let intAddSpaceLen = ofs - intTargetLenB; intAddSpaceLen > 0; intAddSpaceLen = intAddSpaceLen - 1) {
strbufRetVal.Append(' ');
}
strbufRetVal.Append(UtilStrByteMode.leftB(strSource, len));
for (let i = len - intSourceLenB; i > 0; i = i - 1) {
strbufRetVal.Append(' ');
}
strbufRetVal.Append(UtilStrByteMode.rightB(strTarget, intTargetLenB - ofs));
return strbufRetVal.ToString();
}
/**
* @param {?} strVal
* @param {?} ofs
* @param {?} len
* @return {?}
*/
static delB(strVal, ofs, len) {
if (ofs < 0) {
ofs = 0;
}
else {
if (ofs >= 1) {
ofs = ofs - 1;
}
}
/** @type {?} */
let intValLenB = UtilStrByteMode.lenB(strVal);
if (ofs + len > intValLenB) {
len = intValLenB - ofs;
}
/** @type {?} */
let strRet;
if (len <= 0) {
strRet = strVal;
}
else {
/** @type {?} */
let intRightSideLenB = intValLenB - ofs - len;
if (intRightSideLenB < 0) {
strRet = strVal;
}
else {
/** @type {?} */
let strbufRetVal = new StringBuilder(ofs + intRightSideLenB);
strbufRetVal.Append(UtilStrByteMode.leftB(strVal, ofs));
strbufRetVal.Append(UtilStrByteMode.rightB(strVal, intRightSideLenB));
strRet = strbufRetVal.ToString();
}
}
return strRet;
}
/**
* @param {?} strTarget
* @param {?} strSearch
* @return {?}
*/
static instrB(strTarget, strSearch) {
if (strSearch.length === 0) {
// nothing to look for
return 0;
}
/** @type {?} */
let ofs = strTarget.indexOf(strSearch);
if (ofs < 0) {
// not found
return 0;
}
return UtilStrByteMode.lenB(strTarget.substr(0, ofs)) + 1;
}
/**
* @param {?} strTarget
* @param {?} strOrigin
* @param {?} ofs
* @param {?} len
* @return {?}
*/
static repB(strTarget, strOrigin, ofs, len) {
/** @type {?} */
let strbufAddingBuf = new 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 {?} */
let intAddSpaceLen = ofs - UtilStrByteMode.lenB(strTarget);
for (; intAddSpaceLen > 0; intAddSpaceLen--)
strbufAddingBuf.Append(' ');
strbufAddingBuf.Append(UtilStrByteMode.leftB(strOrigin, len));
/** @type {?} */
let 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();
}
/**
* @param {?} strTarget
* @param {?} strOrigin
* @param {?} ofs
* @param {?} len
* @return {?}
*/
static repC(strTarget, strOrigin, ofs, len) {
/** @type {?} */
let strbufAddingBuf = new 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 {?} */
let intAddSpaceLen = ofs - strTarget.length;
for (; intAddSpaceLen > 0; intAddSpaceLen--)
strbufAddingBuf.Append(' ');
strbufAddingBuf.Append(strOrigin.substr(0, len));
/** @type {?} */
let intRightLen = strTarget.length - (ofs + len);
if (intRightLen > 0) {
strbufAddingBuf.Append(strTarget.substr(ofs + len));
}
for (let i = len - strOrigin.length; i > 0; i = i - 1) {
strbufAddingBuf.Append(' ');
}
return strbufAddingBuf.ToString();
}
/**
* @param {?} str
* @return {?}
*/
static isHalfWidth(str) {
/** @type {?} */
let letter = str.charCodeAt(0);
if (32 <= /*' '*/ letter && letter <= 126 /*'~'*/) {
return true;
}
else {
/** @type {?} */
let len = UtilStrByteMode.lenB(str);
if (len === 1)
return true;
}
return false;
}
/**
* @param {?} letter
* @return {?}
*/
static isDigit(letter) {
return 48 <= /*'0'*/ /*'0'*/ letter.charCodeAt(0) && letter.charCodeAt(0) <= 57 /*'9'*/;
}
/**
* @param {?} letter
* @return {?}
*/
static asNumeric(letter) {
/** @type {?} */
let 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;
}
/**
* @param {?} strSource
* @param {?} strDest
* @param {?} pos
* @param {?} isAdvance
* @return {?}
*/
static convPos(strSource, strDest, pos, isAdvance) {
/** @type {?} */
let retPos;
if (pos < 0)
return 0;
if (pos > strSource.length)
pos = strSource.length;
/** @type {?} */
let diffLen = UtilStrByteMode.lenB(strSource) - UtilStrByteMode.lenB(strDest);
if (diffLen > 0) {
/** @type {?} */
let stringBuilder = new StringBuilder(strDest);
for (; diffLen > 0; diffLen--)
stringBuilder.Append(' ');
strDest = stringBuilder.ToString();
}
/** @type {?} */
let byteSource = UtilStrByteMode.Encoding.GetBytes(strSource.substr(0, pos));
/** @type {?} */
let 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;
}
/**
* @param {?} str
* @param {?} picture
* @return {?}
*/
static getMinLenPicture(str, picture) {
/** @type {?} */
let len = 0;
if (UtilStrByteMode.lenB(picture) - UtilStrByteMode.lenB(str) > 0) {
len = UtilStrByteMode.convPos(str, picture, str.length, false);
}
else
len = picture.length;
return len;
}
/**
* @param {?} str1
* @param {?} str2
* @return {?}
*/
static strcmp(str1, str2) {
/** @type {?} */
let array1 = UtilStrByteMode.Encoding.GetBytes(str1);
/** @type {?} */
let array2 = UtilStrByteMode.Encoding.GetBytes(str2);
for (let 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 = 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");
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class Rtf_SYMBOL {
/**
* @param {?} keyWord
* @param {?} kwd
* @param {?} idxInRgprop
*/
constructor(keyWord, kwd, idxInRgprop) {
this.szKeyword = null;
/* RTF keyword */
this.kwd = null;
/* base action to take */
this.idxInRgprop = null;
this.szKeyword = keyWord;
this.kwd = kwd;
this.idxInRgprop = idxInRgprop;
}
}
class Rtf_PROP {
/**
* @param {?} actn
* @param {?} prop
*/
constructor(actn, prop) {
this.actn = null;
/* size of value */
this.prop = null;
this.actn = actn;
this.prop = prop;
}
}
class Rtf_StackSave {
constructor() {
this.rds = null;
this.ris = null;
}
}
/** @enum {number} */
const 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} */
const 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} */
const 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} */
const 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} */
const 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} */
const 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} */
const 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} */
const 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';
class 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.CLOSINGBRACE = '}';
Rtf_RtfChar.BACKSLASH = '\\';
/** @enum {number} */
const Rtf_RIS = {
NORM: 0,
BIN: 1,
HEX: 2,
UNICODE: 3,
};
Rtf_RIS[Rtf_RIS.NORM] = 'NORM';
Rtf_RIS[Rtf_RIS.BIN] = 'BIN';
Rtf_RIS[Rtf_RIS.HEX] = 'HEX';
Rtf_RIS[Rtf_RIS.UNICODE] = 'UNICODE';
class Rtf {
constructor() {
this._group = 0;
this._cbBin = 0;
this._lParam = 0;
this._skipDestIfUnk = false;
this._outputOnce = false;
this._processCrlfSpecial = false;
this._destState = null;
this._internalState = null;
this._stack = null;
this._index = 0;
this._fontNum = 0;
this._charsetTable = new Hashtable();
this._codePageTable = new Hashtable();
this._stack = new Stack();
this._group = 0;
this._cbBin = 0;
this._lParam = 0;
this._outputOnce = false;
this._skipDestIfUnk = false;
this._processCrlfSpecial = false;
this._destState = Rtf_RDS.NORM;
this._internalState = Rtf_RIS.NORM;
this._fontNum = 0;
if (UtilStrByteMode.isLocaleDefLangDBCS()) {
this.setCodePageTable();
}
}
/**
* @param {?} str
* @return {?}
*/
static isRtf(str) {
/** @type {?} */
let isRtf = false;
if (str !== null && str.startsWith(this.RTF_PREFIX)) {
isRtf = true;
}
return isRtf;
}
/**
* @param {?} rtfTxt
* @param {?} outputTxt
* @return {?}
*/
toTxt(rtfTxt, outputTxt) {
/** @type {?} */
let cNibble = 2;
/** @type {?} */
let b = 0;
/** @type {?} */
let currPos = 0;
/** @type {?} */
let skipNewline = false;
/** @type {?} */
let blobStrLen;
/** @type {?} */
let blobChar;
/** @type {?} */
let ec;
/** @type {?} */
let dbcsBytes = new Uint8Array(2);
/** @type {?} */
let skipParseChar = false;
/** @type {?} */
let charset = 0;
/** @type {?} */
let codePage = 0;
this._outputOnce = false;
this._processCrlfSpecial = false;
blobStrLen = rtfTxt.length;
this._index = 0;
this._destState = Rtf_RDS.NORM;
if (rtfTxt === null || blobStrLen === 0 || !Rtf.isRtf(rtfTxt)) {
return Rtf_ErrorRtf.OK;
}
while (this._index < blobStrLen) {
blobChar = rtfTxt[this._index];
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;
}
else {
switch (blobChar) {
case Rtf_RtfChar.OPENINGBRACE:
skipNewline = false;
if ((ec = this.PushState()) !== Rtf_ErrorRtf.OK)
return ec;
break;
case Rtf_RtfChar.CLOSINGBRACE:
skipNewline = true;
if ((ec = this.PopState()) !== Rtf_ErrorRtf.OK)
return ec;
break;
case Rtf_RtfChar.BACKSLASH:
skipNewline = false;
if ((ec = this.ParseKeyword(rtfTxt, outputTxt)) !== Rtf_ErrorRtf.OK)
return ec;
break;
case Rtf_RtfChar.LF:
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;
if (this._internalState === Rtf_RIS.NORM) {
if ((ec = this.ParseChar(blobChar, outputTxt)) !== Rtf_ErrorRtf.OK)
return ec;
}
else if (this._internalState === Rtf_RIS.UNICODE) {
if ((ec = this.ParseChar(String.fromCharCode(this._lParam), outputTxt)) !== Rtf_ErrorRtf.OK)
return ec;
this._internalState = Rtf_RIS.NORM;
}
else {
/* parsing hex data */
if (this._internalState !== Rtf_RIS.HEX)
return Rtf_ErrorRtf.ASSERTION;
b = b << 4;
if (NChar.IsDigit(blobChar))
b += blobChar.charCodeAt(0) - '0'.charCodeAt(0);
else {
if (NChar.IsLower(blobChar)) {
if (blobChar < 'a' || blobChar > 'f')
return Rtf_ErrorRtf.INVALID_HEX;
b += 10 + blobChar.charCodeAt(0) - 'a'.charCodeAt(0);
}
else {
if (blobChar < 'A' || blobChar > 'F')
return Rtf_ErrorRtf.INVALID_HEX;
b += 10 + blobChar.charCodeAt(0) - 'A'.charCodeAt(0);
}
}
cNibble--;
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;
else {
dbcsBytes[0] = b;
dbcsBytes[1] = 0;
}
// convert DBCS to Unicode
codePage = this.getCodePage(charset);
/** @type {?} */
let workStr = Encoding.GetEncoding(codePage).GetString(dbcsBytes, 0, 2);
b = workStr.charCodeAt(0);
skipParseChar = false;
}
}
if (!skipParseChar) {
if ((ec = this.ParseChar(String.fromCharCode(b), outputTxt)) !== Rtf_ErrorRtf.OK)
return ec;
}
cNibble = 2;
b = 0;
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;
}
/**
* @param {?} ch
* @param {?} outputTxt
* @return {?}
*/
ParseChar(ch, outputTxt) {
/** @type {?} */
let ret = Rtf_ErrorRtf.OK;
if (this._internalState === Rtf_RIS.BIN && --this._cbBin <= 0) {
this._internalState = Rtf_RIS.NORM;
}
if (this._destState === Rtf_RDS.SKIP) ;
else if (this._destState === Rtf_RDS.NORM) {
/* Output a character. Properties are valid at this point. */
ret = this.PrintChar(ch, outputTxt);
}
return ret;
}
/**
* @param {?} ch
* @param {?} outputTxt
* @return {?}
*/
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);
}
if (ch >= ' ') {
this._outputOnce = true;
}
return Rtf_ErrorRtf.OK;
}
/**
* @return {?}
*/
PushState() {
/** @type {?} */
let stackSave = new Rtf_StackSave();
if (stackSave === null) {
return Rtf_ErrorRtf.STACK_OVERFLOW;
}
stackSave.rds = this._destState;
stackSave.ris = this._internalState;
this._internalState = Rtf_RIS.NORM;
this._stack.push(stackSave);
this._group++;
return Rtf_ErrorRtf.OK;
}
/**
* @return {?}
*/
PopState() {
/** @type {?} */
let savedPop = this._stack.pop();
if (savedPop === null) {
return Rtf_ErrorRtf.STACK_UNDERFLOW;
}
this._destState = savedPop.rds;
this._internalState = savedPop.ris;
this._group--;
return Rtf_ErrorRtf.OK;
}
/**
* @param {?} rtfTxt
* @param {?} outputTxt
* @return {?}
*/
ParseKeyword(rtfTxt, outputTxt) {
/** @type {?} */
let ch;
/** @type {?} */
let fNeg = false;
/** @type {?} */
let szKeyword = "";
/** @type {?} */
let szParameter = "";
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);
}
for (; NChar.IsLetter(ch); ch = rtfTxt[this._index++])
szKeyword = szKeyword + ch;
if (ch === '-') {
fNeg = true;
if ((ch = rtfTxt[this._index++]) === String.fromCharCode(0))
return Rtf_ErrorRtf.END_OF_FILE;
}
if (NChar.IsDigit(ch)) {
for (; NChar.IsDigit(ch); ch = rtfTxt[this._index++])
szParameter = szParameter + ch;
this._lParam = NNumber.Parse(szParameter);
if (fNeg)
this._lParam = -this._lParam;
}
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;
}
if (this._processCrlfSpecial) {
return Rtf_ErrorRtf.OK;
}
else {
return this.TranslateKeyword(szKeyword, outputTxt);
}
}
/**
* @param {?} szKeyword
* @param {?} outputTxt
* @return {?}
*/
TranslateKeyword(szKeyword, outputTxt) {
/** @type {?} */
let result = Rtf_ErrorRtf.OK;
/** @type {?} */
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(/** @type {?} */ (Rtf.rgsymRtf[isym].idxInRgprop));
}
else if (Rtf.rgsymRtf[isym].kwd === Rtf_KWD.CHAR) {
result = this.ParseChar((Rtf.rgsymRtf[isym].idxInRgprop), outputTxt);
}
else if (Rtf.rgsymRtf[isym].kwd === Rtf_KWD.DEST) {
result = this.changeDestState();
}
else if (Rtf.rgsymRtf[isym].kwd === Rtf_KWD.SPEC) {
result = this.ParseSpecialKeyword(/** @type {?} */ (Rtf.rgsymRtf[isym].idxInRgprop));
}
}
return result;
}
/**
* @param {?} iprop
* @return {?}
*/
validateProp(iprop) {
/** @type {?} */
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) {
ret = Rtf_ErrorRtf.BAD_TABLE;
}
if (Rtf.rgprop[iprop].actn !== Rtf_ACTN.BYTE && Rtf.rgprop[iprop].actn !== Rtf_ACTN.WORD && Rtf.rgprop[iprop].actn !== Rtf_ACTN.SPEC) {
ret = Rtf_ErrorRtf.BAD_TABLE;
}
return ret;
}
/**
* @return {?}
*/
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;
}
/**
* @param {?} ipfn
* @return {?}
*/
ParseSpecialKeyword(ipfn) {
/** @type {?} */
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;
}
}
else {
if (this._destState === Rtf_RDS.SKIP && ipfn !== Rtf_IPFN.BIN && ipfn !== Rtf_IPFN.FONT &&
ipfn !== Rtf_IPFN.CHARSET && ipfn !== Rtf_IPFN.UNICODE) {
return ret;
}
}
if (ipfn === Rtf_IPFN.BIN) {
this._internalState = Rtf_RIS.BIN;
this._cbBin = this._lParam;
}
else if (ipfn === Rtf_IPFN.SKIP_DEST) {
this._skipDestIfUnk = true;
}
else if (ipfn === Rtf_IPFN.HEX) {
this._internalState = Rtf_RIS.HEX;
}
else if (ipfn === Rtf_IPFN.FONT) {
this._fontNum = /** @type {?} */ (this._lParam);
}
else if (ipfn === Rtf_IPFN.CHARSET) {
this._charsetTable.set_Item(this._fontNum, /** @type {?} */ (this._lParam));
}
else if (ipfn === Rtf_IPFN.UNICODE) {
this._internalState = Rtf_RIS.UNICODE;
}
else {
ret = Rtf_ErrorRtf.BAD_TABLE;
}
return ret;
}
/**
* @param {?} dbcsBytes
* @param {?} charset
* @return {?}
*/
static is1stByte(dbcsBytes, charset) {
/** @type {?} */
let ret = false;
if (dbcsBytes > 255)
return ret;
switch (charset) {
case 128:
ret = (129 <= dbcsBytes && dbcsBytes <= 159) || (224 <= dbcsBytes && dbcsBytes <= 254);
break;
case 129:
case 134:
case 136:
ret = (129 <= dbcsBytes);
break;
default:
break;
}
return ret;
}
/**
* @param {?} dbcsBytes
* @param {?} charset
* @return {?}
*/
static is2ndByte(dbcsBytes, charset) {
/** @type {?} */
let ret = false;
if (dbcsBytes > 255)
return ret;
switch (charset) {
case 128:
ret = (dbcsBytes !== 127) && (64 <= dbcsBytes && dbcsBytes <= 252);
break;
case 129:
case 134:
case 136:
ret = (64 <= dbcsBytes);
break;
default:
break;
}
return ret;
}
/**
* @return {?}
*/
setCodePageTable() {
// add elements with key (charset) and value (codepage) into the table.
this._codePageTable.set_Item(0, 1252); // ANSI_CHARSET
this._codePageTable.set_Item(128, 932); // SHIFTJIS_CHARSET
this._codePageTable.set_Item(129, 949); // HANGUL_CHARSET
this._codePageTable.set_Item(134, 936); // GB2312_CHARSET
this._codePageTable.set_Item(136, 950); // CHINESEBIG5_CHARSET
this._codePageTable.set_Item(161, 1253); // GREEK_CHARSET
this._codePageTable.set_Item(162, 1254); // TURKISH_CHARSET
this._codePageTable.set_Item(177, 1255); // HEBREW_CHARSET
this._codePageTable.set_Item(178, 1256); // ARABIC _CHARSET
this._codePageTable.set_Item(186, 1257); // BALTIC_CHARSET
this._codePageTable.set_Item(204, 1251); // RUSSIAN_CHARSET
this._codePageTable.set_Item(222, 874); // THAI_CHARSET
this._codePageTable.set_Item(238, 1250); // EASTEUROPE_CHARSET
}
/**
* @param {?} charset
* @return {?}
*/
getCodePage(charset) {
/** @type {?} */
let codePage = 0;
if (this._codePageTable.ContainsKey(charset)) {
codePage = this._codePageTable.get_Item(charset);
}
return codePage;
}
/**
* @param {?} font
* @return {?}
*/
getCharset(font) {
/** @type {?}