Latest repo

node_modules/jay-peg/src/index.js

@@ -0,0 +1,56 @@
+import * as r from "restructure";
+
+import DACMarker from "./markers/dac.js";
+import DefineHuffmanTableMarker from "./markers/dht.js";
+import DQTMarker from "./markers/dqt.js";
+import DRIMarker from "./markers/dri.js";
+import EndOfImageMarker from "./markers/eoi.js";
+import EXIFMarker from "./markers/exif.js";
+import JFIFMarker from "./markers/jfif.js";
+import SOSMarker from "./markers/sos.js";
+import StartOfFrameMarker from "./markers/sof.js";
+import StartOfImageMarker from "./markers/soi.js";
+
+const UnknownMarker = {
+  length: r.uint16be,
+  buf: new r.Buffer((parent) => parent.length - 2),
+};
+
+const unknownMarkers = Array(63)
+  .fill(0)
+  .reduce((acc, v, i) => ({ ...acc, [i + 0xffc0]: UnknownMarker }), {});
+
+const Marker = new r.VersionedStruct(r.uint16be, {
+  ...unknownMarkers,
+  0xffc0: StartOfFrameMarker,
+  0xffc1: StartOfFrameMarker,
+  0xffc2: StartOfFrameMarker,
+  0xffc3: StartOfFrameMarker,
+  0xffc4: DefineHuffmanTableMarker,
+  0xffc5: StartOfFrameMarker,
+  0xffc6: StartOfFrameMarker,
+  0xffc7: StartOfFrameMarker,
+  0xffc9: StartOfFrameMarker,
+  0xffca: StartOfFrameMarker,
+  0xffcb: StartOfFrameMarker,
+  0xffcc: DACMarker,
+  0xffcd: StartOfFrameMarker,
+  0xffce: StartOfFrameMarker,
+  0xffcf: StartOfFrameMarker,
+  0xffd8: StartOfImageMarker,
+  0xffd9: EndOfImageMarker,
+  0xffda: SOSMarker,
+  0xffdb: DQTMarker,
+  0xffdd: DRIMarker,
+  0xffe0: JFIFMarker,
+  0xffe1: EXIFMarker,
+});
+
+const JPEG = new r.Array(Marker);
+
+const decode = (buffer) => {
+  const markers = JPEG.fromBuffer(buffer);
+  return markers.map(({ version, ...rest }) => ({ type: version, ...rest }));
+};
+
+export default { decode };

node_modules/jay-peg/src/markers/dac.js

@@ -0,0 +1,14 @@
+import * as r from "restructure";
+
+const DACTable = new r.Struct({
+  identifier: new r.Buffer(1),
+  value: new r.Buffer(1),
+});
+
+const DACMarker = {
+  name: () => "DAC",
+  length: r.uint16be,
+  tables: new r.Array(DACTable, (parent) => parent.length / 2),
+};
+
+export default DACMarker;

node_modules/jay-peg/src/markers/dht.js

@@ -0,0 +1,44 @@
+import * as r from "restructure";
+import { concatenateUint8Arrays, readUInt8 } from "./utils.js";
+
+class HuffmanTableElements {
+  decode(stream, parent) {
+    const tables = {};
+
+    let buffer = stream.buffer.slice(
+      stream.pos,
+      stream.pos + parent.length - 2,
+    );
+
+    while (buffer.length > 0) {
+      let offset = 1;
+
+      const elements = [];
+      const identifier = readUInt8(buffer, 0);
+      const lengths = buffer.slice(offset, offset + 16);
+
+      offset += 16;
+
+      for (const length of lengths) {
+        elements.push(buffer.slice(offset, offset + length));
+        offset += length;
+      }
+
+      buffer = buffer.slice(offset);
+
+      tables[identifier] = concatenateUint8Arrays(elements);
+    }
+
+    stream.pos += parent.length - 2;
+
+    return tables;
+  }
+}
+
+const DefineHuffmanTableMarker = {
+  name: () => "DHT",
+  length: r.uint16be,
+  tables: new HuffmanTableElements(),
+};
+
+export default DefineHuffmanTableMarker;

node_modules/jay-peg/src/markers/dqt.js

@@ -0,0 +1,15 @@
+import * as r from "restructure";
+
+const DQTMarker = {
+  name: () => "DQT",
+  length: r.uint16be,
+  tables: new r.Array(
+    new r.Struct({
+      identifier: new r.Buffer(1),
+      data: new r.Buffer(64),
+    }),
+    (parent) => (parent.length - 2) / 65,
+  ),
+};
+
+export default DQTMarker;

node_modules/jay-peg/src/markers/dri.js

@@ -0,0 +1,9 @@
+import * as r from "restructure";
+
+const DRIMarker = {
+  name: () => "DRI",
+  length: r.uint16be,
+  restartInterval: r.uint16be,
+};
+
+export default DRIMarker;

node_modules/jay-peg/src/markers/eoi.js

@@ -0,0 +1,8 @@
+import * as r from "restructure";
+
+const EndOfImageMarker = {
+  name: () => "EOI",
+  afterEOI: new r.Reserved(r.uint8, Infinity),
+};
+
+export default EndOfImageMarker;

node_modules/jay-peg/src/markers/exif.js

@@ -0,0 +1,327 @@
+import * as r from "restructure";
+import {
+  readUInt8,
+  readUInt16BE,
+  readUInt16LE,
+  readUInt32BE,
+  readUInt32LE,
+  uint8ArrayToHexString,
+  uint8ArrayToString,
+  readInt32BE,
+  readInt32LE,
+} from "./utils.js";
+
+const tags = {
+  ifd: {
+    "010e": "imageDescription",
+    "010f": "make",
+    "011a": "xResolution",
+    "011b": "yResolution",
+    "011c": "planarConfiguration",
+    "012d": "transferFunction",
+    "013b": "artist",
+    "013e": "whitePoint",
+    "013f": "primaryChromaticities",
+    "0100": "imageWidth",
+    "0101": "imageHeight",
+    "0102": "bitsPerSample",
+    "0103": "compression",
+    "0106": "photometricInterpretation",
+    "0110": "model",
+    "0111": "stripOffsets",
+    "0112": "orientation",
+    "0115": "samplesPerPixel",
+    "0116": "rowsPerStrip",
+    "0117": "stripByteCounts",
+    "0128": "resolutionUnit",
+    "0131": "software",
+    "0132": "dateTime",
+    "0201": "jpegInterchangeFormat",
+    "0202": "jpegInterchangeFormatLength",
+    "0211": "ycbCrCoefficients",
+    "0212": "ycbCrSubSampling",
+    "0213": "ycbCrPositioning",
+    "0214": "referenceBlackWhite",
+    "829a": "exposureTime",
+    "829d": "fNumber",
+    "920a": "focalLength",
+    "927c": "makerNote",
+    8298: "copyright",
+    8769: "exifIFDPointer",
+    8822: "exposureProgram",
+    8824: "spectralSensitivity",
+    8825: "gpsInfoIFDPointer",
+    8827: "photographicSensitivity",
+    8828: "oecf",
+    8830: "sensitivityType",
+    8831: "standardOutputSensitivity",
+    8832: "recommendedExposureIndex",
+    8833: "isoSpeed",
+    8834: "isoSpeedLatitudeyyy",
+    8835: "isoSpeedLatitudezzz",
+    9000: "exifVersion",
+    9003: "dateTimeOriginal",
+    9004: "dateTimeDigitized",
+    9101: "componentsConfiguration",
+    9102: "compressedBitsPerPixel",
+    9201: "shutterSpeedValue",
+    9202: "apertureValue",
+    9203: "brightnessValue",
+    9204: "exposureBiasValue",
+    9205: "maxApertureValue",
+    9206: "subjectDistance",
+    9207: "meteringMode",
+    9208: "lightSource",
+    9209: "flash",
+    9214: "subjectArea",
+    9286: "userComment",
+    9290: "subSecTime",
+    9291: "subSecTimeOriginal",
+    9292: "subSecTimeDigitized",
+    a000: "flashpixVersion",
+    a001: "colorSpace",
+    a002: "pixelXDimension",
+    a003: "pixelYDimension",
+    a004: "relatedSoundFile",
+    a005: "interoperabilityIFDPointer",
+    a20b: "flashEnergy",
+    a20c: "spatialFrequencyResponse",
+    a20e: "focalPlaneXResolution",
+    a20f: "focalPlaneYResolution",
+    a40a: "sharpness",
+    a40b: "deviceSettingDescription",
+    a40c: "subjectDistanceRange",
+    a210: "focalPlaneResolutionUnit",
+    a214: "subjectLocation",
+    a215: "exposureIndex",
+    a217: "sensingMethod",
+    a300: "fileSource",
+    a301: "sceneType",
+    a302: "cfaPattern",
+    a401: "customRendered",
+    a402: "exposureMode",
+    a403: "whiteBalance",
+    a404: "digitalZoomRatio",
+    a405: "focalLengthIn35mmFilm",
+    a406: "sceneCaptureType",
+    a407: "gainControl",
+    a408: "contrast",
+    a409: "saturation",
+    a420: "imageUniqueID",
+    a430: "cameraOwnerName",
+    a431: "bodySerialNumber",
+    a432: "lensSpecification",
+    a433: "lensMake",
+    a434: "lensModel",
+    a435: "lensSerialNumber",
+    a500: "gamma",
+  },
+  gps: {
+    "0000": "gpsVersionID",
+    "0001": "gpsLatitudeRef",
+    "0002": "gpsLatitude",
+    "0003": "gpsLongitudeRef",
+    "0004": "gpsLongitude",
+    "0005": "gpsAltitudeRef",
+    "0006": "gpsAltitude",
+    "0007": "gpsTimeStamp",
+    "0008": "gpsSatellites",
+    "0009": "gpsStatus",
+    "000a": "gpsMeasureMode",
+    "000b": "gpsDOP",
+    "000c": "gpsSpeedRef",
+    "000d": "gpsSpeed",
+    "000e": "gpsTrackRef",
+    "000f": "gpsTrack",
+    "0010": "gpsImgDirectionRef",
+    "0011": "gpsImgDirection",
+    "0012": "gpsMapDatum",
+    "0013": "gpsDestLatitudeRef",
+    "0014": "gpsDestLatitude",
+    "0015": "gpsDestLongitudeRef",
+    "0016": "gpsDestLongitude",
+    "0017": "gpsDestBearingRef",
+    "0018": "gpsDestBearing",
+    "0019": "gpsDestDistanceRef",
+    "001a": "gpsDestDistance",
+    "001b": "gpsProcessingMethod",
+    "001c": "gpsAreaInformation",
+    "001d": "gpsDateStamp",
+    "001e": "gpsDifferential",
+    "001f": "gpsHPositioningError",
+  },
+};
+
+class IDFEntries {
+  constructor(bigEndian) {
+    this.bigEndian = bigEndian;
+    this.bytes = [0, 1, 1, 2, 4, 8, 1, 1, 2, 4, 8, 4, 8];
+  }
+
+  _getTagValue(dataValue, dataFormat, componentsNumber) {
+    switch (dataFormat) {
+      case 2:
+        return dataValue.toString("ascii").replace(/\0+$/, "");
+      case 129:
+        return dataValue.toString("utf8").replace(/\0+$/, "");
+      case 7:
+        return "0x" + dataValue.toString("hex");
+      default:
+        return this._getTagValueForNumericalData(dataValue, dataFormat, componentsNumber);
+    }
+  }
+
+  _getTagValueForNumericalData(dataValue, dataFormat, componentsNumber) {
+    const tagValue = [];
+    const componentsBytes = this.bytes[dataFormat];
+    for (let i = 0; i < componentsNumber; i += 1) {
+      tagValue.push(this._getSingleTagValueForNumericalData(dataValue, dataFormat, i * componentsBytes));
+    }
+    return tagValue.length === 1 ? tagValue[0] : tagValue;
+  }
+
+  _getSingleTagValueForNumericalData(dataValue, dataFormat, pos) {
+    const uint16 = (pos) =>
+      this.bigEndian
+        ? readUInt16BE(dataValue, pos)
+        : readUInt16LE(dataValue, pos);
+
+    const uint32 = (pos) =>
+      this.bigEndian
+        ? readUInt32BE(dataValue, pos)
+        : readUInt32LE(dataValue, pos);
+
+    const int32 = (pos) =>
+      this.bigEndian
+        ? readInt32BE(dataValue, pos)
+        : readInt32LE(dataValue, pos);
+
+    switch (dataFormat) {
+      case 1:
+        return readUInt8(dataValue, pos)
+      case 3:
+        return uint16(pos);
+      case 4:
+        return uint32(pos);
+      case 5:
+        return uint32(pos) / uint32(pos + 4);
+      case 9:
+        return int32(pos);
+      case 10: {
+        return int32(pos) / int32(pos + 4);
+      }
+    }
+  }
+
+  _decodeIDFEntries(buffer, tags, offset, log = false) {
+    let pos = 2 + offset;
+
+    const entries = {};
+
+    const uint16 = (pos) =>
+      this.bigEndian ? readUInt16BE(buffer, pos) : readUInt16LE(buffer, pos);
+
+    const uint32 = (pos) =>
+      this.bigEndian ? readUInt32BE(buffer, pos) : readUInt32LE(buffer, pos);
+
+    const numberOfEntries = uint16(offset);
+
+    for (let i = 0; i < numberOfEntries; i++) {
+      const tagAddress = buffer.slice(pos, pos + 2);
+      const dataFormat = uint16(pos + 2);
+      const componentsNumber = uint32(pos + 4);
+      const componentsBytes = this.bytes[dataFormat];
+      const dataLength = componentsNumber * componentsBytes;
+
+      let dataValue = buffer.slice(pos + 8, pos + 12);
+
+      if (dataLength > 4) {
+        const dataOffset = this.bigEndian
+          ? readUInt32BE(dataValue, 0)
+          : readUInt32LE(dataValue, 0);
+
+        dataValue = buffer.slice(dataOffset, dataOffset + dataLength);
+      }
+
+      const tagValue = this._getTagValue(dataValue, dataFormat, componentsNumber);
+
+      const tagNumber = this.bigEndian
+        ? uint8ArrayToHexString(tagAddress)
+        : uint8ArrayToHexString(tagAddress.reverse());
+
+      const tagName = tags[tagNumber];
+
+      entries[tagName] = tagValue;
+
+      pos += 12;
+    }
+
+    return entries;
+  }
+
+  decode(stream, parent) {
+    const buffer = stream.buffer.slice(stream.pos - 8);
+    const offsetToFirstIFD = parent.offsetToFirstIFD;
+
+    if (offsetToFirstIFD > buffer.length) {
+      stream.pos += parent.parent.length - 16;
+      return {};
+    }
+
+    const entries = this._decodeIDFEntries(buffer, tags.ifd, offsetToFirstIFD);
+    const { exifIFDPointer, gpsInfoIFDPointer } = entries;
+
+    if (exifIFDPointer) {
+      entries.subExif = this._decodeIDFEntries(
+        buffer,
+        tags.ifd,
+        exifIFDPointer,
+      );
+    }
+
+    if (gpsInfoIFDPointer) {
+      const gps = gpsInfoIFDPointer;
+      entries.gpsInfo = this._decodeIDFEntries(buffer, tags.gps, gps, true);
+    }
+
+    stream.pos += parent.parent.length - 16;
+
+    return entries;
+  }
+}
+
+const IFDData = (bigEndian) => {
+  const uint16 = bigEndian ? r.uint16be : r.uint16le;
+  const uint32 = bigEndian ? r.uint32be : r.uint32le;
+
+  return new r.Struct({
+    fortyTwo: uint16,
+    offsetToFirstIFD: uint32,
+    entries: new IDFEntries(bigEndian),
+  });
+};
+
+class TIFFHeader {
+  decode(stream, parent) {
+    const byteOrder = uint8ArrayToString(
+      stream.buffer.slice(stream.pos, stream.pos + 2),
+    );
+
+    const bigEndian = byteOrder === "MM";
+
+    stream.pos += 2;
+
+    const data = IFDData(bigEndian).decode(stream, parent);
+
+    return data.entries;
+  }
+}
+
+const EXIFMarker = {
+  name: () => "EXIF",
+  length: r.uint16be,
+  identifier: new r.String(6),
+  entries: new TIFFHeader(),
+};
+
+export default EXIFMarker;

node_modules/jay-peg/src/markers/jfif.js

@@ -0,0 +1,15 @@
+import * as r from "restructure";
+
+const JFIFMarker = {
+  name: () => "JFIF",
+  length: r.uint16be,
+  identifier: new r.String(5),
+  version: r.uint16be,
+  units: r.uint8,
+  xDensity: r.uint16be,
+  yDensity: r.uint16be,
+  thumbnailWidth: r.uint8,
+  thumbnailHeight: r.uint8,
+};
+
+export default JFIFMarker;

node_modules/jay-peg/src/markers/sof.js

@@ -0,0 +1,22 @@
+import * as r from "restructure";
+
+const FrameColorComponent = new r.Struct({
+  id: r.uint8,
+  samplingFactors: r.uint8,
+  quantizationTableId: r.uint8,
+});
+
+const StartOfFrameMarker = {
+  name: () => "SOF",
+  length: r.uint16be,
+  precision: r.uint8,
+  height: r.uint16be,
+  width: r.uint16be,
+  numberOfComponents: r.uint8,
+  components: new r.Array(
+    FrameColorComponent,
+    (parent) => parent.numberOfComponents,
+  ),
+};
+
+export default StartOfFrameMarker;

node_modules/jay-peg/src/markers/soi.js

@@ -0,0 +1,5 @@
+const StartOfImageMarker = {
+  name: () => "SOI",
+};
+
+export default StartOfImageMarker;

node_modules/jay-peg/src/markers/sos.js

@@ -0,0 +1,46 @@
+import * as r from "restructure";
+
+class ImageData {
+  decode(stream) {
+    const buffer = stream.buffer.slice(stream.pos);
+
+    let length = 0;
+    let i = buffer.indexOf(0xff);
+
+    while (i !== -1) {
+      length = i;
+
+      const nextByte = buffer[length + 1];
+      const comesRestart = nextByte >= 0xd0 && nextByte <= 0xd7;
+
+      if (nextByte !== 0x00 && !comesRestart) break;
+
+      i = buffer.indexOf(0xff, i + 1);
+    }
+
+    stream.pos += length;
+
+    return buffer.slice(0, length);
+  }
+}
+
+const SOSComponentSpecification = new r.Struct({
+  scanComponentSelector: r.uint8,
+  entropyCodingTable: new r.Buffer(1),
+});
+
+const SOSMarker = {
+  name: () => "SOS",
+  length: r.uint16be,
+  numberOfImageComponents: r.uint8,
+  componentSpecifications: new r.Array(
+    SOSComponentSpecification,
+    (parent) => parent.numberOfImageComponents,
+  ),
+  startOfSpectral: r.uint8,
+  endOfSpectral: r.uint8,
+  successiveApproximationBit: new r.Buffer(1),
+  data: new ImageData(),
+};
+
+export default SOSMarker;

node_modules/jay-peg/src/markers/utils.js

@@ -0,0 +1,63 @@
+export const readUInt8 = (array, offset) => {
+  return array[offset];
+};
+
+export const readUInt16BE = (array, offset) => {
+  return (array[offset] << 8) | array[offset + 1];
+};
+
+export const readUInt16LE = (array, offset) => {
+  return array[offset] | (array[offset + 1] << 8);
+};
+
+export const readUInt32BE = (array, offset) => {
+  return readInt32BE(array, offset) >>> 0;
+};
+
+export const readUInt32LE = (array, offset) => {
+  return readInt32LE(array, offset) >>> 0;
+};
+
+export const uint8ArrayToHexString = (uint8Array) => {
+  return Array.from(uint8Array, (byte) =>
+    byte.toString(16).padStart(2, "0"),
+  ).join("");
+};
+
+const decoder = new TextDecoder("utf-8");
+
+export const uint8ArrayToString = (uint8Array) => {
+  return decoder.decode(uint8Array);
+};
+
+export const concatenateUint8Arrays = (arrays) => {
+  const totalLength = arrays.reduce((length, arr) => length + arr.length, 0);
+  const concatenatedArray = new Uint8Array(totalLength);
+
+  let offset = 0;
+
+  arrays.forEach((arr) => {
+    concatenatedArray.set(arr, offset);
+    offset += arr.length;
+  });
+
+  return concatenatedArray;
+};
+
+export const readInt32BE = (array, offset) => {
+  return (
+    (array[offset] << 24) |
+    (array[offset + 1] << 16) |
+    (array[offset + 2] << 8) |
+    array[offset + 3]
+  );
+};
+
+export const readInt32LE = (array, offset) => {
+  return (
+    array[offset] |
+    (array[offset + 1] << 8) |
+    (array[offset + 2] << 16) |
+    (array[offset + 3] << 24)
+  );
+};