@marktrue/dsh-mobile-remote 3.2.4-alpha.1 → 3.2.4-alpha.2-app

package/node_modules/pngjs/lib/packer.js

@@ -1,129 +0,0 @@
-"use strict";
-
-let constants = require("./constants");
-let CrcStream = require("./crc");
-let bitPacker = require("./bitpacker");
-let filter = require("./filter-pack");
-let zlib = require("zlib");
-
-let Packer = (module.exports = function (options) {
-  this._options = options;
-
-  options.deflateChunkSize = options.deflateChunkSize || 32 * 1024;
-  options.deflateLevel =
-    options.deflateLevel != null ? options.deflateLevel : 9;
-  options.deflateStrategy =
-    options.deflateStrategy != null ? options.deflateStrategy : 3;
-  options.inputHasAlpha =
-    options.inputHasAlpha != null ? options.inputHasAlpha : true;
-  options.deflateFactory = options.deflateFactory || zlib.createDeflate;
-  options.bitDepth = options.bitDepth || 8;
-  // This is outputColorType
-  options.colorType =
-    typeof options.colorType === "number"
-      ? options.colorType
-      : constants.COLORTYPE_COLOR_ALPHA;
-  options.inputColorType =
-    typeof options.inputColorType === "number"
-      ? options.inputColorType
-      : constants.COLORTYPE_COLOR_ALPHA;
-
-  if (
-    [
-      constants.COLORTYPE_GRAYSCALE,
-      constants.COLORTYPE_COLOR,
-      constants.COLORTYPE_COLOR_ALPHA,
-      constants.COLORTYPE_ALPHA,
-    ].indexOf(options.colorType) === -1
-  ) {
-    throw new Error(
-      "option color type:" + options.colorType + " is not supported at present"
-    );
-  }
-  if (
-    [
-      constants.COLORTYPE_GRAYSCALE,
-      constants.COLORTYPE_COLOR,
-      constants.COLORTYPE_COLOR_ALPHA,
-      constants.COLORTYPE_ALPHA,
-    ].indexOf(options.inputColorType) === -1
-  ) {
-    throw new Error(
-      "option input color type:" +
-        options.inputColorType +
-        " is not supported at present"
-    );
-  }
-  if (options.bitDepth !== 8 && options.bitDepth !== 16) {
-    throw new Error(
-      "option bit depth:" + options.bitDepth + " is not supported at present"
-    );
-  }
-});
-
-Packer.prototype.getDeflateOptions = function () {
-  return {
-    chunkSize: this._options.deflateChunkSize,
-    level: this._options.deflateLevel,
-    strategy: this._options.deflateStrategy,
-  };
-};
-
-Packer.prototype.createDeflate = function () {
-  return this._options.deflateFactory(this.getDeflateOptions());
-};
-
-Packer.prototype.filterData = function (data, width, height) {
-  // convert to correct format for filtering (e.g. right bpp and bit depth)
-  let packedData = bitPacker(data, width, height, this._options);
-
-  // filter pixel data
-  let bpp = constants.COLORTYPE_TO_BPP_MAP[this._options.colorType];
-  let filteredData = filter(packedData, width, height, this._options, bpp);
-  return filteredData;
-};
-
-Packer.prototype._packChunk = function (type, data) {
-  let len = data ? data.length : 0;
-  let buf = Buffer.alloc(len + 12);
-
-  buf.writeUInt32BE(len, 0);
-  buf.writeUInt32BE(type, 4);
-
-  if (data) {
-    data.copy(buf, 8);
-  }
-
-  buf.writeInt32BE(
-    CrcStream.crc32(buf.slice(4, buf.length - 4)),
-    buf.length - 4
-  );
-  return buf;
-};
-
-Packer.prototype.packGAMA = function (gamma) {
-  let buf = Buffer.alloc(4);
-  buf.writeUInt32BE(Math.floor(gamma * constants.GAMMA_DIVISION), 0);
-  return this._packChunk(constants.TYPE_gAMA, buf);
-};
-
-Packer.prototype.packIHDR = function (width, height) {
-  let buf = Buffer.alloc(13);
-  buf.writeUInt32BE(width, 0);
-  buf.writeUInt32BE(height, 4);
-  buf[8] = this._options.bitDepth; // Bit depth
-  buf[9] = this._options.colorType; // colorType
-  buf[10] = 0; // compression
-  buf[11] = 0; // filter
-  buf[12] = 0; // interlace
-
-  return this._packChunk(constants.TYPE_IHDR, buf);
-};
-
-Packer.prototype.packIDAT = function (data) {
-  return this._packChunk(constants.TYPE_IDAT, data);
-};
-
-Packer.prototype.packIEND = function () {
-  return this._packChunk(constants.TYPE_IEND, null);
-};

package/node_modules/pngjs/lib/paeth-predictor.js

@@ -1,16 +0,0 @@
-"use strict";
-
-module.exports = function paethPredictor(left, above, upLeft) {
-  let paeth = left + above - upLeft;
-  let pLeft = Math.abs(paeth - left);
-  let pAbove = Math.abs(paeth - above);
-  let pUpLeft = Math.abs(paeth - upLeft);
-
-  if (pLeft <= pAbove && pLeft <= pUpLeft) {
-    return left;
-  }
-  if (pAbove <= pUpLeft) {
-    return above;
-  }
-  return upLeft;
-};

package/node_modules/pngjs/lib/parser-async.js

@@ -1,165 +0,0 @@
-"use strict";
-
-let util = require("util");
-let zlib = require("zlib");
-let ChunkStream = require("./chunkstream");
-let FilterAsync = require("./filter-parse-async");
-let Parser = require("./parser");
-let bitmapper = require("./bitmapper");
-let formatNormaliser = require("./format-normaliser");
-
-let ParserAsync = (module.exports = function (options) {
-  ChunkStream.call(this);
-
-  this._parser = new Parser(options, {
-    read: this.read.bind(this),
-    error: this._handleError.bind(this),
-    metadata: this._handleMetaData.bind(this),
-    gamma: this.emit.bind(this, "gamma"),
-    palette: this._handlePalette.bind(this),
-    transColor: this._handleTransColor.bind(this),
-    finished: this._finished.bind(this),
-    inflateData: this._inflateData.bind(this),
-    simpleTransparency: this._simpleTransparency.bind(this),
-    headersFinished: this._headersFinished.bind(this),
-  });
-  this._options = options;
-  this.writable = true;
-
-  this._parser.start();
-});
-util.inherits(ParserAsync, ChunkStream);
-
-ParserAsync.prototype._handleError = function (err) {
-  this.emit("error", err);
-
-  this.writable = false;
-
-  this.destroy();
-
-  if (this._inflate && this._inflate.destroy) {
-    this._inflate.destroy();
-  }
-
-  if (this._filter) {
-    this._filter.destroy();
-    // For backward compatibility with Node 7 and below.
-    // Suppress errors due to _inflate calling write() even after
-    // it's destroy()'ed.
-    this._filter.on("error", function () {});
-  }
-
-  this.errord = true;
-};
-
-ParserAsync.prototype._inflateData = function (data) {
-  if (!this._inflate) {
-    if (this._bitmapInfo.interlace) {
-      this._inflate = zlib.createInflate();
-
-      this._inflate.on("error", this.emit.bind(this, "error"));
-      this._filter.on("complete", this._complete.bind(this));
-
-      this._inflate.pipe(this._filter);
-    } else {
-      let rowSize =
-        ((this._bitmapInfo.width *
-          this._bitmapInfo.bpp *
-          this._bitmapInfo.depth +
-          7) >>
-          3) +
-        1;
-      let imageSize = rowSize * this._bitmapInfo.height;
-      let chunkSize = Math.max(imageSize, zlib.Z_MIN_CHUNK);
-
-      this._inflate = zlib.createInflate({ chunkSize: chunkSize });
-      let leftToInflate = imageSize;
-
-      let emitError = this.emit.bind(this, "error");
-      this._inflate.on("error", function (err) {
-        if (!leftToInflate) {
-          return;
-        }
-
-        emitError(err);
-      });
-      this._filter.on("complete", this._complete.bind(this));
-
-      let filterWrite = this._filter.write.bind(this._filter);
-      this._inflate.on("data", function (chunk) {
-        if (!leftToInflate) {
-          return;
-        }
-
-        if (chunk.length > leftToInflate) {
-          chunk = chunk.slice(0, leftToInflate);
-        }
-
-        leftToInflate -= chunk.length;
-
-        filterWrite(chunk);
-      });
-
-      this._inflate.on("end", this._filter.end.bind(this._filter));
-    }
-  }
-  this._inflate.write(data);
-};
-
-ParserAsync.prototype._handleMetaData = function (metaData) {
-  this._metaData = metaData;
-  this._bitmapInfo = Object.create(metaData);
-
-  this._filter = new FilterAsync(this._bitmapInfo);
-};
-
-ParserAsync.prototype._handleTransColor = function (transColor) {
-  this._bitmapInfo.transColor = transColor;
-};
-
-ParserAsync.prototype._handlePalette = function (palette) {
-  this._bitmapInfo.palette = palette;
-};
-
-ParserAsync.prototype._simpleTransparency = function () {
-  this._metaData.alpha = true;
-};
-
-ParserAsync.prototype._headersFinished = function () {
-  // Up until this point, we don't know if we have a tRNS chunk (alpha)
-  // so we can't emit metadata any earlier
-  this.emit("metadata", this._metaData);
-};
-
-ParserAsync.prototype._finished = function () {
-  if (this.errord) {
-    return;
-  }
-
-  if (!this._inflate) {
-    this.emit("error", "No Inflate block");
-  } else {
-    // no more data to inflate
-    this._inflate.end();
-  }
-};
-
-ParserAsync.prototype._complete = function (filteredData) {
-  if (this.errord) {
-    return;
-  }
-
-  let normalisedBitmapData;
-
-  try {
-    let bitmapData = bitmapper.dataToBitMap(filteredData, this._bitmapInfo);
-
-    normalisedBitmapData = formatNormaliser(bitmapData, this._bitmapInfo);
-    bitmapData = null;
-  } catch (ex) {
-    this._handleError(ex);
-    return;
-  }
-
-  this.emit("parsed", normalisedBitmapData);
-};

package/node_modules/pngjs/lib/parser-sync.js

@@ -1,108 +0,0 @@
-"use strict";
-
-let hasSyncZlib = true;
-let zlib = require("zlib");
-let inflateSync = require("./sync-inflate");
-if (!zlib.deflateSync) {
-  hasSyncZlib = false;
-}
-let SyncReader = require("./sync-reader");
-let FilterSync = require("./filter-parse-sync");
-let Parser = require("./parser");
-let bitmapper = require("./bitmapper");
-let formatNormaliser = require("./format-normaliser");
-
-module.exports = function (buffer, options) {
-  if (!hasSyncZlib) {
-    throw new Error(
-      "To use the sync capability of this library in old node versions, please pin pngjs to v2.3.0"
-    );
-  }
-
-  let err;
-  function handleError(_err_) {
-    err = _err_;
-  }
-
-  let metaData;
-  function handleMetaData(_metaData_) {
-    metaData = _metaData_;
-  }
-
-  function handleTransColor(transColor) {
-    metaData.transColor = transColor;
-  }
-
-  function handlePalette(palette) {
-    metaData.palette = palette;
-  }
-
-  function handleSimpleTransparency() {
-    metaData.alpha = true;
-  }
-
-  let gamma;
-  function handleGamma(_gamma_) {
-    gamma = _gamma_;
-  }
-
-  let inflateDataList = [];
-  function handleInflateData(inflatedData) {
-    inflateDataList.push(inflatedData);
-  }
-
-  let reader = new SyncReader(buffer);
-
-  let parser = new Parser(options, {
-    read: reader.read.bind(reader),
-    error: handleError,
-    metadata: handleMetaData,
-    gamma: handleGamma,
-    palette: handlePalette,
-    transColor: handleTransColor,
-    inflateData: handleInflateData,
-    simpleTransparency: handleSimpleTransparency,
-  });
-
-  parser.start();
-  reader.process();
-
-  if (err) {
-    throw err;
-  }
-
-  //join together the inflate datas
-  let inflateData = Buffer.concat(inflateDataList);
-  inflateDataList.length = 0;
-
-  let inflatedData;
-  if (metaData.interlace) {
-    inflatedData = zlib.inflateSync(inflateData);
-  } else {
-    let rowSize =
-      ((metaData.width * metaData.bpp * metaData.depth + 7) >> 3) + 1;
-    let imageSize = rowSize * metaData.height;
-    inflatedData = inflateSync(inflateData, {
-      chunkSize: imageSize,
-      maxLength: imageSize,
-    });
-  }
-  inflateData = null;
-
-  if (!inflatedData || !inflatedData.length) {
-    throw new Error("bad png - invalid inflate data response");
-  }
-
-  let unfilteredData = FilterSync.process(inflatedData, metaData);
-  inflateData = null;
-
-  let bitmapData = bitmapper.dataToBitMap(unfilteredData, metaData);
-  unfilteredData = null;
-
-  let normalisedBitmapData = formatNormaliser(bitmapData, metaData);
-
-  metaData.data = normalisedBitmapData;
-  metaData.gamma = gamma || 0;
-
-  return metaData;
-};

package/node_modules/pngjs/lib/parser.js

@@ -1,290 +0,0 @@
-"use strict";
-
-let constants = require("./constants");
-let CrcCalculator = require("./crc");
-
-let Parser = (module.exports = function (options, dependencies) {
-  this._options = options;
-  options.checkCRC = options.checkCRC !== false;
-
-  this._hasIHDR = false;
-  this._hasIEND = false;
-  this._emittedHeadersFinished = false;
-
-  // input flags/metadata
-  this._palette = [];
-  this._colorType = 0;
-
-  this._chunks = {};
-  this._chunks[constants.TYPE_IHDR] = this._handleIHDR.bind(this);
-  this._chunks[constants.TYPE_IEND] = this._handleIEND.bind(this);
-  this._chunks[constants.TYPE_IDAT] = this._handleIDAT.bind(this);
-  this._chunks[constants.TYPE_PLTE] = this._handlePLTE.bind(this);
-  this._chunks[constants.TYPE_tRNS] = this._handleTRNS.bind(this);
-  this._chunks[constants.TYPE_gAMA] = this._handleGAMA.bind(this);
-
-  this.read = dependencies.read;
-  this.error = dependencies.error;
-  this.metadata = dependencies.metadata;
-  this.gamma = dependencies.gamma;
-  this.transColor = dependencies.transColor;
-  this.palette = dependencies.palette;
-  this.parsed = dependencies.parsed;
-  this.inflateData = dependencies.inflateData;
-  this.finished = dependencies.finished;
-  this.simpleTransparency = dependencies.simpleTransparency;
-  this.headersFinished = dependencies.headersFinished || function () {};
-});
-
-Parser.prototype.start = function () {
-  this.read(constants.PNG_SIGNATURE.length, this._parseSignature.bind(this));
-};
-
-Parser.prototype._parseSignature = function (data) {
-  let signature = constants.PNG_SIGNATURE;
-
-  for (let i = 0; i < signature.length; i++) {
-    if (data[i] !== signature[i]) {
-      this.error(new Error("Invalid file signature"));
-      return;
-    }
-  }
-  this.read(8, this._parseChunkBegin.bind(this));
-};
-
-Parser.prototype._parseChunkBegin = function (data) {
-  // chunk content length
-  let length = data.readUInt32BE(0);
-
-  // chunk type
-  let type = data.readUInt32BE(4);
-  let name = "";
-  for (let i = 4; i < 8; i++) {
-    name += String.fromCharCode(data[i]);
-  }
-
-  //console.log('chunk ', name, length);
-
-  // chunk flags
-  let ancillary = Boolean(data[4] & 0x20); // or critical
-  //    priv = Boolean(data[5] & 0x20), // or public
-  //    safeToCopy = Boolean(data[7] & 0x20); // or unsafe
-
-  if (!this._hasIHDR && type !== constants.TYPE_IHDR) {
-    this.error(new Error("Expected IHDR on beggining"));
-    return;
-  }
-
-  this._crc = new CrcCalculator();
-  this._crc.write(Buffer.from(name));
-
-  if (this._chunks[type]) {
-    return this._chunks[type](length);
-  }
-
-  if (!ancillary) {
-    this.error(new Error("Unsupported critical chunk type " + name));
-    return;
-  }
-
-  this.read(length + 4, this._skipChunk.bind(this));
-};
-
-Parser.prototype._skipChunk = function (/*data*/) {
-  this.read(8, this._parseChunkBegin.bind(this));
-};
-
-Parser.prototype._handleChunkEnd = function () {
-  this.read(4, this._parseChunkEnd.bind(this));
-};
-
-Parser.prototype._parseChunkEnd = function (data) {
-  let fileCrc = data.readInt32BE(0);
-  let calcCrc = this._crc.crc32();
-
-  // check CRC
-  if (this._options.checkCRC && calcCrc !== fileCrc) {
-    this.error(new Error("Crc error - " + fileCrc + " - " + calcCrc));
-    return;
-  }
-
-  if (!this._hasIEND) {
-    this.read(8, this._parseChunkBegin.bind(this));
-  }
-};
-
-Parser.prototype._handleIHDR = function (length) {
-  this.read(length, this._parseIHDR.bind(this));
-};
-Parser.prototype._parseIHDR = function (data) {
-  this._crc.write(data);
-
-  let width = data.readUInt32BE(0);
-  let height = data.readUInt32BE(4);
-  let depth = data[8];
-  let colorType = data[9]; // bits: 1 palette, 2 color, 4 alpha
-  let compr = data[10];
-  let filter = data[11];
-  let interlace = data[12];
-
-  // console.log('    width', width, 'height', height,
-  //     'depth', depth, 'colorType', colorType,
-  //     'compr', compr, 'filter', filter, 'interlace', interlace
-  // );
-
-  if (
-    depth !== 8 &&
-    depth !== 4 &&
-    depth !== 2 &&
-    depth !== 1 &&
-    depth !== 16
-  ) {
-    this.error(new Error("Unsupported bit depth " + depth));
-    return;
-  }
-  if (!(colorType in constants.COLORTYPE_TO_BPP_MAP)) {
-    this.error(new Error("Unsupported color type"));
-    return;
-  }
-  if (compr !== 0) {
-    this.error(new Error("Unsupported compression method"));
-    return;
-  }
-  if (filter !== 0) {
-    this.error(new Error("Unsupported filter method"));
-    return;
-  }
-  if (interlace !== 0 && interlace !== 1) {
-    this.error(new Error("Unsupported interlace method"));
-    return;
-  }
-
-  this._colorType = colorType;
-
-  let bpp = constants.COLORTYPE_TO_BPP_MAP[this._colorType];
-
-  this._hasIHDR = true;
-
-  this.metadata({
-    width: width,
-    height: height,
-    depth: depth,
-    interlace: Boolean(interlace),
-    palette: Boolean(colorType & constants.COLORTYPE_PALETTE),
-    color: Boolean(colorType & constants.COLORTYPE_COLOR),
-    alpha: Boolean(colorType & constants.COLORTYPE_ALPHA),
-    bpp: bpp,
-    colorType: colorType,
-  });
-
-  this._handleChunkEnd();
-};
-
-Parser.prototype._handlePLTE = function (length) {
-  this.read(length, this._parsePLTE.bind(this));
-};
-Parser.prototype._parsePLTE = function (data) {
-  this._crc.write(data);
-
-  let entries = Math.floor(data.length / 3);
-  // console.log('Palette:', entries);
-
-  for (let i = 0; i < entries; i++) {
-    this._palette.push([data[i * 3], data[i * 3 + 1], data[i * 3 + 2], 0xff]);
-  }
-
-  this.palette(this._palette);
-
-  this._handleChunkEnd();
-};
-
-Parser.prototype._handleTRNS = function (length) {
-  this.simpleTransparency();
-  this.read(length, this._parseTRNS.bind(this));
-};
-Parser.prototype._parseTRNS = function (data) {
-  this._crc.write(data);
-
-  // palette
-  if (this._colorType === constants.COLORTYPE_PALETTE_COLOR) {
-    if (this._palette.length === 0) {
-      this.error(new Error("Transparency chunk must be after palette"));
-      return;
-    }
-    if (data.length > this._palette.length) {
-      this.error(new Error("More transparent colors than palette size"));
-      return;
-    }
-    for (let i = 0; i < data.length; i++) {
-      this._palette[i][3] = data[i];
-    }
-    this.palette(this._palette);
-  }
-
-  // for colorType 0 (grayscale) and 2 (rgb)
-  // there might be one gray/color defined as transparent
-  if (this._colorType === constants.COLORTYPE_GRAYSCALE) {
-    // grey, 2 bytes
-    this.transColor([data.readUInt16BE(0)]);
-  }
-  if (this._colorType === constants.COLORTYPE_COLOR) {
-    this.transColor([
-      data.readUInt16BE(0),
-      data.readUInt16BE(2),
-      data.readUInt16BE(4),
-    ]);
-  }
-
-  this._handleChunkEnd();
-};
-
-Parser.prototype._handleGAMA = function (length) {
-  this.read(length, this._parseGAMA.bind(this));
-};
-Parser.prototype._parseGAMA = function (data) {
-  this._crc.write(data);
-  this.gamma(data.readUInt32BE(0) / constants.GAMMA_DIVISION);
-
-  this._handleChunkEnd();
-};
-
-Parser.prototype._handleIDAT = function (length) {
-  if (!this._emittedHeadersFinished) {
-    this._emittedHeadersFinished = true;
-    this.headersFinished();
-  }
-  this.read(-length, this._parseIDAT.bind(this, length));
-};
-Parser.prototype._parseIDAT = function (length, data) {
-  this._crc.write(data);
-
-  if (
-    this._colorType === constants.COLORTYPE_PALETTE_COLOR &&
-    this._palette.length === 0
-  ) {
-    throw new Error("Expected palette not found");
-  }
-
-  this.inflateData(data);
-  let leftOverLength = length - data.length;
-
-  if (leftOverLength > 0) {
-    this._handleIDAT(leftOverLength);
-  } else {
-    this._handleChunkEnd();
-  }
-};
-
-Parser.prototype._handleIEND = function (length) {
-  this.read(length, this._parseIEND.bind(this));
-};
-Parser.prototype._parseIEND = function (data) {
-  this._crc.write(data);
-
-  this._hasIEND = true;
-  this._handleChunkEnd();
-
-  if (this.finished) {
-    this.finished();
-  }
-};