statixite 1.0.0

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

@@ -0,0 +1,180 @@
+var _ = require('../util')
+var Cache = require('../cache')
+var cache = new Cache(1000)
+var argRE = /^[^\{\?]+$|^'[^']*'$|^"[^"]*"$/
+var filterTokenRE = /[^\s'"]+|'[^']*'|"[^"]*"/g
+var reservedArgRE = /^in$|^-?\d+/
+
+/**
+ * Parser state
+ */
+
+var str
+var c, i, l
+var inSingle
+var inDouble
+var curly
+var square
+var paren
+var begin
+var argIndex
+var dirs
+var dir
+var lastFilterIndex
+var arg
+
+/**
+ * Push a directive object into the result Array
+ */
+
+function pushDir () {
+  dir.raw = str.slice(begin, i).trim()
+  if (dir.expression === undefined) {
+    dir.expression = str.slice(argIndex, i).trim()
+  } else if (lastFilterIndex !== begin) {
+    pushFilter()
+  }
+  if (i === 0 || dir.expression) {
+    dirs.push(dir)
+  }
+}
+
+/**
+ * Push a filter to the current directive object
+ */
+
+function pushFilter () {
+  var exp = str.slice(lastFilterIndex, i).trim()
+  var filter
+  if (exp) {
+    filter = {}
+    var tokens = exp.match(filterTokenRE)
+    filter.name = tokens[0]
+    if (tokens.length > 1) {
+      filter.args = tokens.slice(1).map(processFilterArg)
+    }
+  }
+  if (filter) {
+    (dir.filters = dir.filters || []).push(filter)
+  }
+  lastFilterIndex = i + 1
+}
+
+/**
+ * Check if an argument is dynamic and strip quotes.
+ *
+ * @param {String} arg
+ * @return {Object}
+ */
+
+function processFilterArg (arg) {
+  var stripped = reservedArgRE.test(arg)
+    ? arg
+    : _.stripQuotes(arg)
+  var dynamic = stripped === false
+  return {
+    value: dynamic ? arg : stripped,
+    dynamic: dynamic
+  }
+}
+
+/**
+ * Parse a directive string into an Array of AST-like
+ * objects representing directives.
+ *
+ * Example:
+ *
+ * "click: a = a + 1 | uppercase" will yield:
+ * {
+ *   arg: 'click',
+ *   expression: 'a = a + 1',
+ *   filters: [
+ *     { name: 'uppercase', args: null }
+ *   ]
+ * }
+ *
+ * @param {String} str
+ * @return {Array<Object>}
+ */
+
+exports.parse = function (s) {
+
+  var hit = cache.get(s)
+  if (hit) {
+    return hit
+  }
+
+  // reset parser state
+  str = s
+  inSingle = inDouble = false
+  curly = square = paren = begin = argIndex = 0
+  lastFilterIndex = 0
+  dirs = []
+  dir = {}
+  arg = null
+
+  for (i = 0, l = str.length; i < l; i++) {
+    c = str.charCodeAt(i)
+    if (inSingle) {
+      // check single quote
+      if (c === 0x27) inSingle = !inSingle
+    } else if (inDouble) {
+      // check double quote
+      if (c === 0x22) inDouble = !inDouble
+    } else if (
+      c === 0x2C && // comma
+      !paren && !curly && !square
+    ) {
+      // reached the end of a directive
+      pushDir()
+      // reset & skip the comma
+      dir = {}
+      begin = argIndex = lastFilterIndex = i + 1
+    } else if (
+      c === 0x3A && // colon
+      !dir.expression &&
+      !dir.arg
+    ) {
+      // argument
+      arg = str.slice(begin, i).trim()
+      // test for valid argument here
+      // since we may have caught stuff like first half of
+      // an object literal or a ternary expression.
+      if (argRE.test(arg)) {
+        argIndex = i + 1
+        dir.arg = _.stripQuotes(arg) || arg
+      }
+    } else if (
+      c === 0x7C && // pipe
+      str.charCodeAt(i + 1) !== 0x7C &&
+      str.charCodeAt(i - 1) !== 0x7C
+    ) {
+      if (dir.expression === undefined) {
+        // first filter, end of expression
+        lastFilterIndex = i + 1
+        dir.expression = str.slice(argIndex, i).trim()
+      } else {
+        // already has filter
+        pushFilter()
+      }
+    } else {
+      switch (c) {
+        case 0x22: inDouble = true; break // "
+        case 0x27: inSingle = true; break // '
+        case 0x28: paren++; break         // (
+        case 0x29: paren--; break         // )
+        case 0x5B: square++; break        // [
+        case 0x5D: square--; break        // ]
+        case 0x7B: curly++; break         // {
+        case 0x7D: curly--; break         // }
+      }
+    }
+  }
+
+  if (i === 0 || begin !== i) {
+    pushDir()
+  }
+
+  cache.put(s, dirs)
+  return dirs
+}

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

@@ -0,0 +1,264 @@
+var _ = require('../util')
+var Path = require('./path')
+var Cache = require('../cache')
+var expressionCache = new Cache(1000)
+
+var allowedKeywords =
+  'Math,Date,this,true,false,null,undefined,Infinity,NaN,' +
+  'isNaN,isFinite,decodeURI,decodeURIComponent,encodeURI,' +
+  'encodeURIComponent,parseInt,parseFloat'
+var allowedKeywordsRE =
+  new RegExp('^(' + allowedKeywords.replace(/,/g, '\\b|') + '\\b)')
+
+// keywords that don't make sense inside expressions
+var improperKeywords =
+  'break,case,class,catch,const,continue,debugger,default,' +
+  'delete,do,else,export,extends,finally,for,function,if,' +
+  'import,in,instanceof,let,return,super,switch,throw,try,' +
+  'var,while,with,yield,enum,await,implements,package,' +
+  'proctected,static,interface,private,public'
+var improperKeywordsRE =
+  new RegExp('^(' + improperKeywords.replace(/,/g, '\\b|') + '\\b)')
+
+var wsRE = /\s/g
+var newlineRE = /\n/g
+var saveRE = /[\{,]\s*[\w\$_]+\s*:|('[^']*'|"[^"]*")|new |typeof |void /g
+var restoreRE = /"(\d+)"/g
+var pathTestRE = /^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*|\['.*?'\]|\[".*?"\]|\[\d+\]|\[[A-Za-z_$][\w$]*\])*$/
+var pathReplaceRE = /[^\w$\.]([A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*|\['.*?'\]|\[".*?"\])*)/g
+var booleanLiteralRE = /^(true|false)$/
+
+/**
+ * Save / Rewrite / Restore
+ *
+ * When rewriting paths found in an expression, it is
+ * possible for the same letter sequences to be found in
+ * strings and Object literal property keys. Therefore we
+ * remove and store these parts in a temporary array, and
+ * restore them after the path rewrite.
+ */
+
+var saved = []
+
+/**
+ * Save replacer
+ *
+ * The save regex can match two possible cases:
+ * 1. An opening object literal
+ * 2. A string
+ * If matched as a plain string, we need to escape its
+ * newlines, since the string needs to be preserved when
+ * generating the function body.
+ *
+ * @param {String} str
+ * @param {String} isString - str if matched as a string
+ * @return {String} - placeholder with index
+ */
+
+function save (str, isString) {
+  var i = saved.length
+  saved[i] = isString
+    ? str.replace(newlineRE, '\\n')
+    : str
+  return '"' + i + '"'
+}
+
+/**
+ * Path rewrite replacer
+ *
+ * @param {String} raw
+ * @return {String}
+ */
+
+function rewrite (raw) {
+  var c = raw.charAt(0)
+  var path = raw.slice(1)
+  if (allowedKeywordsRE.test(path)) {
+    return raw
+  } else {
+    path = path.indexOf('"') > -1
+      ? path.replace(restoreRE, restore)
+      : path
+    return c + 'scope.' + path
+  }
+}
+
+/**
+ * Restore replacer
+ *
+ * @param {String} str
+ * @param {String} i - matched save index
+ * @return {String}
+ */
+
+function restore (str, i) {
+  return saved[i]
+}
+
+/**
+ * Rewrite an expression, prefixing all path accessors with
+ * `scope.` and generate getter/setter functions.
+ *
+ * @param {String} exp
+ * @param {Boolean} needSet
+ * @return {Function}
+ */
+
+function compileExpFns (exp, needSet) {
+  if (improperKeywordsRE.test(exp)) {
+    process.env.NODE_ENV !== 'production' && _.warn(
+      'Avoid using reserved keywords in expression: ' + exp
+    )
+  }
+  // reset state
+  saved.length = 0
+  // save strings and object literal keys
+  var body = exp
+    .replace(saveRE, save)
+    .replace(wsRE, '')
+  // rewrite all paths
+  // pad 1 space here becaue the regex matches 1 extra char
+  body = (' ' + body)
+    .replace(pathReplaceRE, rewrite)
+    .replace(restoreRE, restore)
+  var getter = makeGetter(body)
+  if (getter) {
+    return {
+      get: getter,
+      body: body,
+      set: needSet
+        ? makeSetter(body)
+        : null
+    }
+  }
+}
+
+/**
+ * Compile getter setters for a simple path.
+ *
+ * @param {String} exp
+ * @return {Function}
+ */
+
+function compilePathFns (exp) {
+  var getter, path
+  if (exp.indexOf('[') < 0) {
+    // really simple path
+    path = exp.split('.')
+    path.raw = exp
+    getter = Path.compileGetter(path)
+  } else {
+    // do the real parsing
+    path = Path.parse(exp)
+    getter = path.get
+  }
+  return {
+    get: getter,
+    // always generate setter for simple paths
+    set: function (obj, val) {
+      Path.set(obj, path, val)
+    }
+  }
+}
+
+/**
+ * Build a getter function. Requires eval.
+ *
+ * We isolate the try/catch so it doesn't affect the
+ * optimization of the parse function when it is not called.
+ *
+ * @param {String} body
+ * @return {Function|undefined}
+ */
+
+function makeGetter (body) {
+  try {
+    return new Function('scope', 'return ' + body + ';')
+  } catch (e) {
+    process.env.NODE_ENV !== 'production' && _.warn(
+      'Invalid expression. ' +
+      'Generated function body: ' + body
+    )
+  }
+}
+
+/**
+ * Build a setter function.
+ *
+ * This is only needed in rare situations like "a[b]" where
+ * a settable path requires dynamic evaluation.
+ *
+ * This setter function may throw error when called if the
+ * expression body is not a valid left-hand expression in
+ * assignment.
+ *
+ * @param {String} body
+ * @return {Function|undefined}
+ */
+
+function makeSetter (body) {
+  try {
+    return new Function('scope', 'value', body + '=value;')
+  } catch (e) {
+    process.env.NODE_ENV !== 'production' && _.warn(
+      'Invalid setter function body: ' + body
+    )
+  }
+}
+
+/**
+ * Check for setter existence on a cache hit.
+ *
+ * @param {Function} hit
+ */
+
+function checkSetter (hit) {
+  if (!hit.set) {
+    hit.set = makeSetter(hit.body)
+  }
+}
+
+/**
+ * Parse an expression into re-written getter/setters.
+ *
+ * @param {String} exp
+ * @param {Boolean} needSet
+ * @return {Function}
+ */
+
+exports.parse = function (exp, needSet) {
+  exp = exp.trim()
+  // try cache
+  var hit = expressionCache.get(exp)
+  if (hit) {
+    if (needSet) {
+      checkSetter(hit)
+    }
+    return hit
+  }
+  // we do a simple path check to optimize for them.
+  // the check fails valid paths with unusal whitespaces,
+  // but that's too rare and we don't care.
+  // also skip boolean literals and paths that start with
+  // global "Math"
+  var res = exports.isSimplePath(exp)
+    ? compilePathFns(exp)
+    : compileExpFns(exp, needSet)
+  expressionCache.put(exp, res)
+  return res
+}
+
+/**
+ * Check if an expression is a simple path.
+ *
+ * @param {String} exp
+ * @return {Boolean}
+ */
+
+exports.isSimplePath = function (exp) {
+  return pathTestRE.test(exp) &&
+    // don't treat true/false as paths
+    !booleanLiteralRE.test(exp) &&
+    // Math constants e.g. Math.PI, Math.E etc.
+    exp.slice(0, 5) !== 'Math.'
+}

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

@@ -0,0 +1,348 @@
+var _ = require('../util')
+var Cache = require('../cache')
+var pathCache = new Cache(1000)
+var identRE = exports.identRE = /^[$_a-zA-Z]+[\w$]*$/
+
+// actions
+var APPEND = 0
+var PUSH = 1
+
+// states
+var BEFORE_PATH = 0
+var IN_PATH = 1
+var BEFORE_IDENT = 2
+var IN_IDENT = 3
+var BEFORE_ELEMENT = 4
+var AFTER_ZERO = 5
+var IN_INDEX = 6
+var IN_SINGLE_QUOTE = 7
+var IN_DOUBLE_QUOTE = 8
+var IN_SUB_PATH = 9
+var AFTER_ELEMENT = 10
+var AFTER_PATH = 11
+var ERROR = 12
+
+var pathStateMachine = []
+
+pathStateMachine[BEFORE_PATH] = {
+  'ws': [BEFORE_PATH],
+  'ident': [IN_IDENT, APPEND],
+  '[': [BEFORE_ELEMENT],
+  'eof': [AFTER_PATH]
+}
+
+pathStateMachine[IN_PATH] = {
+  'ws': [IN_PATH],
+  '.': [BEFORE_IDENT],
+  '[': [BEFORE_ELEMENT],
+  'eof': [AFTER_PATH]
+}
+
+pathStateMachine[BEFORE_IDENT] = {
+  'ws': [BEFORE_IDENT],
+  'ident': [IN_IDENT, APPEND]
+}
+
+pathStateMachine[IN_IDENT] = {
+  'ident': [IN_IDENT, APPEND],
+  '0': [IN_IDENT, APPEND],
+  'number': [IN_IDENT, APPEND],
+  'ws': [IN_PATH, PUSH],
+  '.': [BEFORE_IDENT, PUSH],
+  '[': [BEFORE_ELEMENT, PUSH],
+  'eof': [AFTER_PATH, PUSH]
+}
+
+pathStateMachine[BEFORE_ELEMENT] = {
+  'ws': [BEFORE_ELEMENT],
+  '0': [AFTER_ZERO, APPEND],
+  'number': [IN_INDEX, APPEND],
+  "'": [IN_SINGLE_QUOTE, APPEND, ''],
+  '"': [IN_DOUBLE_QUOTE, APPEND, ''],
+  'ident': [IN_SUB_PATH, APPEND, '*']
+}
+
+pathStateMachine[AFTER_ZERO] = {
+  'ws': [AFTER_ELEMENT, PUSH],
+  ']': [IN_PATH, PUSH]
+}
+
+pathStateMachine[IN_INDEX] = {
+  '0': [IN_INDEX, APPEND],
+  'number': [IN_INDEX, APPEND],
+  'ws': [AFTER_ELEMENT],
+  ']': [IN_PATH, PUSH]
+}
+
+pathStateMachine[IN_SINGLE_QUOTE] = {
+  "'": [AFTER_ELEMENT],
+  'eof': ERROR,
+  'else': [IN_SINGLE_QUOTE, APPEND]
+}
+
+pathStateMachine[IN_DOUBLE_QUOTE] = {
+  '"': [AFTER_ELEMENT],
+  'eof': ERROR,
+  'else': [IN_DOUBLE_QUOTE, APPEND]
+}
+
+pathStateMachine[IN_SUB_PATH] = {
+  'ident': [IN_SUB_PATH, APPEND],
+  '0': [IN_SUB_PATH, APPEND],
+  'number': [IN_SUB_PATH, APPEND],
+  'ws': [AFTER_ELEMENT],
+  ']': [IN_PATH, PUSH]
+}
+
+pathStateMachine[AFTER_ELEMENT] = {
+  'ws': [AFTER_ELEMENT],
+  ']': [IN_PATH, PUSH]
+}
+
+/**
+ * Determine the type of a character in a keypath.
+ *
+ * @param {Char} ch
+ * @return {String} type
+ */
+
+function getPathCharType (ch) {
+  if (ch === undefined) {
+    return 'eof'
+  }
+
+  var code = ch.charCodeAt(0)
+
+  switch (code) {
+    case 0x5B: // [
+    case 0x5D: // ]
+    case 0x2E: // .
+    case 0x22: // "
+    case 0x27: // '
+    case 0x30: // 0
+      return ch
+
+    case 0x5F: // _
+    case 0x24: // $
+      return 'ident'
+
+    case 0x20: // Space
+    case 0x09: // Tab
+    case 0x0A: // Newline
+    case 0x0D: // Return
+    case 0xA0:  // No-break space
+    case 0xFEFF:  // Byte Order Mark
+    case 0x2028:  // Line Separator
+    case 0x2029:  // Paragraph Separator
+      return 'ws'
+  }
+
+  // a-z, A-Z
+  if (
+    (code >= 0x61 && code <= 0x7A) ||
+    (code >= 0x41 && code <= 0x5A)
+  ) {
+    return 'ident'
+  }
+
+  // 1-9
+  if (code >= 0x31 && code <= 0x39) {
+    return 'number'
+  }
+
+  return 'else'
+}
+
+/**
+ * Parse a string path into an array of segments
+ * Todo implement cache
+ *
+ * @param {String} path
+ * @return {Array|undefined}
+ */
+
+function parsePath (path) {
+  var keys = []
+  var index = -1
+  var mode = BEFORE_PATH
+  var c, newChar, key, type, transition, action, typeMap
+
+  var actions = []
+  actions[PUSH] = function () {
+    if (key === undefined) {
+      return
+    }
+    keys.push(key)
+    key = undefined
+  }
+  actions[APPEND] = function () {
+    if (key === undefined) {
+      key = newChar
+    } else {
+      key += newChar
+    }
+  }
+
+  function maybeUnescapeQuote () {
+    var nextChar = path[index + 1]
+    if ((mode === IN_SINGLE_QUOTE && nextChar === "'") ||
+        (mode === IN_DOUBLE_QUOTE && nextChar === '"')) {
+      index++
+      newChar = nextChar
+      actions[APPEND]()
+      return true
+    }
+  }
+
+  while (mode != null) {
+    index++
+    c = path[index]
+
+    if (c === '\\' && maybeUnescapeQuote()) {
+      continue
+    }
+
+    type = getPathCharType(c)
+    typeMap = pathStateMachine[mode]
+    transition = typeMap[type] || typeMap['else'] || ERROR
+
+    if (transition === ERROR) {
+      return // parse error
+    }
+
+    mode = transition[0]
+    action = actions[transition[1]]
+    if (action) {
+      newChar = transition[2]
+      newChar = newChar === undefined
+        ? c
+        : newChar === '*'
+          ? newChar + c
+          : newChar
+      action()
+    }
+
+    if (mode === AFTER_PATH) {
+      keys.raw = path
+      return keys
+    }
+  }
+}
+
+/**
+ * Format a accessor segment based on its type.
+ *
+ * @param {String} key
+ * @return {Boolean}
+ */
+
+function formatAccessor (key) {
+  if (identRE.test(key)) { // identifier
+    return '.' + key
+  } else if (+key === key >>> 0) { // bracket index
+    return '[' + key + ']'
+  } else if (key.charAt(0) === '*') {
+    return '[o' + formatAccessor(key.slice(1)) + ']'
+  } else { // bracket string
+    return '["' + key.replace(/"/g, '\\"') + '"]'
+  }
+}
+
+/**
+ * Compiles a getter function with a fixed path.
+ * The fixed path getter supresses errors.
+ *
+ * @param {Array} path
+ * @return {Function}
+ */
+
+exports.compileGetter = function (path) {
+  var body = 'return o' + path.map(formatAccessor).join('')
+  return new Function('o', body)
+}
+
+/**
+ * External parse that check for a cache hit first
+ *
+ * @param {String} path
+ * @return {Array|undefined}
+ */
+
+exports.parse = function (path) {
+  var hit = pathCache.get(path)
+  if (!hit) {
+    hit = parsePath(path)
+    if (hit) {
+      hit.get = exports.compileGetter(hit)
+      pathCache.put(path, hit)
+    }
+  }
+  return hit
+}
+
+/**
+ * Get from an object from a path string
+ *
+ * @param {Object} obj
+ * @param {String} path
+ */
+
+exports.get = function (obj, path) {
+  path = exports.parse(path)
+  if (path) {
+    return path.get(obj)
+  }
+}
+
+/**
+ * Set on an object from a path
+ *
+ * @param {Object} obj
+ * @param {String | Array} path
+ * @param {*} val
+ */
+
+exports.set = function (obj, path, val) {
+  var original = obj
+  if (typeof path === 'string') {
+    path = exports.parse(path)
+  }
+  if (!path || !_.isObject(obj)) {
+    return false
+  }
+  var last, key
+  for (var i = 0, l = path.length; i < l; i++) {
+    last = obj
+    key = path[i]
+    if (key.charAt(0) === '*') {
+      key = original[key.slice(1)]
+    }
+    if (i < l - 1) {
+      obj = obj[key]
+      if (!_.isObject(obj)) {
+        warnNonExistent(path)
+        obj = {}
+        last.$add(key, obj)
+      }
+    } else {
+      if (_.isArray(obj)) {
+        obj.$set(key, val)
+      } else if (key in obj) {
+        obj[key] = val
+      } else {
+        warnNonExistent(path)
+        obj.$add(key, val)
+      }
+    }
+  }
+  return true
+}
+
+function warnNonExistent (path) {
+  process.env.NODE_ENV !== 'production' && _.warn(
+    'You are setting a non-existent path "' + path.raw + '" ' +
+    'on a vm instance. Consider pre-initializing the property ' +
+    'with the "data" option for more reliable reactivity ' +
+    'and better performance.'
+  )
+}