source: trip-planner-front/node_modules/iconv-lite/encodings/utf7.js@ 188ee53

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

initial commit

  • Property mode set to 100644
File size: 9.0 KB
Line 
1"use strict";
2var Buffer = require("safer-buffer").Buffer;
3
4// UTF-7 codec, according to https://tools.ietf.org/html/rfc2152
5// See also below a UTF-7-IMAP codec, according to http://tools.ietf.org/html/rfc3501#section-5.1.3
6
7exports.utf7 = Utf7Codec;
8exports.unicode11utf7 = 'utf7'; // Alias UNICODE-1-1-UTF-7
9function Utf7Codec(codecOptions, iconv) {
10 this.iconv = iconv;
11};
12
13Utf7Codec.prototype.encoder = Utf7Encoder;
14Utf7Codec.prototype.decoder = Utf7Decoder;
15Utf7Codec.prototype.bomAware = true;
16
17
18// -- Encoding
19
20var nonDirectChars = /[^A-Za-z0-9'\(\),-\.\/:\? \n\r\t]+/g;
21
22function Utf7Encoder(options, codec) {
23 this.iconv = codec.iconv;
24}
25
26Utf7Encoder.prototype.write = function(str) {
27 // Naive implementation.
28 // Non-direct chars are encoded as "+<base64>-"; single "+" char is encoded as "+-".
29 return Buffer.from(str.replace(nonDirectChars, function(chunk) {
30 return "+" + (chunk === '+' ? '' :
31 this.iconv.encode(chunk, 'utf16-be').toString('base64').replace(/=+$/, ''))
32 + "-";
33 }.bind(this)));
34}
35
36Utf7Encoder.prototype.end = function() {
37}
38
39
40// -- Decoding
41
42function Utf7Decoder(options, codec) {
43 this.iconv = codec.iconv;
44 this.inBase64 = false;
45 this.base64Accum = '';
46}
47
48var base64Regex = /[A-Za-z0-9\/+]/;
49var base64Chars = [];
50for (var i = 0; i < 256; i++)
51 base64Chars[i] = base64Regex.test(String.fromCharCode(i));
52
53var plusChar = '+'.charCodeAt(0),
54 minusChar = '-'.charCodeAt(0),
55 andChar = '&'.charCodeAt(0);
56
57Utf7Decoder.prototype.write = function(buf) {
58 var res = "", lastI = 0,
59 inBase64 = this.inBase64,
60 base64Accum = this.base64Accum;
61
62 // The decoder is more involved as we must handle chunks in stream.
63
64 for (var i = 0; i < buf.length; i++) {
65 if (!inBase64) { // We're in direct mode.
66 // Write direct chars until '+'
67 if (buf[i] == plusChar) {
68 res += this.iconv.decode(buf.slice(lastI, i), "ascii"); // Write direct chars.
69 lastI = i+1;
70 inBase64 = true;
71 }
72 } else { // We decode base64.
73 if (!base64Chars[buf[i]]) { // Base64 ended.
74 if (i == lastI && buf[i] == minusChar) {// "+-" -> "+"
75 res += "+";
76 } else {
77 var b64str = base64Accum + buf.slice(lastI, i).toString();
78 res += this.iconv.decode(Buffer.from(b64str, 'base64'), "utf16-be");
79 }
80
81 if (buf[i] != minusChar) // Minus is absorbed after base64.
82 i--;
83
84 lastI = i+1;
85 inBase64 = false;
86 base64Accum = '';
87 }
88 }
89 }
90
91 if (!inBase64) {
92 res += this.iconv.decode(buf.slice(lastI), "ascii"); // Write direct chars.
93 } else {
94 var b64str = base64Accum + buf.slice(lastI).toString();
95
96 var canBeDecoded = b64str.length - (b64str.length % 8); // Minimal chunk: 2 quads -> 2x3 bytes -> 3 chars.
97 base64Accum = b64str.slice(canBeDecoded); // The rest will be decoded in future.
98 b64str = b64str.slice(0, canBeDecoded);
99
100 res += this.iconv.decode(Buffer.from(b64str, 'base64'), "utf16-be");
101 }
102
103 this.inBase64 = inBase64;
104 this.base64Accum = base64Accum;
105
106 return res;
107}
108
109Utf7Decoder.prototype.end = function() {
110 var res = "";
111 if (this.inBase64 && this.base64Accum.length > 0)
112 res = this.iconv.decode(Buffer.from(this.base64Accum, 'base64'), "utf16-be");
113
114 this.inBase64 = false;
115 this.base64Accum = '';
116 return res;
117}
118
119
120// UTF-7-IMAP codec.
121// RFC3501 Sec. 5.1.3 Modified UTF-7 (http://tools.ietf.org/html/rfc3501#section-5.1.3)
122// Differences:
123// * Base64 part is started by "&" instead of "+"
124// * Direct characters are 0x20-0x7E, except "&" (0x26)
125// * In Base64, "," is used instead of "/"
126// * Base64 must not be used to represent direct characters.
127// * No implicit shift back from Base64 (should always end with '-')
128// * String must end in non-shifted position.
129// * "-&" while in base64 is not allowed.
130
131
132exports.utf7imap = Utf7IMAPCodec;
133function Utf7IMAPCodec(codecOptions, iconv) {
134 this.iconv = iconv;
135};
136
137Utf7IMAPCodec.prototype.encoder = Utf7IMAPEncoder;
138Utf7IMAPCodec.prototype.decoder = Utf7IMAPDecoder;
139Utf7IMAPCodec.prototype.bomAware = true;
140
141
142// -- Encoding
143
144function Utf7IMAPEncoder(options, codec) {
145 this.iconv = codec.iconv;
146 this.inBase64 = false;
147 this.base64Accum = Buffer.alloc(6);
148 this.base64AccumIdx = 0;
149}
150
151Utf7IMAPEncoder.prototype.write = function(str) {
152 var inBase64 = this.inBase64,
153 base64Accum = this.base64Accum,
154 base64AccumIdx = this.base64AccumIdx,
155 buf = Buffer.alloc(str.length*5 + 10), bufIdx = 0;
156
157 for (var i = 0; i < str.length; i++) {
158 var uChar = str.charCodeAt(i);
159 if (0x20 <= uChar && uChar <= 0x7E) { // Direct character or '&'.
160 if (inBase64) {
161 if (base64AccumIdx > 0) {
162 bufIdx += buf.write(base64Accum.slice(0, base64AccumIdx).toString('base64').replace(/\//g, ',').replace(/=+$/, ''), bufIdx);
163 base64AccumIdx = 0;
164 }
165
166 buf[bufIdx++] = minusChar; // Write '-', then go to direct mode.
167 inBase64 = false;
168 }
169
170 if (!inBase64) {
171 buf[bufIdx++] = uChar; // Write direct character
172
173 if (uChar === andChar) // Ampersand -> '&-'
174 buf[bufIdx++] = minusChar;
175 }
176
177 } else { // Non-direct character
178 if (!inBase64) {
179 buf[bufIdx++] = andChar; // Write '&', then go to base64 mode.
180 inBase64 = true;
181 }
182 if (inBase64) {
183 base64Accum[base64AccumIdx++] = uChar >> 8;
184 base64Accum[base64AccumIdx++] = uChar & 0xFF;
185
186 if (base64AccumIdx == base64Accum.length) {
187 bufIdx += buf.write(base64Accum.toString('base64').replace(/\//g, ','), bufIdx);
188 base64AccumIdx = 0;
189 }
190 }
191 }
192 }
193
194 this.inBase64 = inBase64;
195 this.base64AccumIdx = base64AccumIdx;
196
197 return buf.slice(0, bufIdx);
198}
199
200Utf7IMAPEncoder.prototype.end = function() {
201 var buf = Buffer.alloc(10), bufIdx = 0;
202 if (this.inBase64) {
203 if (this.base64AccumIdx > 0) {
204 bufIdx += buf.write(this.base64Accum.slice(0, this.base64AccumIdx).toString('base64').replace(/\//g, ',').replace(/=+$/, ''), bufIdx);
205 this.base64AccumIdx = 0;
206 }
207
208 buf[bufIdx++] = minusChar; // Write '-', then go to direct mode.
209 this.inBase64 = false;
210 }
211
212 return buf.slice(0, bufIdx);
213}
214
215
216// -- Decoding
217
218function Utf7IMAPDecoder(options, codec) {
219 this.iconv = codec.iconv;
220 this.inBase64 = false;
221 this.base64Accum = '';
222}
223
224var base64IMAPChars = base64Chars.slice();
225base64IMAPChars[','.charCodeAt(0)] = true;
226
227Utf7IMAPDecoder.prototype.write = function(buf) {
228 var res = "", lastI = 0,
229 inBase64 = this.inBase64,
230 base64Accum = this.base64Accum;
231
232 // The decoder is more involved as we must handle chunks in stream.
233 // It is forgiving, closer to standard UTF-7 (for example, '-' is optional at the end).
234
235 for (var i = 0; i < buf.length; i++) {
236 if (!inBase64) { // We're in direct mode.
237 // Write direct chars until '&'
238 if (buf[i] == andChar) {
239 res += this.iconv.decode(buf.slice(lastI, i), "ascii"); // Write direct chars.
240 lastI = i+1;
241 inBase64 = true;
242 }
243 } else { // We decode base64.
244 if (!base64IMAPChars[buf[i]]) { // Base64 ended.
245 if (i == lastI && buf[i] == minusChar) { // "&-" -> "&"
246 res += "&";
247 } else {
248 var b64str = base64Accum + buf.slice(lastI, i).toString().replace(/,/g, '/');
249 res += this.iconv.decode(Buffer.from(b64str, 'base64'), "utf16-be");
250 }
251
252 if (buf[i] != minusChar) // Minus may be absorbed after base64.
253 i--;
254
255 lastI = i+1;
256 inBase64 = false;
257 base64Accum = '';
258 }
259 }
260 }
261
262 if (!inBase64) {
263 res += this.iconv.decode(buf.slice(lastI), "ascii"); // Write direct chars.
264 } else {
265 var b64str = base64Accum + buf.slice(lastI).toString().replace(/,/g, '/');
266
267 var canBeDecoded = b64str.length - (b64str.length % 8); // Minimal chunk: 2 quads -> 2x3 bytes -> 3 chars.
268 base64Accum = b64str.slice(canBeDecoded); // The rest will be decoded in future.
269 b64str = b64str.slice(0, canBeDecoded);
270
271 res += this.iconv.decode(Buffer.from(b64str, 'base64'), "utf16-be");
272 }
273
274 this.inBase64 = inBase64;
275 this.base64Accum = base64Accum;
276
277 return res;
278}
279
280Utf7IMAPDecoder.prototype.end = function() {
281 var res = "";
282 if (this.inBase64 && this.base64Accum.length > 0)
283 res = this.iconv.decode(Buffer.from(this.base64Accum, 'base64'), "utf16-be");
284
285 this.inBase64 = false;
286 this.base64Accum = '';
287 return res;
288}
289
290
Note: See TracBrowser for help on using the repository browser.