@mapcatch/util 1.0.9 → 1.0.10-a

package/src/image-size/types/ico.js

@@ -1,74 +0,0 @@
-import { readUInt16LE } from './utils'
-
-const TYPE_ICON = 1
-
-/**
- * ICON Header
- *
- * | Offset | Size | Purpose |
- * | 0	    | 2    | Reserved. Must always be 0.  |
- * | 2      | 2    | Image type: 1 for icon (.ICO) image, 2 for cursor (.CUR) image. Other values are invalid. |
- * | 4      | 2    | Number of images in the file. |
- *
- */
-const SIZE_HEADER = 2 + 2 + 2 // 6
-
-/**
- * Image Entry
- *
- * | Offset | Size | Purpose |
- * | 0	    | 1    | Image width in pixels. Can be any number between 0 and 255. Value 0 means width is 256 pixels. |
- * | 1      | 1    | Image height in pixels. Can be any number between 0 and 255. Value 0 means height is 256 pixels. |
- * | 2      | 1    | Number of colors in the color palette. Should be 0 if the image does not use a color palette. |
- * | 3      | 1    | Reserved. Should be 0. |
- * | 4      | 2    | ICO format: Color planes. Should be 0 or 1. |
- * |        |      | CUR format: The horizontal coordinates of the hotspot in number of pixels from the left. |
- * | 6      | 2    | ICO format: Bits per pixel. |
- * |        |      | CUR format: The vertical coordinates of the hotspot in number of pixels from the top. |
- * | 8      | 4    | The size of the image's data in bytes |
- * | 12     | 4    | The offset of BMP or PNG data from the beginning of the ICO/CUR file |
- *
- */
-const SIZE_IMAGE_ENTRY = 1 + 1 + 1 + 1 + 2 + 2 + 4 + 4 // 16
-
-function getSizeFromOffset(input, offset) {
-  const value = input[offset]
-  return value === 0 ? 256 : value
-}
-
-function getImageSize(input, imageIndex) {
-  const offset = SIZE_HEADER + imageIndex * SIZE_IMAGE_ENTRY
-  return {
-    height: getSizeFromOffset(input, offset + 1),
-    width: getSizeFromOffset(input, offset),
-  }
-}
-
-export const ICO = {
-  validate(input) {
-    const reserved = readUInt16LE(input, 0)
-    const imageCount = readUInt16LE(input, 4)
-    if (reserved !== 0 || imageCount === 0) return false
-
-    const imageType = readUInt16LE(input, 2)
-    return imageType === TYPE_ICON
-  },
-
-  calculate(input) {
-    const nbImages = readUInt16LE(input, 4)
-    const imageSize = getImageSize(input, 0)
-
-    if (nbImages === 1) return imageSize
-
-    const imgs = [imageSize]
-    for (let imageIndex = 1; imageIndex < nbImages; imageIndex += 1) {
-      imgs.push(getImageSize(input, imageIndex))
-    }
-
-    return {
-      height: imageSize.height,
-      images: imgs,
-      width: imageSize.width,
-    }
-  },
-}

package/src/image-size/types/index.js

@@ -1,43 +0,0 @@
-// load all available handlers explicitely for browserify support
-import { BMP } from './bmp'
-import { CUR } from './cur'
-import { DDS } from './dds'
-import { GIF } from './gif'
-import { HEIF } from './heif'
-import { ICNS } from './icns'
-import { ICO } from './ico'
-import { J2C } from './j2c'
-import { JP2 } from './jp2'
-import { JPG } from './jpg'
-import { KTX } from './ktx'
-import { PNG } from './png'
-import { PNM } from './pnm'
-import { PSD } from './psd'
-import { SVG } from './svg'
-import { TGA } from './tga'
-import { TIFF } from './tiff'
-import { WEBP } from './webp'
-
-export const typeHandlers = new Map([
-  ['bmp', BMP],
-  ['cur', CUR],
-  ['dds', DDS],
-  ['gif', GIF],
-  ['heif', HEIF],
-  ['icns', ICNS],
-  ['ico', ICO],
-  ['j2c', J2C],
-  ['jp2', JP2],
-  ['jpg', JPG],
-  ['ktx', KTX],
-  ['png', PNG],
-  ['pnm', PNM],
-  ['psd', PSD],
-  ['svg', SVG],
-  ['tga', TGA],
-  ['tiff', TIFF],
-  ['webp', WEBP],
-])
-
-
-export const types = Array.from(typeHandlers.keys())

package/src/image-size/types/j2c.js

@@ -1,11 +0,0 @@
-import { toHexString, readUInt32BE } from './utils'
-
-export const J2C = {
-  // TODO: this doesn't seem right. SIZ marker doesn't have to be right after the SOC
-  validate: (input) => toHexString(input, 0, 4) === 'ff4fff51',
-
-  calculate: (input) => ({
-    height: readUInt32BE(input, 12),
-    width: readUInt32BE(input, 8),
-  }),
-}

package/src/image-size/types/jp2.js

@@ -1,22 +0,0 @@
-import { readUInt32BE, findBox } from './utils'
-
-export const JP2 = {
-  validate(input) {
-    if (readUInt32BE(input, 4) !== 0x6a502020 || readUInt32BE(input, 0) < 1)  return false
-    const ftypBox = findBox(input, 'ftyp', 0)
-    if (!ftypBox) return false
-    return readUInt32BE(input, ftypBox.offset + 4) === 0x66747970
-  },
-
-  calculate(input) {
-    const jp2hBox = findBox(input, 'jp2h', 0)
-    const ihdrBox = jp2hBox && findBox(input, 'ihdr', jp2hBox.offset + 8)
-    if (ihdrBox) {
-      return {
-        height: readUInt32BE(input, ihdrBox.offset + 8),
-        width: readUInt32BE(input, ihdrBox.offset + 12),
-      }
-    }
-    throw new TypeError('Unsupported JPEG 2000 format')
-  },
-}

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

@@ -1,157 +0,0 @@
-// 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/image-size/types/ktx.js

@@ -1,18 +0,0 @@
-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/image-size/types/png.js

@@ -1,36 +0,0 @@
-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/image-size/types/pnm.js

@@ -1,74 +0,0 @@
-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/image-size/types/psd.js

@@ -1,10 +0,0 @@
-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/image-size/types/svg.js

@@ -1,100 +0,0 @@
-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/image-size/types/tga.js

@@ -1,14 +0,0 @@
-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/image-size/types/tiff.js

@@ -1,92 +0,0 @@
-// 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 }
-  },
-}