@wcardinal/wcardinal-ui 0.458.0-beta.0 → 0.458.0-beta.1

package/dist/wcardinal-ui.js

@@ -1,5 +1,5 @@
 /*
- Winter Cardinal UI v0.458.0-beta.0
+ Winter Cardinal UI v0.458.0-beta.1
  Copyright (C) 2019 Toshiba Corporation
  SPDX-License-Identifier: Apache-2.0
 
@@ -14372,12 +14372,8 @@
         });
         Object.defineProperty(EShapeLinePoints.prototype, "marker", {
             get: function () {
-                var result = this._marker;
-                if (result == null) {
-                    result = this.newMarker();
-                    this._marker = result;
-                }
-                return result;
+                var _a;
+                return ((_a = this._marker) !== null && _a !== void 0 ? _a : (this._marker = this.newMarker()));
             },
             enumerable: false,
             configurable: true
@@ -48446,7 +48442,7 @@
      * Build vertex buffer for polygons.
      * Transforms vertices from relative coordinates [-0.5, +0.5] to world coordinates.
      */
-    var buildPolygonVertex = function (vertices, polygonVertices, voffset, sizeX, sizeY, internalTransform) {
+    var buildPolygonVertex = function (vertices, polygonVertices, voffset, internalTransform) {
         var a = internalTransform.a;
         var b = internalTransform.b;
         var c = internalTransform.c;
@@ -48455,8 +48451,8 @@
         var ty = internalTransform.ty;
         var iv = (voffset << 1) - 1;
         for (var i = 0, n = polygonVertices.length; i < n; i += 2) {
-            var x = sizeX * polygonVertices[i];
-            var y = sizeY * polygonVertices[i + 1];
+            var x = polygonVertices[i];
+            var y = polygonVertices[i + 1];
             vertices[++iv] = a * x + c * y + tx;
             vertices[++iv] = b * x + d * y + ty;
         }
@@ -48465,28 +48461,26 @@
      * Build step buffer for polygons.
      * Since this is fill-only, step information is minimal.
      */
-    var buildPolygonStep = function (steps, polygonDistances, polygonClippings, voffset, vertexCount, sizeX, sizeY, strokeWidth, strokeSide, strokeStyle) {
+    var buildPolygonStep = function (steps, polygonDistances, polygonClippings, voffset, vertexCount, strokeWidth, strokeSide, strokeStyle) {
         var scaleInvariant = toScaleInvariant(strokeStyle);
         var w = (strokeSide & EShapeStrokeSide.ALL) === EShapeStrokeSide.ALL ? 1 : 0;
         var e = toPackedI4x64(0, scaleInvariant, w, w);
         var is = voffset * 6 - 1;
-        for (var i = 0, j = 0; i < vertexCount; i += 1, j += 2) {
-            var dx = sizeX * polygonDistances[j];
-            var dy = sizeY * polygonDistances[j + 1];
+        for (var i = 0; i < vertexCount; i += 1) {
+            var d = polygonDistances[i];
             var c = polygonClippings[i];
             steps[++is] = strokeWidth;
             steps[++is] = e;
-            steps[++is] = dx;
-            steps[++is] = dy;
+            steps[++is] = d;
+            steps[++is] = d;
             steps[++is] = toPackedF2x1024(c, c);
             steps[++is] = 0;
         }
     };
     /**
      * Build UV buffer for polygons.
-     * Transforms vertices from relative coordinates [-0.5, +0.5] to UV coordinates.
      */
-    var buildPolygonUv = function (uvs, polygonVertices, voffset, textureUvs) {
+    var buildPolygonUv = function (uvs, polygonUvs, voffset, textureUvs) {
         var x0 = textureUvs.x0;
         var x1 = textureUvs.x1;
         var y0 = textureUvs.y0;
@@ -48494,9 +48488,9 @@
         var dx = x1 - x0;
         var dy = y3 - y0;
         var iuv = (voffset << 1) - 1;
-        for (var i = 0, n = polygonVertices.length; i < n; i += 2) {
-            uvs[++iuv] = x0 + (0.5 + polygonVertices[i]) * dx;
-            uvs[++iuv] = y0 + (0.5 + polygonVertices[i + 1]) * dy;
+        for (var i = 0, n = polygonUvs.length; i < n; i += 2) {
+            uvs[++iuv] = x0 + polygonUvs[i] * dx;
+            uvs[++iuv] = y0 + polygonUvs[i + 1] * dy;
         }
     };
 
@@ -48894,14 +48888,10 @@
          * Creates an UtilPolygon instance.
          *
          * @param points points
-         * @param sx the scale along X axis
-         * @param sy the scale along Y axis
          * @param epsilon threshold
          * @returns a created UtilPolygon instance
          */
-        UtilPolygon.from = function (points, sx, sy, epsilon) {
-            if (sx === void 0) { sx = 1; }
-            if (sy === void 0) { sy = 1; }
+        UtilPolygon.from = function (points, epsilon) {
             if (epsilon === void 0) { epsilon = 1e-5; }
             var pointsLength = points.length;
             if (pointsLength <= 0) {
@@ -48910,11 +48900,11 @@
             var tmp = new UtilPolygon(epsilon);
             var p = tmp.points;
             var n = tmp.normals;
-            var npx = sx * points[0];
-            var npy = sy * points[1];
+            var npx = points[0];
+            var npy = points[1];
             for (var i = pointsLength - 2; 0 <= i; i -= 2) {
-                var px = sx * points[i];
-                var py = sy * points[i + 1];
+                var px = points[i];
+                var py = points[i + 1];
                 var dx = npx - px;
                 var dy = npy - py;
                 if (Math.abs(dx) <= epsilon && Math.abs(dy) < epsilon) {
@@ -49517,13 +49507,11 @@
     var UtilStraightSkeleton = /** @class */ (function () {
         function UtilStraightSkeleton() {
         }
-        UtilStraightSkeleton.from = function (points, sx, sy, level, epsilon) {
-            if (sx === void 0) { sx = 1; }
-            if (sy === void 0) { sy = 1; }
+        UtilStraightSkeleton.from = function (points, level, epsilon) {
             if (level === void 0) { level = -1; }
             if (epsilon === void 0) { epsilon = 1e-5; }
             var result = [];
-            var polygons = UtilPolygon.from(points, sx, sy, epsilon);
+            var polygons = UtilPolygon.from(points, epsilon);
             for (var i = 0, imax = polygons.length; i < imax; ++i) {
                 var wavefront = UtilStraightSkeletonWavefront.from(polygons[i], epsilon);
                 if (level < 0 || 0 < level) {
@@ -49593,7 +49581,7 @@
                 var points = wavefront.points;
                 vertices.push(points[index], points[index + 1]);
                 var distance = wavefront.distance;
-                this._distances.push(distance, distance);
+                this._distances.push(distance);
                 return result;
             }
             else {
@@ -49607,7 +49595,7 @@
                 var points = wavefront.points;
                 vertices.push(points[index], points[index + 1]);
                 var distance = wavefront.distance;
-                this._distances.push(distance, distance);
+                this._distances.push(distance);
                 return result;
             }
         };
@@ -49631,23 +49619,21 @@
                 return;
             }
             var mdistance = distances[oldDistancesLength];
-            for (var i = oldDistancesLength + 1; i < newDistancesLength; i += 2) {
+            for (var i = oldDistancesLength + 1; i < newDistancesLength; ++i) {
                 mdistance = Math.max(mdistance, distances[i]);
             }
             var clippings = this._clippings;
             if (0 < mdistance) {
                 var fdistance = 1 / mdistance;
-                for (var i = oldDistancesLength; i < newDistancesLength; i += 2) {
+                for (var i = oldDistancesLength; i < newDistancesLength; ++i) {
                     clippings.push(1 - distances[i] * fdistance);
                     distances[i] = mdistance;
-                    distances[i + 1] = mdistance;
                 }
             }
             else {
-                for (var i = oldDistancesLength; i < newDistancesLength; i += 2) {
+                for (var i = oldDistancesLength; i < newDistancesLength; ++i) {
                     clippings.push(1);
                     distances[i] = mdistance;
-                    distances[i + 1] = mdistance;
                 }
             }
         };
@@ -49780,13 +49766,12 @@
         function EShapePolygonTriangulatedImpl(parent) {
             this._id = 0;
             this._parent = parent;
-            this._parentVertexId = -1;
-            this._parentWidth = -1;
-            this._parentHeight = -1;
+            this._parentPointsId = -1;
             this._vertices = [];
             this._nvertices = 0;
             this._distances = [];
             this._clippings = [];
+            this._uvs = [];
             this._indices = [];
             this._nindices = 0;
         }
@@ -49830,6 +49815,14 @@
             enumerable: false,
             configurable: true
         });
+        Object.defineProperty(EShapePolygonTriangulatedImpl.prototype, "uvs", {
+            get: function () {
+                this.triangulate();
+                return this._uvs;
+            },
+            enumerable: false,
+            configurable: true
+        });
         Object.defineProperty(EShapePolygonTriangulatedImpl.prototype, "indices", {
             get: function () {
                 this.triangulate();
@@ -49846,20 +49839,11 @@
             enumerable: false,
             configurable: true
         });
-        EShapePolygonTriangulatedImpl.prototype.set = function (parentVertexId, parentWidth, parentHeight, vertices, distances, clippings, indices) {
+        EShapePolygonTriangulatedImpl.prototype.set = function (parentPointsId, vertices, distances, clippings, uvs, indices) {
             var isChanged = false;
             // Parent Vertex ID
-            if (parentVertexId != null) {
-                this._parentVertexId = parentVertexId;
-                isChanged = true;
-            }
-            // Parent Size
-            if (parentWidth != null) {
-                this._parentWidth = parentWidth;
-                isChanged = true;
-            }
-            if (parentHeight != null) {
-                this._parentHeight = parentHeight;
+            if (parentPointsId != null) {
+                this._parentPointsId = parentPointsId;
                 isChanged = true;
             }
             // Vertices
@@ -49896,6 +49880,17 @@
                 }
                 isChanged = true;
             }
+            // UVs
+            if (uvs != null) {
+                var uvsLength = uvs.length;
+                for (var i = 0; i < uvsLength; ++i) {
+                    this._uvs[i] = uvs[i];
+                }
+                if (this._uvs.length !== uvsLength) {
+                    this._uvs.length = uvsLength;
+                }
+                isChanged = true;
+            }
             // Indices
             if (indices != null) {
                 var indicesLength = indices.length;
@@ -49916,45 +49911,37 @@
         };
         EShapePolygonTriangulatedImpl.prototype.triangulate = function () {
             var parent = this._parent;
-            var parentVertexId = parent.vertexId;
-            var isVertexIdChanged = this._parentVertexId !== parentVertexId;
-            var parentSize = parent.size;
-            var parentWidth = parentSize.x;
-            var parentHeight = parentSize.y;
-            var threshold = 0.00001;
-            var isWidthChanged = threshold < Math.abs(this._parentWidth - parentWidth);
-            var isHeightChanged = threshold < Math.abs(this._parentHeight - parentHeight);
-            if (isVertexIdChanged || isWidthChanged || isHeightChanged) {
-                this._parentVertexId = parentVertexId;
-                this._parentWidth = parentWidth;
-                this._parentHeight = parentHeight;
-                if (0 < Math.abs(parentWidth) && 0 < Math.abs(parentHeight)) {
-                    var buffer = UtilStraightSkeletonBuffer.from(UtilStraightSkeleton.from(this._parent.vertices, parentWidth, parentHeight));
-                    var vertices = buffer.vertices;
-                    var verticesLength = vertices.length;
-                    var distances = buffer.distances;
-                    var fx = 1 / parentWidth;
-                    var fy = 1 / parentHeight;
-                    for (var i = 0; i < verticesLength; i += 2) {
-                        vertices[i] *= fx;
-                        vertices[i + 1] *= fy;
-                        distances[i] *= fx;
-                        distances[i + 1] *= fy;
-                    }
-                    this._id += 1;
-                    this._vertices = vertices;
-                    this._nvertices = vertices.length >> 1;
-                    this._distances = distances;
-                    this._clippings = buffer.clippings;
-                    this._indices = buffer.indices;
-                    this._nindices = buffer.indices.length / 3;
-                }
+            var parentPoints = parent.points;
+            var parentPointsId = parentPoints.id;
+            var isParentIdChanged = this._parentPointsId !== parentPointsId;
+            if (isParentIdChanged) {
+                this._parentPointsId = parentPointsId;
+                var buffer = UtilStraightSkeletonBuffer.from(UtilStraightSkeleton.from(parentPoints.values));
+                this._id += 1;
+                this._vertices = buffer.vertices;
+                this._nvertices = buffer.vertices.length >> 1;
+                this._distances = buffer.distances;
+                this._clippings = buffer.clippings;
+                this._uvs = this.toUvs(buffer.vertices);
+                this._indices = buffer.indices;
+                this._nindices = buffer.indices.length / 3;
             }
         };
+        EShapePolygonTriangulatedImpl.prototype.toUvs = function (vertices) {
+            var result = [];
+            var size = this._parent.size;
+            var ax = Math.abs(size.x);
+            var ay = Math.abs(size.y);
+            var fx = 0 < ax ? 1 / ax : 0;
+            var fy = 0 < ay ? 1 / ay : 0;
+            var verticesLength = vertices.length;
+            for (var i = 0; i < verticesLength; i += 2) {
+                result.push(0.5 + vertices[i] * fx, 0.5 + vertices[i + 1] * fy);
+            }
+            return result;
+        };
         EShapePolygonTriangulatedImpl.prototype.copy = function (source) {
-            var parent = this._parent;
-            var parentSize = parent.size;
-            this.set(parent.vertexId, parentSize.x, parentSize.y, source.vertices, source.distances, source.clippings, source.indices);
+            this.set(this._parent.points.id, source.vertices, source.distances, source.clippings, source.uvs, source.indices);
             return this;
         };
         EShapePolygonTriangulatedImpl.prototype.serialize = function (manager) {
@@ -49963,6 +49950,7 @@
                 manager.addResource(JSON.stringify(this._vertices)),
                 manager.addResource(JSON.stringify(this._distances)),
                 manager.addResource(JSON.stringify(this._clippings)),
+                manager.addResource(JSON.stringify(this._uvs)),
                 manager.addResource(JSON.stringify(this._indices))
             ];
             return manager.addResource(JSON.stringify(serialized));
@@ -49976,13 +49964,8 @@
                     parsed = JSON.parse(resources[resourceId]);
                     manager.setExtension(resourceId, parsed);
                 }
-                // Parent Vertex Id
-                var parent_1 = this._parent;
-                this._parentVertexId = parent_1.vertexId;
-                // Parent Size
-                var parentSize = parent_1.size;
-                this._parentWidth = parentSize.x;
-                this._parentHeight = parentSize.y;
+                // Parent Points Id
+                this._parentPointsId = this._parent.points.id;
                 // Vertices
                 var vertexId = parsed[0];
                 if (0 <= vertexId && vertexId < resourcesLength) {
@@ -50014,8 +49997,18 @@
                     }
                     this._clippings = clippings;
                 }
+                // UVs
+                var uvId = parsed[3];
+                if (0 <= uvId && uvId < resourcesLength) {
+                    var uvs = manager.getExtension(uvId);
+                    if (uvs == null) {
+                        uvs = JSON.parse(resources[uvId]);
+                        manager.setExtension(uvId, uvs);
+                    }
+                    this._uvs = uvs;
+                }
                 // Indices
-                var indexId = parsed[3];
+                var indexId = parsed[4];
                 if (0 <= indexId && indexId < resourcesLength) {
                     var indices = manager.getExtension(indexId);
                     if (indices == null) {
@@ -50045,20 +50038,16 @@
      * @param ay a polygon height
      * @returns the minimum squared distance between the given point (x, y) and the polygon edges
      */
-    var calcPolygonSquaredDistance = function (shape, x, y, ax, ay) {
-        var vertices = shape.vertices;
-        var verticesLength = vertices.length;
-        if (verticesLength < 4) {
+    var calcPolygonSquaredDistance = function (values, valuesLength, x, y) {
+        if (valuesLength < 4) {
             return Infinity;
         }
         var result = Infinity;
-        var sx = 2 * ax;
-        var sy = 2 * ay;
-        var pvx = vertices[verticesLength - 2] * sx;
-        var pvy = vertices[verticesLength - 1] * sy;
-        for (var i = 0; i < verticesLength; i += 2) {
-            var vx = vertices[i] * sx;
-            var vy = vertices[i + 1] * sy;
+        var pvx = values[valuesLength - 2];
+        var pvy = values[valuesLength - 1];
+        for (var i = 0; i < valuesLength; i += 2) {
+            var vx = values[i];
+            var vy = values[i + 1];
             var dvx = vx - pvx;
             var dvy = vy - pvy;
             var dv = dvx * dvx + dvy * dvy;
@@ -50088,31 +50077,29 @@
         if (!filled && sw <= 0) {
             return false;
         }
-        var vertices = shape.vertices;
-        var verticesLength = vertices.length;
-        if (6 <= verticesLength) {
+        var values = shape.points.values;
+        var valuesLength = values.length;
+        if (6 <= valuesLength) {
             if (0 < ax && 0 < ay) {
                 var count = 0;
-                var nx = 0.5 * (x / ax);
-                var ny = 0.5 * (y / ay);
-                var ppvy = vertices[verticesLength - 3];
-                var pvx = vertices[verticesLength - 2];
-                var pvy = vertices[verticesLength - 1];
-                for (var i = 0; i < verticesLength; i += 2) {
-                    var vx = vertices[i];
-                    var vy = vertices[i + 1];
-                    if ((pvy <= ny && ny < vy) || (ny <= pvy && vy < ny)) {
+                var ppvy = values[valuesLength - 3];
+                var pvx = values[valuesLength - 2];
+                var pvy = values[valuesLength - 1];
+                for (var i = 0; i < valuesLength; i += 2) {
+                    var vx = values[i];
+                    var vy = values[i + 1];
+                    if ((pvy <= y && y < vy) || (y <= pvy && vy < y)) {
                         var dy = vy - pvy;
                         var t = 0;
                         if (0 < Math.abs(dy)) {
-                            t = (ny - pvy) / dy;
+                            t = (y - pvy) / dy;
                         }
                         var cx = pvx + t * (vx - pvx);
-                        if (nx <= cx) {
+                        if (x <= cx) {
                             if (t <= 0) {
                                 // Since we could be just grazing vertices,
                                 // we need to check if the second-previous vertex is on the opposite side.
-                                if ((ppvy <= ny && ny < vy) || (ny <= ppvy && vy < ny)) {
+                                if ((ppvy <= y && y < vy) || (y <= ppvy && vy < y)) {
                                     count += 1;
                                 }
                             }
@@ -50130,7 +50117,7 @@
                         return true;
                     }
                     else {
-                        return calcPolygonSquaredDistance(shape, x, y, ax, ay) <= sw * sw;
+                        return calcPolygonSquaredDistance(values, valuesLength, x, y) <= sw * sw;
                     }
                 }
             }
@@ -50144,66 +50131,29 @@
      */
     var EShapePolygon = /** @class */ (function (_super) {
         __extends(EShapePolygon, _super);
-        /**
-         * Please note that the given arrays `vertices`, `distances`, `clippings` and `indices` are used internally.
-         * Because of this, these arrays must not be modified outside of this class after calling this constructor.
-         */
         function EShapePolygon(type) {
             if (type === void 0) { type = EShapeType.POLYGON; }
             var _this = _super.call(this, type) || this;
-            _this._vertices = [];
-            _this._nvertices = 0;
-            _this._vertexId = 0;
+            _this._points = _this.newPoints();
             _this._triangulated = _this.newTriangulated();
             return _this;
         }
+        Object.defineProperty(EShapePolygon.prototype, "points", {
+            get: function () {
+                return this._points;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        EShapePolygon.prototype.newPoints = function () {
+            return new EShapeLinePoints(this);
+        };
         EShapePolygon.prototype.newTriangulated = function () {
             return new EShapePolygonTriangulatedImpl(this);
         };
         EShapePolygon.prototype.newStroke = function () {
             return new EShapePolygonStroke(this, true, EShapeDefaults.STROKE_COLOR, EShapeDefaults.STROKE_ALPHA, EShapeDefaults.STROKE_WIDTH, EShapeDefaults.STROKE_ALIGN, EShapeDefaults.STROKE_SIDE, EShapeDefaults.STROKE_STYLE);
         };
-        Object.defineProperty(EShapePolygon.prototype, "vertices", {
-            /**
-             * Vertex positions are in [-0.5, +0.5] and relative to the shape position and size.
-             * Therefore, transformed actual vertex positions are calculated as follows:
-             *
-             * ```
-             *     const imx = this.transform.internalTransform;
-             *     const size = this.size;
-             *     const vertices = this._vertices;
-             *     const transformedVertices = [];
-             *     for (let i = 0; i < vertices.length; i += 2) {
-             *         const transformedVertex = imx.apply(
-             *             new Point(size.x * vertices[i + 0], size.y * vertices[i + 1])
-             *         );
-             *         transformedVertices.push(transformedVertex.x, transformedVertex.y);
-             *     }
-             * ```
-             */
-            get: function () {
-                return this._vertices;
-            },
-            set: function (vertices) {
-                this.set(vertices);
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(EShapePolygon.prototype, "nvertices", {
-            get: function () {
-                return this._nvertices;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(EShapePolygon.prototype, "vertexId", {
-            get: function () {
-                return this._vertexId;
-            },
-            enumerable: false,
-            configurable: true
-        });
         Object.defineProperty(EShapePolygon.prototype, "triangulated", {
             get: function () {
                 return this._triangulated;
@@ -50211,70 +50161,24 @@
             enumerable: false,
             configurable: true
         });
-        EShapePolygon.prototype.set = function (vertices) {
-            var isChanged = false;
-            if (vertices != null) {
-                var verticesLength = vertices.length;
-                for (var i = 0; i < verticesLength; ++i) {
-                    this._vertices[i] = vertices[i];
-                }
-                if (this._vertices.length !== verticesLength) {
-                    this._vertices.length = verticesLength;
-                }
-                this._nvertices = verticesLength >> 1;
-                isChanged = true;
-            }
-            if (isChanged) {
-                this._vertexId += 1;
-                this.updateUploaded();
-            }
-            return this;
-        };
         EShapePolygon.prototype.clone = function () {
             return new EShapePolygon(this.type).copy(this);
         };
-        EShapePolygon.prototype.copy = function (source) {
+        EShapePolygon.prototype.copy = function (source, part) {
+            if (part === void 0) { part = EShapeCopyPart.ALL; }
             this.lock(EShapeLockPart.ALL);
-            var result = _super.prototype.copy.call(this, source);
-            if (source instanceof EShapePolygon) {
-                // Vertex ID
-                this._vertexId += 1;
-                // Vertices
-                var sourceVertices = source._vertices;
-                var sourceVerticesLength = sourceVertices.length;
-                var vertices = this._vertices;
-                for (var i = 0; i < sourceVerticesLength; ++i) {
-                    vertices[i] = sourceVertices[i];
-                }
-                if (vertices.length !== sourceVerticesLength) {
-                    vertices.length = sourceVerticesLength;
-                }
-                // Number of Vertices
-                this._nvertices = sourceVerticesLength >> 1;
-                // Triangulated
+            var result = _super.prototype.copy.call(this, source, part);
+            if (part & EShapeCopyPart.POINTS && source instanceof EShapePolygon) {
                 this._triangulated.copy(source._triangulated);
-                // Update
-                var uploaded = this.uploaded;
-                if (uploaded) {
-                    if (uploaded.isCompatible(this)) {
-                        this.updateUploaded();
-                    }
-                    else {
-                        this.toDirty();
-                    }
-                }
-                else {
-                    this.updateUploaded();
-                }
             }
             this.unlock(EShapeLockPart.ALL, true);
             return result;
         };
         EShapePolygon.prototype.serialize = function (manager) {
             var result = _super.prototype.serialize.call(this, manager);
-            var verticesId = manager.addResource(JSON.stringify(this._vertices));
+            var pointsId = this._points.serialize(manager);
             var triangulatedId = this._triangulated.serialize(manager);
-            var serialized = [verticesId, triangulatedId];
+            var serialized = [pointsId, triangulatedId];
             result[15] = manager.addResource(JSON.stringify(serialized));
             return result;
         };
@@ -50287,34 +50191,10 @@
                     parsed = JSON.parse(resources[resourceId]);
                     manager.setExtension(resourceId, parsed);
                 }
-                // Vertex ID
-                this._vertexId += 1;
-                // Vertices
-                var verticesId = parsed[0];
-                if (0 <= verticesId && verticesId < resourcesLength) {
-                    var vertices = manager.getExtension(verticesId);
-                    if (vertices == null) {
-                        vertices = JSON.parse(resources[verticesId]);
-                        manager.setExtension(verticesId, vertices);
-                    }
-                    this._vertices = vertices;
-                    this._nvertices = vertices.length >> 1;
-                }
-                // Triangulated
+                this.lock(EShapeLockPart.ALL);
+                this._points.deserialize(parsed[0], manager);
                 this._triangulated.deserialize(parsed[1], manager);
-                // Update
-                var uploaded = this.uploaded;
-                if (uploaded) {
-                    if (uploaded.isCompatible(this)) {
-                        this.updateUploaded();
-                    }
-                    else {
-                        this.toDirty();
-                    }
-                }
-                else {
-                    this.updateUploaded();
-                }
+                this.unlock(EShapeLockPart.ALL, true);
             }
         };
         EShapePolygon.prototype.containsAbs = function (x, y, ax, ay, sw, ss, sa) {
@@ -50389,10 +50269,6 @@
             this.updateColor(buffer, shape);
         };
         BuilderPolygon.prototype.updateVertexStepUvAndIndex = function (buffer, shape) {
-            var size = shape.size;
-            var sizeX = size.x;
-            var sizeY = size.y;
-            var isSizeChanged = sizeX !== this.sizeX || sizeY !== this.sizeY;
             var transformLocalId = toTransformLocalId(shape);
             var isTransformChanged = this.transformLocalId !== transformLocalId;
             // Check if vertices/distances/clippings/indices changed
@@ -50409,16 +50285,13 @@
             var texture = toTexture(shape);
             var textureTransformId = toTextureTransformId(texture);
             var isTextureChanged = texture !== this.texture || textureTransformId !== this.textureTransformId;
-            var isVertexChanged = isSizeChanged || isTriangulatedIdChanged;
             var isNotInited = !(this.inited & BuilderFlag.VERTEX_STEP_UV_AND_INDEX);
             if (isNotInited ||
-                isVertexChanged ||
+                isTriangulatedIdChanged ||
                 isTransformChanged ||
                 isStrokeChanged ||
                 isTextureChanged) {
                 this.inited |= BuilderFlag.VERTEX_STEP_UV_AND_INDEX;
-                this.sizeX = sizeX;
-                this.sizeY = sizeY;
                 this.transformLocalId = transformLocalId;
                 this.strokeWidth = strokeWidth;
                 this.strokeSide = strokeSide;
@@ -50427,25 +50300,25 @@
                 this.textureTransformId = textureTransformId;
                 this.triangulatedId = triangulatedId;
                 // Indices
-                if (isNotInited || isVertexChanged) {
+                if (isNotInited || isTriangulatedIdChanged) {
                     buffer.updateIndices();
                     buildPolygonIndex(buffer.indices, triangulated.indices, this.vertexOffset, this.indexOffset);
                 }
                 // Vertices
                 var voffset = this.vertexOffset;
-                if (isNotInited || isVertexChanged || isTransformChanged) {
+                if (isNotInited || isTriangulatedIdChanged || isTransformChanged) {
                     buffer.updateVertices();
-                    buildPolygonVertex(buffer.vertices, triangulated.vertices, voffset, sizeX, sizeY, shape.transform.internalTransform);
+                    buildPolygonVertex(buffer.vertices, triangulated.vertices, voffset, shape.transform.internalTransform);
                 }
                 // Steps
-                if (isNotInited || isVertexChanged || isStrokeChanged) {
+                if (isNotInited || isTriangulatedIdChanged || isStrokeChanged) {
                     buffer.updateSteps();
-                    buildPolygonStep(buffer.steps, triangulated.distances, triangulated.clippings, voffset, this.vertexCount, sizeX, sizeY, strokeWidth, strokeSide, strokeStyle);
+                    buildPolygonStep(buffer.steps, triangulated.distances, triangulated.clippings, voffset, this.vertexCount, strokeWidth, strokeSide, strokeStyle);
                 }
                 // UVs
-                if (isNotInited || isVertexChanged || isTextureChanged) {
+                if (isNotInited || isTriangulatedIdChanged || isTextureChanged) {
                     buffer.updateUvs();
-                    buildPolygonUv(buffer.uvs, triangulated.vertices, voffset, toTextureUvs(texture));
+                    buildPolygonUv(buffer.uvs, triangulated.uvs, voffset, toTextureUvs(texture));
                 }
             }
         };
@@ -53012,51 +52885,41 @@
         return result;
     };
 
-    var createPolygon = function (points) {
+    var createPolygon = function (points, result) {
+        result !== null && result !== void 0 ? result : (result = new EShapePolygon());
         var pointsLength = points.length;
-        if (2 <= pointsLength) {
-            var xmin = 0;
-            var xmax = 0;
-            var ymin = 0;
-            var ymax = 0;
-            xmin = xmax = points[0];
-            ymin = ymax = points[1];
-            for (var i = 2; i < pointsLength; i += 2) {
-                var x = points[i];
-                var y = points[i + 1];
-                xmin = Math.min(xmin, x);
-                xmax = Math.max(xmax, x);
-                ymin = Math.min(ymin, y);
-                ymax = Math.max(ymax, y);
-            }
-            var sx = xmax - xmin;
-            var sy = ymax - ymin;
-            var px = xmin + 0.5 * sx;
-            var py = ymin + 0.5 * sy;
-            if (0 < Math.abs(sx) && 0 < Math.abs(sy)) {
-                var fx = 1 / sx;
-                var fy = 1 / sy;
-                var vertices = [];
-                for (var i = 0; i < pointsLength; i += 2) {
-                    vertices.push((points[i] - xmin) * fx - 0.5, (points[i + 1] - ymin) * fy - 0.5);
-                }
-                var result = new EShapePolygon();
-                result.lock(EShapeLockPart.ALL);
-                result.transform.position.set(px, py);
-                result.size.set(sx, sy);
-                result.vertices = vertices;
-                result.unlock(EShapeLockPart.ALL, true);
-                return result;
-            }
-            else {
-                var result = new EShapePolygon();
-                result.transform.position.set(px, py);
-                return result;
-            }
+        if (pointsLength < 2) {
+            result.points.values = [];
+            return result;
         }
-        else {
-            return new EShapePolygon();
+        var xmin = 0;
+        var xmax = 0;
+        var ymin = 0;
+        var ymax = 0;
+        xmin = xmax = points[0];
+        ymin = ymax = points[1];
+        for (var i = 2; i < pointsLength; i += 2) {
+            var x = points[i];
+            var y = points[i + 1];
+            xmin = Math.min(xmin, x);
+            xmax = Math.max(xmax, x);
+            ymin = Math.min(ymin, y);
+            ymax = Math.max(ymax, y);
+        }
+        var sx = xmax - xmin;
+        var sy = ymax - ymin;
+        var px = xmin + 0.5 * sx;
+        var py = ymin + 0.5 * sy;
+        var values = [];
+        for (var i = 0; i < pointsLength; i += 2) {
+            values.push(points[i] - px, points[i + 1] - py);
         }
+        result.lock(EShapeLockPart.ALL);
+        result.transform.position.set(px, py);
+        result.size.set(sx, sy);
+        result.points.values = values;
+        result.unlock(EShapeLockPart.ALL, true);
+        return result;
     };
 
     /*