legacy-libs/@protobufjs/float/index.js

   1 "use strict";\r
   2 \r
   3 module.exports = factory(factory);\r
   4 \r
   5 /**\r
   6  * Reads / writes floats / doubles from / to buffers.\r
   7  * @name util.float\r
   8  * @namespace\r
   9  */\r
  10 \r
  11 /**\r
  12  * Writes a 32 bit float to a buffer using little endian byte order.\r
  13  * @name util.float.writeFloatLE\r
  14  * @function\r
  15  * @param {number} val Value to write\r
  16  * @param {Uint8Array} buf Target buffer\r
  17  * @param {number} pos Target buffer offset\r
  18  * @returns {undefined}\r
  19  */\r
  20 \r
  21 /**\r
  22  * Writes a 32 bit float to a buffer using big endian byte order.\r
  23  * @name util.float.writeFloatBE\r
  24  * @function\r
  25  * @param {number} val Value to write\r
  26  * @param {Uint8Array} buf Target buffer\r
  27  * @param {number} pos Target buffer offset\r
  28  * @returns {undefined}\r
  29  */\r
  30 \r
  31 /**\r
  32  * Reads a 32 bit float from a buffer using little endian byte order.\r
  33  * @name util.float.readFloatLE\r
  34  * @function\r
  35  * @param {Uint8Array} buf Source buffer\r
  36  * @param {number} pos Source buffer offset\r
  37  * @returns {number} Value read\r
  38  */\r
  39 \r
  40 /**\r
  41  * Reads a 32 bit float from a buffer using big endian byte order.\r
  42  * @name util.float.readFloatBE\r
  43  * @function\r
  44  * @param {Uint8Array} buf Source buffer\r
  45  * @param {number} pos Source buffer offset\r
  46  * @returns {number} Value read\r
  47  */\r
  48 \r
  49 /**\r
  50  * Writes a 64 bit double to a buffer using little endian byte order.\r
  51  * @name util.float.writeDoubleLE\r
  52  * @function\r
  53  * @param {number} val Value to write\r
  54  * @param {Uint8Array} buf Target buffer\r
  55  * @param {number} pos Target buffer offset\r
  56  * @returns {undefined}\r
  57  */\r
  58 \r
  59 /**\r
  60  * Writes a 64 bit double to a buffer using big endian byte order.\r
  61  * @name util.float.writeDoubleBE\r
  62  * @function\r
  63  * @param {number} val Value to write\r
  64  * @param {Uint8Array} buf Target buffer\r
  65  * @param {number} pos Target buffer offset\r
  66  * @returns {undefined}\r
  67  */\r
  68 \r
  69 /**\r
  70  * Reads a 64 bit double from a buffer using little endian byte order.\r
  71  * @name util.float.readDoubleLE\r
  72  * @function\r
  73  * @param {Uint8Array} buf Source buffer\r
  74  * @param {number} pos Source buffer offset\r
  75  * @returns {number} Value read\r
  76  */\r
  77 \r
  78 /**\r
  79  * Reads a 64 bit double from a buffer using big endian byte order.\r
  80  * @name util.float.readDoubleBE\r
  81  * @function\r
  82  * @param {Uint8Array} buf Source buffer\r
  83  * @param {number} pos Source buffer offset\r
  84  * @returns {number} Value read\r
  85  */\r
  86 \r
  87 // Factory function for the purpose of node-based testing in modified global environments\r
  88 function factory(exports) {\r
  89 \r
  90     // float: typed array\r
  91     if (typeof Float32Array !== "undefined") (function() {\r
  92 \r
  93         var f32 = new Float32Array([ -0 ]),\r
  94             f8b = new Uint8Array(f32.buffer),\r
  95             le  = f8b[3] === 128;\r
  96 \r
  97         function writeFloat_f32_cpy(val, buf, pos) {\r
  98             f32[0] = val;\r
  99             buf[pos    ] = f8b[0];\r
 100             buf[pos + 1] = f8b[1];\r
 101             buf[pos + 2] = f8b[2];\r
 102             buf[pos + 3] = f8b[3];\r
 103         }\r
 104 \r
 105         function writeFloat_f32_rev(val, buf, pos) {\r
 106             f32[0] = val;\r
 107             buf[pos    ] = f8b[3];\r
 108             buf[pos + 1] = f8b[2];\r
 109             buf[pos + 2] = f8b[1];\r
 110             buf[pos + 3] = f8b[0];\r
 111         }\r
 112 \r
 113         /* istanbul ignore next */\r
 114         exports.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;\r
 115         /* istanbul ignore next */\r
 116         exports.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;\r
 117 \r
 118         function readFloat_f32_cpy(buf, pos) {\r
 119             f8b[0] = buf[pos    ];\r
 120             f8b[1] = buf[pos + 1];\r
 121             f8b[2] = buf[pos + 2];\r
 122             f8b[3] = buf[pos + 3];\r
 123             return f32[0];\r
 124         }\r
 125 \r
 126         function readFloat_f32_rev(buf, pos) {\r
 127             f8b[3] = buf[pos    ];\r
 128             f8b[2] = buf[pos + 1];\r
 129             f8b[1] = buf[pos + 2];\r
 130             f8b[0] = buf[pos + 3];\r
 131             return f32[0];\r
 132         }\r
 133 \r
 134         /* istanbul ignore next */\r
 135         exports.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;\r
 136         /* istanbul ignore next */\r
 137         exports.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;\r
 138 \r
 139     // float: ieee754\r
 140     })(); else (function() {\r
 141 \r
 142         function writeFloat_ieee754(writeUint, val, buf, pos) {\r
 143             var sign = val < 0 ? 1 : 0;\r
 144             if (sign)\r
 145                 val = -val;\r
 146             if (val === 0)\r
 147                 writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos);\r
 148             else if (isNaN(val))\r
 149                 writeUint(2143289344, buf, pos);\r
 150             else if (val > 3.4028234663852886e+38) // +-Infinity\r
 151                 writeUint((sign << 31 | 2139095040) >>> 0, buf, pos);\r
 152             else if (val < 1.1754943508222875e-38) // denormal\r
 153                 writeUint((sign << 31 | Math.round(val / 1.401298464324817e-45)) >>> 0, buf, pos);\r
 154             else {\r
 155                 var exponent = Math.floor(Math.log(val) / Math.LN2),\r
 156                     mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607;\r
 157                 writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos);\r
 158             }\r
 159         }\r
 160 \r
 161         exports.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);\r
 162         exports.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);\r
 163 \r
 164         function readFloat_ieee754(readUint, buf, pos) {\r
 165             var uint = readUint(buf, pos),\r
 166                 sign = (uint >> 31) * 2 + 1,\r
 167                 exponent = uint >>> 23 & 255,\r
 168                 mantissa = uint & 8388607;\r
 169             return exponent === 255\r
 170                 ? mantissa\r
 171                 ? NaN\r
 172                 : sign * Infinity\r
 173                 : exponent === 0 // denormal\r
 174                 ? sign * 1.401298464324817e-45 * mantissa\r
 175                 : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);\r
 176         }\r
 177 \r
 178         exports.readFloatLE = readFloat_ieee754.bind(null, readUintLE);\r
 179         exports.readFloatBE = readFloat_ieee754.bind(null, readUintBE);\r
 180 \r
 181     })();\r
 182 \r
 183     // double: typed array\r
 184     if (typeof Float64Array !== "undefined") (function() {\r
 185 \r
 186         var f64 = new Float64Array([-0]),\r
 187             f8b = new Uint8Array(f64.buffer),\r
 188             le  = f8b[7] === 128;\r
 189 \r
 190         function writeDouble_f64_cpy(val, buf, pos) {\r
 191             f64[0] = val;\r
 192             buf[pos    ] = f8b[0];\r
 193             buf[pos + 1] = f8b[1];\r
 194             buf[pos + 2] = f8b[2];\r
 195             buf[pos + 3] = f8b[3];\r
 196             buf[pos + 4] = f8b[4];\r
 197             buf[pos + 5] = f8b[5];\r
 198             buf[pos + 6] = f8b[6];\r
 199             buf[pos + 7] = f8b[7];\r
 200         }\r
 201 \r
 202         function writeDouble_f64_rev(val, buf, pos) {\r
 203             f64[0] = val;\r
 204             buf[pos    ] = f8b[7];\r
 205             buf[pos + 1] = f8b[6];\r
 206             buf[pos + 2] = f8b[5];\r
 207             buf[pos + 3] = f8b[4];\r
 208             buf[pos + 4] = f8b[3];\r
 209             buf[pos + 5] = f8b[2];\r
 210             buf[pos + 6] = f8b[1];\r
 211             buf[pos + 7] = f8b[0];\r
 212         }\r
 213 \r
 214         /* istanbul ignore next */\r
 215         exports.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;\r
 216         /* istanbul ignore next */\r
 217         exports.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;\r
 218 \r
 219         function readDouble_f64_cpy(buf, pos) {\r
 220             f8b[0] = buf[pos    ];\r
 221             f8b[1] = buf[pos + 1];\r
 222             f8b[2] = buf[pos + 2];\r
 223             f8b[3] = buf[pos + 3];\r
 224             f8b[4] = buf[pos + 4];\r
 225             f8b[5] = buf[pos + 5];\r
 226             f8b[6] = buf[pos + 6];\r
 227             f8b[7] = buf[pos + 7];\r
 228             return f64[0];\r
 229         }\r
 230 \r
 231         function readDouble_f64_rev(buf, pos) {\r
 232             f8b[7] = buf[pos    ];\r
 233             f8b[6] = buf[pos + 1];\r
 234             f8b[5] = buf[pos + 2];\r
 235             f8b[4] = buf[pos + 3];\r
 236             f8b[3] = buf[pos + 4];\r
 237             f8b[2] = buf[pos + 5];\r
 238             f8b[1] = buf[pos + 6];\r
 239             f8b[0] = buf[pos + 7];\r
 240             return f64[0];\r
 241         }\r
 242 \r
 243         /* istanbul ignore next */\r
 244         exports.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;\r
 245         /* istanbul ignore next */\r
 246         exports.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;\r
 247 \r
 248     // double: ieee754\r
 249     })(); else (function() {\r
 250 \r
 251         function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {\r
 252             var sign = val < 0 ? 1 : 0;\r
 253             if (sign)\r
 254                 val = -val;\r
 255             if (val === 0) {\r
 256                 writeUint(0, buf, pos + off0);\r
 257                 writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos + off1);\r
 258             } else if (isNaN(val)) {\r
 259                 writeUint(0, buf, pos + off0);\r
 260                 writeUint(2146959360, buf, pos + off1);\r
 261             } else if (val > 1.7976931348623157e+308) { // +-Infinity\r
 262                 writeUint(0, buf, pos + off0);\r
 263                 writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1);\r
 264             } else {\r
 265                 var mantissa;\r
 266                 if (val < 2.2250738585072014e-308) { // denormal\r
 267                     mantissa = val / 5e-324;\r
 268                     writeUint(mantissa >>> 0, buf, pos + off0);\r
 269                     writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1);\r
 270                 } else {\r
 271                     var exponent = Math.floor(Math.log(val) / Math.LN2);\r
 272                     if (exponent === 1024)\r
 273                         exponent = 1023;\r
 274                     mantissa = val * Math.pow(2, -exponent);\r
 275                     writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);\r
 276                     writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);\r
 277                 }\r
 278             }\r
 279         }\r
 280 \r
 281         exports.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);\r
 282         exports.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);\r
 283 \r
 284         function readDouble_ieee754(readUint, off0, off1, buf, pos) {\r
 285             var lo = readUint(buf, pos + off0),\r
 286                 hi = readUint(buf, pos + off1);\r
 287             var sign = (hi >> 31) * 2 + 1,\r
 288                 exponent = hi >>> 20 & 2047,\r
 289                 mantissa = 4294967296 * (hi & 1048575) + lo;\r
 290             return exponent === 2047\r
 291                 ? mantissa\r
 292                 ? NaN\r
 293                 : sign * Infinity\r
 294                 : exponent === 0 // denormal\r
 295                 ? sign * 5e-324 * mantissa\r
 296                 : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);\r
 297         }\r
 298 \r
 299         exports.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);\r
 300         exports.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);\r
 301 \r
 302     })();\r
 303 \r
 304     return exports;\r
 305 }\r
 306 \r
 307 // uint helpers\r
 308 \r
 309 function writeUintLE(val, buf, pos) {\r
 310     buf[pos    ] =  val        & 255;\r
 311     buf[pos + 1] =  val >>> 8  & 255;\r
 312     buf[pos + 2] =  val >>> 16 & 255;\r
 313     buf[pos + 3] =  val >>> 24;\r
 314 }\r
 315 \r
 316 function writeUintBE(val, buf, pos) {\r
 317     buf[pos    ] =  val >>> 24;\r
 318     buf[pos + 1] =  val >>> 16 & 255;\r
 319     buf[pos + 2] =  val >>> 8  & 255;\r
 320     buf[pos + 3] =  val        & 255;\r
 321 }\r
 322 \r
 323 function readUintLE(buf, pos) {\r
 324     return (buf[pos    ]\r
 325           | buf[pos + 1] << 8\r
 326           | buf[pos + 2] << 16\r
 327           | buf[pos + 3] << 24) >>> 0;\r
 328 }\r
 329 \r
 330 function readUintBE(buf, pos) {\r
 331     return (buf[pos    ] << 24\r
 332           | buf[pos + 1] << 16\r
 333           | buf[pos + 2] << 8\r
 334           | buf[pos + 3]) >>> 0;\r
 335 }\r