@wcardinal/wcardinal-ui 0.309.0 → 0.310.1

package/dist/wcardinal-ui.js

@@ -1,5 +1,5 @@
 /*
- Winter Cardinal UI v0.309.0
+ Winter Cardinal UI v0.310.1
  Copyright (C) 2019 Toshiba Corporation
  SPDX-License-Identifier: Apache-2.0
 
@@ -2605,6 +2605,213 @@
         NEW_WINDOW: "NEW_WINDOW"
     };
 
+    var DBaseStateSetSubDatumImp = /** @class */ (function () {
+        function DBaseStateSetSubDatumImp(interval) {
+            var _this = this;
+            this._stateToTargets = new Map();
+            this._interval = interval;
+            this._onTimeBound = function () { return _this.onTime(); };
+        }
+        Object.defineProperty(DBaseStateSetSubDatumImp.prototype, "interval", {
+            get: function () {
+                return this._interval;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        DBaseStateSetSubDatumImp.prototype.add = function (state, target) {
+            var stateToTargets = this._stateToTargets;
+            var targets = stateToTargets.get(state);
+            if (targets == null) {
+                targets = new Set();
+                targets.add(target);
+                stateToTargets.set(state, targets);
+                if (stateToTargets.size <= 1) {
+                    this.start();
+                }
+            }
+            else {
+                targets.add(target);
+            }
+            return this;
+        };
+        DBaseStateSetSubDatumImp.prototype.remove = function (state, target) {
+            var stateToTargets = this._stateToTargets;
+            var targets = stateToTargets.get(state);
+            if (targets != null && targets.has(target)) {
+                targets.delete(target);
+                target.remove(state);
+                if (targets.size <= 0) {
+                    stateToTargets.delete(state);
+                }
+                if (stateToTargets.size <= 0) {
+                    this.stop();
+                }
+            }
+            return this;
+        };
+        DBaseStateSetSubDatumImp.prototype.start = function () {
+            if (this._timeoutId == null) {
+                this.onTime();
+            }
+            return this;
+        };
+        DBaseStateSetSubDatumImp.prototype.stop = function () {
+            var timeoutId = this._timeoutId;
+            if (timeoutId != null) {
+                clearTimeout(timeoutId);
+                this._timeoutId = undefined;
+            }
+            return this;
+        };
+        DBaseStateSetSubDatumImp.prototype.onTime = function () {
+            var now = Date.now();
+            var interval = this.interval;
+            var value = this.newValue(now, interval);
+            var on = this.newOn(now, interval);
+            this._stateToTargets.forEach(function (targets, state) {
+                targets.forEach(function (target) {
+                    target.set(state, value, on);
+                });
+            });
+            this._timeoutId = window.setTimeout(this._onTimeBound, Math.max(0, interval - (now % interval)));
+        };
+        return DBaseStateSetSubDatumImp;
+    }());
+
+    var DBaseStateSetBlinkerDatumImpl = /** @class */ (function (_super) {
+        __extends(DBaseStateSetBlinkerDatumImpl, _super);
+        function DBaseStateSetBlinkerDatumImpl() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        DBaseStateSetBlinkerDatumImpl.prototype.newValue = function (now, interval) {
+            return null;
+        };
+        DBaseStateSetBlinkerDatumImpl.prototype.newOn = function (now, interval) {
+            return Math.round(now / interval) % 2 === 0;
+        };
+        return DBaseStateSetBlinkerDatumImpl;
+    }(DBaseStateSetSubDatumImp));
+
+    var DBaseStateSetSubImpl = /** @class */ (function () {
+        function DBaseStateSetSubImpl(parent, intervalToDatum) {
+            this._parent = parent;
+            this._stateToInterval = new Map();
+            this._intervalToDatum = intervalToDatum;
+        }
+        DBaseStateSetSubImpl.prototype.add = function (state, interval) {
+            // Check if the interval is not same
+            var stateToInterval = this._stateToInterval;
+            var oldInterval = stateToInterval.get(state);
+            if (oldInterval === interval) {
+                return this;
+            }
+            // Remove the existing one
+            if (oldInterval != null) {
+                stateToInterval.delete(state);
+                var datum_1 = this._intervalToDatum.get(oldInterval);
+                if (datum_1 != null) {
+                    datum_1.remove(state, this._parent);
+                }
+            }
+            // Add a new one
+            stateToInterval.set(state, interval);
+            var datum = this._intervalToDatum.get(interval);
+            if (datum == null) {
+                datum = this.newDatum(interval);
+                this._intervalToDatum.set(interval, datum);
+            }
+            datum.add(state, this._parent);
+            // Done
+            return this;
+        };
+        DBaseStateSetSubImpl.prototype.remove = function (state) {
+            var interval = this._stateToInterval.get(state);
+            if (interval == null) {
+                return this;
+            }
+            this._stateToInterval.delete(state);
+            var datum = this._intervalToDatum.get(interval);
+            if (datum == null) {
+                return this;
+            }
+            datum.remove(state, this._parent);
+            return this;
+        };
+        DBaseStateSetSubImpl.prototype.set = function (state, interval, on) {
+            if (on) {
+                return this.add(state, interval);
+            }
+            else {
+                return this.remove(state);
+            }
+        };
+        DBaseStateSetSubImpl.prototype.has = function (state) {
+            return this._stateToInterval.has(state);
+        };
+        DBaseStateSetSubImpl.prototype.clear = function () {
+            var _this = this;
+            var parent = this._parent;
+            var stateToInterval = this._stateToInterval;
+            stateToInterval.forEach(function (interval, state) {
+                var datum = _this._intervalToDatum.get(interval);
+                if (datum != null) {
+                    datum.remove(state, parent);
+                }
+            });
+            stateToInterval.clear();
+            return this;
+        };
+        return DBaseStateSetSubImpl;
+    }());
+
+    var intervalToDatum$1;
+    var DBaseStateSetBlinkerImpl = /** @class */ (function (_super) {
+        __extends(DBaseStateSetBlinkerImpl, _super);
+        function DBaseStateSetBlinkerImpl(parent) {
+            return _super.call(this, parent, (intervalToDatum$1 !== null && intervalToDatum$1 !== void 0 ? intervalToDatum$1 : (intervalToDatum$1 = new Map()))) || this;
+        }
+        DBaseStateSetBlinkerImpl.prototype.newDatum = function (interval) {
+            return new DBaseStateSetBlinkerDatumImpl(interval);
+        };
+        return DBaseStateSetBlinkerImpl;
+    }(DBaseStateSetSubImpl));
+
+    var DBaseStateSetTickerDatumImpl = /** @class */ (function (_super) {
+        __extends(DBaseStateSetTickerDatumImpl, _super);
+        function DBaseStateSetTickerDatumImpl() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        DBaseStateSetTickerDatumImpl.prototype.newValue = function (now, interval) {
+            return Math.round(now / interval);
+        };
+        DBaseStateSetTickerDatumImpl.prototype.newOn = function (now, interval) {
+            return true;
+        };
+        return DBaseStateSetTickerDatumImpl;
+    }(DBaseStateSetSubDatumImp));
+
+    var intervalToDatum;
+    var DBaseStateSetTickerImpl = /** @class */ (function (_super) {
+        __extends(DBaseStateSetTickerImpl, _super);
+        function DBaseStateSetTickerImpl(parent) {
+            return _super.call(this, parent, (intervalToDatum !== null && intervalToDatum !== void 0 ? intervalToDatum : (intervalToDatum = new Map()))) || this;
+        }
+        DBaseStateSetTickerImpl.prototype.newDatum = function (interval) {
+            return new DBaseStateSetTickerDatumImpl(interval);
+        };
+        return DBaseStateSetTickerImpl;
+    }(DBaseStateSetSubImpl));
+
+    /*
+     * Copyright (C) 2019 Toshiba Corporation
+     * SPDX-License-Identifier: Apache-2.0
+     */
+    var isArray = Array.isArray ||
+        (function (target) {
+            return Object.prototype.toString.call(target) === "[object Array]";
+        });
+
     /*
      * Copyright (C) 2019 Toshiba Corporation
      * SPDX-License-Identifier: Apache-2.0
@@ -2614,6 +2821,14 @@
         return typeof target === "function";
     };
 
+    /*
+     * Copyright (C) 2019 Toshiba Corporation
+     * SPDX-License-Identifier: Apache-2.0
+     */
+    var isNumber = function (target) {
+        return (typeof target === "number" || Object.prototype.toString.call(target) === "[object Number]");
+    };
+
     /*
      * Copyright (C) 2019 Toshiba Corporation
      * SPDX-License-Identifier: Apache-2.0
@@ -2628,22 +2843,80 @@
      */
     var DBaseStateSetImpl = /** @class */ (function () {
         function DBaseStateSetImpl() {
-            this._local = new Set();
+            this._local = new Map();
             this._parent = null;
         }
-        DBaseStateSetImpl.prototype.is = function (state) {
-            return this._local.has(state);
+        Object.defineProperty(DBaseStateSetImpl.prototype, "local", {
+            get: function () {
+                return this._local;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(DBaseStateSetImpl.prototype, "parent", {
+            get: function () {
+                return this._parent;
+            },
+            set: function (parent) {
+                if (this._parent !== parent) {
+                    this.begin();
+                    this._parent = parent;
+                    this.end();
+                }
+            },
+            enumerable: false,
+            configurable: true
+        });
+        DBaseStateSetImpl.prototype.onParentChange = function (newState, oldState) {
+            this._parent = oldState;
+            this.begin();
+            this._parent = newState;
+            this.end();
         };
-        DBaseStateSetImpl.prototype.in = function (state) {
-            return this.is(state) || this.under(state);
+        Object.defineProperty(DBaseStateSetImpl.prototype, "blinker", {
+            get: function () {
+                var result = this._blinker;
+                if (result == null) {
+                    result = this.newBlinker();
+                    this._blinker = result;
+                }
+                return result;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        DBaseStateSetImpl.prototype.newBlinker = function () {
+            return new DBaseStateSetBlinkerImpl(this);
         };
-        DBaseStateSetImpl.prototype.on = function (state) {
-            var _a, _b;
-            return (_b = (_a = this._parent) === null || _a === void 0 ? void 0 : _a.is(state)) !== null && _b !== void 0 ? _b : false;
+        Object.defineProperty(DBaseStateSetImpl.prototype, "ticker", {
+            get: function () {
+                var result = this._ticker;
+                if (result == null) {
+                    result = this.newTicker();
+                    this._ticker = result;
+                }
+                return result;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        DBaseStateSetImpl.prototype.newTicker = function () {
+            return new DBaseStateSetTickerImpl(this);
         };
-        DBaseStateSetImpl.prototype.under = function (state) {
-            var _a, _b;
-            return (_b = (_a = this._parent) === null || _a === void 0 ? void 0 : _a.in(state)) !== null && _b !== void 0 ? _b : false;
+        DBaseStateSetImpl.prototype.is = function (state, value) {
+            var v = this._local.get(state);
+            return v !== undefined && (value === undefined || value === v);
+        };
+        DBaseStateSetImpl.prototype.in = function (state, value) {
+            return this.is(state, value) || this.under(state, value);
+        };
+        DBaseStateSetImpl.prototype.on = function (state, value) {
+            var parent = this._parent;
+            return parent != null && parent.is(state, value);
+        };
+        DBaseStateSetImpl.prototype.under = function (state, value) {
+            var parent = this._parent;
+            return parent != null && parent.in(state, value);
         };
         DBaseStateSetImpl.prototype.lock = function (callOnChange) {
             return this;
@@ -2657,35 +2930,78 @@
         DBaseStateSetImpl.prototype.end = function () {
             return this;
         };
-        DBaseStateSetImpl.prototype.checkAdded = function (added) {
-            return !this._local.has(added);
+        DBaseStateSetImpl.prototype.checkAdded = function (added, value) {
+            var v = this._local.get(added);
+            return v === undefined || v !== value;
         };
-        DBaseStateSetImpl.prototype.add = function (state) {
-            if (this.checkAdded(state)) {
+        DBaseStateSetImpl.prototype.add = function (state, value) {
+            if (value === void 0) { value = null; }
+            if (this.checkAdded(state, value)) {
                 this.begin();
-                this._local.add(state);
+                this._local.set(state, value);
                 this.end();
             }
             return this;
         };
-        DBaseStateSetImpl.prototype.checkAddeds = function (states) {
+        DBaseStateSetImpl.prototype.checkAddedsString = function (states) {
             var local = this._local;
             for (var i = 0, imax = states.length; i < imax; ++i) {
-                if (!local.has(states[i])) {
+                var v = local.get(states[i]);
+                if (v === undefined || v !== null) {
                     return true;
                 }
             }
             return false;
         };
-        DBaseStateSetImpl.prototype.addAll = function (stateOrStates) {
-            var states = isString(stateOrStates)
-                ? arguments // eslint-disable-line prefer-rest-params
-                : stateOrStates;
-            if (this.checkAddeds(states)) {
+        DBaseStateSetImpl.prototype.checkAddedsObject = function (states) {
+            var local = this._local;
+            for (var i = 0, imax = states.length; i < imax; ++i) {
+                var state = states[i];
+                var v = local.get(state.state);
+                if (v === undefined || v !== state.value) {
+                    return true;
+                }
+            }
+            return false;
+        };
+        DBaseStateSetImpl.prototype.addAll = function (first) {
+            if (isString(first)) {
+                return this.addAllString(arguments); // eslint-disable-line prefer-rest-params
+            }
+            else if (isArray(first)) {
+                if (0 < first.length) {
+                    var element = first[0];
+                    if (isString(element)) {
+                        return this.addAllString(first);
+                    }
+                    else {
+                        return this.addAllObject(first);
+                    }
+                }
+                return this;
+            }
+            else {
+                return this.addAllObject(arguments); // eslint-disable-line prefer-rest-params
+            }
+        };
+        DBaseStateSetImpl.prototype.addAllString = function (states) {
+            if (this.checkAddedsString(states)) {
+                this.begin();
+                var local = this._local;
+                for (var i = 0, imax = states.length; i < imax; ++i) {
+                    local.set(states[i], null);
+                }
+                this.end();
+            }
+            return this;
+        };
+        DBaseStateSetImpl.prototype.addAllObject = function (states) {
+            if (this.checkAddedsObject(states)) {
                 this.begin();
                 var local = this._local;
                 for (var i = 0, imax = states.length; i < imax; ++i) {
-                    local.add(states[i]);
+                    var state = states[i];
+                    local.set(state.state, state.value);
                 }
                 this.end();
             }
@@ -2702,7 +3018,7 @@
             }
             return this;
         };
-        DBaseStateSetImpl.prototype.checkRemoveds = function (states) {
+        DBaseStateSetImpl.prototype.checkRemovedsString = function (states) {
             var local = this._local;
             for (var i = 0, imax = states.length; i < imax; ++i) {
                 if (local.has(states[i])) {
@@ -2711,120 +3027,211 @@
             }
             return false;
         };
-        DBaseStateSetImpl.prototype.removeAll = function (stateOrStatesOrMatcher) {
-            var _this = this;
+        DBaseStateSetImpl.prototype.checkRemovedsObject = function (states) {
             var local = this._local;
-            if (isFunction(stateOrStatesOrMatcher)) {
-                var isDirty_1 = false;
-                local.forEach(function (state) {
-                    if (stateOrStatesOrMatcher(state)) {
-                        if (!isDirty_1) {
-                            isDirty_1 = true;
-                            _this.begin();
-                        }
-                        local.delete(state);
+            for (var i = 0, imax = states.length; i < imax; ++i) {
+                if (local.has(states[i].state)) {
+                    return true;
+                }
+            }
+            return false;
+        };
+        DBaseStateSetImpl.prototype.removeAll = function (first) {
+            if (isFunction(first)) {
+                return this.removeAllMatcher(first);
+            }
+            else if (isString(first)) {
+                return this.removeAllString(arguments); // eslint-disable-line prefer-rest-params
+            }
+            else if (isArray(first)) {
+                if (0 < first.length) {
+                    var element = first[0];
+                    if (isString(element)) {
+                        return this.removeAllString(first);
+                    }
+                    else {
+                        return this.removeAllObject(first);
                     }
-                });
-                if (isDirty_1) {
-                    this.end();
                 }
+                return this;
             }
             else {
-                var states = isString(stateOrStatesOrMatcher)
-                    ? arguments // eslint-disable-line prefer-rest-params
-                    : stateOrStatesOrMatcher;
-                if (this.checkRemoveds(states)) {
-                    this.begin();
-                    for (var i = 0, imax = states.length; i < imax; ++i) {
-                        local.delete(states[i]);
+                return this.removeAllObject(arguments); // eslint-disable-line prefer-rest-params
+            }
+        };
+        DBaseStateSetImpl.prototype.removeAllMatcher = function (matcher) {
+            var _this = this;
+            var isDirty = false;
+            var local = this._local;
+            local.forEach(function (value, state) {
+                if (matcher(state)) {
+                    if (!isDirty) {
+                        isDirty = true;
+                        _this.begin();
                     }
-                    this.end();
+                    local.delete(state);
                 }
+            });
+            if (isDirty) {
+                this.end();
             }
             return this;
         };
-        DBaseStateSetImpl.prototype.clear = function () {
-            var local = this._local;
-            if (0 < local.size) {
+        DBaseStateSetImpl.prototype.removeAllString = function (states) {
+            if (this.checkRemovedsString(states)) {
                 this.begin();
-                local.clear();
+                var local = this._local;
+                for (var i = 0, imax = states.length; i < imax; ++i) {
+                    local.delete(states[i]);
+                }
+                this.end();
+            }
+            return this;
+        };
+        DBaseStateSetImpl.prototype.removeAllObject = function (states) {
+            if (this.checkRemovedsObject(states)) {
+                this.begin();
+                var local = this._local;
+                for (var i = 0, imax = states.length; i < imax; ++i) {
+                    local.delete(states[i].state);
+                }
                 this.end();
             }
             return this;
         };
-        DBaseStateSetImpl.prototype.set = function (stateOrAdded, isOnOrRemoved) {
-            if (isOnOrRemoved === true) {
-                if (stateOrAdded != null) {
-                    this.add(stateOrAdded);
+        DBaseStateSetImpl.prototype.set = function (first, second, third) {
+            if (second === true) {
+                if (first != null) {
+                    this.add(first);
                 }
             }
-            else if (isOnOrRemoved === false) {
-                if (stateOrAdded != null) {
-                    this.remove(stateOrAdded);
+            else if (second === false) {
+                if (first != null) {
+                    this.remove(first);
                 }
             }
-            else {
-                var added = stateOrAdded;
-                var removed = isOnOrRemoved;
-                if (added != null) {
-                    if (removed != null) {
-                        if (this.checkAdded(added) || this.checkRemoved(removed)) {
-                            this.begin();
-                            this._local.add(added).delete(removed);
-                            this.end();
-                        }
+            else if (second == null || isNumber(second)) {
+                if (third === true) {
+                    if (first != null) {
+                        this.add(first, second);
                     }
-                    else {
-                        this.add(added);
+                }
+                else if (third === false) {
+                    if (first != null) {
+                        this.remove(first);
                     }
                 }
-                else if (removed != null) {
-                    this.remove(removed);
+                else {
+                    return this.doSet(first, second, third);
                 }
             }
+            else {
+                return this.doSet(first, null, second);
+            }
             return this;
         };
-        DBaseStateSetImpl.prototype.setAll = function (statesOrAddeds, isOnOrRemoveds) {
-            if (isOnOrRemoveds === true) {
-                if (statesOrAddeds != null) {
-                    this.addAll(statesOrAddeds);
+        DBaseStateSetImpl.prototype.doSet = function (added, value, removed) {
+            if (added != null) {
+                if (removed != null) {
+                    if (this.checkAdded(added, value) || this.checkRemoved(removed)) {
+                        this.begin();
+                        this._local.set(added, value).delete(removed);
+                        this.end();
+                    }
+                }
+                else {
+                    this.add(added, value);
                 }
             }
-            else if (isOnOrRemoveds === false) {
-                if (statesOrAddeds != null) {
-                    this.removeAll(statesOrAddeds);
+            else if (removed != null) {
+                this.remove(removed);
+            }
+            return this;
+        };
+        DBaseStateSetImpl.prototype.setAll = function (first, second) {
+            if (second === true) {
+                if (first != null) {
+                    this.addAll(first);
+                }
+            }
+            else if (second === false) {
+                if (first != null) {
+                    this.removeAll(first);
                 }
             }
             else {
-                var addeds = statesOrAddeds;
-                var removeds = isOnOrRemoveds;
-                if (addeds != null) {
-                    if (removeds != null) {
-                        if (this.checkAddeds(addeds) || this.checkRemoveds(removeds)) {
-                            this.begin();
-                            var local = this._local;
-                            for (var i = 0, imax = addeds.length; i < imax; ++i) {
-                                local.add(addeds[i]);
-                            }
-                            for (var i = 0, imax = removeds.length; i < imax; ++i) {
-                                local.delete(removeds[i]);
-                            }
-                            this.end();
+                if (first != null && 0 < first.length) {
+                    if (second != null && 0 < second.length) {
+                        var added = first[0];
+                        if (isString(added)) {
+                            return this.setAllString(first, second);
+                        }
+                        else {
+                            return this.setAllObject(first, second);
                         }
                     }
                     else {
-                        this.addAll(addeds);
+                        this.addAll(first);
                     }
                 }
-                else if (removeds != null) {
-                    this.removeAll(removeds);
+                else if (second != null) {
+                    this.removeAll(second);
                 }
             }
             return this;
         };
+        DBaseStateSetImpl.prototype.setAllString = function (addeds, removeds) {
+            if (this.checkAddedsString(addeds) || this.checkRemovedsString(removeds)) {
+                this.begin();
+                var local = this._local;
+                for (var i = 0, imax = addeds.length; i < imax; ++i) {
+                    local.set(addeds[i], null);
+                }
+                for (var i = 0, imax = removeds.length; i < imax; ++i) {
+                    local.delete(removeds[i]);
+                }
+                this.end();
+            }
+            return this;
+        };
+        DBaseStateSetImpl.prototype.setAllObject = function (addeds, removeds) {
+            if (this.checkAddedsObject(addeds) || this.checkRemovedsString(removeds)) {
+                this.begin();
+                var local = this._local;
+                for (var i = 0, imax = addeds.length; i < imax; ++i) {
+                    var added = addeds[i];
+                    local.set(added.state, added.value);
+                }
+                for (var i = 0, imax = removeds.length; i < imax; ++i) {
+                    local.delete(removeds[i]);
+                }
+                this.end();
+            }
+            return this;
+        };
+        DBaseStateSetImpl.prototype.clear = function () {
+            var local = this._local;
+            if (0 < local.size) {
+                this.begin();
+                local.clear();
+                this.end();
+            }
+            return this;
+        };
+        DBaseStateSetImpl.prototype.valueOf = function (state, def) {
+            var result = this._local.get(state);
+            if (result !== undefined) {
+                return result;
+            }
+            var parent = this._parent;
+            if (parent != null) {
+                return parent.valueOf(state, def);
+            }
+            return def;
+        };
         DBaseStateSetImpl.prototype.each = function (iteratee) {
-            this._local.forEach(function (state) {
-                iteratee(state);
+            this._local.forEach(function (value, state) {
+                iteratee(state, value);
             });
             return this;
         };
@@ -2836,41 +3243,14 @@
                 this.begin();
                 var local_1 = this._local;
                 local_1.clear();
-                other.local.forEach(function (value) {
-                    local_1.add(value);
+                other.local.forEach(function (value, state) {
+                    local_1.set(state, value);
                 });
                 this._parent = other.parent;
                 this.end();
             }
             return this;
         };
-        Object.defineProperty(DBaseStateSetImpl.prototype, "local", {
-            get: function () {
-                return this._local;
-            },
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(DBaseStateSetImpl.prototype, "parent", {
-            get: function () {
-                return this._parent;
-            },
-            set: function (parent) {
-                if (this._parent !== parent) {
-                    this.begin();
-                    this._parent = parent;
-                    this.end();
-                }
-            },
-            enumerable: false,
-            configurable: true
-        });
-        DBaseStateSetImpl.prototype.onParentChange = function (newState, oldState) {
-            this._parent = oldState;
-            this.begin();
-            this._parent = newState;
-            this.end();
-        };
         Object.defineProperty(DBaseStateSetImpl.prototype, "isHovered", {
             get: function () {
                 return this.is(DBaseState.HOVERED);
@@ -3438,8 +3818,8 @@
         });
         DBaseStateSetImpl.prototype.toObject = function () {
             var states = [];
-            this._local.forEach(function (value) {
-                states.push(value);
+            this._local.forEach(function (value, state) {
+                states.push(state);
             });
             return {
                 local: states
@@ -3542,12 +3922,12 @@
         EShapeStateSetImplObservable.prototype.onChange = function (newState, oldState) {
             if (newState.isActive) {
                 if (!oldState.isActive) {
-                    this._local.add(EShapeState.ACTIVATED).delete(EShapeState.DEACTIVATED);
+                    this._local.set(EShapeState.ACTIVATED, null).delete(EShapeState.DEACTIVATED);
                 }
             }
             else {
                 if (oldState.isActive) {
-                    this._local.add(EShapeState.DEACTIVATED).delete(EShapeState.ACTIVATED);
+                    this._local.set(EShapeState.DEACTIVATED, null).delete(EShapeState.ACTIVATED);
                 }
             }
             _super.prototype.onChange.call(this, newState, oldState);
@@ -6313,15 +6693,6 @@
         return EShapeDataMappingImpl;
     }());
 
-    /*
-     * Copyright (C) 2019 Toshiba Corporation
-     * SPDX-License-Identifier: Apache-2.0
-     */
-    var isArray = Array.isArray ||
-        (function (target) {
-            return Object.prototype.toString.call(target) === "[object Array]";
-        });
-
     var EShapeDataScopedImpl = /** @class */ (function () {
         function EShapeDataScopedImpl() {
         }
@@ -8877,14 +9248,6 @@
         EXTENSION: 1000
     };
 
-    /*
-     * Copyright (C) 2019 Toshiba Corporation
-     * SPDX-License-Identifier: Apache-2.0
-     */
-    var isNumber = function (target) {
-        return (typeof target === "number" || Object.prototype.toString.call(target) === "[object Number]");
-    };
-
     /*
      * Copyright (C) 2019 Toshiba Corporation
      * SPDX-License-Identifier: Apache-2.0
@@ -13569,11 +13932,42 @@
             if (options != null) {
                 var state = options.state;
                 if (state != null) {
+                    var s = _this._state;
                     if (isString(state)) {
-                        _this._state.add(state);
+                        s.add(state);
+                    }
+                    else if (isArray(state)) {
+                        s.addAll(state);
                     }
                     else {
-                        _this._state.addAll(state);
+                        // Values
+                        var values = state.values;
+                        if (values != null) {
+                            if (isString(values)) {
+                                s.add(values);
+                            }
+                            else {
+                                s.addAll(values);
+                            }
+                        }
+                        // Blinker
+                        var blinkers = state.blinkers;
+                        if (blinkers != null) {
+                            var b = s.blinker;
+                            for (var i = 0, imax = blinkers.length; i < imax; ++i) {
+                                var blinker = blinkers[i];
+                                b.add(blinker.state, blinker.interval);
+                            }
+                        }
+                        // Ticker
+                        var tickers = state.tickers;
+                        if (tickers != null) {
+                            var t = s.ticker;
+                            for (var i = 0, imax = tickers.length; i < imax; ++i) {
+                                var ticker = tickers[i];
+                                t.add(ticker.state, ticker.interval);
+                            }
+                        }
                     }
                 }
             }
@@ -27386,6 +27780,8 @@
             this.width = 0;
             this.height = 0;
             this.characters = [];
+            this.scale = 1;
+            this.scaled = false;
             this.clipped = false;
             this.x = 0;
             this.y = 0;
@@ -27395,6 +27791,8 @@
             this.countPerLine = 0;
             this.width = 0;
             this.height = 0;
+            this.scale = 1;
+            this.scaled = false;
             this.clipped = false;
             this.x = 0;
             this.y = 0.5 * (lineHeight - fontHeight);
@@ -27481,6 +27879,24 @@
             }
             return false;
         };
+        DDynamicTextMeasureResult.prototype.fit = function (width, height) {
+            var w = this.width;
+            var h = this.height;
+            if (1e-4 < w && width < w) {
+                if (1e-4 < h && height < h) {
+                    this.scale = Math.min(width / w, height / h);
+                    this.scaled = true;
+                }
+                else {
+                    this.scale = width / w;
+                    this.scaled = true;
+                }
+            }
+            else if (1e-4 < h && height < h) {
+                this.scale = height / h;
+                this.scaled = true;
+            }
+        };
         DDynamicTextMeasureResult.prototype.end = function (lineHeight, fontHeight) {
             this.newLine(lineHeight);
             this.y -= 0.5 * (lineHeight - fontHeight);
@@ -27503,21 +27919,22 @@
     var DDynamicTextMeasure = /** @class */ (function () {
         function DDynamicTextMeasure() {
         }
-        DDynamicTextMeasure.measure = function (text, atlas, clipping) {
+        DDynamicTextMeasure.measure = function (text, atlas, modifier) {
             var result = DDynamicTextMeasure.RESULT || new DDynamicTextMeasureResult();
             DDynamicTextMeasure.RESULT = result;
             if (atlas != null) {
                 var itr = UtilCharacterIterator.from(text);
                 var fh = atlas.font.height;
-                var lh = clipping.lineHeight;
-                var ce = clipping.enable;
-                var cw = clipping.width;
-                var ch = clipping.height;
-                var cp = clipping.wordWrap;
+                var lh = modifier.lineHeight;
+                var cf = modifier.fitting;
+                var cc = !cf && modifier.clipping;
+                var cw = modifier.width;
+                var ch = modifier.height;
+                var cp = !cf && modifier.wordWrap;
                 result.start(lh, fh);
                 switch (cp) {
                     case DDynamicTextStyleWordWrap.BREAK_ALL:
-                        if (ce) {
+                        if (cc) {
                             this.measure1(itr, cw, ch, fh, lh, atlas, result);
                         }
                         else {
@@ -27527,7 +27944,7 @@
                     case DDynamicTextStyleWordWrap.NORMAL:
                         var lb = this.newLineBreaker(text);
                         if (lb) {
-                            if (ce) {
+                            if (cc) {
                                 this.measure1a(lb, itr, cw, ch, fh, lh, atlas, result);
                             }
                             else {
@@ -27535,7 +27952,7 @@
                             }
                         }
                         else {
-                            if (ce) {
+                            if (cc) {
                                 this.measure1b(itr, cw, ch, fh, lh, atlas, result);
                             }
                             else {
@@ -27544,7 +27961,7 @@
                         }
                         break;
                     default:
-                        if (ce) {
+                        if (cc) {
                             this.measure3(itr, cw, lh, atlas, result);
                         }
                         else {
@@ -27553,6 +27970,9 @@
                         break;
                 }
                 result.end(lh, fh);
+                if (cf) {
+                    result.fit(cw, ch);
+                }
             }
             else {
                 result.start(0, 0);
@@ -27843,14 +28263,16 @@
             var _this = _super.call(this, new Float32Array(64), new Float32Array(64), new Uint16Array(48)) || this;
             _this.width = 0;
             _this.height = 0;
+            _this.scale = 1;
+            _this.scaled = false;
             _this.clipped = false;
             return _this;
         }
-        DDynamicTextGeometry.prototype.update = function (text, atlas, clipping) {
+        DDynamicTextGeometry.prototype.update = function (text, atlas, modifier) {
             var vertexBuffer = this.getBuffer("aVertexPosition");
             var uvBuffer = this.getBuffer("aTextureCoord");
             var indexBuffer = this.getIndex();
-            var result = DDynamicTextMeasure.measure(text, atlas, clipping);
+            var result = DDynamicTextMeasure.measure(text, atlas, modifier);
             var requiredTextSize = Math.ceil(result.count / 8) << 3;
             var requiredVertexSize = requiredTextSize << 3;
             if (vertexBuffer.data.length < requiredVertexSize) {
@@ -27867,6 +28289,7 @@
             if (atlas != null) {
                 var count = result.count;
                 var characters = result.characters;
+                var scale = result.scale;
                 for (var i = 0; i < count; ++i) {
                     var character = characters[i];
                     var cx = character.x;
@@ -27874,13 +28297,15 @@
                     var cc = character.character;
                     var w = atlas.width;
                     var h = atlas.height;
-                    this.writeCharacter(vertices, uvs, indices, i, cx, cy, cc, w, h);
+                    this.writeCharacter(vertices, uvs, indices, i, cx, cy, scale, cc, w, h);
                 }
                 for (var i = count, imax = vertices.length >> 3; i < imax; ++i) {
                     this.writeCharacterEmpty(vertices, uvs, indices, i);
                 }
-                this.width = result.width;
-                this.height = result.height;
+                this.width = result.width * scale;
+                this.height = result.height * scale;
+                this.scale = scale;
+                this.scaled = result.scaled;
                 this.clipped = result.clipped;
             }
             else {
@@ -27889,22 +28314,24 @@
                 }
                 this.width = 0;
                 this.height = 0;
+                this.scale = 1;
+                this.scaled = false;
                 this.clipped = false;
             }
             vertexBuffer.update();
             uvBuffer.update();
             indexBuffer.update();
         };
-        DDynamicTextGeometry.prototype.writeCharacter = function (vertices, uvs, indices, index, x, y, character, width, height) {
+        DDynamicTextGeometry.prototype.writeCharacter = function (vertices, uvs, indices, index, x, y, scale, character, width, height) {
             var cx = character.x;
             var cy = character.y;
             var cw = character.width;
             var ch = character.height;
             var cox = character.origin.x;
-            var x0 = x + (cx - cox);
-            var y0 = y;
-            var x1 = x0 + cw;
-            var y1 = y0 + ch;
+            var x0 = (x + (cx - cox)) * scale;
+            var y0 = y * scale;
+            var x1 = x0 + cw * scale;
+            var y1 = y0 + ch * scale;
             var iv = index << 3;
             vertices[iv + 0] = x0;
             vertices[iv + 1] = y0;
@@ -27971,7 +28398,7 @@
      */
     var DDynamicTextStyle = /** @class */ (function () {
         function DDynamicTextStyle(options, onChange) {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
             this._id = 0;
             this._idApproved = -1;
             var defaultOptions = this.getDefaultOptions();
@@ -27984,8 +28411,9 @@
                 this._fontWeight = (_f = options.fontWeight) !== null && _f !== void 0 ? _f : defaultOptions.fontWeight;
                 this._fill = (_g = options.fill) !== null && _g !== void 0 ? _g : defaultOptions.fill;
                 this._clipping = (_h = options.clipping) !== null && _h !== void 0 ? _h : defaultOptions.clipping;
-                this._wordWrap = toEnum((_j = options.wordWrap) !== null && _j !== void 0 ? _j : defaultOptions.wordWrap, DDynamicTextStyleWordWrap);
-                this._lineHeight = (_k = options.lineHeight) !== null && _k !== void 0 ? _k : defaultOptions.lineHeight;
+                this._fitting = (_j = options.fitting) !== null && _j !== void 0 ? _j : defaultOptions.fitting;
+                this._wordWrap = toEnum((_k = options.wordWrap) !== null && _k !== void 0 ? _k : defaultOptions.wordWrap, DDynamicTextStyleWordWrap);
+                this._lineHeight = (_l = options.lineHeight) !== null && _l !== void 0 ? _l : defaultOptions.lineHeight;
             }
             else {
                 this._align = defaultOptions.align;
@@ -27996,9 +28424,14 @@
                 this._fontWeight = defaultOptions.fontWeight;
                 this._fill = defaultOptions.fill;
                 this._clipping = defaultOptions.clipping;
+                this._fitting = defaultOptions.fitting;
                 this._wordWrap = toEnum(defaultOptions.wordWrap, DDynamicTextStyleWordWrap);
                 this._lineHeight = defaultOptions.lineHeight;
             }
+            this._fontSizeFitted = this._fontSize;
+            this._lineHeightFitted = this._lineHeight;
+            this._isFontFitted = false;
+            this._fontIdFontSize = this._fontSize;
             this._fontIdId = -1;
             this._fontId = "";
             this._fontIdApproved = "";
@@ -28024,6 +28457,7 @@
                 fontWeight: "normal",
                 fill: theme.getColor(new DBaseStateSetImpl()),
                 clipping: true,
+                fitting: false,
                 wordWrap: DDynamicTextStyleWordWrap.NONE,
                 lineHeight: theme.getLineHeight()
             };
@@ -28050,6 +28484,14 @@
             enumerable: false,
             configurable: true
         });
+        Object.defineProperty(DDynamicTextStyle.prototype, "fontIdFontSize", {
+            get: function () {
+                this.update();
+                return this._fontSizeFitted;
+            },
+            enumerable: false,
+            configurable: true
+        });
         Object.defineProperty(DDynamicTextStyle.prototype, "fontIdApproved", {
             get: function () {
                 return this._fontIdApproved;
@@ -28107,12 +28549,29 @@
             set: function (fontSize) {
                 if (this._fontSize !== fontSize) {
                     this._fontSize = fontSize;
+                    this._fontSizeFitted = fontSize;
+                    this._lineHeightFitted = this._lineHeight;
+                    this._isFontFitted = false;
                     this.onChange();
                 }
             },
             enumerable: false,
             configurable: true
         });
+        Object.defineProperty(DDynamicTextStyle.prototype, "fontSizeFitted", {
+            get: function () {
+                return this._fontSizeFitted;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(DDynamicTextStyle.prototype, "isFontFitted", {
+            get: function () {
+                return this._isFontFitted;
+            },
+            enumerable: false,
+            configurable: true
+        });
         Object.defineProperty(DDynamicTextStyle.prototype, "fontStyle", {
             get: function () {
                 return this._fontStyle;
@@ -28155,11 +28614,13 @@
         DDynamicTextStyle.prototype.update = function () {
             if (this._fontIdId !== this._id) {
                 this._fontIdId = this._id;
-                this._fontId = this.newFontId();
+                var fontIdFontSize = this._fitting ? this._fontSizeFitted : this._fontSize;
+                this._fontIdFontSize = fontIdFontSize;
+                this._fontId = this.toFontId(fontIdFontSize);
             }
         };
-        DDynamicTextStyle.prototype.newFontId = function () {
-            return "".concat(this._fontStyle, " ").concat(this._fontVariant, " ").concat(this._fontWeight, " ").concat(this._fontSize, "px ").concat(this._fontFamily);
+        DDynamicTextStyle.prototype.toFontId = function (fontSize) {
+            return "".concat(this._fontStyle, " ").concat(this._fontVariant, " ").concat(this._fontWeight, " ").concat(fontSize, "px ").concat(this._fontFamily);
         };
         Object.defineProperty(DDynamicTextStyle.prototype, "clipping", {
             get: function () {
@@ -28174,6 +28635,19 @@
             enumerable: false,
             configurable: true
         });
+        Object.defineProperty(DDynamicTextStyle.prototype, "fitting", {
+            get: function () {
+                return this._fitting;
+            },
+            set: function (fitting) {
+                if (this._fitting !== fitting) {
+                    this._fitting = fitting;
+                    this.onChange();
+                }
+            },
+            enumerable: false,
+            configurable: true
+        });
         Object.defineProperty(DDynamicTextStyle.prototype, "wordWrap", {
             get: function () {
                 return this._wordWrap;
@@ -28194,15 +28668,140 @@
             set: function (lineHeight) {
                 if (this._lineHeight !== lineHeight) {
                     this._lineHeight = lineHeight;
+                    this._fontSizeFitted = this._fontSize;
+                    this._lineHeightFitted = lineHeight;
+                    this._isFontFitted = false;
+                    this.onChange();
+                }
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(DDynamicTextStyle.prototype, "lineHeightFitted", {
+            get: function () {
+                return this._lineHeightFitted;
+            },
+            set: function (lineHeightFitted) {
+                if (this._lineHeightFitted !== lineHeightFitted) {
+                    this._lineHeightFitted = lineHeightFitted;
                     this.onChange();
                 }
             },
             enumerable: false,
             configurable: true
         });
+        DDynamicTextStyle.prototype.fit = function (fontSize, lineHeight) {
+            var isChanged = false;
+            if (fontSize < this._fontSizeFitted) {
+                this._fontSizeFitted = fontSize;
+                isChanged = true;
+            }
+            if (this._lineHeightFitted !== lineHeight) {
+                this._lineHeightFitted = lineHeight;
+                isChanged = true;
+            }
+            if (this._isFontFitted !== true) {
+                this._isFontFitted = true;
+                isChanged = true;
+            }
+            if (isChanged) {
+                this.onChange();
+            }
+            return isChanged;
+        };
+        DDynamicTextStyle.prototype.unfit = function () {
+            var isChanged = false;
+            if (this._isFontFitted !== false) {
+                this._isFontFitted = false;
+                isChanged = true;
+            }
+            if (this._fontSizeFitted !== this._fontSize) {
+                this._fontSizeFitted = this._fontSize;
+                isChanged = true;
+            }
+            if (this._lineHeightFitted !== this._lineHeight) {
+                this._lineHeightFitted = this._lineHeight;
+                isChanged = true;
+            }
+            if (isChanged) {
+                this.onChange();
+            }
+            return isChanged;
+        };
         return DDynamicTextStyle;
     }());
 
+    /*
+     * Copyright (C) 2019 Toshiba Corporation
+     * SPDX-License-Identifier: Apache-2.0
+     */
+    var UtilFont = /** @class */ (function () {
+        function UtilFont() {
+        }
+        UtilFont.measure = function (font) {
+            var results = this._results;
+            if (results == null) {
+                results = new Map();
+                this._results = results;
+            }
+            var result = results.get(font);
+            if (result != null) {
+                return result;
+            }
+            this.setup(font);
+            var blockRect = this._block.getBoundingClientRect();
+            var blockRectTop = blockRect.top;
+            var spanRect = this._span.getBoundingClientRect();
+            var ascent = blockRectTop - spanRect.top;
+            var descent = spanRect.bottom - blockRectTop;
+            result = {
+                ascent: ascent,
+                descent: descent
+            };
+            results.set(font, result);
+            return result;
+        };
+        UtilFont.toSize = function (font) {
+            this.setup(font);
+            return parseFloat(window.getComputedStyle(this._span).fontSize);
+        };
+        UtilFont.setup = function (font) {
+            var span = this._span;
+            if (span == null) {
+                span = document.createElement("span");
+                span.innerText = "|ÉqÅ";
+                span.style.border = "none";
+                span.style.margin = "0px";
+                this._span = span;
+            }
+            var block = this._block;
+            if (block == null) {
+                block = document.createElement("div");
+                block.style.display = "inline-block";
+                block.style.width = "0px";
+                block.style.height = "0px";
+                block.style.border = "none";
+                block.style.margin = "0px";
+                block.style.verticalAlign = "baseline";
+                this._block = block;
+            }
+            var div = this._div;
+            if (div == null) {
+                div = document.createElement("div");
+                div.style.position = "absolute";
+                div.style.padding = "0px";
+                div.style.margin = "0px";
+                div.style.visibility = "hidden";
+                div.appendChild(span);
+                div.appendChild(block);
+                document.body.appendChild(div);
+                this._div = div;
+            }
+            span.style.font = font;
+        };
+        return UtilFont;
+    }());
+
     /*
      * Copyright (C) 2019 Toshiba Corporation
      * SPDX-License-Identifier: Apache-2.0
@@ -28225,8 +28824,9 @@
             _this._atlasRevisionUpdated = 0;
             _this._width = 0;
             _this._height = 0;
-            _this._clipping = {
-                enable: false,
+            _this._modifier = {
+                clipping: false,
+                fitting: false,
                 wordWrap: DDynamicTextStyleWordWrap.NONE,
                 width: 0,
                 height: 0,
@@ -28250,13 +28850,13 @@
                     this._textApproved = text;
                     var fontId = style.fontId;
                     var fontIdApproved = style.fontIdApproved;
-                    var fontSize = style.fontSize;
+                    var fontIdFontSize = style.fontIdFontSize;
                     var fill = style.fill;
                     var fillApproved = style.fillApproved;
                     style.approve();
                     var atlases = layer.getDynamicFontAtlases();
                     if (text !== textApproved || fontId !== fontIdApproved || fill !== fillApproved) {
-                        atlases.add(fontId, fontSize, fill, text);
+                        atlases.add(fontId, fontIdFontSize, fill, text);
                         atlases.remove(fontIdApproved, fillApproved, textApproved);
                     }
                 }
@@ -28269,9 +28869,11 @@
             set: function (text) {
                 if (this._text !== text) {
                     this._text = text;
-                    this._isDirty = true;
-                    this._isGeometryDirty = true;
-                    this.update_();
+                    if (!this._style.unfit()) {
+                        this._isDirty = true;
+                        this._isGeometryDirty = true;
+                        this.update_();
+                    }
                 }
             },
             enumerable: false,
@@ -28326,13 +28928,14 @@
             configurable: true
         });
         DDynamicText.prototype.update = function () {
+            var _this = this;
             this.update_();
+            var style = this._style;
             var atlas = this._atlas;
             if (atlas == null) {
                 var layer = DApplications.getLayer(this);
                 if (layer) {
-                    var style_1 = this._style;
-                    atlas = layer.getDynamicFontAtlases().get(style_1.fontId, style_1.fill);
+                    atlas = layer.getDynamicFontAtlases().get(style.fontId, style.fill);
                     if (atlas != null) {
                         this._atlasRevisionUpdated = atlas.getRevisionUpdate();
                         this._atlas = atlas;
@@ -28348,50 +28951,68 @@
                     this._isGeometryDirty = true;
                 }
             }
-            var style = this._style;
-            var clipping = this._clipping;
-            if (this.updateClipping(style, clipping)) {
+            var modifier = this._modifier;
+            if (this.updateClipping(style, modifier)) {
                 this._isGeometryDirty = true;
             }
             if (this._isGeometryDirty) {
                 this._isGeometryDirty = false;
-                this.geometry.update(this._text, atlas, clipping);
+                var geometry = this.geometry;
+                geometry.update(this._text, atlas, modifier);
+                if (modifier.fitting && !style.isFontFitted && geometry.scaled) {
+                    var oldScale = geometry.scale;
+                    var oldFontSize = style.fontSize;
+                    var newFontId = style.toFontId(Math.ceil(oldFontSize * oldScale * 1000) / 1000);
+                    var newFontSize = UtilFont.toSize(newFontId);
+                    var newScale = newFontSize / oldFontSize;
+                    var newLineHeight = style.lineHeight * newScale;
+                    if (style.fit(newFontSize, newLineHeight)) {
+                        setTimeout(function () {
+                            DApplications.update(_this);
+                        }, 0);
+                    }
+                }
             }
         };
-        DDynamicText.prototype.updateClipping = function (style, clipping) {
+        DDynamicText.prototype.updateClipping = function (style, modifier) {
             var isChanged = false;
             var styleClipping = style.clipping;
-            if (clipping.enable !== styleClipping) {
-                clipping.enable = styleClipping;
+            if (modifier.clipping !== styleClipping) {
+                modifier.clipping = styleClipping;
+                isChanged = true;
+            }
+            var styleFitting = style.fitting;
+            if (modifier.fitting !== styleFitting) {
+                modifier.fitting = styleFitting;
                 isChanged = true;
             }
             var styleWordWrap = style.wordWrap;
-            if (clipping.wordWrap !== styleWordWrap) {
-                clipping.wordWrap = styleWordWrap;
+            if (modifier.wordWrap !== styleWordWrap) {
+                modifier.wordWrap = styleWordWrap;
                 isChanged = true;
             }
-            var styleLineHeight = style.lineHeight;
-            if (clipping.lineHeight !== styleLineHeight) {
-                clipping.lineHeight = styleLineHeight;
+            var styleLineHeight = styleFitting ? style.lineHeightFitted : style.lineHeight;
+            if (modifier.lineHeight !== styleLineHeight) {
+                modifier.lineHeight = styleLineHeight;
                 isChanged = true;
             }
-            if (styleClipping || styleWordWrap) {
+            if (styleClipping || styleFitting || styleWordWrap) {
                 var parent_1 = this.parent;
                 if (parent_1 instanceof DBase) {
                     var width = parent_1.width -
                         parent_1.padding.getLeft() -
                         parent_1.padding.getRight() -
-                        clipping.delta.width;
-                    if (clipping.width !== width) {
-                        clipping.width = width;
+                        modifier.delta.width;
+                    if (modifier.width !== width) {
+                        modifier.width = width;
                         isChanged = true;
                     }
                     var height = parent_1.height -
                         parent_1.padding.getTop() -
                         parent_1.padding.getBottom() -
-                        clipping.delta.height;
-                    if (clipping.height !== height) {
-                        clipping.height = height;
+                        modifier.delta.height;
+                    if (modifier.height !== height) {
+                        modifier.height = height;
                         isChanged = true;
                     }
                 }
@@ -28399,7 +29020,7 @@
             return isChanged;
         };
         DDynamicText.prototype.setClippingDelta = function (width, height) {
-            var delta = this._clipping.delta;
+            var delta = this._modifier.delta;
             delta.width = width;
             delta.height = height;
         };
@@ -28419,7 +29040,7 @@
      * SPDX-License-Identifier: Apache-2.0
      */
     var toTextStyle = function (theme, options, state) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
         var style = (_a = options === null || options === void 0 ? void 0 : options.text) === null || _a === void 0 ? void 0 : _a.style;
         if (style != null) {
             var fill = (_b = style.fill) !== null && _b !== void 0 ? _b : theme.getColor(state);
@@ -28429,8 +29050,9 @@
             var fontStyle = (_f = style.fontStyle) !== null && _f !== void 0 ? _f : theme.getFontStyle();
             var fontVariant = (_g = style.fontVariant) !== null && _g !== void 0 ? _g : theme.getFontVariant();
             var clipping = (_h = style.clipping) !== null && _h !== void 0 ? _h : theme.getTextStyleClipping();
-            var wordWrap = (_j = style.wordWrap) !== null && _j !== void 0 ? _j : theme.getTextStyleWordWrap();
-            var lineHeight = (_k = style.lineHeight) !== null && _k !== void 0 ? _k : theme.getLineHeight();
+            var fitting = (_j = style.fitting) !== null && _j !== void 0 ? _j : theme.getTextStyleFitting();
+            var wordWrap = (_k = style.wordWrap) !== null && _k !== void 0 ? _k : theme.getTextStyleWordWrap();
+            var lineHeight = (_l = style.lineHeight) !== null && _l !== void 0 ? _l : theme.getLineHeight();
             return {
                 fill: fill,
                 fontSize: fontSize,
@@ -28439,6 +29061,7 @@
                 fontStyle: fontStyle,
                 fontVariant: fontVariant,
                 clipping: clipping,
+                fitting: fitting,
                 wordWrap: wordWrap,
                 lineHeight: lineHeight
             };
@@ -28451,6 +29074,7 @@
             fontStyle: theme.getFontStyle(),
             fontVariant: theme.getFontVariant(),
             clipping: theme.getTextStyleClipping(),
+            fitting: theme.getTextStyleFitting(),
             wordWrap: theme.getTextStyleWordWrap(),
             lineHeight: theme.getLineHeight()
         };
@@ -43006,11 +43630,27 @@
                             options.state = [state, DBaseState.NEW_WINDOW];
                         }
                     }
-                    else {
+                    else if (isArray(state)) {
                         if (state.indexOf(DBaseState.NEW_WINDOW) < 0) {
                             state.push(DBaseState.NEW_WINDOW);
                         }
                     }
+                    else {
+                        var values = state.values;
+                        if (values == null) {
+                            state.values = DBaseState.NEW_WINDOW;
+                        }
+                        else if (isString(values)) {
+                            if (values !== DBaseState.NEW_WINDOW) {
+                                state.values = [values, DBaseState.NEW_WINDOW];
+                            }
+                        }
+                        else {
+                            if (values.indexOf(DBaseState.NEW_WINDOW) < 0) {
+                                values.push(DBaseState.NEW_WINDOW);
+                            }
+                        }
+                    }
                 }
             }
             return options;
@@ -45556,70 +46196,6 @@
         return DynamicAtlasItemText;
     }(DynamicAtlasItem));
 
-    /*
-     * Copyright (C) 2019 Toshiba Corporation
-     * SPDX-License-Identifier: Apache-2.0
-     */
-    var UtilFont = /** @class */ (function () {
-        function UtilFont() {
-        }
-        UtilFont.measure = function (font) {
-            var results = this._results;
-            if (results == null) {
-                results = new Map();
-                this._results = results;
-            }
-            var result = results.get(font);
-            if (result != null) {
-                return result;
-            }
-            var span = this._span;
-            if (span == null) {
-                span = document.createElement("span");
-                span.innerText = "|ÉqÅ";
-                span.style.border = "none";
-                span.style.margin = "0px";
-                this._span = span;
-            }
-            var block = this._block;
-            if (block == null) {
-                block = document.createElement("div");
-                block.style.display = "inline-block";
-                block.style.width = "0px";
-                block.style.height = "0px";
-                block.style.border = "none";
-                block.style.margin = "0px";
-                block.style.verticalAlign = "baseline";
-                this._block = block;
-            }
-            var div = this._div;
-            if (div == null) {
-                div = document.createElement("div");
-                div.style.position = "absolute";
-                div.style.padding = "0px";
-                div.style.margin = "0px";
-                div.style.visibility = "hidden";
-                div.appendChild(span);
-                div.appendChild(block);
-                document.body.appendChild(div);
-                this._div = div;
-            }
-            span.style.font = font;
-            var blockRect = block.getBoundingClientRect();
-            var blockRectTop = blockRect.top;
-            var spanRect = span.getBoundingClientRect();
-            var ascent = blockRectTop - spanRect.top;
-            var descent = spanRect.bottom - blockRectTop;
-            result = {
-                ascent: ascent,
-                descent: descent
-            };
-            results.set(font, result);
-            return result;
-        };
-        return UtilFont;
-    }());
-
     /*
      * Copyright (C) 2019 Toshiba Corporation
      * SPDX-License-Identifier: Apache-2.0
@@ -54386,6 +54962,80 @@
         return DChartAxisBaseBar;
     }());
 
+    var DChartAxisBaseGuideContainer = /** @class */ (function () {
+        function DChartAxisBaseGuideContainer(axis) {
+            this._axis = axis;
+            this._index = 0;
+            this._list = [];
+        }
+        DChartAxisBaseGuideContainer.prototype.add = function (guide) {
+            this._list.push(guide);
+            var container = this._container;
+            var index = this._index;
+            if (container != null) {
+                guide.bind(container, index, this._axis);
+            }
+            return this;
+        };
+        DChartAxisBaseGuideContainer.prototype.get = function (index) {
+            var list = this._list;
+            if (0 <= index && index < list.length) {
+                return list[index];
+            }
+            return null;
+        };
+        DChartAxisBaseGuideContainer.prototype.indexOf = function (guide) {
+            return this._list.indexOf(guide);
+        };
+        DChartAxisBaseGuideContainer.prototype.clear = function () {
+            var list = this._list;
+            for (var i = 0, imax = list.length; i < imax; ++i) {
+                list[i].destroy();
+            }
+            list.length = 0;
+            return this;
+        };
+        DChartAxisBaseGuideContainer.prototype.size = function () {
+            return this._list.length;
+        };
+        DChartAxisBaseGuideContainer.prototype.bind = function (container, index) {
+            this._container = container;
+            this._index = index;
+            var axis = this._axis;
+            var list = this._list;
+            for (var i = 0, imax = list.length; i < imax; ++i) {
+                list[i].bind(container, index, axis);
+            }
+        };
+        DChartAxisBaseGuideContainer.prototype.unbind = function () {
+            var list = this._list;
+            for (var i = 0, imax = list.length; i < imax; ++i) {
+                list[i].unbind();
+            }
+            this._index = 0;
+            this._container = undefined;
+        };
+        DChartAxisBaseGuideContainer.prototype.update = function () {
+            var isUpdated = false;
+            var list = this._list;
+            for (var i = 0, imax = list.length; i < imax; ++i) {
+                if (list[i].update()) {
+                    isUpdated = true;
+                }
+            }
+            return isUpdated;
+        };
+        DChartAxisBaseGuideContainer.prototype.destroy = function () {
+            var list = this._list;
+            for (var i = 0, imax = list.length; i < imax; ++i) {
+                list[i].destroy();
+            }
+            this._index = 0;
+            this._container = undefined;
+        };
+        return DChartAxisBaseGuideContainer;
+    }());
+
     /*
      * Copyright (C) 2019 Toshiba Corporation
      * SPDX-License-Identifier: Apache-2.0
@@ -54408,6 +55058,7 @@
             this.label = this.toLabel(theme, options);
             this.padding = (_b = options === null || options === void 0 ? void 0 : options.padding) !== null && _b !== void 0 ? _b : theme.getPadding();
             this.bar = this.toBar(theme, options);
+            this.guide = this.toGuide(theme, options);
         }
         DChartAxisBaseOptionParser.prototype.toPosition = function (theme, options) {
             var position = options === null || options === void 0 ? void 0 : options.position;
@@ -54419,6 +55070,12 @@
             }
             return theme.getPosition();
         };
+        DChartAxisBaseOptionParser.prototype.toGuide = function (theme, options) {
+            var _a, _b;
+            return {
+                list: (_b = (_a = options === null || options === void 0 ? void 0 : options.guide) === null || _a === void 0 ? void 0 : _a.list) !== null && _b !== void 0 ? _b : []
+            };
+        };
         DChartAxisBaseOptionParser.prototype.toBar = function (theme, options) {
             var _a;
             return {
@@ -55400,6 +56057,7 @@
             this._index = 0;
             this._bar = this.newBar(parser, theme, options);
             this._tick = this.newTick(parser, theme, options);
+            this._guide = this.newGuide(parser, theme, options);
         }
         DChartAxisBase.prototype.newParser = function (theme, options) {
             return new DChartAxisBaseOptionParser(theme, options);
@@ -55454,13 +56112,30 @@
         DChartAxisBase.prototype.newTick = function (parser, theme, options) {
             return new DChartAxisBaseTickContainer(parser);
         };
+        Object.defineProperty(DChartAxisBase.prototype, "guide", {
+            get: function () {
+                return this._guide;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        DChartAxisBase.prototype.newGuide = function (parser, theme, options) {
+            var result = new DChartAxisBaseGuideContainer(this);
+            var list = parser.guide.list;
+            for (var i = 0, imax = list.length; i < imax; ++i) {
+                result.add(list[i]);
+            }
+            return result;
+        };
         DChartAxisBase.prototype.bind = function (container, index) {
             this._container = container;
             this._index = index;
             this._bar.bind(container, index);
             this._tick.bind(container, index);
+            this._guide.bind(container, index);
         };
         DChartAxisBase.prototype.unbind = function () {
+            this._guide.unbind();
             this._tick.unbind();
             this._bar.unbind();
             this._index = 0;
@@ -55469,7 +56144,8 @@
         DChartAxisBase.prototype.update = function () {
             var isBarUpdated = this._bar.update();
             var isTicksUpdated = this._tick.update();
-            if (isBarUpdated || isTicksUpdated) {
+            var isGuideUpdated = this._guide.update();
+            if (isBarUpdated || isTicksUpdated || isGuideUpdated) {
                 var container = this._container;
                 if (container) {
                     DApplications.update(container.plotArea);
@@ -55479,10 +56155,12 @@
         DChartAxisBase.prototype.onRender = function () {
             this._bar.update();
             this._tick.update();
+            this._guide.update();
         };
         DChartAxisBase.prototype.destroy = function () {
             this._bar.destroy();
             this._tick.destroy();
+            this._guide.destroy();
             this._container = undefined;
         };
         DChartAxisBase.prototype.toTheme = function (options) {
@@ -55594,6 +56272,441 @@
         return DChartAxisContainerImpl;
     }());
 
+    var DChartAxisGuideSimpleShapeImpl = /** @class */ (function () {
+        function DChartAxisGuideSimpleShapeImpl(options) {
+            this._options = options;
+        }
+        Object.defineProperty(DChartAxisGuideSimpleShapeImpl.prototype, "bar", {
+            get: function () {
+                var result = this._bar;
+                if (result === undefined) {
+                    result = this.newBar();
+                    this._bar = result;
+                }
+                return result;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        DChartAxisGuideSimpleShapeImpl.prototype.newBar = function () {
+            var _a, _b;
+            var bar = (_b = (_a = this._options) === null || _a === void 0 ? void 0 : _a.bar) !== null && _b !== void 0 ? _b : {};
+            if (bar.enable !== false) {
+                var result = new EShapeBar();
+                result.stroke.copy(this.toStrokeOptions(bar.stroke, EShapeStrokeStyle.DASHED));
+                result.text.copy(this.toTextOptions(bar.text));
+                return result;
+            }
+            return null;
+        };
+        DChartAxisGuideSimpleShapeImpl.prototype.toStrokeOptions = function (options, style) {
+            var _a;
+            options = options || {};
+            return {
+                enable: options.enable,
+                color: options.color,
+                alpha: options.alpha,
+                width: options.width,
+                align: options.align,
+                side: toEnum(options.side, EShapeStrokeSide),
+                style: toEnum((_a = options.style) !== null && _a !== void 0 ? _a : style, EShapeStrokeStyle)
+            };
+        };
+        DChartAxisGuideSimpleShapeImpl.prototype.toTextOptions = function (options) {
+            options = options || {};
+            return {
+                value: options.value,
+                color: options.color,
+                alpha: options.alpha,
+                family: options.family,
+                size: options.size,
+                weight: toEnum(options.weight, EShapeTextWeight),
+                align: this.toTextAlignOptions(options.align),
+                offset: options.offset,
+                style: toEnum(options.style, EShapeTextStyle),
+                outline: options.outline,
+                spacing: options.spacing,
+                direction: toEnum(options.direction, EShapeTextDirection),
+                padding: options.padding,
+                clipping: options.clipping,
+                fitting: options.fitting
+            };
+        };
+        DChartAxisGuideSimpleShapeImpl.prototype.toTextAlignOptions = function (options) {
+            options = options || {};
+            return {
+                horizontal: toEnum(options === null || options === void 0 ? void 0 : options.horizontal, EShapeTextAlignHorizontal),
+                vertical: toEnum(options === null || options === void 0 ? void 0 : options.vertical, EShapeTextAlignVertical)
+            };
+        };
+        DChartAxisGuideSimpleShapeImpl.prototype.toBarPosition = function (axis) {
+            switch (axis.position) {
+                case DChartAxisPosition.LEFT:
+                case DChartAxisPosition.RIGHT:
+                    return EShapeBarPosition.LEFT;
+                default:
+                    return EShapeBarPosition.TOP;
+            }
+        };
+        Object.defineProperty(DChartAxisGuideSimpleShapeImpl.prototype, "label", {
+            get: function () {
+                var result = this._label;
+                if (result === undefined) {
+                    result = this.newLabel();
+                    this._label = result;
+                }
+                return result;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        DChartAxisGuideSimpleShapeImpl.prototype.newLabel = function () {
+            var _a, _b, _c, _d;
+            var label = (_b = (_a = this._options) === null || _a === void 0 ? void 0 : _a.label) !== null && _b !== void 0 ? _b : {};
+            if (label.enable === true) {
+                var result = new EShapeRectangleRounded();
+                result.stroke.copy(this.toStrokeOptions(label.stroke));
+                result.fill.copy(label.fill);
+                result.text.copy(this.toTextOptions(label.text));
+                result.size.set((_c = label.width) !== null && _c !== void 0 ? _c : 50, (_d = label.height) !== null && _d !== void 0 ? _d : 30);
+                return result;
+            }
+            return null;
+        };
+        Object.defineProperty(DChartAxisGuideSimpleShapeImpl.prototype, "labelMargin", {
+            get: function () {
+                var result = this._labelMargin;
+                if (result == null) {
+                    result = this.newLabelMargin();
+                    this._labelMargin = result;
+                }
+                return result;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        DChartAxisGuideSimpleShapeImpl.prototype.newLabelMargin = function () {
+            var options = this._options;
+            if (options != null) {
+                var label = options.label;
+                if (label != null) {
+                    var result = label.margin;
+                    if (result != null) {
+                        return result;
+                    }
+                }
+            }
+            return 10;
+        };
+        Object.defineProperty(DChartAxisGuideSimpleShapeImpl.prototype, "tick", {
+            get: function () {
+                var result = this._tick;
+                if (result === undefined) {
+                    result = this.newTick();
+                    this._tick = result;
+                }
+                return result;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        DChartAxisGuideSimpleShapeImpl.prototype.newTick = function () {
+            var _a, _b, _c;
+            var tick = (_b = (_a = this._options) === null || _a === void 0 ? void 0 : _a.tick) !== null && _b !== void 0 ? _b : {};
+            if (tick.enable === true) {
+                var result = new EShapeBar();
+                result.stroke.copy(this.toStrokeOptions(tick.stroke));
+                result.text.copy(this.toTextOptions(tick.text));
+                var size = (_c = tick.size) !== null && _c !== void 0 ? _c : 5;
+                result.size.set(size, size);
+                return result;
+            }
+            return null;
+        };
+        Object.defineProperty(DChartAxisGuideSimpleShapeImpl.prototype, "tickMargin", {
+            get: function () {
+                var result = this._tickMargin;
+                if (result == null) {
+                    result = this.newTickMargin();
+                    this._tickMargin = result;
+                }
+                return result;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        DChartAxisGuideSimpleShapeImpl.prototype.newTickMargin = function () {
+            var options = this._options;
+            if (options != null) {
+                var tick = options.tick;
+                if (tick != null) {
+                    var result = tick.margin;
+                    if (result != null) {
+                        return result;
+                    }
+                }
+            }
+            return 0;
+        };
+        DChartAxisGuideSimpleShapeImpl.prototype.toTickPosition = function (axis) {
+            switch (axis.position) {
+                case DChartAxisPosition.LEFT:
+                case DChartAxisPosition.RIGHT:
+                    return EShapeBarPosition.LEFT;
+                default:
+                    return EShapeBarPosition.TOP;
+            }
+        };
+        DChartAxisGuideSimpleShapeImpl.prototype.bind = function (container, index, axis) {
+            var bar = this.bar;
+            if (bar != null) {
+                bar.points.position = this.toBarPosition(axis);
+                bar.attach(container.container);
+            }
+            var label = this.label;
+            if (label != null) {
+                label.attach(container.container);
+            }
+            var tick = this.tick;
+            if (tick != null) {
+                tick.points.position = this.toTickPosition(axis);
+                tick.attach(container.container);
+            }
+        };
+        DChartAxisGuideSimpleShapeImpl.prototype.unbind = function () {
+            var bar = this._bar;
+            if (bar != null) {
+                bar.detach();
+            }
+            var label = this._label;
+            if (label != null) {
+                label.detach();
+            }
+            var tick = this._tick;
+            if (tick != null) {
+                tick.detach();
+            }
+        };
+        DChartAxisGuideSimpleShapeImpl.prototype.update = function (position, x, y, visible, width, height, offset) {
+            var bar = this._bar;
+            if (bar != null) {
+                bar.disallowUploadedUpdate();
+                switch (position) {
+                    case DChartAxisPosition.TOP:
+                        bar.transform.position.set(x, y);
+                        bar.size.set(0, height);
+                        bar.visible = visible;
+                        break;
+                    case DChartAxisPosition.BOTTOM:
+                        bar.transform.position.set(x, y);
+                        bar.size.set(0, height);
+                        bar.visible = visible;
+                        break;
+                    case DChartAxisPosition.LEFT:
+                        bar.transform.position.set(x, y);
+                        bar.size.set(width, 0);
+                        bar.visible = visible;
+                        break;
+                    case DChartAxisPosition.RIGHT:
+                        bar.transform.position.set(x, y);
+                        bar.size.set(width, 0);
+                        bar.visible = visible;
+                        break;
+                }
+                bar.allowUploadedUpdate();
+            }
+            var label = this._label;
+            if (label != null) {
+                var m = this.labelMargin;
+                var s = label.size;
+                var ox = offset + s.x * 0.5 + m;
+                var oy = offset + s.y * 0.5 + m;
+                label.disallowUploadedUpdate();
+                switch (position) {
+                    case DChartAxisPosition.TOP:
+                        label.transform.position.set(x, -oy);
+                        label.visible = visible;
+                        break;
+                    case DChartAxisPosition.BOTTOM:
+                        label.transform.position.set(x, height + oy);
+                        label.visible = visible;
+                        break;
+                    case DChartAxisPosition.LEFT:
+                        label.transform.position.set(-ox, y);
+                        label.visible = visible;
+                        break;
+                    case DChartAxisPosition.RIGHT:
+                        label.transform.position.set(width + ox, y);
+                        label.visible = visible;
+                        break;
+                }
+                label.allowUploadedUpdate();
+            }
+            var tick = this._tick;
+            if (tick != null) {
+                var m = this.tickMargin;
+                var s = tick.size;
+                var ox = offset + s.x * 0.5 + m;
+                var oy = offset + s.y * 0.5 + m;
+                tick.disallowUploadedUpdate();
+                switch (position) {
+                    case DChartAxisPosition.TOP:
+                        tick.transform.position.set(x, -oy);
+                        tick.visible = visible;
+                        break;
+                    case DChartAxisPosition.BOTTOM:
+                        tick.transform.position.set(x, height + oy);
+                        tick.visible = visible;
+                        break;
+                    case DChartAxisPosition.LEFT:
+                        tick.transform.position.set(-ox, y);
+                        tick.visible = visible;
+                        break;
+                    case DChartAxisPosition.RIGHT:
+                        tick.transform.position.set(width + ox, y);
+                        tick.visible = visible;
+                        break;
+                }
+                tick.allowUploadedUpdate();
+            }
+            return true;
+        };
+        DChartAxisGuideSimpleShapeImpl.prototype.destroy = function () {
+            var bar = this._bar;
+            if (bar != null) {
+                bar.destroy();
+            }
+            var label = this._label;
+            if (label != null) {
+                label.destroy();
+            }
+            var tick = this._tick;
+            if (tick != null) {
+                tick.destroy();
+            }
+        };
+        return DChartAxisGuideSimpleShapeImpl;
+    }());
+
+    var DChartAxisGuideSimple = /** @class */ (function () {
+        function DChartAxisGuideSimple(options) {
+            var _a;
+            this._options = options;
+            this._index = 0;
+            this._position = (_a = options === null || options === void 0 ? void 0 : options.position) !== null && _a !== void 0 ? _a : 0;
+            this._work = new pixi_js.Point();
+            this._isShown = true;
+        }
+        Object.defineProperty(DChartAxisGuideSimple.prototype, "shape", {
+            get: function () {
+                var result = this._shape;
+                if (result == null) {
+                    result = this.newShape();
+                    this._shape = result;
+                }
+                return result;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        DChartAxisGuideSimple.prototype.newShape = function () {
+            return new DChartAxisGuideSimpleShapeImpl(this._options);
+        };
+        Object.defineProperty(DChartAxisGuideSimple.prototype, "position", {
+            get: function () {
+                return this._position;
+            },
+            set: function (position) {
+                this._position = position;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        DChartAxisGuideSimple.prototype.show = function () {
+            this._isShown = true;
+            return this;
+        };
+        DChartAxisGuideSimple.prototype.isShown = function () {
+            return this._isShown;
+        };
+        DChartAxisGuideSimple.prototype.hide = function () {
+            this._isShown = false;
+            return this;
+        };
+        DChartAxisGuideSimple.prototype.isHidden = function () {
+            return !this._isShown;
+        };
+        DChartAxisGuideSimple.prototype.bind = function (container, index, axis) {
+            this._container = container;
+            this._index = index;
+            this._axis = axis;
+            this.shape.bind(container, index, axis);
+        };
+        DChartAxisGuideSimple.prototype.unbind = function () {
+            var shape = this._shape;
+            if (shape != null) {
+                shape.unbind();
+            }
+            this._axis = undefined;
+            this._index = 0;
+            this._container = undefined;
+        };
+        DChartAxisGuideSimple.prototype.update = function () {
+            var container = this._container;
+            var index = this._index;
+            var shape = this._shape;
+            var axis = this._axis;
+            if (shape != null && container != null && axis != null) {
+                var plotArea = container.plotArea;
+                var transform = plotArea.container.transform.localTransform;
+                var plotAreaWidth = plotArea.width;
+                var plotAreaHeight = plotArea.height;
+                var offset = axis.padding * index;
+                switch (axis.position) {
+                    case DChartAxisPosition.TOP:
+                    case DChartAxisPosition.BOTTOM:
+                        var coordinateX = plotArea.coordinate.x.get(axis.coordinate);
+                        if (coordinateX) {
+                            var work = this._work;
+                            work.set(coordinateX.transform.map(coordinateX.map(this._position)), 0);
+                            transform.apply(work, work);
+                            var x = work.x;
+                            shape.update(axis.position, x, plotAreaHeight * 0.5, this._isShown && 0 <= x && x <= plotAreaWidth, plotAreaWidth, plotAreaHeight, offset);
+                        }
+                        else {
+                            shape.update(axis.position, 0, plotAreaHeight * 0.5, false, plotAreaWidth, plotAreaHeight, offset);
+                        }
+                        break;
+                    case DChartAxisPosition.LEFT:
+                    case DChartAxisPosition.RIGHT:
+                        var coordinateY = plotArea.coordinate.y.get(axis.coordinate);
+                        if (coordinateY) {
+                            var work = this._work;
+                            work.set(0, coordinateY.transform.map(coordinateY.map(this._position)));
+                            transform.apply(work, work);
+                            var y = work.y;
+                            shape.update(axis.position, plotAreaWidth * 0.5, y, this._isShown && 0 <= y && y <= plotAreaHeight, plotAreaWidth, plotAreaHeight, offset);
+                        }
+                        else {
+                            shape.update(axis.position, plotAreaWidth * 0.5, 0, false, plotAreaWidth, plotAreaHeight, offset);
+                        }
+                        break;
+                }
+                return true;
+            }
+            return false;
+        };
+        DChartAxisGuideSimple.prototype.destroy = function () {
+            var shape = this._shape;
+            if (shape != null) {
+                shape.destroy();
+            }
+            this._index = 0;
+            this._container = undefined;
+        };
+        return DChartAxisGuideSimple;
+    }());
+
     /*
      * Copyright (C) 2019 Toshiba Corporation
      * SPDX-License-Identifier: Apache-2.0
@@ -73810,6 +74923,7 @@
         EShapeBufferUnit: EShapeBufferUnit,
         EShapeBuffer: EShapeBuffer,
         EShapeCapabilities: EShapeCapabilities,
+        EShapeCapabilityContainerImpl: EShapeCapabilityContainerImpl,
         EShapeCapability: EShapeCapability,
         EShapeConnectorBodies: EShapeConnectorBodies,
         EShapeConnectorBodyImpl: EShapeConnectorBodyImpl,
@@ -74024,8 +75138,14 @@
         DBaseReflowableContainer: DBaseReflowableContainer,
         DBaseReflowableImpl: DBaseReflowableImpl,
         DBaseSnippetContainer: DBaseSnippetContainer,
+        DBaseStateSetBlinkerDatumImpl: DBaseStateSetBlinkerDatumImpl,
+        DBaseStateSetBlinkerImpl: DBaseStateSetBlinkerImpl,
         DBaseStateSetImplObservable: DBaseStateSetImplObservable,
         DBaseStateSetImpl: DBaseStateSetImpl,
+        DBaseStateSetSubDatumImp: DBaseStateSetSubDatumImp,
+        DBaseStateSetSubImpl: DBaseStateSetSubImpl,
+        DBaseStateSetTickerDatumImpl: DBaseStateSetTickerDatumImpl,
+        DBaseStateSetTickerImpl: DBaseStateSetTickerImpl,
         DBaseState: DBaseState,
         DBase: DBase,
         DBoard: DBoard,
@@ -74056,6 +75176,7 @@
         DCanvasContainer: DCanvasContainer,
         DCanvas: DCanvas,
         DChartAxisBaseBar: DChartAxisBaseBar,
+        DChartAxisBaseGuideContainer: DChartAxisBaseGuideContainer,
         DChartAxisBaseOptionParser: DChartAxisBaseOptionParser,
         DChartAxisBaseTickContainer: DChartAxisBaseTickContainer,
         DChartAxisBaseTickMajorGridline: DChartAxisBaseTickMajorGridline,
@@ -74063,6 +75184,8 @@
         DChartAxisBaseTickMinor: DChartAxisBaseTickMinor,
         DChartAxisBase: DChartAxisBase,
         DChartAxisContainerImpl: DChartAxisContainerImpl,
+        DChartAxisGuideSimpleShapeImpl: DChartAxisGuideSimpleShapeImpl,
+        DChartAxisGuideSimple: DChartAxisGuideSimple,
         DChartAxisPosition: DChartAxisPosition,
         DChartAxisTickPosition: DChartAxisTickPosition,
         DChartAxisXDatetime: DChartAxisXDatetime,