From ddc3ad723443e3282cb7e1f4f44db80554392734 Mon Sep 17 00:00:00 2001
From: Mikhail Pozdnyakov <mikhail.pozdnyakov@mapbox.com>
Date: Thu, 15 Aug 2019 19:05:43 +0300
Subject: [PATCH 1/8] Enable `text-offset` with variable label placement

This PR allows using of `text-offset` together with `text-variable-anchor`, if `text-radial-offset` is not provided.
Assuming we got `text-offset` [x, y] the offset is calculated based on the `text-variable-anchor` values as following:

"left": [-x, 0]
"right": [x, 0]
"top": [0, -y]
"bottom": [0, y]
"top-left": [-x, -y]
"top-right": [x, -y]
"bottom-left": [-x, y]
"bottom-right": [x, y]

We allow only positive `text-offset` values for simplicity.
---
 src/data/array_types.js                       |  34 ++---
 src/data/bucket/symbol_attributes.js          |   2 +-
 src/symbol/placement.js                       |  13 +-
 src/symbol/symbol_layout.js                   | 123 ++++++++++++------
 .../expected.png                              | Bin 0 -> 608 bytes
 .../style.json                                | 121 +++++++++++++++++
 .../expected.png                              | Bin 0 -> 1107 bytes
 .../style.json                                | 121 +++++++++++++++++
 .../expected.png                              | Bin 0 -> 2339 bytes
 .../style.json                                | 121 +++++++++++++++++
 10 files changed, 474 insertions(+), 61 deletions(-)
 create mode 100644 test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset-negative/expected.png
 create mode 100644 test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset-negative/style.json
 create mode 100644 test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset-zero/expected.png
 create mode 100644 test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset-zero/style.json
 create mode 100644 test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset/expected.png
 create mode 100644 test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset/style.json

diff --git a/src/data/array_types.js b/src/data/array_types.js
index a63a0bd5575..0c93b343c23 100644
--- a/src/data/array_types.js
+++ b/src/data/array_types.js
@@ -478,11 +478,11 @@ register('StructArrayLayout2i2ui3ul3ui2f3ub1ul44', StructArrayLayout2i2ui3ul3ui2
  * [0]: Int16[6]
  * [12]: Uint16[11]
  * [36]: Uint32[1]
- * [40]: Float32[2]
+ * [40]: Float32[3]
  *
  * @private
  */
-class StructArrayLayout6i11ui1ul2f48 extends StructArray {
+class StructArrayLayout6i11ui1ul3f52 extends StructArray {
     uint8: Uint8Array;
     int16: Int16Array;
     uint16: Uint16Array;
@@ -497,15 +497,15 @@ class StructArrayLayout6i11ui1ul2f48 extends StructArray {
         this.float32 = new Float32Array(this.arrayBuffer);
     }
 
-    emplaceBack(v0: number, v1: number, v2: number, v3: number, v4: number, v5: number, v6: number, v7: number, v8: number, v9: number, v10: number, v11: number, v12: number, v13: number, v14: number, v15: number, v16: number, v17: number, v18: number, v19: number) {
+    emplaceBack(v0: number, v1: number, v2: number, v3: number, v4: number, v5: number, v6: number, v7: number, v8: number, v9: number, v10: number, v11: number, v12: number, v13: number, v14: number, v15: number, v16: number, v17: number, v18: number, v19: number, v20: number) {
         const i = this.length;
         this.resize(i + 1);
-        return this.emplace(i, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19);
+        return this.emplace(i, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20);
     }
 
-    emplace(i: number, v0: number, v1: number, v2: number, v3: number, v4: number, v5: number, v6: number, v7: number, v8: number, v9: number, v10: number, v11: number, v12: number, v13: number, v14: number, v15: number, v16: number, v17: number, v18: number, v19: number) {
-        const o2 = i * 24;
-        const o4 = i * 12;
+    emplace(i: number, v0: number, v1: number, v2: number, v3: number, v4: number, v5: number, v6: number, v7: number, v8: number, v9: number, v10: number, v11: number, v12: number, v13: number, v14: number, v15: number, v16: number, v17: number, v18: number, v19: number, v20: number) {
+        const o2 = i * 26;
+        const o4 = i * 13;
         this.int16[o2 + 0] = v0;
         this.int16[o2 + 1] = v1;
         this.int16[o2 + 2] = v2;
@@ -526,12 +526,13 @@ class StructArrayLayout6i11ui1ul2f48 extends StructArray {
         this.uint32[o4 + 9] = v17;
         this.float32[o4 + 10] = v18;
         this.float32[o4 + 11] = v19;
+        this.float32[o4 + 12] = v20;
         return i;
     }
 }
 
-StructArrayLayout6i11ui1ul2f48.prototype.bytesPerElement = 48;
-register('StructArrayLayout6i11ui1ul2f48', StructArrayLayout6i11ui1ul2f48);
+StructArrayLayout6i11ui1ul3f52.prototype.bytesPerElement = 52;
+register('StructArrayLayout6i11ui1ul3f52', StructArrayLayout6i11ui1ul3f52);
 
 /**
  * Implementation of the StructArray layout:
@@ -948,7 +949,8 @@ class SymbolInstanceStruct extends Struct {
     numIconVertices: number;
     crossTileID: number;
     textBoxScale: number;
-    radialTextOffset: number;
+    radialTextOffset0: number;
+    radialTextOffset1: number;
     get anchorX() { return this._structArray.int16[this._pos2 + 0]; }
     set anchorX(x: number) { this._structArray.int16[this._pos2 + 0] = x; }
     get anchorY() { return this._structArray.int16[this._pos2 + 1]; }
@@ -987,18 +989,20 @@ class SymbolInstanceStruct extends Struct {
     set crossTileID(x: number) { this._structArray.uint32[this._pos4 + 9] = x; }
     get textBoxScale() { return this._structArray.float32[this._pos4 + 10]; }
     set textBoxScale(x: number) { this._structArray.float32[this._pos4 + 10] = x; }
-    get radialTextOffset() { return this._structArray.float32[this._pos4 + 11]; }
-    set radialTextOffset(x: number) { this._structArray.float32[this._pos4 + 11] = x; }
+    get radialTextOffset0() { return this._structArray.float32[this._pos4 + 11]; }
+    set radialTextOffset0(x: number) { this._structArray.float32[this._pos4 + 11] = x; }
+    get radialTextOffset1() { return this._structArray.float32[this._pos4 + 12]; }
+    set radialTextOffset1(x: number) { this._structArray.float32[this._pos4 + 12] = x; }
 }
 
-SymbolInstanceStruct.prototype.size = 48;
+SymbolInstanceStruct.prototype.size = 52;
 
 export type SymbolInstance = SymbolInstanceStruct;
 
 /**
  * @private
  */
-export class SymbolInstanceArray extends StructArrayLayout6i11ui1ul2f48 {
+export class SymbolInstanceArray extends StructArrayLayout6i11ui1ul3f52 {
     /**
      * Return the SymbolInstanceStruct at the given location in the array.
      * @param {number} index The index of the element.
@@ -1121,7 +1125,7 @@ export {
     StructArrayLayout2i2i2i12,
     StructArrayLayout2ub2f12,
     StructArrayLayout2i2ui3ul3ui2f3ub1ul44,
-    StructArrayLayout6i11ui1ul2f48,
+    StructArrayLayout6i11ui1ul3f52,
     StructArrayLayout1f4,
     StructArrayLayout3i6,
     StructArrayLayout1ul2ui8,
diff --git a/src/data/bucket/symbol_attributes.js b/src/data/bucket/symbol_attributes.js
index d93a011e0a0..420a7c60bc6 100644
--- a/src/data/bucket/symbol_attributes.js
+++ b/src/data/bucket/symbol_attributes.js
@@ -96,7 +96,7 @@ export const symbolInstance = createLayout([
     {type: 'Uint16', name: 'numIconVertices'},
     {type: 'Uint32', name: 'crossTileID'},
     {type: 'Float32', name: 'textBoxScale'},
-    {type: 'Float32', name: 'radialTextOffset'}
+    {type: 'Float32', components: 2, name: 'radialTextOffset'}
 ]);
 
 export const glyphOffset = createLayout([
diff --git a/src/symbol/placement.js b/src/symbol/placement.js
index cf302e4eb94..3dded19cb5e 100644
--- a/src/symbol/placement.js
+++ b/src/symbol/placement.js
@@ -117,7 +117,7 @@ class CollisionGroups {
     }
 }
 
-function calculateVariableLayoutOffset(anchor: TextAnchor, width: number, height: number, radialOffset: number, textBoxScale: number): Point {
+function calculateVariableLayoutOffset(anchor: TextAnchor, width: number, height: number, radialOffset: [number, number], textBoxScale: number): Point {
     const {horizontalAlign, verticalAlign} = getAnchorAlignment(anchor);
     const shiftX = -(horizontalAlign - 0.5) * width;
     const shiftY = -(verticalAlign - 0.5) * height;
@@ -149,7 +149,7 @@ function shiftVariableCollisionBox(collisionBox: SingleCollisionBox,
 }
 
 export type VariableOffset = {
-    radialOffset: number,
+    radialOffset: [number, number],
     width: number,
     height: number,
     anchor: TextAnchor,
@@ -235,11 +235,12 @@ export class Placement {
     }
 
     attemptAnchorPlacement(anchor: TextAnchor, textBox: SingleCollisionBox, width: number, height: number,
-                           radialTextOffset: number, textBoxScale: number, rotateWithMap: boolean,
+                           textBoxScale: number, rotateWithMap: boolean,
                            pitchWithMap: boolean, textPixelRatio: number, posMatrix: mat4, collisionGroup: CollisionGroup,
                            textAllowOverlap: boolean, symbolInstance: SymbolInstance, bucket: SymbolBucket, orientation: number): ?{ box: Array<number>, offscreen: boolean }  {
 
-        const shift = calculateVariableLayoutOffset(anchor, width, height, radialTextOffset, textBoxScale);
+        const radialOffset = [symbolInstance.radialTextOffset0, symbolInstance.radialTextOffset1];
+        const shift = calculateVariableLayoutOffset(anchor, width, height, radialOffset, textBoxScale);
 
         const placedGlyphBoxes = this.collisionIndex.placeCollisionBox(
             shiftVariableCollisionBox(
@@ -259,7 +260,7 @@ export class Placement {
             }
             assert(symbolInstance.crossTileID !== 0);
             this.variableOffsets[symbolInstance.crossTileID] = {
-                radialOffset: radialTextOffset,
+                radialOffset,
                 width,
                 height,
                 anchor,
@@ -426,7 +427,7 @@ export class Placement {
                             const anchor = anchors[i % anchors.length];
                             const allowOverlap = (i >= anchors.length);
                             placedBox = this.attemptAnchorPlacement(
-                                anchor, collisionTextBox, width, height, symbolInstance.radialTextOffset,
+                                anchor, collisionTextBox, width, height,
                                 textBoxScale, rotateWithMap, pitchWithMap, textPixelRatio, posMatrix,
                                 collisionGroup, allowOverlap, symbolInstance, bucket, orientation);
 
diff --git a/src/symbol/symbol_layout.js b/src/symbol/symbol_layout.js
index 7be720bc932..9a257a5a7f3 100644
--- a/src/symbol/symbol_layout.js
+++ b/src/symbol/symbol_layout.js
@@ -64,46 +64,86 @@ export type TextAnchor = 'center' | 'left' | 'right' | 'top' | 'bottom' | 'top-l
 // (see "yOffset" in shaping.js)
 const baselineOffset = 7;
 
-export function evaluateRadialOffset(anchor: TextAnchor, radialOffset: number) {
-    let x = 0, y = 0;
-    // solve for r where r^2 + r^2 = radialOffset^2
-    const hypotenuse = radialOffset / Math.sqrt(2);
+export function evaluateRadialOffset(anchor: TextAnchor, offset: [number, number]) {
+
+    function fromRadialOffset(anchor: TextAnchor, radialOffset: number) {
+        let x = 0, y = 0;
+        if (radialOffset < 0) radialOffset = 0; // Ignore negative offset.
+        // solve for r where r^2 + r^2 = radialOffset^2
+        const hypotenuse = radialOffset / Math.sqrt(2);
+        switch (anchor) {
+        case 'top-right':
+        case 'top-left':
+            y = hypotenuse - baselineOffset;
+            break;
+        case 'bottom-right':
+        case 'bottom-left':
+            y = -hypotenuse + baselineOffset;
+            break;
+        case 'bottom':
+            y = -radialOffset + baselineOffset;
+            break;
+        case 'top':
+            y = radialOffset - baselineOffset;
+            break;
+        }
 
-    switch (anchor) {
-    case 'top-right':
-    case 'top-left':
-        y = hypotenuse - baselineOffset;
-        break;
-    case 'bottom-right':
-    case 'bottom-left':
-        y = -hypotenuse + baselineOffset;
-        break;
-    case 'bottom':
-        y = -radialOffset + baselineOffset;
-        break;
-    case 'top':
-        y = radialOffset - baselineOffset;
-        break;
+        switch (anchor) {
+        case 'top-right':
+        case 'bottom-right':
+            x = -hypotenuse;
+            break;
+        case 'top-left':
+        case 'bottom-left':
+            x = hypotenuse;
+            break;
+        case 'left':
+            x = radialOffset;
+            break;
+        case 'right':
+            x = -radialOffset;
+            break;
+        }
+
+        return [x, y];
     }
 
-    switch (anchor) {
-    case 'top-right':
-    case 'bottom-right':
-        x = -hypotenuse;
-        break;
-    case 'top-left':
-    case 'bottom-left':
-        x = hypotenuse;
-        break;
-    case 'left':
-        x = radialOffset;
-        break;
-    case 'right':
-        x = -radialOffset;
-        break;
+    function fromTextOffset(anchor: TextAnchor, offsetX: number, offsetY: number) {
+        let x = 0, y = 0;
+        if (offsetX < 0 || offsetY < 0) { // Ignore negative offset.
+            offsetX = offsetY = 0;
+        }
+
+        switch (anchor) {
+        case 'top-right':
+        case 'top-left':
+        case 'top':
+            y = offsetY - baselineOffset;
+            break;
+        case 'bottom-right':
+        case 'bottom-left':
+        case 'bottom':
+            y = -offsetY + baselineOffset;
+            break;
+        }
+
+        switch (anchor) {
+        case 'top-right':
+        case 'bottom-right':
+        case 'right':
+            x = -offsetX;
+            break;
+        case 'top-left':
+        case 'bottom-left':
+        case 'left':
+            x = offsetX;
+            break;
+        }
+
+        return [x, y];
     }
 
-    return [x, y];
+    return (offset[1] !== Number.POSITIVE_INFINITY) ? fromTextOffset(anchor, offset[0], offset[1]) : fromRadialOffset(anchor, offset[0]);
 }
 
 export function performSymbolLayout(bucket: SymbolBucket,
@@ -165,15 +205,15 @@ export function performSymbolLayout(bucket: SymbolBucket,
 
             const textAnchor = layout.get('text-anchor').evaluate(feature, {});
             const variableTextAnchor = layout.get('text-variable-anchor');
-            const radialOffset = layout.get('text-radial-offset').evaluate(feature, {});
 
             if (!variableTextAnchor) {
+                const radialOffset = layout.get('text-radial-offset').evaluate(feature, {});
                 // Layers with variable anchors use the `text-radial-offset` property and the [x, y] offset vector
                 // is calculated at placement time instead of layout time
                 if (radialOffset) {
                     // The style spec says don't use `text-offset` and `text-radial-offset` together
                     // but doesn't actually specify what happens if you use both. We go with the radial offset.
-                    textOffset = evaluateRadialOffset(textAnchor, radialOffset * ONE_EM);
+                    textOffset = evaluateRadialOffset(textAnchor, [radialOffset * ONE_EM, Number.POSITIVE_INFINITY]);
                 } else {
                     textOffset = (layout.get('text-offset').evaluate(feature, {}).map(t => t * ONE_EM): any);
                 }
@@ -510,7 +550,11 @@ function addSymbol(bucket: SymbolBucket,
     let numVerticalGlyphVertices = 0;
     const placedTextSymbolIndices = {};
     let key = murmur3('');
-    const radialTextOffset = (layer.layout.get('text-radial-offset').evaluate(feature, {}) || 0) * ONE_EM;
+    let radialTextOffset0 = (layer.layout.get('text-radial-offset').evaluate(feature, {}) || 0) * ONE_EM;
+    let radialTextOffset1 = Number.POSITIVE_INFINITY;
+    if (!radialTextOffset0) {
+        [radialTextOffset0, radialTextOffset1] = (layer.layout.get('text-offset').evaluate(feature, {}).map(t => t * ONE_EM): any);
+    }
 
     if (bucket.allowVerticalPlacement && shapedTextOrientations.vertical) {
         const textRotation = layer.layout.get('text-rotate').evaluate(feature, {});
@@ -623,7 +667,8 @@ function addSymbol(bucket: SymbolBucket,
         numIconVertices,
         0,
         textBoxScale,
-        radialTextOffset);
+        radialTextOffset0,
+        radialTextOffset1);
 }
 
 function anchorIsTooClose(bucket: any, text: string, repeatDistance: number, anchor: Point) {
diff --git a/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset-negative/expected.png b/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset-negative/expected.png
new file mode 100644
index 0000000000000000000000000000000000000000..78fdbf390c30c0c539a9c549f10090b466924876
GIT binary patch
literal 608
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K5893O0R7}x|GzJDHbx#+^kP61P2MxQ=7cv}p
z*#G~0TEfJui&R{vIG$`UkXSn9;*&RCpQHr1H{IY_bNs-vDNkQ?2`$W<<RWR2ZV>aG
z??df8b)azr1RClOh$!ETmR++gBtJU4x^&5{h}sTCAHzwLuReWM@^wqqefj9s)mK-(
z3jV6nw!zM=Xt!0&+!cCZ?Y|y}ZQWfJcDE-Hs965$>sJ+9m(L2_oR$A|uT{KlKTvem
z(pTxFYoe~NT79)w;*^eC$?{qGSG!+DZ548!d9-8N>iD%=We(3waw)!g^Og74wYQ?q
zu5!QX#gp81@y+^m;nJ(PuQtER*t)(dRQH&{GKrJRUU_X@y(>O;mDsAYR~xh3P2+3(
zKn~sc%4ciH+|_nr+E-7%a@e|g)~fcaUVpv=b!^MpxGUN=@9OnezF*f>h3kf#21VZh
cfCKUG%wt>3uU-taNd;N&>FVdQ&MBb@07oORS^xk5

literal 0
HcmV?d00001

diff --git a/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset-negative/style.json b/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset-negative/style.json
new file mode 100644
index 00000000000..c9601c05e0e
--- /dev/null
+++ b/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset-negative/style.json
@@ -0,0 +1,121 @@
+{
+  "version": 8,
+  "metadata": {
+    "test": {
+      "height": 256,
+      "width": 256
+    }
+  },
+  "center": [ 0, 0 ],
+  "zoom": 0,
+  "sources": {
+    "point": {
+      "type": "geojson",
+      "data": {
+        "type": "FeatureCollection",
+        "features": [
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          }
+        ]
+      }
+    }
+  },
+  "glyphs": "local://glyphs/{fontstack}/{range}.pbf",
+  "layers": [
+    {
+      "id": "text",
+      "type": "symbol",
+      "source": "point",
+      "layout": {
+        "text-field": "x",
+        "text-size": 20,
+        "text-justify": "auto",
+        "text-variable-anchor": [
+            "center",
+            "top",
+            "bottom",
+            "left",
+            "right",
+            "top-left",
+            "top-right",
+            "bottom-left",
+            "bottom-right"
+        ],
+        "text-offset": [2, -1],
+        "text-font": [
+          "Open Sans Semibold",
+          "Arial Unicode MS Bold"
+        ]
+      }
+    },
+    {
+      "id": "anchor",
+      "type": "circle",
+      "source": "point",
+      "paint" :{
+        "circle-radius": 2
+      }
+    }
+  ]
+}
diff --git a/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset-zero/expected.png b/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset-zero/expected.png
new file mode 100644
index 0000000000000000000000000000000000000000..97fd20e897fff9ca705f568bc11f9f20bdc2b53f
GIT binary patch
literal 1107
zcmc&z?N3`}94$IPXFwC?h>%HQ%$&&(7wxvNb;+a!35c}4FSRdNs4}^wZne8GE>;YS
zETX||L`1NRzzWTC+sj7xbW&(hn@y3S0(+t>vay(y<hp{1-cFxJYW*vAzMS*roZl}e
zIUm;6ROD<g*e;XFaw=a|YGksEw9Jq_l$9pqJDx_FY+FI4@+fgCBmVWP-`&p4`0CD&
z$*t<xwmfxK@bsLf$}#xDuGnKInWf=cW%plC_4kje{?5LkiFB;F-&k_r{ps09A3j@M
zlGR!8;*BeE)6;{o-<#L27w-s!HdpQ_X6`1oZY|$)ueUvrzIUIX%PQa3lLrd<2_ogo
zh31hc;T$a`oY6m;J%X1a+YjCP2gy-B-yuJIj4*%_av3e|{K9CWZJq>GVNs{;pP~qI
zp{V!?IvaD&a$}g27^yDe&`N%>9a&Lw;m|ZE1gG$q*b#BmNN=$QIKoY}<sl0yL!$VB
zcw+DOd#>3p;ET9Lf}&aC*g6<0oyIn4u&aq?RZuAPa{=50C!?A;*zn~ZIGhb0M}1-^
za|}-4bfjFZ(1dn=w7=UPqFuEnlZgn`{p*PuLwXy3#M<9Or98sKbHZ+ZjwzGcAdKET
z@d~+47V>`33ZCH+@*^!W?v3v0YXCuy{&f>&GVJmONNvu_mZ*~!n32p`?@-e(jX;57
z;yK0w1<sG{Qsu{Q?x?a~7!bk+pRgOm(S-iV7CN7{4&1xK7^J31>+patO!`0!v;(@K
zx%U#`N0<7>KW75JEnI&0Iy-YycWzGCy$rHJFL0qnF(Kl<GerbV7SY+@5&k^Un{ykB
z8_XEC%IQ_wm1ilus`=Hhs*n5L7Q(eQ?+?Bf;!J@s&&Sama-u&Gi`;04X^p^1E*SJ;
zEn5M@dfKIldm1f^<@*FH_?GVlN&Yjiieik3ZGfZor4XxN0GCN-Iq6c{Kv*BrIhUTd
z`8K>qK!7?<Ciy}D(MhR1-O)8WCn?$Yq@=ixs-^RynI+*E9>(nv2hCQ&SzIq2mD6#s
zpUkI5MK>eVPhI9N>eY(Z6hF^&P~!wm@cb;1>QOy$^&mx#(<Rgjf4cb8^nj3{meEkx
z`aIeYThV;+L1V}e=M$tBRYxYru$K#Cmi1;HCyK~TdXq{%cz<TImii_o<LW%`A5eAW
P{{KRyszxciWbXVAizn0P

literal 0
HcmV?d00001

diff --git a/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset-zero/style.json b/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset-zero/style.json
new file mode 100644
index 00000000000..8e9aca1f758
--- /dev/null
+++ b/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset-zero/style.json
@@ -0,0 +1,121 @@
+{
+  "version": 8,
+  "metadata": {
+    "test": {
+      "height": 256,
+      "width": 256
+    }
+  },
+  "center": [ 0, 0 ],
+  "zoom": 0,
+  "sources": {
+    "point": {
+      "type": "geojson",
+      "data": {
+        "type": "FeatureCollection",
+        "features": [
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          }
+        ]
+      }
+    }
+  },
+  "glyphs": "local://glyphs/{fontstack}/{range}.pbf",
+  "layers": [
+    {
+      "id": "text",
+      "type": "symbol",
+      "source": "point",
+      "layout": {
+        "text-field": "x",
+        "text-size": 20,
+        "text-justify": "auto",
+        "text-variable-anchor": [
+            "center",
+            "top",
+            "bottom",
+            "left",
+            "right",
+            "top-left",
+            "top-right",
+            "bottom-left",
+            "bottom-right"
+        ],
+        "text-offset": [2, 0],
+        "text-font": [
+          "Open Sans Semibold",
+          "Arial Unicode MS Bold"
+        ]
+      }
+    },
+    {
+      "id": "anchor",
+      "type": "circle",
+      "source": "point",
+      "paint" :{
+        "circle-radius": 2
+      }
+    }
+  ]
+}
diff --git a/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset/expected.png b/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset/expected.png
new file mode 100644
index 0000000000000000000000000000000000000000..d3edada11e089349926906bc5700c56d53a1c481
GIT binary patch
literal 2339
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
H@@xJB&e%D9

literal 0
HcmV?d00001

diff --git a/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset/style.json b/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset/style.json
new file mode 100644
index 00000000000..b9623279d23
--- /dev/null
+++ b/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset/style.json
@@ -0,0 +1,121 @@
+{
+  "version": 8,
+  "metadata": {
+    "test": {
+      "height": 256,
+      "width": 256
+    }
+  },
+  "center": [ 0, 0 ],
+  "zoom": 0,
+  "sources": {
+    "point": {
+      "type": "geojson",
+      "data": {
+        "type": "FeatureCollection",
+        "features": [
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          }
+        ]
+      }
+    }
+  },
+  "glyphs": "local://glyphs/{fontstack}/{range}.pbf",
+  "layers": [
+    {
+      "id": "text",
+      "type": "symbol",
+      "source": "point",
+      "layout": {
+        "text-field": "x",
+        "text-size": 20,
+        "text-justify": "auto",
+        "text-variable-anchor": [
+            "center",
+            "top",
+            "bottom",
+            "left",
+            "right",
+            "top-left",
+            "top-right",
+            "bottom-left",
+            "bottom-right"
+        ],
+        "text-offset": [2, 1.5],
+        "text-font": [
+          "Open Sans Semibold",
+          "Arial Unicode MS Bold"
+        ]
+      }
+    },
+    {
+      "id": "anchor",
+      "type": "circle",
+      "source": "point",
+      "paint" :{
+        "circle-radius": 2
+      }
+    }
+  ]
+}

From 59afffbcf9cd5638e455e99f2f52e497d5425e0e Mon Sep 17 00:00:00 2001
From: Mikhail Pozdnyakov <mikhail.pozdnyakov@mapbox.com>
Date: Tue, 20 Aug 2019 11:44:08 +0300
Subject: [PATCH 2/8] Update specification

---
 src/style-spec/reference/v8.json | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/src/style-spec/reference/v8.json b/src/style-spec/reference/v8.json
index bce16fc9948..0a9c58db8de 100644
--- a/src/style-spec/reference/v8.json
+++ b/src/style-spec/reference/v8.json
@@ -1855,7 +1855,7 @@
       "type": "number",
       "units": "ems",
       "default": 0,
-      "doc": "Radial offset of text, in the direction of the symbol's anchor. Useful in combination with `text-variable-anchor`, which doesn't support the two-dimensional `text-offset`.",
+      "doc": "Radial offset of text, in the direction of the symbol's anchor. Useful in combination with `text-variable-anchor`, which otherwise uses the two-dimensional `text-offset`.",
       "sdk-support": {
         "basic functionality": {
           "js": "0.54.0",
@@ -2214,7 +2214,7 @@
     },
     "text-offset": {
       "type": "array",
-      "doc": "Offset distance of text from its anchor. Positive values indicate right and down, while negative values indicate left and up.",
+      "doc": "Offset distance of text from its anchor. Positive values indicate right and down, while negative values indicate left and up. Note that in combination with `text-variable-anchor` only positive values are allowed and they indicate radial offsets along x- and y-axis accordingly.",
       "value": "number",
       "units": "ems",
       "length": 2,
@@ -2226,9 +2226,6 @@
         "text-field",
         {
             "!": "text-radial-offset"
-        },
-        {
-            "!": "text-variable-anchor"
         }
       ],
       "sdk-support": {

From d803520cf2282bc5dcc3b518e50ad9bf40e94a0a Mon Sep 17 00:00:00 2001
From: Mikhail Pozdnyakov <mikhail.pozdnyakov@mapbox.com>
Date: Thu, 22 Aug 2019 16:35:46 +0300
Subject: [PATCH 3/8] Enable zero text-radial-offset

---
 src/symbol/symbol_layout.js                   |  10 +-
 .../all-anchors-offset-zero/expected.png      | Bin 0 -> 608 bytes
 .../all-anchors-offset-zero/style.json        | 122 ++++++++++++++++++
 .../expected.png                              | Bin 0 -> 2339 bytes
 .../all-anchors-radial-offset-zero/style.json | 121 +++++++++++++++++
 5 files changed, 250 insertions(+), 3 deletions(-)
 create mode 100644 test/integration/render-tests/text-variable-anchor/all-anchors-offset-zero/expected.png
 create mode 100644 test/integration/render-tests/text-variable-anchor/all-anchors-offset-zero/style.json
 create mode 100644 test/integration/render-tests/text-variable-anchor/all-anchors-radial-offset-zero/expected.png
 create mode 100644 test/integration/render-tests/text-variable-anchor/all-anchors-radial-offset-zero/style.json

diff --git a/src/symbol/symbol_layout.js b/src/symbol/symbol_layout.js
index 9a257a5a7f3..912d423874e 100644
--- a/src/symbol/symbol_layout.js
+++ b/src/symbol/symbol_layout.js
@@ -550,10 +550,14 @@ function addSymbol(bucket: SymbolBucket,
     let numVerticalGlyphVertices = 0;
     const placedTextSymbolIndices = {};
     let key = murmur3('');
-    let radialTextOffset0 = (layer.layout.get('text-radial-offset').evaluate(feature, {}) || 0) * ONE_EM;
-    let radialTextOffset1 = Number.POSITIVE_INFINITY;
-    if (!radialTextOffset0) {
+
+    let radialTextOffset0 = 0;
+    let radialTextOffset1 = 0;
+    if (layer._unevaluatedLayout.getValue('text-radial-offset') === undefined) {
         [radialTextOffset0, radialTextOffset1] = (layer.layout.get('text-offset').evaluate(feature, {}).map(t => t * ONE_EM): any);
+    } else {
+        radialTextOffset0 = layer.layout.get('text-radial-offset').evaluate(feature, {}) * ONE_EM;
+        radialTextOffset1 = Number.POSITIVE_INFINITY;
     }
 
     if (bucket.allowVerticalPlacement && shapedTextOrientations.vertical) {
diff --git a/test/integration/render-tests/text-variable-anchor/all-anchors-offset-zero/expected.png b/test/integration/render-tests/text-variable-anchor/all-anchors-offset-zero/expected.png
new file mode 100644
index 0000000000000000000000000000000000000000..78fdbf390c30c0c539a9c549f10090b466924876
GIT binary patch
literal 608
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K5893O0R7}x|GzJDHbx#+^kP61P2MxQ=7cv}p
z*#G~0TEfJui&R{vIG$`UkXSn9;*&RCpQHr1H{IY_bNs-vDNkQ?2`$W<<RWR2ZV>aG
z??df8b)azr1RClOh$!ETmR++gBtJU4x^&5{h}sTCAHzwLuReWM@^wqqefj9s)mK-(
z3jV6nw!zM=Xt!0&+!cCZ?Y|y}ZQWfJcDE-Hs965$>sJ+9m(L2_oR$A|uT{KlKTvem
z(pTxFYoe~NT79)w;*^eC$?{qGSG!+DZ548!d9-8N>iD%=We(3waw)!g^Og74wYQ?q
zu5!QX#gp81@y+^m;nJ(PuQtER*t)(dRQH&{GKrJRUU_X@y(>O;mDsAYR~xh3P2+3(
zKn~sc%4ciH+|_nr+E-7%a@e|g)~fcaUVpv=b!^MpxGUN=@9OnezF*f>h3kf#21VZh
cfCKUG%wt>3uU-taNd;N&>FVdQ&MBb@07oORS^xk5

literal 0
HcmV?d00001

diff --git a/test/integration/render-tests/text-variable-anchor/all-anchors-offset-zero/style.json b/test/integration/render-tests/text-variable-anchor/all-anchors-offset-zero/style.json
new file mode 100644
index 00000000000..9fa5eb1c0b8
--- /dev/null
+++ b/test/integration/render-tests/text-variable-anchor/all-anchors-offset-zero/style.json
@@ -0,0 +1,122 @@
+{
+  "version": 8,
+  "metadata": {
+    "test": {
+      "height": 256,
+      "width": 256
+    }
+  },
+  "center": [ 0, 0 ],
+  "zoom": 0,
+  "sources": {
+    "point": {
+      "type": "geojson",
+      "data": {
+        "type": "FeatureCollection",
+        "features": [
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          }
+        ]
+      }
+    }
+  },
+  "glyphs": "local://glyphs/{fontstack}/{range}.pbf",
+  "layers": [
+    {
+      "id": "text",
+      "type": "symbol",
+      "source": "point",
+      "layout": {
+        "text-field": "x",
+        "text-size": 20,
+        "text-justify": "auto",
+        "text-variable-anchor": [
+            "center",
+            "top",
+            "bottom",
+            "left",
+            "right",
+            "top-left",
+            "top-right",
+            "bottom-left",
+            "bottom-right"
+        ],
+        "text-radial-offset": 0,
+        "text-offset": [2, 2],
+        "text-font": [
+          "Open Sans Semibold",
+          "Arial Unicode MS Bold"
+        ]
+      }
+    },
+    {
+      "id": "anchor",
+      "type": "circle",
+      "source": "point",
+      "paint" :{
+        "circle-radius": 2
+      }
+    }
+  ]
+}
diff --git a/test/integration/render-tests/text-variable-anchor/all-anchors-radial-offset-zero/expected.png b/test/integration/render-tests/text-variable-anchor/all-anchors-radial-offset-zero/expected.png
new file mode 100644
index 0000000000000000000000000000000000000000..d3edada11e089349926906bc5700c56d53a1c481
GIT binary patch
literal 2339
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
H@@xJB&e%D9

literal 0
HcmV?d00001

diff --git a/test/integration/render-tests/text-variable-anchor/all-anchors-radial-offset-zero/style.json b/test/integration/render-tests/text-variable-anchor/all-anchors-radial-offset-zero/style.json
new file mode 100644
index 00000000000..b9623279d23
--- /dev/null
+++ b/test/integration/render-tests/text-variable-anchor/all-anchors-radial-offset-zero/style.json
@@ -0,0 +1,121 @@
+{
+  "version": 8,
+  "metadata": {
+    "test": {
+      "height": 256,
+      "width": 256
+    }
+  },
+  "center": [ 0, 0 ],
+  "zoom": 0,
+  "sources": {
+    "point": {
+      "type": "geojson",
+      "data": {
+        "type": "FeatureCollection",
+        "features": [
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          },
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [ 0, 0 ]
+            }
+          }
+        ]
+      }
+    }
+  },
+  "glyphs": "local://glyphs/{fontstack}/{range}.pbf",
+  "layers": [
+    {
+      "id": "text",
+      "type": "symbol",
+      "source": "point",
+      "layout": {
+        "text-field": "x",
+        "text-size": 20,
+        "text-justify": "auto",
+        "text-variable-anchor": [
+            "center",
+            "top",
+            "bottom",
+            "left",
+            "right",
+            "top-left",
+            "top-right",
+            "bottom-left",
+            "bottom-right"
+        ],
+        "text-offset": [2, 1.5],
+        "text-font": [
+          "Open Sans Semibold",
+          "Arial Unicode MS Bold"
+        ]
+      }
+    },
+    {
+      "id": "anchor",
+      "type": "circle",
+      "source": "point",
+      "paint" :{
+        "circle-radius": 2
+      }
+    }
+  ]
+}

From 8772e1f71f9e808197b0755328613ee0df877457 Mon Sep 17 00:00:00 2001
From: Mikhail Pozdnyakov <mikhail.pozdnyakov@mapbox.com>
Date: Wed, 28 Aug 2019 10:46:17 +0300
Subject: [PATCH 4/8] Update text-radial-offset description

Co-Authored-By: Asheem Mamoowala <asheem.mamoowala@mapbox.com>
---
 src/style-spec/reference/v8.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/style-spec/reference/v8.json b/src/style-spec/reference/v8.json
index 0a9c58db8de..bc24f38ce0d 100644
--- a/src/style-spec/reference/v8.json
+++ b/src/style-spec/reference/v8.json
@@ -1855,7 +1855,7 @@
       "type": "number",
       "units": "ems",
       "default": 0,
-      "doc": "Radial offset of text, in the direction of the symbol's anchor. Useful in combination with `text-variable-anchor`, which otherwise uses the two-dimensional `text-offset`.",
+      "doc": "Radial offset of text, in the direction of the symbol's anchor. Useful in combination with `text-variable-anchor`, which defaults to using the two-dimensional `text-offset` if present.",
       "sdk-support": {
         "basic functionality": {
           "js": "0.54.0",

From 3aa5a223ccc11ace204784d59d9aa84286336cd7 Mon Sep 17 00:00:00 2001
From: Mikhail Pozdnyakov <mikhail.pozdnyakov@mapbox.com>
Date: Wed, 28 Aug 2019 11:14:45 +0300
Subject: [PATCH 5/8] `text-offset` absolute values are used with variable
 label placement

Also, render tests image size was decreased.
---
 src/symbol/symbol_layout.js                   |   6 +++---
 .../all-anchors-offset-zero/expected.png      | Bin 608 -> 411 bytes
 .../all-anchors-offset-zero/style.json        |   4 ++--
 .../all-anchors-offset/expected.png           | Bin 2457 -> 2064 bytes
 .../all-anchors-offset/style.json             |   4 ++--
 .../expected.png                              | Bin 2339 -> 1972 bytes
 .../all-anchors-radial-offset-zero/style.json |   4 ++--
 .../expected.png                              | Bin 608 -> 1972 bytes
 .../style.json                                |   4 ++--
 .../expected.png                              | Bin 1107 -> 830 bytes
 .../style.json                                |   4 ++--
 .../expected.png                              | Bin 2339 -> 1972 bytes
 .../style.json                                |   4 ++--
 .../text-allow-overlap/expected.png           | Bin 1396 -> 1094 bytes
 .../text-allow-overlap/style.json             |   4 ++--
 15 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/src/symbol/symbol_layout.js b/src/symbol/symbol_layout.js
index 912d423874e..635e286599f 100644
--- a/src/symbol/symbol_layout.js
+++ b/src/symbol/symbol_layout.js
@@ -110,9 +110,9 @@ export function evaluateRadialOffset(anchor: TextAnchor, offset: [number, number
 
     function fromTextOffset(anchor: TextAnchor, offsetX: number, offsetY: number) {
         let x = 0, y = 0;
-        if (offsetX < 0 || offsetY < 0) { // Ignore negative offset.
-            offsetX = offsetY = 0;
-        }
+        // Use absolute offset values.
+        offsetX = Math.abs(offsetX);
+        offsetY = Math.abs(offsetY);
 
         switch (anchor) {
         case 'top-right':
diff --git a/test/integration/render-tests/text-variable-anchor/all-anchors-offset-zero/expected.png b/test/integration/render-tests/text-variable-anchor/all-anchors-offset-zero/expected.png
index 78fdbf390c30c0c539a9c549f10090b466924876..bed8c64a7aae1c03b839b89d80d94b2ea39496e1 100644
GIT binary patch
literal 411
zcmeAS@N?(olHy`uVBq!ia0vp^4Is?H1|$#LC7xzrU`+CKaSW+oe0y+X_xVJI0}qeC
z&o<t0A}er`QaD?wqyXFEDMqvA#CrZ?JJO_M#{AlFgJ!B_(3F@JvsD7w&Pno2pZWH$
zO}~ogB%;x$c;912?aepZ%KvQ>cHbZ=&y!>{ZSszu%N1SU|J~@TwrKUQND`3leQL({
zm__f=1pB;1{do_UHToR;#GGFs^V{GsPw|hw&lPzJlRvI`px&3*TpC_@I3ev=348ao
zy$4L!NS-+}Bkbep`(eBpM$1^|92KuQTz2LIM>d<0<ax%J<7zPnm}QRE?K!5+JhLa2
zdtCzmyT?M)Hi&+{(dt@b)^RdItbk41qP;)ju=kl{b2XbIvlxAjZDL+uAl|?Bch~la
lV@A_9Xc6t-C-Q&T%s!Z3{r=$NMPQ&ac)I$ztaD0e0s!|~sfqvq

literal 608
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K5893O0R7}x|GzJDHbx#+^kP61P2MxQ=7cv}p
z*#G~0TEfJui&R{vIG$`UkXSn9;*&RCpQHr1H{IY_bNs-vDNkQ?2`$W<<RWR2ZV>aG
z??df8b)azr1RClOh$!ETmR++gBtJU4x^&5{h}sTCAHzwLuReWM@^wqqefj9s)mK-(
z3jV6nw!zM=Xt!0&+!cCZ?Y|y}ZQWfJcDE-Hs965$>sJ+9m(L2_oR$A|uT{KlKTvem
z(pTxFYoe~NT79)w;*^eC$?{qGSG!+DZ548!d9-8N>iD%=We(3waw)!g^Og74wYQ?q
zu5!QX#gp81@y+^m;nJ(PuQtER*t)(dRQH&{GKrJRUU_X@y(>O;mDsAYR~xh3P2+3(
zKn~sc%4ciH+|_nr+E-7%a@e|g)~fcaUVpv=b!^MpxGUN=@9OnezF*f>h3kf#21VZh
cfCKUG%wt>3uU-taNd;N&>FVdQ&MBb@07oORS^xk5

diff --git a/test/integration/render-tests/text-variable-anchor/all-anchors-offset-zero/style.json b/test/integration/render-tests/text-variable-anchor/all-anchors-offset-zero/style.json
index 9fa5eb1c0b8..73fd84ade25 100644
--- a/test/integration/render-tests/text-variable-anchor/all-anchors-offset-zero/style.json
+++ b/test/integration/render-tests/text-variable-anchor/all-anchors-offset-zero/style.json
@@ -2,8 +2,8 @@
   "version": 8,
   "metadata": {
     "test": {
-      "height": 256,
-      "width": 256
+      "height": 128,
+      "width": 128
     }
   },
   "center": [ 0, 0 ],
diff --git a/test/integration/render-tests/text-variable-anchor/all-anchors-offset/expected.png b/test/integration/render-tests/text-variable-anchor/all-anchors-offset/expected.png
index a820ca32692e9ff0011dbde8266d61441d1a2a66..784d063b996e0cb6b3edd9a50e550e575c2ad9d7 100644
GIT binary patch
literal 2064
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
BjdTD2

literal 2457
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

diff --git a/test/integration/render-tests/text-variable-anchor/all-anchors-offset/style.json b/test/integration/render-tests/text-variable-anchor/all-anchors-offset/style.json
index 254adef41cf..95d193fe95b 100644
--- a/test/integration/render-tests/text-variable-anchor/all-anchors-offset/style.json
+++ b/test/integration/render-tests/text-variable-anchor/all-anchors-offset/style.json
@@ -2,8 +2,8 @@
   "version": 8,
   "metadata": {
     "test": {
-      "height": 256,
-      "width": 256
+      "height": 128,
+      "width": 128
     }
   },
   "center": [ 0, 0 ],
diff --git a/test/integration/render-tests/text-variable-anchor/all-anchors-radial-offset-zero/expected.png b/test/integration/render-tests/text-variable-anchor/all-anchors-radial-offset-zero/expected.png
index d3edada11e089349926906bc5700c56d53a1c481..31a3a20875cf351f6f01c2edaab9a9d98f848193 100644
GIT binary patch
literal 1972
zcmZ|QX<QO`8V7Jh#S0V_6cH8IRq;wd#{-MOQp{rrj|`JZP%AapP??5IOG7c`P}6bD
zu^ELyopdTEo5<(@6(_Zlbkpe+=#W+?NNfFcF1^@&)xP*Y|JTp+d_TXZfl5h$*dlEK
z001O$Yh0S?um1F`L8dxNWKID9R)-SfVly~qD~iJAJC+`R#l4SQTY_-rF2JH#3s`;@
z2@UnQc#?WTAU|0+n8JpH!^i=lDUBPcV<*xG!-e={t5VW<%-GH|mYEkH(`o4Tw=Cwj
zZw-ez_50sF+V=7Mqg89~TIlA_m+;c8>%)q0@I-2H>pXCN5sy+v=))XaXWYG_)lqcr
zO`3OAh1L%|=7(yVcZ*~MXX?6J+ghemyXr0(q8gukr5cr?>ZR$)_iGbysk@F$Pux;d
z2p&qz#_B`O-_4>Na$P{WW()lBXi@ZnXqCEQFQz0R`<>(V+xmmS<m73R|M2*OCEmXc
z{`w4I-^{TfT<XnNGGx60VZRj}bn#?VwGlI3bf1S09s{FVDG*vs3ua4Ln`UA`c%2q>
z`P7V=t2QM=M;spa;gC0H)n(O{AOxwHQNOmlR`xyaWkiEU27q+bT}`^W9l=}0BEL5J
z^=gjQ;%&>p<wIWMWj~VZdNnUN9(~<zMCEKJFN8y<SfM89bAcqX=1N_}%MtH^!UF#3
zmjp3wwzOBCP8E}~>H-vWSe`c_7aGx>HUigdNKsZ4Zwc+<?VyG}AnWEa%H$<cnw-Dl
zG?}!4`?l03urvf&N_?XYSw6nY*^nLmgkz(_TErN<^#Al+RomTS2EJhc2pafYqN!=q
z?qA6ua9Rx$QGI}RtU^BvU!@*>lxKfO5>1xCUNC=PcQ$x2Ad^FGIg4p+TIj=8QYQWZ
zE0n-6dpa2{2tm}GjuP1F%l*lD9wiFT=<hIFLWfoRqWr#AY4*(NcFDc_kPw83LgNZ4
zX)XD8nP7We$a1;ZZpLk2s&^GxjM$f|iL07%IM0C#Z%ZBCFkK&#xbk!yC};HQ*{sh?
z`X4b(P;k(RJu=i@9s2cDkkT4Fad^3vXkO~wIHYK($OGTa<*yYs*(~vjP_6Sw9Tw`&
znogWd>V^L`p5K=1{roYV?_cWK&TL&fQJbSJk~iHbOEPRceXT_9TQ!pBQbMwm2lQDx
zXg%4Aps2;a@Agfv|A!3xOzbkHwlmG?%SAW+u+uZimsc7r*DZH4ftgwgs+kz020G7J
zdFA@}<+?PoydHi}$}Ia~1}vFzm@<Y5RQMDHQ_lwPW8pw(E*PY>o;3EXor((u$M3Ba
z{ke41vV%*u$%pqky{GcL5&WGgu~POukq*)Hw}a)zpV<QwMFJHX9Dk(p=r0RCJ%h@*
z9^{T5yGE?TwnF47EMU{)!E3PP*26LC>K9^!P-gz(6E7r-KAX`5@;^1t4kx5?fxBT(
z!S{vj>(B{<Gkvg7=IArz9;0@>;N$at5(|0NPx9%NTmt69pHk>e5E-zKfvL#Fy-q&E
z?5MxfA#%mpbBB=IZx6sdC!oQ~ZK=EuQ4qcwT{HMtwYa08;gTWn6c+hjjp9pZ^&GHt
z-G7hRX$1#-#;|$4wXZCN44E_r{H{BMiT{GwZUVJpfL7@C%e-DK@OKL09E!&S_2qV_
zM-SW={8})UBp~JF8v~KjDaLf1-Lz`8?2ab9t7*eJAg1f*!Td(GeKOYJ{7d4NFCw~;
z1JYYr{mOHk^oM4H6XfDJ-{;a~2b7A>K~6lW5+I9J6~(UqC!hYSYTb4!sRTgKqMvv5
zTWl%?<Rtxcb4i%l|Bd*J#H%y!%vxbhTBZ5Nc!?Z*Gd6OrTm4Ct^WpmIOLg%D&0(H)
zSjTLtZ&j~`NUx7Pn|{-cV-~4l2ggd-ZX$n!&z#Qu;J1s8f@}EYvg7#Ue~K;^2oq&#
zl!WQH{gu^6w)Xi`xqo$to??_Rdab0R38Y_**hTig-}s@7%&@(y3#Iv*#!O7G0w?Sb
z9>1|pyu-j3NoT!_$9)mUZeSGV1)>;3=h_<>7iZn4bKY26ZgkqCm0A2|dk#2CZTwM&
z{H8;6L3*!ZSb+sAqhPwM>CKnd2#sGMnqrrPxOHIqP`oMKqK}=F0WUX?1E<N7wd@AR
zCI0WUrfjOu`-q-sl{PpZ>ud){OIZIJ%6{nDKOerV0v)_Jw0(BSURZWzj9@v5nf|4t
z=5>Edx=7K<8(;-Ir`Gp$3>IP(U|0|62F`p1h91C1icv8vkGl-$2*dG8+pfL30QR+F
zxqy$ghA&_)|JETi(s=GTs1&12v)Sz%31|{;db)UvR?o*l6AU6Y0e%kW^nwxCF0tZ?
z-CZ<i*(0E^Qs{-e0DFxotilFcOtyYCxK~;wV?A=jpjU{xa-&Ve)}Op`k*~Fx85%@p
zUhpIfl`P%1ZKL1-$7%IRhUOkZ<Rs@+QPMK;RXB?&BR1lXfw)cf-S!{bH)N$;vzJ#t
zd%UtaM6?JEWMzy9#@sj_<t!S-JQK~8EHs?|Jg$%RAFP^b%kOmI#WzgX7?2oGi95ZS
Gar8f717J@8

literal 2339
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
H@@xJB&e%D9

diff --git a/test/integration/render-tests/text-variable-anchor/all-anchors-radial-offset-zero/style.json b/test/integration/render-tests/text-variable-anchor/all-anchors-radial-offset-zero/style.json
index b9623279d23..4817d45a2c4 100644
--- a/test/integration/render-tests/text-variable-anchor/all-anchors-radial-offset-zero/style.json
+++ b/test/integration/render-tests/text-variable-anchor/all-anchors-radial-offset-zero/style.json
@@ -2,8 +2,8 @@
   "version": 8,
   "metadata": {
     "test": {
-      "height": 256,
-      "width": 256
+      "height": 128,
+      "width": 128
     }
   },
   "center": [ 0, 0 ],
diff --git a/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset-negative/expected.png b/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset-negative/expected.png
index 78fdbf390c30c0c539a9c549f10090b466924876..8b9cb4b8894a120672fc36ebbf42890c60a1a1a5 100644
GIT binary patch
literal 1972
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
HIIH9jxyf(i

literal 608
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K5893O0R7}x|GzJDHbx#+^kP61P2MxQ=7cv}p
z*#G~0TEfJui&R{vIG$`UkXSn9;*&RCpQHr1H{IY_bNs-vDNkQ?2`$W<<RWR2ZV>aG
z??df8b)azr1RClOh$!ETmR++gBtJU4x^&5{h}sTCAHzwLuReWM@^wqqefj9s)mK-(
z3jV6nw!zM=Xt!0&+!cCZ?Y|y}ZQWfJcDE-Hs965$>sJ+9m(L2_oR$A|uT{KlKTvem
z(pTxFYoe~NT79)w;*^eC$?{qGSG!+DZ548!d9-8N>iD%=We(3waw)!g^Og74wYQ?q
zu5!QX#gp81@y+^m;nJ(PuQtER*t)(dRQH&{GKrJRUU_X@y(>O;mDsAYR~xh3P2+3(
zKn~sc%4ciH+|_nr+E-7%a@e|g)~fcaUVpv=b!^MpxGUN=@9OnezF*f>h3kf#21VZh
cfCKUG%wt>3uU-taNd;N&>FVdQ&MBb@07oORS^xk5

diff --git a/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset-negative/style.json b/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset-negative/style.json
index c9601c05e0e..5d8de72a017 100644
--- a/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset-negative/style.json
+++ b/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset-negative/style.json
@@ -2,8 +2,8 @@
   "version": 8,
   "metadata": {
     "test": {
-      "height": 256,
-      "width": 256
+      "height": 128,
+      "width": 128
     }
   },
   "center": [ 0, 0 ],
diff --git a/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset-zero/expected.png b/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset-zero/expected.png
index 97fd20e897fff9ca705f568bc11f9f20bdc2b53f..9e71ac16b38fcb2a0b94e1a6f240e3d339088bc8 100644
GIT binary patch
literal 830
zcmeAS@N?(olHy`uVBq!ia0vp^4Is?H1|$#LC7xzrU}p7naSW+oe0$J8<0>ly`-k)2
zbe^$v2e55z?p!+c<&_{!RfDrj90OZKuBxusu*7wW)6MubEqbDp^-|mYDm^-qsth@<
zEJ)OimOQy^XIhi7DUaFxxOQ2&dw*=3>YCp_S5_h){0kO6>T{5J2V?!?HM`W-9C>Te
zZG0-7^PPh<TTG7JwFg{(*43mf626|qk^E{|qVBW=hGe}!SHraxveFv_;uEg4xNnf%
zo+RI=HJ|;XmfW#A8RJB;vLsu-huKe!rK3MuL~Xd<qPC~?`h~vr1?N;(X{3qNKZv{2
zBPeqqrX*R+?%?rLF9pIDFo!3z$2n?S6>`ij@cTK(h1;r7xXQ5O_Xbhl3g+LU0fBb{
zeGblzXke}oTfLD#)?)pfV;{7yB^u7U*rWP`UHancJ--aZPZ#pm9W>jL%zn?+mr=C$
z<zXhBLq>O61xptC@8o^V^v-SauJ0RTcZL>9tS;o9wwU?;W6L>V0j|kzhAr(E`qWAu
zJ5P4D7fbHrv|q%XKIOh=&tthQ3){p$_Oh8|-?7k}F=v%T`NmZz7e7mSEOlj#Vfe#T
zA6NZjA6Tx<l$m!#YtA9hGsiz?gw=I_U|RKq&ot*)4)2PLGio+%jBAdkM)bYD*u44F
zYqOGMDYInpYe|}Xi{mS|K4R86JiUUe`$FT(7YBDRX>~<6Z#NXxPvrl#QA&1)jP0qH
zUVGYGf5=2%XrCF;DZNp8`P9p9IR`j%j_^wy`y0`rC==q~YH0j{@7Y7+J)K(r4snDf
z^7TDdfBKn6?x?}MV}(}=IJ6DrMc+93?$kLdwk1KjY}N<qWy!3!KI;A}>D21VJk0aP
z&D`zE-yTJt1djHp=SyE4Uw&itJDI)&f#w&^p*znUtbB9GeaC`#3VshH`Vt~s$OC`g
b|6|?7x1!<E|8hrQzF_cl^>bP0l+XkKtdmts

literal 1107
zcmc&z?N3`}94$IPXFwC?h>%HQ%$&&(7wxvNb;+a!35c}4FSRdNs4}^wZne8GE>;YS
zETX||L`1NRzzWTC+sj7xbW&(hn@y3S0(+t>vay(y<hp{1-cFxJYW*vAzMS*roZl}e
zIUm;6ROD<g*e;XFaw=a|YGksEw9Jq_l$9pqJDx_FY+FI4@+fgCBmVWP-`&p4`0CD&
z$*t<xwmfxK@bsLf$}#xDuGnKInWf=cW%plC_4kje{?5LkiFB;F-&k_r{ps09A3j@M
zlGR!8;*BeE)6;{o-<#L27w-s!HdpQ_X6`1oZY|$)ueUvrzIUIX%PQa3lLrd<2_ogo
zh31hc;T$a`oY6m;J%X1a+YjCP2gy-B-yuJIj4*%_av3e|{K9CWZJq>GVNs{;pP~qI
zp{V!?IvaD&a$}g27^yDe&`N%>9a&Lw;m|ZE1gG$q*b#BmNN=$QIKoY}<sl0yL!$VB
zcw+DOd#>3p;ET9Lf}&aC*g6<0oyIn4u&aq?RZuAPa{=50C!?A;*zn~ZIGhb0M}1-^
za|}-4bfjFZ(1dn=w7=UPqFuEnlZgn`{p*PuLwXy3#M<9Or98sKbHZ+ZjwzGcAdKET
z@d~+47V>`33ZCH+@*^!W?v3v0YXCuy{&f>&GVJmONNvu_mZ*~!n32p`?@-e(jX;57
z;yK0w1<sG{Qsu{Q?x?a~7!bk+pRgOm(S-iV7CN7{4&1xK7^J31>+patO!`0!v;(@K
zx%U#`N0<7>KW75JEnI&0Iy-YycWzGCy$rHJFL0qnF(Kl<GerbV7SY+@5&k^Un{ykB
z8_XEC%IQ_wm1ilus`=Hhs*n5L7Q(eQ?+?Bf;!J@s&&Sama-u&Gi`;04X^p^1E*SJ;
zEn5M@dfKIldm1f^<@*FH_?GVlN&Yjiieik3ZGfZor4XxN0GCN-Iq6c{Kv*BrIhUTd
z`8K>qK!7?<Ciy}D(MhR1-O)8WCn?$Yq@=ixs-^RynI+*E9>(nv2hCQ&SzIq2mD6#s
zpUkI5MK>eVPhI9N>eY(Z6hF^&P~!wm@cb;1>QOy$^&mx#(<Rgjf4cb8^nj3{meEkx
z`aIeYThV;+L1V}e=M$tBRYxYru$K#Cmi1;HCyK~TdXq{%cz<TImii_o<LW%`A5eAW
P{{KRyszxciWbXVAizn0P

diff --git a/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset-zero/style.json b/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset-zero/style.json
index 8e9aca1f758..e9e2988e1e1 100644
--- a/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset-zero/style.json
+++ b/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset-zero/style.json
@@ -2,8 +2,8 @@
   "version": 8,
   "metadata": {
     "test": {
-      "height": 256,
-      "width": 256
+      "height": 128,
+      "width": 128
     }
   },
   "center": [ 0, 0 ],
diff --git a/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset/expected.png b/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset/expected.png
index d3edada11e089349926906bc5700c56d53a1c481..31a3a20875cf351f6f01c2edaab9a9d98f848193 100644
GIT binary patch
literal 1972
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
Gar8f717J@8

literal 2339
zcmc(h>r+$L9)<&Q3wMcJLN-tZ!XObss7Vk6ZAFSAUPq!tAUBb#JD|9$u?R>a0*Mtw
z7$CH@BXvYfM#QZ|NZ7du-fB5wG|0*2DANPjozhAyiYK1G;G9pLSu<;Wc|WYRp68uk
z{f?}3FZW<~3<l$s@zthX7>tAc=zwu^v2V=spAKR$ZvW2Mv~dsQFsIrln{s9;pENJB
z7%>wrj?OQfmjCeC%2OLQ9yu+er}2ue3?_sa_CI0#`~!K*jPOG1o$t;hT>B+0scU~u
zh}yw_VbuWN!<Sdj^1yz7Ix=Fz$hN=0us8pj`({D)uHdhv^z#uJf9K*xQO@&c>pVa|
zsq*CIIpH(&EB)z3&&SW{t_>(BY2C8x8V7h31<ukeL6dd5%p}ZV^{=qMWVA8!9$l)u
zVJ#Cl&TmT!3{%C(o|EUqGz*7r=)VL;E&=nN<HXLhKIXeY?UcZ<kx06C2Uknv0^3cL
zUd_DxK?@G`o^7g9Z$bWWW;VR!FMq3>f_wtZi?%4F-=$kysc<jo_}xX}(t+|zTJVHX
zc!CrDNX?!+dy9kZ)28W*+6GL-&YDQQ^Hx*``A(ZFk(+*t<}@f^!uUZ?2-6hsNa5{G
zIWk|JX%9(tfFT_8G<*pK^%x@*z6KDx^b~zrgR=@qnvJ%ASfz#1ifwPY1_KiIP;|Gd
zJV{igqoJSA)`VFSD!mtsxXZH*JzygBo}S1Z_{QTz`+#qFlISk~T;U>Xs7rSv^F(mK
zz1~JHHNaT@K=)Mdqhqh#8#Isz(H^N*Pl^!qh`_&DSQ@<)T!Hd{MvX0WVvMnw(uWmb
z;xz6GZ-dnls6K3QK#m41O|<ZAlt)S{9QKg|zg1nJdv@#I(SdYMmB2rTtF@=HO{+4^
za}03@xJs-|W;SIY6~28+$M@@Fk<|}0yGYsvemCn*P}M1e%=4J#B7_g%;D+K7sOR}4
z^`b1UZ{*eG6770A-j$WmN{}97MZZzzSkFbr$ecv1?ShaTulsn&gJ?|=jJK@S3!7!B
zWk?q#yn+kNgTYjb0aA-|&nyFz?AhJquv?tlAtB;$xkDaOiImgD>SZ?KK>I*U7INJ*
z4Bq-55zo8*Z6ha8;rLj^f&S5-NXJK+b|$kSv8sU_c6IL1@+@Qu)}gbtH)OuWvZwv)
z`7UBrQON~7ew6-Jxd_GvSc*#GUmdlrkV**PMN^_{RsA!gD{N?SwmIh3yIM<;3UaK9
zASVp*#sGoaZ<=b`YU)^HBNxa4!*a#btYu|t7VPMO`q+9|ckpq_owjYvx?yD~-GgR1
zpg#mnaA=)%h&6n&{stfW+W5g%{XqYf_Gn<G>I&VDW_~PNK{F<oP&0G*gxs1-@zq$M
zRwwsNr7&Z_pe&_>%{f+64ZB}t4ccP|InH9WA0Qc*J500cSUGmIh_Bl!6H|D4B0r|p
z%;-FI3EkZ(5ph2;yoOPmZQ1ZZ<!|fnLbd=+UuNFMPMek^w?Yl*V4GwPiW-XIbewzs
zLfA9gNt8bn6X%i#3{R--7wkwEnAht=Qb+c_$L6x9QM)m&^3Zf+NE=zO6?7oV0Rw-f
zcdNXKOP#8t<*&`H?=d+6XN#>rnbs}O&fm^F6KC=SL^<+bz`5$}Mu=IPs__HrdMx`(
znm<XIh2*i0DF}JU7LsOXTSKwecmm2NX{*faUS$d$|5$Srx<_7v+-8V)HvEKnK^9bu
z;@ai*uMSOVOtaAhm}V%50J?jt?!p>W;eTDXU*WvKPAb!m(jCJEUIwrGd^l*(v`e6B
zNkWe(Fs^11oOh5LVQG_m4SQ$j*A}Mgf_t^WlSPoU>4FUy;=S11JJJQ?V#tLIZ`DBo
zwp+FP@&~6GkhYg~?f+nL=FqH2C)0=nj5|uy&BAF6X(UvipFS)Oj}P=ANMFi=hO0kn
zD#wW^lcZi(a`C?)>i%hB0>Wb1!<GcT|0C^sMj;fdT(lk+;AXacO&mHyv*2NG`<*gu
z5le2(w(kpnQ>XJOWy)oga2!Q^69!J00mWF$2QWUsB(nJ+e`NF`D%iIo-gVlffgH2h
z9j15QLp2|)RDd@&O7~eb=79~LF#OYFwxL<(_RO-zc5+f!Ay<)0NA5z=V%1B=DIa$1
zRQ+{AU$==4G!z(nY-Fh@&caTPwD-Yt7#qco_tq54oCD2C!czaYBlYxvg8Y;e(N=OH
zEL9$$<8*Ahd~y7gH{Z(b{T7NGSNMror>}z11B9UtK1HmYV$|JYcbNt~D){T9O;~2*
zRbB~>l5-XPu5eiWV;54(D1EVivUr;BI?(ZZ#G7;b+Rr`L`v<bZdJ}kf@r?>-ZLV;Q
zz6J;Obs>(-(}@hxZP;y|TVh9_#=^hR&Bz1Ac6VI12lq`I$Mu01%`s5CSW`Y(2ycd0
z6qsEUSY3YnYvXbJeY=pKrwC7i_$B-?V<g>0Vi^<`W;4(3Mh|pK2z<9J<rmD_hr(ZP
z!a)*K2prmhQb^jz{Ekm=D0f|Q8LpiHS4!3EGR=FEeNr_=$h-)~_*hCA_19qk9u8JI
z@~3cmhrnqbjb;{(ZFx`48gUeaNbY^=k#r+8c}9|dvoMBS-=wekNF{}L)-77o1XKO4
zG6x9<*J{Bc<?hn@!$wL8l}9KWagr*JPsaXzBf!V(C7-n^v+oDZSN7S5A52DC)~3EM
H@@xJB&e%D9

diff --git a/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset/style.json b/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset/style.json
index b9623279d23..4817d45a2c4 100644
--- a/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset/style.json
+++ b/test/integration/render-tests/text-variable-anchor/all-anchors-two-dimentional-offset/style.json
@@ -2,8 +2,8 @@
   "version": 8,
   "metadata": {
     "test": {
-      "height": 256,
-      "width": 256
+      "height": 128,
+      "width": 128
     }
   },
   "center": [ 0, 0 ],
diff --git a/test/integration/render-tests/text-variable-anchor/text-allow-overlap/expected.png b/test/integration/render-tests/text-variable-anchor/text-allow-overlap/expected.png
index 2df9b51e027e0c57a138399be0934ee882ad0702..418206d25acbac03f0643ae13d8ae76de98ff960 100644
GIT binary patch
literal 1094
zcmeAS@N?(olHy`uVBq!ia0vp^4Is?H1|$#LC7xzrVBz(2aSW+oe0#9A<N8-d_7B(Z
ze&1u2o5ep{S2X01u~?P+v`yCz++KR5r`JiTx?$s1-IJRdZLMCMoEB1_%6~!W1*4l<
z@|48$0YbJrw%ug5_FD5{;|G)U)VT8N^84-keqYyqciQg#b#E79z!jgRI{S|aojG*7
zExM)KK=QqYOZTQN4~u+`r2p96#&@S*c!QVYtf{H8W{Y^QKR!OAA#_HcZ-tAaR;uIy
z>laSyQ5QN-ZxBEIp|L6C)MozQ7h8=#7V{*S{##~n_S6@ZxC0Vf9^~3AaX5R*gfW=c
zQgE`!ilBLFcREyWbj{5;USZQ*$GUP#y5YNP8)W_;P&#v1ZqHJMshfO`?w!%L|B+sf
ztM)EK_SqYP6}3`#irxJo5S}o<P4|V1^|6PQUo;&iZz@R?vOAD=_%F-mi`~x+G?ZZA
z(SN6<^P&pu{0=(G7%bsTf9NA~;JMp%{*4lsH!|0@^&D23)0X=p*m!D{RQK$SJjEYG
z__B9Me1BN7r>(zton%Ds{YM#l)-2@Q{#ecDpz)9Svogc{*$d729_IY<bGFVq;CZ7V
zyvK*Xs^`q^3Yo_Rl42P@ME^C2*>ud!S`id4znFFZft)>kt1t9k-@p`aRb)G(^YKQJ
zY}uW<8OLjUj@55u3;tm6?$83MRab6{opDotmZ(^@ktw?8Op(m`MEz@4MSov7nm<dj
zv-*%9(_5RhDk#5wBeQrC*Q^44IfJ6?jUv?-^PbopWvJ`)lsIBq5!$<T#eT+`$G<PW
z+ijY$gVFT*ntOeRwYEH*|Kjlb!oFWGk9d7aHfAf7O<S?iYj13~_eNgv1fFNfYG#ib
zswBFr4fv%$xR)$qe!NkT8RY)-$NCwEdn@?fFP4_gIO_IwgUsm-(x*Slzd2MnqgnRH
zbfB{@bM9c?{DCFU)&ARJ@mLGV+aKp$EM@!Gvv?!hYm=Iek3S@rJ>Y#4Xsr9{C3}Ui
z{$o!WvlQ8532gh!e%;z2xBKIYhwqN)`5ciDgoDM4f~K9E(Yo=4>79);dc)p?cX&mH
zJrav)n*L#B+v5##)036v9bLd=qJ28*%`u*s_Arw~R<Q>H?~XS(g`E1ty6thyoHl<0
z-t7xTuRo{+B`WQ{gZ_r%-3FZfiKf3qmjo><FBJ1T%93+b^u}6X;@l#Bo9AZhTdokz
z%RzrQeP0|8kvXE)x^l{M5t|12MBaJFn9dwct62g}jWVsKFAiz%kXrvZ<;?MtoCDLj
z0yR(PZxH%jsCv&`zG{QO+#hWES}sdvM8%T%uRShwwsY3scS!t3k25Se;-=lMZdW*V
WCn!rJB?VYMFnGH9xvX<aXaWE_vg$Da

literal 1396
zcmeAS@N?(olHy`uVBq!ia0y~yU<5K5893O0R7}x|GzJD%Yfl%)kP61P2cu8SXJtI_
z@cHk5_orPB3eKJ?d`DopNU`(jiIO{(DI0Y;DOo#Anfl0!nSZIH`s#^srok&Xv=oCn
zHBvKGXLMZMG)s+FHmzdDsb@x}#d)tE?UvYmw`cE<fAicYsdx@Xlp^nw;&ZQibAime
zZOcP{2=pDXHR3WhQu|z>$9Ht{kC~C)g}i+So*GGAHd4EuEc@)?=L%cCgHIzmtUowQ
z_ICE1^t;n68qp@HbJ+4m)8~TyJ;z**J=4rN%r&QJd$Rhv1O6!?%Tjyt4y-q1H{KzA
zfBMCl(+sUx+;6@uouR+jc;d#Hhf*!LXMfNTdz^5mN7hJ6SaP;;;nc|0AB)!<I$0r8
zKjq?#6EkF5R~MS>YuDb$S-eq5{Q;ki)?$N+hC5lbKQf#<9-NkYz)0tq;||f=PgC=~
zj-{|ZdtA3>`*QOn&TWsx-k=9M<LnaxXCM5vkURe%bGPrqkU34uKkEO!o?W0O_DC>i
z`)$XFR^g8d+fFa=N$KD_GQCjF?|}Y?rbzi?<sZ`Sbhf{V?=E1q>timM9U1(?YF`WM
z4$1%19A{2btYQm)SUIQ9f5ujc_yf`f!g<^C&5{<^7VED&>}bKheCAiV8ZP4>dU8__
z&O8xd+akG#*}Fj8u6ybZVeto+)%nVOM;}^9XTROc8`1OBLa6?@l+FSE0@bpU4}4Ni
zm?dyddzdn(aqSKU={K{lTHINq8<G9~?E$wnM?53?mj2+@I}&W<AuPE``~!zw2kVSO
zS9e_77u~&iBWw5D-Rc{J-yf=ZbLi-gxjff;c<%b`dGSAa<MeBK)weX8&2*j1B=nBk
z{NcR)(R0t`4?2fkZ!~_r(dxa?gDqRhxs21Ui~S?xnS(_#-K7<`3}ia;AE(@D@lTeV
z_9$V^VL!<^ojg}x{$P9d(CALn?+rrUhT^Yz4rk42KO51z|B>Mye)R`}e<In^m7Ggh
z_H{n~5L_c_y@5A+Bh&E*iGR-i`zlr=$ezHv&ipl_Owaa2#=8FFsR3yz9dWJp56tc~
zh`%YbeU>2jFZ=)OcIl0h_M4XHKQxr-vP6s0PeQYRNu={}fx@<1msf9ODc<PomZ+3m
zB)G4s|H1Z(Lu(EfD4#pJ@P}yG$<z0?^qh>!Ii?iTwR6THRtw(qkEPyB2?QoFo9_0H
zd2>4IA7#|=78e@kO$DaA8##xxKZea|37yd||CsB|1fY<_-R|IzYBEi}7V@)GK`DFN
z1IOLAZSAQgYDRA9kBes<;*)7jFKF*M1<VE&G2Pdbc<VYZ7YJQ@EDuWClfx5u!yc5y
zbnGtRnU<`Wcc|Ei3n<$EP$}nddV&15WaV=QjP`WgKcV51qN8RZ-2d1uCVjj5M$!KV
lH%Ih8R~>vs$lfpZvz+e)&8|tg4J=I=JYD@<);T3K0RY`~VXOcE

diff --git a/test/integration/render-tests/text-variable-anchor/text-allow-overlap/style.json b/test/integration/render-tests/text-variable-anchor/text-allow-overlap/style.json
index 3fe9e73524a..ac5402a1d56 100644
--- a/test/integration/render-tests/text-variable-anchor/text-allow-overlap/style.json
+++ b/test/integration/render-tests/text-variable-anchor/text-allow-overlap/style.json
@@ -2,8 +2,8 @@
   "version": 8,
   "metadata": {
     "test": {
-      "height": 256,
-      "width": 256
+      "height": 128,
+      "width": 128
     }
   },
   "center": [ 0, 0 ],

From 36f7a13a0e4791e382b763aefce49014eac9880a Mon Sep 17 00:00:00 2001
From: Mikhail Pozdnyakov <mikhail.pozdnyakov@mapbox.com>
Date: Wed, 28 Aug 2019 11:27:30 +0300
Subject: [PATCH 6/8] Update text-offset description

---
 src/style-spec/reference/v8.json | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/style-spec/reference/v8.json b/src/style-spec/reference/v8.json
index bc24f38ce0d..2853b23c70d 100644
--- a/src/style-spec/reference/v8.json
+++ b/src/style-spec/reference/v8.json
@@ -1922,7 +1922,7 @@
             ]
         }
       ],
-      "doc": "To increase the chance of placing high-priority labels on the map, you can provide an array of `text-anchor` locations: the render will attempt to place the label at each location, in order, before moving onto the next label. Use `text-justify: auto` to choose justification based on anchor position. To apply an offset, use the `text-radial-offset` instead of the two-dimensional `text-offset`.",
+      "doc": "To increase the chance of placing high-priority labels on the map, you can provide an array of `text-anchor` locations: the render will attempt to place the label at each location, in order, before moving onto the next label. Use `text-justify: auto` to choose justification based on anchor position. To apply an offset, use the `text-radial-offset` or the two-dimensional `text-offset`.",
       "sdk-support": {
         "basic functionality": {
           "js": "0.54.0",
@@ -2214,7 +2214,7 @@
     },
     "text-offset": {
       "type": "array",
-      "doc": "Offset distance of text from its anchor. Positive values indicate right and down, while negative values indicate left and up. Note that in combination with `text-variable-anchor` only positive values are allowed and they indicate radial offsets along x- and y-axis accordingly.",
+      "doc": "Offset distance of text from its anchor. Positive values indicate right and down, while negative values indicate left and up. Note that in combination with `text-variable-anchor` absolute values are used and they indicate radial offsets along x- and y-axis accordingly.",
       "value": "number",
       "units": "ems",
       "length": 2,

From 833ccda3b4adaecda5e55fc58d1837962e39bd75 Mon Sep 17 00:00:00 2001
From: Mikhail Pozdnyakov <mikhail.pozdnyakov@mapbox.com>
Date: Thu, 29 Aug 2019 18:20:53 +0300
Subject: [PATCH 7/8] radialText... rename

---
 src/data/array_types.js              | 12 ++++++------
 src/data/bucket/symbol_attributes.js |  2 +-
 src/render/draw_symbol.js            | 14 +++++++-------
 src/style-spec/reference/v8.json     |  2 +-
 src/symbol/placement.js              | 18 +++++++++---------
 src/symbol/symbol_layout.js          | 18 +++++++++---------
 6 files changed, 33 insertions(+), 33 deletions(-)

diff --git a/src/data/array_types.js b/src/data/array_types.js
index 0c93b343c23..31138acba54 100644
--- a/src/data/array_types.js
+++ b/src/data/array_types.js
@@ -949,8 +949,8 @@ class SymbolInstanceStruct extends Struct {
     numIconVertices: number;
     crossTileID: number;
     textBoxScale: number;
-    radialTextOffset0: number;
-    radialTextOffset1: number;
+    textOffset0: number;
+    textOffset1: number;
     get anchorX() { return this._structArray.int16[this._pos2 + 0]; }
     set anchorX(x: number) { this._structArray.int16[this._pos2 + 0] = x; }
     get anchorY() { return this._structArray.int16[this._pos2 + 1]; }
@@ -989,10 +989,10 @@ class SymbolInstanceStruct extends Struct {
     set crossTileID(x: number) { this._structArray.uint32[this._pos4 + 9] = x; }
     get textBoxScale() { return this._structArray.float32[this._pos4 + 10]; }
     set textBoxScale(x: number) { this._structArray.float32[this._pos4 + 10] = x; }
-    get radialTextOffset0() { return this._structArray.float32[this._pos4 + 11]; }
-    set radialTextOffset0(x: number) { this._structArray.float32[this._pos4 + 11] = x; }
-    get radialTextOffset1() { return this._structArray.float32[this._pos4 + 12]; }
-    set radialTextOffset1(x: number) { this._structArray.float32[this._pos4 + 12] = x; }
+    get textOffset0() { return this._structArray.float32[this._pos4 + 11]; }
+    set textOffset0(x: number) { this._structArray.float32[this._pos4 + 11] = x; }
+    get textOffset1() { return this._structArray.float32[this._pos4 + 12]; }
+    set textOffset1(x: number) { this._structArray.float32[this._pos4 + 12] = x; }
 }
 
 SymbolInstanceStruct.prototype.size = 52;
diff --git a/src/data/bucket/symbol_attributes.js b/src/data/bucket/symbol_attributes.js
index 420a7c60bc6..bf78d74a098 100644
--- a/src/data/bucket/symbol_attributes.js
+++ b/src/data/bucket/symbol_attributes.js
@@ -96,7 +96,7 @@ export const symbolInstance = createLayout([
     {type: 'Uint16', name: 'numIconVertices'},
     {type: 'Uint32', name: 'crossTileID'},
     {type: 'Float32', name: 'textBoxScale'},
-    {type: 'Float32', components: 2, name: 'radialTextOffset'}
+    {type: 'Float32', components: 2, name: 'textOffset'}
 ]);
 
 export const glyphOffset = createLayout([
diff --git a/src/render/draw_symbol.js b/src/render/draw_symbol.js
index 96618fd5863..e27937449a7 100644
--- a/src/render/draw_symbol.js
+++ b/src/render/draw_symbol.js
@@ -16,7 +16,7 @@ import {addDynamicAttributes} from '../data/bucket/symbol_bucket';
 
 import {getAnchorAlignment, WritingMode} from '../symbol/shaping';
 import ONE_EM from '../symbol/one_em';
-import {evaluateRadialOffset} from '../symbol/symbol_layout';
+import {evaluateVariableOffset} from '../symbol/symbol_layout';
 
 import {
     symbolIconUniformValues,
@@ -86,14 +86,14 @@ function drawSymbols(painter: Painter, sourceCache: SourceCache, layer: SymbolSt
     }
 }
 
-function calculateVariableRenderShift(anchor, width, height, radialOffset, textBoxScale, renderTextSize): Point {
+function calculateVariableRenderShift(anchor, width, height, textOffset, textBoxScale, renderTextSize): Point {
     const {horizontalAlign, verticalAlign} = getAnchorAlignment(anchor);
     const shiftX = -(horizontalAlign - 0.5) * width;
     const shiftY = -(verticalAlign - 0.5) * height;
-    const offset = evaluateRadialOffset(anchor, radialOffset);
+    const variableOffset = evaluateVariableOffset(anchor, textOffset);
     return new Point(
-        (shiftX / textBoxScale + offset[0]) * renderTextSize,
-        (shiftY / textBoxScale + offset[1]) * renderTextSize
+        (shiftX / textBoxScale + variableOffset[0]) * renderTextSize,
+        (shiftY / textBoxScale + variableOffset[1]) * renderTextSize
     );
 }
 
@@ -120,10 +120,10 @@ function updateVariableAnchors(bucket, rotateWithMap, pitchWithMap, variableOffs
                 renderTextSize *= bucket.tilePixelRatio / tileScale;
             }
 
-            const {width, height, radialOffset, textBoxScale} = variableOffset;
+            const {width, height, anchor, textOffset, textBoxScale} = variableOffset;
 
             const shift = calculateVariableRenderShift(
-                variableOffset.anchor, width, height, radialOffset, textBoxScale, renderTextSize);
+                anchor, width, height, textOffset, textBoxScale, renderTextSize);
 
             // Usual case is that we take the projected anchor and add the pixel-based shift
             // calculated above. In the (somewhat weird) case of pitch-aligned text, we add an equivalent
diff --git a/src/style-spec/reference/v8.json b/src/style-spec/reference/v8.json
index 2853b23c70d..6e998fd095a 100644
--- a/src/style-spec/reference/v8.json
+++ b/src/style-spec/reference/v8.json
@@ -2214,7 +2214,7 @@
     },
     "text-offset": {
       "type": "array",
-      "doc": "Offset distance of text from its anchor. Positive values indicate right and down, while negative values indicate left and up. Note that in combination with `text-variable-anchor` absolute values are used and they indicate radial offsets along x- and y-axis accordingly.",
+      "doc": "Offset distance of text from its anchor. Positive values indicate right and down, while negative values indicate left and up. If used with text-variable-anchor, input values will be taken as absolute values. Offsets along the x- and y-axis will be applied automatically based on the anchor position.",
       "value": "number",
       "units": "ems",
       "length": 2,
diff --git a/src/symbol/placement.js b/src/symbol/placement.js
index 3dded19cb5e..8b9a65216a7 100644
--- a/src/symbol/placement.js
+++ b/src/symbol/placement.js
@@ -4,7 +4,7 @@ import CollisionIndex from './collision_index';
 import EXTENT from '../data/extent';
 import * as symbolSize from './symbol_size';
 import * as projection from './projection';
-import {getAnchorJustification, evaluateRadialOffset} from './symbol_layout';
+import {getAnchorJustification, evaluateVariableOffset} from './symbol_layout';
 import {getAnchorAlignment, WritingMode} from './shaping';
 import assert from 'assert';
 import pixelsToTileUnits from '../source/pixels_to_tile_units';
@@ -117,11 +117,11 @@ class CollisionGroups {
     }
 }
 
-function calculateVariableLayoutOffset(anchor: TextAnchor, width: number, height: number, radialOffset: [number, number], textBoxScale: number): Point {
+function calculateVariableLayoutShift(anchor: TextAnchor, width: number, height: number, textOffset: [number, number], textBoxScale: number): Point {
     const {horizontalAlign, verticalAlign} = getAnchorAlignment(anchor);
     const shiftX = -(horizontalAlign - 0.5) * width;
     const shiftY = -(verticalAlign - 0.5) * height;
-    const offset = evaluateRadialOffset(anchor, radialOffset);
+    const offset = evaluateVariableOffset(anchor, textOffset);
     return new Point(
         shiftX + offset[0] * textBoxScale,
         shiftY + offset[1] * textBoxScale
@@ -149,7 +149,7 @@ function shiftVariableCollisionBox(collisionBox: SingleCollisionBox,
 }
 
 export type VariableOffset = {
-    radialOffset: [number, number],
+    textOffset: [number, number],
     width: number,
     height: number,
     anchor: TextAnchor,
@@ -239,8 +239,8 @@ export class Placement {
                            pitchWithMap: boolean, textPixelRatio: number, posMatrix: mat4, collisionGroup: CollisionGroup,
                            textAllowOverlap: boolean, symbolInstance: SymbolInstance, bucket: SymbolBucket, orientation: number): ?{ box: Array<number>, offscreen: boolean }  {
 
-        const radialOffset = [symbolInstance.radialTextOffset0, symbolInstance.radialTextOffset1];
-        const shift = calculateVariableLayoutOffset(anchor, width, height, radialOffset, textBoxScale);
+        const textOffset = [symbolInstance.textOffset0, symbolInstance.textOffset1];
+        const shift = calculateVariableLayoutShift(anchor, width, height, textOffset, textBoxScale);
 
         const placedGlyphBoxes = this.collisionIndex.placeCollisionBox(
             shiftVariableCollisionBox(
@@ -260,7 +260,7 @@ export class Placement {
             }
             assert(symbolInstance.crossTileID !== 0);
             this.variableOffsets[symbolInstance.crossTileID] = {
-                radialOffset,
+                textOffset,
                 width,
                 height,
                 anchor,
@@ -812,10 +812,10 @@ export class Placement {
                                 // successfully placed position (so you can visualize what collision
                                 // just made the symbol disappear, and the most likely place for the
                                 // symbol to come back)
-                                shift = calculateVariableLayoutOffset(variableOffset.anchor,
+                                shift = calculateVariableLayoutShift(variableOffset.anchor,
                                    variableOffset.width,
                                    variableOffset.height,
-                                   variableOffset.radialOffset,
+                                   variableOffset.textOffset,
                                    variableOffset.textBoxScale);
                                 if (rotateWithMap) {
                                     shift._rotate(pitchWithMap ? this.transform.angle : -this.transform.angle);
diff --git a/src/symbol/symbol_layout.js b/src/symbol/symbol_layout.js
index 635e286599f..3891454af04 100644
--- a/src/symbol/symbol_layout.js
+++ b/src/symbol/symbol_layout.js
@@ -64,7 +64,7 @@ export type TextAnchor = 'center' | 'left' | 'right' | 'top' | 'bottom' | 'top-l
 // (see "yOffset" in shaping.js)
 const baselineOffset = 7;
 
-export function evaluateRadialOffset(anchor: TextAnchor, offset: [number, number]) {
+export function evaluateVariableOffset(anchor: TextAnchor, offset: [number, number]) {
 
     function fromRadialOffset(anchor: TextAnchor, radialOffset: number) {
         let x = 0, y = 0;
@@ -213,7 +213,7 @@ export function performSymbolLayout(bucket: SymbolBucket,
                 if (radialOffset) {
                     // The style spec says don't use `text-offset` and `text-radial-offset` together
                     // but doesn't actually specify what happens if you use both. We go with the radial offset.
-                    textOffset = evaluateRadialOffset(textAnchor, [radialOffset * ONE_EM, Number.POSITIVE_INFINITY]);
+                    textOffset = evaluateVariableOffset(textAnchor, [radialOffset * ONE_EM, Number.POSITIVE_INFINITY]);
                 } else {
                     textOffset = (layout.get('text-offset').evaluate(feature, {}).map(t => t * ONE_EM): any);
                 }
@@ -551,13 +551,13 @@ function addSymbol(bucket: SymbolBucket,
     const placedTextSymbolIndices = {};
     let key = murmur3('');
 
-    let radialTextOffset0 = 0;
-    let radialTextOffset1 = 0;
+    let textOffset0 = 0;
+    let textOffset1 = 0;
     if (layer._unevaluatedLayout.getValue('text-radial-offset') === undefined) {
-        [radialTextOffset0, radialTextOffset1] = (layer.layout.get('text-offset').evaluate(feature, {}).map(t => t * ONE_EM): any);
+        [textOffset0, textOffset1] = (layer.layout.get('text-offset').evaluate(feature, {}).map(t => t * ONE_EM): any);
     } else {
-        radialTextOffset0 = layer.layout.get('text-radial-offset').evaluate(feature, {}) * ONE_EM;
-        radialTextOffset1 = Number.POSITIVE_INFINITY;
+        textOffset0 = layer.layout.get('text-radial-offset').evaluate(feature, {}) * ONE_EM;
+        textOffset1 = Number.POSITIVE_INFINITY;
     }
 
     if (bucket.allowVerticalPlacement && shapedTextOrientations.vertical) {
@@ -671,8 +671,8 @@ function addSymbol(bucket: SymbolBucket,
         numIconVertices,
         0,
         textBoxScale,
-        radialTextOffset0,
-        radialTextOffset1);
+        textOffset0,
+        textOffset1);
 }
 
 function anchorIsTooClose(bucket: any, text: string, repeatDistance: number, anchor: Point) {

From 36dbda2259af48173276b4f2bdde02c899d0084d Mon Sep 17 00:00:00 2001
From: Mikhail Pozdnyakov <mikhail.pozdnyakov@mapbox.com>
Date: Thu, 29 Aug 2019 18:57:34 +0300
Subject: [PATCH 8/8] Introduce INVALID_TEXT_OFFSET

---
 src/symbol/symbol_layout.js | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/symbol/symbol_layout.js b/src/symbol/symbol_layout.js
index 3891454af04..cc1b44bdd99 100644
--- a/src/symbol/symbol_layout.js
+++ b/src/symbol/symbol_layout.js
@@ -63,6 +63,7 @@ export type TextAnchor = 'center' | 'left' | 'right' | 'top' | 'bottom' | 'top-l
 // We don't actually load baseline data, but we assume an offset of ONE_EM - 17
 // (see "yOffset" in shaping.js)
 const baselineOffset = 7;
+const INVALID_TEXT_OFFSET = Number.POSITIVE_INFINITY;
 
 export function evaluateVariableOffset(anchor: TextAnchor, offset: [number, number]) {
 
@@ -143,7 +144,7 @@ export function evaluateVariableOffset(anchor: TextAnchor, offset: [number, numb
         return [x, y];
     }
 
-    return (offset[1] !== Number.POSITIVE_INFINITY) ? fromTextOffset(anchor, offset[0], offset[1]) : fromRadialOffset(anchor, offset[0]);
+    return (offset[1] !== INVALID_TEXT_OFFSET) ? fromTextOffset(anchor, offset[0], offset[1]) : fromRadialOffset(anchor, offset[0]);
 }
 
 export function performSymbolLayout(bucket: SymbolBucket,
@@ -213,7 +214,7 @@ export function performSymbolLayout(bucket: SymbolBucket,
                 if (radialOffset) {
                     // The style spec says don't use `text-offset` and `text-radial-offset` together
                     // but doesn't actually specify what happens if you use both. We go with the radial offset.
-                    textOffset = evaluateVariableOffset(textAnchor, [radialOffset * ONE_EM, Number.POSITIVE_INFINITY]);
+                    textOffset = evaluateVariableOffset(textAnchor, [radialOffset * ONE_EM, INVALID_TEXT_OFFSET]);
                 } else {
                     textOffset = (layout.get('text-offset').evaluate(feature, {}).map(t => t * ONE_EM): any);
                 }
@@ -557,7 +558,7 @@ function addSymbol(bucket: SymbolBucket,
         [textOffset0, textOffset1] = (layer.layout.get('text-offset').evaluate(feature, {}).map(t => t * ONE_EM): any);
     } else {
         textOffset0 = layer.layout.get('text-radial-offset').evaluate(feature, {}) * ONE_EM;
-        textOffset1 = Number.POSITIVE_INFINITY;
+        textOffset1 = INVALID_TEXT_OFFSET;
     }
 
     if (bucket.allowVerticalPlacement && shapedTextOrientations.vertical) {