text: /*! @license Firebase v4.2.0
  Build: rev-d6b2db4
  Terms: https://firebase.google.com/terms/ */
  
  'use strict';
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  exports.FbsBlob = undefined;
  
  var _fs = require('./fs');
  
  var fs = _interopRequireWildcard(_fs);
  
  var _string = require('./string');
  
  var string = _interopRequireWildcard(_string);
  
  var _type = require('./type');
  
  var type = _interopRequireWildcard(_type);
  
  function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
  
  /**
   * @param opt_elideCopy If true, doesn't copy mutable input data
   *     (e.g. Uint8Arrays). Pass true only if you know the objects will not be
   *     modified after this blob's construction.
   */
  /**
  * Copyright 2017 Google Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
  /**
   * @file Provides a Blob-like wrapper for various binary types (including the
   * native Blob type). This makes it possible to upload types like ArrayBuffers,
   * making uploads possible in environments without the native Blob type.
   */
  var FbsBlob = function () {
      function FbsBlob(data, opt_elideCopy) {
          var size = 0;
          var blobType = '';
          if (type.isNativeBlob(data)) {
              this.data_ = data;
              size = data.size;
              blobType = data.type;
          } else if (data instanceof ArrayBuffer) {
              if (opt_elideCopy) {
                  this.data_ = new Uint8Array(data);
              } else {
                  this.data_ = new Uint8Array(data.byteLength);
                  this.data_.set(new Uint8Array(data));
              }
              size = this.data_.length;
          } else if (data instanceof Uint8Array) {
              if (opt_elideCopy) {
                  this.data_ = data;
              } else {
                  this.data_ = new Uint8Array(data.length);
                  this.data_.set(data);
              }
              size = data.length;
          }
          this.size_ = size;
          this.type_ = blobType;
      }
      FbsBlob.prototype.size = function () {
          return this.size_;
      };
      FbsBlob.prototype.type = function () {
          return this.type_;
      };
      FbsBlob.prototype.slice = function (startByte, endByte) {
          if (type.isNativeBlob(this.data_)) {
              var realBlob = this.data_;
              var sliced = fs.sliceBlob(realBlob, startByte, endByte);
              if (sliced === null) {
                  return null;
              }
              return new FbsBlob(sliced);
          } else {
              var slice = new Uint8Array(this.data_.buffer, startByte, endByte - startByte);
              return new FbsBlob(slice, true);
          }
      };
      FbsBlob.getBlob = function () {
          var var_args = [];
          for (var _i = 0; _i < arguments.length; _i++) {
              var_args[_i] = arguments[_i];
          }
          if (type.isNativeBlobDefined()) {
              var blobby = var_args.map(function (val) {
                  if (val instanceof FbsBlob) {
                      return val.data_;
                  } else {
                      return val;
                  }
              });
              return new FbsBlob(fs.getBlob.apply(null, blobby));
          } else {
              var uint8Arrays = var_args.map(function (val) {
                  if (type.isString(val)) {
                      return string.dataFromString(_string.StringFormat.RAW, val).data;
                  } else {
                      // Blobs don't exist, so this has to be a Uint8Array.
                      return val.data_;
                  }
              });
              var finalLength_1 = 0;
              uint8Arrays.forEach(function (array) {
                  finalLength_1 += array.byteLength;
              });
              var merged_1 = new Uint8Array(finalLength_1);
              var index_1 = 0;
              uint8Arrays.forEach(function (array) {
                  for (var i = 0; i < array.length; i++) {
                      merged_1[index_1++] = array[i];
                  }
              });
              return new FbsBlob(merged_1, true);
          }
      };
      FbsBlob.prototype.uploadData = function () {
          return this.data_;
      };
      return FbsBlob;
  }();
  exports.FbsBlob = FbsBlob;
  //# sourceMappingURL=blob.js.map
  