text: /*!
   * vue-slim-better-scroll v1.7.3
   * Copyright (c) 2018-present, komo <ko.momo@qq.com>
   * Released under the MIT License.
   */
  
  (function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('better-scroll')) :
    typeof define === 'function' && define.amd ? define(['better-scroll'], factory) :
    (global = global || self, global['vue-slim-better-scroll'] = factory(global.BScroll));
  }(this, function (BScroll) { 'use strict';
  
    BScroll = BScroll && BScroll.hasOwnProperty('default') ? BScroll['default'] : BScroll;
  
    function _defineProperty(obj, key, value) {
      if (key in obj) {
        Object.defineProperty(obj, key, {
          value: value,
          enumerable: true,
          configurable: true,
          writable: true
        });
      } else {
        obj[key] = value;
      }
  
      return obj;
    }
  
    var defineProperty = _defineProperty;
  
    function _objectSpread(target) {
      for (var i = 1; i < arguments.length; i++) {
        var source = arguments[i] != null ? arguments[i] : {};
        var ownKeys = Object.keys(source);
  
        if (typeof Object.getOwnPropertySymbols === 'function') {
          ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {
            return Object.getOwnPropertyDescriptor(source, sym).enumerable;
          }));
        }
  
        ownKeys.forEach(function (key) {
          defineProperty(target, key, source[key]);
        });
      }
  
      return target;
    }
  
    var objectSpread = _objectSpread;
  
    function createCommonjsModule(fn, module) {
    	return module = { exports: {} }, fn(module, module.exports), module.exports;
    }
  
    var runtime = createCommonjsModule(function (module) {
    /**
     * Copyright (c) 2014-present, Facebook, Inc.
     *
     * This source code is licensed under the MIT license found in the
     * LICENSE file in the root directory of this source tree.
     */
  
    !(function(global) {
  
      var Op = Object.prototype;
      var hasOwn = Op.hasOwnProperty;
      var undefined$1; // More compressible than void 0.
      var $Symbol = typeof Symbol === "function" ? Symbol : {};
      var iteratorSymbol = $Symbol.iterator || "@@iterator";
      var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
      var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
      var runtime = global.regeneratorRuntime;
      if (runtime) {
        {
          // If regeneratorRuntime is defined globally and we're in a module,
          // make the exports object identical to regeneratorRuntime.
          module.exports = runtime;
        }
        // Don't bother evaluating the rest of this file if the runtime was
        // already defined globally.
        return;
      }
  
      // Define the runtime globally (as expected by generated code) as either
      // module.exports (if we're in a module) or a new, empty object.
      runtime = global.regeneratorRuntime = module.exports;
  
      function wrap(innerFn, outerFn, self, tryLocsList) {
        // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
        var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
        var generator = Object.create(protoGenerator.prototype);
        var context = new Context(tryLocsList || []);
  
        // The ._invoke method unifies the implementations of the .next,
        // .throw, and .return methods.
        generator._invoke = makeInvokeMethod(innerFn, self, context);
  
        return generator;
      }
      runtime.wrap = wrap;
  
      // Try/catch helper to minimize deoptimizations. Returns a completion
      // record like context.tryEntries[i].completion. This interface could
      // have been (and was previously) designed to take a closure to be
      // invoked without arguments, but in all the cases we care about we
      // already have an existing method we want to call, so there's no need
      // to create a new function object. We can even get away with assuming
      // the method takes exactly one argument, since that happens to be true
      // in every case, so we don't have to touch the arguments object. The
      // only additional allocation required is the completion record, which
      // has a stable shape and so hopefully should be cheap to allocate.
      function tryCatch(fn, obj, arg) {
        try {
          return { type: "normal", arg: fn.call(obj, arg) };
        } catch (err) {
          return { type: "throw", arg: err };
        }
      }
  
      var GenStateSuspendedStart = "suspendedStart";
      var GenStateSuspendedYield = "suspendedYield";
      var GenStateExecuting = "executing";
      var GenStateCompleted = "completed";
  
      // Returning this object from the innerFn has the same effect as
      // breaking out of the dispatch switch statement.
      var ContinueSentinel = {};
  
      // Dummy constructor functions that we use as the .constructor and
      // .constructor.prototype properties for functions that return Generator
      // objects. For full spec compliance, you may wish to configure your
      // minifier not to mangle the names of these two functions.
      function Generator() {}
      function GeneratorFunction() {}
      function GeneratorFunctionPrototype() {}
  
      // This is a polyfill for %IteratorPrototype% for environments that
      // don't natively support it.
      var IteratorPrototype = {};
      IteratorPrototype[iteratorSymbol] = function () {
        return this;
      };
  
      var getProto = Object.getPrototypeOf;
      var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
      if (NativeIteratorPrototype &&
          NativeIteratorPrototype !== Op &&
          hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
        // This environment has a native %IteratorPrototype%; use it instead
        // of the polyfill.
        IteratorPrototype = NativeIteratorPrototype;
      }
  
      var Gp = GeneratorFunctionPrototype.prototype =
        Generator.prototype = Object.create(IteratorPrototype);
      GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
      GeneratorFunctionPrototype.constructor = GeneratorFunction;
      GeneratorFunctionPrototype[toStringTagSymbol] =
        GeneratorFunction.displayName = "GeneratorFunction";
  
      // Helper for defining the .next, .throw, and .return methods of the
      // Iterator interface in terms of a single ._invoke method.
      function defineIteratorMethods(prototype) {
        ["next", "throw", "return"].forEach(function(method) {
          prototype[method] = function(arg) {
            return this._invoke(method, arg);
          };
        });
      }
  
      runtime.isGeneratorFunction = function(genFun) {
        var ctor = typeof genFun === "function" && genFun.constructor;
        return ctor
          ? ctor === GeneratorFunction ||
            // For the native GeneratorFunction constructor, the best we can
            // do is to check its .name property.
            (ctor.displayName || ctor.name) === "GeneratorFunction"
          : false;
      };
  
      runtime.mark = function(genFun) {
        if (Object.setPrototypeOf) {
          Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
        } else {
          genFun.__proto__ = GeneratorFunctionPrototype;
          if (!(toStringTagSymbol in genFun)) {
            genFun[toStringTagSymbol] = "GeneratorFunction";
          }
        }
        genFun.prototype = Object.create(Gp);
        return genFun;
      };
  
      // Within the body of any async function, `await x` is transformed to
      // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
      // `hasOwn.call(value, "__await")` to determine if the yielded value is
      // meant to be awaited.
      runtime.awrap = function(arg) {
        return { __await: arg };
      };
  
      function AsyncIterator(generator) {
        function invoke(method, arg, resolve, reject) {
          var record = tryCatch(generator[method], generator, arg);
          if (record.type === "throw") {
            reject(record.arg);
          } else {
            var result = record.arg;
            var value = result.value;
            if (value &&
                typeof value === "object" &&
                hasOwn.call(value, "__await")) {
              return Promise.resolve(value.__await).then(function(value) {
                invoke("next", value, resolve, reject);
              }, function(err) {
                invoke("throw", err, resolve, reject);
              });
            }
  
            return Promise.resolve(value).then(function(unwrapped) {
              // When a yielded Promise is resolved, its final value becomes
              // the .value of the Promise<{value,done}> result for the
              // current iteration.
              result.value = unwrapped;
              resolve(result);
            }, function(error) {
              // If a rejected Promise was yielded, throw the rejection back
              // into the async generator function so it can be handled there.
              return invoke("throw", error, resolve, reject);
            });
          }
        }
  
        var previousPromise;
  
        function enqueue(method, arg) {
          function callInvokeWithMethodAndArg() {
            return new Promise(function(resolve, reject) {
              invoke(method, arg, resolve, reject);
            });
          }
  
          return previousPromise =
            // If enqueue has been called before, then we want to wait until
            // all previous Promises have been resolved before calling invoke,
            // so that results are always delivered in the correct order. If
            // enqueue has not been called before, then it is important to
            // call invoke immediately, without waiting on a callback to fire,
            // so that the async generator function has the opportunity to do
            // any necessary setup in a predictable way. This predictability
            // is why the Promise constructor synchronously invokes its
            // executor callback, and why async functions synchronously
            // execute code before the first await. Since we implement simple
            // async functions in terms of async generators, it is especially
            // important to get this right, even though it requires care.
            previousPromise ? previousPromise.then(
              callInvokeWithMethodAndArg,
              // Avoid propagating failures to Promises returned by later
              // invocations of the iterator.
              callInvokeWithMethodAndArg
            ) : callInvokeWithMethodAndArg();
        }
  
        // Define the unified helper method that is used to implement .next,
        // .throw, and .return (see defineIteratorMethods).
        this._invoke = enqueue;
      }
  
      defineIteratorMethods(AsyncIterator.prototype);
      AsyncIterator.prototype[asyncIteratorSymbol] = function () {
        return this;
      };
      runtime.AsyncIterator = AsyncIterator;
  
      // Note that simple async functions are implemented on top of
      // AsyncIterator objects; they just return a Promise for the value of
      // the final result produced by the iterator.
      runtime.async = function(innerFn, outerFn, self, tryLocsList) {
        var iter = new AsyncIterator(
          wrap(innerFn, outerFn, self, tryLocsList)
        );
  
        return runtime.isGeneratorFunction(outerFn)
          ? iter // If outerFn is a generator, return the full iterator.
          : iter.next().then(function(result) {
              return result.done ? result.value : iter.next();
            });
      };
  
      function makeInvokeMethod(innerFn, self, context) {
        var state = GenStateSuspendedStart;
  
        return function invoke(method, arg) {
          if (state === GenStateExecuting) {
            throw new Error("Generator is already running");
          }
  
          if (state === GenStateCompleted) {
            if (method === "throw") {
              throw arg;
            }
  
            // Be forgiving, per 25.3.3.3.3 of the spec:
            // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
            return doneResult();
          }
  
          context.method = method;
          context.arg = arg;
  
          while (true) {
            var delegate = context.delegate;
            if (delegate) {
              var delegateResult = maybeInvokeDelegate(delegate, context);
              if (delegateResult) {
                if (delegateResult === ContinueSentinel) continue;
                return delegateResult;
              }
            }
  
            if (context.method === "next") {
              // Setting context._sent for legacy support of Babel's
              // function.sent implementation.
              context.sent = context._sent = context.arg;
  
            } else if (context.method === "throw") {
              if (state === GenStateSuspendedStart) {
                state = GenStateCompleted;
                throw context.arg;
              }
  
              context.dispatchException(context.arg);
  
            } else if (context.method === "return") {
              context.abrupt("return", context.arg);
            }
  
            state = GenStateExecuting;
  
            var record = tryCatch(innerFn, self, context);
            if (record.type === "normal") {
              // If an exception is thrown from innerFn, we leave state ===
              // GenStateExecuting and loop back for another invocation.
              state = context.done
                ? GenStateCompleted
                : GenStateSuspendedYield;
  
              if (record.arg === ContinueSentinel) {
                continue;
              }
  
              return {
                value: record.arg,
                done: context.done
              };
  
            } else if (record.type === "throw") {
              state = GenStateCompleted;
              // Dispatch the exception by looping back around to the
              // context.dispatchException(context.arg) call above.
              context.method = "throw";
              context.arg = record.arg;
            }
          }
        };
      }
  
      // Call delegate.iterator[context.method](context.arg) and handle the
      // result, either by returning a { value, done } result from the
      // delegate iterator, or by modifying context.method and context.arg,
      // setting context.delegate to null, and returning the ContinueSentinel.
      function maybeInvokeDelegate(delegate, context) {
        var method = delegate.iterator[context.method];
        if (method === undefined$1) {
          // A .throw or .return when the delegate iterator has no .throw
          // method always terminates the yield* loop.
          context.delegate = null;
  
          if (context.method === "throw") {
            if (delegate.iterator.return) {
              // If the delegate iterator has a return method, give it a
              // chance to clean up.
              context.method = "return";
              context.arg = undefined$1;
              maybeInvokeDelegate(delegate, context);
  
              if (context.method === "throw") {
                // If maybeInvokeDelegate(context) changed context.method from
                // "return" to "throw", let that override the TypeError below.
                return ContinueSentinel;
              }
            }
  
            context.method = "throw";
            context.arg = new TypeError(
              "The iterator does not provide a 'throw' method");
          }
  
          return ContinueSentinel;
        }
  
        var record = tryCatch(method, delegate.iterator, context.arg);
  
        if (record.type === "throw") {
          context.method = "throw";
          context.arg = record.arg;
          context.delegate = null;
          return ContinueSentinel;
        }
  
        var info = record.arg;
  
        if (! info) {
          context.method = "throw";
          context.arg = new TypeError("iterator result is not an object");
          context.delegate = null;
          return ContinueSentinel;
        }
  
        if (info.done) {
          // Assign the result of the finished delegate to the temporary
          // variable specified by delegate.resultName (see delegateYield).
          context[delegate.resultName] = info.value;
  
          // Resume execution at the desired location (see delegateYield).
          context.next = delegate.nextLoc;
  
          // If context.method was "throw" but the delegate handled the
          // exception, let the outer generator proceed normally. If
          // context.method was "next", forget context.arg since it has been
          // "consumed" by the delegate iterator. If context.method was
          // "return", allow the original .return call to continue in the
          // outer generator.
          if (context.method !== "return") {
            context.method = "next";
            context.arg = undefined$1;
          }
  
        } else {
          // Re-yield the result returned by the delegate method.
          return info;
        }
  
        // The delegate iterator is finished, so forget it and continue with
        // the outer generator.
        context.delegate = null;
        return ContinueSentinel;
      }
  
      // Define Generator.prototype.{next,throw,return} in terms of the
      // unified ._invoke helper method.
      defineIteratorMethods(Gp);
  
      Gp[toStringTagSymbol] = "Generator";
  
      // A Generator should always return itself as the iterator object when the
      // @@iterator function is called on it. Some browsers' implementations of the
      // iterator prototype chain incorrectly implement this, causing the Generator
      // object to not be returned from this call. This ensures that doesn't happen.
      // See https://github.com/facebook/regenerator/issues/274 for more details.
      Gp[iteratorSymbol] = function() {
        return this;
      };
  
      Gp.toString = function() {
        return "[object Generator]";
      };
  
      function pushTryEntry(locs) {
        var entry = { tryLoc: locs[0] };
  
        if (1 in locs) {
          entry.catchLoc = locs[1];
        }
  
        if (2 in locs) {
          entry.finallyLoc = locs[2];
          entry.afterLoc = locs[3];
        }
  
        this.tryEntries.push(entry);
      }
  
      function resetTryEntry(entry) {
        var record = entry.completion || {};
        record.type = "normal";
        delete record.arg;
        entry.completion = record;
      }
  
      function Context(tryLocsList) {
        // The root entry object (effectively a try statement without a catch
        // or a finally block) gives us a place to store values thrown from
        // locations where there is no enclosing try statement.
        this.tryEntries = [{ tryLoc: "root" }];
        tryLocsList.forEach(pushTryEntry, this);
        this.reset(true);
      }
  
      runtime.keys = function(object) {
        var keys = [];
        for (var key in object) {
          keys.push(key);
        }
        keys.reverse();
  
        // Rather than returning an object with a next method, we keep
        // things simple and return the next function itself.
        return function next() {
          while (keys.length) {
            var key = keys.pop();
            if (key in object) {
              next.value = key;
              next.done = false;
              return next;
            }
          }
  
          // To avoid creating an additional object, we just hang the .value
          // and .done properties off the next function object itself. This
          // also ensures that the minifier will not anonymize the function.
          next.done = true;
          return next;
        };
      };
  
      function values(iterable) {
        if (iterable) {
          var iteratorMethod = iterable[iteratorSymbol];
          if (iteratorMethod) {
            return iteratorMethod.call(iterable);
          }
  
          if (typeof iterable.next === "function") {
            return iterable;
          }
  
          if (!isNaN(iterable.length)) {
            var i = -1, next = function next() {
              while (++i < iterable.length) {
                if (hasOwn.call(iterable, i)) {
                  next.value = iterable[i];
                  next.done = false;
                  return next;
                }
              }
  
              next.value = undefined$1;
              next.done = true;
  
              return next;
            };
  
            return next.next = next;
          }
        }
  
        // Return an iterator with no values.
        return { next: doneResult };
      }
      runtime.values = values;
  
      function doneResult() {
        return { value: undefined$1, done: true };
      }
  
      Context.prototype = {
        constructor: Context,
  
        reset: function(skipTempReset) {
          this.prev = 0;
          this.next = 0;
          // Resetting context._sent for legacy support of Babel's
          // function.sent implementation.
          this.sent = this._sent = undefined$1;
          this.done = false;
          this.delegate = null;
  
          this.method = "next";
          this.arg = undefined$1;
  
          this.tryEntries.forEach(resetTryEntry);
  
          if (!skipTempReset) {
            for (var name in this) {
              // Not sure about the optimal order of these conditions:
              if (name.charAt(0) === "t" &&
                  hasOwn.call(this, name) &&
                  !isNaN(+name.slice(1))) {
                this[name] = undefined$1;
              }
            }
          }
        },
  
        stop: function() {
          this.done = true;
  
          var rootEntry = this.tryEntries[0];
          var rootRecord = rootEntry.completion;
          if (rootRecord.type === "throw") {
            throw rootRecord.arg;
          }
  
          return this.rval;
        },
  
        dispatchException: function(exception) {
          if (this.done) {
            throw exception;
          }
  
          var context = this;
          function handle(loc, caught) {
            record.type = "throw";
            record.arg = exception;
            context.next = loc;
  
            if (caught) {
              // If the dispatched exception was caught by a catch block,
              // then let that catch block handle the exception normally.
              context.method = "next";
              context.arg = undefined$1;
            }
  
            return !! caught;
          }
  
          for (var i = this.tryEntries.length - 1; i >= 0; --i) {
            var entry = this.tryEntries[i];
            var record = entry.completion;
  
            if (entry.tryLoc === "root") {
              // Exception thrown outside of any try block that could handle
              // it, so set the completion value of the entire function to
              // throw the exception.
              return handle("end");
            }
  
            if (entry.tryLoc <= this.prev) {
              var hasCatch = hasOwn.call(entry, "catchLoc");
              var hasFinally = hasOwn.call(entry, "finallyLoc");
  
              if (hasCatch && hasFinally) {
                if (this.prev < entry.catchLoc) {
                  return handle(entry.catchLoc, true);
                } else if (this.prev < entry.finallyLoc) {
                  return handle(entry.finallyLoc);
                }
  
              } else if (hasCatch) {
                if (this.prev < entry.catchLoc) {
                  return handle(entry.catchLoc, true);
                }
  
              } else if (hasFinally) {
                if (this.prev < entry.finallyLoc) {
                  return handle(entry.finallyLoc);
                }
  
              } else {
                throw new Error("try statement without catch or finally");
              }
            }
          }
        },
  
        abrupt: function(type, arg) {
          for (var i = this.tryEntries.length - 1; i >= 0; --i) {
            var entry = this.tryEntries[i];
            if (entry.tryLoc <= this.prev &&
                hasOwn.call(entry, "finallyLoc") &&
                this.prev < entry.finallyLoc) {
              var finallyEntry = entry;
              break;
            }
          }
  
          if (finallyEntry &&
              (type === "break" ||
               type === "continue") &&
              finallyEntry.tryLoc <= arg &&
              arg <= finallyEntry.finallyLoc) {
            // Ignore the finally entry if control is not jumping to a
            // location outside the try/catch block.
            finallyEntry = null;
          }
  
          var record = finallyEntry ? finallyEntry.completion : {};
          record.type = type;
          record.arg = arg;
  
          if (finallyEntry) {
            this.method = "next";
            this.next = finallyEntry.finallyLoc;
            return ContinueSentinel;
          }
  
          return this.complete(record);
        },
  
        complete: function(record, afterLoc) {
          if (record.type === "throw") {
            throw record.arg;
          }
  
          if (record.type === "break" ||
              record.type === "continue") {
            this.next = record.arg;
          } else if (record.type === "return") {
            this.rval = this.arg = record.arg;
            this.method = "return";
            this.next = "end";
          } else if (record.type === "normal" && afterLoc) {
            this.next = afterLoc;
          }
  
          return ContinueSentinel;
        },
  
        finish: function(finallyLoc) {
          for (var i = this.tryEntries.length - 1; i >= 0; --i) {
            var entry = this.tryEntries[i];
            if (entry.finallyLoc === finallyLoc) {
              this.complete(entry.completion, entry.afterLoc);
              resetTryEntry(entry);
              return ContinueSentinel;
            }
          }
        },
  
        "catch": function(tryLoc) {
          for (var i = this.tryEntries.length - 1; i >= 0; --i) {
            var entry = this.tryEntries[i];
            if (entry.tryLoc === tryLoc) {
              var record = entry.completion;
              if (record.type === "throw") {
                var thrown = record.arg;
                resetTryEntry(entry);
              }
              return thrown;
            }
          }
  
          // The context.catch method must only be called with a location
          // argument that corresponds to a known catch block.
          throw new Error("illegal catch attempt");
        },
  
        delegateYield: function(iterable, resultName, nextLoc) {
          this.delegate = {
            iterator: values(iterable),
            resultName: resultName,
            nextLoc: nextLoc
          };
  
          if (this.method === "next") {
            // Deliberately forget the last sent value so that we don't
            // accidentally pass it on to the delegate.
            this.arg = undefined$1;
          }
  
          return ContinueSentinel;
        }
      };
    })(
      // In sloppy mode, unbound `this` refers to the global object, fallback to
      // Function constructor if we're in global strict mode. That is sadly a form
      // of indirect eval which violates Content Security Policy.
      (function() {
        return this || (typeof self === "object" && self);
      })() || Function("return this")()
    );
    });
  
    /**
     * Copyright (c) 2014-present, Facebook, Inc.
     *
     * This source code is licensed under the MIT license found in the
     * LICENSE file in the root directory of this source tree.
     */
  
    // This method of obtaining a reference to the global object needs to be
    // kept identical to the way it is obtained in runtime.js
    var g = (function() {
      return this || (typeof self === "object" && self);
    })() || Function("return this")();
  
    // Use `getOwnPropertyNames` because not all browsers support calling
    // `hasOwnProperty` on the global `self` object in a worker. See #183.
    var hadRuntime = g.regeneratorRuntime &&
      Object.getOwnPropertyNames(g).indexOf("regeneratorRuntime") >= 0;
  
    // Save the old regeneratorRuntime in case it needs to be restored later.
    var oldRuntime = hadRuntime && g.regeneratorRuntime;
  
    // Force reevalutation of runtime.js.
    g.regeneratorRuntime = undefined;
  
    var runtimeModule = runtime;
  
    if (hadRuntime) {
      // Restore the original runtime.
      g.regeneratorRuntime = oldRuntime;
    } else {
      // Remove the global property added by runtime.js.
      try {
        delete g.regeneratorRuntime;
      } catch(e) {
        g.regeneratorRuntime = undefined;
      }
    }
  
    var regenerator = runtimeModule;
  
    function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
      try {
        var info = gen[key](arg);
        var value = info.value;
      } catch (error) {
        reject(error);
        return;
      }
  
      if (info.done) {
        resolve(value);
      } else {
        Promise.resolve(value).then(_next, _throw);
      }
    }
  
    function _asyncToGenerator(fn) {
      return function () {
        var self = this,
            args = arguments;
        return new Promise(function (resolve, reject) {
          var gen = fn.apply(self, args);
  
          function _next(value) {
            asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
          }
  
          function _throw(err) {
            asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
          }
  
          _next(undefined);
        });
      };
    }
  
    var asyncToGenerator = _asyncToGenerator;
  
    var pre = 'vue-slim-better-scroll';
    var mixin = {
      methods: {
        // 生成 css class
        c: function c(className) {
          return className ? "".concat(pre).concat(className) : "".concat(pre);
        }
      }
    };
  
    //
    var script = {
      name: 'Loading',
      mixins: [mixin]
    };
  
    function normalizeComponent(template, style, script, scopeId, isFunctionalTemplate, moduleIdentifier
    /* server only */
    , shadowMode, createInjector, createInjectorSSR, createInjectorShadow) {
      if (typeof shadowMode !== 'boolean') {
        createInjectorSSR = createInjector;
        createInjector = shadowMode;
        shadowMode = false;
      } // Vue.extend constructor export interop.
  
  
      var options = typeof script === 'function' ? script.options : script; // render functions
  
      if (template && template.render) {
        options.render = template.render;
        options.staticRenderFns = template.staticRenderFns;
        options._compiled = true; // functional template
  
        if (isFunctionalTemplate) {
          options.functional = true;
        }
      } // scopedId
  
  
      if (scopeId) {
        options._scopeId = scopeId;
      }
  
      var hook;
  
      if (moduleIdentifier) {
        // server build
        hook = function hook(context) {
          // 2.3 injection
          context = context || // cached call
          this.$vnode && this.$vnode.ssrContext || // stateful
          this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext; // functional
          // 2.2 with runInNewContext: true
  
          if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {
            context = __VUE_SSR_CONTEXT__;
          } // inject component styles
  
  
          if (style) {
            style.call(this, createInjectorSSR(context));
          } // register component module identifier for async chunk inference
  
  
          if (context && context._registeredComponents) {
            context._registeredComponents.add(moduleIdentifier);
          }
        }; // used by ssr in case component is cached and beforeCreate
        // never gets called
  
  
        options._ssrRegister = hook;
      } else if (style) {
        hook = shadowMode ? function () {
          style.call(this, createInjectorShadow(this.$root.$options.shadowRoot));
        } : function (context) {
          style.call(this, createInjector(context));
        };
      }
  
      if (hook) {
        if (options.functional) {
          // register for functional component in vue file
          var originalRender = options.render;
  
          options.render = function renderWithStyleInjection(h, context) {
            hook.call(context);
            return originalRender(h, context);
          };
        } else {
          // inject component registration as beforeCreate hook
          var existing = options.beforeCreate;
          options.beforeCreate = existing ? [].concat(existing, hook) : [hook];
        }
      }
  
      return script;
    }
  
    var normalizeComponent_1 = normalizeComponent;
  
    var isOldIE = typeof navigator !== 'undefined' && /msie [6-9]\\b/.test(navigator.userAgent.toLowerCase());
    function createInjector(context) {
      return function (id, style) {
        return addStyle(id, style);
      };
    }
    var HEAD = document.head || document.getElementsByTagName('head')[0];
    var styles = {};
  
    function addStyle(id, css) {
      var group = isOldIE ? css.media || 'default' : id;
      var style = styles[group] || (styles[group] = {
        ids: new Set(),
        styles: []
      });
  
      if (!style.ids.has(id)) {
        style.ids.add(id);
        var code = css.source;
  
        if (css.map) {
          // https://developer.chrome.com/devtools/docs/javascript-debugging
          // this makes source maps inside style tags work properly in Chrome
          code += '\n/*# sourceURL=' + css.map.sources[0] + ' */'; // http://stackoverflow.com/a/26603875
  
          code += '\n/*# sourceMappingURL=data:application/json;base64,' + btoa(unescape(encodeURIComponent(JSON.stringify(css.map)))) + ' */';
        }
  
        if (!style.element) {
          style.element = document.createElement('style');
          style.element.type = 'text/css';
          if (css.media) style.element.setAttribute('media', css.media);
          HEAD.appendChild(style.element);
        }
  
        if ('styleSheet' in style.element) {
          style.styles.push(code);
          style.element.styleSheet.cssText = style.styles.filter(Boolean).join('\n');
        } else {
          var index = style.ids.size - 1;
          var textNode = document.createTextNode(code);
          var nodes = style.element.childNodes;
          if (nodes[index]) style.element.removeChild(nodes[index]);
          if (nodes.length) style.element.insertBefore(textNode, nodes[index]);else style.element.appendChild(textNode);
        }
      }
    }
  
    var browser = createInjector;
  
    /* script */
    const __vue_script__ = script;
  
    /* template */
    var __vue_render__ = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{class:_vm.c('__loading')},_vm._l((12),function(item){return _c('i',{key:item})}),0)};
    var __vue_staticRenderFns__ = [];
  
      /* style */
      const __vue_inject_styles__ = function (inject) {
        if (!inject) return
        inject("data-v-9479dd72_0", { source: ".vue-slim-better-scroll__loading{width:20px;height:20px;position:relative;display:block;box-sizing:border-box;-webkit-animation:spinner-rotate 1s linear infinite;animation:spinner-rotate 1s linear infinite;-webkit-animation-timing-function:steps(12);animation-timing-function:steps(12);color:#8c8c8c}.vue-slim-better-scroll__loading i{top:0;left:0;width:100%;height:100%;position:absolute}.vue-slim-better-scroll__loading i::before{width:9%;height:25%;content:'';display:block;margin:0 auto;border-radius:10px;background-color:currentColor}.vue-slim-better-scroll__loading i:nth-of-type(1){opacity:1;-webkit-transform:rotate(30deg);-ms-transform:rotate(30deg);transform:rotate(30deg)}.vue-slim-better-scroll__loading i:nth-of-type(2){opacity:.9375;-webkit-transform:rotate(60deg);-ms-transform:rotate(60deg);transform:rotate(60deg)}.vue-slim-better-scroll__loading i:nth-of-type(3){opacity:.875;-webkit-transform:rotate(90deg);-ms-transform:rotate(90deg);transform:rotate(90deg)}.vue-slim-better-scroll__loading i:nth-of-type(4){opacity:.8125;-webkit-transform:rotate(120deg);-ms-transform:rotate(120deg);transform:rotate(120deg)}.vue-slim-better-scroll__loading i:nth-of-type(5){opacity:.75;-webkit-transform:rotate(150deg);-ms-transform:rotate(150deg);transform:rotate(150deg)}.vue-slim-better-scroll__loading i:nth-of-type(6){opacity:.6875;-webkit-transform:rotate(180deg);-ms-transform:rotate(180deg);transform:rotate(180deg)}.vue-slim-better-scroll__loading i:nth-of-type(7){opacity:.625;-webkit-transform:rotate(210deg);-ms-transform:rotate(210deg);transform:rotate(210deg)}.vue-slim-better-scroll__loading i:nth-of-type(8){opacity:.5625;-webkit-transform:rotate(240deg);-ms-transform:rotate(240deg);transform:rotate(240deg)}.vue-slim-better-scroll__loading i:nth-of-type(9){opacity:.5;-webkit-transform:rotate(270deg);-ms-transform:rotate(270deg);transform:rotate(270deg)}.vue-slim-better-scroll__loading i:nth-of-type(10){opacity:.4375;-webkit-transform:rotate(300deg);-ms-transform:rotate(300deg);transform:rotate(300deg)}.vue-slim-better-scroll__loading i:nth-of-type(11){opacity:.375;-webkit-transform:rotate(330deg);-ms-transform:rotate(330deg);transform:rotate(330deg)}.vue-slim-better-scroll__loading i:nth-of-type(12){opacity:.3125;-webkit-transform:rotate(360deg);-ms-transform:rotate(360deg);transform:rotate(360deg)}@-webkit-keyframes spinner-rotate{from{-webkit-transform:rotate(0);transform:rotate(0)}to{-webkit-transform:rotate(360deg);transform:rotate(360deg)}}@keyframes spinner-rotate{from{-webkit-transform:rotate(0);transform:rotate(0)}to{-webkit-transform:rotate(360deg);transform:rotate(360deg)}}", map: undefined, media: undefined });
  
      };
      /* scoped */
      const __vue_scope_id__ = undefined;
      /* module identifier */
      const __vue_module_identifier__ = undefined;
      /* functional template */
      const __vue_is_functional_template__ = false;
      /* style inject SSR */
      
  
      
      var Loading = normalizeComponent_1(
        { render: __vue_render__, staticRenderFns: __vue_staticRenderFns__ },
        __vue_inject_styles__,
        __vue_script__,
        __vue_scope_id__,
        __vue_is_functional_template__,
        __vue_module_identifier__,
        browser,
        undefined
      );
  
    //
    //
    //
    //
    //
    //
    //
    //
    var script$1 = {
      props: {
        y: {
          type: Number,
          default: 0
        }
      },
      data: function data() {
        return {
          width: 50,
          height: 80
        };
      },
      computed: {
        distance: function distance() {
          return Math.max(0, Math.min(this.y * this.ratio, this.maxDistance));
        },
        style: function style() {
          return "width:".concat(this.width / this.ratio, "px;height:").concat(this.height / this.ratio, "px");
        }
      },
      watch: {
        y: function y() {
          this._draw();
        }
      },
      created: function created() {
        this.ratio = window.devicePixelRatio;
        this.width *= this.ratio;
        this.height *= this.ratio;
        this.initRadius = 18 * this.ratio;
        this.minHeadRadius = 12 * this.ratio;
        this.minTailRadius = 5 * this.ratio;
        this.initArrowRadius = 10 * this.ratio;
        this.minArrowRadius = 6 * this.ratio;
        this.arrowWidth = 3 * this.ratio;
        this.maxDistance = 40 * this.ratio;
        this.initCenterX = 25 * this.ratio;
        this.initCenterY = 25 * this.ratio;
        this.headCenter = {
          x: this.initCenterX,
          y: this.initCenterY
        };
      },
      mounted: function mounted() {
        this._draw();
      },
      methods: {
        _draw: function _draw() {
          var bubble = this.$refs.bubble;
          var ctx = bubble.getContext('2d');
          ctx.clearRect(0, 0, bubble.width, bubble.height);
  
          this._drawBubble(ctx);
  
          this._drawArrow(ctx);
        },
        _drawBubble: function _drawBubble(ctx) {
          ctx.save();
          ctx.beginPath();
          var rate = this.distance / this.maxDistance;
          var headRadius = this.initRadius - (this.initRadius - this.minHeadRadius) * rate;
          this.headCenter.y = this.initCenterY - (this.initRadius - this.minHeadRadius) * rate; // 画上半弧线
  
          ctx.arc(this.headCenter.x, this.headCenter.y, headRadius, 0, Math.PI, true); // 画左侧贝塞尔
  
          var tailRadius = this.initRadius - (this.initRadius - this.minTailRadius) * rate;
          var tailCenter = {
            x: this.headCenter.x,
            y: this.headCenter.y + this.distance
          };
          var tailPointL = {
            x: tailCenter.x - tailRadius,
            y: tailCenter.y
          };
          var controlPointL = {
            x: tailPointL.x,
            y: tailPointL.y - this.distance / 2
          };
          ctx.quadraticCurveTo(controlPointL.x, controlPointL.y, tailPointL.x, tailPointL.y); // 画下半弧线
  
          ctx.arc(tailCenter.x, tailCenter.y, tailRadius, Math.PI, 0, true); // 画右侧贝塞尔
  
          var headPointR = {
            x: this.headCenter.x + headRadius,
            y: this.headCenter.y
          };
          var controlPointR = {
            x: tailCenter.x + tailRadius,
            y: headPointR.y + this.distance / 2
          };
          ctx.quadraticCurveTo(controlPointR.x, controlPointR.y, headPointR.x, headPointR.y);
          ctx.fillStyle = 'rgb(170,170,170)';
          ctx.fill();
          ctx.strokeStyle = 'rgb(153,153,153)';
          ctx.stroke();
          ctx.restore();
        },
        _drawArrow: function _drawArrow(ctx) {
          ctx.save();
          ctx.beginPath();
          var rate = this.distance / this.maxDistance;
          var arrowRadius = this.initArrowRadius - (this.initArrowRadius - this.minArrowRadius) * rate; // 画内圆
  
          ctx.arc(this.headCenter.x, this.headCenter.y, arrowRadius - (this.arrowWidth - rate), -Math.PI / 2, 0, true); // 画外圆
  
          ctx.arc(this.headCenter.x, this.headCenter.y, arrowRadius, 0, Math.PI * 3 / 2, false);
          ctx.lineTo(this.headCenter.x, this.headCenter.y - arrowRadius - this.arrowWidth / 2 + rate);
          ctx.lineTo(this.headCenter.x + this.arrowWidth * 2 - rate * 2, this.headCenter.y - arrowRadius + this.arrowWidth / 2);
          ctx.lineTo(this.headCenter.x, this.headCenter.y - arrowRadius + this.arrowWidth * 3 / 2 - rate);
          ctx.fillStyle = 'rgb(255,255,255)';
          ctx.fill();
          ctx.strokeStyle = 'rgb(170,170,170)';
          ctx.stroke();
          ctx.restore();
        }
      }
    };
  
    /* script */
    const __vue_script__$1 = script$1;
  
    /* template */
    var __vue_render__$1 = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('canvas',{ref:"bubble",style:(_vm.style),attrs:{"width":_vm.width,"height":_vm.height}})};
    var __vue_staticRenderFns__$1 = [];
  
      /* style */
      const __vue_inject_styles__$1 = undefined;
      /* scoped */
      const __vue_scope_id__$1 = undefined;
      /* module identifier */
      const __vue_module_identifier__$1 = undefined;
      /* functional template */
      const __vue_is_functional_template__$1 = false;
      /* style inject */
      
      /* style inject SSR */
      
  
      
      var Bubble = normalizeComponent_1(
        { render: __vue_render__$1, staticRenderFns: __vue_staticRenderFns__$1 },
        __vue_inject_styles__$1,
        __vue_script__$1,
        __vue_scope_id__$1,
        __vue_is_functional_template__$1,
        __vue_module_identifier__$1,
        undefined,
        undefined
      );
  
    /**
     * 一些帮助函数
     */
  
    /**
     * setTimeout 的 promise 封装
     * @param {Number} time
     * @returns
     */
    function timeout(time) {
      return new Promise(function (resolve) {
        setTimeout(resolve, time);
      });
    }
  
    var script$2 = {
      name: 'Scroll',
      components: {
        Loading: Loading,
        Bubble: Bubble
      },
      mixins: [mixin],
      props: {
        probeType: {
          // 滚动事件监听类型
          type: Number,
          default: 1
        },
        click: {
          // 开启点击事件代理
          type: Boolean,
          default: true
        },
        listenScroll: {
          // 监听滚动
          type: Boolean,
          default: false
        },
        listenBeforeScrollStart: {
          // 监听滚动开始前
          type: Boolean,
          default: false
        },
        scrollX: {
          // 开启X轴滚动
          type: Boolean,
          default: false
        },
        scrollY: {
          // 开启Y轴滚动
          type: Boolean,
          default: true
        },
        scrollbar: {
          // 开启滚动条
          type: null,
          default: false
        },
        pullDown: {
          // 启用下拉刷新
          type: Boolean,
          default: true
        },
        pullDownConfig: {
          // 下拉刷新配置
          type: Object,
          default: function _default() {
            return {
              threshold: 90,
              // 触发 pullingDown 的距离
              stop: 40,
              // pullingDown 正在刷新 hold 时的距离
              txt: '刷新成功'
            };
          }
        },
        pullUp: {
          // 启用上拉加载
          type: Boolean,
          default: true
        },
        pullUpConfig: {
          // 上拉加载配置
          type: Object,
          default: function _default() {
            return {
              threshold: 100,
              // 提前触发 pullingUp 的距离
              txt: {
                more: '上拉加载',
                noMore: '— 我是有底线的 —'
              }
            };
          }
        },
        startY: {
          // 起始Y位置
          type: Number,
          default: 0
        },
        bounce: {
          // 回弹效果
          type: Boolean,
          default: true
        },
        bounceTime: {
          // 回弹时间
          type: Number,
          default: 600
        },
        preventDefaultException: {
          // 不阻止默认行为
          type: Object,
          default: function _default() {
            return {
              tagName: /^(INPUT|TEXTAREA|BUTTON|SELECT)$/
            };
          }
        },
        mouseWheel: {
          // 启用 PC 鼠标滚轮
          type: Boolean,
          default: false
        },
        betterScrollOptions: {
          // 任何的 better-scroll 配置项，将合并在初始化 better-scroll 的配置中。注意：与 props 冲突的配置项将被 props 覆盖
          type: Object,
          default: null
        },
        autoUpdate: {
          // 自动刷新高度:适用于简单场景，复杂场景请使用updateData/refreshData
          type: Boolean,
          default: false
        },
        updateData: {
          // 引起更新上拉/下拉加载状态的数据（下拉刷新/上拉加载相关的数据）
          type: Array,
          default: null
        },
        refreshData: {
          // 引起刷新高度的数据（不包含 updateData 内的数据）
          type: Array,
          default: null
        }
      },
      data: function data() {
        return {
          pullDownBefore: true,
          // 下拉之前
          pullDownNow: false,
          // 正在下拉
          pullDownStyle: '',
          // 下拉样式
          pullUpNow: false,
          // 正在上拉
          pullUpFinally: false,
          // true表示到了上拉加载到了最底部
          isRebounding: false,
          // 正在回弹
          bubbleY: 0 // 气泡y坐标
  
        };
      },
      computed: {
        // 下拉的文本
        pullDownTxt: function pullDownTxt() {
          return this.pullDownConfig && this.pullDownConfig.txt;
        },
        // 上拉的文本
        pullUpTxt: function pullUpTxt() {
          var moreTxt = this.pullUpConfig && this.pullUpConfig.txt && this.pullUpConfig.txt.more;
          var noMoreTxt = this.pullUpConfig && this.pullUpConfig.txt && this.pullUpConfig.txt.noMore;
          return this.pullUpFinally ? noMoreTxt : moreTxt;
        }
      },
      watch: {
        updateData: function updateData() {
          this.update();
        },
        refreshData: function () {
          var _refreshData = asyncToGenerator(
          /*#__PURE__*/
          regenerator.mark(function _callee() {
            return regenerator.wrap(function _callee$(_context) {
              while (1) {
                switch (_context.prev = _context.next) {
                  case 0:
                    if (!(this.pullDownUpdateState || this.pullUpUpdateState)) {
                      _context.next = 2;
                      break;
                    }
  
                    return _context.abrupt("return");
  
                  case 2:
                    _context.next = 4;
                    return this.$nextTick();
  
                  case 4:
                    this.refresh();
  
                  case 5:
                  case "end":
                    return _context.stop();
                }
              }
            }, _callee, this);
          }));
  
          function refreshData() {
            return _refreshData.apply(this, arguments);
          }
  
          return refreshData;
        }()
      },
      activated: function activated() {
        this.refresh();
      },
      mounted: function () {
        var _mounted = asyncToGenerator(
        /*#__PURE__*/
        regenerator.mark(function _callee2() {
          var _this = this;
  
          return regenerator.wrap(function _callee2$(_context2) {
            while (1) {
              switch (_context2.prev = _context2.next) {
                case 0:
                  this.pullDownInitTop = parseInt(this.$refs.pulldown && getComputedStyle(this.$refs.pulldown).top) || -50;
                  _context2.next = 3;
                  return this.$nextTick();
  
                case 3:
                  this.initScroll(); // 自动刷新高度：深监视 $data，发生改变时更新高度
  
                  this.autoUpdate && this.$parent && this.$parent.$data && this.$watch(function () {
                    return _this.$parent.$data;
                  }, function (val) {
                    _this.update();
                  }, {
                    deep: true
                  });
  
                case 5:
                case "end":
                  return _context2.stop();
              }
            }
          }, _callee2, this);
        }));
  
        function mounted() {
          return _mounted.apply(this, arguments);
        }
  
        return mounted;
      }(),
      methods: {
        // 初始化scroll
        initScroll: function initScroll() {
          var _this2 = this;
  
          if (!this.$refs.scroll) return; // 设置scrollContent的最小高，实现高度不足时也有回弹效果
  
          if (this.$refs.scrollContent) {
            this.$refs.scrollContent.style.minHeight = "".concat(this.$refs.scroll.getBoundingClientRect().height + 1, "px");
          }
  
          var options = objectSpread({}, this.betterScrollOptions, {
            probeType: this.probeType,
            click: this.click,
            scrollX: this.scrollX,
            scrollY: this.scrollY,
            scrollbar: this.scrollbar,
            pullDownRefresh: this.pullDown && this.pullDownConfig,
            pullUpLoad: this.pullUp && this.pullUpConfig,
            startY: this.startY,
            bounce: this.bounce,
            bounceTime: this.bounceTime,
            preventDefaultException: this.preventDefaultException,
            mouseWheel: this.mouseWheel
          });
  
          this.scroll = new BScroll(this.$refs.scroll, options);
          this.listenScroll && this.scroll.on('scroll', function (pos) {
            _this2.$emit('scroll', pos);
          });
          this.listenBeforeScrollStart && this.scroll.on('beforeScrollStart', function () {
            _this2.$emit('beforeScrollStart');
          });
          this.pullDown && this._initPullDown();
          this.pullUp && this._initPullUp();
        },
        // 初始化下拉刷新
        _initPullDown: function _initPullDown() {
          var _this3 = this;
  
          this.scroll.on('pullingDown', function () {
            _this3.pullDownBefore = false;
            _this3.pullDownNow = true;
  
            _this3.$emit('pullingDown');
  
            _this3.scroll.closePullDown(); // 防止在 bounce 前二次触发
  
          });
          this.scroll.on('scroll', function (pos) {
            if (!_this3.pullDown || pos.y < 0) return;
            var posY = Math.floor(pos.y); // 滚动的y轴位置：Number
  
            if (_this3.pullDownBefore) {
              _this3.bubbleY = Math.max(0, posY + _this3.pullDownInitTop);
              _this3.pullDownStyle = "transform: translateY(".concat(Math.min(posY, -_this3.pullDownInitTop), "px)");
            } else {
              _this3.bubbleY = 0;
            }
  
            if (_this3.isRebounding) {
              _this3.pullDownStyle = "transform: translateY(".concat(Math.min(posY, _this3.pullDownConfig.stop), "px)");
            }
          });
        },
        // 初始化上拉加载
        _initPullUp: function _initPullUp() {
          var _this4 = this;
  
          this.scroll.on('pullingUp', function () {
            if (_this4.pullUpFinally) {
              _this4.scroll.finishPullUp();
            } else {
              _this4.pullUpNow = true;
  
              _this4.$emit('pullingUp');
            }
          });
        },
        // 关闭滚动
        disable: function disable() {
          this.scroll && this.scroll.disable();
        },
        // 开启滚动
        enable: function enable() {
          this.scroll && this.scroll.enable();
        },
        // 销毁滚动示例
        destroy: function destroy() {
          this.scroll && this.scroll.destroy();
        },
        // 刷新滚动高度
        refresh: function refresh() {
          this.scroll && this.scroll.refresh();
        },
        // 更新加载状态，下拉/下拉成功后使用
        update: function () {
          var _update = asyncToGenerator(
          /*#__PURE__*/
          regenerator.mark(function _callee3(final) {
            return regenerator.wrap(function _callee3$(_context3) {
              while (1) {
                switch (_context3.prev = _context3.next) {
                  case 0:
                    if (!(this.pullDown && this.pullDownNow)) {
                      _context3.next = 17;
                      break;
                    }
  
                    if (!this.pullDownUpdateState) {
                      _context3.next = 3;
                      break;
                    }
  
                    return _context3.abrupt("return");
  
                  case 3:
                    this.pullDownUpdateState = true; // 正在update状态
                    // 下拉刷新触发成功后
  
                    this.pullDownNow = false;
                    _context3.next = 7;
                    return timeout(this.bounceTime / 2);
  
                  case 7:
                    // 刷新成功hold
                    this.isRebounding = true;
                    this.scroll.finishPullDown(); // 开始回弹
  
                    _context3.next = 11;
                    return timeout(this.bounceTime);
  
                  case 11:
                    this.pullDownBefore = true;
                    this.isRebounding = false;
                    this.scroll.openPullDown(this.pullDownConfig);
                    this.pullUpFinally = false;
                    _context3.next = 23;
                    break;
  
                  case 17:
                    if (!(this.pullUp && this.pullUpNow)) {
                      _context3.next = 23;
                      break;
                    }
  
                    if (!this.pullUpUpdateState) {
                      _context3.next = 20;
                      break;
                    }
  
                    return _context3.abrupt("return");
  
                  case 20:
                    this.pullUpUpdateState = true; // 正在update状态
                    // 上拉加载触发成功后
  
                    this.pullUpNow = false;
                    this.scroll.finishPullUp();
  
                  case 23:
                    typeof final !== 'undefined' && (this.pullUpFinally = !!final);
                    _context3.next = 26;
                    return this.$nextTick();
  
                  case 26:
                    this.refresh();
                    this.pullDownUpdateState = false;
                    this.pullUpUpdateState = false;
  
                  case 29:
                  case "end":
                    return _context3.stop();
                }
              }
            }, _callee3, this);
          }));
  
          function update(_x) {
            return _update.apply(this, arguments);
          }
  
          return update;
        }(),
  
        /**
         * 滚动到指定位置
         * @param  {Number} x    x轴位置
         * @param  {Number} y    y轴位置
         * @param  {Number} time 滚动时间
         * @return {Void}
         */
        scrollTo: function scrollTo() {
          var x = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
          var y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
          var time = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.bounceTime;
          this.scroll && this.scroll.scrollTo(x, y, time);
        },
        // 滚动到元素
        scrollToElement: function scrollToElement() {
          this.scroll && this.scroll.scrollToElement.apply(this.scroll, arguments);
        },
        // 滚动到顶部
        scrollToTop: function scrollToTop() {
          this.scroll && this.scrollTo(0, 0);
        },
        // 滚动到底部
        scrollToBottom: function scrollToBottom() {
          this.scroll && this.scrollTo(0, this.scroll.maxScrollY);
        },
        // 手动触发下拉刷新
        autoPullDownRefresh: function autoPullDownRefresh() {
          this.scroll && this.scroll.autoPullDownRefresh();
        }
      }
    };
  
    /* script */
    const __vue_script__$2 = script$2;
  
    /* template */
    var __vue_render__$2 = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{ref:"scroll",class:_vm.c()},[_c('div',{class:_vm.c('__wrapper')},[_c('div',{ref:"scrollContent"},[_vm._t("default")],2),_vm._v(" "),_vm._t("pullup",[(_vm.pullUp)?_c('div',{class:_vm.c('__pullup')},[(!_vm.pullUpNow)?_c('div',[_c('span',[_vm._v(_vm._s(_vm.pullUpTxt))])]):_c('div',[_c('Loading')],1)]):_vm._e()],{"pullUp":_vm.pullUp,"pullUpNow":_vm.pullUpNow})],2),_vm._v(" "),_vm._t("pulldown",[(_vm.pullDown)?_c('div',{ref:"pulldown",class:_vm.c('__pulldown'),style:(_vm.pullDownStyle)},[(_vm.pullDownBefore)?_c('div',{class:_vm.c('__pulldown__before')},[_c('Bubble',{attrs:{"y":_vm.bubbleY}})],1):_c('div',{class:_vm.c('__pulldown__after')},[(_vm.pullDownNow)?_c('div',[_c('Loading')],1):_c('div',[_c('span',[_vm._v(_vm._s(_vm.pullDownTxt))])])])]):_vm._e()],{"pullDown":_vm.pullDown,"pullDownStyle":_vm.pullDownStyle,"pullDownBefore":_vm.pullDownBefore,"pullDownNow":_vm.pullDownNow,"bubbleY":_vm.bubbleY})],2)};
    var __vue_staticRenderFns__$2 = [];
  
      /* style */
      const __vue_inject_styles__$2 = function (inject) {
        if (!inject) return
        inject("data-v-b236095e_0", { source: ".vue-slim-better-scroll{width:100%;height:100%;overflow:hidden;box-sizing:border-box;position:relative}.vue-slim-better-scroll__wrapper{position:relative;z-index:1}.vue-slim-better-scroll__pullup{width:100%;height:50px;display:-ms-flexbox;display:flex;-ms-flex-pack:center;justify-content:center;-ms-flex-align:center;align-items:center;font-size:14px;color:#999}.vue-slim-better-scroll__pulldown{position:absolute;left:0;top:-50px;width:100%;display:-ms-flexbox;display:flex;-ms-flex-pack:center;justify-content:center;-ms-flex-align:center;align-items:center;transition:all;font-size:14px;color:#999}.vue-slim-better-scroll__pulldown__before{display:-ms-flexbox;display:flex}.vue-slim-better-scroll__pulldown__after{width:100%;height:40px;display:-ms-flexbox;display:flex;-ms-flex-pack:center;justify-content:center;-ms-flex-align:center;align-items:center}", map: undefined, media: undefined });
  
      };
      /* scoped */
      const __vue_scope_id__$2 = undefined;
      /* module identifier */
      const __vue_module_identifier__$2 = undefined;
      /* functional template */
      const __vue_is_functional_template__$2 = false;
      /* style inject SSR */
      
  
      
      var Scroll = normalizeComponent_1(
        { render: __vue_render__$2, staticRenderFns: __vue_staticRenderFns__$2 },
        __vue_inject_styles__$2,
        __vue_script__$2,
        __vue_scope_id__$2,
        __vue_is_functional_template__$2,
        __vue_module_identifier__$2,
        browser,
        undefined
      );
  
    Scroll.install = function (Vue) {
      Vue.component(Scroll.name, Scroll);
    };
  
    return Scroll;
  
  }));
  