@antv/l7-layers 2.17.3 → 2.17.4

package/lib/utils/polylineNormal.js

@@ -1,6 +1,7 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -8,53 +9,77 @@ exports.computeMiter = computeMiter;
 exports.computeNormal = computeNormal;
 exports.default = _default;
 exports.direction = direction;
+
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
 var _l7Utils = require("@antv/l7-utils");
+
 var _glMatrix = require("gl-matrix");
+
 function computeMiter(tangent, miter, lineA, lineB, halfThick) {
   _glMatrix.vec2.add(tangent, lineA, lineB);
+
   _glMatrix.vec2.normalize(tangent, tangent);
+
   miter = _glMatrix.vec2.fromValues(-tangent[1], tangent[0]);
+
   var tmp = _glMatrix.vec2.fromValues(-lineA[1], lineA[0]);
+
   return halfThick / _glMatrix.vec2.dot(miter, tmp);
 }
+
 function computeNormal(out, dir) {
   return _glMatrix.vec2.set(out, -dir[1], dir[0]);
 }
+
 function direction(out, a, b) {
   // const a1 = aProjectFlat([a[0], a[1]]) as [number, number];
   // const b1 = aProjectFlat([b[0], b[1]]) as [number, number];
   _glMatrix.vec2.sub(out, a, b);
+
   _glMatrix.vec2.normalize(out, out);
+
   return out;
 }
+
 function extrusions(positions, out, miters, point, normal, scale) {
   addNext(out, miters, normal, -scale);
   addNext(out, miters, normal, scale);
   positions.push(point[0], point[1], 0);
   positions.push(point[0], point[1], 0);
 }
+
 function addNext(out, miters, normal, length) {
   out.push(normal[0], normal[1], 0);
   miters.push(length);
 }
+
 function lineSegmentDistance(b1, a1) {
   var dx = a1[0] - b1[0];
   var dy = a1[1] - b1[1];
   return Math.sqrt(dx * dx + dy * dy);
 }
+
 function isPointEqual(a, b) {
   return a[0] === b[0] && a[1] === b[1];
 }
+
 function _default(points, closed, indexOffset) {
   var isDash = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+
   var lineA = _glMatrix.vec2.fromValues(0, 0);
+
   var lineB = _glMatrix.vec2.fromValues(0, 0);
+
   var tangent = _glMatrix.vec2.fromValues(0, 0);
+
   var miter = _glMatrix.vec2.create();
+
   var started = false;
   var lineNormal = null;
+
   var tmp = _glMatrix.vec2.create();
+
   var count = indexOffset || 0;
   var miterLimit = 4;
   var out = [];
@@ -62,46 +87,58 @@ function _default(points, closed, indexOffset) {
   var attrIndex = [];
   var miters = [];
   var attrDistance = [0, 0];
+
   if (closed) {
     points = points.slice();
     points.push(points[0]);
   }
+
   var total = points.length;
+
   for (var i = 1; i < total; i++) {
     var index = count;
+
     var last = _glMatrix.vec2.fromValues(points[i - 1][0], points[i - 1][1]);
+
     var cur = _glMatrix.vec2.fromValues(points[i][0], points[i][1]);
-    var next = i < points.length - 1 ? _glMatrix.vec2.fromValues(points[i + 1][0], points[i + 1][1]) : null;
-    // 如果当前点和前一点相同，跳过
+
+    var next = i < points.length - 1 ? _glMatrix.vec2.fromValues(points[i + 1][0], points[i + 1][1]) : null; // 如果当前点和前一点相同，跳过
+
     if (isPointEqual(last, cur)) {
       continue;
     }
+
     if (next) {
-      var nextIndex = i + 1;
-      // 找到不相同的下一点
+      var nextIndex = i + 1; // 找到不相同的下一点
+
       while (next && isPointEqual(cur, next)) {
         next = nextIndex < points.length - 1 ? _glMatrix.vec2.fromValues(points[++nextIndex][0], points[nextIndex][1]) : null;
       }
     }
+
     var d = 0;
     var flatCur = (0, _l7Utils.aProjectFlat)([cur[0], cur[1]]);
     var flatLast = (0, _l7Utils.aProjectFlat)([last[0], last[1]]);
+
     if (isDash) {
       var lineDistance = lineSegmentDistance(flatCur, flatLast);
       d = lineDistance + attrDistance[attrDistance.length - 1];
     }
+
     direction(lineA, flatCur, flatLast);
+
     if (!lineNormal) {
       lineNormal = _glMatrix.vec2.create();
       computeNormal(lineNormal, lineA);
     }
+
     if (!started) {
       started = true;
       extrusions(attrPos, out, miters, last, lineNormal, 1);
     }
-    attrIndex.push(index + 0, index + 2, index + 1);
 
-    // no miter, simple segment
+    attrIndex.push(index + 0, index + 2, index + 1); // no miter, simple segment
+
     if (!next) {
       // reset normal
       computeNormal(lineNormal, lineA);
@@ -110,18 +147,14 @@ function _default(points, closed, indexOffset) {
       attrIndex.push(index + 1, index + 2, index + 3);
       count += 2;
     } else {
-      var flatNext = (0, _l7Utils.aProjectFlat)([next[0], next[1]]);
-      // get unit dir of next line
-      direction(lineB, flatNext, flatCur);
+      var flatNext = (0, _l7Utils.aProjectFlat)([next[0], next[1]]); // get unit dir of next line
 
-      // stores tangent & miter
-      var miterLen = computeMiter(tangent, _glMatrix.vec2.fromValues(miter[0], miter[1]), lineA, lineB, 1);
+      direction(lineB, flatNext, flatCur); // stores tangent & miter
 
-      // get orientation
-      var flip = _glMatrix.vec2.dot(tangent, lineNormal) < 0 ? -1 : 1;
-      var bevel = Math.abs(miterLen) > miterLimit;
+      var miterLen = computeMiter(tangent, _glMatrix.vec2.fromValues(miter[0], miter[1]), lineA, lineB, 1); // get orientation
 
-      // 处理前后两条线段重合的情况，这种情况不需要使用任何接头（miter/bevel）。
+      var flip = _glMatrix.vec2.dot(tangent, lineNormal) < 0 ? -1 : 1;
+      var bevel = Math.abs(miterLen) > miterLimit; // 处理前后两条线段重合的情况，这种情况不需要使用任何接头（miter/bevel）。
       // 理论上这种情况下 miterLen = Infinity，本应通过 isFinite(miterLen) 判断，
       // 但是 AMap 投影变换后丢失精度，只能通过一个阈值（1000）判断。
 
@@ -130,58 +163,60 @@ function _default(points, closed, indexOffset) {
         attrIndex.push(index + 1, index + 2, index + 3);
         attrIndex.push(index + 2, index + 4, index + 3);
         computeNormal(tmp, lineB);
+
         _glMatrix.vec2.copy(lineNormal, tmp); // store normal for next round
 
+
         extrusions(attrPos, out, miters, cur, lineNormal, 1);
-        attrDistance.push(d, d, d, d);
+        attrDistance.push(d, d, d, d); // the miter is now the normal for our next join
 
-        // the miter is now the normal for our next join
         count += 4;
         continue;
       }
+
       if (bevel) {
-        miterLen = miterLimit;
+        miterLen = miterLimit; // next two points in our first segment
 
-        // next two points in our first segment
         extrusions(attrPos, out, miters, cur, lineNormal, 1);
-        attrIndex.push(index + 1, index + 2, index + 3);
+        attrIndex.push(index + 1, index + 2, index + 3); // now add the bevel triangle
 
-        // now add the bevel triangle
         attrIndex.push.apply(attrIndex, (0, _toConsumableArray2.default)(flip === 1 ? [index + 2, index + 4, index + 5] : [index + 4, index + 5, index + 3]));
         computeNormal(tmp, lineB);
+
         _glMatrix.vec2.copy(lineNormal, tmp); // store normal for next round
 
+
         extrusions(attrPos, out, miters, cur, lineNormal, 1);
-        attrDistance.push(d, d, d, d);
+        attrDistance.push(d, d, d, d); // the miter is now the normal for our next join
 
-        // the miter is now the normal for our next join
         count += 4;
       } else {
         // next two points in our first segment
         extrusions(attrPos, out, miters, cur, lineNormal, 1);
-        attrIndex.push(index + 1, index + 2, index + 3);
+        attrIndex.push(index + 1, index + 2, index + 3); // now add the miter triangles
 
-        // now add the miter triangles
         addNext(out, miters, lineNormal, miterLen * -flip);
         attrPos.push(cur[0], cur[1], 0);
         attrIndex.push(index + 2, index + 4, index + 3);
         attrIndex.push(index + 4, index + 5, index + 6);
         computeNormal(tmp, lineB);
+
         _glMatrix.vec2.copy(lineNormal, tmp); // store normal for next round
 
+
         extrusions(attrPos, out, miters, cur, lineNormal, 1);
-        attrDistance.push(d, d, d, d, d);
+        attrDistance.push(d, d, d, d, d); // the miter is now the normal for our next join
 
-        // the miter is now the normal for our next join
         count += 5;
       }
     }
   }
+
   var pickData = [];
+
   for (var _i = 0; _i < miters.length; _i++) {
     var totalDistance = attrDistance[attrDistance.length - 1];
-    pickData.push(attrPos[_i * 3], attrPos[_i * 3 + 1], attrPos[_i * 3 + 2], attrDistance[_i],
-    // dash
+    pickData.push(attrPos[_i * 3], attrPos[_i * 3 + 1], attrPos[_i * 3 + 2], attrDistance[_i], // dash
     miters[_i], totalDistance // dash
     );
   }
@@ -190,6 +225,6 @@ function _default(points, closed, indexOffset) {
     normals: out,
     attrIndex: attrIndex,
     attrPos: pickData // [x,y,z, distance, miter ,t0tal ]
+
   };
-}
-// [x,y,z, distance, miter ]
+} // [x,y,z, distance, miter ]

package/lib/utils/simpleLine.js

@@ -1,22 +1,33 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
 exports.direction = direction;
+
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
 var _l7Utils = require("@antv/l7-utils");
+
 var _glMatrix = require("gl-matrix");
+
 var lineA = _glMatrix.vec2.create();
+
 function direction(out, a, b) {
   _glMatrix.vec2.sub(out, a, b);
+
   _glMatrix.vec2.normalize(out, out);
+
   return out;
 }
+
 var ExtrudePolyline = /*#__PURE__*/function () {
   function ExtrudePolyline() {
     (0, _classCallCheck2.default)(this, ExtrudePolyline);
@@ -30,26 +41,32 @@ var ExtrudePolyline = /*#__PURE__*/function () {
       indexes: []
     };
   }
+
   (0, _createClass2.default)(ExtrudePolyline, [{
     key: "simpleExtrude",
     value: function simpleExtrude(points) {
       var complex = this.complex;
+
       if (points.length <= 1) {
         return complex;
       }
+
       this.started = false;
       this.totalDistance = 0;
       var total = points.length;
       var count = complex.startIndex;
+
       for (var i = 1; i < total; i++) {
         var last = points[i - 1];
         var cur = points[i];
         var amt = this.simpleSegment(complex, count, last, cur);
         count += amt;
       }
+
       for (var _i = 0; _i < complex.positions.length / 6; _i++) {
         complex.positions[_i * 6 + 5] = this.totalDistance;
       }
+
       return complex;
     }
   }, {
@@ -63,10 +80,12 @@ var ExtrudePolyline = /*#__PURE__*/function () {
       direction(lineA, flatCur, flatLast);
       var segmentDistance = this.lineSegmentDistance(flatCur, flatLast);
       this.totalDistance += segmentDistance;
+
       if (!this.started) {
         this.started = true;
         this.extrusions(positions, last, this.totalDistance - segmentDistance);
       }
+
       this.extrusions(positions, cur, this.totalDistance);
       indices.push(index + 0, index + 1, index + 2);
       indices.push(index + 2, index + 1, index + 3);
@@ -75,8 +94,7 @@ var ExtrudePolyline = /*#__PURE__*/function () {
     }
   }, {
     key: "extrusions",
-    value: function extrusions(positions, point,
-    // 顶点
+    value: function extrusions(positions, point, // 顶点
     distanceRadio) {
       positions.push(point[0], point[1], point[2] | 0, distanceRadio, 0, point[2] | 0);
       this.complex.indexes.push(this.currentIndex);
@@ -94,4 +112,5 @@ var ExtrudePolyline = /*#__PURE__*/function () {
   }]);
   return ExtrudePolyline;
 }();
+
 exports.default = ExtrudePolyline;

package/lib/utils/stencil.js

@@ -5,7 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getStencil = getStencil;
 exports.getStencilMask = getStencilMask;
+
 var _l7Core = require("@antv/l7-core");
+
 // 掩膜配置
 function getStencil(mask, maskInside) {
   return {
@@ -19,6 +21,7 @@ function getStencil(mask, maskInside) {
     }
   };
 }
+
 // 模版配置
 function getStencilMask(option) {
   if (option.maskOperation === _l7Core.MaskOperation.OR) {
@@ -37,6 +40,7 @@ function getStencilMask(option) {
       }
     };
   }
+
   return {
     enable: true,
     mask: 0xff,

package/lib/utils/symbol-layout.js

@@ -5,9 +5,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getGlyphQuads = getGlyphQuads;
 exports.shapeText = shapeText;
+
 function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
 /**
  * 返回文本相对锚点位置
  * @param {string} anchor 锚点位置
@@ -16,64 +20,76 @@ function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len
 function getAnchorAlignment(anchor) {
   var horizontalAlign = 0.5;
   var verticalAlign = 0.5;
+
   switch (anchor) {
     case 'right':
     case 'top-right':
     case 'bottom-right':
       horizontalAlign = 1;
       break;
+
     case 'left':
     case 'top-left':
     case 'bottom-left':
       horizontalAlign = 0;
       break;
+
     default:
       horizontalAlign = 0.5;
   }
+
   switch (anchor) {
     case 'bottom':
     case 'bottom-right':
     case 'bottom-left':
       verticalAlign = 1;
       break;
+
     case 'top':
     case 'top-right':
     case 'top-left':
       verticalAlign = 0;
       break;
+
     default:
       verticalAlign = 0.5;
   }
+
   return {
     horizontalAlign: horizontalAlign,
     verticalAlign: verticalAlign
   };
-}
+} // justify right = 1, left = 0, center = 0.5
+
 
-// justify right = 1, left = 0, center = 0.5
 function justifyLine(positionedGlyphs, glyphMap, start, end, justify) {
   if (!justify) {
     return;
   }
+
   var lastPositionedGlyph = positionedGlyphs[end];
   var glyph = lastPositionedGlyph.glyph;
+
   if (glyph) {
     var lastAdvance = glyphMap[glyph].advance * lastPositionedGlyph.scale;
     var lineIndent = (positionedGlyphs[end].x + lastAdvance) * justify;
+
     for (var j = start; j <= end; j++) {
       positionedGlyphs[j].x -= lineIndent;
     }
   }
-}
-
-// justify right=1 left=0 center=0.5
+} // justify right=1 left=0 center=0.5
 // horizontalAlign right=1 left=0 center=0.5
 // verticalAlign right=1 left=0 center=0.5
+
+
 function align(positionedGlyphs, justify, horizontalAlign, verticalAlign, maxLineLength, lineHeight, lineCount) {
   var shiftX = (justify - horizontalAlign) * maxLineLength;
   var shiftY = (-verticalAlign * lineCount + 0.5) * lineHeight;
+
   var _iterator = _createForOfIteratorHelper(positionedGlyphs),
-    _step;
+      _step;
+
   try {
     for (_iterator.s(); !(_step = _iterator.n()).done;) {
       var glyphs = _step.value;
@@ -86,6 +102,7 @@ function align(positionedGlyphs, justify, horizontalAlign, verticalAlign, maxLin
     _iterator.f();
   }
 }
+
 function shapeLines(shaping, glyphMap, lines, lineHeight, textAnchor, textJustify, spacing) {
   // buffer 为 4
   var yOffset = -8;
@@ -99,6 +116,7 @@ function shapeLines(shaping, glyphMap, lines, lineHeight, textAnchor, textJustif
     line.split('').forEach(function (char) {
       var glyph = glyphMap[char];
       var baselineOffset = 0;
+
       if (glyph) {
         positionedGlyphs.push({
           glyph: char,
@@ -111,29 +129,31 @@ function shapeLines(shaping, glyphMap, lines, lineHeight, textAnchor, textJustif
         });
         x += glyph.advance + spacing;
       }
-    });
+    }); // 左右对齐
 
-    // 左右对齐
     if (positionedGlyphs.length !== lineStartIndex) {
       var lineLength = x - spacing;
       maxLineLength = Math.max(lineLength, maxLineLength);
       justifyLine(positionedGlyphs, glyphMap, lineStartIndex, positionedGlyphs.length - 1, justify);
     }
+
     x = 0;
     y -= lineHeight + 5;
   });
+
   var _getAnchorAlignment = getAnchorAlignment(textAnchor),
-    horizontalAlign = _getAnchorAlignment.horizontalAlign,
-    verticalAlign = _getAnchorAlignment.verticalAlign;
-  align(positionedGlyphs, justify, horizontalAlign, verticalAlign, maxLineLength, lineHeight, lines.length);
+      horizontalAlign = _getAnchorAlignment.horizontalAlign,
+      verticalAlign = _getAnchorAlignment.verticalAlign;
+
+  align(positionedGlyphs, justify, horizontalAlign, verticalAlign, maxLineLength, lineHeight, lines.length); // 计算包围盒
 
-  // 计算包围盒
   var height = y - yOffset;
   shaping.top += -verticalAlign * height;
   shaping.bottom = shaping.top - height;
   shaping.left += -horizontalAlign * maxLineLength;
   shaping.right = shaping.left + maxLineLength;
 }
+
 function shapeIconFont(shaping, glyphMap, iconfonts, lineHeight, textAnchor, textJustify, spacing) {
   // buffer 为 4
   var yOffset = -8;
@@ -146,10 +166,12 @@ function shapeIconFont(shaping, glyphMap, iconfonts, lineHeight, textAnchor, tex
   iconfonts.forEach(function (iconfont) {
     var glyph = glyphMap[iconfont];
     var baselineOffset = 0;
+
     if (glyph) {
       positionedGlyphs.push({
         glyph: iconfont,
         // x,
+
         /**
          * iconfont
          * 在计算大小的时候计算的是 unicode 字符 如 &#xe6d4;
@@ -163,30 +185,31 @@ function shapeIconFont(shaping, glyphMap, iconfonts, lineHeight, textAnchor, tex
         metrics: glyph
       });
       x += glyph.advance + spacing;
-    }
+    } // 左右对齐
+
 
-    // 左右对齐
     if (positionedGlyphs.length !== lineStartIndex) {
       var lineLength = x - spacing;
       maxLineLength = Math.max(lineLength, maxLineLength);
       justifyLine(positionedGlyphs, glyphMap, lineStartIndex, positionedGlyphs.length - 1, justify);
     }
+
     x = 0;
     y -= lineHeight + 5;
   });
+
   var _getAnchorAlignment2 = getAnchorAlignment(textAnchor),
-    horizontalAlign = _getAnchorAlignment2.horizontalAlign,
-    verticalAlign = _getAnchorAlignment2.verticalAlign;
-  align(positionedGlyphs, justify, horizontalAlign, verticalAlign, maxLineLength, lineHeight, iconfonts.length);
+      horizontalAlign = _getAnchorAlignment2.horizontalAlign,
+      verticalAlign = _getAnchorAlignment2.verticalAlign;
+
+  align(positionedGlyphs, justify, horizontalAlign, verticalAlign, maxLineLength, lineHeight, iconfonts.length); // 计算包围盒
 
-  // 计算包围盒
   var height = y - yOffset;
   shaping.top += -verticalAlign * height;
   shaping.bottom = shaping.top - height;
   shaping.left += -horizontalAlign * maxLineLength;
   shaping.right = shaping.left + maxLineLength;
 }
-
 /**
  * 计算文本中每个独立字符相对锚点的位置
  *
@@ -200,6 +223,8 @@ function shapeIconFont(shaping, glyphMap, iconfonts, lineHeight, textAnchor, tex
  * @param {[boolean]} isIconFont 是否是 iconfont
  * @return {boolean|shaping} 每个字符相对于锚点的位置
  */
+
+
 function shapeText(text, glyphs, lineHeight, textAnchor, textJustify, spacing) {
   var translate = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : [0, 0];
   var isIconFont = arguments.length > 7 ? arguments[7] : undefined;
@@ -216,25 +241,29 @@ function shapeText(text, glyphs, lineHeight, textAnchor, textJustify, spacing) {
     text: text
   };
   isIconFont ? shapeIconFont(shaping, glyphs, lines, lineHeight, textAnchor, textJustify, spacing) : shapeLines(shaping, glyphs, lines, lineHeight, textAnchor, textJustify, spacing);
+
   if (!positionedGlyphs.length) {
     return false;
   }
+
   return shaping;
 }
+
 function getGlyphQuads(shaping) {
   var textOffset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [0, 0];
   var alongLine = arguments.length > 2 ? arguments[2] : undefined;
   var _shaping$positionedGl = shaping.positionedGlyphs,
-    positionedGlyphs = _shaping$positionedGl === void 0 ? [] : _shaping$positionedGl;
+      positionedGlyphs = _shaping$positionedGl === void 0 ? [] : _shaping$positionedGl;
   var quads = [];
+
   var _iterator2 = _createForOfIteratorHelper(positionedGlyphs),
-    _step2;
+      _step2;
+
   try {
     for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
       var positionedGlyph = _step2.value;
-      var rect = positionedGlyph.metrics;
+      var rect = positionedGlyph.metrics; // The rects have an addditional buffer that is not included in their size.
 
-      // The rects have an addditional buffer that is not included in their size.
       var rectBuffer = 4;
       var halfAdvance = rect.advance * positionedGlyph.scale / 2;
       var glyphOffset = alongLine ? [positionedGlyph.x + halfAdvance, positionedGlyph.y] : [0, 0];
@@ -258,9 +287,7 @@ function getGlyphQuads(shaping) {
       var br = {
         x: x2,
         y: y2
-      };
-
-      // TODO：处理字符旋转的情况
+      }; // TODO：处理字符旋转的情况
 
       quads.push({
         tl: tl,
@@ -276,5 +303,6 @@ function getGlyphQuads(shaping) {
   } finally {
     _iterator2.f();
   }
+
   return quads;
 }