--- /dev/null
+/**
+ * Copyright (c) 2019 The xterm.js authors. All rights reserved.
+ * @license MIT
+ */
+
+/**
+ * Polyfill - Convert UTF32 codepoint into JS string.
+ * Note: The built-in String.fromCodePoint happens to be much slower
+ * due to additional sanity checks. We can avoid them since
+ * we always operate on legal UTF32 (granted by the input decoders)
+ * and use this faster version instead.
+ */
+export function stringFromCodePoint(codePoint: number): string {
+ if (codePoint > 0xFFFF) {
+ codePoint -= 0x10000;
+ return String.fromCharCode((codePoint >> 10) + 0xD800) + String.fromCharCode((codePoint % 0x400) + 0xDC00);
+ }
+ return String.fromCharCode(codePoint);
+}
+
+/**
+ * Convert UTF32 char codes into JS string.
+ * Basically the same as `stringFromCodePoint` but for multiple codepoints
+ * in a loop (which is a lot faster).
+ */
+export function utf32ToString(data: Uint32Array, start: number = 0, end: number = data.length): string {
+ let result = '';
+ for (let i = start; i < end; ++i) {
+ let codepoint = data[i];
+ if (codepoint > 0xFFFF) {
+ // JS strings are encoded as UTF16, thus a non BMP codepoint gets converted into a surrogate pair
+ // conversion rules:
+ // - subtract 0x10000 from code point, leaving a 20 bit number
+ // - add high 10 bits to 0xD800 --> first surrogate
+ // - add low 10 bits to 0xDC00 --> second surrogate
+ codepoint -= 0x10000;
+ result += String.fromCharCode((codepoint >> 10) + 0xD800) + String.fromCharCode((codepoint % 0x400) + 0xDC00);
+ } else {
+ result += String.fromCharCode(codepoint);
+ }
+ }
+ return result;
+}
+
+/**
+ * StringToUtf32 - decodes UTF16 sequences into UTF32 codepoints.
+ * To keep the decoder in line with JS strings it handles single surrogates as UCS2.
+ */
+export class StringToUtf32 {
+ private _interim: number = 0;
+
+ /**
+ * Clears interim and resets decoder to clean state.
+ */
+ public clear(): void {
+ this._interim = 0;
+ }
+
+ /**
+ * Decode JS string to UTF32 codepoints.
+ * The methods assumes stream input and will store partly transmitted
+ * surrogate pairs and decode them with the next data chunk.
+ * Note: The method does no bound checks for target, therefore make sure
+ * the provided input data does not exceed the size of `target`.
+ * Returns the number of written codepoints in `target`.
+ */
+ decode(input: string, target: Uint32Array): number {
+ const length = input.length;
+
+ if (!length) {
+ return 0;
+ }
+
+ let size = 0;
+ let startPos = 0;
+
+ // handle leftover surrogate high
+ if (this._interim) {
+ const second = input.charCodeAt(startPos++);
+ if (0xDC00 <= second && second <= 0xDFFF) {
+ target[size++] = (this._interim - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;
+ } else {
+ // illegal codepoint (USC2 handling)
+ target[size++] = this._interim;
+ target[size++] = second;
+ }
+ this._interim = 0;
+ }
+
+ for (let i = startPos; i < length; ++i) {
+ const code = input.charCodeAt(i);
+ // surrogate pair first
+ if (0xD800 <= code && code <= 0xDBFF) {
+ if (++i >= length) {
+ this._interim = code;
+ return size;
+ }
+ const second = input.charCodeAt(i);
+ if (0xDC00 <= second && second <= 0xDFFF) {
+ target[size++] = (code - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;
+ } else {
+ // illegal codepoint (USC2 handling)
+ target[size++] = code;
+ target[size++] = second;
+ }
+ continue;
+ }
+ target[size++] = code;
+ }
+ return size;
+ }
+}
+
+/**
+ * Utf8Decoder - decodes UTF8 byte sequences into UTF32 codepoints.
+ */
+export class Utf8ToUtf32 {
+ public interim: Uint8Array = new Uint8Array(3);
+
+ /**
+ * Clears interim bytes and resets decoder to clean state.
+ */
+ public clear(): void {
+ this.interim.fill(0);
+ }
+
+ /**
+ * Decodes UTF8 byte sequences in `input` to UTF32 codepoints in `target`.
+ * The methods assumes stream input and will store partly transmitted bytes
+ * and decode them with the next data chunk.
+ * Note: The method does no bound checks for target, therefore make sure
+ * the provided data chunk does not exceed the size of `target`.
+ * Returns the number of written codepoints in `target`.
+ */
+ decode(input: Uint8Array, target: Uint32Array): number {
+ const length = input.length;
+
+ if (!length) {
+ return 0;
+ }
+
+ let size = 0;
+ let byte1: number;
+ let byte2: number;
+ let byte3: number;
+ let byte4: number;
+ let codepoint = 0;
+ let startPos = 0;
+
+ // handle leftover bytes
+ if (this.interim[0]) {
+ let discardInterim = false;
+ let cp = this.interim[0];
+ cp &= ((((cp & 0xE0) === 0xC0)) ? 0x1F : (((cp & 0xF0) === 0xE0)) ? 0x0F : 0x07);
+ let pos = 0;
+ let tmp: number;
+ while ((tmp = this.interim[++pos] & 0x3F) && pos < 4) {
+ cp <<= 6;
+ cp |= tmp;
+ }
+ // missing bytes - read ahead from input
+ const type = (((this.interim[0] & 0xE0) === 0xC0)) ? 2 : (((this.interim[0] & 0xF0) === 0xE0)) ? 3 : 4;
+ const missing = type - pos;
+ while (startPos < missing) {
+ if (startPos >= length) {
+ return 0;
+ }
+ tmp = input[startPos++];
+ if ((tmp & 0xC0) !== 0x80) {
+ // wrong continuation, discard interim bytes completely
+ startPos--;
+ discardInterim = true;
+ break;
+ } else {
+ // need to save so we can continue short inputs in next call
+ this.interim[pos++] = tmp;
+ cp <<= 6;
+ cp |= tmp & 0x3F;
+ }
+ }
+ if (!discardInterim) {
+ // final test is type dependent
+ if (type === 2) {
+ if (cp < 0x80) {
+ // wrong starter byte
+ startPos--;
+ } else {
+ target[size++] = cp;
+ }
+ } else if (type === 3) {
+ if (cp < 0x0800 || (cp >= 0xD800 && cp <= 0xDFFF)) {
+ // illegal codepoint
+ } else {
+ target[size++] = cp;
+ }
+ } else {
+ if (cp < 0x010000 || cp > 0x10FFFF) {
+ // illegal codepoint
+ } else {
+ target[size++] = cp;
+ }
+ }
+ }
+ this.interim.fill(0);
+ }
+
+ // loop through input
+ const fourStop = length - 4;
+ let i = startPos;
+ while (i < length) {
+ /**
+ * ASCII shortcut with loop unrolled to 4 consecutive ASCII chars.
+ * This is a compromise between speed gain for ASCII
+ * and penalty for non ASCII:
+ * For best ASCII performance the char should be stored directly into target,
+ * but even a single attempt to write to target and compare afterwards
+ * penalizes non ASCII really bad (-50%), thus we load the char into byteX first,
+ * which reduces ASCII performance by ~15%.
+ * This trial for ASCII reduces non ASCII performance by ~10% which seems acceptible
+ * compared to the gains.
+ * Note that this optimization only takes place for 4 consecutive ASCII chars,
+ * for any shorter it bails out. Worst case - all 4 bytes being read but
+ * thrown away due to the last being a non ASCII char (-10% performance).
+ */
+ while (i < fourStop
+ && !((byte1 = input[i]) & 0x80)
+ && !((byte2 = input[i + 1]) & 0x80)
+ && !((byte3 = input[i + 2]) & 0x80)
+ && !((byte4 = input[i + 3]) & 0x80))
+ {
+ target[size++] = byte1;
+ target[size++] = byte2;
+ target[size++] = byte3;
+ target[size++] = byte4;
+ i += 4;
+ }
+
+ // reread byte1
+ byte1 = input[i++];
+
+ // 1 byte
+ if (byte1 < 0x80) {
+ target[size++] = byte1;
+
+ // 2 bytes
+ } else if ((byte1 & 0xE0) === 0xC0) {
+ if (i >= length) {
+ this.interim[0] = byte1;
+ return size;
+ }
+ byte2 = input[i++];
+ if ((byte2 & 0xC0) !== 0x80) {
+ // wrong continuation
+ i--;
+ continue;
+ }
+ codepoint = (byte1 & 0x1F) << 6 | (byte2 & 0x3F);
+ if (codepoint < 0x80) {
+ // wrong starter byte
+ i--;
+ continue;
+ }
+ target[size++] = codepoint;
+
+ // 3 bytes
+ } else if ((byte1 & 0xF0) === 0xE0) {
+ if (i >= length) {
+ this.interim[0] = byte1;
+ return size;
+ }
+ byte2 = input[i++];
+ if ((byte2 & 0xC0) !== 0x80) {
+ // wrong continuation
+ i--;
+ continue;
+ }
+ if (i >= length) {
+ this.interim[0] = byte1;
+ this.interim[1] = byte2;
+ return size;
+ }
+ byte3 = input[i++];
+ if ((byte3 & 0xC0) !== 0x80) {
+ // wrong continuation
+ i--;
+ continue;
+ }
+ codepoint = (byte1 & 0x0F) << 12 | (byte2 & 0x3F) << 6 | (byte3 & 0x3F);
+ if (codepoint < 0x0800 || (codepoint >= 0xD800 && codepoint <= 0xDFFF)) {
+ // illegal codepoint, no i-- here
+ continue;
+ }
+ target[size++] = codepoint;
+
+ // 4 bytes
+ } else if ((byte1 & 0xF8) === 0xF0) {
+ if (i >= length) {
+ this.interim[0] = byte1;
+ return size;
+ }
+ byte2 = input[i++];
+ if ((byte2 & 0xC0) !== 0x80) {
+ // wrong continuation
+ i--;
+ continue;
+ }
+ if (i >= length) {
+ this.interim[0] = byte1;
+ this.interim[1] = byte2;
+ return size;
+ }
+ byte3 = input[i++];
+ if ((byte3 & 0xC0) !== 0x80) {
+ // wrong continuation
+ i--;
+ continue;
+ }
+ if (i >= length) {
+ this.interim[0] = byte1;
+ this.interim[1] = byte2;
+ this.interim[2] = byte3;
+ return size;
+ }
+ byte4 = input[i++];
+ if ((byte4 & 0xC0) !== 0x80) {
+ // wrong continuation
+ i--;
+ continue;
+ }
+ codepoint = (byte1 & 0x07) << 18 | (byte2 & 0x3F) << 12 | (byte3 & 0x3F) << 6 | (byte4 & 0x3F);
+ if (codepoint < 0x010000 || codepoint > 0x10FFFF) {
+ // illegal codepoint, no i-- here
+ continue;
+ }
+ target[size++] = codepoint;
+ } else {
+ // illegal byte, just skip
+ }
+ }
+ return size;
+ }
+}
projects / VSoRC / .git / blobdiff