fix: 微信登录补充保存username和role

node_modules/@jimp/core/es/utils/image-bitmap.js

@@ -0,0 +1,263 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseBitmap = parseBitmap;
+exports.getBuffer = getBuffer;
+exports.getBufferAsync = getBufferAsync;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _fileType = _interopRequireDefault(require("file-type"));
+
+var _exifParser = _interopRequireDefault(require("exif-parser"));
+
+var _utils = require("@jimp/utils");
+
+var constants = _interopRequireWildcard(require("../constants"));
+
+var MIME = _interopRequireWildcard(require("./mime"));
+
+var _promisify = _interopRequireDefault(require("./promisify"));
+
+function getMIMEFromBuffer(buffer, path) {
+  var fileTypeFromBuffer = (0, _fileType["default"])(buffer);
+
+  if (fileTypeFromBuffer) {
+    // If fileType returns something for buffer, then return the mime given
+    return fileTypeFromBuffer.mime;
+  }
+
+  if (path) {
+    // If a path is supplied, and fileType yields no results, then retry with MIME
+    // Path can be either a file path or a url
+    return MIME.getType(path);
+  }
+
+  return null;
+}
+/*
+ * Obtains image orientation from EXIF metadata.
+ *
+ * @param img {Jimp} a Jimp image object
+ * @returns {number} a number 1-8 representing EXIF orientation,
+ *          in particular 1 if orientation tag is missing
+ */
+
+
+function getExifOrientation(img) {
+  return img._exif && img._exif.tags && img._exif.tags.Orientation || 1;
+}
+/**
+ * Returns a function which translates EXIF-rotated coordinates into
+ * non-rotated ones.
+ *
+ * Transformation reference: http://sylvana.net/jpegcrop/exif_orientation.html.
+ *
+ * @param img {Jimp} a Jimp image object
+ * @returns {function} transformation function for transformBitmap().
+ */
+
+
+function getExifOrientationTransformation(img) {
+  var w = img.getWidth();
+  var h = img.getHeight();
+
+  switch (getExifOrientation(img)) {
+    case 1:
+      // Horizontal (normal)
+      // does not need to be supported here
+      return null;
+
+    case 2:
+      // Mirror horizontal
+      return function (x, y) {
+        return [w - x - 1, y];
+      };
+
+    case 3:
+      // Rotate 180
+      return function (x, y) {
+        return [w - x - 1, h - y - 1];
+      };
+
+    case 4:
+      // Mirror vertical
+      return function (x, y) {
+        return [x, h - y - 1];
+      };
+
+    case 5:
+      // Mirror horizontal and rotate 270 CW
+      return function (x, y) {
+        return [y, x];
+      };
+
+    case 6:
+      // Rotate 90 CW
+      return function (x, y) {
+        return [y, h - x - 1];
+      };
+
+    case 7:
+      // Mirror horizontal and rotate 90 CW
+      return function (x, y) {
+        return [w - y - 1, h - x - 1];
+      };
+
+    case 8:
+      // Rotate 270 CW
+      return function (x, y) {
+        return [w - y - 1, x];
+      };
+
+    default:
+      return null;
+  }
+}
+/*
+ * Transforms bitmap in place (moves pixels around) according to given
+ * transformation function.
+ *
+ * @param img {Jimp} a Jimp image object, which bitmap is supposed to
+ *        be transformed
+ * @param width {number} bitmap width after the transformation
+ * @param height {number} bitmap height after the transformation
+ * @param transformation {function} transformation function which defines pixel
+ *        mapping between new and source bitmap. It takes a pair of coordinates
+ *        in the target, and returns a respective pair of coordinates in
+ *        the source bitmap, i.e. has following form:
+ *        `function(new_x, new_y) { return [src_x, src_y] }`.
+ */
+
+
+function transformBitmap(img, width, height, transformation) {
+  // Underscore-prefixed values are related to the source bitmap
+  // Their counterparts with no prefix are related to the target bitmap
+  var _data = img.bitmap.data;
+  var _width = img.bitmap.width;
+  var data = Buffer.alloc(_data.length);
+
+  for (var x = 0; x < width; x++) {
+    for (var y = 0; y < height; y++) {
+      var _transformation = transformation(x, y),
+          _transformation2 = (0, _slicedToArray2["default"])(_transformation, 2),
+          _x = _transformation2[0],
+          _y = _transformation2[1];
+
+      var idx = width * y + x << 2;
+
+      var _idx = _width * _y + _x << 2;
+
+      var pixel = _data.readUInt32BE(_idx);
+
+      data.writeUInt32BE(pixel, idx);
+    }
+  }
+
+  img.bitmap.data = data;
+  img.bitmap.width = width;
+  img.bitmap.height = height;
+}
+/*
+ * Automagically rotates an image based on its EXIF data (if present).
+ * @param img {Jimp} a Jimp image object
+ */
+
+
+function exifRotate(img) {
+  if (getExifOrientation(img) < 2) return;
+  var transformation = getExifOrientationTransformation(img);
+  var swapDimensions = getExifOrientation(img) > 4;
+  var newWidth = swapDimensions ? img.bitmap.height : img.bitmap.width;
+  var newHeight = swapDimensions ? img.bitmap.width : img.bitmap.height;
+  transformBitmap(img, newWidth, newHeight, transformation);
+} // parses a bitmap from the constructor to the JIMP bitmap property
+
+
+function parseBitmap(data, path, cb) {
+  var mime = getMIMEFromBuffer(data, path);
+
+  if (typeof mime !== 'string') {
+    return cb(new Error('Could not find MIME for Buffer <' + path + '>'));
+  }
+
+  this._originalMime = mime.toLowerCase();
+
+  try {
+    var _mime = this.getMIME();
+
+    if (this.constructor.decoders[_mime]) {
+      this.bitmap = this.constructor.decoders[_mime](data);
+    } else {
+      return _utils.throwError.call(this, 'Unsupported MIME type: ' + _mime, cb);
+    }
+  } catch (error) {
+    return cb.call(this, error, this);
+  }
+
+  try {
+    this._exif = _exifParser["default"].create(data).parse();
+    exifRotate(this); // EXIF data
+  } catch (error) {
+    /* meh */
+  }
+
+  cb.call(this, null, this);
+  return this;
+}
+
+function compositeBitmapOverBackground(Jimp, image) {
+  return new Jimp(image.bitmap.width, image.bitmap.height, image._background).composite(image, 0, 0).bitmap;
+}
+/**
+ * Converts the image to a buffer
+ * @param {string} mime the mime type of the image buffer to be created
+ * @param {function(Error, Jimp)} cb a Node-style function to call with the buffer as the second argument
+ * @returns {Jimp} this for chaining of methods
+ */
+
+
+function getBuffer(mime, cb) {
+  if (mime === constants.AUTO) {
+    // allow auto MIME detection
+    mime = this.getMIME();
+  }
+
+  if (typeof mime !== 'string') {
+    return _utils.throwError.call(this, 'mime must be a string', cb);
+  }
+
+  if (typeof cb !== 'function') {
+    return _utils.throwError.call(this, 'cb must be a function', cb);
+  }
+
+  mime = mime.toLowerCase();
+
+  if (this._rgba && this.constructor.hasAlpha[mime]) {
+    this.bitmap.data = Buffer.from(this.bitmap.data);
+  } else {
+    // when format doesn't support alpha
+    // composite onto a new image so that the background shows through alpha channels
+    this.bitmap.data = compositeBitmapOverBackground(this.constructor, this).data;
+  }
+
+  if (this.constructor.encoders[mime]) {
+    var buffer = this.constructor.encoders[mime](this);
+    cb.call(this, null, buffer);
+  } else {
+    cb.call(this, 'Unsupported MIME type: ' + mime);
+  }
+
+  return this;
+}
+
+function getBufferAsync(mime) {
+  return (0, _promisify["default"])(getBuffer, this, mime);
+}
+//# sourceMappingURL=image-bitmap.js.map

node_modules/@jimp/core/es/utils/mime.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getExtension = exports.getType = exports.addType = void 0;
+var mimeTypes = {};
+
+var findType = function findType(extension) {
+  return Object.entries(mimeTypes).find(function (type) {
+    return type[1].includes(extension);
+  }) || [];
+};
+
+var addType = function addType(mime, extensions) {
+  mimeTypes[mime] = extensions;
+};
+/**
+ * Lookup a mime type based on extension
+ * @param {string} path path to find extension for
+ * @returns {string} mime found mime type
+ */
+
+
+exports.addType = addType;
+
+var getType = function getType(path) {
+  var pathParts = path.split('/').slice(-1);
+  var extension = pathParts[pathParts.length - 1].split('.').pop();
+  var type = findType(extension);
+  return type[0];
+};
+/**
+ * Return file extension associated with a mime type
+ * @param {string} type mime type to look up
+ * @returns {string} extension file extension
+ */
+
+
+exports.getType = getType;
+
+var getExtension = function getExtension(type) {
+  return (mimeTypes[type.toLowerCase()] || [])[0];
+};
+
+exports.getExtension = getExtension;
+//# sourceMappingURL=mime.js.map

node_modules/@jimp/core/es/utils/mime.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/mime.js"],"names":["mimeTypes","findType","extension","Object","entries","find","type","includes","addType","mime","extensions","getType","path","pathParts","split","slice","length","pop","getExtension","toLowerCase"],"mappings":";;;;;;AAAA,IAAMA,SAAS,GAAG,EAAlB;;AAEA,IAAMC,QAAQ,GAAG,SAAXA,QAAW,CAAAC,SAAS;AAAA,SACxBC,MAAM,CAACC,OAAP,CAAeJ,SAAf,EAA0BK,IAA1B,CAA+B,UAAAC,IAAI;AAAA,WAAIA,IAAI,CAAC,CAAD,CAAJ,CAAQC,QAAR,CAAiBL,SAAjB,CAAJ;AAAA,GAAnC,KAAuE,EAD/C;AAAA,CAA1B;;AAGO,IAAMM,OAAO,GAAG,SAAVA,OAAU,CAACC,IAAD,EAAOC,UAAP,EAAsB;AAC3CV,EAAAA,SAAS,CAACS,IAAD,CAAT,GAAkBC,UAAlB;AACD,CAFM;AAIP;;;;;;;;;AAKO,IAAMC,OAAO,GAAG,SAAVA,OAAU,CAAAC,IAAI,EAAI;AAC7B,MAAMC,SAAS,GAAGD,IAAI,CAACE,KAAL,CAAW,GAAX,EAAgBC,KAAhB,CAAsB,CAAC,CAAvB,CAAlB;AACA,MAAMb,SAAS,GAAGW,SAAS,CAACA,SAAS,CAACG,MAAV,GAAmB,CAApB,CAAT,CAAgCF,KAAhC,CAAsC,GAAtC,EAA2CG,GAA3C,EAAlB;AACA,MAAMX,IAAI,GAAGL,QAAQ,CAACC,SAAD,CAArB;AAEA,SAAOI,IAAI,CAAC,CAAD,CAAX;AACD,CANM;AAQP;;;;;;;;;AAKO,IAAMY,YAAY,GAAG,SAAfA,YAAe,CAAAZ,IAAI;AAAA,SAAI,CAACN,SAAS,CAACM,IAAI,CAACa,WAAL,EAAD,CAAT,IAAiC,EAAlC,EAAsC,CAAtC,CAAJ;AAAA,CAAzB","sourcesContent":["const mimeTypes = {};\n\nconst findType = extension =>\n  Object.entries(mimeTypes).find(type => type[1].includes(extension)) || [];\n\nexport const addType = (mime, extensions) => {\n  mimeTypes[mime] = extensions;\n};\n\n/**\n * Lookup a mime type based on extension\n * @param {string} path path to find extension for\n * @returns {string} mime found mime type\n */\nexport const getType = path => {\n  const pathParts = path.split('/').slice(-1);\n  const extension = pathParts[pathParts.length - 1].split('.').pop();\n  const type = findType(extension);\n\n  return type[0];\n};\n\n/**\n * Return file extension associated with a mime type\n * @param {string} type mime type to look up\n * @returns {string} extension file extension\n */\nexport const getExtension = type => (mimeTypes[type.toLowerCase()] || [])[0];\n"],"file":"mime.js"}

node_modules/@jimp/core/es/utils/promisify.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var promisify = function promisify(fun, ctx) {
+  for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+    args[_key - 2] = arguments[_key];
+  }
+
+  return new Promise(function (resolve, reject) {
+    args.push(function (err, data) {
+      if (err) {
+        reject(err);
+      }
+
+      resolve(data);
+    });
+    fun.bind(ctx).apply(void 0, args);
+  });
+};
+
+var _default = promisify;
+exports["default"] = _default;
+//# sourceMappingURL=promisify.js.map

node_modules/@jimp/core/es/utils/promisify.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/promisify.js"],"names":["promisify","fun","ctx","args","Promise","resolve","reject","push","err","data","bind"],"mappings":";;;;;;;AAAA,IAAMA,SAAS,GAAG,SAAZA,SAAY,CAACC,GAAD,EAAMC,GAAN;AAAA,oCAAcC,IAAd;AAAcA,IAAAA,IAAd;AAAA;;AAAA,SAChB,IAAIC,OAAJ,CAAY,UAACC,OAAD,EAAUC,MAAV,EAAqB;AAC/BH,IAAAA,IAAI,CAACI,IAAL,CAAU,UAACC,GAAD,EAAMC,IAAN,EAAe;AACvB,UAAID,GAAJ,EAAS;AACPF,QAAAA,MAAM,CAACE,GAAD,CAAN;AACD;;AAEDH,MAAAA,OAAO,CAACI,IAAD,CAAP;AACD,KAND;AAOAR,IAAAA,GAAG,CAACS,IAAJ,CAASR,GAAT,gBAAiBC,IAAjB;AACD,GATD,CADgB;AAAA,CAAlB;;eAYeH,S","sourcesContent":["const promisify = (fun, ctx, ...args) =>\n  new Promise((resolve, reject) => {\n    args.push((err, data) => {\n      if (err) {\n        reject(err);\n      }\n\n      resolve(data);\n    });\n    fun.bind(ctx)(...args);\n  });\n\nexport default promisify;\n"],"file":"promisify.js"}