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

package/dist/wcardinal-ui.cjs.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
 
@@ -14375,12 +14375,8 @@ var EShapeLinePoints = /** @class */ (function () {
     });
     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
@@ -48449,7 +48445,7 @@ var buildPolygonIndex = function (indices, polygonIndices, voffset, ioffset) {
  * 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;
@@ -48458,8 +48454,8 @@ var buildPolygonVertex = function (vertices, polygonVertices, voffset, sizeX, si
     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;
     }
@@ -48468,28 +48464,26 @@ var buildPolygonVertex = function (vertices, polygonVertices, voffset, sizeX, si
  * 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;
@@ -48497,9 +48491,9 @@ var buildPolygonUv = function (uvs, polygonVertices, voffset, textureUvs) {
     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;
     }
 };
 
@@ -48897,14 +48891,10 @@ var UtilPolygon = /** @class */ (function () {
      * 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) {
@@ -48913,11 +48903,11 @@ var UtilPolygon = /** @class */ (function () {
         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) {
@@ -49520,13 +49510,11 @@ var UtilStraightSkeletonWavefront = /** @class */ (function () {
 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) {
@@ -49596,7 +49584,7 @@ var UtilStraightSkeletonBufferBuilder = /** @class */ (function () {
             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 {
@@ -49610,7 +49598,7 @@ var UtilStraightSkeletonBufferBuilder = /** @class */ (function () {
             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;
         }
     };
@@ -49634,23 +49622,21 @@ var UtilStraightSkeletonBufferBuilder = /** @class */ (function () {
             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;
             }
         }
     };
@@ -49783,13 +49769,12 @@ var EShapePolygonTriangulatedImpl = /** @class */ (function () {
     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;
     }
@@ -49833,6 +49818,14 @@ var EShapePolygonTriangulatedImpl = /** @class */ (function () {
         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();
@@ -49849,20 +49842,11 @@ var EShapePolygonTriangulatedImpl = /** @class */ (function () {
         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
@@ -49899,6 +49883,17 @@ var EShapePolygonTriangulatedImpl = /** @class */ (function () {
             }
             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;
@@ -49919,45 +49914,37 @@ var EShapePolygonTriangulatedImpl = /** @class */ (function () {
     };
     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) {
@@ -49966,6 +49953,7 @@ var EShapePolygonTriangulatedImpl = /** @class */ (function () {
             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));
@@ -49979,13 +49967,8 @@ var EShapePolygonTriangulatedImpl = /** @class */ (function () {
                 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) {
@@ -50017,8 +50000,18 @@ var EShapePolygonTriangulatedImpl = /** @class */ (function () {
                 }
                 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) {
@@ -50048,20 +50041,16 @@ var EShapePolygonTriangulatedImpl = /** @class */ (function () {
  * @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;
@@ -50091,31 +50080,29 @@ var hitTestPolygon = function (shape, x, y, ax, ay, sw, ss) {
     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;
                             }
                         }
@@ -50133,7 +50120,7 @@ var hitTestPolygon = function (shape, x, y, ax, ay, sw, ss) {
                     return true;
                 }
                 else {
-                    return calcPolygonSquaredDistance(shape, x, y, ax, ay) <= sw * sw;
+                    return calcPolygonSquaredDistance(values, valuesLength, x, y) <= sw * sw;
                 }
             }
         }
@@ -50147,66 +50134,29 @@ var hitTestPolygon = function (shape, x, y, ax, ay, sw, ss) {
  */
 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;
@@ -50214,70 +50164,24 @@ var EShapePolygon = /** @class */ (function (_super) {
         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;
     };
@@ -50290,34 +50194,10 @@ var EShapePolygon = /** @class */ (function (_super) {
                 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) {
@@ -50392,10 +50272,6 @@ var BuilderPolygon = /** @class */ (function (_super) {
         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
@@ -50412,16 +50288,13 @@ var BuilderPolygon = /** @class */ (function (_super) {
         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;
@@ -50430,25 +50303,25 @@ var BuilderPolygon = /** @class */ (function (_super) {
             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));
             }
         }
     };
@@ -53015,51 +52888,41 @@ var createLine = function (points, segments, strokeWidth, pointsStyle) {
     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;
 };
 
 /*