pax_global_header00006660000000000000000000000064137570233650014525gustar00rootroot0000000000000052 comment=5436613585dac060da849f39ff56b159a10b8ba1 typedarray-to-buffer-4.0.0/000077500000000000000000000000001375702336500156015ustar00rootroot00000000000000typedarray-to-buffer-4.0.0/.airtap.yml000066400000000000000000000003661375702336500176670ustar00rootroot00000000000000sauce_connect: true loopback: airtap.local browsers: - name: chrome version: latest - name: firefox version: latest - name: safari version: latest - name: microsoftedge version: latest - name: iphone version: latest typedarray-to-buffer-4.0.0/.npmignore000066400000000000000000000000361375702336500175770ustar00rootroot00000000000000test/ .airtap.yml .travis.yml typedarray-to-buffer-4.0.0/.travis.yml000066400000000000000000000007401375702336500177130ustar00rootroot00000000000000language: node_js node_js: - lts/* addons: sauce_connect: true hosts: - airtap.local env: global: - secure: i51rE9rZGHbcZWlL58j3H1qtL23OIV2r0X4TcQKNI3pw2mubdHFJmfPNNO19ItfReu8wwQMxOehKamwaNvqMiKWyHfn/QcThFQysqzgGZ6AgnUbYx9od6XFNDeWd1sVBf7QBAL07y7KWlYGWCwFwWjabSVySzQhEBdisPcskfkI= - secure: BKq6/5z9LK3KDkTjs7BGeBZ1KsWgz+MsAXZ4P64NSeVGFaBdXU45+ww1mwxXFt5l22/mhyOQZfebQl+kGVqRSZ+DEgQeCymkNZ6CD8c6w6cLuOJXiXwuu/cDM2DD0tfGeu2YZC7yEikP7BqEFwH3D324rRzSGLF2RSAAwkOI7bE= typedarray-to-buffer-4.0.0/LICENSE000066400000000000000000000020711375702336500166060ustar00rootroot00000000000000The MIT License (MIT) Copyright (c) Feross Aboukhadijeh Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. typedarray-to-buffer-4.0.0/README.md000066400000000000000000000066071375702336500170710ustar00rootroot00000000000000# typedarray-to-buffer [![travis][travis-image]][travis-url] [![npm][npm-image]][npm-url] [![downloads][downloads-image]][downloads-url] [![javascript style guide][standard-image]][standard-url] [travis-image]: https://img.shields.io/travis/feross/typedarray-to-buffer/master.svg [travis-url]: https://travis-ci.org/feross/typedarray-to-buffer [npm-image]: https://img.shields.io/npm/v/typedarray-to-buffer.svg [npm-url]: https://npmjs.org/package/typedarray-to-buffer [downloads-image]: https://img.shields.io/npm/dm/typedarray-to-buffer.svg [downloads-url]: https://npmjs.org/package/typedarray-to-buffer [standard-image]: https://img.shields.io/badge/code_style-standard-brightgreen.svg [standard-url]: https://standardjs.com #### Convert a typed array to a [Buffer](https://github.com/feross/buffer) without a copy. [![saucelabs][saucelabs-image]][saucelabs-url] [saucelabs-image]: https://saucelabs.com/browser-matrix/typedarray-to-buffer.svg [saucelabs-url]: https://saucelabs.com/u/typedarray-to-buffer Say you're using the ['buffer'](https://github.com/feross/buffer) module on npm, or [browserify](http://browserify.org/) and you're working with lots of binary data. Unfortunately, sometimes the browser or someone else's API gives you a typed array like `Uint8Array` to work with and you need to convert it to a `Buffer`. What do you do? Of course: `Buffer.from(uint8array)` But, alas, every time you do `Buffer.from(uint8array)` **the entire array gets copied**. The `Buffer` constructor does a copy; this is defined by the [node docs](http://nodejs.org/api/buffer.html) and the 'buffer' module matches the node API exactly. So, how can we avoid this expensive copy in [performance critical applications](https://github.com/feross/buffer/issues/22)? ***Simply use this module, of course!*** If you have an `ArrayBuffer`, you don't need this module, because `Buffer.from(arrayBuffer)` [is already efficient](https://nodejs.org/api/buffer.html#buffer_class_method_buffer_from_arraybuffer_byteoffset_length). ## install ```bash npm install typedarray-to-buffer ``` ## usage To convert a typed array to a `Buffer` **without a copy**, do this: ```js var toBuffer = require('typedarray-to-buffer') var arr = new Uint8Array([1, 2, 3]) arr = toBuffer(arr) // arr is a buffer now! arr.toString() // '\u0001\u0002\u0003' arr.readUInt16BE(0) // 258 ``` ## how it works If the browser supports typed arrays, then `toBuffer` will **augment the typed array** you pass in with the `Buffer` methods and return it. See [how does Buffer work?](https://github.com/feross/buffer#how-does-it-work) for more about how augmentation works. This module uses the typed array's underlying `ArrayBuffer` to back the new `Buffer`. This respects the "view" on the `ArrayBuffer`, i.e. `byteOffset` and `byteLength`. In other words, if you do `toBuffer(new Uint32Array([1, 2, 3]))`, then the new `Buffer` will contain `[1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0]`, **not** `[1, 2, 3]`. And it still doesn't require a copy. If the browser doesn't support typed arrays, then `toBuffer` will create a new `Buffer` object, copy the data into it, and return it. There's no simple performance optimization we can do for old browsers. Oh well. If this module is used in node, then it will just call `Buffer.from`. This is just for the convenience of modules that work in both node and the browser. ## license MIT. Copyright (C) [Feross Aboukhadijeh](http://feross.org). typedarray-to-buffer-4.0.0/index.js000066400000000000000000000010501375702336500172420ustar00rootroot00000000000000/** * Convert a typed array to a Buffer without a copy * * Author: Feross Aboukhadijeh * License: MIT * * `npm install typedarray-to-buffer` */ module.exports = function typedarrayToBuffer (arr) { return ArrayBuffer.isView(arr) // To avoid a copy, use the typed array's underlying ArrayBuffer to back // new Buffer, respecting the "view", i.e. byteOffset and byteLength ? Buffer.from(arr.buffer, arr.byteOffset, arr.byteLength) // Pass through all other types to `Buffer.from` : Buffer.from(arr) } typedarray-to-buffer-4.0.0/package.json000066400000000000000000000021351375702336500200700ustar00rootroot00000000000000{ "name": "typedarray-to-buffer", "description": "Convert a typed array to a Buffer without a copy", "version": "4.0.0", "author": { "name": "Feross Aboukhadijeh", "email": "feross@feross.org", "url": "http://feross.org/" }, "bugs": { "url": "https://github.com/feross/typedarray-to-buffer/issues" }, "dependencies": {}, "devDependencies": { "airtap": "^3.0.0", "standard": "*", "tape": "^5.0.1" }, "homepage": "http://feross.org", "keywords": [ "buffer", "typed array", "convert", "no copy", "uint8array", "uint16array", "uint32array", "int16array", "int32array", "float32array", "float64array", "browser", "arraybuffer", "dataview" ], "license": "MIT", "main": "index.js", "repository": { "type": "git", "url": "git://github.com/feross/typedarray-to-buffer.git" }, "scripts": { "test": "standard && npm run test-node && npm run test-browser", "test-browser": "airtap -- test/*.js", "test-browser-local": "airtap --local -- test/*.js", "test-node": "tape test/*.js" } } typedarray-to-buffer-4.0.0/test/000077500000000000000000000000001375702336500165605ustar00rootroot00000000000000typedarray-to-buffer-4.0.0/test/basic.js000066400000000000000000000030751375702336500202040ustar00rootroot00000000000000const test = require('tape') const toBuffer = require('../') test('convert to buffer from Uint8Array', function (t) { let arr = new Uint8Array([1, 2, 3]) arr = toBuffer(arr) t.deepEqual(arr, Buffer.from([1, 2, 3]), 'contents equal') t.equal(arr.readUInt8(0), 1) t.equal(arr.readUInt8(1), 2) t.equal(arr.readUInt8(2), 3) t.ok(Buffer.isBuffer(arr), 'is buffer') t.ok(arr instanceof Uint8Array, 'is Uint8Array') t.end() }) test('convert to buffer from Uint8Array with larger underlying ArrayBuffer', function (t) { let arr = new Uint8Array([1, 2, 3]).subarray(1, 2) arr = toBuffer(arr) t.deepEqual(arr, Buffer.from([2]), 'contents equal') t.equal(arr.readUInt8(0), 2) t.ok(Buffer.isBuffer(arr), 'is buffer') t.ok(arr instanceof Uint8Array, 'is Uint8Array') t.end() }) test('convert to buffer from Uint32Array', function (t) { let arr = new Uint32Array([1, 2, 3]) arr = toBuffer(arr) t.deepEqual(arr, Buffer.from([1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0]), 'contents equal') t.equal(arr.readUInt32LE(0), 1) t.equal(arr.readUInt32LE(4), 2) t.equal(arr.readUInt32LE(8), 3) t.ok(Buffer.isBuffer(arr), 'is buffer') t.ok(arr instanceof Uint8Array, 'is Uint8Array') t.end() }) test('convert to buffer from Uint32Array with larger underlying ArrayBuffer', function (t) { let arr = new Uint32Array([1, 2, 3]).subarray(1, 2) arr = toBuffer(arr) t.deepEqual(arr, Buffer.from([2, 0, 0, 0]), 'contents equal') t.equal(arr.readUInt32LE(0), 2) t.ok(Buffer.isBuffer(arr), 'is buffer') t.ok(arr instanceof Uint8Array, 'is Uint8Array') t.end() })