statixite 1.0.0

data/vendor/assets/bower_components/vue/src/filters/index.js

@@ -0,0 +1,146 @@
+var _ = require('../util')
+
+/**
+ * Stringify value.
+ *
+ * @param {Number} indent
+ */
+
+exports.json = {
+  read: function (value, indent) {
+    return typeof value === 'string'
+      ? value
+      : JSON.stringify(value, null, Number(indent) || 2)
+  },
+  write: function (value) {
+    try {
+      return JSON.parse(value)
+    } catch (e) {
+      return value
+    }
+  }
+}
+
+/**
+ * 'abc' => 'Abc'
+ */
+
+exports.capitalize = function (value) {
+  if (!value && value !== 0) return ''
+  value = value.toString()
+  return value.charAt(0).toUpperCase() + value.slice(1)
+}
+
+/**
+ * 'abc' => 'ABC'
+ */
+
+exports.uppercase = function (value) {
+  return (value || value === 0)
+    ? value.toString().toUpperCase()
+    : ''
+}
+
+/**
+ * 'AbC' => 'abc'
+ */
+
+exports.lowercase = function (value) {
+  return (value || value === 0)
+    ? value.toString().toLowerCase()
+    : ''
+}
+
+/**
+ * 12345 => $12,345.00
+ *
+ * @param {String} sign
+ */
+
+var digitsRE = /(\d{3})(?=\d)/g
+exports.currency = function (value, currency) {
+  value = parseFloat(value)
+  if (!isFinite(value) || (!value && value !== 0)) return ''
+  currency = currency != null ? currency : '$'
+  var stringified = Math.abs(value).toFixed(2)
+  var _int = stringified.slice(0, -3)
+  var i = _int.length % 3
+  var head = i > 0
+    ? (_int.slice(0, i) + (_int.length > 3 ? ',' : ''))
+    : ''
+  var _float = stringified.slice(-3)
+  var sign = value < 0 ? '-' : ''
+  return currency + sign + head +
+    _int.slice(i).replace(digitsRE, '$1,') +
+    _float
+}
+
+/**
+ * 'item' => 'items'
+ *
+ * @params
+ *  an array of strings corresponding to
+ *  the single, double, triple ... forms of the word to
+ *  be pluralized. When the number to be pluralized
+ *  exceeds the length of the args, it will use the last
+ *  entry in the array.
+ *
+ *  e.g. ['single', 'double', 'triple', 'multiple']
+ */
+
+exports.pluralize = function (value) {
+  var args = _.toArray(arguments, 1)
+  return args.length > 1
+    ? (args[value % 10 - 1] || args[args.length - 1])
+    : (args[0] + (value === 1 ? '' : 's'))
+}
+
+/**
+ * A special filter that takes a handler function,
+ * wraps it so it only gets triggered on specific
+ * keypresses. v-on only.
+ *
+ * @param {String} key
+ */
+
+var keyCodes = {
+  esc: 27,
+  tab: 9,
+  enter: 13,
+  space: 32,
+  'delete': 46,
+  up: 38,
+  left: 37,
+  right: 39,
+  down: 40
+}
+
+exports.key = function (handler, key) {
+  if (!handler) return
+  var code = keyCodes[key]
+  if (!code) {
+    code = parseInt(key, 10)
+  }
+  return function (e) {
+    if (e.keyCode === code) {
+      return handler.call(this, e)
+    }
+  }
+}
+
+// expose keycode hash
+exports.key.keyCodes = keyCodes
+
+exports.debounce = function (handler, delay) {
+  if (!handler) return
+  if (!delay) {
+    delay = 300
+  }
+  return _.debounce(handler, delay)
+}
+
+/**
+ * Install special array filters
+ */
+
+_.extend(exports, require('./array-filters'))

data/vendor/assets/bower_components/vue/src/instance/compile.js

@@ -0,0 +1,200 @@
+var _ = require('../util')
+var Directive = require('../directive')
+var compiler = require('../compiler')
+
+/**
+ * Transclude, compile and link element.
+ *
+ * If a pre-compiled linker is available, that means the
+ * passed in element will be pre-transcluded and compiled
+ * as well - all we need to do is to call the linker.
+ *
+ * Otherwise we need to call transclude/compile/link here.
+ *
+ * @param {Element} el
+ * @return {Element}
+ */
+
+exports._compile = function (el) {
+  var options = this.$options
+  var host = this._host
+  if (options._linkFn) {
+    // pre-transcluded with linker, just use it
+    this._initElement(el)
+    this._unlinkFn = options._linkFn(this, el, host)
+  } else {
+    // transclude and init element
+    // transclude can potentially replace original
+    // so we need to keep reference; this step also injects
+    // the template and caches the original attributes
+    // on the container node and replacer node.
+    var original = el
+    el = compiler.transclude(el, options)
+    this._initElement(el)
+
+    // root is always compiled per-instance, because
+    // container attrs and props can be different every time.
+    var rootLinker = compiler.compileRoot(el, options)
+
+    // compile and link the rest
+    var contentLinkFn
+    var ctor = this.constructor
+    // component compilation can be cached
+    // as long as it's not using inline-template
+    if (options._linkerCachable) {
+      contentLinkFn = ctor.linker
+      if (!contentLinkFn) {
+        contentLinkFn = ctor.linker = compiler.compile(el, options)
+      }
+    }
+
+    // link phase
+    var rootUnlinkFn = rootLinker(this, el)
+    var contentUnlinkFn = contentLinkFn
+      ? contentLinkFn(this, el)
+      : compiler.compile(el, options)(this, el, host)
+
+    // register composite unlink function
+    // to be called during instance destruction
+    this._unlinkFn = function () {
+      rootUnlinkFn()
+      // passing destroying: true to avoid searching and
+      // splicing the directives
+      contentUnlinkFn(true)
+    }
+
+    // finally replace original
+    if (options.replace) {
+      _.replace(original, el)
+    }
+  }
+  return el
+}
+
+/**
+ * Initialize instance element. Called in the public
+ * $mount() method.
+ *
+ * @param {Element} el
+ */
+
+exports._initElement = function (el) {
+  if (el instanceof DocumentFragment) {
+    this._isFragment = true
+    this.$el = this._fragmentStart = el.firstChild
+    this._fragmentEnd = el.lastChild
+    // set persisted text anchors to empty
+    if (this._fragmentStart.nodeType === 3) {
+      this._fragmentStart.data = this._fragmentEnd.data = ''
+    }
+    this._blockFragment = el
+  } else {
+    this.$el = el
+  }
+  this.$el.__vue__ = this
+  this._callHook('beforeCompile')
+}
+
+/**
+ * Create and bind a directive to an element.
+ *
+ * @param {String} name - directive name
+ * @param {Node} node   - target node
+ * @param {Object} desc - parsed directive descriptor
+ * @param {Object} def  - directive definition object
+ * @param {Vue|undefined} host - transclusion host component
+ */
+
+exports._bindDir = function (name, node, desc, def, host) {
+  this._directives.push(
+    new Directive(name, node, this, desc, def, host)
+  )
+}
+
+/**
+ * Teardown an instance, unobserves the data, unbind all the
+ * directives, turn off all the event listeners, etc.
+ *
+ * @param {Boolean} remove - whether to remove the DOM node.
+ * @param {Boolean} deferCleanup - if true, defer cleanup to
+ *                                 be called later
+ */
+
+exports._destroy = function (remove, deferCleanup) {
+  if (this._isBeingDestroyed) {
+    return
+  }
+  this._callHook('beforeDestroy')
+  this._isBeingDestroyed = true
+  var i
+  // remove self from parent. only necessary
+  // if parent is not being destroyed as well.
+  var parent = this.$parent
+  if (parent && !parent._isBeingDestroyed) {
+    parent.$children.$remove(this)
+  }
+  // destroy all children.
+  i = this.$children.length
+  while (i--) {
+    this.$children[i].$destroy()
+  }
+  // teardown props
+  if (this._propsUnlinkFn) {
+    this._propsUnlinkFn()
+  }
+  // teardown all directives. this also tearsdown all
+  // directive-owned watchers.
+  if (this._unlinkFn) {
+    this._unlinkFn()
+  }
+  i = this._watchers.length
+  while (i--) {
+    this._watchers[i].teardown()
+  }
+  // remove reference to self on $el
+  if (this.$el) {
+    this.$el.__vue__ = null
+  }
+  // remove DOM element
+  var self = this
+  if (remove && this.$el) {
+    this.$remove(function () {
+      self._cleanup()
+    })
+  } else if (!deferCleanup) {
+    this._cleanup()
+  }
+}
+
+/**
+ * Clean up to ensure garbage collection.
+ * This is called after the leave transition if there
+ * is any.
+ */
+
+exports._cleanup = function () {
+  // remove reference from data ob
+  // frozen object may not have observer.
+  if (this._data.__ob__) {
+    this._data.__ob__.removeVm(this)
+  }
+  // Clean up references to private properties and other
+  // instances. preserve reference to _data so that proxy
+  // accessors still work. The only potential side effect
+  // here is that mutating the instance after it's destroyed
+  // may affect the state of other components that are still
+  // observing the same object, but that seems to be a
+  // reasonable responsibility for the user rather than
+  // always throwing an error on them.
+  this.$el =
+  this.$parent =
+  this.$root =
+  this.$children =
+  this._watchers =
+  this._directives = null
+  // call the last hook...
+  this._isDestroyed = true
+  this._callHook('destroyed')
+  // turn off all instance listeners.
+  this.$off()
+}

data/vendor/assets/bower_components/vue/src/instance/events.js

@@ -0,0 +1,139 @@
+var _ = require('../util')
+var inDoc = _.inDoc
+
+/**
+ * Setup the instance's option events & watchers.
+ * If the value is a string, we pull it from the
+ * instance's methods by name.
+ */
+
+exports._initEvents = function () {
+  var options = this.$options
+  registerCallbacks(this, '$on', options.events)
+  registerCallbacks(this, '$watch', options.watch)
+}
+
+/**
+ * Register callbacks for option events and watchers.
+ *
+ * @param {Vue} vm
+ * @param {String} action
+ * @param {Object} hash
+ */
+
+function registerCallbacks (vm, action, hash) {
+  if (!hash) return
+  var handlers, key, i, j
+  for (key in hash) {
+    handlers = hash[key]
+    if (_.isArray(handlers)) {
+      for (i = 0, j = handlers.length; i < j; i++) {
+        register(vm, action, key, handlers[i])
+      }
+    } else {
+      register(vm, action, key, handlers)
+    }
+  }
+}
+
+/**
+ * Helper to register an event/watch callback.
+ *
+ * @param {Vue} vm
+ * @param {String} action
+ * @param {String} key
+ * @param {Function|String|Object} handler
+ * @param {Object} [options]
+ */
+
+function register (vm, action, key, handler, options) {
+  var type = typeof handler
+  if (type === 'function') {
+    vm[action](key, handler, options)
+  } else if (type === 'string') {
+    var methods = vm.$options.methods
+    var method = methods && methods[handler]
+    if (method) {
+      vm[action](key, method, options)
+    } else {
+      process.env.NODE_ENV !== 'production' && _.warn(
+        'Unknown method: "' + handler + '" when ' +
+        'registering callback for ' + action +
+        ': "' + key + '".'
+      )
+    }
+  } else if (handler && type === 'object') {
+    register(vm, action, key, handler.handler, handler)
+  }
+}
+
+/**
+ * Setup recursive attached/detached calls
+ */
+
+exports._initDOMHooks = function () {
+  this.$on('hook:attached', onAttached)
+  this.$on('hook:detached', onDetached)
+}
+
+/**
+ * Callback to recursively call attached hook on children
+ */
+
+function onAttached () {
+  if (!this._isAttached) {
+    this._isAttached = true
+    this.$children.forEach(callAttach)
+  }
+}
+
+/**
+ * Iterator to call attached hook
+ *
+ * @param {Vue} child
+ */
+
+function callAttach (child) {
+  if (!child._isAttached && inDoc(child.$el)) {
+    child._callHook('attached')
+  }
+}
+
+/**
+ * Callback to recursively call detached hook on children
+ */
+
+function onDetached () {
+  if (this._isAttached) {
+    this._isAttached = false
+    this.$children.forEach(callDetach)
+  }
+}
+
+/**
+ * Iterator to call detached hook
+ *
+ * @param {Vue} child
+ */
+
+function callDetach (child) {
+  if (child._isAttached && !inDoc(child.$el)) {
+    child._callHook('detached')
+  }
+}
+
+/**
+ * Trigger all handlers for a hook
+ *
+ * @param {String} hook
+ */
+
+exports._callHook = function (hook) {
+  var handlers = this.$options[hook]
+  if (handlers) {
+    for (var i = 0, j = handlers.length; i < j; i++) {
+      handlers[i].call(this)
+    }
+  }
+  this.$emit('hook:' + hook)
+}