weex-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From acton...@apache.org
Subject [26/39] incubator-weex git commit: * [build] support to release weex-legacy-framework
Date Tue, 08 Aug 2017 08:55:38 GMT
http://git-wip-us.apache.org/repos/asf/incubator-weex/blob/5aa1517a/packages/weex-legacy-framework/index.js
----------------------------------------------------------------------
diff --git a/packages/weex-legacy-framework/index.js b/packages/weex-legacy-framework/index.js
new file mode 100644
index 0000000..a2d9804
--- /dev/null
+++ b/packages/weex-legacy-framework/index.js
@@ -0,0 +1,5770 @@
+/* 'WEEX VANILLA FRAMEWORK 0.20.6, Build 2017-08-01 19:19. */
+
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(factory((global.WeexVanillaFramework = global.WeexVanillaFramework || {})));
+}(this, (function (exports) { 'use strict';
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/**
+ * @fileOverview The api for invoking with "$" prefix
+ */
+
+/**
+ * @deprecated use $vm instead
+ * find the vm by id
+ * Note: there is only one id in whole component
+ * @param  {string} id
+ * @return {Vm}
+ */
+function $ (id) {
+  console.warn('[JS Framework] Vm#$ is deprecated, please use Vm#$vm instead');
+  var info = this._ids[id];
+  if (info) {
+    return info.vm
+  }
+}
+
+/**
+ * find the element by id
+ * Note: there is only one id in whole component
+ * @param  {string} id
+ * @return {Element}
+ */
+function $el (id) {
+  var info = this._ids[id];
+  if (info) {
+    return info.el
+  }
+}
+
+/**
+ * find the vm of the custom component by id
+ * Note: there is only one id in whole component
+ * @param  {string} id
+ * @return {Vm}
+ */
+function $vm (id) {
+  var info = this._ids[id];
+  if (info) {
+    return info.vm
+  }
+}
+
+/**
+ * Fire when differ rendering finished
+ *
+ * @param  {Function} fn
+ */
+function $renderThen (fn) {
+  var app = this._app;
+  var differ = app.differ;
+  return differ.then(function () {
+    fn();
+  })
+}
+
+/**
+ * scroll an element specified by id into view,
+ * moreover specify a number of offset optionally
+ * @param  {string} id
+ * @param  {number} offset
+ */
+function $scrollTo (id, offset) {
+  console.warn('[JS Framework] Vm#$scrollTo is deprecated, ' +
+          'please use "require(\'@weex-module/dom\')' +
+          '.scrollTo(el, options)" instead');
+  var el = this.$el(id);
+  if (el) {
+    var dom = this._app.requireModule('dom');
+    dom.scrollToElement(el.ref, { offset: offset });
+  }
+}
+
+/**
+ * perform transition animation on an element specified by id
+ * @param  {string}   id
+ * @param  {object}   options
+ * @param  {object}   options.styles
+ * @param  {object}   options.duration(ms)
+ * @param  {object}   [options.timingFunction]
+ * @param  {object}   [options.delay=0(ms)]
+ * @param  {Function} callback
+ */
+function $transition (id, options, callback) {
+  var this$1 = this;
+
+  var el = this.$el(id);
+  if (el && options && options.styles) {
+    var animation = this._app.requireModule('animation');
+    animation.transition(el.ref, options, function () {
+      var args = [], len = arguments.length;
+      while ( len-- ) args[ len ] = arguments[ len ];
+
+      this$1._setStyle(el, options.styles);
+      callback && callback.apply(void 0, args);
+    });
+  }
+}
+
+/**
+ * get some config
+ * @return {object} some config for app instance
+ * @property {string} bundleUrl
+ * @property {boolean} debug
+ * @property {object} env
+ * @property {string} env.weexVersion(ex. 1.0.0)
+ * @property {string} env.appName(ex. TB/TM)
+ * @property {string} env.appVersion(ex. 5.0.0)
+ * @property {string} env.platform(ex. iOS/Android)
+ * @property {string} env.osVersion(ex. 7.0.0)
+ * @property {string} env.deviceModel **native only**
+ * @property {number} env.[deviceWidth=750]
+ * @property {number} env.deviceHeight
+ */
+function $getConfig (callback) {
+  var config = this._app.options;
+  if (typeof callback === 'function') {
+    console.warn('[JS Framework] the callback of Vm#$getConfig(callback) is deprecated, ' +
+      'this api now can directly RETURN config info.');
+    callback(config);
+  }
+  return config
+}
+
+/**
+ * @deprecated
+ * request network via http protocol
+ * @param  {object}   params
+ * @param  {Function} callback
+ */
+function $sendHttp (params, callback) {
+  console.warn('[JS Framework] Vm#$sendHttp is deprecated, ' +
+          'please use "require(\'@weex-module/stream\')' +
+          '.sendHttp(params, callback)" instead');
+  var stream = this._app.requireModule('stream');
+  stream.sendHttp(params, callback);
+}
+
+/**
+ * @deprecated
+ * open a url
+ * @param  {string} url
+ */
+function $openURL (url) {
+  console.warn('[JS Framework] Vm#$openURL is deprecated, ' +
+          'please use "require(\'@weex-module/event\')' +
+          '.openURL(url)" instead');
+  var event = this._app.requireModule('event');
+  event.openURL(url);
+}
+
+/**
+ * @deprecated
+ * set a title for page
+ * @param  {string} title
+ */
+function $setTitle (title) {
+  console.warn('[JS Framework] Vm#$setTitle is deprecated, ' +
+          'please use "require(\'@weex-module/pageInfo\')' +
+          '.setTitle(title)" instead');
+  var pageInfo = this._app.requireModule('pageInfo');
+  pageInfo.setTitle(title);
+}
+
+/**
+ * @deprecated use "require('@weex-module/moduleName') instead"
+ * invoke a native method by specifing the name of module and method
+ * @param  {string} moduleName
+ * @param  {string} methodName
+ * @param  {...*} the rest arguments
+ */
+function $call (moduleName, methodName) {
+  var args = [], len = arguments.length - 2;
+  while ( len-- > 0 ) args[ len ] = arguments[ len + 2 ];
+
+  console.warn('[JS Framework] Vm#$call is deprecated, ' +
+    'please use "require(\'@weex-module/moduleName\')" instead');
+  var module = this._app.requireModule(moduleName);
+  if (module && module[methodName]) {
+    module[methodName].apply(module, args);
+  }
+}
+
+
+var methods = Object.freeze({
+	$: $,
+	$el: $el,
+	$vm: $vm,
+	$renderThen: $renderThen,
+	$scrollTo: $scrollTo,
+	$transition: $transition,
+	$getConfig: $getConfig,
+	$sendHttp: $sendHttp,
+	$openURL: $openURL,
+	$setTitle: $setTitle,
+	$call: $call
+});
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/**
+ * Mix properties into target object.
+ *
+ * @param {Object} to
+ * @param {Object} from
+ */
+
+function extend (target) {
+  var src = [], len = arguments.length - 1;
+  while ( len-- > 0 ) src[ len ] = arguments[ len + 1 ];
+
+  /* istanbul ignore else */
+  if (typeof Object.assign === 'function') {
+    Object.assign.apply(Object, [ target ].concat( src ));
+  }
+  else {
+    var first = src.shift();
+    for (var key in first) {
+      target[key] = first[key];
+    }
+    if (src.length) {
+      extend.apply(void 0, [ target ].concat( src ));
+    }
+  }
+  return target
+}
+
+/**
+ * Define a property.
+ *
+ * @param {Object} obj
+ * @param {String} key
+ * @param {*} val
+ * @param {Boolean} [enumerable]
+ */
+
+function def (obj, key, val, enumerable) {
+  Object.defineProperty(obj, key, {
+    value: val,
+    enumerable: !!enumerable,
+    writable: true,
+    configurable: true
+  });
+}
+
+/**
+ * Remove an item from an array
+ *
+ * @param {Array} arr
+ * @param {*} item
+ */
+
+function remove (arr, item) {
+  if (arr.length) {
+    var index = arr.indexOf(item);
+    if (index > -1) {
+      return arr.splice(index, 1)
+    }
+  }
+}
+
+/**
+ * Check whether the object has the property.
+ *
+ * @param {Object} obj
+ * @param {String} key
+ * @return {Boolean}
+ */
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+function hasOwn (obj, key) {
+  return hasOwnProperty.call(obj, key)
+}
+
+/**
+ * Simple bind, faster than native
+ *
+ * @param {Function} fn
+ * @param {Object} ctx
+ * @return {Function}
+ */
+
+function bind (fn, ctx) {
+  return function (a) {
+    var l = arguments.length;
+    return l
+      ? l > 1
+        ? fn.apply(ctx, arguments)
+        : fn.call(ctx, a)
+      : fn.call(ctx)
+  }
+}
+
+/**
+ * Quick object check - this is primarily used to tell
+ * Objects from primitive values when we know the value
+ * is a JSON-compliant type.
+ *
+ * @param {*} obj
+ * @return {Boolean}
+ */
+
+function isObject (obj) {
+  return obj !== null && typeof obj === 'object'
+}
+
+/**
+ * Strict object type check. Only returns true
+ * for plain JavaScript objects.
+ *
+ * @param {*} obj
+ * @return {Boolean}
+ */
+
+var toString = Object.prototype.toString;
+var OBJECT_STRING = '[object Object]';
+function isPlainObject (obj) {
+  return toString.call(obj) === OBJECT_STRING
+}
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/**
+ * Check if a string starts with $ or _
+ *
+ * @param {String} str
+ * @return {Boolean}
+ */
+
+function isReserved (str) {
+  var c = (str + '').charCodeAt(0);
+  return c === 0x24 || c === 0x5F
+}
+
+// can we use __proto__?
+var hasProto = '__proto__' in {};
+
+var _Set;
+/* istanbul ignore next */
+if (typeof Set !== 'undefined' && Set.toString().match(/native code/)) {
+  // use native Set when available.
+  _Set = Set;
+}
+else {
+  // a non-standard Set polyfill that only works with primitive keys.
+  _Set = function () {
+    this.set = Object.create(null);
+  };
+  _Set.prototype.has = function (key) {
+    return this.set[key] !== undefined
+  };
+  _Set.prototype.add = function (key) {
+    if (key == null || this.set[key]) {
+      return
+    }
+    this.set[key] = 1;
+  };
+  _Set.prototype.clear = function () {
+    this.set = Object.create(null);
+  };
+}
+
+/**
+ * Polyfill in iOS7 by native because the JavaScript polyfill has memory problem.
+ * @return {object}
+ */
+
+function createNewSet () {
+  /* istanbul ignore next */
+  /* eslint-disable */
+  if (typeof nativeSet === 'object') {
+    return nativeSet.create()
+  }
+  /* eslint-enable */
+  return new _Set()
+}
+
+/**
+ * Create a cached version of a pure function.
+ *
+ * @param {Function} fn
+ * @return {Function}
+ */
+
+
+
+
+
+
+
+function typof (v) {
+  var s = Object.prototype.toString.call(v);
+  return s.substring(8, s.length - 1).toLowerCase()
+}
+
+// weex name rules
+
+var WEEX_COMPONENT_REG = /^@weex-component\//;
+var WEEX_MODULE_REG = /^@weex-module\//;
+var NORMAL_MODULE_REG = /^\.{1,2}\//;
+var JS_SURFIX_REG = /\.js$/;
+
+var isWeexComponent = function (name) { return !!name.match(WEEX_COMPONENT_REG); };
+var isWeexModule = function (name) { return !!name.match(WEEX_MODULE_REG); };
+var isNormalModule = function (name) { return !!name.match(NORMAL_MODULE_REG); };
+var isNpmModule = function (name) { return !isWeexComponent(name) && !isWeexModule(name) && !isNormalModule(name); };
+
+function removeWeexPrefix (str) {
+  var result = str.replace(WEEX_COMPONENT_REG, '').replace(WEEX_MODULE_REG, '');
+  return result
+}
+
+function removeJSSurfix (str) {
+  return str.replace(JS_SURFIX_REG, '')
+}
+
+/* eslint-disable */
+
+
+var uid$1 = 0;
+
+/**
+ * A dep is an observable that can have multiple
+ * directives subscribing to it.
+ *
+ * @constructor
+ */
+
+function Dep () {
+  this.id = uid$1++;
+  this.subs = [];
+}
+
+// the current target watcher being evaluated.
+// this is globally unique because there could be only one
+// watcher being evaluated at any time.
+Dep.target = null;
+var targetStack = [];
+
+function pushTarget (_target) {
+  if (Dep.target) { targetStack.push(Dep.target); }
+  Dep.target = _target;
+}
+
+function popTarget () {
+  Dep.target = targetStack.pop();
+}
+
+function resetTarget () {
+  Dep.target = null;
+  targetStack = [];
+}
+
+/**
+ * Add a directive subscriber.
+ *
+ * @param {Directive} sub
+ */
+
+Dep.prototype.addSub = function (sub) {
+  this.subs.push(sub);
+};
+
+/**
+ * Remove a directive subscriber.
+ *
+ * @param {Directive} sub
+ */
+
+Dep.prototype.removeSub = function (sub) {
+  remove(this.subs, sub);
+};
+
+/**
+ * Add self as a dependency to the target watcher.
+ */
+
+Dep.prototype.depend = function () {
+  if (Dep.target) {
+    Dep.target.addDep(this);
+  }
+};
+
+/**
+ * Notify all subscribers of a new value.
+ */
+
+Dep.prototype.notify = function () {
+  // stablize the subscriber list first
+  var subs = this.subs.slice();
+  for (var i = 0, l = subs.length; i < l; i++) {
+    subs[i].update();
+  }
+};
+
+/* eslint-disable */
+
+
+// import { pushWatcher } from './batcher'
+var uid = 0;
+
+/**
+ * A watcher parses an expression, collects dependencies,
+ * and fires callback when the expression value changes.
+ * This is used for both the $watch() api and directives.
+ *
+ * @param {Vue} vm
+ * @param {String|Function} expOrFn
+ * @param {Function} cb
+ * @param {Object} options
+ *                 - {Array} filters
+ *                 - {Boolean} twoWay
+ *                 - {Boolean} deep
+ *                 - {Boolean} user
+ *                 - {Boolean} sync
+ *                 - {Boolean} lazy
+ *                 - {Function} [preProcess]
+ *                 - {Function} [postProcess]
+ * @constructor
+ */
+
+function Watcher (vm, expOrFn, cb, options) {
+  // mix in options
+  if (options) {
+    extend(this, options);
+  }
+  var isFn = typeof expOrFn === 'function';
+  this.vm = vm;
+  vm._watchers.push(this);
+  this.expression = expOrFn;
+  this.cb = cb;
+  this.id = ++uid; // uid for batching
+  this.active = true;
+  this.dirty = this.lazy; // for lazy watchers
+  this.deps = [];
+  this.newDeps = [];
+  this.depIds = createNewSet(); // new Set()
+  this.newDepIds = createNewSet(); // new Set()
+  // parse expression for getter
+  if (isFn) {
+    this.getter = expOrFn;
+  }
+  this.value = this.lazy
+    ? undefined
+    : this.get();
+  // state for avoiding false triggers for deep and Array
+  // watchers during vm._digest()
+  this.queued = this.shallow = false;
+}
+
+/**
+ * Evaluate the getter, and re-collect dependencies.
+ */
+
+Watcher.prototype.get = function () {
+  pushTarget(this);
+  var value = this.getter.call(this.vm, this.vm);
+  // "touch" every property so they are all tracked as
+  // dependencies for deep watching
+  if (this.deep) {
+    traverse(value);
+  }
+  popTarget();
+  this.cleanupDeps();
+  return value
+};
+
+/**
+ * Add a dependency to this directive.
+ *
+ * @param {Dep} dep
+ */
+
+Watcher.prototype.addDep = function (dep) {
+  var id = dep.id;
+  if (!this.newDepIds.has(id)) {
+    this.newDepIds.add(id);
+    this.newDeps.push(dep);
+    if (!this.depIds.has(id)) {
+      dep.addSub(this);
+    }
+  }
+};
+
+/**
+ * Clean up for dependency collection.
+ */
+
+Watcher.prototype.cleanupDeps = function () {
+  var this$1 = this;
+
+  var i = this.deps.length;
+  while (i--) {
+    var dep = this$1.deps[i];
+    if (!this$1.newDepIds.has(dep.id)) {
+      dep.removeSub(this$1);
+    }
+  }
+  var tmp = this.depIds;
+  this.depIds = this.newDepIds;
+  this.newDepIds = tmp;
+  this.newDepIds.clear();
+  tmp = this.deps;
+  this.deps = this.newDeps;
+  this.newDeps = tmp;
+  this.newDeps.length = 0;
+};
+
+/**
+ * Subscriber interface.
+ * Will be called when a dependency changes.
+ *
+ * @param {Boolean} shallow
+ */
+
+Watcher.prototype.update = function (shallow) {
+  if (this.lazy) {
+    this.dirty = true;
+  } else {
+    this.run();
+  }
+  // } else if (this.sync) {
+  //   this.run()
+  // } else {
+  //   // if queued, only overwrite shallow with non-shallow,
+  //   // but not the other way around.
+  //   this.shallow = this.queued
+  //     ? shallow
+  //       ? this.shallow
+  //       : false
+  //     : !!shallow
+  //   this.queued = true
+  //   pushWatcher(this)
+  // }
+};
+
+/**
+ * Batcher job interface.
+ * Will be called by the batcher.
+ */
+
+Watcher.prototype.run = function () {
+  if (this.active) {
+    var value = this.get();
+    if (
+      value !== this.value ||
+      // Deep watchers and watchers on Object/Arrays should fire even
+      // when the value is the same, because the value may
+      // have mutated; but only do so if this is a
+      // non-shallow update (caused by a vm digest).
+      ((isObject(value) || this.deep) && !this.shallow)
+    ) {
+      // set new value
+      var oldValue = this.value;
+      this.value = value;
+      this.cb.call(this.vm, value, oldValue);
+    }
+    this.queued = this.shallow = false;
+  }
+};
+
+/**
+ * Evaluate the value of the watcher.
+ * This only gets called for lazy watchers.
+ */
+
+Watcher.prototype.evaluate = function () {
+  this.value = this.get();
+  this.dirty = false;
+};
+
+/**
+ * Depend on all deps collected by this watcher.
+ */
+
+Watcher.prototype.depend = function () {
+  var this$1 = this;
+
+  var i = this.deps.length;
+  while (i--) {
+    this$1.deps[i].depend();
+  }
+};
+
+/**
+ * Remove self from all dependencies' subcriber list.
+ */
+
+Watcher.prototype.teardown = function () {
+  var this$1 = this;
+
+  if (this.active) {
+    // remove self from vm's watcher list
+    // this is a somewhat expensive operation so we skip it
+    // if the vm is being destroyed or is performing a v-for
+    // re-render (the watcher list is then filtered by v-for).
+    if (!this.vm._isBeingDestroyed && !this.vm._vForRemoving) {
+      remove(this.vm._watchers, this);
+    }
+    var i = this.deps.length;
+    while (i--) {
+      this$1.deps[i].removeSub(this$1);
+    }
+    this.active = false;
+    this.vm = this.cb = this.value = null;
+  }
+};
+
+/**
+ * Recrusively traverse an object to evoke all converted
+ * getters, so that every nested property inside the object
+ * is collected as a "deep" dependency.
+ *
+ * @param {*} val
+ * @param {Set} seen
+ */
+
+var seenObjects = createNewSet(); // new Set()
+/* istanbul ignore next */
+function traverse (val, seen) {
+  var i, keys, isA, isO;
+  if (!seen) {
+    seen = seenObjects;
+    seen.clear();
+  }
+  isA = Array.isArray(val);
+  isO = isObject(val);
+  if (isA || isO) {
+    if (val.__ob__) {
+      var depId = val.__ob__.dep.id;
+      if (seen.has(depId)) {
+        return
+      } else {
+        seen.add(depId);
+      }
+    }
+    if (isA) {
+      i = val.length;
+      while (i--) { traverse(val[i], seen); }
+    } else if (isO) {
+      keys = Object.keys(val);
+      i = keys.length;
+      while (i--) { traverse(val[keys[i]], seen); }
+    }
+  }
+}
+
+/* eslint-disable */
+
+
+var arrayProto = Array.prototype;
+var arrayMethods = Object.create(arrayProto);[
+  'push',
+  'pop',
+  'shift',
+  'unshift',
+  'splice',
+  'sort',
+  'reverse'
+]
+.forEach(function (method) {
+  // cache original method
+  var original = arrayProto[method];
+  def(arrayMethods, method, function mutator () {
+    var arguments$1 = arguments;
+
+    // avoid leaking arguments:
+    // http://jsperf.com/closure-with-arguments
+    var i = arguments.length;
+    var args = new Array(i);
+    while (i--) {
+      args[i] = arguments$1[i];
+    }
+    var result = original.apply(this, args);
+    var ob = this.__ob__;
+    var inserted;
+    switch (method) {
+      case 'push':
+        inserted = args;
+        break
+      case 'unshift':
+        inserted = args;
+        break
+      case 'splice':
+        inserted = args.slice(2);
+        break
+    }
+    if (inserted) { ob.observeArray(inserted); }
+    // notify change
+    ob.dep.notify();
+    return result
+  });
+});
+
+/**
+ * Swap the element at the given index with a new value
+ * and emits corresponding event.
+ *
+ * @param {Number} index
+ * @param {*} val
+ * @return {*} - replaced element
+ */
+
+def(
+  arrayProto,
+  '$set',
+  function $set (index, val) {
+    if (index >= this.length) {
+      this.length = index + 1;
+    }
+    return this.splice(index, 1, val)[0]
+  }
+);
+
+/**
+ * Convenience method to remove the element at given index.
+ *
+ * @param {Number} index
+ * @param {*} val
+ */
+
+def(
+  arrayProto,
+  '$remove',
+  function $remove (index) {
+    /* istanbul ignore if */
+    if (!this.length) { return }
+    /* istanbul ignore else */
+    if (typeof index !== 'number') {
+      index = this.indexOf(index);
+    }
+    /* istanbul ignore else */
+    if (index > -1) {
+      this.splice(index, 1);
+    }
+  }
+);
+
+/* eslint-disable */
+
+
+var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
+
+/**
+ * Observer class that are attached to each observed
+ * object. Once attached, the observer converts target
+ * object's property keys into getter/setters that
+ * collect dependencies and dispatches updates.
+ *
+ * @param {Array|Object} value
+ * @constructor
+ */
+
+function Observer (value) {
+  this.value = value;
+  this.dep = new Dep();
+  def(value, '__ob__', this);
+  if (Array.isArray(value)) {
+    var augment = hasProto
+      ? protoAugment
+      : copyAugment;
+    augment(value, arrayMethods, arrayKeys);
+    this.observeArray(value);
+  } else {
+    this.walk(value);
+  }
+}
+
+// Instance methods
+
+/**
+ * Walk through each property and convert them into
+ * getter/setters. This method should only be called when
+ * value type is Object.
+ *
+ * @param {Object} obj
+ */
+
+Observer.prototype.walk = function (obj) {
+  var this$1 = this;
+
+  for (var key in obj) {
+    this$1.convert(key, obj[key]);
+  }
+};
+
+/**
+ * Observe a list of Array items.
+ *
+ * @param {Array} items
+ */
+
+Observer.prototype.observeArray = function (items) {
+  for (var i = 0, l = items.length; i < l; i++) {
+    observe(items[i]);
+  }
+};
+
+/**
+ * Convert a property into getter/setter so we can emit
+ * the events when the property is accessed/changed.
+ *
+ * @param {String} key
+ * @param {*} val
+ */
+
+Observer.prototype.convert = function (key, val) {
+  defineReactive(this.value, key, val);
+};
+
+/**
+ * Add an owner vm, so that when $set/$delete mutations
+ * happen we can notify owner vms to proxy the keys and
+ * digest the watchers. This is only called when the object
+ * is observed as an instance's root $data.
+ *
+ * @param {Vue} vm
+ */
+
+Observer.prototype.addVm = function (vm) {
+  (this.vms || (this.vms = [])).push(vm);
+};
+
+/**
+ * Remove an owner vm. This is called when the object is
+ * swapped out as an instance's $data object.
+ *
+ * @param {Vue} vm
+ */
+
+/* istanbul ignore next */
+Observer.prototype.removeVm = function (vm) {
+  remove(this.vms, vm);
+};
+
+// helpers
+
+/**
+ * Augment an target Object or Array by intercepting
+ * the prototype chain using __proto__
+ *
+ * @param {Object|Array} target
+ * @param {Object} src
+ */
+
+function protoAugment (target, src) {
+  /* eslint-disable no-proto */
+  target.__proto__ = src;
+  /* eslint-enable no-proto */
+}
+
+/**
+ * Augment an target Object or Array by defining
+ * hidden properties.
+ *
+ * @param {Object|Array} target
+ * @param {Object} proto
+ */
+
+/* istanbul ignore next */
+function copyAugment (target, src, keys) {
+  for (var i = 0, l = keys.length; i < l; i++) {
+    var key = keys[i];
+    def(target, key, src[key]);
+  }
+}
+
+/**
+ * Attempt to create an observer instance for a value,
+ * returns the new observer if successfully observed,
+ * or the existing observer if the value already has one.
+ *
+ * @param {*} value
+ * @param {Vue} [vm]
+ * @return {Observer|undefined}
+ * @static
+ */
+
+function observe (value, vm) {
+  if (!isObject(value)) {
+    return
+  }
+  var ob;
+  if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+    ob = value.__ob__;
+  } else if (
+    (Array.isArray(value) || isPlainObject(value)) &&
+    Object.isExtensible(value) &&
+    !value._isVue
+  ) {
+    ob = new Observer(value);
+  }
+  if (ob && vm) {
+    ob.addVm(vm);
+  }
+  return ob
+}
+
+/**
+ * Define a reactive property on an Object.
+ *
+ * @param {Object} obj
+ * @param {String} key
+ * @param {*} val
+ */
+
+function defineReactive (obj, key, val) {
+  var dep = new Dep();
+
+  var property = Object.getOwnPropertyDescriptor(obj, key);
+  if (property && property.configurable === false) {
+    return
+  }
+
+  // cater for pre-defined getter/setters
+  var getter = property && property.get;
+  var setter = property && property.set;
+
+  var childOb = observe(val);
+  Object.defineProperty(obj, key, {
+    enumerable: true,
+    configurable: true,
+    get: function reactiveGetter () {
+      var value = getter ? getter.call(obj) : val;
+      if (Dep.target) {
+        dep.depend();
+        if (childOb) {
+          childOb.dep.depend();
+        }
+        if (Array.isArray(value)) {
+          for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
+            e = value[i];
+            e && e.__ob__ && e.__ob__.dep.depend();
+          }
+        }
+      }
+      return value
+    },
+    set: function reactiveSetter (newVal) {
+      var value = getter ? getter.call(obj) : val;
+      if (newVal === value) {
+        return
+      }
+      if (setter) {
+        setter.call(obj, newVal);
+      } else {
+        val = newVal;
+      }
+      childOb = observe(newVal);
+      dep.notify();
+    }
+  });
+}
+
+/**
+ * Set a property on an object. Adds the new property and
+ * triggers change notification if the property doesn't
+ * already exist.
+ *
+ * @param {Object} obj
+ * @param {String} key
+ * @param {*} val
+ * @public
+ */
+
+/* istanbul ignore next */
+function set (obj, key, val) {
+  if (Array.isArray(obj)) {
+    return obj.splice(key, 1, val)
+  }
+  if (hasOwn(obj, key)) {
+    obj[key] = val;
+    return
+  }
+  if (obj._isVue) {
+    set(obj._data, key, val);
+    return
+  }
+  var ob = obj.__ob__;
+  if (!ob) {
+    obj[key] = val;
+    return
+  }
+  ob.convert(key, val);
+  ob.dep.notify();
+  if (ob.vms) {
+    var i = ob.vms.length;
+    while (i--) {
+      var vm = ob.vms[i];
+      proxy(vm, key);
+      // vm.$forceUpdate()
+    }
+  }
+  return val
+}
+
+/**
+ * Delete a property and trigger change if necessary.
+ *
+ * @param {Object} obj
+ * @param {String} key
+ */
+
+/* istanbul ignore next */
+function del (obj, key) {
+  if (!hasOwn(obj, key)) {
+    return
+  }
+  delete obj[key];
+  var ob = obj.__ob__;
+
+  if (!ob) {
+    if (obj._isVue) {
+      delete obj._data[key];
+      // obj.$forceUpdate()
+    }
+    return
+  }
+  ob.dep.notify();
+  if (ob.vms) {
+    var i = ob.vms.length;
+    while (i--) {
+      var vm = ob.vms[i];
+      unproxy(vm, key);
+      // vm.$forceUpdate()
+    }
+  }
+}
+
+var KEY_WORDS = ['$index', '$value', '$event'];
+function proxy (vm, key) {
+  if (KEY_WORDS.indexOf(key) > -1 || !isReserved(key)) {
+    Object.defineProperty(vm, key, {
+      configurable: true,
+      enumerable: true,
+      get: function proxyGetter () {
+        return vm._data[key]
+      },
+      set: function proxySetter (val) {
+        vm._data[key] = val;
+      }
+    });
+  }
+}
+
+/* istanbul ignore next */
+function unproxy (vm, key) {
+  if (!isReserved(key)) {
+    delete vm[key];
+  }
+}
+
+/* eslint-disable */
+
+
+function initState (vm) {
+  vm._watchers = [];
+  initData(vm);
+  initComputed(vm);
+  initMethods(vm);
+}
+
+function initData (vm) {
+  var data = vm._data;
+
+  if (!isPlainObject(data)) {
+    data = {};
+  }
+  // proxy data on instance
+  var keys = Object.keys(data);
+  var i = keys.length;
+  while (i--) {
+    proxy(vm, keys[i]);
+  }
+  // observe data
+  observe(data, vm);
+}
+
+/* istanbul ignore next */
+function noop () {
+}
+
+function initComputed (vm) {
+  var computed = vm._computed;
+  if (computed) {
+    for (var key in computed) {
+      var userDef = computed[key];
+      var def$$1 = {
+        enumerable: true,
+        configurable: true
+      };
+      if (typeof userDef === 'function') {
+        def$$1.get = makeComputedGetter(userDef, vm);
+        def$$1.set = noop;
+      } else {
+        def$$1.get = userDef.get
+          ? userDef.cache !== false
+            ? makeComputedGetter(userDef.get, vm)
+            : bind(userDef.get, vm)
+          : noop;
+        def$$1.set = userDef.set
+          ? bind(userDef.set, vm)
+          : noop;
+      }
+      Object.defineProperty(vm, key, def$$1);
+    }
+  }
+}
+
+function makeComputedGetter (getter, owner) {
+  var watcher = new Watcher(owner, getter, null, {
+    lazy: true
+  });
+  return function computedGetter () {
+    if (watcher.dirty) {
+      watcher.evaluate();
+    }
+    if (Dep.target) {
+      watcher.depend();
+    }
+    return watcher.value
+  }
+}
+
+function initMethods (vm) {
+  var methods = vm._methods;
+  if (methods) {
+    for (var key in methods) {
+      vm[key] = methods[key];
+    }
+  }
+}
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+// @todo: It should be registered by native from `registerComponents()`.
+
+var config = {
+  nativeComponentMap: {
+    text: true,
+    image: true,
+    container: true,
+    slider: {
+      type: 'slider',
+      append: 'tree'
+    },
+    cell: {
+      type: 'cell',
+      append: 'tree'
+    }
+  }
+};
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/**
+ * @fileOverview
+ * Directive Parser
+ */
+
+var nativeComponentMap = config.nativeComponentMap;
+
+var SETTERS = {
+  attr: 'setAttr',
+  style: 'setStyle',
+  event: 'addEvent'
+};
+
+/**
+ * apply the native component's options(specified by template.type)
+ * to the template
+ */
+function applyNaitveComponentOptions (template) {
+  var type = template.type;
+  var options = nativeComponentMap[type];
+
+  if (typeof options === 'object') {
+    for (var key in options) {
+      if (template[key] == null) {
+        template[key] = options[key];
+      }
+      else if (typof(template[key]) === 'object' &&
+        typof(options[key]) === 'object') {
+        for (var subkey in options[key]) {
+          if (template[key][subkey] == null) {
+            template[key][subkey] = options[key][subkey];
+          }
+        }
+      }
+    }
+  }
+}
+
+/**
+ * bind all id, attr, classnames, style, events to an element
+ */
+function bindElement (vm, el, template) {
+  setId(vm, el, template.id, vm);
+  setAttr(vm, el, template.attr);
+  setClass(vm, el, template.classList);
+  setStyle(vm, el, template.style);
+  bindEvents(vm, el, template.events);
+}
+
+/**
+ * bind all props to sub vm and bind all style, events to the root element
+ * of the sub vm if it doesn't have a replaced multi-node fragment
+ */
+function bindSubVm (vm, subVm, template, repeatItem) {
+  subVm = subVm || {};
+  template = template || {};
+
+  var options = subVm._options || {};
+
+  // bind props
+  var props = options.props;
+
+  if (Array.isArray(props)) {
+    props = props.reduce(function (result, value) {
+      result[value] = true;
+      return result
+    }, {});
+  }
+
+  mergeProps(repeatItem, props, vm, subVm);
+  mergeProps(template.attr, props, vm, subVm);
+}
+
+/**
+ * merge class and styles from vm to sub vm.
+ */
+function bindSubVmAfterInitialized (vm, subVm, template, target) {
+  if ( target === void 0 ) target = {};
+
+  mergeClassStyle(template.classList, vm, subVm);
+  mergeStyle(template.style, vm, subVm);
+
+  // bind subVm to the target element
+  if (target.children) {
+    target.children[target.children.length - 1]._vm = subVm;
+  }
+  else {
+    target._vm = subVm;
+  }
+}
+
+/**
+ * Bind props from vm to sub vm and watch their updates.
+ */
+function mergeProps (target, props, vm, subVm) {
+  if (!target) {
+    return
+  }
+  var loop = function ( key ) {
+    if (!props || props[key]) {
+      var value = target[key];
+      if (typeof value === 'function') {
+        var returnValue = watch(vm, value, function (v) {
+          subVm[key] = v;
+        });
+        subVm[key] = returnValue;
+      }
+      else {
+        subVm[key] = value;
+      }
+    }
+  };
+
+  for (var key in target) loop( key );
+}
+
+/**
+ * Bind style from vm to sub vm and watch their updates.
+ */
+function mergeStyle (target, vm, subVm) {
+  var loop = function ( key ) {
+    var value = target[key];
+    if (typeof value === 'function') {
+      var returnValue = watch(vm, value, function (v) {
+        if (subVm._rootEl) {
+          subVm._rootEl.setStyle(key, v);
+        }
+      });
+      subVm._rootEl.setStyle(key, returnValue);
+    }
+    else {
+      if (subVm._rootEl) {
+        subVm._rootEl.setStyle(key, value);
+      }
+    }
+  };
+
+  for (var key in target) loop( key );
+}
+
+/**
+ * Bind class & style from vm to sub vm and watch their updates.
+ */
+function mergeClassStyle (target, vm, subVm) {
+  var css = vm._options && vm._options.style || {};
+
+  /* istanbul ignore if */
+  if (!subVm._rootEl) {
+    return
+  }
+
+  var className = '@originalRootEl';
+  css[className] = subVm._rootEl.classStyle;
+
+  function addClassName (list, name) {
+    if (typof(list) === 'array') {
+      list.unshift(name);
+    }
+  }
+
+  if (typeof target === 'function') {
+    var value = watch(vm, target, function (v) {
+      addClassName(v, className);
+      setClassStyle(subVm._rootEl, css, v);
+    });
+    addClassName(value, className);
+    setClassStyle(subVm._rootEl, css, value);
+  }
+  else if (target != null) {
+    addClassName(target, className);
+    setClassStyle(subVm._rootEl, css, target);
+  }
+}
+
+/**
+ * bind id to an element
+ * each id is unique in a whole vm
+ */
+function setId (vm, el, id, target) {
+  var map = Object.create(null);
+
+  Object.defineProperties(map, {
+    vm: {
+      value: target,
+      writable: false,
+      configurable: false
+    },
+    el: {
+      get: function () { return el || target._rootEl; },
+      configurable: false
+    }
+  });
+
+  if (typeof id === 'function') {
+    var handler = id;
+    id = handler.call(vm);
+    if (id || id === 0) {
+      vm._ids[id] = map;
+    }
+    watch(vm, handler, function (newId) {
+      if (newId) {
+        vm._ids[newId] = map;
+      }
+    });
+  }
+  else if (id && typeof id === 'string') {
+    vm._ids[id] = map;
+  }
+}
+
+/**
+ * bind attr to an element
+ */
+function setAttr (vm, el, attr) {
+  bindDir(vm, el, 'attr', attr);
+}
+
+function setClassStyle (el, css, classList) {
+  var classStyle = {};
+  var length = classList.length;
+
+  var loop = function ( i ) {
+    var style = css[classList[i]];
+    if (style) {
+      Object.keys(style).forEach(function (key) {
+        classStyle[key] = style[key];
+      });
+    }
+  };
+
+  for (var i = 0; i < length; i++) loop( i );
+  el.setClassStyle(classStyle);
+}
+
+/**
+ * bind classnames to an element
+ */
+function setClass (vm, el, classList) {
+  if (typeof classList !== 'function' && !Array.isArray(classList)) {
+    return
+  }
+  if (Array.isArray(classList) && !classList.length) {
+    el.setClassStyle({});
+    return
+  }
+
+  var style = vm._options && vm._options.style || {};
+  if (typeof classList === 'function') {
+    var value = watch(vm, classList, function (v) {
+      setClassStyle(el, style, v);
+    });
+    setClassStyle(el, style, value);
+  }
+  else {
+    setClassStyle(el, style, classList);
+  }
+}
+
+/**
+ * bind style to an element
+ */
+function setStyle (vm, el, style) {
+  bindDir(vm, el, 'style', style);
+}
+
+/**
+ * add an event type and handler to an element and generate a dom update
+ */
+function setEvent (vm, el, type, handler) {
+  el.addEvent(type, bind(handler, vm));
+}
+
+/**
+ * add all events of an element
+ */
+function bindEvents (vm, el, events) {
+  if (!events) {
+    return
+  }
+  var keys = Object.keys(events);
+  var i = keys.length;
+  while (i--) {
+    var key = keys[i];
+    var handler = events[key];
+    if (typeof handler === 'string') {
+      handler = vm[handler];
+      /* istanbul ignore if */
+      if (!handler) {
+        console.warn(("[JS Framework] The event handler \"" + handler + "\" is not defined."));
+      }
+    }
+    setEvent(vm, el, key, handler);
+  }
+}
+
+/**
+ * set a series of members as a kind of an element
+ * for example: style, attr, ...
+ * if the value is a function then bind the data changes
+ */
+function bindDir (vm, el, name, data) {
+  if (!data) {
+    return
+  }
+  var keys = Object.keys(data);
+  var i = keys.length;
+  while (i--) {
+    var key = keys[i];
+    var value = data[key];
+    if (typeof value === 'function') {
+      bindKey(vm, el, name, key, value);
+    }
+    else {
+      el[SETTERS[name]](key, value);
+    }
+  }
+}
+
+/**
+ * bind data changes to a certain key to a name series in an element
+ */
+function bindKey (vm, el, name, key, calc) {
+  var methodName = SETTERS[name];
+  // watch the calc, and returns a value by calc.call()
+  var value = watch(vm, calc, function (value) {
+    function handler () {
+      el[methodName](key, value);
+    }
+    var differ = vm && vm._app && vm._app.differ;
+    if (differ) {
+      differ.append('element', el.depth, el.ref, handler);
+    }
+    else {
+      handler();
+    }
+  });
+
+  el[methodName](key, value);
+}
+
+/**
+ * watch a calc function and callback if the calc value changes
+ */
+function watch (vm, calc, callback) {
+  if (vm._static) {
+    return calc.call(vm, vm)
+  }
+  var watcher = new Watcher(vm, calc, function (value, oldValue) {
+    /* istanbul ignore if */
+    if (typeof value !== 'object' && value === oldValue) {
+      return
+    }
+    callback(value);
+  });
+
+  return watcher.value
+}
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/**
+ * @fileOverview Document & Element Helpers.
+ *
+ * required:
+ * Document#: createElement, createComment, getRef
+ * Element#: appendChild, insertBefore, removeChild, nextSibling
+ */
+
+/**
+ * Create a body by type
+ * Using this._app.doc
+ *
+ * @param  {string} type
+ */
+function createBody (vm, type) {
+  var doc = vm._app.doc;
+  return doc.createBody(type)
+}
+
+/**
+ * Create an element by type
+ * Using this._app.doc
+ *
+ * @param  {string} type
+ */
+function createElement (vm, type) {
+  var doc = vm._app.doc;
+  return doc.createElement(type)
+}
+
+/**
+ * Create and return a frag block for an element.
+ * The frag block has a starter, ender and the element itself.
+ *
+ * @param  {object} element
+ */
+function createBlock (vm, element) {
+  var start = createBlockStart(vm);
+  var end = createBlockEnd(vm);
+  var blockId = lastestBlockId++;
+  if (element.element) {
+    var updateMark = element.updateMark;
+    if (updateMark) {
+      if (updateMark.element) {
+        updateMark = updateMark.end;
+      }
+      element.element.insertAfter(end, updateMark);
+      element.element.insertAfter(start, updateMark);
+      element.updateMark = end;
+    }
+    else {
+      element.element.insertBefore(start, element.end);
+      element.element.insertBefore(end, element.end);
+    }
+    element = element.element;
+  }
+  else {
+    element.appendChild(start);
+    element.appendChild(end);
+  }
+  return { start: start, end: end, element: element, blockId: blockId }
+}
+
+var lastestBlockId = 1;
+
+/**
+ * Create and return a block starter.
+ * Using this._app.doc
+ */
+function createBlockStart (vm) {
+  var doc = vm._app.doc;
+  var anchor = doc.createComment('start');
+  return anchor
+}
+
+/**
+ * Create and return a block ender.
+ * Using this._app.doc
+ */
+function createBlockEnd (vm) {
+  var doc = vm._app.doc;
+  var anchor = doc.createComment('end');
+  return anchor
+}
+
+/**
+ * Attach target to a certain dest using appendChild by default.
+ * If the dest is a frag block then insert before the ender.
+ * If the target is a frag block then attach the starter and ender in order.
+ *
+ * @param  {object} target
+ * @param  {object} dest
+ */
+function attachTarget (vm, target, dest) {
+  if (dest.element) {
+    var before = dest.end;
+    var after = dest.updateMark;
+    // push new target for watch list update later
+    if (dest.children) {
+      dest.children.push(target);
+    }
+    // for check repeat case
+    if (after) {
+      var signal = moveTarget(vm, target, after);
+      dest.updateMark = target.element ? target.end : target;
+      return signal
+    }
+    else if (target.element) {
+      dest.element.insertBefore(target.start, before);
+      dest.element.insertBefore(target.end, before);
+    }
+    else {
+      return dest.element.insertBefore(target, before)
+    }
+  }
+  else {
+    if (target.element) {
+      dest.appendChild(target.start);
+      dest.appendChild(target.end);
+    }
+    else {
+      return dest.appendChild(target)
+    }
+  }
+}
+
+/**
+ * Move target before a certain element. The target maybe block or element.
+ *
+ * @param  {object} target
+ * @param  {object} before
+ */
+function moveTarget (vm, target, after) {
+  if (target.element) {
+    return moveBlock(target, after)
+  }
+  return moveElement(target, after)
+}
+
+/**
+ * Move element before a certain element.
+ *
+ * @param  {object} element
+ * @param  {object} before
+ */
+function moveElement (element, after) {
+  var parent = after.parentNode;
+  if (parent) {
+    return parent.insertAfter(element, after)
+  }
+}
+
+/**
+ * Move all elements of the block before a certain element.
+ *
+ * @param  {object} fragBlock
+ * @param  {object} before
+ */
+function moveBlock (fragBlock, after) {
+  var parent = after.parentNode;
+
+  if (parent) {
+    var el = fragBlock.start;
+    var signal;
+    var group = [el];
+
+    while (el && el !== fragBlock.end) {
+      el = el.nextSibling;
+      group.push(el);
+    }
+
+    var temp = after;
+    group.every(function (el) {
+      signal = parent.insertAfter(el, temp);
+      temp = el;
+      return signal !== -1
+    });
+
+    return signal
+  }
+}
+
+/**
+ * Remove target from DOM tree.
+ * If the target is a frag block then call _removeBlock
+ *
+ * @param  {object} target
+ */
+function removeTarget (vm, target, preserveBlock) {
+  if ( preserveBlock === void 0 ) preserveBlock = false;
+
+  if (target.element) {
+    removeBlock(target, preserveBlock);
+  }
+  else {
+    removeElement(target);
+  }
+  if (target._vm) {
+    target._vm.$emit('hook:destroyed');
+  }
+}
+
+/**
+ * Remove a certain element.
+ * Using this._app.doc
+ *
+ * @param  {object} target
+ */
+function removeElement (target) {
+  var parent = target.parentNode;
+
+  if (parent) {
+    parent.removeChild(target);
+  }
+}
+
+/**
+ * Remove a frag block.
+ * The second param decides whether the block self should be removed too.
+ *
+ * @param  {object}  fragBlock
+ * @param  {Boolean} preserveBlock=false
+ */
+function removeBlock (fragBlock, preserveBlock) {
+  if ( preserveBlock === void 0 ) preserveBlock = false;
+
+  var result = [];
+  var el = fragBlock.start.nextSibling;
+
+  while (el && el !== fragBlock.end) {
+    result.push(el);
+    el = el.nextSibling;
+  }
+
+  if (!preserveBlock) {
+    removeElement(fragBlock.start);
+  }
+  result.forEach(function (el) {
+    removeElement(el);
+  });
+  if (!preserveBlock) {
+    removeElement(fragBlock.end);
+  }
+}
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/**
+ * @fileOverview
+ * ViewModel template parser & data-binding process
+ */
+
+/**
+ * build()
+ *   compile(template, parentNode)
+ *     if (type is content) create contentNode
+ *     else if (dirs have v-for) foreach -> create context
+ *       -> compile(templateWithoutFor, parentNode): diff(list) onchange
+ *     else if (dirs have v-if) assert
+ *       -> compile(templateWithoutIf, parentNode): toggle(shown) onchange
+ *     else if (type is dynamic)
+ *       -> compile(templateWithoutDynamicType, parentNode): watch(type) onchange
+ *     else if (type is custom)
+ *       addChildVm(vm, parentVm)
+ *       build(externalDirs)
+ *       foreach childNodes -> compile(childNode, template)
+ *     else if (type is native)
+ *       set(dirs): update(id/attr/style/class) onchange
+ *       append(template, parentNode)
+ *       foreach childNodes -> compile(childNode, template)
+ */
+function build (vm) {
+  var opt = vm._options || {};
+  var template = opt.template || {};
+
+  if (opt.replace) {
+    if (template.children && template.children.length === 1) {
+      compile(vm, template.children[0], vm._parentEl);
+    }
+    else {
+      compile(vm, template.children, vm._parentEl);
+    }
+  }
+  else {
+    compile(vm, template, vm._parentEl);
+  }
+
+  console.debug(("[JS Framework] \"ready\" lifecycle in Vm(" + (vm._type) + ")"));
+  vm.$emit('hook:ready');
+  vm._ready = true;
+}
+
+/**
+ * Generate elements by child or children and append to parent elements.
+ * Root element info would be merged if has. The first argument may be an array
+ * if the root element with options.replace has not only one child.
+ *
+ * @param {object|array} target
+ * @param {object}       dest
+ * @param {object}       meta
+ */
+function compile (vm, target, dest, meta) {
+  var app = vm._app || {};
+
+  if (app.lastSignal === -1) {
+    return
+  }
+
+  if (target.attr && target.attr.hasOwnProperty('static')) {
+    vm._static = true;
+  }
+
+  if (targetIsFragment(target)) {
+    compileFragment(vm, target, dest, meta);
+    return
+  }
+  meta = meta || {};
+  if (targetIsContent(target)) {
+    console.debug('[JS Framework] compile "content" block by', target);
+    vm._content = createBlock(vm, dest);
+    return
+  }
+
+  if (targetNeedCheckRepeat(target, meta)) {
+    console.debug('[JS Framework] compile "repeat" logic by', target);
+    if (dest.type === 'document') {
+      console.warn('[JS Framework] The root element does\'t support `repeat` directive!');
+    }
+    else {
+      compileRepeat(vm, target, dest);
+    }
+    return
+  }
+  if (targetNeedCheckShown(target, meta)) {
+    console.debug('[JS Framework] compile "if" logic by', target);
+    if (dest.type === 'document') {
+      console.warn('[JS Framework] The root element does\'t support `if` directive!');
+    }
+    else {
+      compileShown(vm, target, dest, meta);
+    }
+    return
+  }
+  var typeGetter = meta.type || target.type;
+  if (targetNeedCheckType(typeGetter, meta)) {
+    compileType(vm, target, dest, typeGetter, meta);
+    return
+  }
+  var type = typeGetter;
+  var component = targetIsComposed(vm, target, type);
+  if (component) {
+    console.debug('[JS Framework] compile composed component by', target);
+    compileCustomComponent(vm, component, target, dest, type, meta);
+    return
+  }
+  console.debug('[JS Framework] compile native component by', target);
+  compileNativeComponent(vm, target, dest, type);
+}
+
+/**
+ * Check if target is a fragment (an array).
+ *
+ * @param  {object}  target
+ * @return {boolean}
+ */
+function targetIsFragment (target) {
+  return Array.isArray(target)
+}
+
+/**
+ * Check if target type is content/slot.
+ *
+ * @param  {object}  target
+ * @return {boolean}
+ */
+function targetIsContent (target) {
+  return target.type === 'content' || target.type === 'slot'
+}
+
+/**
+ * Check if target need to compile by a list.
+ *
+ * @param  {object}  target
+ * @param  {object}  meta
+ * @return {boolean}
+ */
+function targetNeedCheckRepeat (target, meta) {
+  return !meta.hasOwnProperty('repeat') && target.repeat
+}
+
+/**
+ * Check if target need to compile by a boolean value.
+ *
+ * @param  {object}  target
+ * @param  {object}  meta
+ * @return {boolean}
+ */
+function targetNeedCheckShown (target, meta) {
+  return !meta.hasOwnProperty('shown') && target.shown
+}
+
+/**
+ * Check if target need to compile by a dynamic type.
+ *
+ * @param  {string|function} typeGetter
+ * @param  {object}          meta
+ * @return {boolean}
+ */
+function targetNeedCheckType (typeGetter, meta) {
+  return (typeof typeGetter === 'function') && !meta.hasOwnProperty('type')
+}
+
+/**
+ * Check if this kind of component is composed.
+ *
+ * @param  {string}  type
+ * @return {boolean}
+ */
+function targetIsComposed (vm, target, type) {
+  var component;
+  if (vm._app && vm._app.customComponentMap) {
+    component = vm._app.customComponentMap[type];
+  }
+  if (vm._options && vm._options.components) {
+    component = vm._options.components[type];
+  }
+  if (target.component) {
+    component = component || {};
+  }
+  return component
+}
+
+/**
+ * Compile a list of targets.
+ *
+ * @param {object} target
+ * @param {object} dest
+ * @param {object} meta
+ */
+function compileFragment (vm, target, dest, meta) {
+  var fragBlock = createBlock(vm, dest);
+  target.forEach(function (child) {
+    compile(vm, child, fragBlock, meta);
+  });
+}
+
+/**
+ * Compile a target with repeat directive.
+ *
+ * @param {object} target
+ * @param {object} dest
+ */
+function compileRepeat (vm, target, dest) {
+  var repeat = target.repeat;
+  var oldStyle = typeof repeat === 'function';
+  var getter = repeat.getter || repeat.expression || repeat;
+  if (typeof getter !== 'function') {
+    getter = function () { return [] };
+  }
+  var key = repeat.key || '$index';
+  var value = repeat.value || '$value';
+  var trackBy = repeat.trackBy || target.trackBy ||
+    (target.attr && target.attr.trackBy);
+
+  var fragBlock = createBlock(vm, dest);
+  fragBlock.children = [];
+  fragBlock.data = [];
+  fragBlock.vms = [];
+
+  bindRepeat(vm, target, fragBlock, { getter: getter, key: key, value: value, trackBy: trackBy, oldStyle: oldStyle });
+}
+
+/**
+ * Compile a target with if directive.
+ *
+ * @param {object} target
+ * @param {object} dest
+ * @param {object} meta
+ */
+function compileShown (vm, target, dest, meta) {
+  var newMeta = { shown: true };
+  var fragBlock = createBlock(vm, dest);
+
+  if (dest.element && dest.children) {
+    dest.children.push(fragBlock);
+  }
+
+  if (meta.repeat) {
+    newMeta.repeat = meta.repeat;
+  }
+
+  bindShown(vm, target, fragBlock, newMeta);
+}
+
+/**
+ * Compile a target with dynamic component type.
+ *
+ * @param {object}   target
+ * @param {object}   dest
+ * @param {function} typeGetter
+ */
+function compileType (vm, target, dest, typeGetter, meta) {
+  var type = typeGetter.call(vm);
+  var newMeta = extend({ type: type }, meta);
+  var fragBlock = createBlock(vm, dest);
+
+  if (dest.element && dest.children) {
+    dest.children.push(fragBlock);
+  }
+
+  watch(vm, typeGetter, function (value) {
+    var newMeta = extend({ type: value }, meta);
+    removeTarget(vm, fragBlock, true);
+    compile(vm, target, fragBlock, newMeta);
+  });
+
+  compile(vm, target, fragBlock, newMeta);
+}
+
+/**
+ * Compile a composed component.
+ *
+ * @param {object} target
+ * @param {object} dest
+ * @param {string} type
+ */
+function compileCustomComponent (vm, component, target, dest, type, meta) {
+  var Ctor = vm.constructor;
+  var subVm = new Ctor(type, component, vm, dest, undefined, {
+    'hook:init': function () {
+      if (vm._static) {
+        this._static = vm._static;
+      }
+      setId(vm, null, target.id, this);
+      // bind template earlier because of lifecycle issues
+      this._externalBinding = {
+        parent: vm,
+        template: target
+      };
+    },
+    'hook:created': function () {
+      bindSubVm(vm, this, target, meta.repeat);
+    },
+    'hook:ready': function () {
+      if (this._content) {
+        compileChildren(vm, target, this._content);
+      }
+    }
+  });
+  bindSubVmAfterInitialized(vm, subVm, target, dest);
+}
+
+/**
+ * Generate element from template and attach to the dest if needed.
+ * The time to attach depends on whether the mode status is node or tree.
+ *
+ * @param {object} template
+ * @param {object} dest
+ * @param {string} type
+ */
+function compileNativeComponent (vm, template, dest, type) {
+  applyNaitveComponentOptions(template);
+
+  var element;
+  if (dest.ref === '_documentElement') {
+    // if its parent is documentElement then it's a body
+    console.debug(("[JS Framework] compile to create body for " + type));
+    element = createBody(vm, type);
+  }
+  else {
+    console.debug(("[JS Framework] compile to create element for " + type));
+    element = createElement(vm, type);
+  }
+
+  if (!vm._rootEl) {
+    vm._rootEl = element;
+    // bind event earlier because of lifecycle issues
+    var binding = vm._externalBinding || {};
+    var target = binding.template;
+    var parentVm = binding.parent;
+    if (target && target.events && parentVm && element) {
+      for (var type$1 in target.events) {
+        var handler = parentVm[target.events[type$1]];
+        if (handler) {
+          element.addEvent(type$1, bind(handler, parentVm));
+        }
+      }
+    }
+  }
+
+  bindElement(vm, element, template);
+
+  if (template.attr && template.attr.append) { // backward, append prop in attr
+    template.append = template.attr.append;
+  }
+
+  if (template.append) { // give the append attribute for ios adaptation
+    element.attr = element.attr || {};
+    element.attr.append = template.append;
+  }
+
+  var treeMode = template.append === 'tree';
+  var app = vm._app || {};
+  if (app.lastSignal !== -1 && !treeMode) {
+    console.debug('[JS Framework] compile to append single node for', element);
+    app.lastSignal = attachTarget(vm, element, dest);
+  }
+  if (app.lastSignal !== -1) {
+    compileChildren(vm, template, element);
+  }
+  if (app.lastSignal !== -1 && treeMode) {
+    console.debug('[JS Framework] compile to append whole tree for', element);
+    app.lastSignal = attachTarget(vm, element, dest);
+  }
+}
+
+/**
+ * Set all children to a certain parent element.
+ *
+ * @param {object} template
+ * @param {object} dest
+ */
+function compileChildren (vm, template, dest) {
+  var app = vm._app || {};
+  var children = template.children;
+  if (children && children.length) {
+    children.every(function (child) {
+      compile(vm, child, dest);
+      return app.lastSignal !== -1
+    });
+  }
+}
+
+/**
+ * Watch the list update and refresh the changes.
+ *
+ * @param {object} target
+ * @param {object} fragBlock {vms, data, children}
+ * @param {object} info      {getter, key, value, trackBy, oldStyle}
+ */
+function bindRepeat (vm, target, fragBlock, info) {
+  var vms = fragBlock.vms;
+  var children = fragBlock.children;
+  var getter = info.getter;
+  var trackBy = info.trackBy;
+  var oldStyle = info.oldStyle;
+  var keyName = info.key;
+  var valueName = info.value;
+
+  function compileItem (item, index, context) {
+    var mergedData;
+    if (oldStyle) {
+      mergedData = item;
+      if (isObject(item)) {
+        mergedData[keyName] = index;
+        if (!mergedData.hasOwnProperty('INDEX')) {
+          Object.defineProperty(mergedData, 'INDEX', {
+            value: function () {
+              console.warn('[JS Framework] "INDEX" in repeat is deprecated, ' +
+                'please use "$index" instead');
+            }
+          });
+        }
+      }
+      else {
+        console.warn('[JS Framework] Each list item must be an object in old-style repeat, '
+          + 'please use `repeat={{v in list}}` instead.');
+        mergedData = {};
+        mergedData[keyName] = index;
+        mergedData[valueName] = item;
+      }
+    }
+    else {
+      mergedData = {};
+      mergedData[keyName] = index;
+      mergedData[valueName] = item;
+    }
+    var newContext = mergeContext(context, mergedData);
+    vms.push(newContext);
+    compile(newContext, target, fragBlock, { repeat: item });
+  }
+
+  var list = watchBlock(vm, fragBlock, getter, 'repeat',
+    function (data) {
+      console.debug('[JS Framework] the "repeat" item has changed', data);
+      if (!fragBlock || !data) {
+        return
+      }
+
+      var oldChildren = children.slice();
+      var oldVms = vms.slice();
+      var oldData = fragBlock.data.slice();
+      // 1. collect all new refs track by
+      var trackMap = {};
+      var reusedMap = {};
+      data.forEach(function (item, index) {
+        var key = trackBy ? item[trackBy] : (oldStyle ? item[keyName] : index);
+        /* istanbul ignore if */
+        if (key == null || key === '') {
+          return
+        }
+        trackMap[key] = item;
+      });
+
+      // 2. remove unused element foreach old item
+      var reusedList = [];
+      oldData.forEach(function (item, index) {
+        var key = trackBy ? item[trackBy] : (oldStyle ? item[keyName] : index);
+        if (trackMap.hasOwnProperty(key)) {
+          reusedMap[key] = {
+            item: item, index: index, key: key,
+            target: oldChildren[index],
+            vm: oldVms[index]
+          };
+          reusedList.push(item);
+        }
+        else {
+          removeTarget(vm, oldChildren[index]);
+        }
+      });
+
+      // 3. create new element foreach new item
+      children.length = 0;
+      vms.length = 0;
+      fragBlock.data = data.slice();
+      fragBlock.updateMark = fragBlock.start;
+
+      data.forEach(function (item, index) {
+        var key = trackBy ? item[trackBy] : (oldStyle ? item[keyName] : index);
+        var reused = reusedMap[key];
+        if (reused) {
+          if (reused.item === reusedList[0]) {
+            reusedList.shift();
+          }
+          else {
+            reusedList.$remove(reused.item);
+            moveTarget(vm, reused.target, fragBlock.updateMark, true);
+          }
+          children.push(reused.target);
+          vms.push(reused.vm);
+          if (oldStyle) {
+            reused.vm = item;
+          }
+          else {
+            reused.vm[valueName] = item;
+          }
+          reused.vm[keyName] = index;
+          fragBlock.updateMark = reused.target;
+        }
+        else {
+          compileItem(item, index, vm);
+        }
+      });
+
+      delete fragBlock.updateMark;
+    }
+  );
+
+  fragBlock.data = list.slice(0);
+  list.forEach(function (item, index) {
+    compileItem(item, index, vm);
+  });
+}
+
+/**
+ * Watch the display update and add/remove the element.
+ *
+ * @param  {object} target
+ * @param  {object} fragBlock
+ * @param  {object} context
+ */
+function bindShown (vm, target, fragBlock, meta) {
+  var display = watchBlock(vm, fragBlock, target.shown, 'shown',
+    function (display) {
+      console.debug('[JS Framework] the "if" item was changed', display);
+
+      if (!fragBlock || !!fragBlock.display === !!display) {
+        return
+      }
+      fragBlock.display = !!display;
+      if (display) {
+        compile(vm, target, fragBlock, meta);
+      }
+      else {
+        removeTarget(vm, fragBlock, true);
+      }
+    }
+  );
+
+  fragBlock.display = !!display;
+  if (display) {
+    compile(vm, target, fragBlock, meta);
+  }
+}
+
+/**
+ * Watch calc value changes and append certain type action to differ.
+ * It is used for if or repeat data-binding generator.
+ *
+ * @param  {object}   fragBlock
+ * @param  {function} calc
+ * @param  {string}   type
+ * @param  {function} handler
+ * @return {any}      init value of calc
+ */
+function watchBlock (vm, fragBlock, calc, type, handler) {
+  var differ = vm && vm._app && vm._app.differ;
+  var config = {};
+  var depth = (fragBlock.element.depth || 0) + 1;
+
+  return watch(vm, calc, function (value) {
+    config.latestValue = value;
+    if (differ && !config.recorded) {
+      differ.append(type, depth, fragBlock.blockId, function () {
+        var latestValue = config.latestValue;
+        handler(latestValue);
+        config.recorded = false;
+        config.latestValue = undefined;
+      });
+    }
+    config.recorded = true;
+  })
+}
+
+/**
+ * Clone a context and merge certain data.
+ *
+ * @param  {object} mergedData
+ * @return {object}
+ */
+function mergeContext (context, mergedData) {
+  var newContext = Object.create(context);
+  newContext._data = mergedData;
+  initData(newContext);
+  initComputed(newContext);
+  newContext._realParent = context;
+  if (context._static) {
+    newContext._static = context._static;
+  }
+  return newContext
+}
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/**
+ * @fileOverview
+ * Everything about component event which includes event object, event listener,
+ * event emitter and lifecycle hooks.
+ */
+
+/**
+ * Event object definition. An event object has `type`, `timestamp` and
+ * `detail` from which a component emit. The event object could be dispatched to
+ * parents or broadcasted to children except `this.stop()` is called.
+ * @param {string} type
+ * @param {any}    detail
+ */
+function Evt (type, detail) {
+  if (detail instanceof Evt) {
+    return detail
+  }
+
+  this.timestamp = Date.now();
+  this.detail = detail;
+  this.type = type;
+
+  var shouldStop = false;
+
+  /**
+   * stop dispatch and broadcast
+   */
+  this.stop = function () {
+    shouldStop = true;
+  };
+
+  /**
+   * check if it can't be dispatched or broadcasted
+   */
+  this.hasStopped = function () {
+    return shouldStop
+  };
+}
+
+/**
+ * Emit an event but not broadcast down or dispatch up.
+ * @param  {string} type
+ * @param  {any}    detail
+ */
+function $emit (type, detail) {
+  var this$1 = this;
+
+  var events = this._vmEvents;
+  var handlerList = events[type];
+  if (handlerList) {
+    var evt = new Evt(type, detail);
+    handlerList.forEach(function (handler) {
+      handler.call(this$1, evt);
+    });
+  }
+}
+
+/**
+ * Emit an event and dispatch it up.
+ * @param  {string} type
+ * @param  {any}    detail
+ */
+function $dispatch (type, detail) {
+  var evt = new Evt(type, detail);
+  this.$emit(type, evt);
+
+  if (!evt.hasStopped() && this._parent && this._parent.$dispatch) {
+    this._parent.$dispatch(type, evt);
+  }
+}
+
+/**
+ * Emit an event and broadcast it down.
+ * @param  {string} type
+ * @param  {any}    detail
+ */
+function $broadcast (type, detail) {
+  var evt = new Evt(type, detail);
+  this.$emit(type, evt);
+
+  if (!evt.hasStopped() && this._childrenVms) {
+    this._childrenVms.forEach(function (subVm) {
+      subVm.$broadcast(type, evt);
+    });
+  }
+}
+
+/**
+ * Add event listener.
+ * @param  {string}   type
+ * @param  {function} handler
+ */
+function $on (type, handler) {
+  if (!type || typeof handler !== 'function') {
+    return
+  }
+  var events = this._vmEvents;
+  var handlerList = events[type] || [];
+  handlerList.push(handler);
+  events[type] = handlerList;
+
+  // fixed old version lifecycle design
+  /* istanbul ignore if */
+  if (type === 'hook:ready' && this._ready) {
+    this.$emit('hook:ready');
+  }
+}
+
+/**
+ * Remove event listener.
+ * @param  {string}   type
+ * @param  {function} handler
+ */
+function $off (type, handler) {
+  if (!type) {
+    return
+  }
+  var events = this._vmEvents;
+  if (!handler) {
+    delete events[type];
+    return
+  }
+  var handlerList = events[type];
+  if (!handlerList) {
+    return
+  }
+  handlerList.$remove(handler);
+}
+
+var LIFE_CYCLE_TYPES = ['init', 'created', 'ready', 'destroyed'];
+
+/**
+ * Init events:
+ * 1. listen `events` in component options & `externalEvents`.
+ * 2. bind lifecycle hooks.
+ * @param  {Vm}     vm
+ * @param  {object} externalEvents
+ */
+function initEvents (vm, externalEvents) {
+  var options = vm._options || {};
+  var events = options.events || {};
+  for (var type1 in events) {
+    vm.$on(type1, events[type1]);
+  }
+  for (var type2 in externalEvents) {
+    vm.$on(type2, externalEvents[type2]);
+  }
+  LIFE_CYCLE_TYPES.forEach(function (type) {
+    vm.$on(("hook:" + type), options[type]);
+  });
+}
+
+/**
+ * Bind event related methods to ViewModel instance.
+ * @param  {Vm} vm
+ */
+function mixinEvents (vm) {
+  vm.$emit = $emit;
+  vm.$dispatch = $dispatch;
+  vm.$broadcast = $broadcast;
+  vm.$on = $on;
+  vm.$off = $off;
+}
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/**
+ * @fileOverview
+ * ViewModel Constructor & definition
+ */
+
+/**
+ * ViewModel constructor
+ *
+ * @param {string} type
+ * @param {object} options    component options
+ * @param {object} parentVm   which contains _app
+ * @param {object} parentEl   root element or frag block
+ * @param {object} mergedData external data
+ * @param {object} externalEvents external events
+ */
+function Vm (
+  type,
+  options,
+  parentVm,
+  parentEl,
+  mergedData,
+  externalEvents
+) {
+  parentVm = parentVm || {};
+  this._parent = parentVm._realParent ? parentVm._realParent : parentVm;
+  this._app = parentVm._app || {};
+  parentVm._childrenVms && parentVm._childrenVms.push(this);
+
+  if (!options && this._app.customComponentMap) {
+    options = this._app.customComponentMap[type];
+  }
+  options = options || {};
+
+  var data = options.data || {};
+
+  this._options = options;
+  this._methods = options.methods || {};
+  this._computed = options.computed || {};
+  this._css = options.style || {};
+  this._ids = {};
+  this._vmEvents = {};
+  this._childrenVms = [];
+  this._type = type;
+
+  // bind events and lifecycles
+  initEvents(this, externalEvents);
+
+  console.debug(("[JS Framework] \"init\" lifecycle in Vm(" + (this._type) + ")"));
+  this.$emit('hook:init');
+  this._inited = true;
+
+  // proxy data and methods
+  // observe data and add this to vms
+  this._data = typeof data === 'function' ? data() : data;
+  if (mergedData) {
+    extend(this._data, mergedData);
+  }
+  initState(this);
+
+  console.debug(("[JS Framework] \"created\" lifecycle in Vm(" + (this._type) + ")"));
+  this.$emit('hook:created');
+  this._created = true;
+
+  // backward old ready entry
+  if (options.methods && options.methods.ready) {
+    console.warn('"exports.methods.ready" is deprecated, ' +
+      'please use "exports.created" instead');
+    options.methods.ready.call(this);
+  }
+
+  if (!this._app.doc) {
+    return
+  }
+
+  // if no parentElement then specify the documentElement
+  this._parentEl = parentEl || this._app.doc.documentElement;
+  build(this);
+}
+
+mixinEvents(Vm.prototype);
+
+/**
+ * Watch an function and bind all the data appeared in it. When the related
+ * data changes, the callback will be called with new value as 1st param.
+ *
+ * @param {Function} fn
+ * @param {Function} callback
+ */
+Vm.prototype.$watch = function (fn, callback) {
+  watch(this, fn, callback);
+};
+
+Vm.set = set;
+Vm.delete = del;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+var nativeModules = {};
+
+// for testing
+
+/**
+ * for testing
+ */
+
+
+/**
+ * for testing
+ */
+
+
+// for framework
+
+/**
+ * init modules for an app instance
+ * the second param determines whether to replace an existed method
+ */
+function initModules (modules, ifReplace) {
+  var loop = function ( moduleName ) {
+    // init `modules[moduleName][]`
+    var methods = nativeModules[moduleName];
+    if (!methods) {
+      methods = {};
+      nativeModules[moduleName] = methods;
+    }
+
+    // push each non-existed new method
+    modules[moduleName].forEach(function (method) {
+      if (typeof method === 'string') {
+        method = {
+          name: method
+        };
+      }
+
+      if (!methods[method.name] || ifReplace) {
+        methods[method.name] = method;
+      }
+    });
+  };
+
+  for (var moduleName in modules) loop( moduleName );
+}
+
+/**
+ * init app methods
+ */
+function initMethods$1 (Vm, apis) {
+  var p = Vm.prototype;
+
+  for (var apiName in apis) {
+    if (!p.hasOwnProperty(apiName)) {
+      p[apiName] = apis[apiName];
+    }
+  }
+}
+
+/**
+ * get a module of methods for an app instance
+ */
+function requireModule (app, name) {
+  var methods = nativeModules[name];
+  var target = {};
+  var loop = function ( methodName ) {
+    Object.defineProperty(target, methodName, {
+      configurable: true,
+      enumerable: true,
+      get: function moduleGetter () {
+        return function () {
+          var args = [], len = arguments.length;
+          while ( len-- ) args[ len ] = arguments[ len ];
+
+          return app.callTasks({
+          module: name,
+          method: methodName,
+          args: args
+        });
+        }
+      },
+      set: function moduleSetter (value) {
+        if (typeof value === 'function') {
+          return app.callTasks({
+            module: name,
+            method: methodName,
+            args: [value]
+          })
+        }
+      }
+    });
+  };
+
+  for (var methodName in methods) loop( methodName );
+  return target
+}
+
+/**
+ * get a custom component options
+ */
+function requireCustomComponent (app, name) {
+  var customComponentMap = app.customComponentMap;
+  return customComponentMap[name]
+}
+
+/**
+ * register a custom component options
+ */
+function registerCustomComponent (app, name, def) {
+  var customComponentMap = app.customComponentMap;
+
+  if (customComponentMap[name]) {
+    console.error(("[JS Framework] define a component(" + name + ") that already exists"));
+    return
+  }
+
+  customComponentMap[name] = def;
+}
+
+function createCommonjsModule(fn, module) {
+	return module = { exports: {} }, fn(module, module.exports), module.exports;
+}
+
+var semver = createCommonjsModule(function (module, exports) {
+exports = module.exports = SemVer;
+
+// The debug function is excluded entirely from the minified version.
+/* nomin */ var debug;
+/* nomin */ if (typeof process === 'object' &&
+    /* nomin */ process.env &&
+    /* nomin */ false &&
+    /* nomin */ /\bsemver\b/i.test(false))
+  /* nomin */ { debug = function() {
+    /* nomin */ var args = Array.prototype.slice.call(arguments, 0);
+    /* nomin */ args.unshift('SEMVER');
+    /* nomin */ console.log.apply(console, args);
+    /* nomin */ }; }
+/* nomin */ else
+  /* nomin */ { debug = function() {}; }
+
+// Note: this is the semver.org version of the spec that it implements
+// Not necessarily the package version of this code.
+exports.SEMVER_SPEC_VERSION = '2.0.0';
+
+var MAX_LENGTH = 256;
+var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
+
+// The actual regexps go on exports.re
+var re = exports.re = [];
+var src = exports.src = [];
+var R = 0;
+
+// The following Regular Expressions can be used for tokenizing,
+// validating, and parsing SemVer version strings.
+
+// ## Numeric Identifier
+// A single `0`, or a non-zero digit followed by zero or more digits.
+
+var NUMERICIDENTIFIER = R++;
+src[NUMERICIDENTIFIER] = '0|[1-9]\\d*';
+var NUMERICIDENTIFIERLOOSE = R++;
+src[NUMERICIDENTIFIERLOOSE] = '[0-9]+';
+
+
+// ## Non-numeric Identifier
+// Zero or more digits, followed by a letter or hyphen, and then zero or
+// more letters, digits, or hyphens.
+
+var NONNUMERICIDENTIFIER = R++;
+src[NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-][a-zA-Z0-9-]*';
+
+
+// ## Main Version
+// Three dot-separated numeric identifiers.
+
+var MAINVERSION = R++;
+src[MAINVERSION] = '(' + src[NUMERICIDENTIFIER] + ')\\.' +
+                   '(' + src[NUMERICIDENTIFIER] + ')\\.' +
+                   '(' + src[NUMERICIDENTIFIER] + ')';
+
+var MAINVERSIONLOOSE = R++;
+src[MAINVERSIONLOOSE] = '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' +
+                        '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' +
+                        '(' + src[NUMERICIDENTIFIERLOOSE] + ')';
+
+// ## Pre-release Version Identifier
+// A numeric identifier, or a non-numeric identifier.
+
+var PRERELEASEIDENTIFIER = R++;
+src[PRERELEASEIDENTIFIER] = '(?:' + src[NUMERICIDENTIFIER] +
+                            '|' + src[NONNUMERICIDENTIFIER] + ')';
+
+var PRERELEASEIDENTIFIERLOOSE = R++;
+src[PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[NUMERICIDENTIFIERLOOSE] +
+                                 '|' + src[NONNUMERICIDENTIFIER] + ')';
+
+
+// ## Pre-release Version
+// Hyphen, followed by one or more dot-separated pre-release version
+// identifiers.
+
+var PRERELEASE = R++;
+src[PRERELEASE] = '(?:-(' + src[PRERELEASEIDENTIFIER] +
+                  '(?:\\.' + src[PRERELEASEIDENTIFIER] + ')*))';
+
+var PRERELEASELOOSE = R++;
+src[PRERELEASELOOSE] = '(?:-?(' + src[PRERELEASEIDENTIFIERLOOSE] +
+                       '(?:\\.' + src[PRERELEASEIDENTIFIERLOOSE] + ')*))';
+
+// ## Build Metadata Identifier
+// Any combination of digits, letters, or hyphens.
+
+var BUILDIDENTIFIER = R++;
+src[BUILDIDENTIFIER] = '[0-9A-Za-z-]+';
+
+// ## Build Metadata
+// Plus sign, followed by one or more period-separated build metadata
+// identifiers.
+
+var BUILD = R++;
+src[BUILD] = '(?:\\+(' + src[BUILDIDENTIFIER] +
+             '(?:\\.' + src[BUILDIDENTIFIER] + ')*))';
+
+
+// ## Full Version String
+// A main version, followed optionally by a pre-release version and
+// build metadata.
+
+// Note that the only major, minor, patch, and pre-release sections of
+// the version string are capturing groups.  The build metadata is not a
+// capturing group, because it should not ever be used in version
+// comparison.
+
+var FULL = R++;
+var FULLPLAIN = 'v?' + src[MAINVERSION] +
+                src[PRERELEASE] + '?' +
+                src[BUILD] + '?';
+
+src[FULL] = '^' + FULLPLAIN + '$';
+
+// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
+// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
+// common in the npm registry.
+var LOOSEPLAIN = '[v=\\s]*' + src[MAINVERSIONLOOSE] +
+                 src[PRERELEASELOOSE] + '?' +
+                 src[BUILD] + '?';
+
+var LOOSE = R++;
+src[LOOSE] = '^' + LOOSEPLAIN + '$';
+
+var GTLT = R++;
+src[GTLT] = '((?:<|>)?=?)';
+
+// Something like "2.*" or "1.2.x".
+// Note that "x.x" is a valid xRange identifer, meaning "any version"
+// Only the first item is strictly required.
+var XRANGEIDENTIFIERLOOSE = R++;
+src[XRANGEIDENTIFIERLOOSE] = src[NUMERICIDENTIFIERLOOSE] + '|x|X|\\*';
+var XRANGEIDENTIFIER = R++;
+src[XRANGEIDENTIFIER] = src[NUMERICIDENTIFIER] + '|x|X|\\*';
+
+var XRANGEPLAIN = R++;
+src[XRANGEPLAIN] = '[v=\\s]*(' + src[XRANGEIDENTIFIER] + ')' +
+                   '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' +
+                   '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' +
+                   '(?:' + src[PRERELEASE] + ')?' +
+                   src[BUILD] + '?' +
+                   ')?)?';
+
+var XRANGEPLAINLOOSE = R++;
+src[XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
+                        '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
+                        '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
+                        '(?:' + src[PRERELEASELOOSE] + ')?' +
+                        src[BUILD] + '?' +
+                        ')?)?';
+
+var XRANGE = R++;
+src[XRANGE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAIN] + '$';
+var XRANGELOOSE = R++;
+src[XRANGELOOSE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAINLOOSE] + '$';
+
+// Tilde ranges.
+// Meaning is "reasonably at or greater than"
+var LONETILDE = R++;
+src[LONETILDE] = '(?:~>?)';
+
+var TILDETRIM = R++;
+src[TILDETRIM] = '(\\s*)' + src[LONETILDE] + '\\s+';
+re[TILDETRIM] = new RegExp(src[TILDETRIM], 'g');
+var tildeTrimReplace = '$1~';
+
+var TILDE = R++;
+src[TILDE] = '^' + src[LONETILDE] + src[XRANGEPLAIN] + '$';
+var TILDELOOSE = R++;
+src[TILDELOOSE] = '^' + src[LONETILDE] + src[XRANGEPLAINLOOSE] + '$';
+
+// Caret ranges.
+// Meaning is "at least and backwards compatible with"
+var LONECARET = R++;
+src[LONECARET] = '(?:\\^)';
+
+var CARETTRIM = R++;
+src[CARETTRIM] = '(\\s*)' + src[LONECARET] + '\\s+';
+re[CARETTRIM] = new RegExp(src[CARETTRIM], 'g');
+var caretTrimReplace = '$1^';
+
+var CARET = R++;
+src[CARET] = '^' + src[LONECARET] + src[XRANGEPLAIN] + '$';
+var CARETLOOSE = R++;
+src[CARETLOOSE] = '^' + src[LONECARET] + src[XRANGEPLAINLOOSE] + '$';
+
+// A simple gt/lt/eq thing, or just "" to indicate "any version"
+var COMPARATORLOOSE = R++;
+src[COMPARATORLOOSE] = '^' + src[GTLT] + '\\s*(' + LOOSEPLAIN + ')$|^$';
+var COMPARATOR = R++;
+src[COMPARATOR] = '^' + src[GTLT] + '\\s*(' + FULLPLAIN + ')$|^$';
+
+
+// An expression to strip any whitespace between the gtlt and the thing
+// it modifies, so that `> 1.2.3` ==> `>1.2.3`
+var COMPARATORTRIM = R++;
+src[COMPARATORTRIM] = '(\\s*)' + src[GTLT] +
+                      '\\s*(' + LOOSEPLAIN + '|' + src[XRANGEPLAIN] + ')';
+
+// this one has to use the /g flag
+re[COMPARATORTRIM] = new RegExp(src[COMPARATORTRIM], 'g');
+var comparatorTrimReplace = '$1$2$3';
+
+
+// Something like `1.2.3 - 1.2.4`
+// Note that these all use the loose form, because they'll be
+// checked against either the strict or loose comparator form
+// later.
+var HYPHENRANGE = R++;
+src[HYPHENRANGE] = '^\\s*(' + src[XRANGEPLAIN] + ')' +
+                   '\\s+-\\s+' +
+                   '(' + src[XRANGEPLAIN] + ')' +
+                   '\\s*$';
+
+var HYPHENRANGELOOSE = R++;
+src[HYPHENRANGELOOSE] = '^\\s*(' + src[XRANGEPLAINLOOSE] + ')' +
+                        '\\s+-\\s+' +
+                        '(' + src[XRANGEPLAINLOOSE] + ')' +
+                        '\\s*$';
+
+// Star ranges basically just allow anything at all.
+var STAR = R++;
+src[STAR] = '(<|>)?=?\\s*\\*';
+
+// Compile to actual regexp objects.
+// All are flag-free, unless they were created above with a flag.
+for (var i = 0; i < R; i++) {
+  debug(i, src[i]);
+  if (!re[i])
+    { re[i] = new RegExp(src[i]); }
+}
+
+exports.parse = parse;
+function parse(version, loose) {
+  if (version instanceof SemVer)
+    { return version; }
+
+  if (typeof version !== 'string')
+    { return null; }
+
+  if (version.length > MAX_LENGTH)
+    { return null; }
+
+  var r = loose ? re[LOOSE] : re[FULL];
+  if (!r.test(version))
+    { return null; }
+
+  try {
+    return new SemVer(version, loose);
+  } catch (er) {
+    return null;
+  }
+}
+
+exports.valid = valid;
+function valid(version, loose) {
+  var v = parse(version, loose);
+  return v ? v.version : null;
+}
+
+
+exports.clean = clean;
+function clean(version, loose) {
+  var s = parse(version.trim().replace(/^[=v]+/, ''), loose);
+  return s ? s.version : null;
+}
+
+exports.SemVer = SemVer;
+
+function SemVer(version, loose) {
+  if (version instanceof SemVer) {
+    if (version.loose === loose)
+      { return version; }
+    else
+      { version = version.version; }
+  } else if (typeof version !== 'string') {
+    throw new TypeError('Invalid Version: ' + version);
+  }
+
+  if (version.length > MAX_LENGTH)
+    { throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters') }
+
+  if (!(this instanceof SemVer))
+    { return new SemVer(version, loose); }
+
+  debug('SemVer', version, loose);
+  this.loose = loose;
+  var m = version.trim().match(loose ? re[LOOSE] : re[FULL]);
+
+  if (!m)
+    { throw new TypeError('Invalid Version: ' + version); }
+
+  this.raw = version;
+
+  // these are actually numbers
+  this.major = +m[1];
+  this.minor = +m[2];
+  this.patch = +m[3];
+
+  if (this.major > MAX_SAFE_INTEGER || this.major < 0)
+    { throw new TypeError('Invalid major version') }
+
+  if (this.minor > MAX_SAFE_INTEGER || this.minor < 0)
+    { throw new TypeError('Invalid minor version') }
+
+  if (this.patch > MAX_SAFE_INTEGER || this.patch < 0)
+    { throw new TypeError('Invalid patch version') }
+
+  // numberify any prerelease numeric ids
+  if (!m[4])
+    { this.prerelease = []; }
+  else
+    { this.prerelease = m[4].split('.').map(function(id) {
+      if (/^[0-9]+$/.test(id)) {
+        var num = +id;
+        if (num >= 0 && num < MAX_SAFE_INTEGER)
+          { return num; }
+      }
+      return id;
+    }); }
+
+  this.build = m[5] ? m[5].split('.') : [];
+  this.format();
+}
+
+SemVer.prototype.format = function() {
+  this.version = this.major + '.' + this.minor + '.' + this.patch;
+  if (this.prerelease.length)
+    { this.version += '-' + this.prerelease.join('.'); }
+  return this.version;
+};
+
+SemVer.prototype.toString = function() {
+  return this.version;
+};
+
+SemVer.prototype.compare = function(other) {
+  debug('SemVer.compare', this.version, this.loose, other);
+  if (!(other instanceof SemVer))
+    { other = new SemVer(other, this.loose); }
+
+  return this.compareMain(other) || this.comparePre(other);
+};
+
+SemVer.prototype.compareMain = function(other) {
+  if (!(other instanceof SemVer))
+    { other = new SemVer(other, this.loose); }
+
+  return compareIdentifiers(this.major, other.major) ||
+         compareIdentifiers(this.minor, other.minor) ||
+         compareIdentifiers(this.patch, other.patch);
+};
+
+SemVer.prototype.comparePre = function(other) {
+  var this$1 = this;
+
+  if (!(other instanceof SemVer))
+    { other = new SemVer(other, this.loose); }
+
+  // NOT having a prerelease is > having one
+  if (this.prerelease.length && !other.prerelease.length)
+    { return -1; }
+  else if (!this.prerelease.length && other.prerelease.length)
+    { return 1; }
+  else if (!this.prerelease.length && !other.prerelease.length)
+    { return 0; }
+
+  var i = 0;
+  do {
+    var a = this$1.prerelease[i];
+    var b = other.prerelease[i];
+    debug('prerelease compare', i, a, b);
+    if (a === undefined && b === undefined)
+      { return 0; }
+    else if (b === undefined)
+      { return 1; }
+    else if (a === undefined)
+      { return -1; }
+    else if (a === b)
+      { continue; }
+    else
+      { return compareIdentifiers(a, b); }
+  } while (++i);
+};
+
+// preminor will bump the version up to the next minor release, and immediately
+// down to pre-release. premajor and prepatch work the same way.
+SemVer.prototype.inc = function(release, identifier) {
+  var this$1 = this;
+
+  switch (release) {
+    case 'premajor':
+      this.prerelease.length = 0;
+      this.patch = 0;
+      this.minor = 0;
+      this.major++;
+      this.inc('pre', identifier);
+      break;
+    case 'preminor':
+      this.prerelease.length = 0;
+      this.patch = 0;
+      this.minor++;
+      this.inc('pre', identifier);
+      break;
+    case 'prepatch':
+      // If this is already a prerelease, it will bump to the next version
+      // drop any prereleases that might already exist, since they are not
+      // relevant at this point.
+      this.prerelease.length = 0;
+      this.inc('patch', identifier);
+      this.inc('pre', identifier);
+      

<TRUNCATED>


Mime
View raw message