first

node_modules/vant/lib/utils/constant.js

@@ -0,0 +1,22 @@
+"use strict";
+
+exports.__esModule = true;
+exports.BORDER_UNSET_TOP_BOTTOM = exports.BORDER_TOP_BOTTOM = exports.BORDER_SURROUND = exports.BORDER_BOTTOM = exports.BORDER_LEFT = exports.BORDER_TOP = exports.BORDER = exports.RED = void 0;
+// color
+var RED = '#ee0a24'; // border
+
+exports.RED = RED;
+var BORDER = 'van-hairline';
+exports.BORDER = BORDER;
+var BORDER_TOP = BORDER + "--top";
+exports.BORDER_TOP = BORDER_TOP;
+var BORDER_LEFT = BORDER + "--left";
+exports.BORDER_LEFT = BORDER_LEFT;
+var BORDER_BOTTOM = BORDER + "--bottom";
+exports.BORDER_BOTTOM = BORDER_BOTTOM;
+var BORDER_SURROUND = BORDER + "--surround";
+exports.BORDER_SURROUND = BORDER_SURROUND;
+var BORDER_TOP_BOTTOM = BORDER + "--top-bottom";
+exports.BORDER_TOP_BOTTOM = BORDER_TOP_BOTTOM;
+var BORDER_UNSET_TOP_BOTTOM = BORDER + "-unset--top-bottom";
+exports.BORDER_UNSET_TOP_BOTTOM = BORDER_UNSET_TOP_BOTTOM;

node_modules/vant/lib/utils/create/bem.js

@@ -0,0 +1,44 @@
+"use strict";
+
+exports.__esModule = true;
+exports.createBEM = createBEM;
+
+/**
+ * bem helper
+ * b() // 'button'
+ * b('text') // 'button__text'
+ * b({ disabled }) // 'button button--disabled'
+ * b('text', { disabled }) // 'button__text button__text--disabled'
+ * b(['disabled', 'primary']) // 'button button--disabled button--primary'
+ */
+function gen(name, mods) {
+  if (!mods) {
+    return '';
+  }
+
+  if (typeof mods === 'string') {
+    return " " + name + "--" + mods;
+  }
+
+  if (Array.isArray(mods)) {
+    return mods.reduce(function (ret, item) {
+      return ret + gen(name, item);
+    }, '');
+  }
+
+  return Object.keys(mods).reduce(function (ret, key) {
+    return ret + (mods[key] ? gen(name, key) : '');
+  }, '');
+}
+
+function createBEM(name) {
+  return function (el, mods) {
+    if (el && typeof el !== 'string') {
+      mods = el;
+      el = '';
+    }
+
+    el = el ? name + "__" + el : name;
+    return "" + el + gen(el, mods);
+  };
+}

node_modules/vant/lib/utils/create/component.js

@@ -0,0 +1,70 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.unifySlots = unifySlots;
+exports.createComponent = createComponent;
+
+require("../../locale");
+
+var _ = require("..");
+
+var _string = require("../format/string");
+
+var _slots = require("../../mixins/slots");
+
+var _vue = _interopRequireDefault(require("vue"));
+
+/**
+ * Create a basic component with common options
+ */
+function install(Vue) {
+  var name = this.name;
+  Vue.component(name, this);
+  Vue.component((0, _string.camelize)("-" + name), this);
+} // unify slots & scopedSlots
+
+
+function unifySlots(context) {
+  // use data.scopedSlots in lower Vue version
+  var scopedSlots = context.scopedSlots || context.data.scopedSlots || {};
+  var slots = context.slots();
+  Object.keys(slots).forEach(function (key) {
+    if (!scopedSlots[key]) {
+      scopedSlots[key] = function () {
+        return slots[key];
+      };
+    }
+  });
+  return scopedSlots;
+} // should be removed after Vue 3
+
+
+function transformFunctionComponent(pure) {
+  return {
+    functional: true,
+    props: pure.props,
+    model: pure.model,
+    render: function render(h, context) {
+      return pure(h, context.props, unifySlots(context), context);
+    }
+  };
+}
+
+function createComponent(name) {
+  return function (sfc) {
+    if ((0, _.isFunction)(sfc)) {
+      sfc = transformFunctionComponent(sfc);
+    }
+
+    if (!sfc.functional) {
+      sfc.mixins = sfc.mixins || [];
+      sfc.mixins.push(_slots.SlotsMixin);
+    }
+
+    sfc.name = name;
+    sfc.install = install;
+    return sfc;
+  };
+}

node_modules/vant/lib/utils/create/i18n.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.createI18N = createI18N;
+
+var _ = require("..");
+
+var _string = require("../format/string");
+
+var _locale = _interopRequireDefault(require("../../locale"));
+
+function createI18N(name) {
+  var prefix = (0, _string.camelize)(name) + '.';
+  return function (path) {
+    var messages = _locale.default.messages();
+
+    var message = (0, _.get)(messages, prefix + path) || (0, _.get)(messages, path);
+
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+
+    return (0, _.isFunction)(message) ? message.apply(void 0, args) : message;
+  };
+}

node_modules/vant/lib/utils/create/index.js

@@ -0,0 +1,15 @@
+"use strict";
+
+exports.__esModule = true;
+exports.createNamespace = createNamespace;
+
+var _bem = require("./bem");
+
+var _component = require("./component");
+
+var _i18n = require("./i18n");
+
+function createNamespace(name) {
+  name = 'van-' + name;
+  return [(0, _component.createComponent)(name), (0, _bem.createBEM)(name), (0, _i18n.createI18N)(name)];
+}

node_modules/vant/lib/utils/deep-assign.js

@@ -0,0 +1,30 @@
+"use strict";
+
+exports.__esModule = true;
+exports.deepAssign = deepAssign;
+
+var _ = require(".");
+
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+function assignKey(to, from, key) {
+  var val = from[key];
+
+  if (!(0, _.isDef)(val)) {
+    return;
+  }
+
+  if (!hasOwnProperty.call(to, key) || !(0, _.isObject)(val)) {
+    to[key] = val;
+  } else {
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    to[key] = deepAssign(Object(to[key]), from[key]);
+  }
+}
+
+function deepAssign(to, from) {
+  Object.keys(from).forEach(function (key) {
+    assignKey(to, from, key);
+  });
+  return to;
+}

node_modules/vant/lib/utils/deep-clone.js

@@ -0,0 +1,28 @@
+"use strict";
+
+exports.__esModule = true;
+exports.deepClone = deepClone;
+
+var _index = require("./index");
+
+function deepClone(obj) {
+  if (!(0, _index.isDef)(obj)) {
+    return obj;
+  }
+
+  if (Array.isArray(obj)) {
+    return obj.map(function (item) {
+      return deepClone(item);
+    });
+  }
+
+  if (typeof obj === 'object') {
+    var to = {};
+    Object.keys(obj).forEach(function (key) {
+      to[key] = deepClone(obj[key]);
+    });
+    return to;
+  }
+
+  return obj;
+}

node_modules/vant/lib/utils/dom/event.js

@@ -0,0 +1,62 @@
+"use strict";
+
+exports.__esModule = true;
+exports.on = on;
+exports.off = off;
+exports.stopPropagation = stopPropagation;
+exports.preventDefault = preventDefault;
+exports.supportsPassive = void 0;
+
+var _ = require("..");
+
+// eslint-disable-next-line import/no-mutable-exports
+var supportsPassive = false;
+exports.supportsPassive = supportsPassive;
+
+if (!_.isServer) {
+  try {
+    var opts = {};
+    Object.defineProperty(opts, 'passive', {
+      // eslint-disable-next-line getter-return
+      get: function get() {
+        /* istanbul ignore next */
+        exports.supportsPassive = supportsPassive = true;
+      }
+    });
+    window.addEventListener('test-passive', null, opts); // eslint-disable-next-line no-empty
+  } catch (e) {}
+}
+
+function on(target, event, handler, passive) {
+  if (passive === void 0) {
+    passive = false;
+  }
+
+  if (!_.isServer) {
+    target.addEventListener(event, handler, supportsPassive ? {
+      capture: false,
+      passive: passive
+    } : false);
+  }
+}
+
+function off(target, event, handler) {
+  if (!_.isServer) {
+    target.removeEventListener(event, handler);
+  }
+}
+
+function stopPropagation(event) {
+  event.stopPropagation();
+}
+
+function preventDefault(event, isStopPropagation) {
+  /* istanbul ignore else */
+  if (typeof event.cancelable !== 'boolean' || event.cancelable) {
+    event.preventDefault();
+  }
+
+  if (isStopPropagation) {
+    stopPropagation(event);
+  }
+}

node_modules/vant/lib/utils/dom/node.js

@@ -0,0 +1,12 @@
+"use strict";
+
+exports.__esModule = true;
+exports.removeNode = removeNode;
+
+function removeNode(el) {
+  var parent = el.parentNode;
+
+  if (parent) {
+    parent.removeChild(el);
+  }
+}

node_modules/vant/lib/utils/dom/raf.js

@@ -0,0 +1,47 @@
+"use strict";
+
+exports.__esModule = true;
+exports.raf = raf;
+exports.doubleRaf = doubleRaf;
+exports.cancelRaf = cancelRaf;
+
+var _ = require("..");
+
+/**
+ * requestAnimationFrame polyfill
+ */
+var prev = Date.now();
+/* istanbul ignore next */
+
+function fallback(fn) {
+  var curr = Date.now();
+  var ms = Math.max(0, 16 - (curr - prev));
+  var id = setTimeout(fn, ms);
+  prev = curr + ms;
+  return id;
+}
+/* istanbul ignore next */
+
+
+var root = _.isServer ? global : window;
+/* istanbul ignore next */
+
+var iRaf = root.requestAnimationFrame || fallback;
+/* istanbul ignore next */
+
+var iCancel = root.cancelAnimationFrame || root.clearTimeout;
+
+function raf(fn) {
+  return iRaf.call(root, fn);
+} // double raf for animation
+
+
+function doubleRaf(fn) {
+  raf(function () {
+    raf(fn);
+  });
+}
+
+function cancelRaf(id) {
+  iCancel.call(root, id);
+}

node_modules/vant/lib/utils/dom/reset-scroll.js

@@ -0,0 +1,21 @@
+"use strict";
+
+exports.__esModule = true;
+exports.resetScroll = resetScroll;
+
+var _system = require("../validate/system");
+
+var _scroll = require("./scroll");
+
+/**
+ * Hack for iOS12 page scroll
+ * https://developers.weixin.qq.com/community/develop/doc/00044ae90742f8c82fb78fcae56800
+ */
+var isIOS = (0, _system.isIOS)();
+/* istanbul ignore next */
+
+function resetScroll() {
+  if (isIOS) {
+    (0, _scroll.setRootScrollTop)((0, _scroll.getRootScrollTop)());
+  }
+}

node_modules/vant/lib/utils/dom/scroll.js

@@ -0,0 +1,89 @@
+"use strict";
+
+exports.__esModule = true;
+exports.getScroller = getScroller;
+exports.getScrollTop = getScrollTop;
+exports.setScrollTop = setScrollTop;
+exports.getRootScrollTop = getRootScrollTop;
+exports.setRootScrollTop = setRootScrollTop;
+exports.getElementTop = getElementTop;
+exports.getVisibleHeight = getVisibleHeight;
+exports.getVisibleTop = getVisibleTop;
+
+function isWindow(val) {
+  return val === window;
+} // get nearest scroll element
+// https://github.com/vant-ui/vant/issues/3823
+
+
+var overflowScrollReg = /scroll|auto|overlay/i;
+
+function getScroller(el, root) {
+  if (root === void 0) {
+    root = window;
+  }
+
+  var node = el;
+
+  while (node && node.tagName !== 'HTML' && node.tagName !== 'BODY' && node.nodeType === 1 && node !== root) {
+    var _window$getComputedSt = window.getComputedStyle(node),
+        overflowY = _window$getComputedSt.overflowY;
+
+    if (overflowScrollReg.test(overflowY)) {
+      return node;
+    }
+
+    node = node.parentNode;
+  }
+
+  return root;
+}
+
+function getScrollTop(el) {
+  var top = 'scrollTop' in el ? el.scrollTop : el.pageYOffset; // iOS scroll bounce cause minus scrollTop
+
+  return Math.max(top, 0);
+}
+
+function setScrollTop(el, value) {
+  if ('scrollTop' in el) {
+    el.scrollTop = value;
+  } else {
+    el.scrollTo(el.scrollX, value);
+  }
+}
+
+function getRootScrollTop() {
+  return window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0;
+}
+
+function setRootScrollTop(value) {
+  setScrollTop(window, value);
+  setScrollTop(document.body, value);
+} // get distance from element top to page top or scroller top
+
+
+function getElementTop(el, scroller) {
+  if (isWindow(el)) {
+    return 0;
+  }
+
+  var scrollTop = scroller ? getScrollTop(scroller) : getRootScrollTop();
+  return el.getBoundingClientRect().top + scrollTop;
+}
+
+function getVisibleHeight(el) {
+  if (isWindow(el)) {
+    return el.innerHeight;
+  }
+
+  return el.getBoundingClientRect().height;
+}
+
+function getVisibleTop(el) {
+  if (isWindow(el)) {
+    return 0;
+  }
+
+  return el.getBoundingClientRect().top;
+}

node_modules/vant/lib/utils/dom/style.js

@@ -0,0 +1,14 @@
+"use strict";
+
+exports.__esModule = true;
+exports.isHidden = isHidden;
+
+function isHidden(el) {
+  var style = window.getComputedStyle(el);
+  var hidden = style.display === 'none'; // offsetParent returns null in the following situations:
+  // 1. The element or its parent element has the display property set to none.
+  // 2. The element has the position property set to fixed
+
+  var parentHidden = el.offsetParent === null && style.position !== 'fixed';
+  return hidden || parentHidden;
+}

node_modules/vant/lib/utils/format/number.js

@@ -0,0 +1,60 @@
+"use strict";
+
+exports.__esModule = true;
+exports.range = range;
+exports.formatNumber = formatNumber;
+exports.addNumber = addNumber;
+
+function range(num, min, max) {
+  return Math.min(Math.max(num, min), max);
+}
+
+function trimExtraChar(value, _char, regExp) {
+  var index = value.indexOf(_char);
+  var prefix = '';
+
+  if (index === -1) {
+    return value;
+  }
+
+  if (_char === '-' && index !== 0) {
+    return value.slice(0, index);
+  }
+
+  if (_char === '.' && value.match(/^(\.|-\.)/)) {
+    prefix = index ? '-0' : '0';
+  }
+
+  return prefix + value.slice(0, index + 1) + value.slice(index).replace(regExp, '');
+}
+
+function formatNumber(value, allowDot, allowMinus) {
+  if (allowDot === void 0) {
+    allowDot = true;
+  }
+
+  if (allowMinus === void 0) {
+    allowMinus = true;
+  }
+
+  if (allowDot) {
+    value = trimExtraChar(value, '.', /\./g);
+  } else {
+    value = value.split('.')[0];
+  }
+
+  if (allowMinus) {
+    value = trimExtraChar(value, '-', /-/g);
+  } else {
+    value = value.replace(/-/, '');
+  }
+
+  var regExp = allowDot ? /[^-0-9.]/g : /[^-0-9]/g;
+  return value.replace(regExp, '');
+} // add num and avoid float number
+
+
+function addNumber(num1, num2) {
+  var cardinal = Math.pow(10, 10);
+  return Math.round((num1 + num2) * cardinal) / cardinal;
+}

node_modules/vant/lib/utils/format/string.js

@@ -0,0 +1,26 @@
+"use strict";
+
+exports.__esModule = true;
+exports.camelize = camelize;
+exports.padZero = padZero;
+var camelizeRE = /-(\w)/g;
+
+function camelize(str) {
+  return str.replace(camelizeRE, function (_, c) {
+    return c.toUpperCase();
+  });
+}
+
+function padZero(num, targetLength) {
+  if (targetLength === void 0) {
+    targetLength = 2;
+  }
+
+  var str = num + '';
+
+  while (str.length < targetLength) {
+    str = '0' + str;
+  }
+
+  return str;
+}

node_modules/vant/lib/utils/format/unit.js

@@ -0,0 +1,68 @@
+"use strict";
+
+exports.__esModule = true;
+exports.addUnit = addUnit;
+exports.unitToPx = unitToPx;
+
+var _ = require("..");
+
+var _number = require("../validate/number");
+
+function addUnit(value) {
+  if (!(0, _.isDef)(value)) {
+    return undefined;
+  }
+
+  value = String(value);
+  return (0, _number.isNumeric)(value) ? value + "px" : value;
+} // cache
+
+
+var rootFontSize;
+
+function getRootFontSize() {
+  if (!rootFontSize) {
+    var doc = document.documentElement;
+    var fontSize = doc.style.fontSize || window.getComputedStyle(doc).fontSize;
+    rootFontSize = parseFloat(fontSize);
+  }
+
+  return rootFontSize;
+}
+
+function convertRem(value) {
+  value = value.replace(/rem/g, '');
+  return +value * getRootFontSize();
+}
+
+function convertVw(value) {
+  value = value.replace(/vw/g, '');
+  return +value * window.innerWidth / 100;
+}
+
+function convertVh(value) {
+  value = value.replace(/vh/g, '');
+  return +value * window.innerHeight / 100;
+}
+
+function unitToPx(value) {
+  if (typeof value === 'number') {
+    return value;
+  }
+
+  if (_.inBrowser) {
+    if (value.indexOf('rem') !== -1) {
+      return convertRem(value);
+    }
+
+    if (value.indexOf('vw') !== -1) {
+      return convertVw(value);
+    }
+
+    if (value.indexOf('vh') !== -1) {
+      return convertVh(value);
+    }
+  }
+
+  return parseFloat(value);
+}

node_modules/vant/lib/utils/functional.js

@@ -0,0 +1,68 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.inherit = inherit;
+exports.emit = emit;
+exports.mount = mount;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _vue = _interopRequireDefault(require("vue"));
+
+var inheritKey = ['ref', 'key', 'style', 'class', 'attrs', 'refInFor', 'nativeOn', 'directives', 'staticClass', 'staticStyle'];
+var mapInheritKey = {
+  nativeOn: 'on'
+}; // inherit partial context, map nativeOn to on
+
+function inherit(context, inheritListeners) {
+  var result = inheritKey.reduce(function (obj, key) {
+    if (context.data[key]) {
+      obj[mapInheritKey[key] || key] = context.data[key];
+    }
+
+    return obj;
+  }, {});
+
+  if (inheritListeners) {
+    result.on = result.on || {};
+    (0, _extends2.default)(result.on, context.data.on);
+  }
+
+  return result;
+} // emit event
+
+
+function emit(context, eventName) {
+  for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+    args[_key - 2] = arguments[_key];
+  }
+
+  var listeners = context.listeners[eventName];
+
+  if (listeners) {
+    if (Array.isArray(listeners)) {
+      listeners.forEach(function (listener) {
+        listener.apply(void 0, args);
+      });
+    } else {
+      listeners.apply(void 0, args);
+    }
+  }
+} // mount functional component
+
+
+function mount(Component, data) {
+  var instance = new _vue.default({
+    el: document.createElement('div'),
+    props: Component.props,
+    render: function render(h) {
+      return h(Component, (0, _extends2.default)({
+        props: this.$props
+      }, data));
+    }
+  });
+  document.body.appendChild(instance.$el);
+  return instance;
+}

node_modules/vant/lib/utils/index.js

@@ -0,0 +1,100 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.noop = noop;
+exports.isDef = isDef;
+exports.isFunction = isFunction;
+exports.isObject = isObject;
+exports.isPromise = isPromise;
+exports.get = get;
+exports.isEmpty = isEmpty;
+exports.isServer = exports.inBrowser = exports.addUnit = exports.createNamespace = void 0;
+
+var _vue = _interopRequireDefault(require("vue"));
+
+var _create = require("./create");
+
+exports.createNamespace = _create.createNamespace;
+
+var _unit = require("./format/unit");
+
+exports.addUnit = _unit.addUnit;
+var inBrowser = typeof window !== 'undefined';
+exports.inBrowser = inBrowser;
+var isServer = _vue.default.prototype.$isServer; // eslint-disable-next-line @typescript-eslint/no-empty-function
+
+exports.isServer = isServer;
+
+function noop() {}
+
+function isDef(val) {
+  return val !== undefined && val !== null;
+}
+
+function isFunction(val) {
+  return typeof val === 'function';
+}
+
+function isObject(val) {
+  return val !== null && typeof val === 'object';
+}
+
+function isPromise(val) {
+  return isObject(val) && isFunction(val.then) && isFunction(val.catch);
+}
+
+function get(object, path) {
+  var keys = path.split('.');
+  var result = object;
+  keys.forEach(function (key) {
+    var _result$key;
+
+    result = isObject(result) ? (_result$key = result[key]) != null ? _result$key : '' : '';
+  });
+  return result;
+}
+/**
+ * Checks if `value` is an empty object, collection, map, or set.
+ *
+ * Objects are considered empty if they have no own enumerable string keyed
+ * properties.
+ *
+ * Array-like values such as `arguments` objects, arrays, buffers, strings, or
+ * jQuery-like collections are considered empty if they have a `length` of `0`.
+ * Similarly, maps and sets are considered empty if they have a `size` of `0`.
+ *
+ * @function isEmpty
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is empty, else `false`.
+ * @example
+ *
+ * _.isEmpty(null);
+ * // => true
+ *
+ * _.isEmpty(true);
+ * // => true
+ *
+ * _.isEmpty(1);
+ * // => true
+ *
+ * _.isEmpty([1, 2, 3]);
+ * // => false
+ *
+ * _.isEmpty({ 'a': 1 });
+ * // => false
+ */
+
+
+function isEmpty(value) {
+  if (value == null) {
+    return true;
+  }
+
+  if (typeof value !== 'object') {
+    return true;
+  }
+
+  return Object.keys(value).length === 0;
+}

node_modules/vant/lib/utils/interceptor.js

@@ -0,0 +1,28 @@
+"use strict";
+
+exports.__esModule = true;
+exports.callInterceptor = callInterceptor;
+
+var _ = require(".");
+
+function callInterceptor(options) {
+  var interceptor = options.interceptor,
+      args = options.args,
+      done = options.done;
+
+  if (interceptor) {
+    var returnVal = interceptor.apply(void 0, args);
+
+    if ((0, _.isPromise)(returnVal)) {
+      returnVal.then(function (value) {
+        if (value) {
+          done();
+        }
+      }).catch(_.noop);
+    } else if (returnVal) {
+      done();
+    }
+  } else {
+    done();
+  }
+}

node_modules/vant/lib/utils/router.js

@@ -0,0 +1,46 @@
+"use strict";
+
+exports.__esModule = true;
+exports.route = route;
+exports.functionalRoute = functionalRoute;
+exports.routeProps = void 0;
+
+/**
+ * Vue Router support
+ */
+function isRedundantNavigation(err) {
+  return err.name === 'NavigationDuplicated' || // compatible with vue-router@3.3
+  err.message && err.message.indexOf('redundant navigation') !== -1;
+}
+
+function route(router, config) {
+  var to = config.to,
+      url = config.url,
+      replace = config.replace;
+
+  if (to && router) {
+    var promise = router[replace ? 'replace' : 'push'](to);
+    /* istanbul ignore else */
+
+    if (promise && promise.catch) {
+      promise.catch(function (err) {
+        if (err && !isRedundantNavigation(err)) {
+          throw err;
+        }
+      });
+    }
+  } else if (url) {
+    replace ? location.replace(url) : location.href = url;
+  }
+}
+
+function functionalRoute(context) {
+  route(context.parent && context.parent.$router, context.props);
+}
+
+var routeProps = {
+  url: String,
+  replace: Boolean,
+  to: [String, Object]
+};
+exports.routeProps = routeProps;

node_modules/vant/lib/utils/types.js

@@ -0,0 +1 @@
+"use strict";

node_modules/vant/lib/utils/validate/date.js

@@ -0,0 +1,10 @@
+"use strict";
+
+exports.__esModule = true;
+exports.isDate = isDate;
+
+var _number = require("./number");
+
+function isDate(val) {
+  return Object.prototype.toString.call(val) === '[object Date]' && !(0, _number.isNaN)(val.getTime());
+}

node_modules/vant/lib/utils/validate/email.js

@@ -0,0 +1,10 @@
+"use strict";
+
+exports.__esModule = true;
+exports.isEmail = isEmail;
+
+/* eslint-disable */
+function isEmail(value) {
+  var reg = /^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$/;
+  return reg.test(value.trim());
+}

node_modules/vant/lib/utils/validate/mobile.js

@@ -0,0 +1,9 @@
+"use strict";
+
+exports.__esModule = true;
+exports.isMobile = isMobile;
+
+function isMobile(value) {
+  value = value.replace(/[^-|\d]/g, '');
+  return /^((\+86)|(86))?(1)\d{10}$/.test(value) || /^0[0-9-]{10,13}$/.test(value);
+}

node_modules/vant/lib/utils/validate/number.js

@@ -0,0 +1,18 @@
+"use strict";
+
+exports.__esModule = true;
+exports.isNumeric = isNumeric;
+exports.isNaN = isNaN;
+
+function isNumeric(val) {
+  return /^\d+(\.\d+)?$/.test(val);
+}
+
+function isNaN(val) {
+  if (Number.isNaN) {
+    return Number.isNaN(val);
+  } // eslint-disable-next-line no-self-compare
+
+
+  return val !== val;
+}

node_modules/vant/lib/utils/validate/system.js

@@ -0,0 +1,17 @@
+"use strict";
+
+exports.__esModule = true;
+exports.isAndroid = isAndroid;
+exports.isIOS = isIOS;
+
+var _ = require("..");
+
+function isAndroid() {
+  /* istanbul ignore next */
+  return _.isServer ? false : /android/.test(navigator.userAgent.toLowerCase());
+}
+
+function isIOS() {
+  /* istanbul ignore next */
+  return _.isServer ? false : /ios|iphone|ipad|ipod/.test(navigator.userAgent.toLowerCase());
+}

node_modules/vant/lib/utils/vnodes.js

@@ -0,0 +1,41 @@
+"use strict";
+
+exports.__esModule = true;
+exports.sortChildren = sortChildren;
+
+function flattenVNodes(vnodes) {
+  var result = [];
+
+  function traverse(vnodes) {
+    vnodes.forEach(function (vnode) {
+      result.push(vnode);
+
+      if (vnode.componentInstance) {
+        traverse(vnode.componentInstance.$children.map(function (item) {
+          return item.$vnode;
+        }));
+      }
+
+      if (vnode.children) {
+        traverse(vnode.children);
+      }
+    });
+  }
+
+  traverse(vnodes);
+  return result;
+} // sort children instances by vnodes order
+
+
+function sortChildren(children, parent) {
+  var componentOptions = parent.$vnode.componentOptions;
+
+  if (!componentOptions || !componentOptions.children) {
+    return;
+  }
+
+  var vnodes = flattenVNodes(componentOptions.children);
+  children.sort(function (a, b) {
+    return vnodes.indexOf(a.$vnode) - vnodes.indexOf(b.$vnode);
+  });
+}