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

package/node_modules/pngjs/lib/filter-pack.js

@@ -1,171 +0,0 @@
-"use strict";
-
-let paethPredictor = require("./paeth-predictor");
-
-function filterNone(pxData, pxPos, byteWidth, rawData, rawPos) {
-  for (let x = 0; x < byteWidth; x++) {
-    rawData[rawPos + x] = pxData[pxPos + x];
-  }
-}
-
-function filterSumNone(pxData, pxPos, byteWidth) {
-  let sum = 0;
-  let length = pxPos + byteWidth;
-
-  for (let i = pxPos; i < length; i++) {
-    sum += Math.abs(pxData[i]);
-  }
-  return sum;
-}
-
-function filterSub(pxData, pxPos, byteWidth, rawData, rawPos, bpp) {
-  for (let x = 0; x < byteWidth; x++) {
-    let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
-    let val = pxData[pxPos + x] - left;
-
-    rawData[rawPos + x] = val;
-  }
-}
-
-function filterSumSub(pxData, pxPos, byteWidth, bpp) {
-  let sum = 0;
-  for (let x = 0; x < byteWidth; x++) {
-    let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
-    let val = pxData[pxPos + x] - left;
-
-    sum += Math.abs(val);
-  }
-
-  return sum;
-}
-
-function filterUp(pxData, pxPos, byteWidth, rawData, rawPos) {
-  for (let x = 0; x < byteWidth; x++) {
-    let up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;
-    let val = pxData[pxPos + x] - up;
-
-    rawData[rawPos + x] = val;
-  }
-}
-
-function filterSumUp(pxData, pxPos, byteWidth) {
-  let sum = 0;
-  let length = pxPos + byteWidth;
-  for (let x = pxPos; x < length; x++) {
-    let up = pxPos > 0 ? pxData[x - byteWidth] : 0;
-    let val = pxData[x] - up;
-
-    sum += Math.abs(val);
-  }
-
-  return sum;
-}
-
-function filterAvg(pxData, pxPos, byteWidth, rawData, rawPos, bpp) {
-  for (let x = 0; x < byteWidth; x++) {
-    let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
-    let up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;
-    let val = pxData[pxPos + x] - ((left + up) >> 1);
-
-    rawData[rawPos + x] = val;
-  }
-}
-
-function filterSumAvg(pxData, pxPos, byteWidth, bpp) {
-  let sum = 0;
-  for (let x = 0; x < byteWidth; x++) {
-    let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
-    let up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;
-    let val = pxData[pxPos + x] - ((left + up) >> 1);
-
-    sum += Math.abs(val);
-  }
-
-  return sum;
-}
-
-function filterPaeth(pxData, pxPos, byteWidth, rawData, rawPos, bpp) {
-  for (let x = 0; x < byteWidth; x++) {
-    let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
-    let up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;
-    let upleft =
-      pxPos > 0 && x >= bpp ? pxData[pxPos + x - (byteWidth + bpp)] : 0;
-    let val = pxData[pxPos + x] - paethPredictor(left, up, upleft);
-
-    rawData[rawPos + x] = val;
-  }
-}
-
-function filterSumPaeth(pxData, pxPos, byteWidth, bpp) {
-  let sum = 0;
-  for (let x = 0; x < byteWidth; x++) {
-    let left = x >= bpp ? pxData[pxPos + x - bpp] : 0;
-    let up = pxPos > 0 ? pxData[pxPos + x - byteWidth] : 0;
-    let upleft =
-      pxPos > 0 && x >= bpp ? pxData[pxPos + x - (byteWidth + bpp)] : 0;
-    let val = pxData[pxPos + x] - paethPredictor(left, up, upleft);
-
-    sum += Math.abs(val);
-  }
-
-  return sum;
-}
-
-let filters = {
-  0: filterNone,
-  1: filterSub,
-  2: filterUp,
-  3: filterAvg,
-  4: filterPaeth,
-};
-
-let filterSums = {
-  0: filterSumNone,
-  1: filterSumSub,
-  2: filterSumUp,
-  3: filterSumAvg,
-  4: filterSumPaeth,
-};
-
-module.exports = function (pxData, width, height, options, bpp) {
-  let filterTypes;
-  if (!("filterType" in options) || options.filterType === -1) {
-    filterTypes = [0, 1, 2, 3, 4];
-  } else if (typeof options.filterType === "number") {
-    filterTypes = [options.filterType];
-  } else {
-    throw new Error("unrecognised filter types");
-  }
-
-  if (options.bitDepth === 16) {
-    bpp *= 2;
-  }
-  let byteWidth = width * bpp;
-  let rawPos = 0;
-  let pxPos = 0;
-  let rawData = Buffer.alloc((byteWidth + 1) * height);
-
-  let sel = filterTypes[0];
-
-  for (let y = 0; y < height; y++) {
-    if (filterTypes.length > 1) {
-      // find best filter for this line (with lowest sum of values)
-      let min = Infinity;
-
-      for (let i = 0; i < filterTypes.length; i++) {
-        let sum = filterSums[filterTypes[i]](pxData, pxPos, byteWidth, bpp);
-        if (sum < min) {
-          sel = filterTypes[i];
-          min = sum;
-        }
-      }
-    }
-
-    rawData[rawPos] = sel;
-    rawPos++;
-    filters[sel](pxData, pxPos, byteWidth, rawData, rawPos, bpp);
-    rawPos += byteWidth;
-    pxPos += byteWidth;
-  }
-  return rawData;
-};

package/node_modules/pngjs/lib/filter-parse-async.js

@@ -1,24 +0,0 @@
-"use strict";
-
-let util = require("util");
-let ChunkStream = require("./chunkstream");
-let Filter = require("./filter-parse");
-
-let FilterAsync = (module.exports = function (bitmapInfo) {
-  ChunkStream.call(this);
-
-  let buffers = [];
-  let that = this;
-  this._filter = new Filter(bitmapInfo, {
-    read: this.read.bind(this),
-    write: function (buffer) {
-      buffers.push(buffer);
-    },
-    complete: function () {
-      that.emit("complete", Buffer.concat(buffers));
-    },
-  });
-
-  this._filter.start();
-});
-util.inherits(FilterAsync, ChunkStream);

package/node_modules/pngjs/lib/filter-parse-sync.js

@@ -1,21 +0,0 @@
-"use strict";
-
-let SyncReader = require("./sync-reader");
-let Filter = require("./filter-parse");
-
-exports.process = function (inBuffer, bitmapInfo) {
-  let outBuffers = [];
-  let reader = new SyncReader(inBuffer);
-  let filter = new Filter(bitmapInfo, {
-    read: reader.read.bind(reader),
-    write: function (bufferPart) {
-      outBuffers.push(bufferPart);
-    },
-    complete: function () {},
-  });
-
-  filter.start();
-  reader.process();
-
-  return Buffer.concat(outBuffers);
-};

package/node_modules/pngjs/lib/filter-parse.js

@@ -1,177 +0,0 @@
-"use strict";
-
-let interlaceUtils = require("./interlace");
-let paethPredictor = require("./paeth-predictor");
-
-function getByteWidth(width, bpp, depth) {
-  let byteWidth = width * bpp;
-  if (depth !== 8) {
-    byteWidth = Math.ceil(byteWidth / (8 / depth));
-  }
-  return byteWidth;
-}
-
-let Filter = (module.exports = function (bitmapInfo, dependencies) {
-  let width = bitmapInfo.width;
-  let height = bitmapInfo.height;
-  let interlace = bitmapInfo.interlace;
-  let bpp = bitmapInfo.bpp;
-  let depth = bitmapInfo.depth;
-
-  this.read = dependencies.read;
-  this.write = dependencies.write;
-  this.complete = dependencies.complete;
-
-  this._imageIndex = 0;
-  this._images = [];
-  if (interlace) {
-    let passes = interlaceUtils.getImagePasses(width, height);
-    for (let i = 0; i < passes.length; i++) {
-      this._images.push({
-        byteWidth: getByteWidth(passes[i].width, bpp, depth),
-        height: passes[i].height,
-        lineIndex: 0,
-      });
-    }
-  } else {
-    this._images.push({
-      byteWidth: getByteWidth(width, bpp, depth),
-      height: height,
-      lineIndex: 0,
-    });
-  }
-
-  // when filtering the line we look at the pixel to the left
-  // the spec also says it is done on a byte level regardless of the number of pixels
-  // so if the depth is byte compatible (8 or 16) we subtract the bpp in order to compare back
-  // a pixel rather than just a different byte part. However if we are sub byte, we ignore.
-  if (depth === 8) {
-    this._xComparison = bpp;
-  } else if (depth === 16) {
-    this._xComparison = bpp * 2;
-  } else {
-    this._xComparison = 1;
-  }
-});
-
-Filter.prototype.start = function () {
-  this.read(
-    this._images[this._imageIndex].byteWidth + 1,
-    this._reverseFilterLine.bind(this)
-  );
-};
-
-Filter.prototype._unFilterType1 = function (
-  rawData,
-  unfilteredLine,
-  byteWidth
-) {
-  let xComparison = this._xComparison;
-  let xBiggerThan = xComparison - 1;
-
-  for (let x = 0; x < byteWidth; x++) {
-    let rawByte = rawData[1 + x];
-    let f1Left = x > xBiggerThan ? unfilteredLine[x - xComparison] : 0;
-    unfilteredLine[x] = rawByte + f1Left;
-  }
-};
-
-Filter.prototype._unFilterType2 = function (
-  rawData,
-  unfilteredLine,
-  byteWidth
-) {
-  let lastLine = this._lastLine;
-
-  for (let x = 0; x < byteWidth; x++) {
-    let rawByte = rawData[1 + x];
-    let f2Up = lastLine ? lastLine[x] : 0;
-    unfilteredLine[x] = rawByte + f2Up;
-  }
-};
-
-Filter.prototype._unFilterType3 = function (
-  rawData,
-  unfilteredLine,
-  byteWidth
-) {
-  let xComparison = this._xComparison;
-  let xBiggerThan = xComparison - 1;
-  let lastLine = this._lastLine;
-
-  for (let x = 0; x < byteWidth; x++) {
-    let rawByte = rawData[1 + x];
-    let f3Up = lastLine ? lastLine[x] : 0;
-    let f3Left = x > xBiggerThan ? unfilteredLine[x - xComparison] : 0;
-    let f3Add = Math.floor((f3Left + f3Up) / 2);
-    unfilteredLine[x] = rawByte + f3Add;
-  }
-};
-
-Filter.prototype._unFilterType4 = function (
-  rawData,
-  unfilteredLine,
-  byteWidth
-) {
-  let xComparison = this._xComparison;
-  let xBiggerThan = xComparison - 1;
-  let lastLine = this._lastLine;
-
-  for (let x = 0; x < byteWidth; x++) {
-    let rawByte = rawData[1 + x];
-    let f4Up = lastLine ? lastLine[x] : 0;
-    let f4Left = x > xBiggerThan ? unfilteredLine[x - xComparison] : 0;
-    let f4UpLeft = x > xBiggerThan && lastLine ? lastLine[x - xComparison] : 0;
-    let f4Add = paethPredictor(f4Left, f4Up, f4UpLeft);
-    unfilteredLine[x] = rawByte + f4Add;
-  }
-};
-
-Filter.prototype._reverseFilterLine = function (rawData) {
-  let filter = rawData[0];
-  let unfilteredLine;
-  let currentImage = this._images[this._imageIndex];
-  let byteWidth = currentImage.byteWidth;
-
-  if (filter === 0) {
-    unfilteredLine = rawData.slice(1, byteWidth + 1);
-  } else {
-    unfilteredLine = Buffer.alloc(byteWidth);
-
-    switch (filter) {
-      case 1:
-        this._unFilterType1(rawData, unfilteredLine, byteWidth);
-        break;
-      case 2:
-        this._unFilterType2(rawData, unfilteredLine, byteWidth);
-        break;
-      case 3:
-        this._unFilterType3(rawData, unfilteredLine, byteWidth);
-        break;
-      case 4:
-        this._unFilterType4(rawData, unfilteredLine, byteWidth);
-        break;
-      default:
-        throw new Error("Unrecognised filter type - " + filter);
-    }
-  }
-
-  this.write(unfilteredLine);
-
-  currentImage.lineIndex++;
-  if (currentImage.lineIndex >= currentImage.height) {
-    this._lastLine = null;
-    this._imageIndex++;
-    currentImage = this._images[this._imageIndex];
-  } else {
-    this._lastLine = unfilteredLine;
-  }
-
-  if (currentImage) {
-    // read, using the byte width that may be from the new current image
-    this.read(currentImage.byteWidth + 1, this._reverseFilterLine.bind(this));
-  } else {
-    this._lastLine = null;
-    this.complete();
-  }
-};

package/node_modules/pngjs/lib/format-normaliser.js

@@ -1,93 +0,0 @@
-"use strict";
-
-function dePalette(indata, outdata, width, height, palette) {
-  let pxPos = 0;
-  // use values from palette
-  for (let y = 0; y < height; y++) {
-    for (let x = 0; x < width; x++) {
-      let color = palette[indata[pxPos]];
-
-      if (!color) {
-        throw new Error("index " + indata[pxPos] + " not in palette");
-      }
-
-      for (let i = 0; i < 4; i++) {
-        outdata[pxPos + i] = color[i];
-      }
-      pxPos += 4;
-    }
-  }
-}
-
-function replaceTransparentColor(indata, outdata, width, height, transColor) {
-  let pxPos = 0;
-  for (let y = 0; y < height; y++) {
-    for (let x = 0; x < width; x++) {
-      let makeTrans = false;
-
-      if (transColor.length === 1) {
-        if (transColor[0] === indata[pxPos]) {
-          makeTrans = true;
-        }
-      } else if (
-        transColor[0] === indata[pxPos] &&
-        transColor[1] === indata[pxPos + 1] &&
-        transColor[2] === indata[pxPos + 2]
-      ) {
-        makeTrans = true;
-      }
-      if (makeTrans) {
-        for (let i = 0; i < 4; i++) {
-          outdata[pxPos + i] = 0;
-        }
-      }
-      pxPos += 4;
-    }
-  }
-}
-
-function scaleDepth(indata, outdata, width, height, depth) {
-  let maxOutSample = 255;
-  let maxInSample = Math.pow(2, depth) - 1;
-  let pxPos = 0;
-
-  for (let y = 0; y < height; y++) {
-    for (let x = 0; x < width; x++) {
-      for (let i = 0; i < 4; i++) {
-        outdata[pxPos + i] = Math.floor(
-          (indata[pxPos + i] * maxOutSample) / maxInSample + 0.5
-        );
-      }
-      pxPos += 4;
-    }
-  }
-}
-
-module.exports = function (indata, imageData) {
-  let depth = imageData.depth;
-  let width = imageData.width;
-  let height = imageData.height;
-  let colorType = imageData.colorType;
-  let transColor = imageData.transColor;
-  let palette = imageData.palette;
-
-  let outdata = indata; // only different for 16 bits
-
-  if (colorType === 3) {
-    // paletted
-    dePalette(indata, outdata, width, height, palette);
-  } else {
-    if (transColor) {
-      replaceTransparentColor(indata, outdata, width, height, transColor);
-    }
-    // if it needs scaling
-    if (depth !== 8) {
-      // if we need to change the buffer size
-      if (depth === 16) {
-        outdata = Buffer.alloc(width * height * 4);
-      }
-      scaleDepth(indata, outdata, width, height, depth);
-    }
-  }
-  return outdata;
-};

package/node_modules/pngjs/lib/interlace.js

@@ -1,95 +0,0 @@
-"use strict";
-
-// Adam 7
-//   0 1 2 3 4 5 6 7
-// 0 x 6 4 6 x 6 4 6
-// 1 7 7 7 7 7 7 7 7
-// 2 5 6 5 6 5 6 5 6
-// 3 7 7 7 7 7 7 7 7
-// 4 3 6 4 6 3 6 4 6
-// 5 7 7 7 7 7 7 7 7
-// 6 5 6 5 6 5 6 5 6
-// 7 7 7 7 7 7 7 7 7
-
-let imagePasses = [
-  {
-    // pass 1 - 1px
-    x: [0],
-    y: [0],
-  },
-  {
-    // pass 2 - 1px
-    x: [4],
-    y: [0],
-  },
-  {
-    // pass 3 - 2px
-    x: [0, 4],
-    y: [4],
-  },
-  {
-    // pass 4 - 4px
-    x: [2, 6],
-    y: [0, 4],
-  },
-  {
-    // pass 5 - 8px
-    x: [0, 2, 4, 6],
-    y: [2, 6],
-  },
-  {
-    // pass 6 - 16px
-    x: [1, 3, 5, 7],
-    y: [0, 2, 4, 6],
-  },
-  {
-    // pass 7 - 32px
-    x: [0, 1, 2, 3, 4, 5, 6, 7],
-    y: [1, 3, 5, 7],
-  },
-];
-
-exports.getImagePasses = function (width, height) {
-  let images = [];
-  let xLeftOver = width % 8;
-  let yLeftOver = height % 8;
-  let xRepeats = (width - xLeftOver) / 8;
-  let yRepeats = (height - yLeftOver) / 8;
-  for (let i = 0; i < imagePasses.length; i++) {
-    let pass = imagePasses[i];
-    let passWidth = xRepeats * pass.x.length;
-    let passHeight = yRepeats * pass.y.length;
-    for (let j = 0; j < pass.x.length; j++) {
-      if (pass.x[j] < xLeftOver) {
-        passWidth++;
-      } else {
-        break;
-      }
-    }
-    for (let j = 0; j < pass.y.length; j++) {
-      if (pass.y[j] < yLeftOver) {
-        passHeight++;
-      } else {
-        break;
-      }
-    }
-    if (passWidth > 0 && passHeight > 0) {
-      images.push({ width: passWidth, height: passHeight, index: i });
-    }
-  }
-  return images;
-};
-
-exports.getInterlaceIterator = function (width) {
-  return function (x, y, pass) {
-    let outerXLeftOver = x % imagePasses[pass].x.length;
-    let outerX =
-      ((x - outerXLeftOver) / imagePasses[pass].x.length) * 8 +
-      imagePasses[pass].x[outerXLeftOver];
-    let outerYLeftOver = y % imagePasses[pass].y.length;
-    let outerY =
-      ((y - outerYLeftOver) / imagePasses[pass].y.length) * 8 +
-      imagePasses[pass].y[outerYLeftOver];
-    return outerX * 4 + outerY * width * 4;
-  };
-};

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

@@ -1,50 +0,0 @@
-"use strict";
-
-let util = require("util");
-let Stream = require("stream");
-let constants = require("./constants");
-let Packer = require("./packer");
-
-let PackerAsync = (module.exports = function (opt) {
-  Stream.call(this);
-
-  let options = opt || {};
-
-  this._packer = new Packer(options);
-  this._deflate = this._packer.createDeflate();
-
-  this.readable = true;
-});
-util.inherits(PackerAsync, Stream);
-
-PackerAsync.prototype.pack = function (data, width, height, gamma) {
-  // Signature
-  this.emit("data", Buffer.from(constants.PNG_SIGNATURE));
-  this.emit("data", this._packer.packIHDR(width, height));
-
-  if (gamma) {
-    this.emit("data", this._packer.packGAMA(gamma));
-  }
-
-  let filteredData = this._packer.filterData(data, width, height);
-
-  // compress it
-  this._deflate.on("error", this.emit.bind(this, "error"));
-
-  this._deflate.on(
-    "data",
-    function (compressedData) {
-      this.emit("data", this._packer.packIDAT(compressedData));
-    }.bind(this)
-  );
-
-  this._deflate.on(
-    "end",
-    function () {
-      this.emit("data", this._packer.packIEND());
-      this.emit("end");
-    }.bind(this)
-  );
-
-  this._deflate.end(filteredData);
-};

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

@@ -1,56 +0,0 @@
-"use strict";
-
-let hasSyncZlib = true;
-let zlib = require("zlib");
-if (!zlib.deflateSync) {
-  hasSyncZlib = false;
-}
-let constants = require("./constants");
-let Packer = require("./packer");
-
-module.exports = function (metaData, opt) {
-  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 options = opt || {};
-
-  let packer = new Packer(options);
-
-  let chunks = [];
-
-  // Signature
-  chunks.push(Buffer.from(constants.PNG_SIGNATURE));
-
-  // Header
-  chunks.push(packer.packIHDR(metaData.width, metaData.height));
-
-  if (metaData.gamma) {
-    chunks.push(packer.packGAMA(metaData.gamma));
-  }
-
-  let filteredData = packer.filterData(
-    metaData.data,
-    metaData.width,
-    metaData.height
-  );
-
-  // compress it
-  let compressedData = zlib.deflateSync(
-    filteredData,
-    packer.getDeflateOptions()
-  );
-  filteredData = null;
-
-  if (!compressedData || !compressedData.length) {
-    throw new Error("bad png - invalid compressed data response");
-  }
-  chunks.push(packer.packIDAT(compressedData));
-
-  // End
-  chunks.push(packer.packIEND());
-
-  return Buffer.concat(chunks);
-};