text: function createMVTWithStyle(Cesium,ol,createMapboxStreetsV6Style,options) {
      function MVTProvider(options) {
          options = Cesium.defaultValue(options, Cesium.defaultValue.EMPTY_OBJECT);
  
          this._tilingScheme = Cesium.defined(options.tilingScheme) ? options.tilingScheme : new Cesium.WebMercatorTilingScheme({ ellipsoid : options.ellipsoid });
          this._tileWidth = Cesium.defaultValue(options.tileWidth, 512);
          this._tileHeight = Cesium.defaultValue(options.tileHeight, 512);
          this._readyPromise = Cesium.when.resolve(true);
          this._ol = ol;
          this._mvtParser = new this._ol.format.MVT();
  
          this._styleFun = createMapboxStreetsV6Style;
          this._key = Cesium.defaultValue(options.key, "");
          this._url = Cesium.defaultValue(options.url, "https://a.tiles.mapbox.com/v4/mapbox.mapbox-streets-v6/{z}/{x}/{y}.vector.pbf?access_token={k}");
  
          var sw = this._tilingScheme._rectangleSouthwestInMeters;
          var ne = this._tilingScheme._rectangleNortheastInMeters;
          var mapExtent = [sw.x,sw.y,ne.x,ne.y];
          this._resolutions = ol.tilegrid.resolutionsFromExtent(
              mapExtent, 22, this._tileWidth);
  
          this._pixelRatio = 1;
          this._transform = [0.125,0,0,0.125,0,0];
          this._replays =  ["Default","Image","Polygon", "LineString","Text"];
  
          this._tileQueue = new Cesium.TileReplacementQueue();
          this._cacheSize = 1000;
      }
  
      Cesium.defineProperties(MVTProvider.prototype, {
          proxy : {
              get : function() {
                  return undefined;
              }
          },
  
          tileWidth : {
              get : function() {
                  return this._tileWidth;
              }
          },
  
          tileHeight: {
              get : function() {
                  return this._tileHeight;
              }
          },
  
          maximumLevel : {
              get : function() {
                  return undefined;
              }
          },
  
          minimumLevel : {
              get : function() {
                  return undefined;
              }
          },
  
          tilingScheme : {
              get : function() {
                  return this._tilingScheme;
              }
          },
  
          rectangle : {
              get : function() {
                  return this._tilingScheme.rectangle;
              }
          },
  
          tileDiscardPolicy : {
              get : function() {
                  return undefined;
              }
          },
  
          errorEvent : {
              get : function() {
                  return this._errorEvent;
              }
          },
  
          ready : {
              get : function() {
                  return true;
              }
          },
  
          readyPromise : {
              get : function() {
                  return this._readyPromise;
              }
          },
  
          credit : {
              get : function() {
                  return undefined;
              }
          },
  
          hasAlphaChannel : {
              get : function() {
                  return true;
              }
          }
      });
  
      MVTProvider.prototype.getTileCredits = function(x, y, level) {
          return undefined;
      };
  
      function findTileInQueue(x, y, level,tileQueue){
          var item = tileQueue.head;
          while(item != undefined && !(item.xMvt == x && item.yMvt ==y && item.zMvt == level)){
              item = item.replacementNext;
          }
          return item;
      };
  
      function remove(tileReplacementQueue, item) {
          var previous = item.replacementPrevious;
          var next = item.replacementNext;
  
          if (item === tileReplacementQueue._lastBeforeStartOfFrame) {
              tileReplacementQueue._lastBeforeStartOfFrame = next;
          }
  
          if (item === tileReplacementQueue.head) {
              tileReplacementQueue.head = next;
          } else {
              previous.replacementNext = next;
          }
  
          if (item === tileReplacementQueue.tail) {
              tileReplacementQueue.tail = previous;
          } else {
              next.replacementPrevious = previous;
          }
  
          item.replacementPrevious = undefined;
          item.replacementNext = undefined;
  
          --tileReplacementQueue.count;
      }
  
      function trimTiles(tileQueue,maximumTiles) {
          var tileToTrim = tileQueue.tail;
          while (tileQueue.count > maximumTiles &&
                 Cesium.defined(tileToTrim)) {
              var previous = tileToTrim.replacementPrevious;
  
              remove(tileQueue, tileToTrim);
              delete tileToTrim;
              tileToTrim = null;
  
              tileToTrim = previous;
          }
      };
  
      MVTProvider.prototype.requestImage = function(x, y, level, request) {
          var cacheTile = findTileInQueue(x, y, level,this._tileQueue);
          if(cacheTile != undefined){
              return cacheTile;
          }
          else{
              var that = this;
              var url = this._url;
              url = url.replace('{x}', x).replace('{y}', y).replace('{z}', level).replace('{k}', this._key);
              var tilerequest = function(x,y,z){
                  var resource = Cesium.Resource.createIfNeeded(url);
  
                  return resource.fetchArrayBuffer().then(function(arrayBuffer) {
                      var canvas = document.createElement('canvas');
                      canvas.width = 512;
                      canvas.height = 512;
                      var vectorContext = canvas.getContext('2d');
          
                      var features = that._mvtParser.readFeatures(arrayBuffer);
          
                      var styleFun = that._styleFun();
          
                      var extent = [0,0,4096,4096];
                      var _replayGroup = new ol.render.canvas.ReplayGroup(0, extent,
                          8,true,100);
          
                      for(var i=0;i<features.length;i++){
                          var feature = features[i];
                          var styles = styleFun(features[i],that._resolutions[level]);
                          for(var j=0;j<styles.length;j++)
                          {
                              ol.renderer.vector.renderFeature_(_replayGroup, feature, styles[j],16);
                          }
                      }
                      _replayGroup.finish();
                      
                      _replayGroup.replay(vectorContext, that._pixelRatio, that._transform, 0, {}, that._replays, true);
                      if(that._tileQueue.count>that._cacheSize){
                          trimTiles(that._tileQueue,that._cacheSize/2);
                      }
  
                      canvas.xMvt = x;
                      canvas.yMvt = y;
                      canvas.zMvt = z;
                      that._tileQueue.markTileRendered(canvas);
  
                      delete _replayGroup;
                      _replayGroup = null;
  
                      return canvas;
                  }).otherwise(function(error) {                
                  });
                  // return Cesium.loadArrayBuffer(url).then(function(arrayBuffer) {
                      
                  // }).otherwise(function(error) {
                  // });
              }(x,y,level);
          }
      };
  
      MVTProvider.prototype.pickFeatures = function(x, y, level, longitude, latitude) {
          return undefined;
      };
  
      return new MVTProvider(options);
  }