docs: function (opt) {
          var dataExtent = this._dataExtent;
          var axisModel = this.getAxisModel();
          var scale = axisModel.axis.scale;
          var rangePropMode = this._dataZoomModel.getRangePropMode();
          var percentExtent = [0, 100];
          var percentWindow = [];
          var valueWindow = [];
          var hasPropModeValue;
  
          each(['start', 'end'], function (prop, idx) {
              var boundPercent = opt[prop];
              var boundValue = opt[prop + 'Value'];
  
              // Notice: dataZoom is based either on `percentProp` ('start', 'end') or
              // on `valueProp` ('startValue', 'endValue'). (They are based on the data extent
              // but not min/max of axis, which will be calculated by data window then).
              // The former one is suitable for cases that a dataZoom component controls multiple
              // axes with different unit or extent, and the latter one is suitable for accurate
              // zoom by pixel (e.g., in dataZoomSelect).
              // we use `getRangePropMode()` to mark which prop is used. `rangePropMode` is updated
              // only when setOption or dispatchAction, otherwise it remains its original value.
              // (Why not only record `percentProp` and always map to `valueProp`? Because
              // the map `valueProp` -> `percentProp` -> `valueProp` probably not the original
              // `valueProp`. consider two axes constrolled by one dataZoom. They have different
              // data extent. All of values that are overflow the `dataExtent` will be calculated
              // to percent '100%').
  
              if (rangePropMode[idx] === 'percent') {
                  boundPercent == null && (boundPercent = percentExtent[idx]);
                  // Use scale.parse to math round for category or time axis.
                  boundValue = scale.parse(numberUtil.linearMap(
                      boundPercent, percentExtent, dataExtent
                  ));
              }
              else {
                  hasPropModeValue = true;
                  boundValue = boundValue == null ? dataExtent[idx] : scale.parse(boundValue);
                  // Calculating `percent` from `value` may be not accurate, because
                  // This calculation can not be inversed, because all of values that
                  // are overflow the `dataExtent` will be calculated to percent '100%'
                  boundPercent = numberUtil.linearMap(
                      boundValue, dataExtent, percentExtent
                  );
              }
  
              // valueWindow[idx] = round(boundValue);
              // percentWindow[idx] = round(boundPercent);
              valueWindow[idx] = boundValue;
              percentWindow[idx] = boundPercent;
          });
  
          asc(valueWindow);
          asc(percentWindow);
  
          // The windows from user calling of `dispatchAction` might be out of the extent,
          // or do not obey the `min/maxSpan`, `min/maxValueSpan`. But we dont restrict window
          // by `zoomLock` here, because we see `zoomLock` just as a interaction constraint,
          // where API is able to initialize/modify the window size even though `zoomLock`
          // specified.
          var spans = this._minMaxSpan;
          hasPropModeValue
              ? restrictSet(valueWindow, percentWindow, dataExtent, percentExtent, false)
              : restrictSet(percentWindow, valueWindow, percentExtent, dataExtent, true);
  
          function restrictSet(fromWindow, toWindow, fromExtent, toExtent, toValue) {
              var suffix = toValue ? 'Span' : 'ValueSpan';
              sliderMove(0, fromWindow, fromExtent, 'all', spans['min' + suffix], spans['max' + suffix]);
              for (var i = 0; i < 2; i++) {
                  toWindow[i] = numberUtil.linearMap(fromWindow[i], fromExtent, toExtent, true);
                  toValue && (toWindow[i] = scale.parse(toWindow[i]));
              }
          }
  
          return {
              valueWindow: valueWindow,
              percentWindow: percentWindow
          };
      }