- Migrated from https://github.com/Yetangitu/owncloud-apps

- substantial bit rot accrued in 4 years of non-maintenance which made Reader unusable
 - Reader now works reliably on public pages - or at least it _Works For Me™_

 - Refactored a substantial part of the code to comply to the "current" (ha ha) Nextcloud API
 - Dropped Owncloud compatibility for lack of a testing installation
 - Dropped IE (<11) support
 - Dropped compatibility with older (<20) Nextcloud versions
 - Dropped app-specific ajax code, now handled by SettingsController
 - Updated dependencies where applicable

vendor/bitjs/archive/archive.js

@@ -0,0 +1,341 @@
+/**
+ * archive.js
+ *
+ * Provides base functionality for unarchiving.
+ *
+ * Licensed under the MIT License
+ *
+ * Copyright(c) 2011 Google Inc.
+ */
+
+var bitjs = bitjs || {};
+bitjs.archive = bitjs.archive || {};
+
+/**
+ * An unarchive event.
+ */
+bitjs.archive.UnarchiveEvent = class {
+  /**
+   * @param {string} type The event type.
+   */
+  constructor(type) {
+    /**
+     * The event type.
+     * @type {string}
+     */
+    this.type = type;
+  }
+}
+
+/**
+ * The UnarchiveEvent types.
+ */
+bitjs.archive.UnarchiveEvent.Type = {
+  START: 'start',
+  PROGRESS: 'progress',
+  EXTRACT: 'extract',
+  FINISH: 'finish',
+  INFO: 'info',
+  ERROR: 'error'
+};
+
+/**
+ * Useful for passing info up to the client (for debugging).
+ */
+bitjs.archive.UnarchiveInfoEvent = class extends bitjs.archive.UnarchiveEvent {
+  /**
+   * @param {string} msg The info message.
+   */
+  constructor(msg) {
+    super(bitjs.archive.UnarchiveEvent.Type.INFO);
+
+    /**
+     * The information message.
+     * @type {string}
+     */
+    this.msg = msg;
+  }
+}
+
+/**
+ * An unrecoverable error has occured.
+ */
+bitjs.archive.UnarchiveErrorEvent = class extends bitjs.archive.UnarchiveEvent {
+  /**
+   * @param {string} msg The error message.
+   */
+  constructor(msg) {
+    super(bitjs.archive.UnarchiveEvent.Type.ERROR);
+
+    /**
+     * The information message.
+     * @type {string}
+     */
+    this.msg = msg;
+  }
+}
+
+/**
+ * Start event.
+ */
+bitjs.archive.UnarchiveStartEvent = class extends bitjs.archive.UnarchiveEvent {
+  constructor() {
+    super(bitjs.archive.UnarchiveEvent.Type.START);
+  }
+}
+
+/**
+ * Finish event.
+ */
+bitjs.archive.UnarchiveFinishEvent = class extends bitjs.archive.UnarchiveEvent {
+  constructor() {
+    super(bitjs.archive.UnarchiveEvent.Type.FINISH);
+  }
+}
+
+/**
+ * Progress event.
+ */
+bitjs.archive.UnarchiveProgressEvent = class extends bitjs.archive.UnarchiveEvent {
+  /**
+   * @param {string} currentFilename
+   * @param {number} currentFileNumber
+   * @param {number} currentBytesUnarchivedInFile
+   * @param {number} currentBytesUnarchived
+   * @param {number} totalUncompressedBytesInArchive
+   * @param {number} totalFilesInArchive
+   */
+  constructor(currentFilename, currentFileNumber, currentBytesUnarchivedInFile,
+      currentBytesUnarchived, totalUncompressedBytesInArchive, totalFilesInArchive) {
+    super(bitjs.archive.UnarchiveEvent.Type.PROGRESS);
+
+    this.currentFilename = currentFilename;
+    this.currentFileNumber = currentFileNumber;
+    this.currentBytesUnarchivedInFile = currentBytesUnarchivedInFile;
+    this.totalFilesInArchive = totalFilesInArchive;
+    this.currentBytesUnarchived = currentBytesUnarchived;
+    this.totalUncompressedBytesInArchive = totalUncompressedBytesInArchive;
+  }
+}
+
+/**
+ * Extract event.
+ */
+bitjs.archive.UnarchiveExtractEvent = class extends bitjs.archive.UnarchiveEvent {
+  /**
+   * @param {UnarchivedFile} unarchivedFile
+   */
+  constructor(unarchivedFile) {
+    super(bitjs.archive.UnarchiveEvent.Type.EXTRACT);
+
+    /**
+     * @type {UnarchivedFile}
+     */
+    this.unarchivedFile = unarchivedFile;
+  }
+}
+
+/**
+ * All extracted files returned by an Unarchiver will implement
+ * the following interface:
+ *
+ * interface UnarchivedFile {
+ *   string filename
+ *   TypedArray fileData  
+ * }
+ *
+ */
+
+/**
+ * Base class for all Unarchivers.
+ */
+bitjs.archive.Unarchiver = class {
+  /**
+   * @param {ArrayBuffer} arrayBuffer The Array Buffer.
+   * @param {string} opt_pathToBitJS Optional string for where the BitJS files are located.
+   */
+  constructor(arrayBuffer, opt_pathToBitJS) {
+    /**
+     * The ArrayBuffer object.
+     * @type {ArrayBuffer}
+     * @protected
+     */
+    this.ab = arrayBuffer;
+
+    /**
+     * The path to the BitJS files.
+     * @type {string}
+     * @private
+     */
+    this.pathToBitJS_ = opt_pathToBitJS || '/';
+
+    /**
+     * A map from event type to an array of listeners.
+     * @type {Map.<string, Array>}
+     */
+    this.listeners_ = {};
+    for (let type in bitjs.archive.UnarchiveEvent.Type) {
+      this.listeners_[bitjs.archive.UnarchiveEvent.Type[type]] = [];
+    }
+
+    /**
+     * Private web worker initialized during start().
+     * @type {Worker}
+     * @private
+     */
+    this.worker_ = null;
+  }
+
+  /**
+   * This method must be overridden by the subclass to return the script filename.
+   * @return {string} The script filename.
+   * @protected.
+   */
+  getScriptFileName() {
+    throw 'Subclasses of AbstractUnarchiver must overload getScriptFileName()';
+  }
+
+  /**
+   * Adds an event listener for UnarchiveEvents.
+   *
+   * @param {string} Event type.
+   * @param {function} An event handler function.
+   */
+  addEventListener(type, listener) {
+    if (type in this.listeners_) {
+      if (this.listeners_[type].indexOf(listener) == -1) {
+        this.listeners_[type].push(listener);
+      }
+    }
+  }
+
+  /**
+   * Removes an event listener.
+   *
+   * @param {string} Event type.
+   * @param {EventListener|function} An event listener or handler function.
+   */
+  removeEventListener(type, listener) {
+    if (type in this.listeners_) {
+      const index = this.listeners_[type].indexOf(listener);
+      if (index != -1) {
+        this.listeners_[type].splice(index, 1);
+      }
+    }
+  }
+
+  /**
+   * Receive an event and pass it to the listener functions.
+   *
+   * @param {bitjs.archive.UnarchiveEvent} e
+   * @private
+   */
+  handleWorkerEvent_(e) {
+    if ((e instanceof bitjs.archive.UnarchiveEvent || e.type) &&
+        this.listeners_[e.type] instanceof Array) {
+      this.listeners_[e.type].forEach(function (listener) { listener(e) });
+      if (e.type == bitjs.archive.UnarchiveEvent.Type.FINISH) {
+          this.worker_.terminate();
+      }
+    } else {
+      console.log(e);
+    }
+  }
+
+  /**
+   * Starts the unarchive in a separate Web Worker thread and returns immediately.
+   */
+  start() {
+    const me = this;
+    const scriptFileName = this.pathToBitJS_ + this.getScriptFileName();
+    if (scriptFileName) {
+      this.worker_ = new Worker(scriptFileName);
+
+      this.worker_.onerror = function(e) {
+        console.log('Worker error: message = ' + e.message);
+        throw e;
+      };
+
+      this.worker_.onmessage = function(e) {
+        if (typeof e.data == 'string') {
+          // Just log any strings the workers pump our way.
+          console.log(e.data);
+        } else {
+          // Assume that it is an UnarchiveEvent.  Some browsers preserve the 'type'
+          // so that instanceof UnarchiveEvent returns true, but others do not.
+          me.handleWorkerEvent_(e.data);
+        }
+      };
+
+      this.worker_.postMessage({file: this.ab});
+    }
+  }
+
+  /**
+   * Terminates the Web Worker for this Unarchiver and returns immediately.
+   */
+  stop() {
+    if (this.worker_) {
+      this.worker_.terminate();
+    }
+  }
+}
+
+
+/**
+ * Unzipper
+ */
+bitjs.archive.Unzipper = class extends bitjs.archive.Unarchiver {
+  constructor(arrayBuffer, opt_pathToBitJS) {
+    super(arrayBuffer, opt_pathToBitJS);
+  }
+
+  getScriptFileName() { return 'archive/unzip.js'; }
+}
+
+
+/**
+ * Unrarrer
+ */
+bitjs.archive.Unrarrer = class extends bitjs.archive.Unarchiver {
+  constructor(arrayBuffer, opt_pathToBitJS) {
+    super(arrayBuffer, opt_pathToBitJS);
+  }
+
+  getScriptFileName() { return 'archive/unrar.js'; }
+}
+
+/**
+ * Untarrer
+ * @extends {bitjs.archive.Unarchiver}
+ * @constructor
+ */
+bitjs.archive.Untarrer = class extends bitjs.archive.Unarchiver {
+  constructor(arrayBuffer, opt_pathToBitJS) {
+    super(arrayBuffer, opt_pathToBitJS);
+  }
+
+  getScriptFileName() { return 'archive/untar.js'; };
+}
+
+/**
+ * Factory method that creates an unarchiver based on the byte signature found
+ * in the arrayBuffer.
+ * @param {ArrayBuffer} ab
+ * @param {string=} opt_pathToBitJS Path to the unarchiver script files.
+ * @return {bitjs.archive.Unarchiver}
+ */
+bitjs.archive.GetUnarchiver = function(ab, opt_pathToBitJS) {
+  let unarchiver = null;
+  const pathToBitJS = opt_pathToBitJS || '';
+  const h = new Uint8Array(ab, 0, 10);
+
+  if (h[0] == 0x52 && h[1] == 0x61 && h[2] == 0x72 && h[3] == 0x21) { // Rar!
+    unarchiver = new bitjs.archive.Unrarrer(ab, pathToBitJS);
+  } else if (h[0] == 0x50 && h[1] == 0x4B) { // PK (Zip)
+    unarchiver = new bitjs.archive.Unzipper(ab, pathToBitJS);
+  } else { // Try with tar
+    unarchiver = new bitjs.archive.Untarrer(ab, pathToBitJS);
+  }
+  return unarchiver;
+};

vendor/bitjs/archive/untar.js

@@ -0,0 +1,168 @@
+/**
+ * untar.js
+ *
+ * Licensed under the MIT License
+ *
+ * Copyright(c) 2011 Google Inc.
+ *
+ * Reference Documentation:
+ *
+ * TAR format: http://www.gnu.org/software/automake/manual/tar/Standard.html
+ */
+
+// This file expects to be invoked as a Worker (see onmessage below).
+importScripts('../io/bytestream.js');
+importScripts('archive.js');
+
+// Progress variables.
+let currentFilename = "";
+let currentFileNumber = 0;
+let currentBytesUnarchivedInFile = 0;
+let currentBytesUnarchived = 0;
+let totalUncompressedBytesInArchive = 0;
+let totalFilesInArchive = 0;
+
+// Helper functions.
+const info = function(str) {
+  postMessage(new bitjs.archive.UnarchiveInfoEvent(str));
+};
+const err = function(str) {
+  postMessage(new bitjs.archive.UnarchiveErrorEvent(str));
+};
+const postProgress = function() {
+  postMessage(new bitjs.archive.UnarchiveProgressEvent(
+      currentFilename,
+      currentFileNumber,
+      currentBytesUnarchivedInFile,
+      currentBytesUnarchived,
+      totalUncompressedBytesInArchive,
+      totalFilesInArchive));
+};
+
+// Removes all characters from the first zero-byte in the string onwards.
+const readCleanString = function(bstr, numBytes) {
+  const str = bstr.readString(numBytes);
+  const zIndex = str.indexOf(String.fromCharCode(0));
+  return zIndex != -1 ? str.substr(0, zIndex) : str;
+};
+
+class TarLocalFile {
+  // takes a ByteStream and parses out the local file information
+  constructor(bstream) {
+    this.isValid = false;
+
+    // Read in the header block
+    this.name = readCleanString(bstream, 100);
+    this.mode = readCleanString(bstream, 8);
+    this.uid = readCleanString(bstream, 8);
+    this.gid = readCleanString(bstream, 8);
+    this.size = parseInt(readCleanString(bstream, 12), 8);
+    this.mtime = readCleanString(bstream, 12);
+    this.chksum = readCleanString(bstream, 8);
+    this.typeflag = readCleanString(bstream, 1);
+    this.linkname = readCleanString(bstream, 100);
+    this.maybeMagic = readCleanString(bstream, 6);
+
+    if (this.maybeMagic == "ustar") {
+      this.version = readCleanString(bstream, 2);
+      this.uname = readCleanString(bstream, 32);
+      this.gname = readCleanString(bstream, 32);
+      this.devmajor = readCleanString(bstream, 8);
+      this.devminor = readCleanString(bstream, 8);
+      this.prefix = readCleanString(bstream, 155);
+
+      if (this.prefix.length) {
+        this.name = this.prefix + this.name;
+      }
+      bstream.readBytes(12); // 512 - 500
+    } else {
+      bstream.readBytes(255); // 512 - 257
+    }
+
+    // Done header, now rest of blocks are the file contents.
+    this.filename = this.name;
+    this.fileData = null;
+
+    info("Untarring file '" + this.filename + "'");
+    info("  size = " + this.size);
+    info("  typeflag = " + this.typeflag);
+
+    // A regular file.
+    if (this.typeflag == 0) {
+      info("  This is a regular file.");
+      const sizeInBytes = parseInt(this.size);
+      this.fileData = new Uint8Array(bstream.readBytes(sizeInBytes));
+      if (this.name.length > 0 && this.size > 0 && this.fileData && this.fileData.buffer) {
+        this.isValid = true;
+      }
+
+      bstream.readBytes(this.size);
+
+      // Round up to 512-byte blocks.
+      const remaining = 512 - bstream.ptr % 512;
+      if (remaining > 0 && remaining < 512) {
+        bstream.readBytes(remaining);
+      }
+    } else if (this.typeflag == 5) {
+       info("  This is a directory.")
+    }
+  }
+}
+
+// Takes an ArrayBuffer of a tar file in
+// returns null on error
+// returns an array of DecompressedFile objects on success
+const untar = function(arrayBuffer) {
+  currentFilename = "";
+  currentFileNumber = 0;
+  currentBytesUnarchivedInFile = 0;
+  currentBytesUnarchived = 0;
+  totalUncompressedBytesInArchive = 0;
+  totalFilesInArchive = 0;
+
+  postMessage(new bitjs.archive.UnarchiveStartEvent());
+  const bstream = new bitjs.io.ByteStream(arrayBuffer);
+  const localFiles = [];
+
+  // While we don't encounter an empty block, keep making TarLocalFiles.
+  while (bstream.peekNumber(4) != 0) {
+    const oneLocalFile = new TarLocalFile(bstream);
+    if (oneLocalFile && oneLocalFile.isValid) {
+      localFiles.push(oneLocalFile);
+      totalUncompressedBytesInArchive += oneLocalFile.size;
+    }
+  }
+  totalFilesInArchive = localFiles.length;
+
+  // got all local files, now sort them
+  localFiles.sort((a,b) => a.filename > b.filename ? 1 : -1);
+
+  // report # files and total length
+  if (localFiles.length > 0) {
+    postProgress();
+  }
+
+  // now do the shipping of each file
+  for (let i = 0; i < localFiles.length; ++i) {
+    const localfile = localFiles[i];
+    info("Sending file '" + localfile.filename + "' up");
+
+    // update progress
+    currentFilename = localfile.filename;
+    currentFileNumber = i;
+    currentBytesUnarchivedInFile = localfile.size;
+    currentBytesUnarchived += localfile.size;
+    postMessage(new bitjs.archive.UnarchiveExtractEvent(localfile));
+    postProgress();
+  }
+
+  postProgress();
+
+  postMessage(new bitjs.archive.UnarchiveFinishEvent());
+};
+
+// event.data.file has the ArrayBuffer.
+onmessage = function(event) {
+  const ab = event.data.file;
+  untar(ab);
+};

vendor/bitjs/io/bitstream.js

@@ -0,0 +1,222 @@
+/*
+ * bitstream.js
+ *
+ * Provides readers for bitstreams.
+ *
+ * Licensed under the MIT License
+ *
+ * Copyright(c) 2011 Google Inc.
+ * Copyright(c) 2011 antimatter15
+ */
+
+var bitjs = bitjs || {};
+bitjs.io = bitjs.io || {};
+
+
+/**
+ * This bit stream peeks and consumes bits out of a binary stream.
+ */
+bitjs.io.BitStream = class {
+  /**
+   * @param {ArrayBuffer} ab An ArrayBuffer object or a Uint8Array.
+   * @param {boolean} rtl Whether the stream reads bits from the byte starting
+   *     from bit 7 to 0 (true) or bit 0 to 7 (false).
+   * @param {Number} opt_offset The offset into the ArrayBuffer
+   * @param {Number} opt_length The length of this BitStream
+   */
+  constructor(ab, rtl, opt_offset, opt_length) {
+    if (!ab || !ab.toString || ab.toString() !== "[object ArrayBuffer]") {
+      throw "Error! BitArray constructed with an invalid ArrayBuffer object";
+    }
+
+    const offset = opt_offset || 0;
+    const length = opt_length || ab.byteLength;
+    this.bytes = new Uint8Array(ab, offset, length);
+    this.bytePtr = 0; // tracks which byte we are on
+    this.bitPtr = 0; // tracks which bit we are on (can have values 0 through 7)
+    this.peekBits = rtl ? this.peekBits_rtl : this.peekBits_ltr;
+  }
+
+  /**
+   *   byte0      byte1      byte2      byte3
+   * 7......0 | 7......0 | 7......0 | 7......0
+   *
+   * The bit pointer starts at bit0 of byte0 and moves left until it reaches
+   * bit7 of byte0, then jumps to bit0 of byte1, etc.
+   * @param {number} n The number of bits to peek.
+   * @param {boolean=} movePointers Whether to move the pointer, defaults false.
+   * @return {number} The peeked bits, as an unsigned number.
+   */
+  peekBits_ltr(n, opt_movePointers) {
+    if (n <= 0 || typeof n != typeof 1) {
+      return 0;
+    }
+
+    const movePointers = opt_movePointers || false;
+    const bytes = this.bytes;
+    let bytePtr = this.bytePtr;
+    let bitPtr = this.bitPtr;
+    let result = 0;
+    let bitsIn = 0;
+
+    // keep going until we have no more bits left to peek at
+    // TODO: Consider putting all bits from bytes we will need into a variable and then
+    //       shifting/masking it to just extract the bits we want.
+    //       This could be considerably faster when reading more than 3 or 4 bits at a time.
+    while (n > 0) {
+      if (bytePtr >= bytes.length) {
+        throw "Error!  Overflowed the bit stream! n=" + n + ", bytePtr=" + bytePtr + ", bytes.length=" +
+          bytes.length + ", bitPtr=" + bitPtr;
+        return -1;
+      }
+
+      const numBitsLeftInThisByte = (8 - bitPtr);
+      if (n >= numBitsLeftInThisByte) {
+        const mask = (bitjs.io.BitStream.BITMASK[numBitsLeftInThisByte] << bitPtr);
+        result |= (((bytes[bytePtr] & mask) >> bitPtr) << bitsIn);
+
+        bytePtr++;
+        bitPtr = 0;
+        bitsIn += numBitsLeftInThisByte;
+        n -= numBitsLeftInThisByte;
+      }
+      else {
+        const mask = (bitjs.io.BitStream.BITMASK[n] << bitPtr);
+        result |= (((bytes[bytePtr] & mask) >> bitPtr) << bitsIn);
+
+        bitPtr += n;
+        bitsIn += n;
+        n = 0;
+      }
+    }
+
+    if (movePointers) {
+      this.bitPtr = bitPtr;
+      this.bytePtr = bytePtr;
+    }
+
+    return result;
+  }
+
+  /**
+   *   byte0      byte1      byte2      byte3
+   * 7......0 | 7......0 | 7......0 | 7......0
+   *
+   * The bit pointer starts at bit7 of byte0 and moves right until it reaches
+   * bit0 of byte0, then goes to bit7 of byte1, etc.
+   * @param {number} n The number of bits to peek.
+   * @param {boolean=} movePointers Whether to move the pointer, defaults false.
+   * @return {number} The peeked bits, as an unsigned number.
+   */
+  peekBits_rtl(n, opt_movePointers) {
+    if (n <= 0 || typeof n != typeof 1) {
+      return 0;
+    }
+
+    const movePointers = opt_movePointers || false;
+    const bytes = this.bytes;
+    let bytePtr = this.bytePtr;
+    let bitPtr = this.bitPtr;
+    let result = 0;
+
+    // keep going until we have no more bits left to peek at
+    // TODO: Consider putting all bits from bytes we will need into a variable and then
+    //       shifting/masking it to just extract the bits we want.
+    //       This could be considerably faster when reading more than 3 or 4 bits at a time.
+    while (n > 0) {
+      if (bytePtr >= bytes.length) {
+        throw "Error!  Overflowed the bit stream! n=" + n + ", bytePtr=" + bytePtr + ", bytes.length=" +
+          bytes.length + ", bitPtr=" + bitPtr;
+        return -1;
+      }
+
+      const numBitsLeftInThisByte = (8 - bitPtr);
+      if (n >= numBitsLeftInThisByte) {
+        result <<= numBitsLeftInThisByte;
+        result |= (bitjs.io.BitStream.BITMASK[numBitsLeftInThisByte] & bytes[bytePtr]);
+        bytePtr++;
+        bitPtr = 0;
+        n -= numBitsLeftInThisByte;
+      }
+      else {
+        result <<= n;
+        result |= ((bytes[bytePtr] & (bitjs.io.BitStream.BITMASK[n] << (8 - n - bitPtr))) >> (8 - n - bitPtr));
+
+        bitPtr += n;
+        n = 0;
+      }
+    }
+
+    if (movePointers) {
+      this.bitPtr = bitPtr;
+      this.bytePtr = bytePtr;
+    }
+
+    return result;
+  }
+
+  /**
+   * Peek at 16 bits from current position in the buffer.
+   * Bit at (bytePtr,bitPtr) has the highest position in returning data.
+   * Taken from getbits.hpp in unrar.
+   * TODO: Move this out of BitStream and into unrar.
+   */
+  getBits() {
+    return (((((this.bytes[this.bytePtr] & 0xff) << 16) +
+                ((this.bytes[this.bytePtr+1] & 0xff) << 8) +
+                ((this.bytes[this.bytePtr+2] & 0xff))) >>> (8-this.bitPtr)) & 0xffff);
+  }
+
+  /**
+   * Reads n bits out of the stream, consuming them (moving the bit pointer).
+   * @param {number} n The number of bits to read.
+   * @return {number} The read bits, as an unsigned number.
+   */
+  readBits(n) {
+    return this.peekBits(n, true);
+  }
+
+  /**
+   * This returns n bytes as a sub-array, advancing the pointer if movePointers
+   * is true.  Only use this for uncompressed blocks as this throws away remaining
+   * bits in the current byte.
+   * @param {number} n The number of bytes to peek.
+   * @param {boolean=} movePointers Whether to move the pointer, defaults false.
+   * @return {Uint8Array} The subarray.
+   */
+  peekBytes(n, opt_movePointers) {
+    if (n <= 0 || typeof n != typeof 1) {
+      return 0;
+    }
+
+    // from http://tools.ietf.org/html/rfc1951#page-11
+    // "Any bits of input up to the next byte boundary are ignored."
+    while (this.bitPtr != 0) {
+      this.readBits(1);
+    }
+
+    const movePointers = opt_movePointers || false;
+    let bytePtr = this.bytePtr;
+    let bitPtr = this.bitPtr;
+
+    const result = this.bytes.subarray(bytePtr, bytePtr + n);
+
+    if (movePointers) {
+      this.bytePtr += n;
+    }
+
+    return result;
+  }
+
+  /**
+   * @param {number} n The number of bytes to read.
+   * @return {Uint8Array} The subarray.
+   */
+  readBytes(n) {
+    return this.peekBytes(n, true);
+  }
+}
+
+// mask for getting N number of bits (0-8)
+bitjs.io.BitStream.BITMASK = [0, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF ];
+

vendor/bitjs/io/bytebuffer.js

@@ -0,0 +1,117 @@
+/*
+ * bytestream.js
+ *
+ * Provides a writer for bytes.
+ *
+ * Licensed under the MIT License
+ *
+ * Copyright(c) 2011 Google Inc.
+ * Copyright(c) 2011 antimatter15
+ */
+
+var bitjs = bitjs || {};
+bitjs.io = bitjs.io || {};
+
+
+/**
+ * A write-only Byte buffer which uses a Uint8 Typed Array as a backing store.
+ */
+bitjs.io.ByteBuffer = class {
+  /**
+   * @param {number} numBytes The number of bytes to allocate.
+   */
+  constructor(numBytes) {
+    if (typeof numBytes != typeof 1 || numBytes <= 0) {
+      throw "Error! ByteBuffer initialized with '" + numBytes + "'";
+    }
+    this.data = new Uint8Array(numBytes);
+    this.ptr = 0;
+  }
+
+
+  /**
+   * @param {number} b The byte to insert.
+   */
+  insertByte(b) {
+    // TODO: throw if byte is invalid?
+    this.data[this.ptr++] = b;
+  }
+
+  /**
+   * @param {Array.<number>|Uint8Array|Int8Array} bytes The bytes to insert.
+   */
+  insertBytes(bytes) {
+    // TODO: throw if bytes is invalid?
+    this.data.set(bytes, this.ptr);
+    this.ptr += bytes.length;
+  }
+
+  /**
+   * Writes an unsigned number into the next n bytes.  If the number is too large
+   * to fit into n bytes or is negative, an error is thrown.
+   * @param {number} num The unsigned number to write.
+   * @param {number} numBytes The number of bytes to write the number into.
+   */
+  writeNumber(num, numBytes) {
+    if (numBytes < 1) {
+      throw 'Trying to write into too few bytes: ' + numBytes;
+    }
+    if (num < 0) {
+      throw 'Trying to write a negative number (' + num +
+          ') as an unsigned number to an ArrayBuffer';
+    }
+    if (num > (Math.pow(2, numBytes * 8) - 1)) {
+      throw 'Trying to write ' + num + ' into only ' + numBytes + ' bytes';
+    }
+
+    // Roll 8-bits at a time into an array of bytes.
+    const bytes = [];
+    while (numBytes-- > 0) {
+      const eightBits = num & 255;
+      bytes.push(eightBits);
+      num >>= 8;
+    }
+
+    this.insertBytes(bytes);
+  }
+
+  /**
+   * Writes a signed number into the next n bytes.  If the number is too large
+   * to fit into n bytes, an error is thrown.
+   * @param {number} num The signed number to write.
+   * @param {number} numBytes The number of bytes to write the number into.
+   */
+  writeSignedNumber(num, numBytes) {
+    if (numBytes < 1) {
+      throw 'Trying to write into too few bytes: ' + numBytes;
+    }
+
+    const HALF = Math.pow(2, (numBytes * 8) - 1);
+    if (num >= HALF || num < -HALF) {
+      throw 'Trying to write ' + num + ' into only ' + numBytes + ' bytes';
+    }
+
+    // Roll 8-bits at a time into an array of bytes.
+    const bytes = [];
+    while (numBytes-- > 0) {
+      const eightBits = num & 255;
+      bytes.push(eightBits);
+      num >>= 8;
+    }
+
+    this.insertBytes(bytes);
+  }
+
+  /**
+   * @param {string} str The ASCII string to write.
+   */
+  writeASCIIString(str) {
+    for (let i = 0; i < str.length; ++i) {
+      const curByte = str.charCodeAt(i);
+      if (curByte < 0 || curByte > 255) {
+        throw 'Trying to write a non-ASCII string!';
+      }
+      this.insertByte(curByte);
+    }
+  };
+}

vendor/bitjs/io/bytestream.js

@@ -0,0 +1,159 @@
+/*
+ * bytestream.js
+ *
+ * Provides readers for byte streams.
+ *
+ * Licensed under the MIT License
+ *
+ * Copyright(c) 2011 Google Inc.
+ * Copyright(c) 2011 antimatter15
+ */
+
+var bitjs = bitjs || {};
+bitjs.io = bitjs.io || {};
+
+
+/**
+ * This object allows you to peek and consume bytes as numbers and strings
+ * out of an ArrayBuffer.  In this buffer, everything must be byte-aligned.
+ */
+bitjs.io.ByteStream = class {
+  /**
+   * @param {ArrayBuffer} ab The ArrayBuffer object.
+   * @param {number=} opt_offset The offset into the ArrayBuffer
+   * @param {number=} opt_length The length of this BitStream
+   */
+  constructor(ab, opt_offset, opt_length) {
+    const offset = opt_offset || 0;
+    const length = opt_length || ab.byteLength;
+    this.bytes = new Uint8Array(ab, offset, length);
+    this.ptr = 0;
+  }
+
+
+  /**
+   * Peeks at the next n bytes as an unsigned number but does not advance the
+   * pointer
+   * TODO: This apparently cannot read more than 4 bytes as a number?
+   * @param {number} n The number of bytes to peek at.
+   * @return {number} The n bytes interpreted as an unsigned number.
+   */
+  peekNumber(n) {
+    // TODO: return error if n would go past the end of the stream?
+    if (n <= 0 || typeof n != typeof 1) {
+      return -1;
+    }
+
+    let result = 0;
+    // read from last byte to first byte and roll them in
+    let curByte = this.ptr + n - 1;
+    while (curByte >= this.ptr) {
+      result <<= 8;
+      result |= this.bytes[curByte];
+      --curByte;
+    }
+    return result;
+  }
+
+
+  /**
+   * Returns the next n bytes as an unsigned number (or -1 on error)
+   * and advances the stream pointer n bytes.
+   * @param {number} n The number of bytes to read.
+   * @return {number} The n bytes interpreted as an unsigned number.
+   */
+  readNumber(n) {
+    const num = this.peekNumber( n );
+    this.ptr += n;
+    return num;
+  }
+
+
+  /**
+   * Returns the next n bytes as a signed number but does not advance the
+   * pointer.
+   * @param {number} n The number of bytes to read.
+   * @return {number} The bytes interpreted as a signed number.
+   */
+  peekSignedNumber(n) {
+    let num = this.peekNumber(n);
+    const HALF = Math.pow(2, (n * 8) - 1);
+    const FULL = HALF * 2;
+
+    if (num >= HALF) num -= FULL;
+
+    return num;
+  }
+
+
+  /**
+   * Returns the next n bytes as a signed number and advances the stream pointer.
+   * @param {number} n The number of bytes to read.
+   * @return {number} The bytes interpreted as a signed number.
+   */
+  readSignedNumber(n) {
+    const num = this.peekSignedNumber(n);
+    this.ptr += n;
+    return num;
+  }
+
+
+  /**
+   * This returns n bytes as a sub-array, advancing the pointer if movePointers
+   * is true.
+   * @param {number} n The number of bytes to read.
+   * @param {boolean} movePointers Whether to move the pointers.
+   * @return {Uint8Array} The subarray.
+   */
+  peekBytes(n, movePointers) {
+    if (n <= 0 || typeof n != typeof 1) {
+      return null;
+    }
+
+    const result = this.bytes.subarray(this.ptr, this.ptr + n);
+
+    if (movePointers) {
+      this.ptr += n;
+    }
+
+    return result;
+  }
+
+  /**
+   * Reads the next n bytes as a sub-array.
+   * @param {number} n The number of bytes to read.
+   * @return {Uint8Array} The subarray.
+   */
+  readBytes(n) {
+    return this.peekBytes(n, true);
+  }
+
+  /**
+   * Peeks at the next n bytes as a string but does not advance the pointer.
+   * @param {number} n The number of bytes to peek at.
+   * @return {string} The next n bytes as a string.
+   */
+  peekString(n) {
+    if (n <= 0 || typeof n != typeof 1) {
+      return "";
+    }
+
+    let result = "";
+    for (let p = this.ptr, end = this.ptr + n; p < end; ++p) {
+      result += String.fromCharCode(this.bytes[p]);
+    }
+    return result;
+  }
+
+  /**
+   * Returns the next n bytes as an ASCII string and advances the stream pointer
+   * n bytes.
+   * @param {number} n The number of bytes to read.
+   * @return {string} The next n bytes as a string.
+   */
+  readString(n) {
+    const strToReturn = this.peekString(n);
+    this.ptr += n;
+    return strToReturn;
+  }
+}