1246 lines
36 KiB
Plaintext
1246 lines
36 KiB
Plaintext
|
'use strict';
|
|||
|
|
|
|||
|
|
Object.defineProperty(exports, '__esModule', { value: true });
|
|||
|
|
|
|||
|
|
var Scanner = require('@emmetio/scanner');
|
|||
|
|
|
|||
|
|
function tokenScanner(tokens) {
|
|||
|
|
return {
|
|||
|
|
tokens,
|
|||
|
|
start: 0,
|
|||
|
|
pos: 0,
|
|||
|
|
size: tokens.length
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
function peek(scanner) {
|
|||
|
|
return scanner.tokens[scanner.pos];
|
|||
|
|
}
|
|||
|
|
function next(scanner) {
|
|||
|
|
return scanner.tokens[scanner.pos++];
|
|||
|
|
}
|
|||
|
|
function slice(scanner, from = scanner.start, to = scanner.pos) {
|
|||
|
|
return scanner.tokens.slice(from, to);
|
|||
|
|
}
|
|||
|
|
function readable(scanner) {
|
|||
|
|
return scanner.pos < scanner.size;
|
|||
|
|
}
|
|||
|
|
function consume(scanner, test) {
|
|||
|
|
const token = peek(scanner);
|
|||
|
|
if (token && test(token)) {
|
|||
|
|
scanner.pos++;
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
function error(scanner, message, token = peek(scanner)) {
|
|||
|
|
if (token && token.start != null) {
|
|||
|
|
message += ` at ${token.start}`;
|
|||
|
|
}
|
|||
|
|
const err = new Error(message);
|
|||
|
|
err['pos'] = token && token.start;
|
|||
|
|
return err;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function abbreviation(abbr, options = {}) {
|
|||
|
|
const scanner = tokenScanner(abbr);
|
|||
|
|
const result = statements(scanner, options);
|
|||
|
|
if (readable(scanner)) {
|
|||
|
|
throw error(scanner, 'Unexpected character');
|
|||
|
|
}
|
|||
|
|
return result;
|
|||
|
|
}
|
|||
|
|
function statements(scanner, options) {
|
|||
|
|
const result = {
|
|||
|
|
type: 'TokenGroup',
|
|||
|
|
elements: []
|
|||
|
|
};
|
|||
|
|
let ctx = result;
|
|||
|
|
let node;
|
|||
|
|
const stack = [];
|
|||
|
|
while (readable(scanner)) {
|
|||
|
|
if (node = element(scanner, options) || group(scanner, options)) {
|
|||
|
|
ctx.elements.push(node);
|
|||
|
|
if (consume(scanner, isChildOperator)) {
|
|||
|
|
stack.push(ctx);
|
|||
|
|
ctx = node;
|
|||
|
|
}
|
|||
|
|
else if (consume(scanner, isSiblingOperator)) {
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
else if (consume(scanner, isClimbOperator)) {
|
|||
|
|
do {
|
|||
|
|
if (stack.length) {
|
|||
|
|
ctx = stack.pop();
|
|||
|
|
}
|
|||
|
|
} while (consume(scanner, isClimbOperator));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return result;
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Consumes group from given scanner
|
|||
|
|
*/
|
|||
|
|
function group(scanner, options) {
|
|||
|
|
if (consume(scanner, isGroupStart)) {
|
|||
|
|
const result = statements(scanner, options);
|
|||
|
|
const token = next(scanner);
|
|||
|
|
if (isBracket(token, 'group', false)) {
|
|||
|
|
result.repeat = repeater$1(scanner);
|
|||
|
|
}
|
|||
|
|
return result;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Consumes single element from given scanner
|
|||
|
|
*/
|
|||
|
|
function element(scanner, options) {
|
|||
|
|
let attr;
|
|||
|
|
const elem = {
|
|||
|
|
type: 'TokenElement',
|
|||
|
|
name: void 0,
|
|||
|
|
attributes: void 0,
|
|||
|
|
value: void 0,
|
|||
|
|
repeat: void 0,
|
|||
|
|
selfClose: false,
|
|||
|
|
elements: []
|
|||
|
|
};
|
|||
|
|
if (elementName(scanner, options)) {
|
|||
|
|
elem.name = slice(scanner);
|
|||
|
|
}
|
|||
|
|
while (readable(scanner)) {
|
|||
|
|
scanner.start = scanner.pos;
|
|||
|
|
if (!elem.repeat && !isEmpty(elem) && consume(scanner, isRepeater)) {
|
|||
|
|
elem.repeat = scanner.tokens[scanner.pos - 1];
|
|||
|
|
}
|
|||
|
|
else if (!elem.value && text(scanner)) {
|
|||
|
|
elem.value = getText(scanner);
|
|||
|
|
}
|
|||
|
|
else if (attr = shortAttribute(scanner, 'id', options) || shortAttribute(scanner, 'class', options) || attributeSet(scanner)) {
|
|||
|
|
if (!elem.attributes) {
|
|||
|
|
elem.attributes = Array.isArray(attr) ? attr.slice() : [attr];
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
elem.attributes = elem.attributes.concat(attr);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
if (!isEmpty(elem) && consume(scanner, isCloseOperator)) {
|
|||
|
|
elem.selfClose = true;
|
|||
|
|
if (!elem.repeat && consume(scanner, isRepeater)) {
|
|||
|
|
elem.repeat = scanner.tokens[scanner.pos - 1];
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return !isEmpty(elem) ? elem : void 0;
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Consumes attribute set from given scanner
|
|||
|
|
*/
|
|||
|
|
function attributeSet(scanner) {
|
|||
|
|
if (consume(scanner, isAttributeSetStart)) {
|
|||
|
|
const attributes = [];
|
|||
|
|
let attr;
|
|||
|
|
while (readable(scanner)) {
|
|||
|
|
if (attr = attribute(scanner)) {
|
|||
|
|
attributes.push(attr);
|
|||
|
|
}
|
|||
|
|
else if (consume(scanner, isAttributeSetEnd)) {
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
else if (!consume(scanner, isWhiteSpace)) {
|
|||
|
|
throw error(scanner, `Unexpected "${peek(scanner).type}" token`);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return attributes;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Consumes attribute shorthand (class or id) from given scanner
|
|||
|
|
*/
|
|||
|
|
function shortAttribute(scanner, type, options) {
|
|||
|
|
if (isOperator(peek(scanner), type)) {
|
|||
|
|
scanner.pos++;
|
|||
|
|
// Consume multiple operators
|
|||
|
|
let count = 1;
|
|||
|
|
while (isOperator(peek(scanner), type)) {
|
|||
|
|
scanner.pos++;
|
|||
|
|
count++;
|
|||
|
|
}
|
|||
|
|
const attr = {
|
|||
|
|
name: [createLiteral(type)]
|
|||
|
|
};
|
|||
|
|
if (count > 1) {
|
|||
|
|
attr.multiple = true;
|
|||
|
|
}
|
|||
|
|
// Consume expression after shorthand start for React-like components
|
|||
|
|
if (options.jsx && text(scanner)) {
|
|||
|
|
attr.value = getText(scanner);
|
|||
|
|
attr.expression = true;
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
attr.value = literal$1(scanner) ? slice(scanner) : void 0;
|
|||
|
|
}
|
|||
|
|
return attr;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Consumes single attribute from given scanner
|
|||
|
|
*/
|
|||
|
|
function attribute(scanner) {
|
|||
|
|
if (quoted(scanner)) {
|
|||
|
|
// Consumed quoted value: it’s a value for default attribute
|
|||
|
|
return {
|
|||
|
|
value: slice(scanner)
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
if (literal$1(scanner, true)) {
|
|||
|
|
const name = slice(scanner);
|
|||
|
|
let value;
|
|||
|
|
if (consume(scanner, isEquals)) {
|
|||
|
|
if (quoted(scanner) || literal$1(scanner, true)) {
|
|||
|
|
value = slice(scanner);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return { name, value };
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
function repeater$1(scanner) {
|
|||
|
|
return isRepeater(peek(scanner))
|
|||
|
|
? scanner.tokens[scanner.pos++]
|
|||
|
|
: void 0;
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Consumes quoted value from given scanner, if possible
|
|||
|
|
*/
|
|||
|
|
function quoted(scanner) {
|
|||
|
|
const start = scanner.pos;
|
|||
|
|
const quote = peek(scanner);
|
|||
|
|
if (isQuote(quote)) {
|
|||
|
|
scanner.pos++;
|
|||
|
|
while (readable(scanner)) {
|
|||
|
|
if (isQuote(next(scanner), quote.single)) {
|
|||
|
|
scanner.start = start;
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
throw error(scanner, 'Unclosed quote', quote);
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Consumes literal (unquoted value) from given scanner
|
|||
|
|
*/
|
|||
|
|
function literal$1(scanner, allowBrackets) {
|
|||
|
|
const start = scanner.pos;
|
|||
|
|
const brackets = {
|
|||
|
|
attribute: 0,
|
|||
|
|
expression: 0,
|
|||
|
|
group: 0
|
|||
|
|
};
|
|||
|
|
while (readable(scanner)) {
|
|||
|
|
const token = peek(scanner);
|
|||
|
|
if (brackets.expression) {
|
|||
|
|
// If we’re inside expression, we should consume all content in it
|
|||
|
|
if (isBracket(token, 'expression')) {
|
|||
|
|
brackets[token.context] += token.open ? 1 : -1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else if (isQuote(token) || isOperator(token) || isWhiteSpace(token) || isRepeater(token)) {
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
else if (isBracket(token)) {
|
|||
|
|
if (!allowBrackets) {
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
if (token.open) {
|
|||
|
|
brackets[token.context]++;
|
|||
|
|
}
|
|||
|
|
else if (!brackets[token.context]) {
|
|||
|
|
// Stop if found unmatched closing brace: it must be handled
|
|||
|
|
// by parent consumer
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
brackets[token.context]--;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
scanner.pos++;
|
|||
|
|
}
|
|||
|
|
if (start !== scanner.pos) {
|
|||
|
|
scanner.start = start;
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Consumes element name from given scanner
|
|||
|
|
*/
|
|||
|
|
function elementName(scanner, options) {
|
|||
|
|
const start = scanner.pos;
|
|||
|
|
if (options.jsx && consume(scanner, isCapitalizedLiteral)) {
|
|||
|
|
// Check for edge case: consume immediate capitalized class names
|
|||
|
|
// for React-like components, e.g. `Foo.Bar.Baz`
|
|||
|
|
while (readable(scanner)) {
|
|||
|
|
const { pos } = scanner;
|
|||
|
|
if (!consume(scanner, isClassNameOperator) || !consume(scanner, isCapitalizedLiteral)) {
|
|||
|
|
scanner.pos = pos;
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
while (readable(scanner) && consume(scanner, isElementName$1)) {
|
|||
|
|
// empty
|
|||
|
|
}
|
|||
|
|
if (scanner.pos !== start) {
|
|||
|
|
scanner.start = start;
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Consumes text value from given scanner
|
|||
|
|
*/
|
|||
|
|
function text(scanner) {
|
|||
|
|
const start = scanner.pos;
|
|||
|
|
if (consume(scanner, isTextStart)) {
|
|||
|
|
let brackets = 0;
|
|||
|
|
while (readable(scanner)) {
|
|||
|
|
const token = next(scanner);
|
|||
|
|
if (isBracket(token, 'expression')) {
|
|||
|
|
if (token.open) {
|
|||
|
|
brackets++;
|
|||
|
|
}
|
|||
|
|
else if (!brackets) {
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
brackets--;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
scanner.start = start;
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
function getText(scanner) {
|
|||
|
|
let from = scanner.start;
|
|||
|
|
let to = scanner.pos;
|
|||
|
|
if (isBracket(scanner.tokens[from], 'expression', true)) {
|
|||
|
|
from++;
|
|||
|
|
}
|
|||
|
|
if (isBracket(scanner.tokens[to - 1], 'expression', false)) {
|
|||
|
|
to--;
|
|||
|
|
}
|
|||
|
|
return slice(scanner, from, to);
|
|||
|
|
}
|
|||
|
|
function isBracket(token, context, isOpen) {
|
|||
|
|
return Boolean(token && token.type === 'Bracket'
|
|||
|
|
&& (!context || token.context === context)
|
|||
|
|
&& (isOpen == null || token.open === isOpen));
|
|||
|
|
}
|
|||
|
|
function isOperator(token, type) {
|
|||
|
|
return Boolean(token && token.type === 'Operator' && (!type || token.operator === type));
|
|||
|
|
}
|
|||
|
|
function isQuote(token, isSingle) {
|
|||
|
|
return Boolean(token && token.type === 'Quote' && (isSingle == null || token.single === isSingle));
|
|||
|
|
}
|
|||
|
|
function isWhiteSpace(token) {
|
|||
|
|
return Boolean(token && token.type === 'WhiteSpace');
|
|||
|
|
}
|
|||
|
|
function isEquals(token) {
|
|||
|
|
return isOperator(token, 'equal');
|
|||
|
|
}
|
|||
|
|
function isRepeater(token) {
|
|||
|
|
return Boolean(token && token.type === 'Repeater');
|
|||
|
|
}
|
|||
|
|
function isLiteral(token) {
|
|||
|
|
return token.type === 'Literal';
|
|||
|
|
}
|
|||
|
|
function isCapitalizedLiteral(token) {
|
|||
|
|
if (isLiteral(token)) {
|
|||
|
|
const ch = token.value.charCodeAt(0);
|
|||
|
|
return ch >= 65 && ch <= 90;
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
function isElementName$1(token) {
|
|||
|
|
return token.type === 'Literal' || token.type === 'RepeaterNumber' || token.type === 'RepeaterPlaceholder';
|
|||
|
|
}
|
|||
|
|
function isClassNameOperator(token) {
|
|||
|
|
return isOperator(token, 'class');
|
|||
|
|
}
|
|||
|
|
function isAttributeSetStart(token) {
|
|||
|
|
return isBracket(token, 'attribute', true);
|
|||
|
|
}
|
|||
|
|
function isAttributeSetEnd(token) {
|
|||
|
|
return isBracket(token, 'attribute', false);
|
|||
|
|
}
|
|||
|
|
function isTextStart(token) {
|
|||
|
|
return isBracket(token, 'expression', true);
|
|||
|
|
}
|
|||
|
|
function isGroupStart(token) {
|
|||
|
|
return isBracket(token, 'group', true);
|
|||
|
|
}
|
|||
|
|
function createLiteral(value) {
|
|||
|
|
return { type: 'Literal', value };
|
|||
|
|
}
|
|||
|
|
function isEmpty(elem) {
|
|||
|
|
return !elem.name && !elem.value && !elem.attributes;
|
|||
|
|
}
|
|||
|
|
function isChildOperator(token) {
|
|||
|
|
return isOperator(token, 'child');
|
|||
|
|
}
|
|||
|
|
function isSiblingOperator(token) {
|
|||
|
|
return isOperator(token, 'sibling');
|
|||
|
|
}
|
|||
|
|
function isClimbOperator(token) {
|
|||
|
|
return isOperator(token, 'climb');
|
|||
|
|
}
|
|||
|
|
function isCloseOperator(token) {
|
|||
|
|
return isOperator(token, 'close');
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var Chars;
|
|||
|
|
(function (Chars) {
|
|||
|
|
/** `{` character */
|
|||
|
|
Chars[Chars["CurlyBracketOpen"] = 123] = "CurlyBracketOpen";
|
|||
|
|
/** `}` character */
|
|||
|
|
Chars[Chars["CurlyBracketClose"] = 125] = "CurlyBracketClose";
|
|||
|
|
/** `\\` character */
|
|||
|
|
Chars[Chars["Escape"] = 92] = "Escape";
|
|||
|
|
/** `=` character */
|
|||
|
|
Chars[Chars["Equals"] = 61] = "Equals";
|
|||
|
|
/** `[` character */
|
|||
|
|
Chars[Chars["SquareBracketOpen"] = 91] = "SquareBracketOpen";
|
|||
|
|
/** `]` character */
|
|||
|
|
Chars[Chars["SquareBracketClose"] = 93] = "SquareBracketClose";
|
|||
|
|
/** `*` character */
|
|||
|
|
Chars[Chars["Asterisk"] = 42] = "Asterisk";
|
|||
|
|
/** `#` character */
|
|||
|
|
Chars[Chars["Hash"] = 35] = "Hash";
|
|||
|
|
/** `$` character */
|
|||
|
|
Chars[Chars["Dollar"] = 36] = "Dollar";
|
|||
|
|
/** `-` character */
|
|||
|
|
Chars[Chars["Dash"] = 45] = "Dash";
|
|||
|
|
/** `.` character */
|
|||
|
|
Chars[Chars["Dot"] = 46] = "Dot";
|
|||
|
|
/** `/` character */
|
|||
|
|
Chars[Chars["Slash"] = 47] = "Slash";
|
|||
|
|
/** `:` character */
|
|||
|
|
Chars[Chars["Colon"] = 58] = "Colon";
|
|||
|
|
/** `!` character */
|
|||
|
|
Chars[Chars["Excl"] = 33] = "Excl";
|
|||
|
|
/** `@` character */
|
|||
|
|
Chars[Chars["At"] = 64] = "At";
|
|||
|
|
/** `_` character */
|
|||
|
|
Chars[Chars["Underscore"] = 95] = "Underscore";
|
|||
|
|
/** `(` character */
|
|||
|
|
Chars[Chars["RoundBracketOpen"] = 40] = "RoundBracketOpen";
|
|||
|
|
/** `)` character */
|
|||
|
|
Chars[Chars["RoundBracketClose"] = 41] = "RoundBracketClose";
|
|||
|
|
/** `+` character */
|
|||
|
|
Chars[Chars["Sibling"] = 43] = "Sibling";
|
|||
|
|
/** `>` character */
|
|||
|
|
Chars[Chars["Child"] = 62] = "Child";
|
|||
|
|
/** `^` character */
|
|||
|
|
Chars[Chars["Climb"] = 94] = "Climb";
|
|||
|
|
/** `'` character */
|
|||
|
|
Chars[Chars["SingleQuote"] = 39] = "SingleQuote";
|
|||
|
|
/** `""` character */
|
|||
|
|
Chars[Chars["DoubleQuote"] = 34] = "DoubleQuote";
|
|||
|
|
})(Chars || (Chars = {}));
|
|||
|
|
/**
|
|||
|
|
* If consumes escape character, sets current stream range to escaped value
|
|||
|
|
*/
|
|||
|
|
function escaped(scanner) {
|
|||
|
|
if (scanner.eat(Chars.Escape)) {
|
|||
|
|
scanner.start = scanner.pos;
|
|||
|
|
if (!scanner.eof()) {
|
|||
|
|
scanner.pos++;
|
|||
|
|
}
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function tokenize(source) {
|
|||
|
|
const scanner = new Scanner(source);
|
|||
|
|
const result = [];
|
|||
|
|
const ctx = {
|
|||
|
|
group: 0,
|
|||
|
|
attribute: 0,
|
|||
|
|
expression: 0,
|
|||
|
|
quote: 0
|
|||
|
|
};
|
|||
|
|
let ch = 0;
|
|||
|
|
let token;
|
|||
|
|
while (!scanner.eof()) {
|
|||
|
|
ch = scanner.peek();
|
|||
|
|
token = getToken(scanner, ctx);
|
|||
|
|
if (token) {
|
|||
|
|
result.push(token);
|
|||
|
|
if (token.type === 'Quote') {
|
|||
|
|
ctx.quote = ch === ctx.quote ? 0 : ch;
|
|||
|
|
}
|
|||
|
|
else if (token.type === 'Bracket') {
|
|||
|
|
ctx[token.context] += token.open ? 1 : -1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
throw scanner.error('Unexpected character');
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return result;
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Returns next token from given scanner, if possible
|
|||
|
|
*/
|
|||
|
|
function getToken(scanner, ctx) {
|
|||
|
|
return field(scanner, ctx)
|
|||
|
|
|| repeaterPlaceholder(scanner)
|
|||
|
|
|| repeaterNumber(scanner)
|
|||
|
|
|| repeater(scanner)
|
|||
|
|
|| whiteSpace(scanner)
|
|||
|
|
|| literal(scanner, ctx)
|
|||
|
|
|| operator(scanner)
|
|||
|
|
|| quote(scanner)
|
|||
|
|
|| bracket(scanner);
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Consumes literal from given scanner
|
|||
|
|
*/
|
|||
|
|
function literal(scanner, ctx) {
|
|||
|
|
const start = scanner.pos;
|
|||
|
|
const expressionStart = ctx.expression;
|
|||
|
|
let value = '';
|
|||
|
|
while (!scanner.eof()) {
|
|||
|
|
// Consume escaped sequence no matter of context
|
|||
|
|
if (escaped(scanner)) {
|
|||
|
|
value += scanner.current();
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
const ch = scanner.peek();
|
|||
|
|
if (ch === Chars.Slash && !ctx.quote && !ctx.expression && !ctx.attribute) {
|
|||
|
|
// Special case for `/` character between numbers in class names
|
|||
|
|
const prev = scanner.string.charCodeAt(scanner.pos - 1);
|
|||
|
|
const next = scanner.string.charCodeAt(scanner.pos + 1);
|
|||
|
|
if (Scanner.isNumber(prev) && Scanner.isNumber(next)) {
|
|||
|
|
value += scanner.string[scanner.pos++];
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (ch === ctx.quote || ch === Chars.Dollar || isAllowedOperator(ch, ctx)) {
|
|||
|
|
// 1. Found matching quote
|
|||
|
|
// 2. The `$` character has special meaning in every context
|
|||
|
|
// 3. Depending on context, some characters should be treated as operators
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
if (expressionStart) {
|
|||
|
|
// Consume nested expressions, e.g. span{{foo}}
|
|||
|
|
if (ch === Chars.CurlyBracketOpen) {
|
|||
|
|
ctx.expression++;
|
|||
|
|
}
|
|||
|
|
else if (ch === Chars.CurlyBracketClose) {
|
|||
|
|
if (ctx.expression > expressionStart) {
|
|||
|
|
ctx.expression--;
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else if (!ctx.quote) {
|
|||
|
|
// Consuming element name
|
|||
|
|
if (!ctx.attribute && !isElementName(ch)) {
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
if (isAllowedSpace(ch, ctx) || isAllowedRepeater(ch, ctx) || Scanner.isQuote(ch) || bracketType(ch)) {
|
|||
|
|
// Stop for characters not allowed in unquoted literal
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
value += scanner.string[scanner.pos++];
|
|||
|
|
}
|
|||
|
|
if (start !== scanner.pos) {
|
|||
|
|
scanner.start = start;
|
|||
|
|
return {
|
|||
|
|
type: 'Literal',
|
|||
|
|
value,
|
|||
|
|
start,
|
|||
|
|
end: scanner.pos
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Consumes white space characters as string literal from given scanner
|
|||
|
|
*/
|
|||
|
|
function whiteSpace(scanner) {
|
|||
|
|
const start = scanner.pos;
|
|||
|
|
if (scanner.eatWhile(Scanner.isSpace)) {
|
|||
|
|
return {
|
|||
|
|
type: 'WhiteSpace',
|
|||
|
|
start,
|
|||
|
|
end: scanner.pos,
|
|||
|
|
value: scanner.substring(start, scanner.pos)
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Consumes quote from given scanner
|
|||
|
|
*/
|
|||
|
|
function quote(scanner) {
|
|||
|
|
const ch = scanner.peek();
|
|||
|
|
if (Scanner.isQuote(ch)) {
|
|||
|
|
return {
|
|||
|
|
type: 'Quote',
|
|||
|
|
single: ch === Chars.SingleQuote,
|
|||
|
|
start: scanner.pos++,
|
|||
|
|
end: scanner.pos
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Consumes bracket from given scanner
|
|||
|
|
*/
|
|||
|
|
function bracket(scanner) {
|
|||
|
|
const ch = scanner.peek();
|
|||
|
|
const context = bracketType(ch);
|
|||
|
|
if (context) {
|
|||
|
|
return {
|
|||
|
|
type: 'Bracket',
|
|||
|
|
open: isOpenBracket(ch),
|
|||
|
|
context,
|
|||
|
|
start: scanner.pos++,
|
|||
|
|
end: scanner.pos
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Consumes operator from given scanner
|
|||
|
|
*/
|
|||
|
|
function operator(scanner) {
|
|||
|
|
const op = operatorType(scanner.peek());
|
|||
|
|
if (op) {
|
|||
|
|
return {
|
|||
|
|
type: 'Operator',
|
|||
|
|
operator: op,
|
|||
|
|
start: scanner.pos++,
|
|||
|
|
end: scanner.pos
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Consumes node repeat token from current stream position and returns its
|
|||
|
|
* parsed value
|
|||
|
|
*/
|
|||
|
|
function repeater(scanner) {
|
|||
|
|
const start = scanner.pos;
|
|||
|
|
if (scanner.eat(Chars.Asterisk)) {
|
|||
|
|
scanner.start = scanner.pos;
|
|||
|
|
let count = 1;
|
|||
|
|
let implicit = false;
|
|||
|
|
if (scanner.eatWhile(Scanner.isNumber)) {
|
|||
|
|
count = Number(scanner.current());
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
implicit = true;
|
|||
|
|
}
|
|||
|
|
return {
|
|||
|
|
type: 'Repeater',
|
|||
|
|
count,
|
|||
|
|
value: 0,
|
|||
|
|
implicit,
|
|||
|
|
start,
|
|||
|
|
end: scanner.pos
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Consumes repeater placeholder `$#` from given scanner
|
|||
|
|
*/
|
|||
|
|
function repeaterPlaceholder(scanner) {
|
|||
|
|
const start = scanner.pos;
|
|||
|
|
if (scanner.eat(Chars.Dollar) && scanner.eat(Chars.Hash)) {
|
|||
|
|
return {
|
|||
|
|
type: 'RepeaterPlaceholder',
|
|||
|
|
value: void 0,
|
|||
|
|
start,
|
|||
|
|
end: scanner.pos
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
scanner.pos = start;
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Consumes numbering token like `$` from given scanner state
|
|||
|
|
*/
|
|||
|
|
function repeaterNumber(scanner) {
|
|||
|
|
const start = scanner.pos;
|
|||
|
|
if (scanner.eatWhile(Chars.Dollar)) {
|
|||
|
|
const size = scanner.pos - start;
|
|||
|
|
let reverse = false;
|
|||
|
|
let base = 1;
|
|||
|
|
let parent = 0;
|
|||
|
|
if (scanner.eat(Chars.At)) {
|
|||
|
|
// Consume numbering modifiers
|
|||
|
|
while (scanner.eat(Chars.Climb)) {
|
|||
|
|
parent++;
|
|||
|
|
}
|
|||
|
|
reverse = scanner.eat(Chars.Dash);
|
|||
|
|
scanner.start = scanner.pos;
|
|||
|
|
if (scanner.eatWhile(Scanner.isNumber)) {
|
|||
|
|
base = Number(scanner.current());
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
scanner.start = start;
|
|||
|
|
return {
|
|||
|
|
type: 'RepeaterNumber',
|
|||
|
|
size,
|
|||
|
|
reverse,
|
|||
|
|
base,
|
|||
|
|
parent,
|
|||
|
|
start,
|
|||
|
|
end: scanner.pos
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
function field(scanner, ctx) {
|
|||
|
|
const start = scanner.pos;
|
|||
|
|
// Fields are allowed inside expressions and attributes
|
|||
|
|
if ((ctx.expression || ctx.attribute) && scanner.eat(Chars.Dollar) && scanner.eat(Chars.CurlyBracketOpen)) {
|
|||
|
|
scanner.start = scanner.pos;
|
|||
|
|
let index;
|
|||
|
|
let name = '';
|
|||
|
|
if (scanner.eatWhile(Scanner.isNumber)) {
|
|||
|
|
// It’s a field
|
|||
|
|
index = Number(scanner.current());
|
|||
|
|
name = scanner.eat(Chars.Colon) ? consumePlaceholder(scanner) : '';
|
|||
|
|
}
|
|||
|
|
else if (Scanner.isAlpha(scanner.peek())) {
|
|||
|
|
// It’s a variable
|
|||
|
|
name = consumePlaceholder(scanner);
|
|||
|
|
}
|
|||
|
|
if (scanner.eat(Chars.CurlyBracketClose)) {
|
|||
|
|
return {
|
|||
|
|
type: 'Field',
|
|||
|
|
index, name,
|
|||
|
|
start,
|
|||
|
|
end: scanner.pos
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
throw scanner.error('Expecting }');
|
|||
|
|
}
|
|||
|
|
// If we reached here then there’s no valid field here, revert
|
|||
|
|
// back to starting position
|
|||
|
|
scanner.pos = start;
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Consumes a placeholder: value right after `:` in field. Could be empty
|
|||
|
|
*/
|
|||
|
|
function consumePlaceholder(stream) {
|
|||
|
|
const stack = [];
|
|||
|
|
stream.start = stream.pos;
|
|||
|
|
while (!stream.eof()) {
|
|||
|
|
if (stream.eat(Chars.CurlyBracketOpen)) {
|
|||
|
|
stack.push(stream.pos);
|
|||
|
|
}
|
|||
|
|
else if (stream.eat(Chars.CurlyBracketClose)) {
|
|||
|
|
if (!stack.length) {
|
|||
|
|
stream.pos--;
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
stack.pop();
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
stream.pos++;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (stack.length) {
|
|||
|
|
stream.pos = stack.pop();
|
|||
|
|
throw stream.error(`Expecting }`);
|
|||
|
|
}
|
|||
|
|
return stream.current();
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Check if given character code is an operator and it’s allowed in current context
|
|||
|
|
*/
|
|||
|
|
function isAllowedOperator(ch, ctx) {
|
|||
|
|
const op = operatorType(ch);
|
|||
|
|
if (!op || ctx.quote || ctx.expression) {
|
|||
|
|
// No operators inside quoted values or expressions
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
// Inside attributes, only `equals` is allowed
|
|||
|
|
return !ctx.attribute || op === 'equal';
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Check if given character is a space character and is allowed to be consumed
|
|||
|
|
* as a space token in current context
|
|||
|
|
*/
|
|||
|
|
function isAllowedSpace(ch, ctx) {
|
|||
|
|
return Scanner.isSpace(ch) && !ctx.expression;
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Check if given character can be consumed as repeater in current context
|
|||
|
|
*/
|
|||
|
|
function isAllowedRepeater(ch, ctx) {
|
|||
|
|
return ch === Chars.Asterisk && !ctx.attribute && !ctx.expression;
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* If given character is a bracket, returns it’s type
|
|||
|
|
*/
|
|||
|
|
function bracketType(ch) {
|
|||
|
|
if (ch === Chars.RoundBracketOpen || ch === Chars.RoundBracketClose) {
|
|||
|
|
return 'group';
|
|||
|
|
}
|
|||
|
|
if (ch === Chars.SquareBracketOpen || ch === Chars.SquareBracketClose) {
|
|||
|
|
return 'attribute';
|
|||
|
|
}
|
|||
|
|
if (ch === Chars.CurlyBracketOpen || ch === Chars.CurlyBracketClose) {
|
|||
|
|
return 'expression';
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* If given character is an operator, returns it’s type
|
|||
|
|
*/
|
|||
|
|
function operatorType(ch) {
|
|||
|
|
return (ch === Chars.Child && 'child')
|
|||
|
|
|| (ch === Chars.Sibling && 'sibling')
|
|||
|
|
|| (ch === Chars.Climb && 'climb')
|
|||
|
|
|| (ch === Chars.Dot && 'class')
|
|||
|
|
|| (ch === Chars.Hash && 'id')
|
|||
|
|
|| (ch === Chars.Slash && 'close')
|
|||
|
|
|| (ch === Chars.Equals && 'equal')
|
|||
|
|
|| void 0;
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Check if given character is an open bracket
|
|||
|
|
*/
|
|||
|
|
function isOpenBracket(ch) {
|
|||
|
|
return ch === Chars.CurlyBracketOpen
|
|||
|
|
|| ch === Chars.SquareBracketOpen
|
|||
|
|
|| ch === Chars.RoundBracketOpen;
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Check if given character is allowed in element name
|
|||
|
|
*/
|
|||
|
|
function isElementName(ch) {
|
|||
|
|
return Scanner.isAlphaNumericWord(ch)
|
|||
|
|
|| Scanner.isUmlaut(ch)
|
|||
|
|
|| ch === Chars.Dash
|
|||
|
|
|| ch === Chars.Colon
|
|||
|
|
|| ch === Chars.Excl;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const operators = {
|
|||
|
|
child: '>',
|
|||
|
|
class: '.',
|
|||
|
|
climb: '^',
|
|||
|
|
id: '#',
|
|||
|
|
equal: '=',
|
|||
|
|
close: '/',
|
|||
|
|
sibling: '+'
|
|||
|
|
};
|
|||
|
|
const tokenVisitor = {
|
|||
|
|
Literal(token) {
|
|||
|
|
return token.value;
|
|||
|
|
},
|
|||
|
|
Quote(token) {
|
|||
|
|
return token.single ? '\'' : '"';
|
|||
|
|
},
|
|||
|
|
Bracket(token) {
|
|||
|
|
if (token.context === 'attribute') {
|
|||
|
|
return token.open ? '[' : ']';
|
|||
|
|
}
|
|||
|
|
else if (token.context === 'expression') {
|
|||
|
|
return token.open ? '{' : '}';
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
return token.open ? '(' : '}';
|
|||
|
|
}
|
|||
|
|
},
|
|||
|
|
Operator(token) {
|
|||
|
|
return operators[token.operator];
|
|||
|
|
},
|
|||
|
|
Field(token, state) {
|
|||
|
|
if (token.index != null) {
|
|||
|
|
// It’s a field: by default, return TextMate-compatible field
|
|||
|
|
return token.name
|
|||
|
|
? `\${${token.index}:${token.name}}`
|
|||
|
|
: `\${${token.index}`;
|
|||
|
|
}
|
|||
|
|
else if (token.name) {
|
|||
|
|
// It’s a variable
|
|||
|
|
return state.getVariable(token.name);
|
|||
|
|
}
|
|||
|
|
return '';
|
|||
|
|
},
|
|||
|
|
RepeaterPlaceholder(token, state) {
|
|||
|
|
// Find closest implicit repeater
|
|||
|
|
let repeater;
|
|||
|
|
for (let i = state.repeaters.length - 1; i >= 0; i--) {
|
|||
|
|
if (state.repeaters[i].implicit) {
|
|||
|
|
repeater = state.repeaters[i];
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
state.inserted = true;
|
|||
|
|
return state.getText(repeater && repeater.value);
|
|||
|
|
},
|
|||
|
|
RepeaterNumber(token, state) {
|
|||
|
|
let value = 1;
|
|||
|
|
const lastIx = state.repeaters.length - 1;
|
|||
|
|
// const repeaterIx = Math.max(0, state.repeaters.length - 1 - token.parent);
|
|||
|
|
const repeater = state.repeaters[lastIx];
|
|||
|
|
if (repeater) {
|
|||
|
|
value = token.reverse
|
|||
|
|
? token.base + repeater.count - repeater.value - 1
|
|||
|
|
: token.base + repeater.value;
|
|||
|
|
if (token.parent) {
|
|||
|
|
const parentIx = Math.max(0, lastIx - token.parent);
|
|||
|
|
if (parentIx !== lastIx) {
|
|||
|
|
const parentRepeater = state.repeaters[parentIx];
|
|||
|
|
value += repeater.count * parentRepeater.value;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
let result = String(value);
|
|||
|
|
while (result.length < token.size) {
|
|||
|
|
result = '0' + result;
|
|||
|
|
}
|
|||
|
|
return result;
|
|||
|
|
},
|
|||
|
|
WhiteSpace(token) {
|
|||
|
|
return token.value;
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
/**
|
|||
|
|
* Converts given value token to string
|
|||
|
|
*/
|
|||
|
|
function stringify(token, state) {
|
|||
|
|
if (!tokenVisitor[token.type]) {
|
|||
|
|
throw new Error(`Unknown token ${token.type}`);
|
|||
|
|
}
|
|||
|
|
return tokenVisitor[token.type](token, state);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const urlRegex = /^((https?:|ftp:|file:)?\/\/|(www|ftp)\.)[^ ]*$/;
|
|||
|
|
const emailRegex = /^[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,5}$/;
|
|||
|
|
/**
|
|||
|
|
* Converts given token-based abbreviation into simplified and unrolled node-based
|
|||
|
|
* abbreviation
|
|||
|
|
*/
|
|||
|
|
function convert(abbr, options = {}) {
|
|||
|
|
let textInserted = false;
|
|||
|
|
let cleanText;
|
|||
|
|
if (options.text) {
|
|||
|
|
if (Array.isArray(options.text)) {
|
|||
|
|
cleanText = options.text.filter(s => s.trim());
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
cleanText = options.text;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
const result = {
|
|||
|
|
type: 'Abbreviation',
|
|||
|
|
children: convertGroup(abbr, {
|
|||
|
|
inserted: false,
|
|||
|
|
repeaters: [],
|
|||
|
|
text: options.text,
|
|||
|
|
cleanText,
|
|||
|
|
repeatGuard: options.maxRepeat || Number.POSITIVE_INFINITY,
|
|||
|
|
getText(pos) {
|
|||
|
|
var _a;
|
|||
|
|
textInserted = true;
|
|||
|
|
let value;
|
|||
|
|
if (Array.isArray(options.text)) {
|
|||
|
|
if (pos !== undefined && pos >= 0 && pos < cleanText.length) {
|
|||
|
|
return cleanText[pos];
|
|||
|
|
}
|
|||
|
|
value = pos !== undefined ? options.text[pos] : options.text.join('\n');
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
value = (_a = options.text) !== null && _a !== void 0 ? _a : '';
|
|||
|
|
}
|
|||
|
|
return value;
|
|||
|
|
},
|
|||
|
|
getVariable(name) {
|
|||
|
|
const varValue = options.variables && options.variables[name];
|
|||
|
|
return varValue != null ? varValue : name;
|
|||
|
|
}
|
|||
|
|
})
|
|||
|
|
};
|
|||
|
|
if (options.text != null && !textInserted) {
|
|||
|
|
// Text given but no implicitly repeated elements: insert it into
|
|||
|
|
// deepest child
|
|||
|
|
const deepest = deepestNode(last(result.children));
|
|||
|
|
if (deepest) {
|
|||
|
|
const text = Array.isArray(options.text) ? options.text.join('\n') : options.text;
|
|||
|
|
insertText(deepest, text);
|
|||
|
|
if (deepest.name === 'a' && options.href) {
|
|||
|
|
// Automatically update value of `<a>` element if inserting URL or email
|
|||
|
|
insertHref(deepest, text);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return result;
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Converts given statement to abbreviation nodes
|
|||
|
|
*/
|
|||
|
|
function convertStatement(node, state) {
|
|||
|
|
let result = [];
|
|||
|
|
if (node.repeat) {
|
|||
|
|
// Node is repeated: we should create copies of given node
|
|||
|
|
// and supply context token with actual repeater state
|
|||
|
|
const original = node.repeat;
|
|||
|
|
const repeat = Object.assign({}, original);
|
|||
|
|
repeat.count = repeat.implicit && Array.isArray(state.text)
|
|||
|
|
? state.cleanText.length
|
|||
|
|
: (repeat.count || 1);
|
|||
|
|
let items;
|
|||
|
|
state.repeaters.push(repeat);
|
|||
|
|
for (let i = 0; i < repeat.count; i++) {
|
|||
|
|
repeat.value = i;
|
|||
|
|
node.repeat = repeat;
|
|||
|
|
items = isGroup(node)
|
|||
|
|
? convertGroup(node, state)
|
|||
|
|
: convertElement(node, state);
|
|||
|
|
if (repeat.implicit && !state.inserted) {
|
|||
|
|
// It’s an implicit repeater but no repeater placeholders found inside,
|
|||
|
|
// we should insert text into deepest node
|
|||
|
|
const target = last(items);
|
|||
|
|
const deepest = target && deepestNode(target);
|
|||
|
|
if (deepest) {
|
|||
|
|
insertText(deepest, state.getText(repeat.value));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
result = result.concat(items);
|
|||
|
|
// We should output at least one repeated item even if it’s reached
|
|||
|
|
// repeat limit
|
|||
|
|
if (--state.repeatGuard <= 0) {
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
state.repeaters.pop();
|
|||
|
|
node.repeat = original;
|
|||
|
|
if (repeat.implicit) {
|
|||
|
|
state.inserted = true;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
result = result.concat(isGroup(node) ? convertGroup(node, state) : convertElement(node, state));
|
|||
|
|
}
|
|||
|
|
return result;
|
|||
|
|
}
|
|||
|
|
function convertElement(node, state) {
|
|||
|
|
let children = [];
|
|||
|
|
const elem = {
|
|||
|
|
type: 'AbbreviationNode',
|
|||
|
|
name: node.name && stringifyName(node.name, state),
|
|||
|
|
value: node.value && stringifyValue(node.value, state),
|
|||
|
|
attributes: void 0,
|
|||
|
|
children,
|
|||
|
|
repeat: node.repeat && Object.assign({}, node.repeat),
|
|||
|
|
selfClosing: node.selfClose,
|
|||
|
|
};
|
|||
|
|
let result = [elem];
|
|||
|
|
for (const child of node.elements) {
|
|||
|
|
children = children.concat(convertStatement(child, state));
|
|||
|
|
}
|
|||
|
|
if (node.attributes) {
|
|||
|
|
elem.attributes = [];
|
|||
|
|
for (const attr of node.attributes) {
|
|||
|
|
elem.attributes.push(convertAttribute(attr, state));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
// In case if current node is a text-only snippet without fields, we should
|
|||
|
|
// put all children as siblings
|
|||
|
|
if (!elem.name && !elem.attributes && elem.value && !elem.value.some(isField)) {
|
|||
|
|
// XXX it’s unclear that `children` is not bound to `elem`
|
|||
|
|
// due to concat operation
|
|||
|
|
result = result.concat(children);
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
elem.children = children;
|
|||
|
|
}
|
|||
|
|
return result;
|
|||
|
|
}
|
|||
|
|
function convertGroup(node, state) {
|
|||
|
|
let result = [];
|
|||
|
|
for (const child of node.elements) {
|
|||
|
|
result = result.concat(convertStatement(child, state));
|
|||
|
|
}
|
|||
|
|
if (node.repeat) {
|
|||
|
|
result = attachRepeater(result, node.repeat);
|
|||
|
|
}
|
|||
|
|
return result;
|
|||
|
|
}
|
|||
|
|
function convertAttribute(node, state) {
|
|||
|
|
let implied = false;
|
|||
|
|
let isBoolean = false;
|
|||
|
|
let valueType = node.expression ? 'expression' : 'raw';
|
|||
|
|
let value;
|
|||
|
|
const name = node.name && stringifyName(node.name, state);
|
|||
|
|
if (name && name[0] === '!') {
|
|||
|
|
implied = true;
|
|||
|
|
}
|
|||
|
|
if (name && name[name.length - 1] === '.') {
|
|||
|
|
isBoolean = true;
|
|||
|
|
}
|
|||
|
|
if (node.value) {
|
|||
|
|
const tokens = node.value.slice();
|
|||
|
|
if (isQuote(tokens[0])) {
|
|||
|
|
// It’s a quoted value: remove quotes from output but mark attribute
|
|||
|
|
// value as quoted
|
|||
|
|
const quote = tokens.shift();
|
|||
|
|
if (tokens.length && last(tokens).type === quote.type) {
|
|||
|
|
tokens.pop();
|
|||
|
|
}
|
|||
|
|
valueType = quote.single ? 'singleQuote' : 'doubleQuote';
|
|||
|
|
}
|
|||
|
|
else if (isBracket(tokens[0], 'expression', true)) {
|
|||
|
|
// Value is expression: remove brackets but mark value type
|
|||
|
|
valueType = 'expression';
|
|||
|
|
tokens.shift();
|
|||
|
|
if (isBracket(last(tokens), 'expression', false)) {
|
|||
|
|
tokens.pop();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
value = stringifyValue(tokens, state);
|
|||
|
|
}
|
|||
|
|
return {
|
|||
|
|
name: isBoolean || implied
|
|||
|
|
? name.slice(implied ? 1 : 0, isBoolean ? -1 : void 0)
|
|||
|
|
: name,
|
|||
|
|
value,
|
|||
|
|
boolean: isBoolean,
|
|||
|
|
implied,
|
|||
|
|
valueType,
|
|||
|
|
multiple: node.multiple
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Converts given token list to string
|
|||
|
|
*/
|
|||
|
|
function stringifyName(tokens, state) {
|
|||
|
|
let str = '';
|
|||
|
|
for (let i = 0; i < tokens.length; i++) {
|
|||
|
|
str += stringify(tokens[i], state);
|
|||
|
|
}
|
|||
|
|
return str;
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Converts given token list to value list
|
|||
|
|
*/
|
|||
|
|
function stringifyValue(tokens, state) {
|
|||
|
|
const result = [];
|
|||
|
|
let str = '';
|
|||
|
|
for (let i = 0, token; i < tokens.length; i++) {
|
|||
|
|
token = tokens[i];
|
|||
|
|
if (isField(token)) {
|
|||
|
|
// We should keep original fields in output since some editors has their
|
|||
|
|
// own syntax for field or doesn’t support fields at all so we should
|
|||
|
|
// capture actual field location in output stream
|
|||
|
|
if (str) {
|
|||
|
|
result.push(str);
|
|||
|
|
str = '';
|
|||
|
|
}
|
|||
|
|
result.push(token);
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
str += stringify(token, state);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (str) {
|
|||
|
|
result.push(str);
|
|||
|
|
}
|
|||
|
|
return result;
|
|||
|
|
}
|
|||
|
|
function isGroup(node) {
|
|||
|
|
return node.type === 'TokenGroup';
|
|||
|
|
}
|
|||
|
|
function isField(token) {
|
|||
|
|
return typeof token === 'object' && token.type === 'Field' && token.index != null;
|
|||
|
|
}
|
|||
|
|
function last(arr) {
|
|||
|
|
return arr[arr.length - 1];
|
|||
|
|
}
|
|||
|
|
function deepestNode(node) {
|
|||
|
|
return node.children.length ? deepestNode(last(node.children)) : node;
|
|||
|
|
}
|
|||
|
|
function insertText(node, text) {
|
|||
|
|
if (node.value) {
|
|||
|
|
const lastToken = last(node.value);
|
|||
|
|
if (typeof lastToken === 'string') {
|
|||
|
|
node.value[node.value.length - 1] += text;
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
node.value.push(text);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
node.value = [text];
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
function insertHref(node, text) {
|
|||
|
|
var _a;
|
|||
|
|
let href = '';
|
|||
|
|
if (urlRegex.test(text)) {
|
|||
|
|
href = text;
|
|||
|
|
if (!/\w+:/.test(href) && !href.startsWith('//')) {
|
|||
|
|
href = `http://${href}`;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else if (emailRegex.test(text)) {
|
|||
|
|
href = `mailto:${text}`;
|
|||
|
|
}
|
|||
|
|
const hrefAttribute = (_a = node.attributes) === null || _a === void 0 ? void 0 : _a.find(attr => attr.name === 'href');
|
|||
|
|
if (!hrefAttribute) {
|
|||
|
|
if (!node.attributes) {
|
|||
|
|
node.attributes = [];
|
|||
|
|
}
|
|||
|
|
node.attributes.push({ name: 'href', value: [href], valueType: 'doubleQuote' });
|
|||
|
|
}
|
|||
|
|
else if (!hrefAttribute.value) {
|
|||
|
|
hrefAttribute.value = [href];
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
function attachRepeater(items, repeater) {
|
|||
|
|
for (const item of items) {
|
|||
|
|
if (!item.repeat) {
|
|||
|
|
item.repeat = Object.assign({}, repeater);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return items;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Parses given abbreviation into node tree
|
|||
|
|
*/
|
|||
|
|
function parseAbbreviation(abbr, options) {
|
|||
|
|
try {
|
|||
|
|
const tokens = typeof abbr === 'string' ? tokenize(abbr) : abbr;
|
|||
|
|
return convert(abbreviation(tokens, options), options);
|
|||
|
|
}
|
|||
|
|
catch (err) {
|
|||
|
|
if (err instanceof Scanner.ScannerError && typeof abbr === 'string') {
|
|||
|
|
err.message += `\n${abbr}\n${'-'.repeat(err.pos)}^`;
|
|||
|
|
}
|
|||
|
|
throw err;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
exports.convert = convert;
|
|||
|
|
exports.default = parseAbbreviation;
|
|||
|
|
exports.getToken = getToken;
|
|||
|
|
exports.parse = abbreviation;
|
|||
|
|
exports.tokenize = tokenize;
|
|||
|
|
//# sourceMappingURL=index.cjs.map
|