mirror of
https://github.com/overleaf/overleaf.git
synced 2024-12-08 09:09:02 -05:00
513 lines
18 KiB
JavaScript
513 lines
18 KiB
JavaScript
|
/**
|
||
|
* Copyright (c) 2009-2013 Jeremy Ashkenas
|
||
|
*
|
||
|
* Permission is hereby granted, free of charge, to any person
|
||
|
* obtaining a copy of this software and associated documentation
|
||
|
* files (the "Software"), to deal in the Software without
|
||
|
* restriction, including without limitation the rights to use,
|
||
|
* copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||
|
* copies of the Software, and to permit persons to whom the
|
||
|
* Software is furnished to do so, subject to the following
|
||
|
* conditions:
|
||
|
*
|
||
|
* The above copyright notice and this permission notice shall be
|
||
|
* included in all copies or substantial portions of the Software.
|
||
|
*
|
||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
||
|
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
||
|
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
||
|
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||
|
* OTHER DEALINGS IN THE SOFTWARE.
|
||
|
*
|
||
|
*/
|
||
|
|
||
|
define(function(require, exports, module) {
|
||
|
// Generated by CoffeeScript 1.6.3
|
||
|
|
||
|
var BALANCED_PAIRS, EXPRESSION_CLOSE, EXPRESSION_END, EXPRESSION_START, IMPLICIT_CALL, IMPLICIT_END, IMPLICIT_FUNC, IMPLICIT_UNSPACED_CALL, INVERSES, LINEBREAKS, SINGLE_CLOSERS, SINGLE_LINERS, generate, left, rite, _i, _len, _ref,
|
||
|
__indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; },
|
||
|
__slice = [].slice;
|
||
|
|
||
|
generate = function(tag, value) {
|
||
|
var tok;
|
||
|
tok = [tag, value];
|
||
|
tok.generated = true;
|
||
|
return tok;
|
||
|
};
|
||
|
|
||
|
exports.Rewriter = (function() {
|
||
|
function Rewriter() {}
|
||
|
|
||
|
Rewriter.prototype.rewrite = function(tokens) {
|
||
|
this.tokens = tokens;
|
||
|
this.removeLeadingNewlines();
|
||
|
this.removeMidExpressionNewlines();
|
||
|
this.closeOpenCalls();
|
||
|
this.closeOpenIndexes();
|
||
|
this.addImplicitIndentation();
|
||
|
this.tagPostfixConditionals();
|
||
|
this.addImplicitBracesAndParens();
|
||
|
this.addLocationDataToGeneratedTokens();
|
||
|
return this.tokens;
|
||
|
};
|
||
|
|
||
|
Rewriter.prototype.scanTokens = function(block) {
|
||
|
var i, token, tokens;
|
||
|
tokens = this.tokens;
|
||
|
i = 0;
|
||
|
while (token = tokens[i]) {
|
||
|
i += block.call(this, token, i, tokens);
|
||
|
}
|
||
|
return true;
|
||
|
};
|
||
|
|
||
|
Rewriter.prototype.detectEnd = function(i, condition, action) {
|
||
|
var levels, token, tokens, _ref, _ref1;
|
||
|
tokens = this.tokens;
|
||
|
levels = 0;
|
||
|
while (token = tokens[i]) {
|
||
|
if (levels === 0 && condition.call(this, token, i)) {
|
||
|
return action.call(this, token, i);
|
||
|
}
|
||
|
if (!token || levels < 0) {
|
||
|
return action.call(this, token, i - 1);
|
||
|
}
|
||
|
if (_ref = token[0], __indexOf.call(EXPRESSION_START, _ref) >= 0) {
|
||
|
levels += 1;
|
||
|
} else if (_ref1 = token[0], __indexOf.call(EXPRESSION_END, _ref1) >= 0) {
|
||
|
levels -= 1;
|
||
|
}
|
||
|
i += 1;
|
||
|
}
|
||
|
return i - 1;
|
||
|
};
|
||
|
|
||
|
Rewriter.prototype.removeLeadingNewlines = function() {
|
||
|
var i, tag, _i, _len, _ref;
|
||
|
_ref = this.tokens;
|
||
|
for (i = _i = 0, _len = _ref.length; _i < _len; i = ++_i) {
|
||
|
tag = _ref[i][0];
|
||
|
if (tag !== 'TERMINATOR') {
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
if (i) {
|
||
|
return this.tokens.splice(0, i);
|
||
|
}
|
||
|
};
|
||
|
|
||
|
Rewriter.prototype.removeMidExpressionNewlines = function() {
|
||
|
return this.scanTokens(function(token, i, tokens) {
|
||
|
var _ref;
|
||
|
if (!(token[0] === 'TERMINATOR' && (_ref = this.tag(i + 1), __indexOf.call(EXPRESSION_CLOSE, _ref) >= 0))) {
|
||
|
return 1;
|
||
|
}
|
||
|
tokens.splice(i, 1);
|
||
|
return 0;
|
||
|
});
|
||
|
};
|
||
|
|
||
|
Rewriter.prototype.closeOpenCalls = function() {
|
||
|
var action, condition;
|
||
|
condition = function(token, i) {
|
||
|
var _ref;
|
||
|
return ((_ref = token[0]) === ')' || _ref === 'CALL_END') || token[0] === 'OUTDENT' && this.tag(i - 1) === ')';
|
||
|
};
|
||
|
action = function(token, i) {
|
||
|
return this.tokens[token[0] === 'OUTDENT' ? i - 1 : i][0] = 'CALL_END';
|
||
|
};
|
||
|
return this.scanTokens(function(token, i) {
|
||
|
if (token[0] === 'CALL_START') {
|
||
|
this.detectEnd(i + 1, condition, action);
|
||
|
}
|
||
|
return 1;
|
||
|
});
|
||
|
};
|
||
|
|
||
|
Rewriter.prototype.closeOpenIndexes = function() {
|
||
|
var action, condition;
|
||
|
condition = function(token, i) {
|
||
|
var _ref;
|
||
|
return (_ref = token[0]) === ']' || _ref === 'INDEX_END';
|
||
|
};
|
||
|
action = function(token, i) {
|
||
|
return token[0] = 'INDEX_END';
|
||
|
};
|
||
|
return this.scanTokens(function(token, i) {
|
||
|
if (token[0] === 'INDEX_START') {
|
||
|
this.detectEnd(i + 1, condition, action);
|
||
|
}
|
||
|
return 1;
|
||
|
});
|
||
|
};
|
||
|
|
||
|
Rewriter.prototype.matchTags = function() {
|
||
|
var fuzz, i, j, pattern, _i, _ref, _ref1;
|
||
|
i = arguments[0], pattern = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
|
||
|
fuzz = 0;
|
||
|
for (j = _i = 0, _ref = pattern.length; 0 <= _ref ? _i < _ref : _i > _ref; j = 0 <= _ref ? ++_i : --_i) {
|
||
|
while (this.tag(i + j + fuzz) === 'HERECOMMENT') {
|
||
|
fuzz += 2;
|
||
|
}
|
||
|
if (pattern[j] == null) {
|
||
|
continue;
|
||
|
}
|
||
|
if (typeof pattern[j] === 'string') {
|
||
|
pattern[j] = [pattern[j]];
|
||
|
}
|
||
|
if (_ref1 = this.tag(i + j + fuzz), __indexOf.call(pattern[j], _ref1) < 0) {
|
||
|
return false;
|
||
|
}
|
||
|
}
|
||
|
return true;
|
||
|
};
|
||
|
|
||
|
Rewriter.prototype.looksObjectish = function(j) {
|
||
|
return this.matchTags(j, '@', null, ':') || this.matchTags(j, null, ':');
|
||
|
};
|
||
|
|
||
|
Rewriter.prototype.findTagsBackwards = function(i, tags) {
|
||
|
var backStack, _ref, _ref1, _ref2, _ref3, _ref4, _ref5;
|
||
|
backStack = [];
|
||
|
while (i >= 0 && (backStack.length || (_ref2 = this.tag(i), __indexOf.call(tags, _ref2) < 0) && ((_ref3 = this.tag(i), __indexOf.call(EXPRESSION_START, _ref3) < 0) || this.tokens[i].generated) && (_ref4 = this.tag(i), __indexOf.call(LINEBREAKS, _ref4) < 0))) {
|
||
|
if (_ref = this.tag(i), __indexOf.call(EXPRESSION_END, _ref) >= 0) {
|
||
|
backStack.push(this.tag(i));
|
||
|
}
|
||
|
if ((_ref1 = this.tag(i), __indexOf.call(EXPRESSION_START, _ref1) >= 0) && backStack.length) {
|
||
|
backStack.pop();
|
||
|
}
|
||
|
i -= 1;
|
||
|
}
|
||
|
return _ref5 = this.tag(i), __indexOf.call(tags, _ref5) >= 0;
|
||
|
};
|
||
|
|
||
|
Rewriter.prototype.addImplicitBracesAndParens = function() {
|
||
|
var stack;
|
||
|
stack = [];
|
||
|
return this.scanTokens(function(token, i, tokens) {
|
||
|
var endImplicitCall, endImplicitObject, forward, inImplicit, inImplicitCall, inImplicitControl, inImplicitObject, nextTag, offset, prevTag, s, sameLine, stackIdx, stackTag, stackTop, startIdx, startImplicitCall, startImplicitObject, startsLine, tag, _ref, _ref1, _ref2, _ref3, _ref4, _ref5;
|
||
|
tag = token[0];
|
||
|
prevTag = (i > 0 ? tokens[i - 1] : [])[0];
|
||
|
nextTag = (i < tokens.length - 1 ? tokens[i + 1] : [])[0];
|
||
|
stackTop = function() {
|
||
|
return stack[stack.length - 1];
|
||
|
};
|
||
|
startIdx = i;
|
||
|
forward = function(n) {
|
||
|
return i - startIdx + n;
|
||
|
};
|
||
|
inImplicit = function() {
|
||
|
var _ref, _ref1;
|
||
|
return (_ref = stackTop()) != null ? (_ref1 = _ref[2]) != null ? _ref1.ours : void 0 : void 0;
|
||
|
};
|
||
|
inImplicitCall = function() {
|
||
|
var _ref;
|
||
|
return inImplicit() && ((_ref = stackTop()) != null ? _ref[0] : void 0) === '(';
|
||
|
};
|
||
|
inImplicitObject = function() {
|
||
|
var _ref;
|
||
|
return inImplicit() && ((_ref = stackTop()) != null ? _ref[0] : void 0) === '{';
|
||
|
};
|
||
|
inImplicitControl = function() {
|
||
|
var _ref;
|
||
|
return inImplicit && ((_ref = stackTop()) != null ? _ref[0] : void 0) === 'CONTROL';
|
||
|
};
|
||
|
startImplicitCall = function(j) {
|
||
|
var idx;
|
||
|
idx = j != null ? j : i;
|
||
|
stack.push([
|
||
|
'(', idx, {
|
||
|
ours: true
|
||
|
}
|
||
|
]);
|
||
|
tokens.splice(idx, 0, generate('CALL_START', '('));
|
||
|
if (j == null) {
|
||
|
return i += 1;
|
||
|
}
|
||
|
};
|
||
|
endImplicitCall = function() {
|
||
|
stack.pop();
|
||
|
tokens.splice(i, 0, generate('CALL_END', ')'));
|
||
|
return i += 1;
|
||
|
};
|
||
|
startImplicitObject = function(j, startsLine) {
|
||
|
var idx;
|
||
|
if (startsLine == null) {
|
||
|
startsLine = true;
|
||
|
}
|
||
|
idx = j != null ? j : i;
|
||
|
stack.push([
|
||
|
'{', idx, {
|
||
|
sameLine: true,
|
||
|
startsLine: startsLine,
|
||
|
ours: true
|
||
|
}
|
||
|
]);
|
||
|
tokens.splice(idx, 0, generate('{', generate(new String('{'))));
|
||
|
if (j == null) {
|
||
|
return i += 1;
|
||
|
}
|
||
|
};
|
||
|
endImplicitObject = function(j) {
|
||
|
j = j != null ? j : i;
|
||
|
stack.pop();
|
||
|
tokens.splice(j, 0, generate('}', '}'));
|
||
|
return i += 1;
|
||
|
};
|
||
|
if (inImplicitCall() && (tag === 'IF' || tag === 'TRY' || tag === 'FINALLY' || tag === 'CATCH' || tag === 'CLASS' || tag === 'SWITCH')) {
|
||
|
stack.push([
|
||
|
'CONTROL', i, {
|
||
|
ours: true
|
||
|
}
|
||
|
]);
|
||
|
return forward(1);
|
||
|
}
|
||
|
if (tag === 'INDENT' && inImplicit()) {
|
||
|
if (prevTag !== '=>' && prevTag !== '->' && prevTag !== '[' && prevTag !== '(' && prevTag !== ',' && prevTag !== '{' && prevTag !== 'TRY' && prevTag !== 'ELSE' && prevTag !== '=') {
|
||
|
while (inImplicitCall()) {
|
||
|
endImplicitCall();
|
||
|
}
|
||
|
}
|
||
|
if (inImplicitControl()) {
|
||
|
stack.pop();
|
||
|
}
|
||
|
stack.push([tag, i]);
|
||
|
return forward(1);
|
||
|
}
|
||
|
if (__indexOf.call(EXPRESSION_START, tag) >= 0) {
|
||
|
stack.push([tag, i]);
|
||
|
return forward(1);
|
||
|
}
|
||
|
if (__indexOf.call(EXPRESSION_END, tag) >= 0) {
|
||
|
while (inImplicit()) {
|
||
|
if (inImplicitCall()) {
|
||
|
endImplicitCall();
|
||
|
} else if (inImplicitObject()) {
|
||
|
endImplicitObject();
|
||
|
} else {
|
||
|
stack.pop();
|
||
|
}
|
||
|
}
|
||
|
stack.pop();
|
||
|
}
|
||
|
if ((__indexOf.call(IMPLICIT_FUNC, tag) >= 0 && token.spaced && !token.stringEnd || tag === '?' && i > 0 && !tokens[i - 1].spaced) && (__indexOf.call(IMPLICIT_CALL, nextTag) >= 0 || __indexOf.call(IMPLICIT_UNSPACED_CALL, nextTag) >= 0 && !((_ref = tokens[i + 1]) != null ? _ref.spaced : void 0) && !((_ref1 = tokens[i + 1]) != null ? _ref1.newLine : void 0))) {
|
||
|
if (tag === '?') {
|
||
|
tag = token[0] = 'FUNC_EXIST';
|
||
|
}
|
||
|
startImplicitCall(i + 1);
|
||
|
return forward(2);
|
||
|
}
|
||
|
if (__indexOf.call(IMPLICIT_FUNC, tag) >= 0 && this.matchTags(i + 1, 'INDENT', null, ':') && !this.findTagsBackwards(i, ['CLASS', 'EXTENDS', 'IF', 'CATCH', 'SWITCH', 'LEADING_WHEN', 'FOR', 'WHILE', 'UNTIL'])) {
|
||
|
startImplicitCall(i + 1);
|
||
|
stack.push(['INDENT', i + 2]);
|
||
|
return forward(3);
|
||
|
}
|
||
|
if (tag === ':') {
|
||
|
if (this.tag(i - 2) === '@') {
|
||
|
s = i - 2;
|
||
|
} else {
|
||
|
s = i - 1;
|
||
|
}
|
||
|
while (this.tag(s - 2) === 'HERECOMMENT') {
|
||
|
s -= 2;
|
||
|
}
|
||
|
startsLine = s === 0 || (_ref2 = this.tag(s - 1), __indexOf.call(LINEBREAKS, _ref2) >= 0) || tokens[s - 1].newLine;
|
||
|
if (stackTop()) {
|
||
|
_ref3 = stackTop(), stackTag = _ref3[0], stackIdx = _ref3[1];
|
||
|
if ((stackTag === '{' || stackTag === 'INDENT' && this.tag(stackIdx - 1) === '{') && (startsLine || this.tag(s - 1) === ',' || this.tag(s - 1) === '{')) {
|
||
|
return forward(1);
|
||
|
}
|
||
|
}
|
||
|
startImplicitObject(s, !!startsLine);
|
||
|
return forward(2);
|
||
|
}
|
||
|
if (prevTag === 'OUTDENT' && inImplicitCall() && (tag === '.' || tag === '?.' || tag === '::' || tag === '?::')) {
|
||
|
endImplicitCall();
|
||
|
return forward(1);
|
||
|
}
|
||
|
if (inImplicitObject() && __indexOf.call(LINEBREAKS, tag) >= 0) {
|
||
|
stackTop()[2].sameLine = false;
|
||
|
}
|
||
|
if (__indexOf.call(IMPLICIT_END, tag) >= 0) {
|
||
|
while (inImplicit()) {
|
||
|
_ref4 = stackTop(), stackTag = _ref4[0], stackIdx = _ref4[1], (_ref5 = _ref4[2], sameLine = _ref5.sameLine, startsLine = _ref5.startsLine);
|
||
|
if (inImplicitCall() && prevTag !== ',') {
|
||
|
endImplicitCall();
|
||
|
} else if (inImplicitObject() && sameLine && !startsLine) {
|
||
|
endImplicitObject();
|
||
|
} else if (inImplicitObject() && tag === 'TERMINATOR' && prevTag !== ',' && !(startsLine && this.looksObjectish(i + 1))) {
|
||
|
endImplicitObject();
|
||
|
} else {
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
if (tag === ',' && !this.looksObjectish(i + 1) && inImplicitObject() && (nextTag !== 'TERMINATOR' || !this.looksObjectish(i + 2))) {
|
||
|
offset = nextTag === 'OUTDENT' ? 1 : 0;
|
||
|
while (inImplicitObject()) {
|
||
|
endImplicitObject(i + offset);
|
||
|
}
|
||
|
}
|
||
|
return forward(1);
|
||
|
});
|
||
|
};
|
||
|
|
||
|
Rewriter.prototype.addLocationDataToGeneratedTokens = function() {
|
||
|
return this.scanTokens(function(token, i, tokens) {
|
||
|
var column, line, nextLocation, prevLocation, _ref, _ref1;
|
||
|
if (token[2]) {
|
||
|
return 1;
|
||
|
}
|
||
|
if (!(token.generated || token.explicit)) {
|
||
|
return 1;
|
||
|
}
|
||
|
if (token[0] === '{' && (nextLocation = (_ref = tokens[i + 1]) != null ? _ref[2] : void 0)) {
|
||
|
line = nextLocation.first_line, column = nextLocation.first_column;
|
||
|
} else if (prevLocation = (_ref1 = tokens[i - 1]) != null ? _ref1[2] : void 0) {
|
||
|
line = prevLocation.last_line, column = prevLocation.last_column;
|
||
|
} else {
|
||
|
line = column = 0;
|
||
|
}
|
||
|
token[2] = {
|
||
|
first_line: line,
|
||
|
first_column: column,
|
||
|
last_line: line,
|
||
|
last_column: column
|
||
|
};
|
||
|
return 1;
|
||
|
});
|
||
|
};
|
||
|
|
||
|
Rewriter.prototype.addImplicitIndentation = function() {
|
||
|
var action, condition, indent, outdent, starter;
|
||
|
starter = indent = outdent = null;
|
||
|
condition = function(token, i) {
|
||
|
var _ref, _ref1;
|
||
|
return token[1] !== ';' && (_ref = token[0], __indexOf.call(SINGLE_CLOSERS, _ref) >= 0) && !(token[0] === 'ELSE' && starter !== 'THEN') && !(((_ref1 = token[0]) === 'CATCH' || _ref1 === 'FINALLY') && (starter === '->' || starter === '=>'));
|
||
|
};
|
||
|
action = function(token, i) {
|
||
|
return this.tokens.splice((this.tag(i - 1) === ',' ? i - 1 : i), 0, outdent);
|
||
|
};
|
||
|
return this.scanTokens(function(token, i, tokens) {
|
||
|
var j, tag, _i, _ref, _ref1;
|
||
|
tag = token[0];
|
||
|
if (tag === 'TERMINATOR' && this.tag(i + 1) === 'THEN') {
|
||
|
tokens.splice(i, 1);
|
||
|
return 0;
|
||
|
}
|
||
|
if (tag === 'ELSE' && this.tag(i - 1) !== 'OUTDENT') {
|
||
|
tokens.splice.apply(tokens, [i, 0].concat(__slice.call(this.indentation())));
|
||
|
return 2;
|
||
|
}
|
||
|
if (tag === 'CATCH') {
|
||
|
for (j = _i = 1; _i <= 2; j = ++_i) {
|
||
|
if (!((_ref = this.tag(i + j)) === 'OUTDENT' || _ref === 'TERMINATOR' || _ref === 'FINALLY')) {
|
||
|
continue;
|
||
|
}
|
||
|
tokens.splice.apply(tokens, [i + j, 0].concat(__slice.call(this.indentation())));
|
||
|
return 2 + j;
|
||
|
}
|
||
|
}
|
||
|
if (__indexOf.call(SINGLE_LINERS, tag) >= 0 && this.tag(i + 1) !== 'INDENT' && !(tag === 'ELSE' && this.tag(i + 1) === 'IF')) {
|
||
|
starter = tag;
|
||
|
_ref1 = this.indentation(true), indent = _ref1[0], outdent = _ref1[1];
|
||
|
if (starter === 'THEN') {
|
||
|
indent.fromThen = true;
|
||
|
}
|
||
|
tokens.splice(i + 1, 0, indent);
|
||
|
this.detectEnd(i + 2, condition, action);
|
||
|
if (tag === 'THEN') {
|
||
|
tokens.splice(i, 1);
|
||
|
}
|
||
|
return 1;
|
||
|
}
|
||
|
return 1;
|
||
|
});
|
||
|
};
|
||
|
|
||
|
Rewriter.prototype.tagPostfixConditionals = function() {
|
||
|
var action, condition, original;
|
||
|
original = null;
|
||
|
condition = function(token, i) {
|
||
|
var prevTag, tag;
|
||
|
tag = token[0];
|
||
|
prevTag = this.tokens[i - 1][0];
|
||
|
return tag === 'TERMINATOR' || (tag === 'INDENT' && __indexOf.call(SINGLE_LINERS, prevTag) < 0);
|
||
|
};
|
||
|
action = function(token, i) {
|
||
|
if (token[0] !== 'INDENT' || (token.generated && !token.fromThen)) {
|
||
|
return original[0] = 'POST_' + original[0];
|
||
|
}
|
||
|
};
|
||
|
return this.scanTokens(function(token, i) {
|
||
|
if (token[0] !== 'IF') {
|
||
|
return 1;
|
||
|
}
|
||
|
original = token;
|
||
|
this.detectEnd(i + 1, condition, action);
|
||
|
return 1;
|
||
|
});
|
||
|
};
|
||
|
|
||
|
Rewriter.prototype.indentation = function(implicit) {
|
||
|
var indent, outdent;
|
||
|
if (implicit == null) {
|
||
|
implicit = false;
|
||
|
}
|
||
|
indent = ['INDENT', 2];
|
||
|
outdent = ['OUTDENT', 2];
|
||
|
if (implicit) {
|
||
|
indent.generated = outdent.generated = true;
|
||
|
}
|
||
|
if (!implicit) {
|
||
|
indent.explicit = outdent.explicit = true;
|
||
|
}
|
||
|
return [indent, outdent];
|
||
|
};
|
||
|
|
||
|
Rewriter.prototype.generate = generate;
|
||
|
|
||
|
Rewriter.prototype.tag = function(i) {
|
||
|
var _ref;
|
||
|
return (_ref = this.tokens[i]) != null ? _ref[0] : void 0;
|
||
|
};
|
||
|
|
||
|
return Rewriter;
|
||
|
|
||
|
})();
|
||
|
|
||
|
BALANCED_PAIRS = [['(', ')'], ['[', ']'], ['{', '}'], ['INDENT', 'OUTDENT'], ['CALL_START', 'CALL_END'], ['PARAM_START', 'PARAM_END'], ['INDEX_START', 'INDEX_END']];
|
||
|
|
||
|
exports.INVERSES = INVERSES = {};
|
||
|
|
||
|
EXPRESSION_START = [];
|
||
|
|
||
|
EXPRESSION_END = [];
|
||
|
|
||
|
for (_i = 0, _len = BALANCED_PAIRS.length; _i < _len; _i++) {
|
||
|
_ref = BALANCED_PAIRS[_i], left = _ref[0], rite = _ref[1];
|
||
|
EXPRESSION_START.push(INVERSES[rite] = left);
|
||
|
EXPRESSION_END.push(INVERSES[left] = rite);
|
||
|
}
|
||
|
|
||
|
EXPRESSION_CLOSE = ['CATCH', 'WHEN', 'ELSE', 'FINALLY'].concat(EXPRESSION_END);
|
||
|
|
||
|
IMPLICIT_FUNC = ['IDENTIFIER', 'SUPER', ')', 'CALL_END', ']', 'INDEX_END', '@', 'THIS'];
|
||
|
|
||
|
IMPLICIT_CALL = ['IDENTIFIER', 'NUMBER', 'STRING', 'JS', 'REGEX', 'NEW', 'PARAM_START', 'CLASS', 'IF', 'TRY', 'SWITCH', 'THIS', 'BOOL', 'NULL', 'UNDEFINED', 'UNARY', 'SUPER', 'THROW', '@', '->', '=>', '[', '(', '{', '--', '++'];
|
||
|
|
||
|
IMPLICIT_UNSPACED_CALL = ['+', '-'];
|
||
|
|
||
|
IMPLICIT_END = ['POST_IF', 'FOR', 'WHILE', 'UNTIL', 'WHEN', 'BY', 'LOOP', 'TERMINATOR'];
|
||
|
|
||
|
SINGLE_LINERS = ['ELSE', '->', '=>', 'TRY', 'FINALLY', 'THEN'];
|
||
|
|
||
|
SINGLE_CLOSERS = ['TERMINATOR', 'CATCH', 'FINALLY', 'ELSE', 'OUTDENT', 'LEADING_WHEN'];
|
||
|
|
||
|
LINEBREAKS = ['TERMINATOR', 'INDENT', 'OUTDENT'];
|
||
|
|
||
|
|
||
|
});
|