statixite 1.0.0

data/vendor/assets/bower_components/vue/src/api/global.js

@@ -0,0 +1,129 @@
+var _ = require('../util')
+var config = require('../config')
+
+/**
+ * Expose useful internals
+ */
+
+exports.util = _
+exports.config = config
+exports.nextTick = _.nextTick
+exports.compiler = require('../compiler')
+
+exports.parsers = {
+  path: require('../parsers/path'),
+  text: require('../parsers/text'),
+  template: require('../parsers/template'),
+  directive: require('../parsers/directive'),
+  expression: require('../parsers/expression')
+}
+
+/**
+ * Each instance constructor, including Vue, has a unique
+ * cid. This enables us to create wrapped "child
+ * constructors" for prototypal inheritance and cache them.
+ */
+
+exports.cid = 0
+var cid = 1
+
+/**
+ * Class inheritance
+ *
+ * @param {Object} extendOptions
+ */
+
+exports.extend = function (extendOptions) {
+  extendOptions = extendOptions || {}
+  var Super = this
+  var Sub = createClass(
+    extendOptions.name ||
+    Super.options.name ||
+    'VueComponent'
+  )
+  Sub.prototype = Object.create(Super.prototype)
+  Sub.prototype.constructor = Sub
+  Sub.cid = cid++
+  Sub.options = _.mergeOptions(
+    Super.options,
+    extendOptions
+  )
+  Sub['super'] = Super
+  // allow further extension
+  Sub.extend = Super.extend
+  // create asset registers, so extended classes
+  // can have their private assets too.
+  config._assetTypes.forEach(function (type) {
+    Sub[type] = Super[type]
+  })
+  return Sub
+}
+
+/**
+ * A function that returns a sub-class constructor with the
+ * given name. This gives us much nicer output when
+ * logging instances in the console.
+ *
+ * @param {String} name
+ * @return {Function}
+ */
+
+function createClass (name) {
+  return new Function(
+    'return function ' + _.classify(name) +
+    ' (options) { this._init(options) }'
+  )()
+}
+
+/**
+ * Plugin system
+ *
+ * @param {Object} plugin
+ */
+
+exports.use = function (plugin) {
+  // additional parameters
+  var args = _.toArray(arguments, 1)
+  args.unshift(this)
+  if (typeof plugin.install === 'function') {
+    plugin.install.apply(plugin, args)
+  } else {
+    plugin.apply(null, args)
+  }
+  return this
+}
+
+/**
+ * Apply a global mixin by merging it into the default
+ * options.
+ */
+
+exports.mixin = function (mixin) {
+  var Vue = _.Vue
+  Vue.options = _.mergeOptions(Vue.options, mixin)
+}
+
+/**
+ * Create asset registration methods with the following
+ * signature:
+ *
+ * @param {String} id
+ * @param {*} definition
+ */
+
+config._assetTypes.forEach(function (type) {
+  exports[type] = function (id, definition) {
+    if (!definition) {
+      return this.options[type + 's'][id]
+    } else {
+      if (
+        type === 'component' &&
+        _.isPlainObject(definition)
+      ) {
+        definition.name = id
+        definition = _.Vue.extend(definition)
+      }
+      this.options[type + 's'][id] = definition
+    }
+  }
+})

data/vendor/assets/bower_components/vue/src/api/lifecycle.js

@@ -0,0 +1,68 @@
+var _ = require('../util')
+var compiler = require('../compiler')
+
+/**
+ * Set instance target element and kick off the compilation
+ * process. The passed in `el` can be a selector string, an
+ * existing Element, or a DocumentFragment (for block
+ * instances).
+ *
+ * @param {Element|DocumentFragment|string} el
+ * @public
+ */
+
+exports.$mount = function (el) {
+  if (this._isCompiled) {
+    process.env.NODE_ENV !== 'production' && _.warn(
+      '$mount() should be called only once.'
+    )
+    return
+  }
+  el = _.query(el)
+  if (!el) {
+    el = document.createElement('div')
+  }
+  this._compile(el)
+  this._isCompiled = true
+  this._callHook('compiled')
+  this._initDOMHooks()
+  if (_.inDoc(this.$el)) {
+    this._callHook('attached')
+    ready.call(this)
+  } else {
+    this.$once('hook:attached', ready)
+  }
+  return this
+}
+
+/**
+ * Mark an instance as ready.
+ */
+
+function ready () {
+  this._isAttached = true
+  this._isReady = true
+  this._callHook('ready')
+}
+
+/**
+ * Teardown the instance, simply delegate to the internal
+ * _destroy.
+ */
+
+exports.$destroy = function (remove, deferCleanup) {
+  this._destroy(remove, deferCleanup)
+}
+
+/**
+ * Partially compile a piece of DOM and return a
+ * decompile function.
+ *
+ * @param {Element|DocumentFragment} el
+ * @param {Vue} [host]
+ * @return {Function}
+ */
+
+exports.$compile = function (el, host) {
+  return compiler.compile(el, this.$options, true)(this, el, host)
+}

data/vendor/assets/bower_components/vue/src/batcher.js

@@ -0,0 +1,98 @@
+var _ = require('./util')
+var config = require('./config')
+
+// we have two separate queues: one for directive updates
+// and one for user watcher registered via $watch().
+// we want to guarantee directive updates to be called
+// before user watchers so that when user watchers are
+// triggered, the DOM would have already been in updated
+// state.
+var queue = []
+var userQueue = []
+var has = {}
+var circular = {}
+var waiting = false
+var internalQueueDepleted = false
+
+/**
+ * Reset the batcher's state.
+ */
+
+function resetBatcherState () {
+  queue = []
+  userQueue = []
+  has = {}
+  circular = {}
+  waiting = internalQueueDepleted = false
+}
+
+/**
+ * Flush both queues and run the watchers.
+ */
+
+function flushBatcherQueue () {
+  runBatcherQueue(queue)
+  internalQueueDepleted = true
+  runBatcherQueue(userQueue)
+  resetBatcherState()
+}
+
+/**
+ * Run the watchers in a single queue.
+ *
+ * @param {Array} queue
+ */
+
+function runBatcherQueue (queue) {
+  // do not cache length because more watchers might be pushed
+  // as we run existing watchers
+  for (var i = 0; i < queue.length; i++) {
+    var watcher = queue[i]
+    var id = watcher.id
+    has[id] = null
+    watcher.run()
+    // in dev build, check and stop circular updates.
+    if (process.env.NODE_ENV !== 'production' && has[id] != null) {
+      circular[id] = (circular[id] || 0) + 1
+      if (circular[id] > config._maxUpdateCount) {
+        queue.splice(has[id], 1)
+        _.warn(
+          'You may have an infinite update loop for watcher ' +
+          'with expression: ' + watcher.expression
+        )
+      }
+    }
+  }
+}
+
+/**
+ * Push a watcher into the watcher queue.
+ * Jobs with duplicate IDs will be skipped unless it's
+ * pushed when the queue is being flushed.
+ *
+ * @param {Watcher} watcher
+ *   properties:
+ *   - {Number} id
+ *   - {Function} run
+ */
+
+exports.push = function (watcher) {
+  var id = watcher.id
+  if (has[id] == null) {
+    // if an internal watcher is pushed, but the internal
+    // queue is already depleted, we run it immediately.
+    if (internalQueueDepleted && !watcher.user) {
+      watcher.run()
+      return
+    }
+    // push watcher into appropriate queue
+    var q = watcher.user ? userQueue : queue
+    has[id] = q.length
+    q.push(watcher)
+    // queue the flush
+    if (!waiting) {
+      waiting = true
+      _.nextTick(flushBatcherQueue)
+    }
+  }
+}

data/vendor/assets/bower_components/vue/src/cache.js

@@ -0,0 +1,112 @@
+/**
+ * A doubly linked list-based Least Recently Used (LRU)
+ * cache. Will keep most recently used items while
+ * discarding least recently used items when its limit is
+ * reached. This is a bare-bone version of
+ * Rasmus Andersson's js-lru:
+ *
+ *   https://github.com/rsms/js-lru
+ *
+ * @param {Number} limit
+ * @constructor
+ */
+
+function Cache (limit) {
+  this.size = 0
+  this.limit = limit
+  this.head = this.tail = undefined
+  this._keymap = Object.create(null)
+}
+
+var p = Cache.prototype
+
+/**
+ * Put <value> into the cache associated with <key>.
+ * Returns the entry which was removed to make room for
+ * the new entry. Otherwise undefined is returned.
+ * (i.e. if there was enough room already).
+ *
+ * @param {String} key
+ * @param {*} value
+ * @return {Entry|undefined}
+ */
+
+p.put = function (key, value) {
+  var entry = {
+    key: key,
+    value: value
+  }
+  this._keymap[key] = entry
+  if (this.tail) {
+    this.tail.newer = entry
+    entry.older = this.tail
+  } else {
+    this.head = entry
+  }
+  this.tail = entry
+  if (this.size === this.limit) {
+    return this.shift()
+  } else {
+    this.size++
+  }
+}
+
+/**
+ * Purge the least recently used (oldest) entry from the
+ * cache. Returns the removed entry or undefined if the
+ * cache was empty.
+ */
+
+p.shift = function () {
+  var entry = this.head
+  if (entry) {
+    this.head = this.head.newer
+    this.head.older = undefined
+    entry.newer = entry.older = undefined
+    this._keymap[entry.key] = undefined
+  }
+  return entry
+}
+
+/**
+ * Get and register recent use of <key>. Returns the value
+ * associated with <key> or undefined if not in cache.
+ *
+ * @param {String} key
+ * @param {Boolean} returnEntry
+ * @return {Entry|*}
+ */
+
+p.get = function (key, returnEntry) {
+  var entry = this._keymap[key]
+  if (entry === undefined) return
+  if (entry === this.tail) {
+    return returnEntry
+      ? entry
+      : entry.value
+  }
+  // HEAD--------------TAIL
+  //   <.older   .newer>
+  //  <--- add direction --
+  //   A  B  C  <D>  E
+  if (entry.newer) {
+    if (entry === this.head) {
+      this.head = entry.newer
+    }
+    entry.newer.older = entry.older // C <-- E.
+  }
+  if (entry.older) {
+    entry.older.newer = entry.newer // C. --> E
+  }
+  entry.newer = undefined // D --x
+  entry.older = this.tail // D. --> E
+  if (this.tail) {
+    this.tail.newer = entry // E. <-- D
+  }
+  this.tail = entry
+  return returnEntry
+    ? entry
+    : entry.value
+}
+
+module.exports = Cache

data/vendor/assets/bower_components/vue/src/compiler/compile-props.js

@@ -0,0 +1,183 @@
+var _ = require('../util')
+var textParser = require('../parsers/text')
+var propDef = require('../directives/prop')
+var propBindingModes = require('../config')._propBindingModes
+
+// regexes
+var identRE = require('../parsers/path').identRE
+var dataAttrRE = /^data-/
+var settablePathRE = /^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*|\[[^\[\]]+\])*$/
+var literalValueRE = /^(true|false)$|^\d.*/
+
+/**
+ * Compile param attributes on a root element and return
+ * a props link function.
+ *
+ * @param {Element|DocumentFragment} el
+ * @param {Array} propOptions
+ * @return {Function} propsLinkFn
+ */
+
+module.exports = function compileProps (el, propOptions) {
+  var props = []
+  var i = propOptions.length
+  var options, name, attr, value, path, prop, literal, single
+  while (i--) {
+    options = propOptions[i]
+    name = options.name
+    // props could contain dashes, which will be
+    // interpreted as minus calculations by the parser
+    // so we need to camelize the path here
+    path = _.camelize(name.replace(dataAttrRE, ''))
+    if (!identRE.test(path)) {
+      process.env.NODE_ENV !== 'production' && _.warn(
+        'Invalid prop key: "' + name + '". Prop keys ' +
+        'must be valid identifiers.'
+      )
+      continue
+    }
+    attr = _.hyphenate(name)
+    value = el.getAttribute(attr)
+    if (value === null) {
+      attr = 'data-' + attr
+      value = el.getAttribute(attr)
+    }
+    // create a prop descriptor
+    prop = {
+      name: name,
+      raw: value,
+      path: path,
+      options: options,
+      mode: propBindingModes.ONE_WAY
+    }
+    if (value !== null) {
+      // important so that this doesn't get compiled
+      // again as a normal attribute binding
+      el.removeAttribute(attr)
+      var tokens = textParser.parse(value)
+      if (tokens) {
+        prop.dynamic = true
+        prop.parentPath = textParser.tokensToExp(tokens)
+        // check prop binding type.
+        single = tokens.length === 1
+        literal = literalValueRE.test(prop.parentPath)
+        // one time: {{* prop}}
+        if (literal || (single && tokens[0].oneTime)) {
+          prop.mode = propBindingModes.ONE_TIME
+        } else if (
+          !literal &&
+          (single && tokens[0].twoWay)
+        ) {
+          if (settablePathRE.test(prop.parentPath)) {
+            prop.mode = propBindingModes.TWO_WAY
+          } else {
+            process.env.NODE_ENV !== 'production' && _.warn(
+              'Cannot bind two-way prop with non-settable ' +
+              'parent path: ' + prop.parentPath
+            )
+          }
+        }
+        if (
+          process.env.NODE_ENV !== 'production' &&
+          options.twoWay &&
+          prop.mode !== propBindingModes.TWO_WAY
+        ) {
+          _.warn(
+            'Prop "' + name + '" expects a two-way binding type.'
+          )
+        }
+      }
+    } else if (options && options.required) {
+      process.env.NODE_ENV !== 'production' && _.warn(
+        'Missing required prop: ' + name
+      )
+    }
+    props.push(prop)
+  }
+  return makePropsLinkFn(props)
+}
+
+/**
+ * Build a function that applies props to a vm.
+ *
+ * @param {Array} props
+ * @return {Function} propsLinkFn
+ */
+
+function makePropsLinkFn (props) {
+  return function propsLinkFn (vm, el) {
+    // store resolved props info
+    vm._props = {}
+    var i = props.length
+    var prop, path, options, value
+    while (i--) {
+      prop = props[i]
+      path = prop.path
+      vm._props[path] = prop
+      options = prop.options
+      if (prop.raw === null) {
+        // initialize absent prop
+        _.initProp(vm, prop, getDefault(options))
+      } else if (prop.dynamic) {
+        // dynamic prop
+        if (vm._context) {
+          if (prop.mode === propBindingModes.ONE_TIME) {
+            // one time binding
+            value = vm._context.$get(prop.parentPath)
+            _.initProp(vm, prop, value)
+          } else {
+            // dynamic binding
+            vm._bindDir('prop', el, prop, propDef)
+          }
+        } else {
+          process.env.NODE_ENV !== 'production' && _.warn(
+            'Cannot bind dynamic prop on a root instance' +
+            ' with no parent: ' + prop.name + '="' +
+            prop.raw + '"'
+          )
+        }
+      } else {
+        // literal, cast it and just set once
+        var raw = prop.raw
+        value = options.type === Boolean && raw === ''
+          ? true
+          // do not cast emptry string.
+          // _.toNumber casts empty string to 0.
+          : raw.trim()
+            ? _.toBoolean(_.toNumber(raw))
+            : raw
+        _.initProp(vm, prop, value)
+      }
+    }
+  }
+}
+
+/**
+ * Get the default value of a prop.
+ *
+ * @param {Object} options
+ * @return {*}
+ */
+
+function getDefault (options) {
+  // no default, return undefined
+  if (!options.hasOwnProperty('default')) {
+    // absent boolean value defaults to false
+    return options.type === Boolean
+      ? false
+      : undefined
+  }
+  var def = options.default
+  // warn against non-factory defaults for Object & Array
+  if (_.isObject(def)) {
+    process.env.NODE_ENV !== 'production' && _.warn(
+      'Object/Array as default prop values will be shared ' +
+      'across multiple instances. Use a factory function ' +
+      'to return the default value instead.'
+    )
+  }
+  // call factory function for non-Function types
+  return typeof def === 'function' && options.type !== Function
+    ? def()
+    : def
+}