source: trip-planner-front/node_modules/engine.io/lib/parser-v3/utf8.js@ 6a3a178

Last change on this file since 6a3a178 was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago

initial commit

  • Property mode set to 100644
File size: 5.0 KB
Line 
1/*! https://mths.be/utf8js v2.1.2 by @mathias */
2
3var stringFromCharCode = String.fromCharCode;
4
5// Taken from https://mths.be/punycode
6function ucs2decode(string) {
7 var output = [];
8 var counter = 0;
9 var length = string.length;
10 var value;
11 var extra;
12 while (counter < length) {
13 value = string.charCodeAt(counter++);
14 if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
15 // high surrogate, and there is a next character
16 extra = string.charCodeAt(counter++);
17 if ((extra & 0xFC00) == 0xDC00) { // low surrogate
18 output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
19 } else {
20 // unmatched surrogate; only append this code unit, in case the next
21 // code unit is the high surrogate of a surrogate pair
22 output.push(value);
23 counter--;
24 }
25 } else {
26 output.push(value);
27 }
28 }
29 return output;
30}
31
32// Taken from https://mths.be/punycode
33function ucs2encode(array) {
34 var length = array.length;
35 var index = -1;
36 var value;
37 var output = '';
38 while (++index < length) {
39 value = array[index];
40 if (value > 0xFFFF) {
41 value -= 0x10000;
42 output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
43 value = 0xDC00 | value & 0x3FF;
44 }
45 output += stringFromCharCode(value);
46 }
47 return output;
48}
49
50function checkScalarValue(codePoint, strict) {
51 if (codePoint >= 0xD800 && codePoint <= 0xDFFF) {
52 if (strict) {
53 throw Error(
54 'Lone surrogate U+' + codePoint.toString(16).toUpperCase() +
55 ' is not a scalar value'
56 );
57 }
58 return false;
59 }
60 return true;
61}
62/*--------------------------------------------------------------------------*/
63
64function createByte(codePoint, shift) {
65 return stringFromCharCode(((codePoint >> shift) & 0x3F) | 0x80);
66}
67
68function encodeCodePoint(codePoint, strict) {
69 if ((codePoint & 0xFFFFFF80) == 0) { // 1-byte sequence
70 return stringFromCharCode(codePoint);
71 }
72 var symbol = '';
73 if ((codePoint & 0xFFFFF800) == 0) { // 2-byte sequence
74 symbol = stringFromCharCode(((codePoint >> 6) & 0x1F) | 0xC0);
75 }
76 else if ((codePoint & 0xFFFF0000) == 0) { // 3-byte sequence
77 if (!checkScalarValue(codePoint, strict)) {
78 codePoint = 0xFFFD;
79 }
80 symbol = stringFromCharCode(((codePoint >> 12) & 0x0F) | 0xE0);
81 symbol += createByte(codePoint, 6);
82 }
83 else if ((codePoint & 0xFFE00000) == 0) { // 4-byte sequence
84 symbol = stringFromCharCode(((codePoint >> 18) & 0x07) | 0xF0);
85 symbol += createByte(codePoint, 12);
86 symbol += createByte(codePoint, 6);
87 }
88 symbol += stringFromCharCode((codePoint & 0x3F) | 0x80);
89 return symbol;
90}
91
92function utf8encode(string, opts) {
93 opts = opts || {};
94 var strict = false !== opts.strict;
95
96 var codePoints = ucs2decode(string);
97 var length = codePoints.length;
98 var index = -1;
99 var codePoint;
100 var byteString = '';
101 while (++index < length) {
102 codePoint = codePoints[index];
103 byteString += encodeCodePoint(codePoint, strict);
104 }
105 return byteString;
106}
107
108/*--------------------------------------------------------------------------*/
109
110function readContinuationByte() {
111 if (byteIndex >= byteCount) {
112 throw Error('Invalid byte index');
113 }
114
115 var continuationByte = byteArray[byteIndex] & 0xFF;
116 byteIndex++;
117
118 if ((continuationByte & 0xC0) == 0x80) {
119 return continuationByte & 0x3F;
120 }
121
122 // If we end up here, it’s not a continuation byte
123 throw Error('Invalid continuation byte');
124}
125
126function decodeSymbol(strict) {
127 var byte1;
128 var byte2;
129 var byte3;
130 var byte4;
131 var codePoint;
132
133 if (byteIndex > byteCount) {
134 throw Error('Invalid byte index');
135 }
136
137 if (byteIndex == byteCount) {
138 return false;
139 }
140
141 // Read first byte
142 byte1 = byteArray[byteIndex] & 0xFF;
143 byteIndex++;
144
145 // 1-byte sequence (no continuation bytes)
146 if ((byte1 & 0x80) == 0) {
147 return byte1;
148 }
149
150 // 2-byte sequence
151 if ((byte1 & 0xE0) == 0xC0) {
152 byte2 = readContinuationByte();
153 codePoint = ((byte1 & 0x1F) << 6) | byte2;
154 if (codePoint >= 0x80) {
155 return codePoint;
156 } else {
157 throw Error('Invalid continuation byte');
158 }
159 }
160
161 // 3-byte sequence (may include unpaired surrogates)
162 if ((byte1 & 0xF0) == 0xE0) {
163 byte2 = readContinuationByte();
164 byte3 = readContinuationByte();
165 codePoint = ((byte1 & 0x0F) << 12) | (byte2 << 6) | byte3;
166 if (codePoint >= 0x0800) {
167 return checkScalarValue(codePoint, strict) ? codePoint : 0xFFFD;
168 } else {
169 throw Error('Invalid continuation byte');
170 }
171 }
172
173 // 4-byte sequence
174 if ((byte1 & 0xF8) == 0xF0) {
175 byte2 = readContinuationByte();
176 byte3 = readContinuationByte();
177 byte4 = readContinuationByte();
178 codePoint = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0C) |
179 (byte3 << 0x06) | byte4;
180 if (codePoint >= 0x010000 && codePoint <= 0x10FFFF) {
181 return codePoint;
182 }
183 }
184
185 throw Error('Invalid UTF-8 detected');
186}
187
188var byteArray;
189var byteCount;
190var byteIndex;
191function utf8decode(byteString, opts) {
192 opts = opts || {};
193 var strict = false !== opts.strict;
194
195 byteArray = ucs2decode(byteString);
196 byteCount = byteArray.length;
197 byteIndex = 0;
198 var codePoints = [];
199 var tmp;
200 while ((tmp = decodeSymbol(strict)) !== false) {
201 codePoints.push(tmp);
202 }
203 return ucs2encode(codePoints);
204}
205
206module.exports = {
207 version: '2.1.2',
208 encode: utf8encode,
209 decode: utf8decode
210};
Note: See TracBrowser for help on using the repository browser.