summaryrefslogtreecommitdiffstats
path: root/toolkit/jetpack/sdk/io/buffer.js
diff options
context:
space:
mode:
authorMatt A. Tobin <email@mattatobin.com>2018-02-09 06:46:43 -0500
committerMatt A. Tobin <email@mattatobin.com>2018-02-09 06:46:43 -0500
commitac46df8daea09899ce30dc8fd70986e258c746bf (patch)
tree2750d3125fc253fd5b0671e4bd268eff1fd97296 /toolkit/jetpack/sdk/io/buffer.js
parent8cecf8d5208f3945b35f879bba3015bb1a11bec6 (diff)
downloadUXP-ac46df8daea09899ce30dc8fd70986e258c746bf.tar
UXP-ac46df8daea09899ce30dc8fd70986e258c746bf.tar.gz
UXP-ac46df8daea09899ce30dc8fd70986e258c746bf.tar.lz
UXP-ac46df8daea09899ce30dc8fd70986e258c746bf.tar.xz
UXP-ac46df8daea09899ce30dc8fd70986e258c746bf.zip
Move Add-on SDK source to toolkit/jetpack
Diffstat (limited to 'toolkit/jetpack/sdk/io/buffer.js')
-rw-r--r--toolkit/jetpack/sdk/io/buffer.js351
1 files changed, 351 insertions, 0 deletions
diff --git a/toolkit/jetpack/sdk/io/buffer.js b/toolkit/jetpack/sdk/io/buffer.js
new file mode 100644
index 000000000..5ea169402
--- /dev/null
+++ b/toolkit/jetpack/sdk/io/buffer.js
@@ -0,0 +1,351 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+'use strict';
+
+module.metadata = {
+ 'stability': 'experimental'
+};
+
+/*
+ * Encodings supported by TextEncoder/Decoder:
+ * utf-8, utf-16le, utf-16be
+ * http://encoding.spec.whatwg.org/#interface-textencoder
+ *
+ * Node however supports the following encodings:
+ * ascii, utf-8, utf-16le, usc2, base64, hex
+ */
+
+const { Cu } = require('chrome');
+const { isNumber } = require('sdk/lang/type');
+const { TextEncoder, TextDecoder } = Cu.import('resource://gre/modules/commonjs/toolkit/loader.js', {});
+
+exports.TextEncoder = TextEncoder;
+exports.TextDecoder = TextDecoder;
+
+/**
+ * Use WeakMaps to work around Bug 929146, which prevents us from adding
+ * getters or values to typed arrays
+ * https://bugzilla.mozilla.org/show_bug.cgi?id=929146
+ */
+const parents = new WeakMap();
+const views = new WeakMap();
+
+function Buffer(subject, encoding /*, bufferLength */) {
+
+ // Allow invocation without `new` constructor
+ if (!(this instanceof Buffer))
+ return new Buffer(subject, encoding, arguments[2]);
+
+ var type = typeof(subject);
+
+ switch (type) {
+ case 'number':
+ // Create typed array of the given size if number.
+ try {
+ let buffer = new Uint8Array(subject > 0 ? Math.floor(subject) : 0);
+ return buffer;
+ } catch (e) {
+ if (/size and count too large/.test(e.message) ||
+ /invalid arguments/.test(e.message))
+ throw new RangeError('Could not instantiate buffer: size of buffer may be too large');
+ else
+ throw new Error('Could not instantiate buffer');
+ }
+ break;
+ case 'string':
+ // If string encode it and use buffer for the returned Uint8Array
+ // to create a local patched version that acts like node buffer.
+ encoding = encoding || 'utf8';
+ return new Uint8Array(new TextEncoder(encoding).encode(subject).buffer);
+ case 'object':
+ // This form of the constructor uses the form of
+ // new Uint8Array(buffer, offset, length);
+ // So we can instantiate a typed array within the constructor
+ // to inherit the appropriate properties, where both the
+ // `subject` and newly instantiated buffer share the same underlying
+ // data structure.
+ if (arguments.length === 3)
+ return new Uint8Array(subject, encoding, arguments[2]);
+ // If array or alike just make a copy with a local patched prototype.
+ else
+ return new Uint8Array(subject);
+ default:
+ throw new TypeError('must start with number, buffer, array or string');
+ }
+}
+exports.Buffer = Buffer;
+
+// Tests if `value` is a Buffer.
+Buffer.isBuffer = value => value instanceof Buffer
+
+// Returns true if the encoding is a valid encoding argument & false otherwise
+Buffer.isEncoding = function (encoding) {
+ if (!encoding) return false;
+ try {
+ new TextDecoder(encoding);
+ } catch(e) {
+ return false;
+ }
+ return true;
+}
+
+// Gives the actual byte length of a string. encoding defaults to 'utf8'.
+// This is not the same as String.prototype.length since that returns the
+// number of characters in a string.
+Buffer.byteLength = (value, encoding = 'utf8') =>
+ new TextEncoder(encoding).encode(value).byteLength
+
+// Direct copy of the nodejs's buffer implementation:
+// https://github.com/joyent/node/blob/b255f4c10a80343f9ce1cee56d0288361429e214/lib/buffer.js#L146-L177
+Buffer.concat = function(list, length) {
+ if (!Array.isArray(list))
+ throw new TypeError('Usage: Buffer.concat(list[, length])');
+
+ if (typeof length === 'undefined') {
+ length = 0;
+ for (var i = 0; i < list.length; i++)
+ length += list[i].length;
+ } else {
+ length = ~~length;
+ }
+
+ if (length < 0)
+ length = 0;
+
+ if (list.length === 0)
+ return new Buffer(0);
+ else if (list.length === 1)
+ return list[0];
+
+ if (length < 0)
+ throw new RangeError('length is not a positive number');
+
+ var buffer = new Buffer(length);
+ var pos = 0;
+ for (var i = 0; i < list.length; i++) {
+ var buf = list[i];
+ buf.copy(buffer, pos);
+ pos += buf.length;
+ }
+
+ return buffer;
+};
+
+// Node buffer is very much like Uint8Array although it has bunch of methods
+// that typically can be used in combination with `DataView` while preserving
+// access by index. Since in SDK each module has it's own set of bult-ins it
+// ok to patch ours to make it nodejs Buffer compatible.
+const Uint8ArraySet = Uint8Array.prototype.set
+Buffer.prototype = Uint8Array.prototype;
+Object.defineProperties(Buffer.prototype, {
+ parent: {
+ get: function() { return parents.get(this, undefined); }
+ },
+ view: {
+ get: function () {
+ let view = views.get(this, undefined);
+ if (view) return view;
+ view = new DataView(this.buffer);
+ views.set(this, view);
+ return view;
+ }
+ },
+ toString: {
+ value: function(encoding, start, end) {
+ encoding = !!encoding ? (encoding + '').toLowerCase() : 'utf8';
+ start = Math.max(0, ~~start);
+ end = Math.min(this.length, end === void(0) ? this.length : ~~end);
+ return new TextDecoder(encoding).decode(this.subarray(start, end));
+ }
+ },
+ toJSON: {
+ value: function() {
+ return { type: 'Buffer', data: Array.slice(this, 0) };
+ }
+ },
+ get: {
+ value: function(offset) {
+ return this[offset];
+ }
+ },
+ set: {
+ value: function(offset, value) { this[offset] = value; }
+ },
+ copy: {
+ value: function(target, offset, start, end) {
+ let length = this.length;
+ let targetLength = target.length;
+ offset = isNumber(offset) ? offset : 0;
+ start = isNumber(start) ? start : 0;
+
+ if (start < 0)
+ throw new RangeError('sourceStart is outside of valid range');
+ if (end < 0)
+ throw new RangeError('sourceEnd is outside of valid range');
+
+ // If sourceStart > sourceEnd, or targetStart > targetLength,
+ // zero bytes copied
+ if (start > end ||
+ offset > targetLength
+ )
+ return 0;
+
+ // If `end` is not defined, or if it is defined
+ // but would overflow `target`, redefine `end`
+ // so we can copy as much as we can
+ if (end - start > targetLength - offset ||
+ end == null) {
+ let remainingTarget = targetLength - offset;
+ let remainingSource = length - start;
+ if (remainingSource <= remainingTarget)
+ end = length;
+ else
+ end = start + remainingTarget;
+ }
+
+ Uint8ArraySet.call(target, this.subarray(start, end), offset);
+ return end - start;
+ }
+ },
+ slice: {
+ value: function(start, end) {
+ let length = this.length;
+ start = ~~start;
+ end = end != null ? end : length;
+
+ if (start < 0) {
+ start += length;
+ if (start < 0) start = 0;
+ } else if (start > length)
+ start = length;
+
+ if (end < 0) {
+ end += length;
+ if (end < 0) end = 0;
+ } else if (end > length)
+ end = length;
+
+ if (end < start)
+ end = start;
+
+ // This instantiation uses the new Uint8Array(buffer, offset, length) version
+ // of construction to share the same underling data structure
+ let buffer = new Buffer(this.buffer, start, end - start);
+
+ // If buffer has a value, assign its parent value to the
+ // buffer it shares its underlying structure with. If a slice of
+ // a slice, then use the root structure
+ if (buffer.length > 0)
+ parents.set(buffer, this.parent || this);
+
+ return buffer;
+ }
+ },
+ write: {
+ value: function(string, offset, length, encoding = 'utf8') {
+ // write(string, encoding);
+ if (typeof(offset) === 'string' && Number.isNaN(parseInt(offset))) {
+ [offset, length, encoding] = [0, null, offset];
+ }
+ // write(string, offset, encoding);
+ else if (typeof(length) === 'string')
+ [length, encoding] = [null, length];
+
+ if (offset < 0 || offset > this.length)
+ throw new RangeError('offset is outside of valid range');
+
+ offset = ~~offset;
+
+ // Clamp length if it would overflow buffer, or if its
+ // undefined
+ if (length == null || length + offset > this.length)
+ length = this.length - offset;
+
+ let buffer = new TextEncoder(encoding).encode(string);
+ let result = Math.min(buffer.length, length);
+ if (buffer.length !== length)
+ buffer = buffer.subarray(0, length);
+
+ Uint8ArraySet.call(this, buffer, offset);
+ return result;
+ }
+ },
+ fill: {
+ value: function fill(value, start, end) {
+ let length = this.length;
+ value = value || 0;
+ start = start || 0;
+ end = end || length;
+
+ if (typeof(value) === 'string')
+ value = value.charCodeAt(0);
+ if (typeof(value) !== 'number' || isNaN(value))
+ throw TypeError('value is not a number');
+ if (end < start)
+ throw new RangeError('end < start');
+
+ // Fill 0 bytes; we're done
+ if (end === start)
+ return 0;
+ if (length == 0)
+ return 0;
+
+ if (start < 0 || start >= length)
+ throw RangeError('start out of bounds');
+
+ if (end < 0 || end > length)
+ throw RangeError('end out of bounds');
+
+ let index = start;
+ while (index < end) this[index++] = value;
+ }
+ }
+});
+
+// Define nodejs Buffer's getter and setter functions that just proxy
+// to internal DataView's equivalent methods.
+
+// TODO do we need to check architecture to see if it's default big/little endian?
+[['readUInt16LE', 'getUint16', true],
+ ['readUInt16BE', 'getUint16', false],
+ ['readInt16LE', 'getInt16', true],
+ ['readInt16BE', 'getInt16', false],
+ ['readUInt32LE', 'getUint32', true],
+ ['readUInt32BE', 'getUint32', false],
+ ['readInt32LE', 'getInt32', true],
+ ['readInt32BE', 'getInt32', false],
+ ['readFloatLE', 'getFloat32', true],
+ ['readFloatBE', 'getFloat32', false],
+ ['readDoubleLE', 'getFloat64', true],
+ ['readDoubleBE', 'getFloat64', false],
+ ['readUInt8', 'getUint8'],
+ ['readInt8', 'getInt8']].forEach(([alias, name, littleEndian]) => {
+ Object.defineProperty(Buffer.prototype, alias, {
+ value: function(offset) {
+ return this.view[name](offset, littleEndian);
+ }
+ });
+});
+
+[['writeUInt16LE', 'setUint16', true],
+ ['writeUInt16BE', 'setUint16', false],
+ ['writeInt16LE', 'setInt16', true],
+ ['writeInt16BE', 'setInt16', false],
+ ['writeUInt32LE', 'setUint32', true],
+ ['writeUInt32BE', 'setUint32', false],
+ ['writeInt32LE', 'setInt32', true],
+ ['writeInt32BE', 'setInt32', false],
+ ['writeFloatLE', 'setFloat32', true],
+ ['writeFloatBE', 'setFloat32', false],
+ ['writeDoubleLE', 'setFloat64', true],
+ ['writeDoubleBE', 'setFloat64', false],
+ ['writeUInt8', 'setUint8'],
+ ['writeInt8', 'setInt8']].forEach(([alias, name, littleEndian]) => {
+ Object.defineProperty(Buffer.prototype, alias, {
+ value: function(value, offset) {
+ return this.view[name](offset, value, littleEndian);
+ }
+ });
+});