big updat:

- update dependencies
- add webp support and webp conversion for profile images

node_modules/js-binary-schema-parser/src/index.js

@@ -0,0 +1,49 @@
+export const parse = (stream, schema, result = {}, parent = result) => {
+  if (Array.isArray(schema)) {
+    schema.forEach(partSchema => parse(stream, partSchema, result, parent))
+  } else if (typeof schema === 'function') {
+    schema(stream, result, parent, parse)
+  } else {
+    const key = Object.keys(schema)[0]
+    if (Array.isArray(schema[key])) {
+      parent[key] = {}
+      parse(stream, schema[key], result, parent[key])
+    } else {
+      parent[key] = schema[key](stream, result, parent, parse)
+    }
+  }
+  return result
+}
+
+export const conditional = (schema, conditionFunc) => (
+  stream,
+  result,
+  parent,
+  parse
+) => {
+  if (conditionFunc(stream, result, parent)) {
+    parse(stream, schema, result, parent)
+  }
+}
+
+export const loop = (schema, continueFunc) => (
+  stream,
+  result,
+  parent,
+  parse
+) => {
+  const arr = []
+  let lastStreamPos = stream.pos;
+  while (continueFunc(stream, result, parent)) {
+    const newParent = {}
+    parse(stream, schema, result, newParent)
+    // cases when whole file is parsed but no termination is there and stream position is not getting updated as well
+    // it falls into infinite recursion, null check to avoid the same
+    if(stream.pos === lastStreamPos) {
+      break
+    }
+    lastStreamPos = stream.pos
+    arr.push(newParent)
+  }
+  return arr
+}

node_modules/js-binary-schema-parser/src/parsers/uint8.js

@@ -0,0 +1,78 @@
+// Default stream and parsers for Uint8TypedArray data type
+
+export const buildStream = uint8Data => ({
+  data: uint8Data,
+  pos: 0
+})
+
+export const readByte = () => stream => {
+  return stream.data[stream.pos++]
+}
+
+export const peekByte = (offset = 0) => stream => {
+  return stream.data[stream.pos + offset]
+}
+
+export const readBytes = length => stream => {
+  return stream.data.subarray(stream.pos, (stream.pos += length))
+}
+
+export const peekBytes = length => stream => {
+  return stream.data.subarray(stream.pos, stream.pos + length)
+}
+
+export const readString = length => stream => {
+  return Array.from(readBytes(length)(stream))
+    .map(value => String.fromCharCode(value))
+    .join('')
+}
+
+export const readUnsigned = littleEndian => stream => {
+  const bytes = readBytes(2)(stream)
+  return littleEndian ? (bytes[1] << 8) + bytes[0] : (bytes[0] << 8) + bytes[1]
+}
+
+export const readArray = (byteSize, totalOrFunc) => (
+  stream,
+  result,
+  parent
+) => {
+  const total =
+    typeof totalOrFunc === 'function'
+      ? totalOrFunc(stream, result, parent)
+      : totalOrFunc
+
+  const parser = readBytes(byteSize)
+  const arr = new Array(total)
+  for (var i = 0; i < total; i++) {
+    arr[i] = parser(stream)
+  }
+  return arr
+}
+
+const subBitsTotal = (bits, startIndex, length) => {
+  var result = 0
+  for (var i = 0; i < length; i++) {
+    result += bits[startIndex + i] && 2 ** (length - i - 1)
+  }
+  return result
+}
+
+export const readBits = schema => stream => {
+  const byte = readByte()(stream)
+  // convert the byte to bit array
+  const bits = new Array(8)
+  for (var i = 0; i < 8; i++) {
+    bits[7 - i] = !!(byte & (1 << i))
+  }
+  // convert the bit array to values based on the schema
+  return Object.keys(schema).reduce((res, key) => {
+    const def = schema[key]
+    if (def.length) {
+      res[key] = subBitsTotal(bits, def.index, def.length)
+    } else {
+      res[key] = bits[def.index]
+    }
+    return res
+  }, {})
+}

node_modules/js-binary-schema-parser/src/schemas/gif.js

@@ -0,0 +1,201 @@
+import { conditional, loop } from '../'
+import {
+  readByte,
+  peekByte,
+  readBytes,
+  peekBytes,
+  readString,
+  readUnsigned,
+  readArray,
+  readBits,
+} from '../parsers/uint8'
+
+// a set of 0x00 terminated subblocks
+var subBlocksSchema = {
+  blocks: (stream) => {
+    const terminator = 0x00
+    const chunks = []
+    const streamSize = stream.data.length
+    var total = 0
+    for (
+      var size = readByte()(stream);
+      size !== terminator;
+      size = readByte()(stream)
+    ) {
+      // size becomes undefined for some case when file is corrupted and  terminator is not proper 
+      // null check to avoid recursion
+      if(!size) break;
+      // catch corrupted files with no terminator
+      if (stream.pos + size >= streamSize) {
+        const availableSize = streamSize - stream.pos
+        chunks.push(readBytes(availableSize)(stream))
+        total += availableSize
+        break
+      }
+      chunks.push(readBytes(size)(stream))
+      total += size
+    }
+    const result = new Uint8Array(total)
+    var offset = 0
+    for (var i = 0; i < chunks.length; i++) {
+      result.set(chunks[i], offset)
+      offset += chunks[i].length
+    }
+    return result
+  },
+}
+
+// global control extension
+const gceSchema = conditional(
+  {
+    gce: [
+      { codes: readBytes(2) },
+      { byteSize: readByte() },
+      {
+        extras: readBits({
+          future: { index: 0, length: 3 },
+          disposal: { index: 3, length: 3 },
+          userInput: { index: 6 },
+          transparentColorGiven: { index: 7 },
+        }),
+      },
+      { delay: readUnsigned(true) },
+      { transparentColorIndex: readByte() },
+      { terminator: readByte() },
+    ],
+  },
+  (stream) => {
+    var codes = peekBytes(2)(stream)
+    return codes[0] === 0x21 && codes[1] === 0xf9
+  }
+)
+
+// image pipeline block
+const imageSchema = conditional(
+  {
+    image: [
+      { code: readByte() },
+      {
+        descriptor: [
+          { left: readUnsigned(true) },
+          { top: readUnsigned(true) },
+          { width: readUnsigned(true) },
+          { height: readUnsigned(true) },
+          {
+            lct: readBits({
+              exists: { index: 0 },
+              interlaced: { index: 1 },
+              sort: { index: 2 },
+              future: { index: 3, length: 2 },
+              size: { index: 5, length: 3 },
+            }),
+          },
+        ],
+      },
+      conditional(
+        {
+          lct: readArray(3, (stream, result, parent) => {
+            return Math.pow(2, parent.descriptor.lct.size + 1)
+          }),
+        },
+        (stream, result, parent) => {
+          return parent.descriptor.lct.exists
+        }
+      ),
+      { data: [{ minCodeSize: readByte() }, subBlocksSchema] },
+    ],
+  },
+  (stream) => {
+    return peekByte()(stream) === 0x2c
+  }
+)
+
+// plain text block
+const textSchema = conditional(
+  {
+    text: [
+      { codes: readBytes(2) },
+      { blockSize: readByte() },
+      {
+        preData: (stream, result, parent) =>
+          readBytes(parent.text.blockSize)(stream),
+      },
+      subBlocksSchema,
+    ],
+  },
+  (stream) => {
+    var codes = peekBytes(2)(stream)
+    return codes[0] === 0x21 && codes[1] === 0x01
+  }
+)
+
+// application block
+const applicationSchema = conditional(
+  {
+    application: [
+      { codes: readBytes(2) },
+      { blockSize: readByte() },
+      { id: (stream, result, parent) => readString(parent.blockSize)(stream) },
+      subBlocksSchema,
+    ],
+  },
+  (stream) => {
+    var codes = peekBytes(2)(stream)
+    return codes[0] === 0x21 && codes[1] === 0xff
+  }
+)
+
+// comment block
+const commentSchema = conditional(
+  {
+    comment: [{ codes: readBytes(2) }, subBlocksSchema],
+  },
+  (stream) => {
+    var codes = peekBytes(2)(stream)
+    return codes[0] === 0x21 && codes[1] === 0xfe
+  }
+)
+
+const schema = [
+  { header: [{ signature: readString(3) }, { version: readString(3) }] },
+  {
+    lsd: [
+      { width: readUnsigned(true) },
+      { height: readUnsigned(true) },
+      {
+        gct: readBits({
+          exists: { index: 0 },
+          resolution: { index: 1, length: 3 },
+          sort: { index: 4 },
+          size: { index: 5, length: 3 },
+        }),
+      },
+      { backgroundColorIndex: readByte() },
+      { pixelAspectRatio: readByte() },
+    ],
+  },
+  conditional(
+    {
+      gct: readArray(3, (stream, result) =>
+        Math.pow(2, result.lsd.gct.size + 1)
+      ),
+    },
+    (stream, result) => result.lsd.gct.exists
+  ),
+  // content frames
+  {
+    frames: loop(
+      [gceSchema, applicationSchema, commentSchema, imageSchema, textSchema],
+      (stream) => {
+        var nextCode = peekByte()(stream)
+        // rather than check for a terminator, we should check for the existence
+        // of an ext or image block to avoid infinite loops
+        //var terminator = 0x3B;
+        //return nextCode !== terminator;
+        return nextCode === 0x21 || nextCode === 0x2c
+      }
+    ),
+  },
+]
+
+export default schema