PluginProbe
Page Builder: Pagelayer – Drag and Drop website builder / 2.1.5
Page Builder: Pagelayer – Drag and Drop website builder v2.1.5
2.2.1 2.2.0 2.1.9 2.1.8 2.1.7 2.1.6 2.1.5 2.1.4 2.1.3 trunk 0.9.0 0.9.1 0.9.2 0.9.3 0.9.4 0.9.5 0.9.6 0.9.7 0.9.8 0.9.9 1.0.0 1.0.2 1.0.3 1.0.4 1.0.5 All 129 releases
pagelayer / js / base-64.js

base-64.js in Page Builder: Pagelayer – Drag and Drop website builder 2.1.5, at js/base-64.js

374 lines 12.5 KB
No matching file
Up and down to move Enter to open Esc to close
Raw Download Zip
1 /*
2 * [hi-base64]{@link https://github.com/emn178/hi-base64}
3 *
4 * @version 0.2.1
5 * @author Chen, Yi-Cyuan [emn178@gmail.com]
6 * @copyright Chen, Yi-Cyuan 2014-2017
7 * @license MIT
8 */
9 /*jslint bitwise: true */
10 /*Modified by Pagelayer*/
11 (function () {
12 'use strict';
13
14 var root = typeof window === 'object' ? window : {};
15 var NODE_JS = false;
16 if (NODE_JS) {
17 root = global;
18 }
19 var COMMON_JS = !root.HI_BASE64_NO_COMMON_JS && typeof module === 'object' && module.exports;
20 var AMD = typeof define === 'function' && define.amd;
21 var BASE64_ENCODE_CHAR = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('');
22 var BASE64_DECODE_CHAR = {
23 'A': 0, 'B': 1, 'C': 2, 'D': 3, 'E': 4, 'F': 5, 'G': 6, 'H': 7, 'I': 8,
24 'J': 9, 'K': 10, 'L': 11, 'M': 12, 'N': 13, 'O': 14, 'P': 15, 'Q': 16,
25 'R': 17, 'S': 18, 'T': 19, 'U': 20, 'V': 21, 'W': 22, 'X': 23, 'Y': 24,
26 'Z': 25, 'a': 26, 'b': 27, 'c': 28, 'd': 29, 'e': 30, 'f': 31, 'g': 32,
27 'h': 33, 'i': 34, 'j': 35, 'k': 36, 'l': 37, 'm': 38, 'n': 39, 'o': 40,
28 'p': 41, 'q': 42, 'r': 43, 's': 44, 't': 45, 'u': 46, 'v': 47, 'w': 48,
29 'x': 49, 'y': 50, 'z': 51, '0': 52, '1': 53, '2': 54, '3': 55, '4': 56,
30 '5': 57, '6': 58, '7': 59, '8': 60, '9': 61, '+': 62, '/': 63, '-': 62,
31 '_': 63
32 };
33
34 var utf8ToBytes = function (str) {
35 var bytes = [];
36 for (var i = 0; i < str.length; i++) {
37 var c = str.charCodeAt(i);
38 if (c < 0x80) {
39 bytes[bytes.length] = c;
40 } else if (c < 0x800) {
41 bytes[bytes.length] = 0xc0 | (c >> 6);
42 bytes[bytes.length] = 0x80 | (c & 0x3f);
43 } else if (c < 0xd800 || c >= 0xe000) {
44 bytes[bytes.length] = 0xe0 | (c >> 12);
45 bytes[bytes.length] = 0x80 | ((c >> 6) & 0x3f);
46 bytes[bytes.length] = 0x80 | (c & 0x3f);
47 } else {
48 c = 0x10000 + (((c & 0x3ff) << 10) | (str.charCodeAt(++i) & 0x3ff));
49 bytes[bytes.length] = 0xf0 | (c >> 18);
50 bytes[bytes.length] = 0x80 | ((c >> 12) & 0x3f);
51 bytes[bytes.length] = 0x80 | ((c >> 6) & 0x3f);
52 bytes[bytes.length] = 0x80 | (c & 0x3f);
53 }
54 }
55 return bytes;
56 };
57
58 var decodeAsBytes = function (base64Str) {
59 var v1, v2, v3, v4, bytes = [], index = 0, length = base64Str.length;
60 if (base64Str.charAt(length - 2) === '=') {
61 length -= 2;
62 } else if (base64Str.charAt(length - 1) === '=') {
63 length -= 1;
64 }
65
66 // 4 char to 3 bytes
67 for (var i = 0, count = length >> 2 << 2; i < count;) {
68 v1 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
69 v2 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
70 v3 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
71 v4 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
72 bytes[index++] = (v1 << 2 | v2 >>> 4) & 255;
73 bytes[index++] = (v2 << 4 | v3 >>> 2) & 255;
74 bytes[index++] = (v3 << 6 | v4) & 255;
75 }
76
77 // remain bytes
78 var remain = length - count;
79 if (remain === 2) {
80 v1 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
81 v2 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
82 bytes[index++] = (v1 << 2 | v2 >>> 4) & 255;
83 } else if (remain === 3) {
84 v1 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
85 v2 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
86 v3 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
87 bytes[index++] = (v1 << 2 | v2 >>> 4) & 255;
88 bytes[index++] = (v2 << 4 | v3 >>> 2) & 255;
89 }
90 return bytes;
91 };
92
93 var encodeFromBytes = function (bytes) {
94 var v1, v2, v3, base64Str = '', length = bytes.length;
95 for (var i = 0, count = parseInt(length / 3) * 3; i < count;) {
96 v1 = bytes[i++];
97 v2 = bytes[i++];
98 v3 = bytes[i++];
99 base64Str += BASE64_ENCODE_CHAR[v1 >>> 2] +
100 BASE64_ENCODE_CHAR[(v1 << 4 | v2 >>> 4) & 63] +
101 BASE64_ENCODE_CHAR[(v2 << 2 | v3 >>> 6) & 63] +
102 BASE64_ENCODE_CHAR[v3 & 63];
103 }
104
105 // remain char
106 var remain = length - count;
107 if (remain === 1) {
108 v1 = bytes[i];
109 base64Str += BASE64_ENCODE_CHAR[v1 >>> 2] +
110 BASE64_ENCODE_CHAR[(v1 << 4) & 63] +
111 '==';
112 } else if (remain === 2) {
113 v1 = bytes[i++];
114 v2 = bytes[i];
115 base64Str += BASE64_ENCODE_CHAR[v1 >>> 2] +
116 BASE64_ENCODE_CHAR[(v1 << 4 | v2 >>> 4) & 63] +
117 BASE64_ENCODE_CHAR[(v2 << 2) & 63] +
118 '=';
119 }
120 return base64Str;
121 };
122
123 var btoa = root.btoa, atob = root.atob, utf8Base64Encode, utf8Base64Decode;
124 if (NODE_JS) {
125 } else if (!btoa) {
126 btoa = function (str) {
127 var v1, v2, v3, base64Str = '', length = str.length;
128 for (var i = 0, count = parseInt(length / 3) * 3; i < count;) {
129 v1 = str.charCodeAt(i++);
130 v2 = str.charCodeAt(i++);
131 v3 = str.charCodeAt(i++);
132 base64Str += BASE64_ENCODE_CHAR[v1 >>> 2] +
133 BASE64_ENCODE_CHAR[(v1 << 4 | v2 >>> 4) & 63] +
134 BASE64_ENCODE_CHAR[(v2 << 2 | v3 >>> 6) & 63] +
135 BASE64_ENCODE_CHAR[v3 & 63];
136 }
137
138 // remain char
139 var remain = length - count;
140 if (remain === 1) {
141 v1 = str.charCodeAt(i);
142 base64Str += BASE64_ENCODE_CHAR[v1 >>> 2] +
143 BASE64_ENCODE_CHAR[(v1 << 4) & 63] +
144 '==';
145 } else if (remain === 2) {
146 v1 = str.charCodeAt(i++);
147 v2 = str.charCodeAt(i);
148 base64Str += BASE64_ENCODE_CHAR[v1 >>> 2] +
149 BASE64_ENCODE_CHAR[(v1 << 4 | v2 >>> 4) & 63] +
150 BASE64_ENCODE_CHAR[(v2 << 2) & 63] +
151 '=';
152 }
153 return base64Str;
154 };
155
156 utf8Base64Encode = function (str) {
157 var v1, v2, v3, base64Str = '', bytes = utf8ToBytes(str), length = bytes.length;
158 for (var i = 0, count = parseInt(length / 3) * 3; i < count;) {
159 v1 = bytes[i++];
160 v2 = bytes[i++];
161 v3 = bytes[i++];
162 base64Str += BASE64_ENCODE_CHAR[v1 >>> 2] +
163 BASE64_ENCODE_CHAR[(v1 << 4 | v2 >>> 4) & 63] +
164 BASE64_ENCODE_CHAR[(v2 << 2 | v3 >>> 6) & 63] +
165 BASE64_ENCODE_CHAR[v3 & 63];
166 }
167
168 // remain char
169 var remain = length - count;
170 if (remain === 1) {
171 v1 = bytes[i];
172 base64Str += BASE64_ENCODE_CHAR[v1 >>> 2] +
173 BASE64_ENCODE_CHAR[(v1 << 4) & 63] +
174 '==';
175 } else if (remain === 2) {
176 v1 = bytes[i++];
177 v2 = bytes[i];
178 base64Str += BASE64_ENCODE_CHAR[v1 >>> 2] +
179 BASE64_ENCODE_CHAR[(v1 << 4 | v2 >>> 4) & 63] +
180 BASE64_ENCODE_CHAR[(v2 << 2) & 63] +
181 '=';
182 }
183 return base64Str;
184 };
185
186 atob = function (base64Str) {
187 var v1, v2, v3, v4, str = '', length = base64Str.length;
188 if (base64Str.charAt(length - 2) === '=') {
189 length -= 2;
190 } else if (base64Str.charAt(length - 1) === '=') {
191 length -= 1;
192 }
193
194 // 4 char to 3 bytes
195 for (var i = 0, count = length >> 2 << 2; i < count;) {
196 v1 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
197 v2 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
198 v3 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
199 v4 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
200 str += String.fromCharCode((v1 << 2 | v2 >>> 4) & 255) +
201 String.fromCharCode((v2 << 4 | v3 >>> 2) & 255) +
202 String.fromCharCode((v3 << 6 | v4) & 255);
203 }
204
205 // remain bytes
206 var remain = length - count;
207 if (remain === 2) {
208 v1 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
209 v2 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
210 str += String.fromCharCode((v1 << 2 | v2 >>> 4) & 255);
211 } else if (remain === 3) {
212 v1 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
213 v2 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
214 v3 = BASE64_DECODE_CHAR[base64Str.charAt(i++)];
215 str += String.fromCharCode((v1 << 2 | v2 >>> 4) & 255) +
216 String.fromCharCode((v2 << 4 | v3 >>> 2) & 255);
217 }
218 return str;
219 };
220
221 utf8Base64Decode = function (base64Str) {
222 var str = '', bytes = decodeAsBytes(base64Str), length = bytes.length;
223 var i = 0, followingChars = 0, b, c;
224 while (i < length) {
225 b = bytes[i++];
226 if (b <= 0x7F) {
227 str += String.fromCharCode(b);
228 continue;
229 } else if (b > 0xBF && b <= 0xDF) {
230 c = b & 0x1F;
231 followingChars = 1;
232 } else if (b <= 0xEF) {
233 c = b & 0x0F;
234 followingChars = 2;
235 } else if (b <= 0xF7) {
236 c = b & 0x07;
237 followingChars = 3;
238 } else {
239 throw 'not a UTF-8 string';
240 }
241
242 for (var j = 0; j < followingChars; ++j) {
243 b = bytes[i++];
244 if (b < 0x80 || b > 0xBF) {
245 throw 'not a UTF-8 string';
246 }
247 c <<= 6;
248 c += b & 0x3F;
249 }
250 if (c >= 0xD800 && c <= 0xDFFF) {
251 throw 'not a UTF-8 string';
252 }
253 if (c > 0x10FFFF) {
254 throw 'not a UTF-8 string';
255 }
256
257 if (c <= 0xFFFF) {
258 str += String.fromCharCode(c);
259 } else {
260 c -= 0x10000;
261 str += String.fromCharCode((c >> 10) + 0xD800);
262 str += String.fromCharCode((c & 0x3FF) + 0xDC00);
263 }
264 }
265 return str;
266 };
267 } else {
268 utf8Base64Encode = function (str) {
269 var result = '';
270 for (var i = 0; i < str.length; i++) {
271 var charcode = str.charCodeAt(i);
272 if (charcode < 0x80) {
273 result += String.fromCharCode(charcode);
274 } else if (charcode < 0x800) {
275 result += String.fromCharCode(0xc0 | (charcode >> 6)) +
276 String.fromCharCode(0x80 | (charcode & 0x3f));
277 } else if (charcode < 0xd800 || charcode >= 0xe000) {
278 result += String.fromCharCode(0xe0 | (charcode >> 12)) +
279 String.fromCharCode(0x80 | ((charcode >> 6) & 0x3f)) +
280 String.fromCharCode(0x80 | (charcode & 0x3f));
281 } else {
282 charcode = 0x10000 + (((charcode & 0x3ff) << 10) | (str.charCodeAt(++i) & 0x3ff));
283 result += String.fromCharCode(0xf0 | (charcode >> 18)) +
284 String.fromCharCode(0x80 | ((charcode >> 12) & 0x3f)) +
285 String.fromCharCode(0x80 | ((charcode >> 6) & 0x3f)) +
286 String.fromCharCode(0x80 | (charcode & 0x3f));
287 }
288 }
289 return btoa(result);
290 };
291
292 utf8Base64Decode = function (base64Str) {
293 var tmpStr = atob(base64Str.trim('=').replace(/-/g, '+').replace(/_/g, '/'));
294 if (!/[^\x00-\x7F]/.test(tmpStr)) {
295 return tmpStr;
296 }
297 var str = '', i = 0, length = tmpStr.length, followingChars = 0, b, c;
298 while (i < length) {
299 b = tmpStr.charCodeAt(i++);
300 if (b <= 0x7F) {
301 str += String.fromCharCode(b);
302 continue;
303 } else if (b > 0xBF && b <= 0xDF) {
304 c = b & 0x1F;
305 followingChars = 1;
306 } else if (b <= 0xEF) {
307 c = b & 0x0F;
308 followingChars = 2;
309 } else if (b <= 0xF7) {
310 c = b & 0x07;
311 followingChars = 3;
312 } else {
313 throw 'not a UTF-8 string';
314 }
315
316 for (var j = 0; j < followingChars; ++j) {
317 b = tmpStr.charCodeAt(i++);
318 if (b < 0x80 || b > 0xBF) {
319 throw 'not a UTF-8 string';
320 }
321 c <<= 6;
322 c += b & 0x3F;
323 }
324 if (c >= 0xD800 && c <= 0xDFFF) {
325 throw 'not a UTF-8 string';
326 }
327 if (c > 0x10FFFF) {
328 throw 'not a UTF-8 string';
329 }
330
331 if (c <= 0xFFFF) {
332 str += String.fromCharCode(c);
333 } else {
334 c -= 0x10000;
335 str += String.fromCharCode((c >> 10) + 0xD800);
336 str += String.fromCharCode((c & 0x3FF) + 0xDC00);
337 }
338 }
339 return str;
340 };
341 }
342
343 var encode = function (str, asciiOnly) {
344 var notString = typeof(str) != 'string';
345 if (notString && str.constructor === root.ArrayBuffer) {
346 str = new Uint8Array(str);
347 }
348 if (notString) {
349 return encodeFromBytes(str);
350 } else {
351 if (!asciiOnly && /[^\x00-\x7F]/.test(str)) {
352 return utf8Base64Encode(str);
353 } else {
354 return btoa(str);
355 }
356 }
357 };
358
359 var decode = function (base64Str, asciiOnly) {
360 return asciiOnly ? atob(base64Str) : utf8Base64Decode(base64Str);
361 };
362
363 var exports = {
364 encode: encode,
365 decode: decode,
366 atob: atob,
367 btoa: btoa
368 };
369 decode.bytes = decodeAsBytes;
370 decode.string = decode;
371
372 root.pagelayer_Base64 = exports;
373 })();
374