|
8 | 8 | */ |
9 | 9 |
|
10 | 10 | (bufferify => { |
11 | | - const types = { |
12 | | - Uint8: { |
13 | | - val: 0, |
| 11 | + const types = [ |
| 12 | + { |
| 13 | + type: 'Uint8', |
14 | 14 | offset: 1 |
15 | 15 | }, |
16 | | - Int8: { |
17 | | - val: 1, |
| 16 | + { |
| 17 | + type: 'Int8', |
18 | 18 | offset: 1 |
19 | 19 | }, |
20 | | - Uint16: { |
21 | | - val: 2, |
| 20 | + { |
| 21 | + type: 'Uint16', |
22 | 22 | offset: 2 |
23 | 23 | }, |
24 | | - Int16: { |
25 | | - val: 3, |
| 24 | + { |
| 25 | + type: 'Int16', |
26 | 26 | offset: 2 |
27 | 27 | }, |
28 | | - Uint32: { |
29 | | - val: 4, |
| 28 | + { |
| 29 | + type: 'Uint32', |
30 | 30 | offset: 4 |
31 | 31 | }, |
32 | | - Int32: { |
33 | | - val: 5, |
| 32 | + { |
| 33 | + type: 'Int32', |
34 | 34 | offset: 4 |
35 | 35 | }, |
36 | | - Float32: { |
37 | | - val: 6, |
| 36 | + { |
| 37 | + type: 'Float32', |
38 | 38 | offset: 4 |
39 | 39 | }, |
40 | | - Float64: { |
41 | | - val: 7, |
| 40 | + { |
| 41 | + type: 'Float64', |
42 | 42 | offset: 8 |
43 | 43 | } |
44 | | - }; |
| 44 | + ]; |
45 | 45 |
|
46 | 46 | /** |
47 | 47 | * Extend anything. |
|
52 | 52 | let val, |
53 | 53 | deep; |
54 | 54 | if (typeof args[0] === 'boolean') { |
55 | | - val = [].slice.call(args, 1); |
| 55 | + val = args.slice(1); |
56 | 56 | deep = args[0]; |
57 | 57 | } else { |
58 | | - val = [].slice.call(args); |
| 58 | + val = args.slice(); |
59 | 59 | } |
60 | 60 | val.forEach(obj => { |
61 | 61 | if (obj instanceof Object) { |
|
76 | 76 | const encode = (offset, data) => { |
77 | 77 | let arr = [], |
78 | 78 | view = new DataView(new ArrayBuffer(_encode(offset, arr, data))); |
79 | | - arr.forEach(item => { |
80 | | - view[`set${item.type}`](item.offset, item.val); |
| 79 | + arr.forEach(obj => { |
| 80 | + view[`set${obj.type}`](obj.offset, obj.val); |
81 | 81 | }); |
82 | 82 | return view; |
83 | 83 | }; |
|
106 | 106 | offset = _encode(offset, arr, data[key]); |
107 | 107 | } else if (typeof data[key] === 'number') { |
108 | 108 | let flag, |
109 | | - type; |
| 109 | + val; |
110 | 110 | if (data[key] % 1 || (flag = data[key] < Math.pow(-2, 31) || data[key] > Math.pow(2, 32) - 1)) { |
111 | | - type = flag || data[key] < -3.4e38 || data[key] > 3.4e38 ? 'Float64' : 'Float32'; |
| 111 | + val = flag || data[key] < -3.4e38 || data[key] > 3.4e38 ? 7 : 6; |
112 | 112 | } else { |
113 | 113 | if (data[key] < 0) { |
114 | | - type = data[key] > Math.pow(-2, 7) ? 'Int8' : data[key] > Math.pow(-2, 15) ? 'Int16' : 'Int32'; |
| 114 | + val = data[key] > Math.pow(-2, 7) ? 1 : data[key] > Math.pow(-2, 15) ? 3 : 5; |
115 | 115 | } else { |
116 | | - type = data[key] < Math.pow(2, 8) ? 'Uint8' : data[key] < Math.pow(2, 16) ? 'Uint16' : 'Uint32'; |
| 116 | + val = data[key] < Math.pow(2, 8) ? 0 : data[key] < Math.pow(2, 16) ? 2 : 4; |
117 | 117 | } |
118 | 118 | } |
119 | 119 | arr.push({ |
120 | | - val: types[type].val, |
| 120 | + val, |
121 | 121 | type: 'Uint8', |
122 | 122 | offset: offset++ |
123 | 123 | }, { |
124 | 124 | val: data[key], |
125 | | - type, |
| 125 | + type: types[val].type, |
126 | 126 | offset |
127 | 127 | }); |
128 | | - offset += types[type].offset; |
| 128 | + offset += types[val].offset; |
129 | 129 | } else if (typeof data[key] === 'boolean') { |
130 | 130 | arr.push({ |
131 | 131 | val: data[key] ? 1 : 0, |
|
178 | 178 | if (template instanceof Object) { |
179 | 179 | view = source instanceof DataView ? source : new DataView(source instanceof ArrayBuffer ? source : new Uint8Array(source).buffer); |
180 | 180 | if (template instanceof Array && (template.length = view.getUint8(offset++))) { |
181 | | - template.join().split(',').forEach((item, i) => template[i] = extend(true, template[0] instanceof Array ? [] : {}, template[0])); |
| 181 | + template.fill(null, 1).forEach((tmpl, i) => template[i] = extend(true, template[0] instanceof Array ? [] : {}, template[0])); |
182 | 182 | } |
183 | 183 | if (template instanceof Array && template[0] instanceof Object) { |
184 | | - template.forEach(item => offset = _decode(offset, item, view)); |
| 184 | + template.forEach(tmpl => offset = _decode(offset, tmpl, view)); |
185 | 185 | } else { |
186 | | - Object.keys(template).sort().forEach(item => { |
187 | | - if (template[item] instanceof Object) { |
188 | | - offset = _decode(offset, template[item], view); |
189 | | - } else if (template[item] === 'number') { |
190 | | - switch (view.getUint8(offset++)) { |
191 | | - case 0: |
192 | | - template[item] = view.getUint8(offset); |
193 | | - offset += 1; |
194 | | - break; |
195 | | - case 1: |
196 | | - template[item] = view.getInt8(offset); |
197 | | - offset += 1; |
198 | | - break; |
199 | | - case 2: |
200 | | - template[item] = view.getUint16(offset); |
201 | | - offset += 2; |
202 | | - break; |
203 | | - case 3: |
204 | | - template[item] = view.getInt16(offset); |
205 | | - offset += 2; |
206 | | - break; |
207 | | - case 4: |
208 | | - template[item] = view.getUint32(offset); |
209 | | - offset += 4; |
210 | | - break; |
211 | | - case 5: |
212 | | - template[item] = view.getInt32(offset); |
213 | | - offset += 4; |
214 | | - break; |
215 | | - case 6: |
216 | | - template[item] = view.getFloat32(offset); |
217 | | - offset += 4; |
218 | | - break; |
219 | | - case 7: |
220 | | - template[item] = view.getFloat64(offset); |
221 | | - offset += 8; |
222 | | - break; |
223 | | - } |
224 | | - } else if (template[item] === 'boolean') { |
225 | | - template[item] = !!view.getUint8(offset++); |
| 186 | + Object.keys(template).sort().forEach(key => { |
| 187 | + if (template[key] instanceof Object) { |
| 188 | + offset = _decode(offset, template[key], view); |
| 189 | + } else if (template[key] === 'number') { |
| 190 | + let obj = types[view.getUint8(offset++)]; |
| 191 | + template[key] = view[`get${obj.type}`](offset); |
| 192 | + offset += obj.offset; |
| 193 | + } else if (template[key] === 'boolean') { |
| 194 | + template[key] = !!view.getUint8(offset++); |
226 | 195 | } else { |
227 | | - template[item] = (template[item] = view.getUint8(offset++)) ? String.fromCharCode.apply(null, new Array(template[item]).join().split(',').map(() => { |
| 196 | + template[key] = (template[key] = view.getUint8(offset++)) ? String.fromCharCode(...Array(template[key]).fill().map(() => { |
228 | 197 | let code = view.getUint16(offset); |
229 | 198 | offset += 2; |
230 | 199 | return code; |
|
0 commit comments