ethers.js/packages/strings/src.ts/utf8.ts
2019-08-02 01:58:42 -04:00

217 lines
6.4 KiB
TypeScript

"use strict";
import { arrayify, BytesLike } from "@ethersproject/bytes";
import { Logger } from "@ethersproject/logger";
import { version } from "./_version";
const logger = new Logger(version);
///////////////////////////////
export enum UnicodeNormalizationForm {
current = "",
NFC = "NFC",
NFD = "NFD",
NFKC = "NFKC",
NFKD = "NFKD"
};
// http://stackoverflow.com/questions/13356493/decode-utf-8-with-javascript#13691499
function getUtf8CodePoints(bytes: BytesLike, ignoreErrors?: boolean): Array<number> {
bytes = arrayify(bytes);
let result: Array<number> = [];
let i = 0;
// Invalid bytes are ignored
while(i < bytes.length) {
let c = bytes[i++];
// 0xxx xxxx
if (c >> 7 === 0) {
result.push(c);
continue;
}
// Multibyte; how many bytes left for this character?
let extraLength = null;
let overlongMask = null;
// 110x xxxx 10xx xxxx
if ((c & 0xe0) === 0xc0) {
extraLength = 1;
overlongMask = 0x7f;
// 1110 xxxx 10xx xxxx 10xx xxxx
} else if ((c & 0xf0) === 0xe0) {
extraLength = 2;
overlongMask = 0x7ff;
// 1111 0xxx 10xx xxxx 10xx xxxx 10xx xxxx
} else if ((c & 0xf8) === 0xf0) {
extraLength = 3;
overlongMask = 0xffff;
} else {
if (!ignoreErrors) {
if ((c & 0xc0) === 0x80) {
throw new Error("invalid utf8 byte sequence; unexpected continuation byte");
}
throw new Error("invalid utf8 byte sequence; invalid prefix");
}
continue;
}
// Do we have enough bytes in our data?
if (i + extraLength > bytes.length) {
if (!ignoreErrors) { throw new Error("invalid utf8 byte sequence; too short"); }
// If there is an invalid unprocessed byte, skip continuation bytes
for (; i < bytes.length; i++) {
if (bytes[i] >> 6 !== 0x02) { break; }
}
continue;
}
// Remove the length prefix from the char
let res = c & ((1 << (8 - extraLength - 1)) - 1);
for (let j = 0; j < extraLength; j++) {
let nextChar = bytes[i];
// Invalid continuation byte
if ((nextChar & 0xc0) != 0x80) {
res = null;
break;
};
res = (res << 6) | (nextChar & 0x3f);
i++;
}
if (res === null) {
if (!ignoreErrors) { throw new Error("invalid utf8 byte sequence; invalid continuation byte"); }
continue;
}
// Check for overlong seuences (more bytes than needed)
if (res <= overlongMask) {
if (!ignoreErrors) { throw new Error("invalid utf8 byte sequence; overlong"); }
continue;
}
// Maximum code point
if (res > 0x10ffff) {
if (!ignoreErrors) { throw new Error("invalid utf8 byte sequence; out-of-range"); }
continue;
}
// Reserved for UTF-16 surrogate halves
if (res >= 0xd800 && res <= 0xdfff) {
if (!ignoreErrors) { throw new Error("invalid utf8 byte sequence; utf-16 surrogate"); }
continue;
}
result.push(res);
}
return result;
}
// http://stackoverflow.com/questions/18729405/how-to-convert-utf8-string-to-byte-array
export function toUtf8Bytes(str: string, form: UnicodeNormalizationForm = UnicodeNormalizationForm.current): Uint8Array {
if (form != UnicodeNormalizationForm.current) {
logger.checkNormalize();
str = str.normalize(form);
}
let result = [];
for (let i = 0; i < str.length; i++) {
let c = str.charCodeAt(i);
if (c < 0x80) {
result.push(c);
} else if (c < 0x800) {
result.push((c >> 6) | 0xc0);
result.push((c & 0x3f) | 0x80);
} else if ((c & 0xfc00) == 0xd800) {
i++;
let c2 = str.charCodeAt(i);
if (i >= str.length || (c2 & 0xfc00) !== 0xdc00) {
throw new Error("invalid utf-8 string");
}
// Surrogate Pair
c = 0x10000 + ((c & 0x03ff) << 10) + (c2 & 0x03ff);
result.push((c >> 18) | 0xf0);
result.push(((c >> 12) & 0x3f) | 0x80);
result.push(((c >> 6) & 0x3f) | 0x80);
result.push((c & 0x3f) | 0x80);
} else {
result.push((c >> 12) | 0xe0);
result.push(((c >> 6) & 0x3f) | 0x80);
result.push((c & 0x3f) | 0x80);
}
}
return arrayify(result);
};
function escapeChar(value: number) {
let hex = ("0000" + value.toString(16));
return "\\u" + hex.substring(hex.length - 4);
}
export function _toEscapedUtf8String(bytes: BytesLike, ignoreErrors?: boolean): string {
return '"' + getUtf8CodePoints(bytes, ignoreErrors).map((codePoint) => {
if (codePoint < 256) {
switch (codePoint) {
case 8: return "\\b";
case 9: return "\\t";
case 10: return "\\n"
case 13: return "\\r";
case 34: return "\\\"";
case 92: return "\\\\";
}
if (codePoint >= 32 && codePoint < 127) {
return String.fromCharCode(codePoint);
}
}
if (codePoint <= 0xffff) {
return escapeChar(codePoint);
}
codePoint -= 0x10000;
return escapeChar(((codePoint >> 10) & 0x3ff) + 0xd800) + escapeChar((codePoint & 0x3ff) + 0xdc00);
}).join("") + '"';
}
export function _toUtf8String(codePoints: Array<number>): string {
return codePoints.map((codePoint) => {
if (codePoint <= 0xffff) {
return String.fromCharCode(codePoint);
}
codePoint -= 0x10000;
return String.fromCharCode(
(((codePoint >> 10) & 0x3ff) + 0xd800),
((codePoint & 0x3ff) + 0xdc00)
);
}).join("");
}
export function toUtf8String(bytes: BytesLike, ignoreErrors?: boolean): string {
return _toUtf8String(getUtf8CodePoints(bytes, ignoreErrors));
}
export function toUtf8CodePoints(str: string, form: UnicodeNormalizationForm = UnicodeNormalizationForm.current): Array<number> {
return getUtf8CodePoints(toUtf8Bytes(str, form));
}