@wcardinal/wcardinal-ui 0.309.0 → 0.310.0

package/dist/wcardinal-ui.cjs.js

@@ -1,5 +1,5 @@
 /*
- Winter Cardinal UI v0.309.0
+ Winter Cardinal UI v0.310.0
  Copyright (C) 2019 Toshiba Corporation
  SPDX-License-Identifier: Apache-2.0
 
@@ -2608,6 +2608,213 @@ var DBaseState = {
     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
@@ -2617,6 +2824,14 @@ var isFunction = function (target) {
     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
@@ -2631,22 +2846,80 @@ var isString = function (target) {
  */
 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;
@@ -2660,35 +2933,78 @@ var DBaseStateSetImpl = /** @class */ (function () {
     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();
         }
@@ -2705,7 +3021,7 @@ var DBaseStateSetImpl = /** @class */ (function () {
         }
         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])) {
@@ -2714,120 +3030,211 @@ var DBaseStateSetImpl = /** @class */ (function () {
         }
         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;
     };
@@ -2839,41 +3246,14 @@ var DBaseStateSetImpl = /** @class */ (function () {
             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);
@@ -3441,8 +3821,8 @@ var DBaseStateSetImpl = /** @class */ (function () {
     });
     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
@@ -3545,12 +3925,12 @@ var EShapeStateSetImplObservable = /** @class */ (function (_super) {
     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);
@@ -6316,15 +6696,6 @@ var EShapeDataMappingImpl = /** @class */ (function () {
     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() {
     }
@@ -8880,14 +9251,6 @@ var EShapeActionValueType = {
     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
@@ -13572,11 +13935,42 @@ var DBase = /** @class */ (function (_super) {
         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);
+                        }
+                    }
                 }
             }
         }
@@ -27389,6 +27783,8 @@ var DDynamicTextMeasureResult = /** @class */ (function () {
         this.width = 0;
         this.height = 0;
         this.characters = [];
+        this.scale = 1;
+        this.scaled = false;
         this.clipped = false;
         this.x = 0;
         this.y = 0;
@@ -27398,6 +27794,8 @@ var DDynamicTextMeasureResult = /** @class */ (function () {
         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);
@@ -27484,6 +27882,24 @@ var DDynamicTextMeasureResult = /** @class */ (function () {
         }
         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);
@@ -27506,21 +27922,22 @@ var NEW_LINE = "\n";
 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 {
@@ -27530,7 +27947,7 @@ var DDynamicTextMeasure = /** @class */ (function () {
                 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 {
@@ -27538,7 +27955,7 @@ var DDynamicTextMeasure = /** @class */ (function () {
                         }
                     }
                     else {
-                        if (ce) {
+                        if (cc) {
                             this.measure1b(itr, cw, ch, fh, lh, atlas, result);
                         }
                         else {
@@ -27547,7 +27964,7 @@ var DDynamicTextMeasure = /** @class */ (function () {
                     }
                     break;
                 default:
-                    if (ce) {
+                    if (cc) {
                         this.measure3(itr, cw, lh, atlas, result);
                     }
                     else {
@@ -27556,6 +27973,9 @@ var DDynamicTextMeasure = /** @class */ (function () {
                     break;
             }
             result.end(lh, fh);
+            if (cf) {
+                result.fit(cw, ch);
+            }
         }
         else {
             result.start(0, 0);
@@ -27846,14 +28266,16 @@ var DDynamicTextGeometry = /** @class */ (function (_super) {
         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) {
@@ -27870,6 +28292,7 @@ var DDynamicTextGeometry = /** @class */ (function (_super) {
         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;
@@ -27877,13 +28300,15 @@ var DDynamicTextGeometry = /** @class */ (function (_super) {
                 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 {
@@ -27892,22 +28317,24 @@ var DDynamicTextGeometry = /** @class */ (function (_super) {
             }
             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;
@@ -27974,7 +28401,7 @@ var DDynamicTextGeometry = /** @class */ (function (_super) {
  */
 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();
@@ -27987,8 +28414,9 @@ var DDynamicTextStyle = /** @class */ (function () {
             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;
@@ -27999,9 +28427,14 @@ var DDynamicTextStyle = /** @class */ (function () {
             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 = "";
@@ -28027,6 +28460,7 @@ var DDynamicTextStyle = /** @class */ (function () {
             fontWeight: "normal",
             fill: theme.getColor(new DBaseStateSetImpl()),
             clipping: true,
+            fitting: false,
             wordWrap: DDynamicTextStyleWordWrap.NONE,
             lineHeight: theme.getLineHeight()
         };
@@ -28053,6 +28487,14 @@ var DDynamicTextStyle = /** @class */ (function () {
         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;
@@ -28110,12 +28552,29 @@ var DDynamicTextStyle = /** @class */ (function () {
         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;
@@ -28158,11 +28617,13 @@ var DDynamicTextStyle = /** @class */ (function () {
     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 () {
@@ -28177,6 +28638,19 @@ var DDynamicTextStyle = /** @class */ (function () {
         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;
@@ -28197,15 +28671,140 @@ var DDynamicTextStyle = /** @class */ (function () {
         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
@@ -28228,8 +28827,9 @@ var DDynamicText = /** @class */ (function (_super) {
         _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,
@@ -28253,13 +28853,13 @@ var DDynamicText = /** @class */ (function (_super) {
                 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);
                 }
             }
@@ -28272,9 +28872,11 @@ var DDynamicText = /** @class */ (function (_super) {
         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,
@@ -28329,13 +28931,14 @@ var DDynamicText = /** @class */ (function (_super) {
         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;
@@ -28351,50 +28954,68 @@ var DDynamicText = /** @class */ (function (_super) {
                 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;
                 }
             }
@@ -28402,7 +29023,7 @@ var DDynamicText = /** @class */ (function (_super) {
         return isChanged;
     };
     DDynamicText.prototype.setClippingDelta = function (width, height) {
-        var delta = this._clipping.delta;
+        var delta = this._modifier.delta;
         delta.width = width;
         delta.height = height;
     };
@@ -28422,7 +29043,7 @@ var DDynamicText = /** @class */ (function (_super) {
  * 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);
@@ -28432,8 +29053,9 @@ var toTextStyle = function (theme, options, state) {
         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,
@@ -28442,6 +29064,7 @@ var toTextStyle = function (theme, options, state) {
             fontStyle: fontStyle,
             fontVariant: fontVariant,
             clipping: clipping,
+            fitting: fitting,
             wordWrap: wordWrap,
             lineHeight: lineHeight
         };
@@ -28454,6 +29077,7 @@ var toTextStyle = function (theme, options, state) {
         fontStyle: theme.getFontStyle(),
         fontVariant: theme.getFontVariant(),
         clipping: theme.getTextStyleClipping(),
+        fitting: theme.getTextStyleFitting(),
         wordWrap: theme.getTextStyleWordWrap(),
         lineHeight: theme.getLineHeight()
     };
@@ -43009,11 +43633,27 @@ var DLinks = /** @class */ (function () {
                         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;
@@ -46049,6 +46689,9 @@ var DThemeWhiteTextBase = /** @class */ (function (_super) {
     DThemeWhiteTextBase.prototype.getTextStyleClipping = function () {
         return true;
     };
+    DThemeWhiteTextBase.prototype.getTextStyleFitting = function () {
+        return false;
+    };
     DThemeWhiteTextBase.prototype.getTextStyleWordWrap = function () {
         return DDynamicTextStyleWordWrap.NONE;
     };
@@ -55763,6 +56406,9 @@ var DThemeDarkTextBase = /** @class */ (function (_super) {
     DThemeDarkTextBase.prototype.getTextStyleClipping = function () {
         return true;
     };
+    DThemeDarkTextBase.prototype.getTextStyleFitting = function () {
+        return false;
+    };
     DThemeDarkTextBase.prototype.getTextStyleWordWrap = function () {
         return DDynamicTextStyleWordWrap.NONE;
     };
@@ -64536,70 +65182,6 @@ var DynamicAtlasItemText = /** @class */ (function (_super) {
     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
@@ -72715,6 +73297,80 @@ var DChartAxisBaseBar = /** @class */ (function () {
     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
@@ -72728,6 +73384,7 @@ var DChartAxisBaseOptionParser = /** @class */ (function () {
         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;
@@ -72739,6 +73396,12 @@ var DChartAxisBaseOptionParser = /** @class */ (function () {
         }
         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 {
@@ -73720,6 +74383,7 @@ var DChartAxisBase = /** @class */ (function () {
         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);
@@ -73774,13 +74438,30 @@ var DChartAxisBase = /** @class */ (function () {
     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;
@@ -73789,7 +74470,8 @@ var DChartAxisBase = /** @class */ (function () {
     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);
@@ -73799,10 +74481,12 @@ var DChartAxisBase = /** @class */ (function () {
     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) {
@@ -73914,6 +74598,441 @@ var DChartAxisContainerImpl = /** @class */ (function () {
     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
@@ -91685,8 +92804,14 @@ exports.DBaseReflowableContainer = DBaseReflowableContainer;
 exports.DBaseReflowableImpl = DBaseReflowableImpl;
 exports.DBaseSnippetContainer = DBaseSnippetContainer;
 exports.DBaseState = DBaseState;
+exports.DBaseStateSetBlinkerDatumImpl = DBaseStateSetBlinkerDatumImpl;
+exports.DBaseStateSetBlinkerImpl = DBaseStateSetBlinkerImpl;
 exports.DBaseStateSetImpl = DBaseStateSetImpl;
 exports.DBaseStateSetImplObservable = DBaseStateSetImplObservable;
+exports.DBaseStateSetSubDatumImp = DBaseStateSetSubDatumImp;
+exports.DBaseStateSetSubImpl = DBaseStateSetSubImpl;
+exports.DBaseStateSetTickerDatumImpl = DBaseStateSetTickerDatumImpl;
+exports.DBaseStateSetTickerImpl = DBaseStateSetTickerImpl;
 exports.DBoard = DBoard;
 exports.DBorderMask = DBorderMask;
 exports.DButton = DButton;
@@ -91717,12 +92842,15 @@ exports.DCanvasContainer = DCanvasContainer;
 exports.DChart = DChart;
 exports.DChartAxisBase = DChartAxisBase;
 exports.DChartAxisBaseBar = DChartAxisBaseBar;
+exports.DChartAxisBaseGuideContainer = DChartAxisBaseGuideContainer;
 exports.DChartAxisBaseOptionParser = DChartAxisBaseOptionParser;
 exports.DChartAxisBaseTickContainer = DChartAxisBaseTickContainer;
 exports.DChartAxisBaseTickMajor = DChartAxisBaseTickMajor;
 exports.DChartAxisBaseTickMajorGridline = DChartAxisBaseTickMajorGridline;
 exports.DChartAxisBaseTickMinor = DChartAxisBaseTickMinor;
 exports.DChartAxisContainerImpl = DChartAxisContainerImpl;
+exports.DChartAxisGuideSimple = DChartAxisGuideSimple;
+exports.DChartAxisGuideSimpleShapeImpl = DChartAxisGuideSimpleShapeImpl;
 exports.DChartAxisPosition = DChartAxisPosition;
 exports.DChartAxisTickPosition = DChartAxisTickPosition;
 exports.DChartAxisX = DChartAxisX;