First Commit
This commit is contained in:
313
html/sternwarte/checkfuehrung/node_modules/redeyed/redeyed.js
generated
vendored
Executable file
313
html/sternwarte/checkfuehrung/node_modules/redeyed/redeyed.js
generated
vendored
Executable file
@@ -0,0 +1,313 @@
|
||||
;(function() {
|
||||
'use strict'
|
||||
/* global define */
|
||||
|
||||
var esprima
|
||||
var exportFn
|
||||
var toString = Object.prototype.toString
|
||||
|
||||
if (typeof module === 'object' && typeof module.exports === 'object' && typeof require === 'function') {
|
||||
// server side
|
||||
esprima = require('esprima')
|
||||
exportFn = function(redeyed) { module.exports = redeyed }
|
||||
bootstrap(esprima, exportFn)
|
||||
} else if (typeof define === 'function' && define.amd) {
|
||||
// client side
|
||||
// amd
|
||||
define(['esprima'], function(esprima) {
|
||||
return bootstrap(esprima)
|
||||
})
|
||||
} else if (typeof window === 'object') {
|
||||
// no amd -> attach to window if it exists
|
||||
// Note that this requires 'esprima' to be defined on the window, so that script has to be loaded first
|
||||
window.redeyed = bootstrap(window.esprima)
|
||||
}
|
||||
|
||||
function bootstrap(esprima, exportFn) {
|
||||
function isFunction(obj) {
|
||||
return toString.call(obj) === '[object Function]'
|
||||
}
|
||||
|
||||
function isString(obj) {
|
||||
return toString.call(obj) === '[object String]'
|
||||
}
|
||||
|
||||
function isObject(obj) {
|
||||
return toString.call(obj) === '[object Object]'
|
||||
}
|
||||
|
||||
function surroundWith(before, after) {
|
||||
return function(s) { return before + s + after }
|
||||
}
|
||||
|
||||
function isNonCircular(key) {
|
||||
return key !== '_parent'
|
||||
}
|
||||
|
||||
function objectizeString(value) {
|
||||
var vals = value.split(':')
|
||||
|
||||
if (vals.length === 0 || vals.length > 2) {
|
||||
throw new Error(
|
||||
'illegal string config: ' + value +
|
||||
'\nShould be of format "before:after"'
|
||||
)
|
||||
}
|
||||
|
||||
if (vals.length === 1 || vals[1].length === 0) {
|
||||
return vals.indexOf(':') < 0 ? { _before: vals[0] } : { _after: vals[0] }
|
||||
} else {
|
||||
return { _before: vals[0], _after: vals[1] }
|
||||
}
|
||||
}
|
||||
|
||||
function objectize(node) {
|
||||
// Converts 'bef:aft' to { _before: bef, _after: aft }
|
||||
// and resolves undefined before/after from parent or root
|
||||
|
||||
function resolve(value, key) {
|
||||
// resolve before/after from root or parent if it isn't present on the current node
|
||||
if (!value._parent) return undefined
|
||||
|
||||
// Immediate parent
|
||||
if (value._parent._default && value._parent._default[key]) return value._parent._default[key]
|
||||
|
||||
// Root
|
||||
var root = value._parent._parent
|
||||
if (!root) return undefined
|
||||
|
||||
return root._default ? root._default[key] : undefined
|
||||
}
|
||||
|
||||
function process(key) {
|
||||
var value = node[key]
|
||||
|
||||
if (!value) return
|
||||
if (isFunction(value)) return
|
||||
|
||||
// normalize all strings to objects
|
||||
if (isString(value)) {
|
||||
node[key] = value = objectizeString(value)
|
||||
}
|
||||
|
||||
value._parent = node
|
||||
if (isObject(value)) {
|
||||
if (!value._before && !value._after) return objectize(value)
|
||||
|
||||
// resolve missing _before or _after from parent(s)
|
||||
// in case we only have either one on this node
|
||||
value._before = value._before || resolve(value, '_before')
|
||||
value._after = value._after || resolve(value, '_after')
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
throw new Error('nodes need to be either {String}, {Object} or {Function}.' + value + ' is neither.')
|
||||
}
|
||||
|
||||
// Process _default ones first so children can resolve missing before/after from them
|
||||
if (node._default) process('_default')
|
||||
|
||||
Object.keys(node)
|
||||
.filter(function(key) {
|
||||
return isNonCircular(key)
|
||||
&& node.hasOwnProperty(key)
|
||||
&& key !== '_before'
|
||||
&& key !== '_after'
|
||||
&& key !== '_default'
|
||||
})
|
||||
.forEach(process)
|
||||
}
|
||||
|
||||
function functionize(node) {
|
||||
Object.keys(node)
|
||||
.filter(function(key) {
|
||||
return isNonCircular(key) && node.hasOwnProperty(key)
|
||||
})
|
||||
.forEach(function(key) {
|
||||
var value = node[key]
|
||||
|
||||
if (isFunction(value)) return
|
||||
|
||||
if (isObject(value)) {
|
||||
if (!value._before && !value._after) return functionize(value)
|
||||
|
||||
// at this point before/after were "inherited" from the parent or root
|
||||
// (see objectize)
|
||||
var before = value._before || ''
|
||||
var after = value._after || ''
|
||||
|
||||
node[key] = surroundWith(before, after)
|
||||
return node[key]
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
function normalize(root) {
|
||||
objectize(root)
|
||||
functionize(root)
|
||||
}
|
||||
|
||||
function mergeTokensAndComments(tokens, comments) {
|
||||
var all = {}
|
||||
|
||||
function addToAllByRangeStart(t) { all[ t.range[0] ] = t }
|
||||
|
||||
tokens.forEach(addToAllByRangeStart)
|
||||
comments.forEach(addToAllByRangeStart)
|
||||
|
||||
// keys are sorted automatically
|
||||
return Object.keys(all)
|
||||
.map(function(k) { return all[k] })
|
||||
}
|
||||
|
||||
function redeyed(code, config, opts) {
|
||||
opts = opts || {}
|
||||
var parser = opts.parser || esprima
|
||||
var jsx = !!opts.jsx
|
||||
// tokenizer doesn't support JSX at this point (esprima@4.0.0)
|
||||
// therefore we need to generate the AST via the parser not only to
|
||||
// avoid the tokenizer from erroring but also to get JSXIdentifier tokens
|
||||
var buildAst = jsx || !!opts.buildAst
|
||||
|
||||
var hashbang = ''
|
||||
var ast
|
||||
var tokens
|
||||
var comments
|
||||
var lastSplitEnd = 0
|
||||
var splits = []
|
||||
var transformedCode
|
||||
var all
|
||||
var info
|
||||
|
||||
// Replace hashbang line with empty whitespaces to preserve token locations
|
||||
if (code[0] === '#' && code[1] === '!') {
|
||||
hashbang = code.substr(0, code.indexOf('\n') + 1)
|
||||
code = Array.apply(0, Array(hashbang.length)).join(' ') + '\n' + code.substr(hashbang.length)
|
||||
}
|
||||
|
||||
if (buildAst) {
|
||||
ast = parser.parse(code, { tokens: true, comment: true, range: true, loc: true, tolerant: true, jsx: true })
|
||||
tokens = ast.tokens
|
||||
comments = ast.comments
|
||||
} else {
|
||||
tokens = []
|
||||
comments = []
|
||||
parser.tokenize(code, { range: true, loc: true, comment: true }, function(token) {
|
||||
if (token.type === 'LineComment') {
|
||||
token.type = 'Line'
|
||||
comments.push(token)
|
||||
} else if (token.type === 'BlockComment') {
|
||||
token.type = 'Block'
|
||||
comments.push(token)
|
||||
} else {
|
||||
// Optimistically upgrade 'static' to a keyword
|
||||
if (token.type === 'Identifier' && token.value === 'static') token.type = 'Keyword'
|
||||
tokens.push(token)
|
||||
}
|
||||
})
|
||||
}
|
||||
normalize(config)
|
||||
|
||||
function tokenIndex(tokens, tkn, start) {
|
||||
var current
|
||||
var rangeStart = tkn.range[0]
|
||||
|
||||
for (current = start; current < tokens.length; current++) {
|
||||
if (tokens[current].range[0] === rangeStart) return current
|
||||
}
|
||||
|
||||
throw new Error('Token %s not found at or after index: %d', tkn, start)
|
||||
}
|
||||
|
||||
function process(surround) {
|
||||
var result
|
||||
var currentIndex
|
||||
var nextIndex
|
||||
var skip = 0
|
||||
var splitEnd
|
||||
|
||||
result = surround(code.slice(start, end), info)
|
||||
if (isObject(result)) {
|
||||
splits.push(result.replacement)
|
||||
|
||||
currentIndex = info.tokenIndex
|
||||
nextIndex = tokenIndex(info.tokens, result.skipPastToken, currentIndex)
|
||||
skip = nextIndex - currentIndex
|
||||
splitEnd = skip > 0 ? tokens[nextIndex - 1].range[1] : end
|
||||
} else {
|
||||
splits.push(result)
|
||||
splitEnd = end
|
||||
}
|
||||
|
||||
return { skip: skip, splitEnd: splitEnd }
|
||||
}
|
||||
|
||||
function addSplit(start, end, surround, info) {
|
||||
var result
|
||||
var skip = 0
|
||||
|
||||
if (start >= end) return
|
||||
if (surround) {
|
||||
result = process(surround)
|
||||
skip = result.skip
|
||||
lastSplitEnd = result.splitEnd
|
||||
} else {
|
||||
splits.push(code.slice(start, end))
|
||||
lastSplitEnd = end
|
||||
}
|
||||
|
||||
return skip
|
||||
}
|
||||
|
||||
all = mergeTokensAndComments(tokens, comments)
|
||||
for (var tokenIdx = 0; tokenIdx < all.length; tokenIdx++) {
|
||||
var token = all[tokenIdx]
|
||||
var surroundForType = config[token.type]
|
||||
var surround
|
||||
var start
|
||||
var end
|
||||
|
||||
// At least the type (e.g., 'Keyword') needs to be specified for the token to be surrounded
|
||||
if (surroundForType) {
|
||||
// root defaults are only taken into account while resolving before/after otherwise
|
||||
// a root default would apply to everything, even if no type default was specified
|
||||
surround = surroundForType
|
||||
&& surroundForType.hasOwnProperty(token.value)
|
||||
&& surroundForType[token.value]
|
||||
&& isFunction(surroundForType[token.value])
|
||||
? surroundForType[token.value]
|
||||
: surroundForType._default
|
||||
|
||||
start = token.range[0]
|
||||
end = token.range[1]
|
||||
|
||||
addSplit(lastSplitEnd, start)
|
||||
info = { tokenIndex: tokenIdx, tokens: all, ast: ast, code: code }
|
||||
tokenIdx += addSplit(start, end, surround, info)
|
||||
}
|
||||
}
|
||||
|
||||
if (lastSplitEnd < code.length) {
|
||||
addSplit(lastSplitEnd, code.length)
|
||||
}
|
||||
|
||||
if (!opts.nojoin) {
|
||||
transformedCode = splits.join('')
|
||||
if (hashbang.length > 0) {
|
||||
transformedCode = hashbang + transformedCode.substr(hashbang.length)
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
ast : ast
|
||||
, tokens : tokens
|
||||
, comments : comments
|
||||
, splits : splits
|
||||
, code : transformedCode
|
||||
}
|
||||
}
|
||||
|
||||
return exportFn ? exportFn(redeyed) : redeyed
|
||||
}
|
||||
})()
|
||||
Reference in New Issue
Block a user