undefined when no more characters are available.
* @returns {Number}
*/
next() {
if (this.pos < this.string.length) {
return this.string.charCodeAt(this.pos++);
}
}
/**
* `match` can be a character code or a function that takes a character code
* and returns a boolean. If the next character in the stream 'matches'
* the given argument, it is consumed and returned.
* Otherwise, `false` is returned.
* @param {Number|Function} match
* @returns {Boolean}
*/
eat(match) {
const ch = this.peek();
const ok = typeof match === 'function' ? match(ch) : ch === match;
if (ok) {
this.next();
}
return ok;
}
/**
* Repeatedly calls eat with the given argument, until it
* fails. Returns true if any characters were eaten.
* @param {Object} match
* @returns {Boolean}
*/
eatWhile(match) {
const start = this.pos;
while (!this.eof() && this.eat(match)) {}
return this.pos !== start;
}
/**
* Backs up the stream n characters. Backing it up further than the
* start of the current token will cause things to break, so be careful.
* @param {Number} n
*/
backUp(n) {
this.pos -= n || 1;
}
/**
* Get the string between the start of the current token and the
* current stream position.
* @returns {String}
*/
current() {
return this.substring(this.start, this.pos);
}
/**
* Returns substring for given range
* @param {Number} start
* @param {Number} [end]
* @return {String}
*/
substring(start, end) {
return this.string.slice(start, end);
}
/**
* Creates error object with current stream state
* @param {String} message
* @return {Error}
*/
error(message) {
const err = new Error(`${message} at char ${this.pos + 1}`);
err.originalMessage = message;
err.pos = this.pos;
err.string = this.string;
return err;
}
};
/* harmony default export */ var stream_reader_es = (StreamReader);
// CONCATENATED MODULE: ../node_modules/@emmetio/stream-reader-utils/dist/stream-reader-utils.es.js
var stream_reader_utils_es__extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
/**
* Methods for consuming quoted values
*/
const SINGLE_QUOTE = 39; // '
const DOUBLE_QUOTE = 34; // "
const defaultOptions = {
escape: 92, // \ character
throws: false
};
/**
* Consumes 'single' or "double"-quoted string from given string, if possible
* @param {StreamReader} stream
* @param {Number} options.escape A character code of quote-escape symbol
* @param {Boolean} options.throws Throw error if quotes string can’t be properly consumed
* @return {Boolean} `true` if quoted string was consumed. The contents
* of quoted string will be availabe as `stream.current()`
*/
var eatQuoted = function (stream, options) {
options = options ? stream_reader_utils_es__extends({}, defaultOptions, options) : defaultOptions;
const start = stream.pos;
const quote = stream.peek();
if (stream.eat(isQuote)) {
while (!stream.eof()) {
switch (stream.next()) {
case quote:
stream.start = start;
return true;
case options.escape:
stream.next();
break;
}
}
// If we’re here then stream wasn’t properly consumed.
// Revert stream and decide what to do
stream.pos = start;
if (options.throws) {
throw stream.error('Unable to consume quoted string');
}
}
return false;
};
function isQuote(code) {
return code === SINGLE_QUOTE || code === DOUBLE_QUOTE;
}
/**
* Check if given code is a number
* @param {Number} code
* @return {Boolean}
*/
function isNumber(code) {
return code > 47 && code < 58;
}
/**
* Check if given character code is alpha code (letter through A to Z)
* @param {Number} code
* @param {Number} [from]
* @param {Number} [to]
* @return {Boolean}
*/
function isAlpha(code, from, to) {
from = from || 65; // A
to = to || 90; // Z
code &= ~32; // quick hack to convert any char code to uppercase char code
return code >= from && code <= to;
}
/**
* Check if given character code is alpha-numeric (letter through A to Z or number)
* @param {Number} code
* @return {Boolean}
*/
function isAlphaNumeric(code) {
return isNumber(code) || isAlpha(code);
}
function isWhiteSpace(code) {
return code === 32 /* space */
|| code === 9 /* tab */
|| code === 160; /* non-breaking space */
}
/**
* Check if given character code is a space
* @param {Number} code
* @return {Boolean}
*/
function isSpace(code) {
return isWhiteSpace(code) || code === 10 /* LF */
|| code === 13; /* CR */
}
const defaultOptions$1 = {
escape: 92, // \ character
throws: false
};
/**
* Eats paired characters substring, for example `(foo)` or `[bar]`
* @param {StreamReader} stream
* @param {Number} open Character code of pair openinig
* @param {Number} close Character code of pair closing
* @param {Object} [options]
* @return {Boolean} Returns `true` if chacarter pair was successfully
* consumed, it’s content will be available as `stream.current()`
*/
function eatPair(stream, open, close, options) {
options = options ? stream_reader_utils_es__extends({}, defaultOptions$1, options) : defaultOptions$1;
const start = stream.pos;
if (stream.eat(open)) {
let stack = 1,
ch;
while (!stream.eof()) {
if (eatQuoted(stream, options)) {
continue;
}
ch = stream.next();
if (ch === open) {
stack++;
} else if (ch === close) {
stack--;
if (!stack) {
stream.start = start;
return true;
}
} else if (ch === options.escape) {
stream.next();
}
}
// If we’re here then paired character can’t be consumed
stream.pos = start;
if (options.throws) {
throw stream.error(`Unable to find matching pair for ${String.fromCharCode(open)}`);
}
}
return false;
}
// CONCATENATED MODULE: ../node_modules/@emmetio/field-parser/dist/field-parser.es.js
const DOLLAR = 36; // $
const COLON = 58; // :
const ESCAPE = 92; // \
const OPEN_BRACE = 123; // {
const CLOSE_BRACE = 125; // }
/**
* Finds fields in given string and returns object with field-less string
* and array of fields found
* @param {String} string
* @return {Object}
*/
function parse(string) {
const stream = new stream_reader_es(string);
const fields = [];
let cleanString = '',
offset = 0,
pos = 0;
let code, field;
while (!stream.eof()) {
code = stream.peek();
pos = stream.pos;
if (code === ESCAPE) {
stream.next();
stream.next();
} else if (field = consumeField(stream, cleanString.length + pos - offset)) {
fields.push(field);
cleanString += stream.string.slice(offset, pos) + field.placeholder;
offset = stream.pos;
} else {
stream.next();
}
}
return new FieldString(cleanString + stream.string.slice(offset), fields);
}
/**
* Marks given `string` with `fields`: wraps each field range with
* `${index:placeholder}` (by default) or any other token produced by `token`
* function, if provided
* @param {String} string String to mark
* @param {Array} fields Array of field descriptor. A field descriptor is a
* `{index, location, length}` array. It is important that fields in array
* must be ordered by their location in string: some fields my refer the same
* location so they must appear in order that user expects.
* @param {Function} [token] Function that generates field token. This function
* received two arguments: `index` and `placeholder` and should return string
* @return {String} String with marked fields
*/
function mark(string, fields, token) {
token = token || createToken;
// order fields by their location and appearence
// NB field ranges should not overlap! (not supported yet)
const ordered = fields.map((field, order) => ({ order, field, end: field.location + field.length })).sort((a, b) => a.end - b.end || a.order - b.order);
// mark ranges in string
let offset = 0;
const result = ordered.map(item => {
const placeholder = string.substr(item.field.location, item.field.length);
const prefix = string.slice(offset, item.field.location);
offset = item.end;
return prefix + token(item.field.index, placeholder);
});
return result.join('') + string.slice(offset);
}
/**
* Creates field token for string
* @param {Number} index Field index
* @param {String} placeholder Field placeholder, could be empty string
* @return {String}
*/
function createToken(index, placeholder) {
return placeholder ? `\${${index}:${placeholder}}` : `\${${index}}`;
}
/**
* Consumes field from current stream position: it can be an `$index` or
* or `${index}` or `${index:placeholder}`
* @param {StreamReader} stream
* @param {Number} location Field location in *clean* string
* @return {Field} Object with `index` and `placeholder` properties if
* field was successfully consumed, `null` otherwise
*/
function consumeField(stream, location) {
const start = stream.pos;
if (stream.eat(DOLLAR)) {
// Possible start of field
let index = consumeIndex(stream);
let placeholder = '';
// consumed $index placeholder
if (index != null) {
return new Field(index, placeholder, location);
}
if (stream.eat(OPEN_BRACE)) {
index = consumeIndex(stream);
if (index != null) {
if (stream.eat(COLON)) {
placeholder = consumePlaceholder(stream);
}
if (stream.eat(CLOSE_BRACE)) {
return new Field(index, placeholder, location);
}
}
}
}
// If we reached here then there’s no valid field here, revert
// back to starting position
stream.pos = start;
}
/**
* Consumes a placeholder: value right after `:` in field. Could be empty
* @param {StreamReader} stream
* @return {String}
*/
function consumePlaceholder(stream) {
let code;
const stack = [];
stream.start = stream.pos;
while (!stream.eof()) {
code = stream.peek();
if (code === OPEN_BRACE) {
stack.push(stream.pos);
} else if (code === CLOSE_BRACE) {
if (!stack.length) {
break;
}
stack.pop();
}
stream.next();
}
if (stack.length) {
throw stream.error('Unable to find matching "}" for curly brace at ' + stack.pop());
}
return stream.current();
}
/**
* Consumes integer from current stream position
* @param {StreamReader} stream
* @return {Number}
*/
function consumeIndex(stream) {
stream.start = stream.pos;
if (stream.eatWhile(isNumber)) {
return Number(stream.current());
}
}
let Field = class Field {
constructor(index, placeholder, location) {
this.index = index;
this.placeholder = placeholder;
this.location = location;
this.length = this.placeholder.length;
}
};
let FieldString = class FieldString {
/**
* @param {String} string
* @param {Field[]} fields
*/
constructor(string, fields) {
this.string = string;
this.fields = fields;
}
mark(token) {
return mark(this.string, this.fields, token);
}
toString() {
return this.string;
}
};
/* harmony default export */ var field_parser_es = (parse);
//# sourceMappingURL=field-parser.es.js.map
// CONCATENATED MODULE: ../node_modules/@emmetio/extract-abbreviation/dist/extract-abbreviation.es.js
var extract_abbreviation_es__extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
/**
* Minimalistic backwards stream reader
*/
let extract_abbreviation_es_StreamReader = class StreamReader {
constructor(string, start) {
this.string = string;
this.start = start || 0;
this.pos = this.string.length;
}
sol() {
return this.pos === this.start;
}
peek(offset) {
return this.string.charCodeAt(this.pos - 1 + (offset || 0));
}
prev() {
if (!this.sol()) {
return this.string.charCodeAt(--this.pos);
}
}
eat(match) {
if (this.sol()) {
return false;
}
const ok = typeof match === 'function' ? match(this.peek()) : match === this.peek();
if (ok) {
this.pos--;
}
return ok;
}
eatWhile(match) {
const start = this.pos;
while (this.eat(match)) {}
return this.pos < start;
}
};
/**
* Quotes-related utilities
*/
const extract_abbreviation_es_SINGLE_QUOTE = 39; // '
const extract_abbreviation_es_DOUBLE_QUOTE = 34; // "
const extract_abbreviation_es_ESCAPE = 92; // \
/**
* Check if given character code is a quote
* @param {Number} c
* @return {Boolean}
*/
function extract_abbreviation_es_isQuote(c) {
return c === extract_abbreviation_es_SINGLE_QUOTE || c === extract_abbreviation_es_DOUBLE_QUOTE;
}
/**
* Consumes quoted value, if possible
* @param {StreamReader} stream
* @return {Boolean} Returns `true` is value was consumed
*/
function extract_abbreviation_es_eatQuoted(stream) {
const start = stream.pos;
const quote = stream.prev();
if (extract_abbreviation_es_isQuote(quote)) {
while (!stream.sol()) {
if (stream.prev() === quote && stream.peek() !== extract_abbreviation_es_ESCAPE) {
return true;
}
}
}
stream.pos = start;
return false;
}
const TAB = 9;
const SPACE = 32;
const DASH = 45; // -
const SLASH = 47; // /
const extract_abbreviation_es_COLON = 58; // :
const EQUALS = 61; // =
const ANGLE_LEFT = 60; // <
const ANGLE_RIGHT = 62; // >
/**
* Check if given reader’s current position points at the end of HTML tag
* @param {StreamReader} stream
* @return {Boolean}
*/
var isAtHTMLTag = function (stream) {
const start = stream.pos;
if (!stream.eat(ANGLE_RIGHT)) {
return false;
}
let ok = false;
stream.eat(SLASH); // possibly self-closed element
while (!stream.sol()) {
stream.eatWhile(extract_abbreviation_es_isWhiteSpace);
if (eatIdent(stream)) {
// ate identifier: could be a tag name, boolean attribute or unquoted
// attribute value
if (stream.eat(SLASH)) {
// either closing tag or invalid tag
ok = stream.eat(ANGLE_LEFT);
break;
} else if (stream.eat(ANGLE_LEFT)) {
// opening tag
ok = true;
break;
} else if (stream.eat(extract_abbreviation_es_isWhiteSpace)) {
// boolean attribute
continue;
} else if (stream.eat(EQUALS)) {
// simple unquoted value or invalid attribute
if (eatIdent(stream)) {
continue;
}
break;
} else if (eatAttributeWithUnquotedValue(stream)) {
// identifier was a part of unquoted value
ok = true;
break;
}
// invalid tag
break;
}
if (eatAttribute(stream)) {
continue;
}
break;
}
stream.pos = start;
return ok;
};
/**
* Eats HTML attribute from given string.
* @param {StreamReader} state
* @return {Boolean} `true` if attribute was consumed.
*/
function eatAttribute(stream) {
return eatAttributeWithQuotedValue(stream) || eatAttributeWithUnquotedValue(stream);
}
/**
* @param {StreamReader} stream
* @return {Boolean}
*/
function eatAttributeWithQuotedValue(stream) {
const start = stream.pos;
if (extract_abbreviation_es_eatQuoted(stream) && stream.eat(EQUALS) && eatIdent(stream)) {
return true;
}
stream.pos = start;
return false;
}
/**
* @param {StreamReader} stream
* @return {Boolean}
*/
function eatAttributeWithUnquotedValue(stream) {
const start = stream.pos;
if (stream.eatWhile(isUnquotedValue) && stream.eat(EQUALS) && eatIdent(stream)) {
return true;
}
stream.pos = start;
return false;
}
/**
* Eats HTML identifier from stream
* @param {StreamReader} stream
* @return {Boolean}
*/
function eatIdent(stream) {
return stream.eatWhile(isIdent);
}
/**
* Check if given character code belongs to HTML identifier
* @param {Number} c
* @return {Boolean}
*/
function isIdent(c) {
return c === extract_abbreviation_es_COLON || c === DASH || extract_abbreviation_es_isAlpha(c) || extract_abbreviation_es_isNumber(c);
}
/**
* Check if given character code is alpha code (letter though A to Z)
* @param {Number} c
* @return {Boolean}
*/
function extract_abbreviation_es_isAlpha(c) {
c &= ~32; // quick hack to convert any char code to uppercase char code
return c >= 65 && c <= 90; // A-Z
}
/**
* Check if given code is a number
* @param {Number} c
* @return {Boolean}
*/
function extract_abbreviation_es_isNumber(c) {
return c > 47 && c < 58;
}
/**
* Check if given code is a whitespace
* @param {Number} c
* @return {Boolean}
*/
function extract_abbreviation_es_isWhiteSpace(c) {
return c === SPACE || c === TAB;
}
/**
* Check if given code may belong to unquoted attribute value
* @param {Number} c
* @return {Boolean}
*/
function isUnquotedValue(c) {
return c && c !== EQUALS && !extract_abbreviation_es_isWhiteSpace(c) && !extract_abbreviation_es_isQuote(c);
}
const extract_abbreviation_es_code = ch => ch.charCodeAt(0);
const SQUARE_BRACE_L = extract_abbreviation_es_code('[');
const SQUARE_BRACE_R = extract_abbreviation_es_code(']');
const ROUND_BRACE_L = extract_abbreviation_es_code('(');
const ROUND_BRACE_R = extract_abbreviation_es_code(')');
const CURLY_BRACE_L = extract_abbreviation_es_code('{');
const CURLY_BRACE_R = extract_abbreviation_es_code('}');
const specialChars = new Set('#.*:$-_!@%^+>/'.split('').map(extract_abbreviation_es_code));
const bracePairs = new Map().set(SQUARE_BRACE_L, SQUARE_BRACE_R).set(ROUND_BRACE_L, ROUND_BRACE_R).set(CURLY_BRACE_L, CURLY_BRACE_R);
const extract_abbreviation_es_defaultOptions = {
syntax: 'markup',
lookAhead: null,
prefix: ''
};
/**
* Extracts Emmet abbreviation from given string.
* The goal of this module is to extract abbreviation from current editor’s line,
* e.g. like this: `.foo[title=bar|]` -> `.foo[title=bar]`, where
* `|` is a current caret position.
* @param {String} line A text line where abbreviation should be expanded
* @param {Number} [pos] Caret position in line. If not given, uses end-of-line
* @param {Object} [options]
* @param {Boolean} [options.lookAhead] Allow parser to look ahead of `pos` index for
* searching of missing abbreviation parts. Most editors automatically inserts
* closing braces for `[`, `{` and `(`, which will most likely be right after
* current caret position. So in order to properly expand abbreviation, user
* must explicitly move caret right after auto-inserted braces. With this option
* enabled, parser will search for closing braces right after `pos`. Default is `true`
* @param {String} [options.syntax] Name of context syntax of expanded abbreviation.
* Either 'markup' (default) or 'stylesheet'. In 'stylesheet' syntax, braces `[]`
* and `{}` are not supported thus not extracted.
* @param {String} [options.prefix] A string that should precede abbreviation in
* order to make it successfully extracted. If given, the abbreviation will be
* extracted from the nearest `prefix` occurrence.
* @return {Object} Object with `abbreviation` and its `location` in given line
* if abbreviation can be extracted, `null` otherwise
*/
function extractAbbreviation(line, pos, options) {
// make sure `pos` is within line range
pos = Math.min(line.length, Math.max(0, pos == null ? line.length : pos));
if (typeof options === 'boolean') {
options = extract_abbreviation_es__extends({}, extract_abbreviation_es_defaultOptions, { lookAhead: options });
} else {
options = extract_abbreviation_es__extends({}, extract_abbreviation_es_defaultOptions, options);
}
if (options.lookAhead == null || options.lookAhead === true) {
pos = offsetPastAutoClosed(line, pos, options);
}
let c;
const start = getStartOffset(line, pos, options.prefix);
if (start === -1) {
return null;
}
const stream = new extract_abbreviation_es_StreamReader(line, start);
stream.pos = pos;
const stack = [];
while (!stream.sol()) {
c = stream.peek();
if (isCloseBrace(c, options.syntax)) {
stack.push(c);
} else if (isOpenBrace(c, options.syntax)) {
if (stack.pop() !== bracePairs.get(c)) {
// unexpected brace
break;
}
} else if (has(stack, SQUARE_BRACE_R) || has(stack, CURLY_BRACE_R)) {
// respect all characters inside attribute sets or text nodes
stream.pos--;
continue;
} else if (isAtHTMLTag(stream) || !isAbbreviation(c)) {
break;
}
stream.pos--;
}
if (!stack.length && stream.pos !== pos) {
// found something, remove some invalid symbols from the
// beginning and return abbreviation
const abbreviation = line.slice(stream.pos, pos).replace(/^[*+>^]+/, '');
return {
abbreviation,
location: pos - abbreviation.length,
start: options.prefix ? start - options.prefix.length : pos - abbreviation.length,
end: pos
};
}
}
/**
* Returns new `line` index which is right after characters beyound `pos` that
* editor will likely automatically close, e.g. }, ], and quotes
* @param {String} line
* @param {Number} pos
* @return {Number}
*/
function offsetPastAutoClosed(line, pos, options) {
// closing quote is allowed only as a next character
if (extract_abbreviation_es_isQuote(line.charCodeAt(pos))) {
pos++;
}
// offset pointer until non-autoclosed character is found
while (isCloseBrace(line.charCodeAt(pos), options.syntax)) {
pos++;
}
return pos;
}
/**
* Returns start offset (left limit) in `line` where we should stop looking for
* abbreviation: it’s nearest to `pos` location of `prefix` token
* @param {String} line
* @param {Number} pos
* @param {String} prefix
* @return {Number}
*/
function getStartOffset(line, pos, prefix) {
if (!prefix) {
return 0;
}
const stream = new extract_abbreviation_es_StreamReader(line);
const compiledPrefix = String(prefix).split('').map(extract_abbreviation_es_code);
stream.pos = pos;
let result;
while (!stream.sol()) {
if (consumePair(stream, SQUARE_BRACE_R, SQUARE_BRACE_L) || consumePair(stream, CURLY_BRACE_R, CURLY_BRACE_L)) {
continue;
}
result = stream.pos;
if (consumeArray(stream, compiledPrefix)) {
return result;
}
stream.pos--;
}
return -1;
}
/**
* Consumes full character pair, if possible
* @param {StreamReader} stream
* @param {Number} close
* @param {Number} open
* @return {Boolean}
*/
function consumePair(stream, close, open) {
const start = stream.pos;
if (stream.eat(close)) {
while (!stream.sol()) {
if (stream.eat(open)) {
return true;
}
stream.pos--;
}
}
stream.pos = start;
return false;
}
/**
* Consumes all character codes from given array, right-to-left, if possible
* @param {StreamReader} stream
* @param {Number[]} arr
*/
function consumeArray(stream, arr) {
const start = stream.pos;
let consumed = false;
for (let i = arr.length - 1; i >= 0 && !stream.sol(); i--) {
if (!stream.eat(arr[i])) {
break;
}
consumed = i === 0;
}
if (!consumed) {
stream.pos = start;
}
return consumed;
}
function has(arr, value) {
return arr.indexOf(value) !== -1;
}
function isAbbreviation(c) {
return c > 64 && c < 91 || // uppercase letter
c > 96 && c < 123 // lowercase letter
|| c > 47 && c < 58 // number
|| specialChars.has(c); // special character
}
function isOpenBrace(c, syntax) {
return c === ROUND_BRACE_L || syntax === 'markup' && (c === SQUARE_BRACE_L || c === CURLY_BRACE_L);
}
function isCloseBrace(c, syntax) {
return c === ROUND_BRACE_R || syntax === 'markup' && (c === SQUARE_BRACE_R || c === CURLY_BRACE_R);
}
/* harmony default export */ var extract_abbreviation_es = (extractAbbreviation);
// CONCATENATED MODULE: ../node_modules/@emmetio/node/dist/node.es.js
var node_es__extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
/**
* Attribute descriptor of parsed abbreviation node
* @param {String} name Attribute name
* @param {String} value Attribute value
* @param {Object} options Additional custom attribute options
* @param {Boolean} options.boolean Attribute is boolean (e.g. name equals value)
* @param {Boolean} options.implied Attribute is implied (e.g. must be outputted
* only if contains non-null value)
*/
let Attribute = class Attribute {
constructor(name, value, options) {
this.name = name;
this.value = value != null ? value : null;
this.options = options || {};
}
/**
* Create a copy of current attribute
* @return {Attribute}
*/
clone() {
return new Attribute(this.name, this.value, node_es__extends({}, this.options));
}
/**
* A string representation of current node
*/
valueOf() {
return `${this.name}="${this.value}"`;
}
};
/**
* A parsed abbreviation AST node. Nodes build up an abbreviation AST tree
*/
let Node = class Node {
/**
* Creates a new node
* @param {String} [name] Node name
* @param {Array} [attributes] Array of attributes to add
*/
constructor(name, attributes) {
// own properties
this.name = name || null;
this.value = null;
this.repeat = null;
this.selfClosing = false;
this.children = [];
/** @type {Node} Pointer to parent node */
this.parent = null;
/** @type {Node} Pointer to next sibling */
this.next = null;
/** @type {Node} Pointer to previous sibling */
this.previous = null;
this._attributes = [];
if (Array.isArray(attributes)) {
attributes.forEach(attr => this.setAttribute(attr));
}
}
/**
* Array of current node attributes
* @return {Attribute[]} Array of attributes
*/
get attributes() {
return this._attributes;
}
/**
* A shorthand to retreive node attributes as map
* @return {Object}
*/
get attributesMap() {
return this.attributes.reduce((out, attr) => {
out[attr.name] = attr.options.boolean ? attr.name : attr.value;
return out;
}, {});
}
/**
* Check if current node is a grouping one, e.g. has no actual representation
* and is used for grouping subsequent nodes only
* @return {Boolean}
*/
get isGroup() {
return !this.name && !this.value && !this._attributes.length;
}
/**
* Check if given node is a text-only node, e.g. contains only value
* @return {Boolean}
*/
get isTextOnly() {
return !this.name && !!this.value && !this._attributes.length;
}
/**
* Returns first child node
* @return {Node}
*/
get firstChild() {
return this.children[0];
}
/**
* Returns last child of current node
* @return {Node}
*/
get lastChild() {
return this.children[this.children.length - 1];
}
/**
* Return index of current node in its parent child list
* @return {Number} Returns -1 if current node is a root one
*/
get childIndex() {
return this.parent ? this.parent.children.indexOf(this) : -1;
}
/**
* Returns next sibling of current node
* @return {Node}
*/
get nextSibling() {
return this.next;
}
/**
* Returns previous sibling of current node
* @return {Node}
*/
get previousSibling() {
return this.previous;
}
/**
* Returns array of unique class names in current node
* @return {String[]}
*/
get classList() {
const attr = this.getAttribute('class');
return attr && attr.value ? attr.value.split(/\s+/g).filter(uniqueClass) : [];
}
/**
* Convenient alias to create a new node instance
* @param {String} [name] Node name
* @param {Object} [attributes] Attributes hash
* @return {Node}
*/
create(name, attributes) {
return new Node(name, attributes);
}
/**
* Sets given attribute for current node
* @param {String|Object|Attribute} name Attribute name or attribute object
* @param {String} [value] Attribute value
*/
setAttribute(name, value) {
const attr = createAttribute(name, value);
const curAttr = this.getAttribute(name);
if (curAttr) {
this.replaceAttribute(curAttr, attr);
} else {
this._attributes.push(attr);
}
}
/**
* Check if attribute with given name exists in node
* @param {String} name
* @return {Boolean}
*/
hasAttribute(name) {
return !!this.getAttribute(name);
}
/**
* Returns attribute object by given name
* @param {String} name
* @return {Attribute}
*/
getAttribute(name) {
if (typeof name === 'object') {
name = name.name;
}
for (var i = 0; i < this._attributes.length; i++) {
const attr = this._attributes[i];
if (attr.name === name) {
return attr;
}
}
}
/**
* Replaces attribute with new instance
* @param {String|Attribute} curAttribute Current attribute name or instance
* to replace
* @param {String|Object|Attribute} newName New attribute name or attribute object
* @param {String} [newValue] New attribute value
*/
replaceAttribute(curAttribute, newName, newValue) {
if (typeof curAttribute === 'string') {
curAttribute = this.getAttribute(curAttribute);
}
const ix = this._attributes.indexOf(curAttribute);
if (ix !== -1) {
this._attributes.splice(ix, 1, createAttribute(newName, newValue));
}
}
/**
* Removes attribute with given name
* @param {String|Attribute} attr Atrtibute name or instance
*/
removeAttribute(attr) {
if (typeof attr === 'string') {
attr = this.getAttribute(attr);
}
const ix = this._attributes.indexOf(attr);
if (ix !== -1) {
this._attributes.splice(ix, 1);
}
}
/**
* Removes all attributes from current node
*/
clearAttributes() {
this._attributes.length = 0;
}
/**
* Adds given class name to class attribute
* @param {String} token Class name token
*/
addClass(token) {
token = normalize(token);
if (!this.hasAttribute('class')) {
this.setAttribute('class', token);
} else if (token && !this.hasClass(token)) {
this.setAttribute('class', this.classList.concat(token).join(' '));
}
}
/**
* Check if current node contains given class name
* @param {String} token Class name token
* @return {Boolean}
*/
hasClass(token) {
return this.classList.indexOf(normalize(token)) !== -1;
}
/**
* Removes given class name from class attribute
* @param {String} token Class name token
*/
removeClass(token) {
token = normalize(token);
if (this.hasClass(token)) {
this.setAttribute('class', this.classList.filter(name => name !== token).join(' '));
}
}
/**
* Appends child to current node
* @param {Node} node
*/
appendChild(node) {
this.insertAt(node, this.children.length);
}
/**
* Inserts given `newNode` before `refNode` child node
* @param {Node} newNode
* @param {Node} refNode
*/
insertBefore(newNode, refNode) {
this.insertAt(newNode, this.children.indexOf(refNode));
}
/**
* Insert given `node` at `pos` position of child list
* @param {Node} node
* @param {Number} pos
*/
insertAt(node, pos) {
if (pos < 0 || pos > this.children.length) {
throw new Error('Unable to insert node: position is out of child list range');
}
const prev = this.children[pos - 1];
const next = this.children[pos];
node.remove();
node.parent = this;
this.children.splice(pos, 0, node);
if (prev) {
node.previous = prev;
prev.next = node;
}
if (next) {
node.next = next;
next.previous = node;
}
}
/**
* Removes given child from current node
* @param {Node} node
*/
removeChild(node) {
const ix = this.children.indexOf(node);
if (ix !== -1) {
this.children.splice(ix, 1);
if (node.previous) {
node.previous.next = node.next;
}
if (node.next) {
node.next.previous = node.previous;
}
node.parent = node.next = node.previous = null;
}
}
/**
* Removes current node from its parent
*/
remove() {
if (this.parent) {
this.parent.removeChild(this);
}
}
/**
* Creates a detached copy of current node
* @param {Boolean} deep Clone node contents as well
* @return {Node}
*/
clone(deep) {
const clone = new Node(this.name);
clone.value = this.value;
clone.selfClosing = this.selfClosing;
if (this.repeat) {
clone.repeat = node_es__extends({}, this.repeat);
}
this._attributes.forEach(attr => clone.setAttribute(attr.clone()));
if (deep) {
this.children.forEach(child => clone.appendChild(child.clone(true)));
}
return clone;
}
/**
* Walks on each descendant node and invokes given `fn` function on it.
* The function receives two arguments: the node itself and its depth level
* from current node. If function returns `false`, it stops walking
* @param {Function} fn
*/
walk(fn, _level) {
_level = _level || 0;
let ctx = this.firstChild;
while (ctx) {
// in case if context node will be detached during `fn` call
const next = ctx.next;
if (fn(ctx, _level) === false || ctx.walk(fn, _level + 1) === false) {
return false;
}
ctx = next;
}
}
/**
* A helper method for transformation chaining: runs given `fn` function on
* current node and returns the same node
*/
use(fn) {
const args = [this];
for (var i = 1; i < arguments.length; i++) {
args.push(arguments[i]);
}
fn.apply(null, args);
return this;
}
toString() {
const attrs = this.attributes.map(attr => {
attr = this.getAttribute(attr.name);
const opt = attr.options;
let out = `${opt && opt.implied ? '!' : ''}${attr.name || ''}`;
if (opt && opt.boolean) {
out += '.';
} else if (attr.value != null) {
out += `="${attr.value}"`;
}
return out;
});
let out = `${this.name || ''}`;
if (attrs.length) {
out += `[${attrs.join(' ')}]`;
}
if (this.value != null) {
out += `{${this.value}}`;
}
if (this.selfClosing) {
out += '/';
}
if (this.repeat) {
out += `*${this.repeat.count ? this.repeat.count : ''}`;
if (this.repeat.value != null) {
out += `@${this.repeat.value}`;
}
}
return out;
}
};
/**
* Attribute factory
* @param {String|Attribute|Object} name Attribute name or attribute descriptor
* @param {*} value Attribute value
* @return {Attribute}
*/
function createAttribute(name, value) {
if (name instanceof Attribute) {
return name;
}
if (typeof name === 'string') {
return new Attribute(name, value);
}
if (name && typeof name === 'object') {
return new Attribute(name.name, name.value, name.options);
}
}
/**
* @param {String} str
* @return {String}
*/
function normalize(str) {
return String(str).trim();
}
function uniqueClass(item, i, arr) {
return item && arr.indexOf(item) === i;
}
/* harmony default export */ var node_es = (Node);
// CONCATENATED MODULE: ../node_modules/@emmetio/abbreviation/dist/abbreviation.es.js
const ASTERISK = 42; // *
/**
* Consumes node repeat token from current stream position and returns its
* parsed value
* @param {StringReader} stream
* @return {Object}
*/
function consumeRepeat(stream) {
if (stream.eat(ASTERISK)) {
stream.start = stream.pos;
// XXX think about extending repeat syntax with through numbering
return { count: stream.eatWhile(isNumber) ? +stream.current() : null };
}
}
const opt = { throws: true };
/**
* Consumes quoted literal from current stream position and returns it’s inner,
* unquoted, value
* @param {StringReader} stream
* @return {String} Returns `null` if unable to consume quoted value from current
* position
*/
function consumeQuoted(stream) {
if (eatQuoted(stream, opt)) {
return stream.current().slice(1, -1);
}
}
const TEXT_START = 123; // {
const TEXT_END = 125; // }
const abbreviation_es_ESCAPE = 92; // \ character
/**
* Consumes text node `{...}` from stream
* @param {StreamReader} stream
* @return {String} Returns consumed text value (without surrounding braces) or
* `null` if there’s no text at starting position
*/
function consumeText(stream) {
// NB using own implementation instead of `eatPair()` from @emmetio/stream-reader-utils
// to disable quoted value consuming
const start = stream.pos;
if (stream.eat(TEXT_START)) {
let stack = 1,
ch;
let result = '';
let offset = stream.pos;
while (!stream.eof()) {
ch = stream.next();
if (ch === TEXT_START) {
stack++;
} else if (ch === TEXT_END) {
stack--;
if (!stack) {
stream.start = start;
return result + stream.substring(offset, stream.pos - 1);
}
} else if (ch === abbreviation_es_ESCAPE) {
ch = stream.next();
if (ch === TEXT_START || ch === TEXT_END) {
result += stream.substring(offset, stream.pos - 2) + String.fromCharCode(ch);
offset = stream.pos;
}
}
}
// If we’re here then paired character can’t be consumed
stream.pos = start;
throw stream.error(`Unable to find closing ${String.fromCharCode(TEXT_END)} for text start`);
}
return null;
}
const EXCL = 33; // .
const DOT = 46; // .
const abbreviation_es_EQUALS = 61; // =
const ATTR_OPEN = 91; // [
const ATTR_CLOSE = 93; // ]
const reAttributeName = /^\!?[\w\-:\$@]+\.?$/;
/**
* Consumes attributes defined in square braces from given stream.
* Example:
* [attr col=3 title="Quoted string" selected. support={react}]
* @param {StringReader} stream
* @returns {Array} Array of consumed attributes
*/
function consumeAttributes(stream) {
if (!stream.eat(ATTR_OPEN)) {
return null;
}
const result = [];
let token, attr;
while (!stream.eof()) {
stream.eatWhile(isWhiteSpace);
if (stream.eat(ATTR_CLOSE)) {
return result; // End of attribute set
} else if ((token = consumeQuoted(stream)) != null) {
// Consumed quoted value: anonymous attribute
result.push({
name: null,
value: token
});
} else if (eatUnquoted(stream)) {
// Consumed next word: could be either attribute name or unquoted default value
token = stream.current();
if (!reAttributeName.test(token)) {
// anonymous attribute
result.push({ name: null, value: token });
} else {
// Looks like a regular attribute
attr = parseAttributeName(token);
result.push(attr);
if (stream.eat(abbreviation_es_EQUALS)) {
// Explicitly defined value. Could be a word, a quoted string
// or React-like expression
if ((token = consumeQuoted(stream)) != null) {
attr.value = token;
} else if ((token = consumeText(stream)) != null) {
attr.value = token;
attr.options = {
before: '{',
after: '}'
};
} else if (eatUnquoted(stream)) {
attr.value = stream.current();
}
}
}
} else {
throw stream.error('Expected attribute name');
}
}
throw stream.error('Expected closing "]" brace');
}
function parseAttributeName(name) {
const options = {};
// If a first character in attribute name is `!` — it’s an implied
// default attribute
if (name.charCodeAt(0) === EXCL) {
name = name.slice(1);
options.implied = true;
}
// Check for last character: if it’s a `.`, user wants boolean attribute
if (name.charCodeAt(name.length - 1) === DOT) {
name = name.slice(0, name.length - 1);
options.boolean = true;
}
const attr = { name };
if (Object.keys(options).length) {
attr.options = options;
}
return attr;
}
/**
* Eats token that can be an unquoted value from given stream
* @param {StreamReader} stream
* @return {Boolean}
*/
function eatUnquoted(stream) {
const start = stream.pos;
if (stream.eatWhile(isUnquoted)) {
stream.start = start;
return true;
}
}
function isUnquoted(code) {
return !isSpace(code) && !isQuote(code) && code !== ATTR_OPEN && code !== ATTR_CLOSE && code !== abbreviation_es_EQUALS;
}
const HASH = 35; // #
const DOT$1 = 46; // .
const abbreviation_es_SLASH = 47; // /
/**
* Consumes a single element node from current abbreviation stream
* @param {StringReader} stream
* @return {Node}
*/
function consumeElement(stream) {
// consume element name, if provided
const start = stream.pos;
const node = new node_es(eatName(stream));
let next;
while (!stream.eof()) {
if (stream.eat(DOT$1)) {
node.addClass(eatName(stream));
} else if (stream.eat(HASH)) {
node.setAttribute('id', eatName(stream));
} else if (stream.eat(abbreviation_es_SLASH)) {
// A self-closing indicator must be at the end of non-grouping node
if (node.isGroup) {
stream.backUp(1);
throw stream.error('Unexpected self-closing indicator');
}
node.selfClosing = true;
if (next = consumeRepeat(stream)) {
node.repeat = next;
}
break;
} else if (next = consumeAttributes(stream)) {
for (let i = 0, il = next.length; i < il; i++) {
node.setAttribute(next[i]);
}
} else if ((next = consumeText(stream)) !== null) {
node.value = next;
} else if (next = consumeRepeat(stream)) {
node.repeat = next;
} else {
break;
}
}
if (start === stream.pos) {
throw stream.error(`Unable to consume abbreviation node, unexpected ${stream.peek()}`);
}
return node;
}
function eatName(stream) {
stream.start = stream.pos;
stream.eatWhile(isName);
return stream.current();
}
function isName(code) {
return isAlphaNumeric(code) || code === 45 /* - */
|| code === 58 /* : */
|| code === 36 /* $ */
|| code === 64 /* @ */
|| code === 33 /* ! */
|| code === 95 /* _ */
|| code === 37 /* % */;
}
const GROUP_START = 40; // (
const GROUP_END = 41; // )
const OP_SIBLING = 43; // +
const OP_CHILD = 62; // >
const OP_CLIMB = 94; // ^
/**
* Parses given string into a node tree
* @param {String} str Abbreviation to parse
* @return {Node}
*/
function abbreviation_es_parse(str) {
const stream = new stream_reader_es(str.trim());
const root = new node_es();
let ctx = root,
groupStack = [],
ch;
while (!stream.eof()) {
ch = stream.peek();
if (ch === GROUP_START) {
// start of group
// The grouping node should be detached to properly handle
// out-of-bounds `^` operator. Node will be attached right on group end
const node = new node_es();
groupStack.push([node, ctx, stream.pos]);
ctx = node;
stream.next();
continue;
} else if (ch === GROUP_END) {
// end of group
const lastGroup = groupStack.pop();
if (!lastGroup) {
throw stream.error('Unexpected ")" group end');
}
const node = lastGroup[0];
ctx = lastGroup[1];
stream.next();
// a group can have a repeater
if (node.repeat = consumeRepeat(stream)) {
ctx.appendChild(node);
} else {
// move all children of group into parent node
while (node.firstChild) {
ctx.appendChild(node.firstChild);
}
}
// for convenience, groups can be joined with optional `+` operator
stream.eat(OP_SIBLING);
continue;
}
const node = consumeElement(stream);
ctx.appendChild(node);
if (stream.eof()) {
break;
}
switch (stream.peek()) {
case OP_SIBLING:
stream.next();
continue;
case OP_CHILD:
stream.next();
ctx = node;
continue;
case OP_CLIMB:
// it’s perfectly valid to have multiple `^` operators
while (stream.eat(OP_CLIMB)) {
ctx = ctx.parent || ctx;
}
continue;
}
}
if (groupStack.length) {
stream.pos = groupStack.pop()[2];
throw stream.error('Expected group close');
}
return root;
}
/**
* Parses given abbreviation and un-rolls it into a full tree: recursively
* replaces repeated elements with actual nodes
* @param {String} abbr
* @return {Node}
*/
function index(abbr) {
const tree = abbreviation_es_parse(abbr);
tree.walk(unroll);
return tree;
}
function unroll(node) {
if (!node.repeat || !node.repeat.count) {
return;
}
const parent = node.parent;
let ix = parent.children.indexOf(node);
for (let i = 0; i < node.repeat.count; i++) {
const clone = node.clone(true);
clone.repeat.value = i + 1;
clone.walk(unroll);
if (clone.isGroup) {
while (clone.children.length > 0) {
clone.firstChild.repeat = clone.repeat;
parent.insertAt(clone.firstChild, ix++);
}
} else {
parent.insertAt(clone, ix++);
}
}
node.parent.removeChild(node);
}
/* harmony default export */ var abbreviation_es = (index);
//# sourceMappingURL=abbreviation.es.js.map
// CONCATENATED MODULE: ../node_modules/@emmetio/html-snippets-resolver/dist/html-snippets-resolver.es.js
var html_snippets_resolver_es__extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
/**
* For every node in given `tree`, finds matching snippet from `registry` and
* resolves it into a parsed abbreviation. Resolved node is then updated or
* replaced with matched abbreviation tree.
*
* A HTML registry basically contains aliases to another Emmet abbreviations,
* e.g. a predefined set of name, attribues and so on, possibly a complex
* abbreviation with multiple elements. So we have to get snippet, parse it
* and recursively resolve it.
*
* @param {Node} tree Parsed Emmet abbreviation
* @param {SnippetsRegistry} registry Registry with all available snippets
* @return {Node} Updated tree
*/
var html_snippets_resolver_es_index = function (tree, registry) {
tree.walk(node => resolveNode(node, registry));
return tree;
};
function resolveNode(node, registry) {
const stack = new Set();
const resolve = node => {
const snippet = registry.resolve(node.name);
// A snippet in stack means circular reference.
// It can be either a user error or a perfectly valid snippet like
// "img": "img[src alt]/", e.g. an element with predefined shape.
// In any case, simply stop parsing and keep element as is
if (!snippet || stack.has(snippet)) {
return;
}
// In case if matched snippet is a function, pass control into it
if (typeof snippet.value === 'function') {
return snippet.value(node, registry, resolve);
}
const tree = abbreviation_es(snippet.value);
stack.add(snippet);
tree.walk(resolve);
stack.delete(snippet);
// move current node contents into new tree
const childTarget = findDeepestNode(tree);
merge(childTarget, node);
while (tree.firstChild) {
node.parent.insertBefore(tree.firstChild, node);
}
childTarget.parent.insertBefore(node, childTarget);
childTarget.remove();
};
resolve(node);
}
/**
* Adds data from first node into second node and returns it
* @param {Node} from
* @param {Node} to
* @return {Node}
*/
function merge(from, to) {
to.name = from.name;
if (from.selfClosing) {
to.selfClosing = true;
}
if (from.value != null) {
to.value = from.value;
}
if (from.repeat) {
to.repeat = html_snippets_resolver_es__extends({}, from.repeat);
}
return mergeAttributes(from, to);
}
/**
* Transfer attributes from first element to second one and preserve first
* element’s attributes order
* @param {Node} from
* @param {Node} to
* @return {Node}
*/
function mergeAttributes(from, to) {
mergeClassNames(from, to);
// It’s important to preserve attributes order: ones in `from` have higher
// pripority than in `to`. Collect attributes in map in order they should
// appear in `to`
const attrMap = new Map();
let attrs = from.attributes;
for (let i = 0; i < attrs.length; i++) {
attrMap.set(attrs[i].name, attrs[i].clone());
}
attrs = to.attributes.slice();
for (let i = 0, attr, a; i < attrs.length; i++) {
attr = attrs[i];
if (attrMap.has(attr.name)) {
a = attrMap.get(attr.name);
a.value = attr.value;
// If user explicitly wrote attribute in abbreviation, it’s no longer
// implied and should be outputted even if value is empty
if (a.options.implied) {
a.options.implied = false;
}
} else {
attrMap.set(attr.name, attr);
}
to.removeAttribute(attr);
}
const newAttrs = Array.from(attrMap.values());
for (let i = 0; i < newAttrs.length; i++) {
to.setAttribute(newAttrs[i]);
}
return to;
}
/**
* Adds class names from first node to second one
* @param {Node} from
* @param {Node} to
* @return {Node}
*/
function mergeClassNames(from, to) {
const classNames = from.classList;
for (let i = 0; i < classNames.length; i++) {
to.addClass(classNames[i]);
}
return to;
}
/**
* Finds node which is the deepest for in current node or node iteself.
* @param {Node} node
* @return {Node}
*/
function findDeepestNode(node) {
while (node.children.length) {
node = node.children[node.children.length - 1];
}
return node;
}
/* harmony default export */ var html_snippets_resolver_es = (html_snippets_resolver_es_index);
// CONCATENATED MODULE: ../node_modules/@emmetio/implicit-tag/dist/implicit-tag.es.js
const inlineElements = new Set('a,abbr,acronym,applet,b,basefont,bdo,big,br,button,cite,code,del,dfn,em,font,i,iframe,img,input,ins,kbd,label,map,object,q,s,samp,select,small,span,strike,strong,sub,sup,textarea,tt,u,var'.split(','));
const elementMap = {
p: 'span',
ul: 'li',
ol: 'li',
table: 'tr',
tr: 'td',
tbody: 'tr',
thead: 'tr',
tfoot: 'tr',
colgroup: 'col',
select: 'option',
optgroup: 'option',
audio: 'source',
video: 'source',
object: 'param',
map: 'area'
};
/**
* Returns best child node name for given parent node name
* @param {String} parentName Name of parent node
* @return {String}
*/
function resolveImplicitName(parentName) {
parentName = (parentName || '').toLowerCase();
return elementMap[parentName] || (inlineElements.has(parentName) ? 'span' : 'div');
}
/* harmony default export */ var implicit_tag_es = (resolveImplicitName);
// CONCATENATED MODULE: ../node_modules/@emmetio/html-transform/dist/html-transform.es.js
var html_transform_es__extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
/**
* Adds missing tag names for given tree depending on node’s parent name
*/
var implicitTags = function (tree) {
tree.walk(node => {
// resolve only nameless nodes without content
if (node.name == null && node.attributes.length) {
node.name = implicit_tag_es(node.parent.name);
}
});
return tree;
};
/**
* Locates all occurances of given `token` which are not escaped (e.g. are not
* preceded with `\`) given in `str`
* @param {String} str
* @return {Array} Array of token ranges
*/
function findUnescapedTokens(str, token) {
const result = new Set();
const tlen = token.length;
// 1. Find all occurances of tokens
let pos = 0;
while ((pos = str.indexOf(token, pos)) !== -1) {
result.add(pos);
pos += tlen;
}
if (result.size) {
// 2. Remove ones that escaped
let pos = 0;
const len = str.length;
while (pos < len) {
if (str[pos++] === '\\') {
result.delete(pos++);
}
}
}
return Array.from(result).map(ix => html_transform_es_range(ix, tlen));
}
/**
* Replaces `ranges`, generated by `range()` function, with given `value` in `str`
* @param {String} str Where to replace ranges
* @param {Array} ranges Ranes, created by `range()` function
* @param {String|Function} value Replacement value. If it’s a function, it
* will take a range value as argument and should return a new string
* @return {String}
*/
function replaceRanges(str, ranges, value) {
// should walk from the end of array to keep ranges valid after replacement
for (let i = ranges.length - 1; i >= 0; i--) {
const r = ranges[i];
let offset = 0;
let offsetLength = 0;
let descendingOrder = false;
if (str.substr(r[0] + r[1], 1) === '@') {
if (str.substr(r[0] + r[1] + 1, 1) === '-') {
descendingOrder = true;
}
const matches = str.substr(r[0] + r[1] + 1 + Number(descendingOrder)).match(/^(\d+)/);
if (matches) {
offsetLength = matches[1].length + 1 + Number(descendingOrder);
offset = parseInt(matches[1]) - 1;
} else {
offsetLength = 2;
}
}
str = str.substring(0, r[0]) + (typeof value === 'function' ? value(str.substr(r[0], r[1]), offset, descendingOrder) : value) + str.substring(r[0] + r[1] + offsetLength);
}
return str;
}
function html_transform_es_range(start, length) {
return [start, length];
}
const numberingToken = '$';
/**
* Numbering of expanded abbreviation: finds all nodes with `$` in value
* or attributes and replaces its occurances with repeater value
*/
var applyNumbering = function (tree) {
tree.walk(applyNumbering$1);
return tree;
};
/**
* Applies numbering for given node: replaces occurances of numbering token
* in node’s name, content and attributes
* @param {Node} node
* @return {Node}
*/
function applyNumbering$1(node) {
const repeater = findRepeater(node);
if (repeater && repeater.value != null) {
// NB replace numbering in nodes with explicit repeater only:
// it solves issues with abbreviations like `xsl:if[test=$foo]` where
// `$foo` is preferred output
const value = repeater.value;
const count = repeater.count;
node.name = replaceNumbering(node.name, value, count);
node.value = replaceNumbering(node.value, value, count);
node.attributes.forEach(attr => {
const copy = node.getAttribute(attr.name).clone();
copy.name = replaceNumbering(attr.name, value, count);
copy.value = replaceNumbering(attr.value, value, count);
node.replaceAttribute(attr.name, copy);
});
}
return node;
}
/**
* Returns repeater object for given node
* @param {Node} node
* @return {Object}
*/
function findRepeater(node) {
while (node) {
if (node.repeat) {
return node.repeat;
}
node = node.parent;
}
}
/**
* Replaces numbering in given string
* @param {String} str
* @param {Number} value
* @return {String}
*/
function replaceNumbering(str, value, count) {
// replace numbering in strings only: skip explicit wrappers that could
// contain unescaped numbering tokens
if (typeof str === 'string') {
const ranges = getNumberingRanges(str);
return replaceNumberingRanges(str, ranges, value, count);
}
return str;
}
/**
* Returns numbering ranges, e.g. ranges of `$` occurances, in given string.
* Multiple adjacent ranges are combined
* @param {String} str
* @return {Array}
*/
function getNumberingRanges(str) {
return findUnescapedTokens(str || '', numberingToken).reduce((out, range$$1) => {
// skip ranges that actually belongs to output placeholder or tabstops
if (!/[#{]/.test(str[range$$1[0] + 1] || '')) {
const lastRange = out[out.length - 1];
if (lastRange && lastRange[0] + lastRange[1] === range$$1[0]) {
lastRange[1] += range$$1[1];
} else {
out.push(range$$1);
}
}
return out;
}, []);
}
/**
* @param {String} str
* @param {Array} ranges
* @param {Number} value
* @return {String}
*/
function replaceNumberingRanges(str, ranges, value, count) {
const replaced = replaceRanges(str, ranges, (token, offset, descendingOrder) => {
let _value = descendingOrder ? String(offset + count - value + 1) : String(value + offset);
// pad values for multiple numbering tokens, e.g. 3 for $$$ becomes 003
while (_value.length < token.length) {
_value = '0' + _value;
}
return _value;
});
// unescape screened numbering tokens
return unescapeString(replaced);
}
/**
* Unescapes characters, screened with `\`, in given string
* @param {String} str
* @return {String}
*/
function unescapeString(str) {
let i = 0,
result = '';
const len = str.length;
while (i < len) {
const ch = str[i++];
result += ch === '\\' ? str[i++] || '' : ch;
}
return result;
}
/** Placeholder for inserted content */
const placeholder = '$#';
/** Placeholder for caret */
const caret = '|';
const reUrl = /^((?:https?|ftp|file):\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$/;
const reEmail = /^([a-z0-9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6})$/;
const reProto = /^([a-z]+:)?\/\//i;
/**
* Inserts content into node with implicit repeat count: this node is then
* duplicated for each content item and content itself is inserted either into
* deepest child or instead of a special token.
*
* This method uses two distinct steps: `prepare()` and `insert()` since most
* likely these steps will be used separately to properly insert content
* with unescaped `$` numbering markers.
*
* @param {Node} tree Parsed abbreviation
* @param {String[]} content Array of content items to insert
* @return {Node}
*/
/**
* Finds nodes with implicit repeat and creates `amount` copies of it in tree
* @param {Node} tree
* @param {Number} amount
* @return {Node}
*/
function prepare(tree, amount) {
amount = amount || 1;
tree.walk(node => {
if (node.repeat && node.repeat.count === null) {
for (let i = 0; i < amount; i++) {
const clone = node.clone(true);
clone.repeat.implicit = true;
clone.repeat.count = amount;
clone.repeat.value = i + 1;
clone.repeat.index = i;
node.parent.insertBefore(clone, node);
}
node.remove();
}
});
return tree;
}
/**
* Inserts content into implicitly repeated nodes, created by `prepare()` method
* @param {Node} tree
* @param {String[]} content
* @return {Node}
*/
function insert(tree, content) {
if (Array.isArray(content) && content.length) {
let updated = false;
tree.walk(node => {
if (node.repeat && node.repeat.implicit) {
updated = true;
insertContent(node, content[node.repeat.index]);
}
});
if (!updated) {
// no node with implicit repeat was found, insert content as
// deepest child
setNodeContent(html_transform_es_findDeepestNode(tree), content.join('\n'));
}
}
return tree;
}
/**
* Inserts `content` into given `node`: either replaces output placeholders
* or inserts it into deepest child node
* @param {Node} node
* @param {String} content
* @return {Node}
*/
function insertContent(node, content) {
let inserted = insertContentIntoPlaceholder(node, content);
node.walk(child => inserted |= insertContentIntoPlaceholder(child, content));
if (!inserted) {
// no placeholders were found in node, insert content into deepest child
setNodeContent(html_transform_es_findDeepestNode(node), content);
}
return node;
}
/**
* Inserts given `content` into placeholders for given `node`. Placeholders
* might be available in attribute values and node content
* @param {Node} node
* @param {String} content
* @return {Boolean} Returns `true` if placeholders were found and replaced in node
*/
function insertContentIntoPlaceholder(node, content) {
const state = { replaced: false };
node.value = replacePlaceholder(node.value, content, state);
node.attributes.forEach(attr => {
if (attr.value) {
node.setAttribute(attr.name, replacePlaceholder(attr.value, content, state));
}
});
return state.replaced;
}
/**
* Replaces all placeholder occurances in given `str` with `value`
* @param {String} str
* @param {String} value
* @param {Object} [_state] If provided, set `replaced` property of given
* object to `true` if placeholder was found and replaced
* @return {String}
*/
function replacePlaceholder(str, value, _state) {
if (typeof str === 'string') {
const ranges = findUnescapedTokens(str, placeholder);
if (ranges.length) {
if (_state) {
_state.replaced = true;
}
str = replaceRanges(str, ranges, value);
}
}
return str;
}
/**
* Finds node which is the deepest for in current node or node iteself.
* @param {Node} node
* @return {Node}
*/
function html_transform_es_findDeepestNode(node) {
while (node.children.length) {
node = node.children[node.children.length - 1];
}
return node;
}
/**
* Updates content of given node
* @param {Node} node
* @param {String} content
*/
function setNodeContent(node, content) {
// find caret position and replace it with content, if possible
if (node.value) {
const ranges = findUnescapedTokens(node.value, caret);
if (ranges.length) {
node.value = replaceRanges(node.value, ranges, content);
return;
}
}
if (node.name.toLowerCase() === 'a' || node.hasAttribute('href')) {
// special case: inserting content into `` tag
if (reUrl.test(content)) {
node.setAttribute('href', (reProto.test(content) ? '' : 'http://') + content);
} else if (reEmail.test(content)) {
node.setAttribute('href', 'mailto:' + content);
}
}
node.value = content;
}
const html_transform_es_defaultOptions = {
element: '__',
modifier: '_'
};
const reElement = /^(-+)([a-z0-9]+[a-z0-9-]*)/i;
const reModifier = /^(_+)([a-z0-9]+[a-z0-9-_]*)/i;
const blockCandidates1 = className => /^[a-z]\-/i.test(className);
const blockCandidates2 = className => /^[a-z]/i.test(className);
/**
* BEM transformer: updates class names written as `-element` and
* `_modifier` into full class names as described in BEM specs. Also adds missing
* class names: fir example, if node contains `.block_modifier` class, ensures
* that element contains `.block` class as well
*/
var bem = function (tree, options) {
options = html_transform_es__extends({}, html_transform_es_defaultOptions, options);
tree.walk(node => expandClassNames(node, options));
const lookup = createBlockLookup(tree);
tree.walk(node => expandShortNotation(node, lookup, options));
return tree;
};
/**
* Expands existing class names in BEM notation in given `node`.
* For example, if node contains `b__el_mod` class name, this method ensures
* that element contains `b__el` class as well
* @param {Node} node
* @param {Object} options
* @return {Set}
*/
function expandClassNames(node, options) {
const classNames = node.classList.reduce((out, cl) => {
// remove all modifiers and element prefixes from class name to get a base element name
const ix = cl.indexOf('_');
if (ix > 0 && !cl.startsWith('-')) {
out.add(cl.slice(0, ix));
out.add(cl.slice(ix));
return out;
}
return out.add(cl);
}, new Set());
if (classNames.size) {
node.setAttribute('class', Array.from(classNames).join(' '));
}
}
/**
* Expands short BEM notation, e.g. `-element` and `_modifier`
* @param {Node} node Parsed Emmet abbreviation node
* @param {Map} lookup BEM block name lookup
* @param {Object} options
*/
function expandShortNotation(node, lookup, options) {
const classNames = node.classList.reduce((out, cl) => {
let prefix, m;
const originalClass = cl;
// parse element definition (could be only one)
if (m = cl.match(reElement)) {
prefix = getBlockName(node, lookup, m[1]) + options.element + m[2];
out.add(prefix);
cl = cl.slice(m[0].length);
}
// parse modifiers definitions
if (m = cl.match(reModifier)) {
if (!prefix) {
prefix = getBlockName(node, lookup, m[1]);
out.add(prefix);
}
out.add(`${prefix}${options.modifier}${m[2]}`);
cl = cl.slice(m[0].length);
}
if (cl === originalClass) {
// class name wasn’t modified: it’s not a BEM-specific class,
// add it as-is into output
out.add(originalClass);
}
return out;
}, new Set());
const arrClassNames = Array.from(classNames).filter(Boolean);
if (arrClassNames.length) {
node.setAttribute('class', arrClassNames.join(' '));
}
}
/**
* Creates block name lookup for each node in given tree, e.g. finds block
* name explicitly for each node
* @param {Node} tree
* @return {Map}
*/
function createBlockLookup(tree) {
const lookup = new Map();
tree.walk(node => {
const classNames = node.classList;
if (classNames.length) {
// guess best block name from class or use parent’s block name
lookup.set(node, find(classNames, blockCandidates1) || find(classNames, blockCandidates2) || lookup.get(node.parent));
}
});
return lookup;
}
/**
* Returns block name for given `node` by `prefix`, which tells the depth of
* of parent node lookup
* @param {Node} node
* @param {Map} lookup
* @param {String} prefix
* @return {String}
*/
function getBlockName(node, lookup, prefix) {
let depth = prefix.length > 1 ? prefix.length : 0;
// NB don’t walk up to root node, stay at first root child in case of
// too deep prefix
while (node.parent && node.parent.parent && depth--) {
node = node.parent;
}
return lookup.get(node) || '';
}
function find(arr, filter) {
for (let i = 0; i < arr.length; i++) {
if (reElement.test(arr[i]) || reModifier.test(arr[i])) {
break;
}
if (filter(arr[i])) {
return arr[i];
}
}
}
/**
* JSX transformer: replaces `class` and `for` attributes with `className` and
* `htmlFor` attributes respectively
*/
var jsx = function (tree) {
tree.walk(node => {
replace(node, 'class', 'className');
replace(node, 'for', 'htmlFor');
});
return tree;
};
function replace(node, oldName, newName) {
let attr = node.getAttribute(oldName);
if (attr) {
attr.name = newName;
}
}
const reSupporterNames = /^xsl:(variable|with\-param)$/i;
/**
* XSL transformer: removes `select` attributes from certain nodes that contain
* children
*/
var xsl = function (tree) {
tree.walk(node => {
if (reSupporterNames.test(node.name || '') && (node.children.length || node.value)) {
node.removeAttribute('select');
}
});
return tree;
};
const supportedAddons = { bem, jsx, xsl };
/**
* Runs additional transforms on given tree.
* These transforms may introduce side-effects and unexpected result
* so they are not applied by default, authors must specify which addons
* in `addons` argument as `{addonName: addonOptions}`
* @param {Node} tree Parsed Emmet abbreviation
* @param {Object} addons Add-ons to apply and their options
*/
var addons = function (tree, addons) {
Object.keys(addons || {}).forEach(key => {
if (key in supportedAddons) {
const addonOpt = typeof addons[key] === 'object' ? addons[key] : null;
tree = tree.use(supportedAddons[key], addonOpt);
}
});
return tree;
};
/**
* Applies basic HTML-specific transformations for given parsed abbreviation:
* – resolve implied tag names
* – insert repeated content
* – resolve node numbering
*/
var html_transform_es_index = function (tree, content, appliedAddons) {
if (typeof content === 'string') {
content = [content];
} else if (content && typeof content === 'object' && !Array.isArray(content)) {
appliedAddons = content;
content = null;
}
return tree.use(implicitTags).use(prepare, Array.isArray(content) ? content.length : null).use(applyNumbering).use(insert, content).use(addons, appliedAddons);
};
/* harmony default export */ var html_transform_es = (html_transform_es_index);
// CONCATENATED MODULE: ../node_modules/@emmetio/variable-resolver/dist/variable-resolver.es.js
/**
* Replaces all unescaped ${variable} occurances in given parsed abbreviation
* `tree` with values provided in `variables` hash. Precede `$` with `\` to
* escape it and skip replacement
* @param {Node} tree Parsed abbreviation tree
* @param {Object} variables Variables values
* @return {Node}
*/
function replaceVariables(tree, variables) {
variables = variables || {};
tree.walk(node => replaceInNode(node, variables));
return tree;
}
function replaceInNode(node, variables) {
// Replace variables in attributes.
const attrs = node.attributes;
for (let i = 0, il = attrs.length; i < il; i++) {
const attr = attrs[i];
if (typeof attr.value === 'string') {
node.setAttribute(attr.name, replaceInString(attr.value, variables));
}
}
if (node.value != null) {
node.value = replaceInString(node.value, variables);
}
return node;
}
/**
* Replaces all unescaped `${variable}` occurances in given string with values
* from `variables` object
* @param {String} string
* @param {Object} variables
* @return {String}
*/
function replaceInString(string, variables) {
const model = createModel(string);
let offset = 0;
let output = '';
for (let i = 0, il = model.variables.length; i < il; i++) {
const v = model.variables[i];
let value = v.name in variables ? variables[v.name] : v.name;
if (typeof value === 'function') {
value = value(model.string, v, offset + v.location);
}
output += model.string.slice(offset, v.location) + value;
offset = v.location + v.length;
}
return output + model.string.slice(offset);
}
/**
* Creates variable model from given string. The model contains a `string` with
* all escaped variable tokens written without escape symbol and `variables`
* property with all unescaped variables and their ranges
* @param {String} string
* @return {Object}
*/
function createModel(string) {
const reVariable = /\$\{([a-z][\w\-]*)\}/ig;
const escapeCharCode = 92; // `\` symbol
const variables = [];
// We have to replace unescaped (e.g. not preceded with `\`) tokens.
// Instead of writing a stream parser, we’ll cut some edges here:
// 1. Find all tokens
// 2. Walk string char-by-char and resolve only tokens that are not escaped
const tokens = new Map();
let m;
while (m = reVariable.exec(string)) {
tokens.set(m.index, m);
}
if (tokens.size) {
let start = 0,
pos = 0,
len = string.length;
let output = '';
while (pos < len) {
if (string.charCodeAt(pos) === escapeCharCode && tokens.has(pos + 1)) {
// Found escape symbol that escapes variable: we should
// omit this symbol in output string and skip variable
const token = tokens.get(pos + 1);
output += string.slice(start, pos) + token[0];
start = pos = token.index + token[0].length;
tokens.delete(pos + 1);
continue;
}
pos++;
}
string = output + string.slice(start);
// Not using `.map()` here to reduce memory allocations
const validMatches = Array.from(tokens.values());
for (let i = 0, il = validMatches.length; i < il; i++) {
const token = validMatches[i];
variables.push({
name: token[1],
location: token.index,
length: token[0].length
});
}
}
return { string, variables };
}
/* harmony default export */ var variable_resolver_es = (replaceVariables);
// CONCATENATED MODULE: ../node_modules/@emmetio/output-renderer/dist/output-renderer.es.js
var output_renderer_es__extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
const defaultFieldsRenderer = text => text;
/**
* Output node is an object containing generated output for given Emmet
* abbreviation node. Output node can be passed to various processors that
* may shape-up final node output. The final output is simply a concatenation
* of `.open`, `.text` and `.close` properties and its `.before*` and `.after*`
* satellites
* @param {Node} node Parsed Emmet abbreviation node
* @param {Function} fieldsRenderer A function for rendering fielded text (text with
* tabstops) for current node. @see ./render.js for details
*/
let OutputNode = class OutputNode {
constructor(node, fieldsRenderer, options) {
if (typeof fieldsRenderer === 'object') {
options = fieldsRenderer;
fieldsRenderer = null;
}
this.node = node;
this._fieldsRenderer = fieldsRenderer || defaultFieldsRenderer;
this.open = null;
this.beforeOpen = '';
this.afterOpen = '';
this.close = null;
this.beforeClose = '';
this.afterClose = '';
this.text = null;
this.beforeText = '';
this.afterText = '';
this.indent = '';
this.newline = '';
if (options) {
output_renderer_es__extends(this, options);
}
}
clone() {
return new this.constructor(this.node, this);
}
/**
* Properly indents given multiline text
* @param {String} text
*/
indentText(text) {
const lines = splitByLines(text);
if (lines.length === 1) {
// no newlines, nothing to indent
return text;
}
// No newline and no indent means no formatting at all:
// in this case we should replace newlines with spaces
const nl = !this.newline && !this.indent ? ' ' : this.newline;
return lines.map((line, i) => i ? this.indent + line : line).join(nl);
}
/**
* Renders given text with fields
* @param {String} text
* @return {String}
*/
renderFields(text) {
return this._fieldsRenderer(text);
}
toString(children) {
const open = this._wrap(this.open, this.beforeOpen, this.afterOpen);
const close = this._wrap(this.close, this.beforeClose, this.afterClose);
const text = this._wrap(this.text, this.beforeText, this.afterText);
return open + text + (children != null ? children : '') + close;
}
_wrap(str, before, after) {
before = before != null ? before : '';
after = after != null ? after : '';
// automatically trim whitespace for non-empty wraps
if (str != null) {
str = before ? str.replace(/^\s+/, '') : str;
str = after ? str.replace(/\s+$/, '') : str;
return before + this.indentText(str) + after;
}
return '';
}
};
/**
* Splits given text by lines
* @param {String} text
* @return {String[]}
*/
function splitByLines(text) {
return (text || '').split(/\r\n|\r|\n/g);
}
/**
* Default output of field (tabstop)
* @param {Number} index Field index
* @param {String} placeholder Field placeholder, can be null
* @return {String}
*/
const defaultField = (index, placeholder) => placeholder || '';
/**
* Renders given parsed abbreviation `tree` via `formatter` function.
* @param {Node} tree Parsed Emmet abbreviation
* @param {Function} [field] Optional function to format field/tabstop (@see `defaultField`)
* @param {Function} formatter Output formatter function. It takes an output node—
* a special wrapper for parsed node that holds formatting and output properties—
* and updates its output properties to shape-up node’s output.
* Function arguments:
* – `outNode`: OutputNode
* – `renderFields`: a helper function that parses fields/tabstops from given
* text and replaces them with `field` function output.
* It also takes care about field indicies and ensures that the same indicies
* from different nodes won’t collide
*/
function render(tree, field, formatter) {
if (typeof formatter === 'undefined') {
formatter = field;
field = null;
}
field = field || defaultField;
// Each node may contain fields like `${1:placeholder}`.
// Since most modern editors will link all fields with the same
// index, we have to ensure that different nodes has their own indicies.
// We’ll use this `fieldState` object to globally increment field indices
// during output
const fieldState = { index: 1 };
const fieldsRenderer = text => text == null ? field(fieldState.index++) : getFieldsModel(text, fieldState).mark(field);
return run(tree.children, formatter, fieldsRenderer);
}
function run(nodes, formatter, fieldsRenderer) {
return nodes.map(node => {
const outNode = formatter(new OutputNode(node, fieldsRenderer));
return outNode ? outNode.toString(run(node.children, formatter, fieldsRenderer)) : '';
}).join('');
}
/**
* Returns fields (tab-stops) model with properly updated indices that won’t
* collide with fields in other nodes of foprmatted tree
* @param {String|Object} text Text to get fields model from or model itself
* @param {Object} fieldState Abbreviation tree-wide field state reference
* @return {Object} Field model
*/
function getFieldsModel(text, fieldState) {
const model = typeof text === 'object' ? text : field_parser_es(text);
let largestIndex = -1;
model.fields.forEach(field => {
field.index += fieldState.index;
if (field.index > largestIndex) {
largestIndex = field.index;
}
});
if (largestIndex !== -1) {
fieldState.index = largestIndex + 1;
}
return model;
}
/* harmony default export */ var output_renderer_es = (render);
// CONCATENATED MODULE: ../node_modules/@emmetio/markup-formatters/dist/markup-formatters.es.js
var markup_formatters_es__extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
const TOKEN = /^(.*?)([A-Z_]+)(.*?)$/;
const TOKEN_OPEN = 91; // [
const TOKEN_CLOSE = 93; // ]
/**
* A basic templating engine.
* Takes every `[TOKEN]` from given string and replaces it with
* `TOKEN` value from given `data` attribute. The token itself may contain
* various characters between `[`, token name and `]`. Contents of `[...]` will
* be outputted only if `TOKEN` value is not empty. Also, only `TOKEN` name will
* be replaced with actual value, all other characters will remain as is.
*
* Example:
* ```
* template('[from and to values
* @param {Number} from
* @param {Number} to
* @returns {Number}
*/
function rand(from, to) {
return Math.floor(Math.random() * (to - from) + from);
}
/**
* @param {Array} arr
* @param {Number} count
* @returns {Array}
*/
function sample(arr, count) {
const len = arr.length;
const iterations = Math.min(len, count);
const result = new Set();
while (result.size < iterations) {
result.add(arr[rand(0, len)]);
}
return Array.from(result);
}
function choice(val) {
return val[rand(0, val.length - 1)];
}
function sentence(words, end) {
if (words.length) {
words = [capitalize(words[0])].concat(words.slice(1));
}
return words.join(' ') + (end || choice('?!...')); // more dots than question marks
}
function capitalize(word) {
return word[0].toUpperCase() + word.slice(1);
}
/**
* Insert commas at randomly selected words. This function modifies values
* inside words array
* @param {Array} words
*/
function insertCommas(words) {
if (words.length < 2) {
return words;
}
words = words.slice();
const len = words.length;
const hasComma = /,$/;
let totalCommas = 0;
if (len > 3 && len <= 6) {
totalCommas = rand(0, 1);
} else if (len > 6 && len <= 12) {
totalCommas = rand(0, 2);
} else {
totalCommas = rand(1, 4);
}
for (let i = 0, pos, word; i < totalCommas; i++) {
pos = rand(0, len - 2);
if (!hasComma.test(words[pos])) {
words[pos] += ',';
}
}
return words;
}
/**
* Generate a paragraph of "Lorem ipsum" text
* @param {Object} dict Words dictionary (see `lang/*.json`)
* @param {Number} wordCount Words count in paragraph
* @param {Boolean} startWithCommon Should paragraph start with common
* "lorem ipsum" sentence.
* @returns {String}
*/
function paragraph(dict, wordCount, startWithCommon) {
const result = [];
let totalWords = 0;
let words;
if (startWithCommon && dict.common) {
words = dict.common.slice(0, wordCount);
totalWords += words.length;
result.push(sentence(insertCommas(words), '.'));
}
while (totalWords < wordCount) {
words = sample(dict.words, Math.min(rand(2, 30), wordCount - totalWords));
totalWords += words.length;
result.push(sentence(insertCommas(words)));
}
return result.join(' ');
}
/**
* Check if given node is in repeating context, e.g. node itself or one of its
* parent is repeated
* @param {Node} node
* @return {Boolean}
*/
function isRepeating(node) {
while (node.parent) {
if (node.repeat && node.repeat.value && node.repeat.value > 1) {
return true;
}
node = node.parent;
}
return false;
}
/* harmony default export */ var lorem_es = (lorem_es_index);
// CONCATENATED MODULE: ../node_modules/@emmetio/snippets-registry/dist/snippets-registry.es.js
let Snippet = class Snippet {
constructor(key, value) {
this.key = key;
this.value = value;
}
};
let SnippetsStorage = class SnippetsStorage {
constructor(data) {
this._string = new Map();
this._regexp = new Map();
this._disabled = false;
this.load(data);
}
get disabled() {
return this._disabled;
}
/**
* Disables current store. A disabled store always returns `undefined`
* on `get()` method
*/
disable() {
this._disabled = true;
}
/**
* Enables current store.
*/
enable() {
this._disabled = false;
}
/**
* Registers a new snippet item
* @param {String|Regexp} key
* @param {String|Function} value
*/
set(key, value) {
if (typeof key === 'string') {
key.split('|').forEach(k => this._string.set(k, new Snippet(k, value)));
} else if (key instanceof RegExp) {
this._regexp.set(key, new Snippet(key, value));
} else {
throw new Error('Unknow snippet key: ' + key);
}
return this;
}
/**
* Returns a snippet matching given key. It first tries to find snippet
* exact match in a string key map, then tries to match one with regexp key
* @param {String} key
* @return {Snippet}
*/
get(key) {
if (this.disabled) {
return undefined;
}
if (this._string.has(key)) {
return this._string.get(key);
}
const keys = Array.from(this._regexp.keys());
for (let i = 0, il = keys.length; i < il; i++) {
if (keys[i].test(key)) {
return this._regexp.get(keys[i]);
}
}
}
/**
* Batch load of snippets data
* @param {Object|Map} data
*/
load(data) {
this.reset();
if (data instanceof Map) {
data.forEach((value, key) => this.set(key, value));
} else if (data && typeof data === 'object') {
Object.keys(data).forEach(key => this.set(key, data[key]));
}
}
/**
* Clears all stored snippets
*/
reset() {
this._string.clear();
this._regexp.clear();
}
/**
* Returns all available snippets from given store
*/
values() {
if (this.disabled) {
return [];
}
const string = Array.from(this._string.values());
const regexp = Array.from(this._regexp.values());
return string.concat(regexp);
}
};
/**
* A snippets registry. Contains snippets, separated by store and sorted by
* priority: a store with higher priority takes precedence when resolving snippet
* for given key
*/
let SnippetsRegistry = class SnippetsRegistry {
/**
* Creates snippets registry, filled with given `data`
* @param {Object|Array} data Registry snippets. If array is given, adds items
* from array in order of precedence, registers global snippets otherwise
*/
constructor(data) {
this._registry = [];
if (Array.isArray(data)) {
data.forEach((snippets, level) => this.add(level, snippets));
} else if (typeof data === 'object') {
this.add(data);
}
}
/**
* Return store for given level
* @param {Number} level
* @return {SnippetsStorage}
*/
get(level) {
for (let i = 0; i < this._registry.length; i++) {
const item = this._registry[i];
if (item.level === level) {
return item.store;
}
}
}
/**
* Adds new store for given level
* @param {Number} [level] Store level (priority). Store with higher level
* takes precedence when resolving snippets
* @param {Object} [snippets] A snippets data for new store
* @return {SnipetsStorage}
*/
add(level, snippets) {
if (level != null && typeof level === 'object') {
snippets = level;
level = 0;
}
const store = new SnippetsStorage(snippets);
// remove previous store from same level
this.remove(level);
this._registry.push({ level, store });
this._registry.sort((a, b) => b.level - a.level);
return store;
}
/**
* Remove registry with given level or store
* @param {Number|SnippetsStorage} data Either level or snippets store
*/
remove(data) {
this._registry = this._registry.filter(item => item.level !== data && item.store !== data);
}
/**
* Returns snippet from registry that matches given name
* @param {String} name
* @return {Snippet}
*/
resolve(name) {
for (let i = 0; i < this._registry.length; i++) {
const snippet = this._registry[i].store.get(name);
if (snippet) {
return snippet;
}
}
}
/**
* Returns all available snippets from current registry. Snippets with the
* same key are resolved by their storage priority.
* @param {Object} options
* @param {Object} options.type Return snippets only of given type: 'string'
* or 'regexp'. Returns all snippets if not defined
* @return {Array}
*/
all(options) {
options = options || {};
const result = new Map();
const fillResult = snippet => {
const type = snippet.key instanceof RegExp ? 'regexp' : 'string';
if ((!options.type || options.type === type) && !result.has(snippet.key)) {
result.set(snippet.key, snippet);
}
};
this._registry.forEach(item => {
item.store.values().forEach(fillResult);
});
return Array.from(result.values());
}
/**
* Removes all stores from registry
*/
clear() {
this._registry.length = 0;
}
};
/* harmony default export */ var snippets_registry_es = (SnippetsRegistry);
// CONCATENATED MODULE: ../node_modules/@emmetio/output-profile/dist/output-profile.es.js
var output_profile_es__extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
/**
* @type {EmmetOutputProfile}
*/
var output_profile_es_defaultOptions = {
indent: '\t',
tagCase: '',
attributeCase: '',
attributeQuotes: 'double',
format: true,
formatSkip: ['html'],
formatForce: ['body'],
inlineBreak: 3,
compactBooleanAttributes: false,
booleanAttributes: ['contenteditable', 'seamless', 'async', 'autofocus', 'autoplay', 'checked', 'controls', 'defer', 'disabled', 'formnovalidate', 'hidden', 'ismap', 'loop', 'multiple', 'muted', 'novalidate', 'readonly', 'required', 'reversed', 'selected', 'typemustmatch'],
selfClosingStyle: 'html',
inlineElements: ['a', 'abbr', 'acronym', 'applet', 'b', 'basefont', 'bdo', 'big', 'br', 'button', 'cite', 'code', 'del', 'dfn', 'em', 'font', 'i', 'iframe', 'img', 'input', 'ins', 'kbd', 'label', 'map', 'object', 'q', 's', 'samp', 'select', 'small', 'span', 'strike', 'strong', 'sub', 'sup', 'textarea', 'tt', 'u', 'var']
};
/**
* Creates output profile for given options
*/
let Profile = class Profile {
/**
* @param {EmmetOutputProfile} options
*/
constructor(options) {
/** @type {EmmetOutputProfile} */
this.options = output_profile_es__extends({}, output_profile_es_defaultOptions, options);
this.quoteChar = this.options.attributeQuotes === 'single' ? '\'' : '"';
}
/**
* Returns value of given option name
* @param {String} name
* @return {*}
*/
get(name) {
return this.options[name];
}
/**
* Quote given string according to profile
* @param {String} str String to quote
* @return {String}
*/
quote(str) {
return `${this.quoteChar}${str != null ? str : ''}${this.quoteChar}`;
}
/**
* Output given tag name according to options
* @param {String} name
* @return {String}
*/
name(name) {
return strcase(name, this.options.tagCase);
}
/**
* Outputs attribute name according to current settings
* @param {String} attr Attribute name
* @return {String}
*/
attribute(attr) {
return strcase(attr, this.options.attributeCase);
}
/**
* Check if given attribute is boolean
* @param {Object} attr
* @return {Boolean}
*/
isBooleanAttribute(attr) {
return attr.options.boolean || this.get('booleanAttributes').indexOf((attr.name || '').toLowerCase()) !== -1;
}
/**
* Returns a token for self-closing tag, depending on current options
* @return {String}
*/
selfClose() {
switch (this.options.selfClosingStyle) {
case 'xhtml':
return ' /';
case 'xml':
return '/';
default:
return '';
}
}
/**
* Returns indent for given level
* @param {Number} level Indentation level
* @return {String}
*/
indent(level) {
level = level || 0;
let output = '';
while (level--) {
output += this.options.indent;
}
return output;
}
/**
* Check if given tag name belongs to inline-level element
* @param {Object|String} node Parsed node or tag name
* @return {Boolean}
*/
isInline(node) {
if (typeof node === 'string') {
return this.get('inlineElements').indexOf(node.toLowerCase()) !== -1;
}
// inline node is a node either with inline-level name or text-only node
return node.name != null ? this.isInline(node.name) : node.isTextOnly;
}
/**
* Outputs formatted field for given params
* @param {Number} index Field index
* @param {String} [placeholder] Field placeholder, can be empty
* @return {String}
*/
field(index, placeholder) {
return this.options.field(index, placeholder);
}
};
function strcase(string, type) {
if (type) {
return type === 'upper' ? string.toUpperCase() : string.toLowerCase();
}
return string;
}
/* harmony default export */ var output_profile_es = (Profile);
// CONCATENATED MODULE: ../node_modules/@emmetio/expand-abbreviation/dist/expand.es.js
var expand_es__extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
/**
* Expands given abbreviation into code
* @param {String|Node} abbr Abbreviation to parse or already parsed abbreviation
* @param {Object} config
* @return {String}
*/
function expand(abbr, config) {
config = expand_es__extends({}, config);
if (typeof abbr === 'string') {
abbr = expand_es_parse(abbr, config);
}
return markup_formatters_es(abbr, config.profile, config.syntax, config);
}
/**
* Parses given Emmet abbreviation into a final abbreviation tree with all
* required transformations applied
* @param {String} Abbreviation to parse
* @param {Object} config
* @return {Node}
*/
function expand_es_parse(abbr, config) {
return abbreviation_es(abbr).use(html_snippets_resolver_es, config.snippets).use(variable_resolver_es, config.variables).use(html_transform_es, config.text, config.options);
}
/**
* Expands given abbreviation into code
* @param {String|Node} abbr Abbreviation to parse or already parsed abbreviation
* @param {Object} config
* @return {String}
*/
function expand$1(abbr, config) {
config = config || {};
if (typeof abbr === 'string') {
abbr = parse$1(abbr, config);
}
return stylesheet_formatters_es(abbr, config.profile, config.syntax, config);
}
/**
* Parses given Emmet abbreviation into a final abbreviation tree with all
* required transformations applied
* @param {String|Node} abbr Abbreviation to parse or already parsed abbreviation
* @param {Object} config
* @return {Node}
*/
function parse$1(abbr, config) {
if (typeof abbr === 'string') {
abbr = css_abbreviation_es(abbr);
}
return abbr.use(css_snippets_resolver_es, config.snippets, config.options);
}
const reLorem = /^lorem([a-z]*)(\d*)$/i;
/**
* Constructs a snippets registry, filled with snippets, for given options
* @param {String} syntax Abbreviation syntax
* @param {Object|Object[]} snippets Additional snippets
* @return {SnippetsRegistry}
*/
function snippetsRegistryFactory(type, syntax, snippets) {
const registrySnippets = [];
if (type === 'markup') {
registrySnippets.push(snippets_es.html);
} else if (type === 'stylesheet') {
registrySnippets.push(snippets_es.css);
}
if (syntax in snippets_es && registrySnippets.indexOf(snippets_es[syntax]) === -1) {
registrySnippets.push(snippets_es[syntax]);
}
if (Array.isArray(snippets)) {
snippets.forEach(item => {
// if array item is a string, treat it as a reference to globally
// defined snippets
registrySnippets.push(typeof item === 'string' ? snippets_es[item] : item);
});
} else if (typeof snippets === 'object') {
registrySnippets.push(snippets);
}
const registry = new snippets_registry_es(registrySnippets.filter(Boolean));
// for non-stylesheet syntaxes add Lorem Ipsum generator
if (type !== 'stylesheet') {
registry.get(0).set(reLorem, loremGenerator);
}
return registry;
}
function loremGenerator(node) {
const options = {};
const m = node.name.match(reLorem);
if (m[1]) {
options.lang = m[1];
}
if (m[2]) {
options.wordCount = +m[2];
}
return lorem_es(node, options);
}
/**
* Default variables used in snippets to insert common values into predefined snippets
* @type {Object}
*/
const defaultVariables = {
lang: 'en',
locale: 'en-US',
charset: 'UTF-8'
};
/**
* A list of syntaxes that should use Emmet CSS abbreviations:
* a variations of default abbreviation that holds values right in abbreviation name
* @type {Array}
*/
const stylesheetSyntaxes = ['css', 'sass', 'scss', 'less', 'stylus', 'sss'];
const expand_es_defaultOptions = {
/**
* Type of abbreviation to parse: 'markup' or 'stylesheet'.
* Can be auto-detected from `syntax` property. Default is 'markup'
*/
type: null,
/**
* Abbreviation output syntax
* @type {String}
*/
syntax: 'html',
/**
* Field/tabstop generator for editor. Most editors support TextMate-style
* fields: ${0} or ${1:item}. So for TextMate-style fields this function
* will look like this:
* @example
* (index, placeholder) => `\${${index}${placeholder ? ':' + placeholder : ''}}`
*
* @param {Number} index Placeholder index. Fields with the same indices
* should be linked
* @param {String} [placeholder] Field placeholder
* @return {String}
*/
field: (index, placeholder) => placeholder || '',
/**
* Insert given text string(s) into expanded abbreviation
* If array of strings is given, the implicitly repeated element (e.g. `li*`)
* will be repeated by the amount of items in array
* @type {String|String[]}
*/
text: null,
/**
* Either predefined output profile or options for output profile. Used for
* abbreviation output
* @type {Profile|Object}
*/
profile: null,
/**
* Custom variables for variable resolver
* @see @emmetio/variable-resolver
* @type {Object}
*/
variables: {},
/**
* Custom predefined snippets for abbreviation. The expanded abbreviation
* will try to match given snippets that may contain custom elements,
* predefined attributes etc.
* May also contain array of items: either snippets (Object) or references
* to default syntax snippets (String; the key in default snippets hash)
* @see @emmetio/snippets
* @type {Object|SnippetsRegistry}
*/
snippets: {},
/**
* Hash of additional transformations that should be applied to expanded
* abbreviation, like BEM or JSX. Since these transformations introduce
* side-effect, they are disabled by default and should be enabled by
* providing a transform name as a key and transform options as value:
* @example
* {
* bem: {element: '--'},
* jsx: true // no options, just enable transform
* }
* @see @emmetio/html-transform/lib/addons
* @type {Object}
*/
options: null,
/**
* Additional options for syntax formatter
* @see @emmetio/markup-formatters
* @type {Object}
*/
format: null
};
/**
* Expands given abbreviation into string, formatted according to provided
* syntax and options
* @param {String|Node} abbr Abbreviation string or parsed abbreviation tree
* @param {String|Object} [config] Parsing and formatting options (object) or
* abbreviation syntax (string)
* @return {String}
*/
function expand$2(abbr, config) {
config = createOptions(config);
return getType(config.type, config.syntax) === 'stylesheet' ? expand$1(abbr, config) : expand(abbr, config);
}
/**
* Parses given abbreviation into AST tree. This tree can be later formatted to
* string with `expand` function
* @param {String} abbr Abbreviation to parse
* @param {String|Object} [options] Parsing and formatting options (object) or
* abbreviation syntax (string)
* @return {Node}
*/
function parse$2(abbr, options) {
options = createOptions(options);
return getType(options.type, options.syntax) === 'stylesheet' ? parse$1(abbr, options) : expand_es_parse(abbr, options);
}
/**
* Creates snippets registry for given syntax and additional `snippets`
* @param {String} type Abbreviation type, 'markup' or 'stylesheet'
* @param {String} syntax Snippets syntax, used for retrieving predefined snippets
* @param {SnippetsRegistry|Object|Object[]} [snippets] Additional snippets
* @return {SnippetsRegistry}
*/
function createSnippetsRegistry(type, syntax, snippets) {
// Backward-compatibility with <0.6
if (type && type !== 'markup' && type !== 'stylesheet') {
snippets = syntax;
syntax = type;
type = 'markup';
}
return snippets instanceof snippets_registry_es ? snippets : snippetsRegistryFactory(type, syntax, snippets);
}
function createOptions(options) {
if (typeof options === 'string') {
options = { syntax: options };
}
options = expand_es__extends({}, expand_es_defaultOptions, options);
if (options.type == null && options.syntax) {
options.type = isStylesheet(options.syntax) ? 'stylesheet' : 'markup';
}
options.format = expand_es__extends({ field: options.field }, options.format);
options.profile = createProfile(options);
options.variables = expand_es__extends({}, defaultVariables, options.variables);
options.snippets = createSnippetsRegistry(options.type, options.syntax, options.snippets);
return options;
}
/**
* Check if given syntax belongs to stylesheet markup.
* Emmet uses different abbreviation flavours: one is a default markup syntax,
* used for HTML, Slim, Pug etc, the other one is used for stylesheets and
* allows embedded values in abbreviation name
* @param {String} syntax
* @return {Boolean}
*/
function isStylesheet(syntax) {
return stylesheetSyntaxes.indexOf(syntax) !== -1;
}
/**
* Creates output profile from given options
* @param {Object} options
* @return {Profile}
*/
function createProfile(options) {
return options.profile instanceof output_profile_es ? options.profile : new output_profile_es(options.profile);
}
/**
* Returns type of abbreviation expander: either 'markup' or 'stylesheet'
* @param {String} type
* @param {String} [syntax]
*/
function getType(type, syntax) {
if (type) {
return type === 'stylesheet' ? 'stylesheet' : 'markup';
}
return isStylesheet(syntax) ? 'stylesheet' : 'markup';
}
//# sourceMappingURL=expand.es.js.map
// CONCATENATED MODULE: ../node_modules/@emmetio/css-snippets-resolver/dist/css-snippets-resolver.es.js
var dist_css_snippets_resolver_es__extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
const dist_css_snippets_resolver_es_DASH = 45; // -
/**
* Calculates fuzzy match score of how close `abbr` matches given `string`.
* @param {String} abbr Abbreviation to score
* @param {String} string String to match
* @param {Number} [fuzziness] Fuzzy factor
* @return {Number} Match score
*/
function css_snippets_resolver_es_stringScore(abbr, string) {
abbr = abbr.toLowerCase();
string = string.toLowerCase();
if (abbr === string) {
return 1;
}
// a string MUST start with the same character as abbreviation
if (!string || abbr.charCodeAt(0) !== string.charCodeAt(0)) {
return 0;
}
const abbrLength = abbr.length;
const stringLength = string.length;
let i = 1,
j = 1,
score = stringLength;
let ch1, ch2, found, acronym;
while (i < abbrLength) {
ch1 = abbr.charCodeAt(i);
found = false;
acronym = false;
while (j < stringLength) {
ch2 = string.charCodeAt(j);
if (ch1 === ch2) {
found = true;
score += (stringLength - j) * (acronym ? 2 : 1);
break;
}
// add acronym bonus for exactly next match after unmatched `-`
acronym = ch2 === dist_css_snippets_resolver_es_DASH;
j++;
}
if (!found) {
break;
}
i++;
}
return score && score * (i / abbrLength) / css_snippets_resolver_es_sum(stringLength);
}
/**
* Calculates sum of first `n` natural numbers, e.g. 1+2+3+...n
* @param {Number} n
* @return {Number}
*/
function css_snippets_resolver_es_sum(n) {
return n * (n + 1) / 2;
}
const css_snippets_resolver_es_reProperty = /^([a-z\-]+)(?:\s*:\s*([^\n\r]+))?$/;
const dist_css_snippets_resolver_es_DASH$1 = 45; // -
/**
* Creates a special structure for resolving CSS properties from plain CSS
* snippets.
* Almost all CSS snippets are aliases for real CSS properties with available
* value variants, optionally separated by `|`. Most values are keywords that
* can be fuzzy-resolved as well. Some CSS properties are shorthands for other,
* more specific properties, like `border` and `border-style`. For such cases
* keywords from more specific properties should be available in shorthands too.
* @param {Snippet[]} snippets
* @return {CSSSnippet[]}
*/
function css_snippets_resolver_es_cssSnippets(snippets) {
return css_snippets_resolver_es_nest(snippets.map(snippet => new css_snippets_resolver_es_CSSSnippet(snippet.key, snippet.value)));
}
let css_snippets_resolver_es_CSSSnippet = class CSSSnippet {
constructor(key, value) {
this.key = key;
this.value = value;
this.property = null;
// detect if given snippet is a property
const m = value && value.match(css_snippets_resolver_es_reProperty);
if (m) {
this.property = m[1];
this.value = m[2];
}
this.dependencies = [];
}
addDependency(dep) {
this.dependencies.push(dep);
}
get defaultValue() {
return this.value != null ? css_snippets_resolver_es_splitValue(this.value)[0] : null;
}
/**
* Returns list of unique keywords for current CSS snippet and its dependencies
* @return {String[]}
*/
keywords() {
const stack = [];
const keywords = new Set();
let i = 0,
item,
candidates;
if (this.property) {
// scan valid CSS-properties only
stack.push(this);
}
while (i < stack.length) {
// NB Keep items in stack instead of push/pop to avoid possible
// circular references
item = stack[i++];
if (item.value) {
candidates = css_snippets_resolver_es_splitValue(item.value).filter(dist_css_snippets_resolver_es_isKeyword);
// extract possible keywords from snippet value
for (let j = 0; j < candidates.length; j++) {
keywords.add(candidates[j].trim());
}
// add dependencies into scan stack
for (let j = 0, deps = item.dependencies; j < deps.length; j++) {
if (stack.indexOf(deps[j]) === -1) {
stack.push(deps[j]);
}
}
}
}
return Array.from(keywords);
}
};
/**
* Nests more specific CSS properties into shorthand ones, e.g.
* background-position-x -> background-position -> background
* @param {CSSSnippet[]} snippets
* @return {CSSSnippet[]}
*/
function css_snippets_resolver_es_nest(snippets) {
snippets = snippets.sort(css_snippets_resolver_es_snippetsSort);
const stack = [];
// For sorted list of CSS properties, create dependency graph where each
// shorthand property contains its more specific one, e.g.
// backgound -> background-position -> background-position-x
for (let i = 0, cur, prev; i < snippets.length; i++) {
cur = snippets[i];
if (!cur.property) {
// not a CSS property, skip it
continue;
}
// Check if current property belongs to one from parent stack.
// Since `snippets` array is sorted, items are perfectly aligned
// from shorthands to more specific variants
while (stack.length) {
prev = stack[stack.length - 1];
if (cur.property.indexOf(prev.property) === 0 && cur.property.charCodeAt(prev.property.length) === dist_css_snippets_resolver_es_DASH$1) {
prev.addDependency(cur);
stack.push(cur);
break;
}
stack.pop();
}
if (!stack.length) {
stack.push(cur);
}
}
return snippets;
}
/**
* A sorting function for array of snippets
* @param {CSSSnippet} a
* @param {CSSSnippet} b
* @return {Number}
*/
function css_snippets_resolver_es_snippetsSort(a, b) {
if (a.key === b.key) {
return 0;
}
return a.key < b.key ? -1 : 1;
}
/**
* Check if given string is a keyword candidate
* @param {String} str
* @return {Boolean}
*/
function dist_css_snippets_resolver_es_isKeyword(str) {
return (/^\s*[\w-]+/.test(str)
);
}
function css_snippets_resolver_es_splitValue(value) {
return String(value).split('|');
}
const css_snippets_resolver_es_globalKeywords = ['auto', 'inherit', 'unset'];
const css_snippets_resolver_es_unitlessProperties = ['z-index', 'line-height', 'opacity', 'font-weight', 'zoom', 'flex', 'flex-grow', 'flex-shrink'];
const dist_css_snippets_resolver_es_defaultOptions = {
intUnit: 'px',
floatUnit: 'em',
unitAliases: {
e: 'em',
p: '%',
x: 'ex',
r: 'rem'
},
fuzzySearchMinScore: 0
};
/**
* For every node in given `tree`, finds matching snippet from `registry` and
* updates node with snippet data.
*
* This resolver uses fuzzy matching for searching matched snippets and their
* keyword values.
*/
function dist_css_snippets_resolver_es_index(tree, registry, options) {
options = dist_css_snippets_resolver_es__extends({}, dist_css_snippets_resolver_es_defaultOptions, options);
options.unitAliases = dist_css_snippets_resolver_es__extends({}, dist_css_snippets_resolver_es_defaultOptions.unitAliases, options && options.unitAliases);
const snippets = css_snippets_resolver_es_convertToCSSSnippets(registry);
tree.walk(node => dist_css_snippets_resolver_es_resolveNode(node, snippets, options));
return tree;
}
function css_snippets_resolver_es_convertToCSSSnippets(registry) {
return css_snippets_resolver_es_cssSnippets(registry.all({ type: 'string' }));
}
/**
* Resolves given node: finds matched CSS snippets using fuzzy match and resolves
* keyword aliases from node value
* @param {Node} node
* @param {CSSSnippet[]} snippets
* @param {Object} options
* @return {Node}
*/
function dist_css_snippets_resolver_es_resolveNode(node, snippets, options) {
const snippet = css_snippets_resolver_es_findBestMatch(node.name, snippets, 'key', options.fuzzySearchMinScore);
if (!snippet) {
// Edge case: `!important` snippet
return node.name === '!' ? css_snippets_resolver_es_setNodeAsText(node, '!important') : node;
}
return snippet.property ? css_snippets_resolver_es_resolveAsProperty(node, snippet, options) : css_snippets_resolver_es_resolveAsSnippet(node, snippet);
}
/**
* Resolves given parsed abbreviation node as CSS property
* @param {Node} node
* @param {CSSSnippet} snippet
* @param {Object} formatOptions
* @return {Node}
*/
function css_snippets_resolver_es_resolveAsProperty(node, snippet, formatOptions) {
const abbr = node.name;
node.name = snippet.property;
if (node.value && typeof node.value === 'object') {
// resolve keyword shortcuts
const keywords = snippet.keywords();
if (!node.value.size) {
// no value defined, try to resolve unmatched part as a keyword alias
let kw = css_snippets_resolver_es_findBestMatch(css_snippets_resolver_es_getUnmatchedPart(abbr, snippet.key), keywords);
if (!kw) {
// no matching value, try to get default one
kw = snippet.defaultValue;
if (kw && kw.indexOf('${') === -1) {
// Quick and dirty test for existing field. If not, wrap
// default value in a field
kw = `\${1:${kw}}`;
}
}
if (kw) {
node.value.add(kw);
}
} else {
// replace keyword aliases in current node value
for (let i = 0, token; i < node.value.value.length; i++) {
token = node.value.value[i];
if (token === '!') {
token = `${!i ? '${1} ' : ''}!important`;
} else if (css_snippets_resolver_es_isKeyword$1(token)) {
token = css_snippets_resolver_es_findBestMatch(token.value, keywords) || css_snippets_resolver_es_findBestMatch(token.value, css_snippets_resolver_es_globalKeywords) || token;
} else if (css_snippets_resolver_es_isNumericValue(token)) {
token = css_snippets_resolver_es_resolveNumericValue(node.name, token, formatOptions);
}
node.value.value[i] = token;
}
}
}
return node;
}
/**
* Resolves given parsed abbreviation node as a snippet: a plain code chunk
* @param {Node} node
* @param {CSSSnippet} snippet
* @return {Node}
*/
function css_snippets_resolver_es_resolveAsSnippet(node, snippet) {
return css_snippets_resolver_es_setNodeAsText(node, snippet.value);
}
/**
* Sets given parsed abbreviation node as a text snippet
* @param {Node} node
* @param {String} text
* @return {Node}
*/
function css_snippets_resolver_es_setNodeAsText(node, text) {
node.name = null;
node.value = text;
return node;
}
/**
* Finds best matching item from `items` array
* @param {String} abbr Abbreviation to match
* @param {Array} items List of items for match
* @param {String} [key] If `items` is a list of objects, use `key` as object
* property to test against
* @param {Number} fuzzySearchMinScore The minimum score the best matched item should have to be a valid match.
* @return {*}
*/
function css_snippets_resolver_es_findBestMatch(abbr, items, key, fuzzySearchMinScore) {
if (!abbr) {
return null;
}
let matchedItem = null;
let maxScore = 0;
fuzzySearchMinScore = fuzzySearchMinScore || 0;
for (let i = 0, item; i < items.length; i++) {
item = items[i];
const score = css_snippets_resolver_es_stringScore(abbr, css_snippets_resolver_es_getScoringPart(item, key));
if (score === 1) {
// direct hit, no need to look further
return item;
}
if (score && score >= maxScore) {
maxScore = score;
matchedItem = item;
}
}
return maxScore >= fuzzySearchMinScore ? matchedItem : null;
}
function css_snippets_resolver_es_getScoringPart(item, key) {
const value = item && typeof item === 'object' ? item[key] : item;
const m = (value || '').match(/^[\w-@]+/);
return m ? m[0] : value;
}
/**
* Returns a part of `abbr` that wasn’t directly matched agains `string`.
* For example, if abbreviation `poas` is matched against `position`, the unmatched part will be `as`
* since `a` wasn’t found in string stream
* @param {String} abbr
* @param {String} string
* @return {String}
*/
function css_snippets_resolver_es_getUnmatchedPart(abbr, string) {
for (let i = 0, lastPos = 0; i < abbr.length; i++) {
lastPos = string.indexOf(abbr[i], lastPos);
if (lastPos === -1) {
return abbr.slice(i);
}
lastPos++;
}
return '';
}
/**
* Check if given CSS value token is a keyword
* @param {*} token
* @return {Boolean}
*/
function css_snippets_resolver_es_isKeyword$1(token) {
return css_snippets_resolver_es_tokenTypeOf(token, 'keyword');
}
/**
* Check if given CSS value token is a numeric value
* @param {*} token
* @return {Boolean}
*/
function css_snippets_resolver_es_isNumericValue(token) {
return css_snippets_resolver_es_tokenTypeOf(token, 'numeric');
}
function css_snippets_resolver_es_tokenTypeOf(token, type) {
return token && typeof token === 'object' && token.type === type;
}
/**
* Resolves numeric value for given CSS property
* @param {String} property CSS property name
* @param {NumericValue} token CSS numeric value token
* @param {Object} formatOptions Formatting options for units
* @return {NumericValue}
*/
function css_snippets_resolver_es_resolveNumericValue(property, token, formatOptions) {
if (token.unit) {
token.unit = formatOptions.unitAliases[token.unit] || token.unit;
} else if (token.value !== 0 && css_snippets_resolver_es_unitlessProperties.indexOf(property) === -1) {
// use `px` for integers, `em` for floats
// NB: num|0 is a quick alternative to Math.round(0)
token.unit = token.value === (token.value | 0) ? formatOptions.intUnit : formatOptions.floatUnit;
}
return token;
}
/* harmony default export */ var dist_css_snippets_resolver_es = (dist_css_snippets_resolver_es_index);
//# sourceMappingURL=css-snippets-resolver.es.js.map
// CONCATENATED MODULE: ../node_modules/@emmetio/html-matcher/dist/html-matcher.es.js
var html_matcher_es__extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
let html_matcher_es_Node = class Node {
constructor(stream, type, open, close) {
this.stream = stream;
this.type = type;
this.open = open;
this.close = close;
this.children = [];
this.parent = null;
}
/**
* Returns node name
* @return {String}
*/
get name() {
if (this.type === 'tag' && this.open) {
return this.open && this.open.name && this.open.name.value;
}
return '#' + this.type;
}
/**
* Returns attributes of current node
* @return {Array}
*/
get attributes() {
return this.open && this.open.attributes;
}
/**
* Returns node’s start position in stream
* @return {*}
*/
get start() {
return this.open && this.open.start;
}
/**
* Returns node’s start position in stream
* @return {*}
*/
get end() {
return this.close ? this.close.end : this.open && this.open.end;
}
get firstChild() {
return this.children[0];
}
get nextSibling() {
const ix = this.getIndex();
return ix !== -1 ? this.parent.children[ix + 1] : null;
}
get previousSibling() {
const ix = this.getIndex();
return ix !== -1 ? this.parent.children[ix - 1] : null;
}
/**
* Returns current element’s index in parent list of child nodes
* @return {Number}
*/
getIndex() {
return this.parent ? this.parent.children.indexOf(this) : -1;
}
/**
* Adds given node as a child
* @param {Node} node
* @return {Node} Current node
*/
addChild(node) {
this.removeChild(node);
this.children.push(node);
node.parent = this;
return this;
}
/**
* Removes given node from current node’s child list
* @param {Node} node
* @return {Node} Current node
*/
removeChild(node) {
const ix = this.children.indexOf(node);
if (ix !== -1) {
this.children.splice(ix, 1);
node.parent = null;
}
return this;
}
};
/**
* A token factory method
* @param {StreamReader} stream
* @param {Point|Function} start Tokens’ start location or stream consumer
* @param {Point} [end] Tokens’ end location
* @return {Token}
*/
var html_matcher_es_token = function (stream, start, end) {
return typeof start === 'function' ? eatToken(stream, start) : new Token(stream, start, end);
};
/**
* Consumes characters from given stream that matches `fn` call and returns it
* as token, if consumed
* @param {StreamReader} stream
* @param {Function} test
* @return {Token}
*/
function eatToken(stream, test) {
const start = stream.pos;
if (stream.eatWhile(test)) {
return new Token(stream, start, stream.pos);
}
stream.pos = start;
}
/**
* A structure describing text fragment in content stream
*/
let Token = class Token {
/**
* @param {ContentStreamReader} stream
* @param {Point} start Tokens’ start location in content stream
* @param {Point} end Tokens’ end location in content stream
*/
constructor(stream, start, end) {
this.stream = stream;
this.start = start != null ? start : stream.start;
this.end = end != null ? end : stream.pos;
this._value = null;
}
/**
* Returns token textual value
* NB implemented as getter to reduce unnecessary memory allocations for
* strings that not required
* @return {String}
*/
get value() {
if (this._value === null) {
const start = this.stream.start;
const end = this.stream.pos;
this.stream.start = this.start;
this.stream.pos = this.end;
this._value = this.stream.current();
this.stream.start = start;
this.stream.pos = end;
}
return this._value;
}
toString() {
return this.value;
}
valueOf() {
return `${this.value} [${this.start}; ${this.end}]`;
}
};
const LANGLE = 60;
const RANGLE = 62; // < and >
const LSQUARE = 91;
const RSQUARE = 93; // [ and ]
const LROUND = 40;
const RROUND = 41; // ( and )
const LCURLY = 123;
const RCURLY = 125; // { and }
const html_matcher_es_opt = { throws: true };
/**
* Consumes paired tokens (like `[` and `]`) with respect of nesting and embedded
* quoted values
* @param {StreamReader} stream
* @return {Token} A token with consumed paired character
*/
var eatPaired = function (stream) {
const start = stream.pos;
const consumed = eatPair(stream, LANGLE, RANGLE, html_matcher_es_opt) || eatPair(stream, LSQUARE, RSQUARE, html_matcher_es_opt) || eatPair(stream, LROUND, RROUND, html_matcher_es_opt) || eatPair(stream, LCURLY, RCURLY, html_matcher_es_opt);
if (consumed) {
return html_matcher_es_token(stream, start);
}
};
const SLASH$1 = 47; // /
const html_matcher_es_EQUALS = 61; // =
const RIGHT_ANGLE$1 = 62; // >
/**
* Consumes attributes from given stream
* @param {StreamReader} stream
* @return {Array} Array of consumed attributes
*/
var eatAttributes = function (stream) {
const result = [];
let name, value, attr;
while (!stream.eof()) {
stream.eatWhile(isSpace);
attr = { start: stream.pos };
// A name could be a regular name or expression:
// React-style –