@mapcatch/util 1.0.15 → 2.0.1

package/src/photo-parser/image-size/types/jpg.js

@@ -0,0 +1,157 @@
+// NOTE: we only support baseline and progressive JPGs here
+// due to the structure of the loader class, we only get a buffer
+// with a maximum size of 4096 bytes. so if the SOF marker is outside
+// if this range we can't detect the file size correctly.
+import { readUInt, readUInt16BE, toHexString } from './utils'
+
+const EXIF_MARKER = '45786966'
+const APP1_DATA_SIZE_BYTES = 2
+const EXIF_HEADER_BYTES = 6
+const TIFF_BYTE_ALIGN_BYTES = 2
+const BIG_ENDIAN_BYTE_ALIGN = '4d4d'
+const LITTLE_ENDIAN_BYTE_ALIGN = '4949'
+
+// Each entry is exactly 12 bytes
+const IDF_ENTRY_BYTES = 12
+const NUM_DIRECTORY_ENTRIES_BYTES = 2
+
+function isEXIF (input) {
+  return toHexString(input, 2, 6) === EXIF_MARKER
+}
+
+function extractSize (input, index) {
+  return {
+    height: readUInt16BE(input, index),
+    width: readUInt16BE(input, index + 2)
+  }
+}
+
+function extractOrientation (exifBlock, isBigEndian) {
+  // TODO: assert that this contains 0x002A
+  // let STATIC_MOTOROLA_TIFF_HEADER_BYTES = 2
+  // let TIFF_IMAGE_FILE_DIRECTORY_BYTES = 4
+
+  // TODO: derive from TIFF_IMAGE_FILE_DIRECTORY_BYTES
+  const idfOffset = 8
+
+  // IDF osset works from right after the header bytes
+  // (so the offset includes the tiff byte align)
+  const offset = EXIF_HEADER_BYTES + idfOffset
+
+  const idfDirectoryEntries = readUInt(exifBlock, 16, offset, isBigEndian)
+
+  for (
+    let directoryEntryNumber = 0;
+    directoryEntryNumber < idfDirectoryEntries;
+    directoryEntryNumber++
+  ) {
+    const start =
+      offset +
+      NUM_DIRECTORY_ENTRIES_BYTES +
+      directoryEntryNumber * IDF_ENTRY_BYTES
+    const end = start + IDF_ENTRY_BYTES
+
+    // Skip on corrupt EXIF blocks
+    if (start > exifBlock.length) {
+      return
+    }
+
+    const block = exifBlock.slice(start, end)
+    const tagNumber = readUInt(block, 16, 0, isBigEndian)
+
+    // 0x0112 (decimal: 274) is the `orientation` tag ID
+    if (tagNumber === 274) {
+      const dataFormat = readUInt(block, 16, 2, isBigEndian)
+      if (dataFormat !== 3) {
+        return
+      }
+
+      // unsinged int has 2 bytes per component
+      // if there would more than 4 bytes in total it's a pointer
+      const numberOfComponents = readUInt(block, 32, 4, isBigEndian)
+      if (numberOfComponents !== 1) {
+        return
+      }
+
+      return readUInt(block, 16, 8, isBigEndian)
+    }
+  }
+}
+
+function validateExifBlock (input, index) {
+  // Skip APP1 Data Size
+  const exifBlock = input.slice(APP1_DATA_SIZE_BYTES, index)
+
+  // Consider byte alignment
+  const byteAlign = toHexString(
+    exifBlock,
+    EXIF_HEADER_BYTES,
+    EXIF_HEADER_BYTES + TIFF_BYTE_ALIGN_BYTES
+  )
+
+  // Ignore Empty EXIF. Validate byte alignment
+  const isBigEndian = byteAlign === BIG_ENDIAN_BYTE_ALIGN
+  const isLittleEndian = byteAlign === LITTLE_ENDIAN_BYTE_ALIGN
+
+  if (isBigEndian || isLittleEndian) {
+    return extractOrientation(exifBlock, isBigEndian)
+  }
+}
+
+function validateInput (input, index) {
+  // index should be within buffer limits
+  if (index > input.length) {
+    throw new TypeError('Corrupt JPG, exceeded buffer limits')
+  }
+  // Every JPEG block must begin with a 0xFF
+  if (input[index] !== 0xff) {
+    throw new TypeError('Invalid JPG, marker table corrupted')
+  }
+}
+
+export const JPG = {
+  validate: (input) => toHexString(input, 0, 2) === 'ffd8',
+
+  calculate (input) {
+    // Skip 4 chars, they are for signature
+    input = input.slice(4)
+
+    let orientation
+    let next
+    while (input.length) {
+      // read length of the next block
+      const i = readUInt16BE(input, 0)
+
+      if (isEXIF(input)) {
+        orientation = validateExifBlock(input, i)
+      }
+
+      // ensure correct format
+      validateInput(input, i)
+
+      // 0xFFC0 is baseline standard(SOF)
+      // 0xFFC1 is baseline optimized(SOF)
+      // 0xFFC2 is progressive(SOF2)
+      next = input[i + 1]
+      if (next === 0xc0 || next === 0xc1 || next === 0xc2) {
+        const size = extractSize(input, i + 5)
+
+        // TODO: is orientation=0 a valid answer here?
+        if (!orientation) {
+          return size
+        }
+
+        return {
+          height: size.height,
+          orientation,
+          width: size.width
+        }
+      }
+
+      // move to the next block
+      input = input.slice(i + 2)
+    }
+
+    throw new TypeError('Invalid JPG, no size found')
+  }
+}

package/src/photo-parser/image-size/types/ktx.js

@@ -0,0 +1,18 @@
+import { toUTF8String, readUInt32LE } from './utils'
+
+export const KTX = {
+  validate: (input) => {
+    const signature = toUTF8String(input, 1, 7)
+    return ['KTX 11', 'KTX 20'].includes(signature)
+  },
+
+  calculate: (input) => {
+    const type = input[5] === 0x31 ? 'ktx' : 'ktx2'
+    const offset = type === 'ktx' ? 36 : 20
+    return ({
+      height: readUInt32LE(input, offset + 4),
+      width: readUInt32LE(input, offset),
+      type
+    })
+  }
+}

package/src/photo-parser/image-size/types/png.js

@@ -0,0 +1,36 @@
+import { toUTF8String, readUInt32BE } from './utils'
+
+const pngSignature = 'PNG\r\n\x1a\n'
+const pngImageHeaderChunkName = 'IHDR'
+
+// Used to detect "fried" png's: http://www.jongware.com/pngdefry.html
+const pngFriedChunkName = 'CgBI'
+
+export const PNG = {
+  validate (input) {
+    if (pngSignature === toUTF8String(input, 1, 8)) {
+      let chunkName = toUTF8String(input, 12, 16)
+      if (chunkName === pngFriedChunkName) {
+        chunkName = toUTF8String(input, 28, 32)
+      }
+      if (chunkName !== pngImageHeaderChunkName) {
+        throw new TypeError('Invalid PNG')
+      }
+      return true
+    }
+    return false
+  },
+
+  calculate (input) {
+    if (toUTF8String(input, 12, 16) === pngFriedChunkName) {
+      return {
+        height: readUInt32BE(input, 36),
+        width: readUInt32BE(input, 32)
+      }
+    }
+    return {
+      height: readUInt32BE(input, 20),
+      width: readUInt32BE(input, 16)
+    }
+  }
+}

package/src/photo-parser/image-size/types/pnm.js

@@ -0,0 +1,74 @@
+import { toUTF8String } from './utils'
+
+const PNMTypes = {
+  P1: 'pbm/ascii',
+  P2: 'pgm/ascii',
+  P3: 'ppm/ascii',
+  P4: 'pbm',
+  P5: 'pgm',
+  P6: 'ppm',
+  P7: 'pam',
+  PF: 'pfm'
+}
+
+const handlers = {
+  default: (lines) => {
+    let dimensions = []
+
+    while (lines.length > 0) {
+      const line = lines.shift()
+      if (line[0] === '#') {
+        continue
+      }
+      dimensions = line.split(' ')
+      break
+    }
+
+    if (dimensions.length === 2) {
+      return {
+        height: parseInt(dimensions[1], 10),
+        width: parseInt(dimensions[0], 10)
+      }
+    } else {
+      throw new TypeError('Invalid PNM')
+    }
+  },
+  pam: (lines) => {
+    const size = {}
+    while (lines.length > 0) {
+      const line = lines.shift()
+      if (line.length > 16 || line.charCodeAt(0) > 128) {
+        continue
+      }
+      const [key, value] = line.split(' ')
+      if (key && value) {
+        size[key.toLowerCase()] = parseInt(value, 10)
+      }
+      if (size.height && size.width) {
+        break
+      }
+    }
+
+    if (size.height && size.width) {
+      return {
+        height: size.height,
+        width: size.width
+      }
+    } else {
+      throw new TypeError('Invalid PAM')
+    }
+  }
+}
+
+export const PNM = {
+  validate: (input) => toUTF8String(input, 0, 2) in PNMTypes,
+
+  calculate (input) {
+    const signature = toUTF8String(input, 0, 2)
+    const type = PNMTypes[signature]
+    // TODO: this probably generates garbage. move to a stream based parser
+    const lines = toUTF8String(input, 3).split(/[\r\n]+/)
+    const handler = handlers[type] || handlers.default
+    return handler(lines)
+  }
+}

package/src/photo-parser/image-size/types/psd.js

@@ -0,0 +1,10 @@
+import { toUTF8String, readUInt32BE } from './utils'
+
+export const PSD = {
+  validate: (input) => toUTF8String(input, 0, 4) === '8BPS',
+
+  calculate: (input) => ({
+    height: readUInt32BE(input, 14),
+    width: readUInt32BE(input, 18)
+  })
+}

package/src/photo-parser/image-size/types/svg.js

@@ -0,0 +1,100 @@
+import { toUTF8String } from './utils'
+
+const svgReg = /<svg\s([^>"']|"[^"]*"|'[^']*')*>/
+
+const extractorRegExps = {
+  height: /\sheight=(['"])([^%]+?)\1/,
+  root: svgReg,
+  viewbox: /\sviewBox=(['"])(.+?)\1/i,
+  width: /\swidth=(['"])([^%]+?)\1/
+}
+
+const INCH_CM = 2.54
+const units = {
+  in: 96,
+  cm: 96 / INCH_CM,
+  em: 16,
+  ex: 8,
+  m: (96 / INCH_CM) * 100,
+  mm: 96 / INCH_CM / 10,
+  pc: 96 / 72 / 12,
+  pt: 96 / 72,
+  px: 1
+}
+
+const unitsReg = new RegExp(
+  `^([0-9.]+(?:e\\d+)?)(${Object.keys(units).join('|')})?$`
+)
+
+function parseLength (len) {
+  const m = unitsReg.exec(len)
+  if (!m) {
+    return undefined
+  }
+  return Math.round(Number(m[1]) * (units[m[2]] || 1))
+}
+
+function parseViewbox (viewbox) {
+  const bounds = viewbox.split(' ')
+  return {
+    height: parseLength(bounds[3]),
+    width: parseLength(bounds[2])
+  }
+}
+
+function parseAttributes (root) {
+  const width = root.match(extractorRegExps.width)
+  const height = root.match(extractorRegExps.height)
+  const viewbox = root.match(extractorRegExps.viewbox)
+  return {
+    height: height && (parseLength(height[2])),
+    viewbox: viewbox && (parseViewbox(viewbox[2])),
+    width: width && (parseLength(width[2]))
+  }
+}
+
+function calculateByDimensions (attrs) {
+  return {
+    height: attrs.height,
+    width: attrs.width
+  }
+}
+
+function calculateByViewbox (attrs, viewbox) {
+  const ratio = (viewbox.width) / (viewbox.height)
+  if (attrs.width) {
+    return {
+      height: Math.floor(attrs.width / ratio),
+      width: attrs.width
+    }
+  }
+  if (attrs.height) {
+    return {
+      height: attrs.height,
+      width: Math.floor(attrs.height * ratio)
+    }
+  }
+  return {
+    height: viewbox.height,
+    width: viewbox.width
+  }
+}
+
+export const SVG = {
+  // Scan only the first kilo-byte to speed up the check on larger files
+  validate: (input) => svgReg.test(toUTF8String(input, 0, 1000)),
+
+  calculate (input) {
+    const root = toUTF8String(input).match(extractorRegExps.root)
+    if (root) {
+      const attrs = parseAttributes(root[0])
+      if (attrs.width && attrs.height) {
+        return calculateByDimensions(attrs)
+      }
+      if (attrs.viewbox) {
+        return calculateByViewbox(attrs, attrs.viewbox)
+      }
+    }
+    throw new TypeError('Invalid SVG')
+  }
+}

package/src/photo-parser/image-size/types/tga.js

@@ -0,0 +1,14 @@
+import { readUInt16LE } from './utils'
+
+export const TGA = {
+  validate (input) {
+    return readUInt16LE(input, 0) === 0 && readUInt16LE(input, 4) === 0
+  },
+
+  calculate (input) {
+    return {
+      height: readUInt16LE(input, 14),
+      width: readUInt16LE(input, 12)
+    }
+  }
+}

package/src/photo-parser/image-size/types/tiff.js

@@ -0,0 +1,92 @@
+// based on http://www.compix.com/fileformattif.htm
+// TO-DO: support big-endian as well
+import { readUInt, toHexString, toUTF8String } from './utils'
+
+// Read IFD (image-file-directory) into a buffer
+function readIFD (input, isBigEndian) {
+  const ifdOffset = readUInt(input, 32, 4, isBigEndian)
+  return input.slice(ifdOffset + 2)
+}
+
+// TIFF values seem to be messed up on Big-Endian, this helps
+function readValue (input, isBigEndian) {
+  const low = readUInt(input, 16, 8, isBigEndian)
+  const high = readUInt(input, 16, 10, isBigEndian)
+  return (high << 16) + low
+}
+
+// move to the next tag
+function nextTag (input) {
+  if (input.length > 24) {
+    return input.slice(12)
+  }
+}
+
+// Extract IFD tags from TIFF metadata
+function extractTags (input, isBigEndian) {
+  const tags = {}
+
+  let temp = input
+  while (temp && temp.length) {
+    const code = readUInt(temp, 16, 0, isBigEndian)
+    const type = readUInt(temp, 16, 2, isBigEndian)
+    const length = readUInt(temp, 32, 4, isBigEndian)
+
+    // 0 means end of IFD
+    if (code === 0) {
+      break
+    } else {
+      // 256 is width, 257 is height
+      // if (code === 256 || code === 257) {
+      if (length === 1 && (type === 3 || type === 4)) {
+        tags[code] = readValue(temp, isBigEndian)
+      }
+
+      // move to the next tag
+      temp = nextTag(temp)
+    }
+  }
+
+  return tags
+}
+
+// Test if the TIFF is Big Endian or Little Endian
+function determineEndianness (input) {
+  const signature = toUTF8String(input, 0, 2)
+  if ('II' === signature) {
+    return 'LE'
+  } else if ('MM' === signature) {
+    return 'BE'
+  }
+}
+
+const signatures = [
+  // '492049', // currently not supported
+  '49492a00', // Little endian
+  '4d4d002a' // Big Endian
+  // '4d4d002a', // BigTIFF > 4GB. currently not supported
+]
+
+export const TIFF = {
+  validate: (input) => signatures.includes(toHexString(input, 0, 4)),
+
+  calculate (input) {
+    // Determine BE/LE
+    const isBigEndian = determineEndianness(input) === 'BE'
+
+    // read the IFD
+    const ifdBuffer = readIFD(input, isBigEndian)
+
+    // extract the tags from the IFD
+    const tags = extractTags(ifdBuffer, isBigEndian)
+
+    const width = tags[256]
+    const height = tags[257]
+
+    if (!width || !height) {
+      throw new TypeError('Invalid Tiff. Missing tags')
+    }
+
+    return { height, width }
+  }
+}

package/src/photo-parser/image-size/types/utils.js

@@ -0,0 +1,83 @@
+const decoder = new TextDecoder()
+export const toUTF8String = (
+  input,
+  start = 0,
+  end = input.length
+) => decoder.decode(input.slice(start, end))
+
+export const toHexString = (input, start = 0, end = input.length) =>
+  input
+    .slice(start, end)
+    .reduce((memo, i) => memo + ('0' + i.toString(16)).slice(-2), '')
+
+export const readInt16LE = (input, offset = 0) => {
+  const val = input[offset] + input[offset + 1] * 2 ** 8
+  return val | ((val & (2 ** 15)) * 0x1fffe)
+}
+
+export const readUInt16BE = (input, offset = 0) =>
+  input[offset] * 2 ** 8 + input[offset + 1]
+
+export const readUInt16LE = (input, offset = 0) =>
+  input[offset] + input[offset + 1] * 2 ** 8
+
+export const readUInt24LE = (input, offset = 0) =>
+  input[offset] + input[offset + 1] * 2 ** 8 + input[offset + 2] * 2 ** 16
+
+export const readInt32LE = (input, offset = 0) =>
+  input[offset] +
+  input[offset + 1] * 2 ** 8 +
+  input[offset + 2] * 2 ** 16 +
+  (input[offset + 3] << 24)
+
+export const readUInt32BE = (input, offset = 0) =>
+  input[offset] * 2 ** 24 +
+  input[offset + 1] * 2 ** 16 +
+  input[offset + 2] * 2 ** 8 +
+  input[offset + 3]
+
+export const readUInt32LE = (input, offset = 0) =>
+  input[offset] +
+  input[offset + 1] * 2 ** 8 +
+  input[offset + 2] * 2 ** 16 +
+  input[offset + 3] * 2 ** 24
+
+// Abstract reading multi-byte unsigned integers
+const methods = {
+  readUInt16BE,
+  readUInt16LE,
+  readUInt32BE,
+  readUInt32LE
+}
+
+export function readUInt (
+  input,
+  bits,
+  offset,
+  isBigEndian
+) {
+  offset = offset || 0
+  const endian = isBigEndian ? 'BE' : 'LE'
+  const methodName = 'readUInt' + bits + endian
+  return methods[methodName](input, offset)
+}
+
+function readBox (buffer, offset) {
+  if (buffer.length - offset < 4) return
+  const boxSize = readUInt32BE(buffer, offset)
+  if (buffer.length - offset < boxSize) return
+  return {
+    name: toUTF8String(buffer, 4 + offset, 8 + offset),
+    offset,
+    size: boxSize
+  }
+}
+
+export function findBox (buffer, boxName, offset) {
+  while (offset < buffer.length) {
+    const box = readBox(buffer, offset)
+    if (!box) break
+    if (box.name === boxName) return box
+    offset += box.size
+  }
+}

package/src/photo-parser/image-size/types/webp.js

@@ -0,0 +1,67 @@
+// based on https://developers.google.com/speed/webp/docs/riff_container
+import { toHexString, toUTF8String, readInt16LE, readUInt24LE } from './utils'
+
+function calculateExtended (input) {
+  return {
+    height: 1 + readUInt24LE(input, 7),
+    width: 1 + readUInt24LE(input, 4)
+  }
+}
+
+function calculateLossless (input) {
+  return {
+    height:
+      1 +
+      (((input[4] & 0xf) << 10) | (input[3] << 2) | ((input[2] & 0xc0) >> 6)),
+    width: 1 + (((input[2] & 0x3f) << 8) | input[1])
+  }
+}
+
+function calculateLossy (input) {
+  // `& 0x3fff` returns the last 14 bits
+  // TO-DO: include webp scaling in the calculations
+  return {
+    height: readInt16LE(input, 8) & 0x3fff,
+    width: readInt16LE(input, 6) & 0x3fff
+  }
+}
+
+export const WEBP = {
+  validate (input) {
+    const riffHeader = 'RIFF' === toUTF8String(input, 0, 4)
+    const webpHeader = 'WEBP' === toUTF8String(input, 8, 12)
+    const vp8Header = 'VP8' === toUTF8String(input, 12, 15)
+    return riffHeader && webpHeader && vp8Header
+  },
+
+  calculate (input) {
+    const chunkHeader = toUTF8String(input, 12, 16)
+    input = input.slice(20, 30)
+
+    // Extended webp stream signature
+    if (chunkHeader === 'VP8X') {
+      const extendedHeader = input[0]
+      const validStart = (extendedHeader & 0xc0) === 0
+      const validEnd = (extendedHeader & 0x01) === 0
+      if (validStart && validEnd) {
+        return calculateExtended(input)
+      } else {
+        // TODO: breaking change
+        throw new TypeError('Invalid WebP')
+      }
+    }
+
+    // Lossless webp stream signature
+    if (chunkHeader === 'VP8 ' && input[0] !== 0x2f) {
+      return calculateLossy(input)
+    }
+
+    // Lossy webp stream signature
+    const signature = toHexString(input, 3, 6)
+    if (chunkHeader === 'VP8L' && signature !== '9d012a') {
+      return calculateLossless(input)
+    }
+
+    throw new TypeError('Invalid WebP')
+  }
+}