@mapcatch/util 1.0.7 → 1.0.8-a

package/src/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/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/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/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/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/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/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/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/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')
+  },
+}