plate-lang 0.1.0

data/skeleton/vendor/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.'
+  )
+}

data/skeleton/vendor/vue/src/parsers/template.js

@@ -0,0 +1,264 @@
+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>'
+]
+
+var tagRE = /<([\w:]+)/
+var entityRE = /&\w+;/
+
+/**
+ * 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 (
+    _.isTemplate(node) &&
+    node.content instanceof DocumentFragment
+  ) {
+    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)
+  }
+  return frag
+}
+
+// Test for the presence of the Safari template cloning bug
+// https://bugs.webkit.org/show_bug.cgi?id=137755
+var hasBrokenTemplate = _.inBrowser
+  ? (function () {
+      var a = document.createElement('div')
+      a.innerHTML = '<template>1</template>'
+      return !a.cloneNode(true).firstChild.innerHTML
+    })()
+  : false
+
+// Test for IE10/11 textarea placeholder clone bug
+var hasTextareaCloneBug = _.inBrowser
+  ? (function () {
+      var t = document.createElement('textarea')
+      t.placeholder = 't'
+      return t.cloneNode(true).value === 't'
+    })()
+  : 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) {
+  var res = node.cloneNode(true)
+  if (!node.querySelectorAll) {
+    return res
+  }
+  var i, original, cloned
+  /* istanbul ignore if */
+  if (hasBrokenTemplate) {
+    original = node.querySelectorAll('template')
+    if (original.length) {
+      cloned = res.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) {
+    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
+}