statixite 1.0.0

data/vendor/assets/bower_components/vue/src/parsers/template.js

@@ -0,0 +1,288 @@
+var _ = require('../util')
+var Cache = require('../cache')
+var templateCache = new Cache(1000)
+var idSelectorCache = new Cache(1000)
+
+var map = {
+  _default: [0, '', ''],
+  legend: [1, '<fieldset>', '</fieldset>'],
+  tr: [2, '<table><tbody>', '</tbody></table>'],
+  col: [
+    2,
+    '<table><tbody></tbody><colgroup>',
+    '</colgroup></table>'
+  ]
+}
+
+map.td =
+map.th = [
+  3,
+  '<table><tbody><tr>',
+  '</tr></tbody></table>'
+]
+
+map.option =
+map.optgroup = [
+  1,
+  '<select multiple="multiple">',
+  '</select>'
+]
+
+map.thead =
+map.tbody =
+map.colgroup =
+map.caption =
+map.tfoot = [1, '<table>', '</table>']
+
+map.g =
+map.defs =
+map.symbol =
+map.use =
+map.image =
+map.text =
+map.circle =
+map.ellipse =
+map.line =
+map.path =
+map.polygon =
+map.polyline =
+map.rect = [
+  1,
+  '<svg ' +
+    'xmlns="http://www.w3.org/2000/svg" ' +
+    'xmlns:xlink="http://www.w3.org/1999/xlink" ' +
+    'xmlns:ev="http://www.w3.org/2001/xml-events"' +
+    'version="1.1">',
+  '</svg>'
+]
+
+/**
+ * Check if a node is a supported template node with a
+ * DocumentFragment content.
+ *
+ * @param {Node} node
+ * @return {Boolean}
+ */
+
+function isRealTemplate (node) {
+  return _.isTemplate(node) &&
+    node.content instanceof DocumentFragment
+}
+
+var tagRE = /<([\w:]+)/
+var entityRE = /&\w+;|&#\d+;|&#x[\dA-F]+;/
+
+/**
+ * Convert a string template to a DocumentFragment.
+ * Determines correct wrapping by tag types. Wrapping
+ * strategy found in jQuery & component/domify.
+ *
+ * @param {String} templateString
+ * @return {DocumentFragment}
+ */
+
+function stringToFragment (templateString) {
+  // try a cache hit first
+  var hit = templateCache.get(templateString)
+  if (hit) {
+    return hit
+  }
+
+  var frag = document.createDocumentFragment()
+  var tagMatch = templateString.match(tagRE)
+  var entityMatch = entityRE.test(templateString)
+
+  if (!tagMatch && !entityMatch) {
+    // text only, return a single text node.
+    frag.appendChild(
+      document.createTextNode(templateString)
+    )
+  } else {
+
+    var tag = tagMatch && tagMatch[1]
+    var wrap = map[tag] || map._default
+    var depth = wrap[0]
+    var prefix = wrap[1]
+    var suffix = wrap[2]
+    var node = document.createElement('div')
+
+    node.innerHTML = prefix + templateString.trim() + suffix
+    while (depth--) {
+      node = node.lastChild
+    }
+
+    var child
+    /* eslint-disable no-cond-assign */
+    while (child = node.firstChild) {
+    /* eslint-enable no-cond-assign */
+      frag.appendChild(child)
+    }
+  }
+
+  templateCache.put(templateString, frag)
+  return frag
+}
+
+/**
+ * Convert a template node to a DocumentFragment.
+ *
+ * @param {Node} node
+ * @return {DocumentFragment}
+ */
+
+function nodeToFragment (node) {
+  // if its a template tag and the browser supports it,
+  // its content is already a document fragment.
+  if (isRealTemplate(node)) {
+    _.trimNode(node.content)
+    return node.content
+  }
+  // script template
+  if (node.tagName === 'SCRIPT') {
+    return stringToFragment(node.textContent)
+  }
+  // normal node, clone it to avoid mutating the original
+  var clone = exports.clone(node)
+  var frag = document.createDocumentFragment()
+  var child
+  /* eslint-disable no-cond-assign */
+  while (child = clone.firstChild) {
+  /* eslint-enable no-cond-assign */
+    frag.appendChild(child)
+  }
+  _.trimNode(frag)
+  return frag
+}
+
+// Test for the presence of the Safari template cloning bug
+// https://bugs.webkit.org/show_bug.cgi?id=137755
+var hasBrokenTemplate = (function () {
+  /* istanbul ignore else */
+  if (_.inBrowser) {
+    var a = document.createElement('div')
+    a.innerHTML = '<template>1</template>'
+    return !a.cloneNode(true).firstChild.innerHTML
+  } else {
+    return false
+  }
+})()
+
+// Test for IE10/11 textarea placeholder clone bug
+var hasTextareaCloneBug = (function () {
+  /* istanbul ignore else */
+  if (_.inBrowser) {
+    var t = document.createElement('textarea')
+    t.placeholder = 't'
+    return t.cloneNode(true).value === 't'
+  } else {
+    return false
+  }
+})()
+
+/**
+ * 1. Deal with Safari cloning nested <template> bug by
+ *    manually cloning all template instances.
+ * 2. Deal with IE10/11 textarea placeholder bug by setting
+ *    the correct value after cloning.
+ *
+ * @param {Element|DocumentFragment} node
+ * @return {Element|DocumentFragment}
+ */
+
+exports.clone = function (node) {
+  if (!node.querySelectorAll) {
+    return node.cloneNode()
+  }
+  var res = node.cloneNode(true)
+  var i, original, cloned
+  /* istanbul ignore if */
+  if (hasBrokenTemplate) {
+    var clone = res
+    if (isRealTemplate(node)) {
+      node = node.content
+      clone = res.content
+    }
+    original = node.querySelectorAll('template')
+    if (original.length) {
+      cloned = clone.querySelectorAll('template')
+      i = cloned.length
+      while (i--) {
+        cloned[i].parentNode.replaceChild(
+          exports.clone(original[i]),
+          cloned[i]
+        )
+      }
+    }
+  }
+  /* istanbul ignore if */
+  if (hasTextareaCloneBug) {
+    if (node.tagName === 'TEXTAREA') {
+      res.value = node.value
+    } else {
+      original = node.querySelectorAll('textarea')
+      if (original.length) {
+        cloned = res.querySelectorAll('textarea')
+        i = cloned.length
+        while (i--) {
+          cloned[i].value = original[i].value
+        }
+      }
+    }
+  }
+  return res
+}
+
+/**
+ * Process the template option and normalizes it into a
+ * a DocumentFragment that can be used as a partial or a
+ * instance template.
+ *
+ * @param {*} template
+ *    Possible values include:
+ *    - DocumentFragment object
+ *    - Node object of type Template
+ *    - id selector: '#some-template-id'
+ *    - template string: '<div><span>{{msg}}</span></div>'
+ * @param {Boolean} clone
+ * @param {Boolean} noSelector
+ * @return {DocumentFragment|undefined}
+ */
+
+exports.parse = function (template, clone, noSelector) {
+  var node, frag
+
+  // if the template is already a document fragment,
+  // do nothing
+  if (template instanceof DocumentFragment) {
+    _.trimNode(template)
+    return clone
+      ? exports.clone(template)
+      : template
+  }
+
+  if (typeof template === 'string') {
+    // id selector
+    if (!noSelector && template.charAt(0) === '#') {
+      // id selector can be cached too
+      frag = idSelectorCache.get(template)
+      if (!frag) {
+        node = document.getElementById(template.slice(1))
+        if (node) {
+          frag = nodeToFragment(node)
+          // save selector to cache
+          idSelectorCache.put(template, frag)
+        }
+      }
+    } else {
+      // normal string template
+      frag = stringToFragment(template)
+    }
+  } else if (template.nodeType) {
+    // a direct node
+    frag = nodeToFragment(template)
+  }
+
+  return frag && clone
+    ? exports.clone(frag)
+    : frag
+}

data/vendor/assets/bower_components/vue/src/parsers/text.js

@@ -0,0 +1,178 @@
+var Cache = require('../cache')
+var config = require('../config')
+var dirParser = require('./directive')
+var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g
+var cache, tagRE, htmlRE, firstChar, lastChar
+
+/**
+ * Escape a string so it can be used in a RegExp
+ * constructor.
+ *
+ * @param {String} str
+ */
+
+function escapeRegex (str) {
+  return str.replace(regexEscapeRE, '\\$&')
+}
+
+/**
+ * Compile the interpolation tag regex.
+ *
+ * @return {RegExp}
+ */
+
+function compileRegex () {
+  config._delimitersChanged = false
+  var open = config.delimiters[0]
+  var close = config.delimiters[1]
+  firstChar = open.charAt(0)
+  lastChar = close.charAt(close.length - 1)
+  var firstCharRE = escapeRegex(firstChar)
+  var lastCharRE = escapeRegex(lastChar)
+  var openRE = escapeRegex(open)
+  var closeRE = escapeRegex(close)
+  tagRE = new RegExp(
+    firstCharRE + '?' + openRE +
+    '(.+?)' +
+    closeRE + lastCharRE + '?',
+    'g'
+  )
+  htmlRE = new RegExp(
+    '^' + firstCharRE + openRE +
+    '.*' +
+    closeRE + lastCharRE + '$'
+  )
+  // reset cache
+  cache = new Cache(1000)
+}
+
+/**
+ * Parse a template text string into an array of tokens.
+ *
+ * @param {String} text
+ * @return {Array<Object> | null}
+ *               - {String} type
+ *               - {String} value
+ *               - {Boolean} [html]
+ *               - {Boolean} [oneTime]
+ */
+
+exports.parse = function (text) {
+  if (config._delimitersChanged) {
+    compileRegex()
+  }
+  var hit = cache.get(text)
+  if (hit) {
+    return hit
+  }
+  text = text.replace(/\n/g, '')
+  if (!tagRE.test(text)) {
+    return null
+  }
+  var tokens = []
+  var lastIndex = tagRE.lastIndex = 0
+  var match, index, value, first, oneTime, twoWay
+  /* eslint-disable no-cond-assign */
+  while (match = tagRE.exec(text)) {
+  /* eslint-enable no-cond-assign */
+    index = match.index
+    // push text token
+    if (index > lastIndex) {
+      tokens.push({
+        value: text.slice(lastIndex, index)
+      })
+    }
+    // tag token
+    first = match[1].charCodeAt(0)
+    oneTime = first === 42 // *
+    twoWay = first === 64  // @
+    value = oneTime || twoWay
+      ? match[1].slice(1)
+      : match[1]
+    tokens.push({
+      tag: true,
+      value: value.trim(),
+      html: htmlRE.test(match[0]),
+      oneTime: oneTime,
+      twoWay: twoWay
+    })
+    lastIndex = index + match[0].length
+  }
+  if (lastIndex < text.length) {
+    tokens.push({
+      value: text.slice(lastIndex)
+    })
+  }
+  cache.put(text, tokens)
+  return tokens
+}
+
+/**
+ * Format a list of tokens into an expression.
+ * e.g. tokens parsed from 'a {{b}} c' can be serialized
+ * into one single expression as '"a " + b + " c"'.
+ *
+ * @param {Array} tokens
+ * @param {Vue} [vm]
+ * @return {String}
+ */
+
+exports.tokensToExp = function (tokens, vm) {
+  if (tokens.length > 1) {
+    return tokens.map(function (token) {
+      return formatToken(token, vm)
+    }).join('+')
+  } else {
+    return formatToken(tokens[0], vm, true)
+  }
+}
+
+/**
+ * Format a single token.
+ *
+ * @param {Object} token
+ * @param {Vue} [vm]
+ * @param {Boolean} single
+ * @return {String}
+ */
+
+function formatToken (token, vm, single) {
+  return token.tag
+    ? vm && token.oneTime
+      ? '"' + vm.$eval(token.value) + '"'
+      : inlineFilters(token.value, single)
+    : '"' + token.value + '"'
+}
+
+/**
+ * For an attribute with multiple interpolation tags,
+ * e.g. attr="some-{{thing | filter}}", in order to combine
+ * the whole thing into a single watchable expression, we
+ * have to inline those filters. This function does exactly
+ * that. This is a bit hacky but it avoids heavy changes
+ * to directive parser and watcher mechanism.
+ *
+ * @param {String} exp
+ * @param {Boolean} single
+ * @return {String}
+ */
+
+var filterRE = /[^|]\|[^|]/
+function inlineFilters (exp, single) {
+  if (!filterRE.test(exp)) {
+    return single
+      ? exp
+      : '(' + exp + ')'
+  } else {
+    var dir = dirParser.parse(exp)[0]
+    if (!dir.filters) {
+      return '(' + exp + ')'
+    } else {
+      return 'this._applyFilters(' +
+        dir.expression + // value
+        ',null,' +       // oldValue (null for read)
+        JSON.stringify(dir.filters) + // filter descriptors
+        ',false)'        // write?
+    }
+  }
+}