made with requirebin
Last active
April 25, 2017 03:14
-
-
Save tholman/8471aa2108bff253894fbcfb9deb80b5 to your computer and use it in GitHub Desktop.
requirebin sketch
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// Welcome! require() some modules from npm (like you were using browserify) | |
// and then hit Run Code to run your code on the right side. | |
// Modules get downloaded from browserify-cdn and bundled in your browser. | |
require('@emmetio/abbreviation'); | |
require('@emmetio/html-transform'); |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
setTimeout(function(){ | |
;require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){ | |
'use strict'; | |
/** | |
* 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) | |
*/ | |
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, Object.assign({}, 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 | |
*/ | |
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 = Object.assign({}, 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; | |
} | |
module.exports = Node; | |
},{}],2:[function(require,module,exports){ | |
'use strict'; | |
Object.defineProperty(exports, '__esModule', { value: true }); | |
/** | |
* 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 ? Object.assign({}, 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 ? Object.assign({}, 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; | |
} | |
exports.eatQuoted = eatQuoted; | |
exports.isQuote = isQuote; | |
exports.isAlpha = isAlpha; | |
exports.isNumber = isNumber; | |
exports.isAlphaNumeric = isAlphaNumeric; | |
exports.isSpace = isSpace; | |
exports.isWhiteSpace = isWhiteSpace; | |
exports.eatPair = eatPair; | |
},{}],3:[function(require,module,exports){ | |
'use strict'; | |
/** | |
* A streaming, character code-based string reader | |
*/ | |
class StreamReader { | |
constructor(string, start, end) { | |
if (end == null && typeof string === 'string') { | |
end = string.length; | |
} | |
this.string = string; | |
this.pos = this.start = start || 0; | |
this.end = end; | |
} | |
/** | |
* Returns true only if the stream is at the end of the file. | |
* @returns {Boolean} | |
*/ | |
eof() { | |
return this.pos >= this.end; | |
} | |
/** | |
* Creates a new stream instance which is limited to given `start` and `end` | |
* range. E.g. its `eof()` method will look at `end` property, not actual | |
* stream end | |
* @param {Point} start | |
* @param {Point} end | |
* @return {StreamReader} | |
*/ | |
limit(start, end) { | |
return new this.constructor(this.string, start, end); | |
} | |
/** | |
* Returns the next character code in the stream without advancing it. | |
* Will return NaN at the end of the file. | |
* @returns {Number} | |
*/ | |
peek() { | |
return this.string.charCodeAt(this.pos); | |
} | |
/** | |
* Returns the next character in the stream and advances it. | |
* Also returns <code>undefined</code> 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 <code>eat</code> with the given argument, until it | |
* fails. Returns <code>true</code> 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.string.slice(this.start, this.pos); | |
} | |
/** | |
* 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; | |
} | |
} | |
module.exports = StreamReader; | |
},{}],"@emmetio/abbreviation":[function(require,module,exports){ | |
'use strict'; | |
function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } | |
var Node = _interopDefault(require('@emmetio/node')); | |
var StreamReader = _interopDefault(require('@emmetio/stream-reader')); | |
var _emmetio_streamReaderUtils = require('@emmetio/stream-reader-utils'); | |
const ASTERISK = 42; // * | |
/** | |
* Consumes node repeat token from current stream position and returns its | |
* parsed value | |
* @param {StringReader} stream | |
* @return {Object} | |
*/ | |
var consumeRepeat = function(stream) { | |
if (stream.eat(ASTERISK)) { | |
stream.start = stream.pos; | |
// XXX think about extending repeat syntax with through numbering | |
return { count: stream.eatWhile(_emmetio_streamReaderUtils.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 | |
*/ | |
var consumeQuoted = function(stream) { | |
if (_emmetio_streamReaderUtils.eatQuoted(stream, opt)) { | |
return stream.current().slice(1, -1); | |
} | |
}; | |
const LCURLY = 123; // { | |
const RCURLY = 125; // } | |
const opt$1 = { throws: true }; | |
/** | |
* Consumes text node, e.g. contents of `{...}` and returns its inner value | |
* @param {StringReader} stream | |
* @return {String} Consumed text content or `null` otherwise | |
*/ | |
var consumeTextNode = function(stream) { | |
return _emmetio_streamReaderUtils.eatPair(stream, LCURLY, RCURLY, opt$1) | |
? stream.current().slice(1, -1) | |
: null; | |
}; | |
const EXCL = 33; // . | |
const DOT$1 = 46; // . | |
const 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 | |
*/ | |
var consumeAttributes = function(stream) { | |
if (!stream.eat(ATTR_OPEN)) { | |
return null; | |
} | |
const result = []; | |
let token, attr; | |
while (!stream.eof()) { | |
stream.eatWhile(_emmetio_streamReaderUtils.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(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 = consumeTextNode(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$1) { | |
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 !_emmetio_streamReaderUtils.isSpace(code) && !_emmetio_streamReaderUtils.isQuote(code) | |
&& code !== ATTR_OPEN && code !== ATTR_CLOSE && code !== EQUALS; | |
} | |
const HASH = 35; // # | |
const DOT = 46; // . | |
const SLASH = 47; // / | |
/** | |
* Consumes a single element node from current abbreviation stream | |
* @param {StringReader} stream | |
* @return {Node} | |
*/ | |
var consumeElement = function(stream) { | |
// consume element name, if provided | |
const start = stream.pos; | |
const node = new Node(eatName(stream)); | |
let next; | |
while (!stream.eof()) { | |
if (stream.eat(DOT)) { | |
node.addClass(eatName(stream)); | |
} else if (stream.eat(HASH)) { | |
node.setAttribute('id', eatName(stream)); | |
} else if (stream.eat(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 = consumeTextNode(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 _emmetio_streamReaderUtils.isAlphaNumeric(code) | |
|| code === 45 /* - */ | |
|| code === 58 /* : */ | |
|| code === 36 /* $ */ | |
|| code === 64 /* @ */ | |
|| code === 33 /* ! */ | |
|| 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 parse(str) { | |
const stream = new StreamReader(str.trim()); | |
const root = new Node(); | |
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(); | |
const groupCtx = groupStack.length ? last(groupStack)[0] : ctx; | |
groupStack.push([node, groupCtx, 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; | |
} | |
function last(arr) { | |
return arr[arr.length - 1]; | |
} | |
/** | |
* Parses given abbreviation and un-rolls it into a full tree: recursively | |
* replaces repeated elements with actual nodes | |
* @param {String} abbr | |
* @return {Node} | |
*/ | |
var index = function(abbr) { | |
const tree = parse(abbr); | |
tree.walk(unroll); | |
return tree; | |
}; | |
function unroll(node) { | |
if (!node.repeat || !node.repeat.count) { | |
return; | |
} | |
for (let i = 1; i < node.repeat.count; i++) { | |
const clone = node.clone(true); | |
clone.repeat.value = i; | |
clone.walk(unroll); | |
node.parent.insertBefore(clone, node); | |
} | |
node.repeat.value = node.repeat.count; | |
} | |
module.exports = index; | |
},{"@emmetio/node":1,"@emmetio/stream-reader":3,"@emmetio/stream-reader-utils":2}]},{},[]) | |
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/browser-pack/_prelude.js","node_modules/@emmetio/node/dist/node.cjs.js","node_modules/@emmetio/stream-reader-utils/dist/stream-reader-utils.cjs.js","node_modules/@emmetio/stream-reader/dist/stream-reader.cjs.js","@emmetio%2Fabbreviation"],"names":[],"mappings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neA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","'use strict';\n\n/**\n * Attribute descriptor of parsed abbreviation node\n * @param {String} name Attribute name\n * @param {String} value Attribute value\n * @param {Object} options Additional custom attribute options\n * @param {Boolean} options.boolean Attribute is boolean (e.g. name equals value)\n * @param {Boolean} options.implied Attribute is implied (e.g. must be outputted\n * only if contains non-null value)\n */\nclass Attribute {\n\tconstructor(name, value, options) {\n\t\tthis.name = name;\n\t\tthis.value = value != null ? value : null;\n\t\tthis.options = options || {};\n\t}\n\n\t/**\n\t * Create a copy of current attribute\n\t * @return {Attribute}\n\t */\n\tclone() {\n\t\treturn new Attribute(this.name, this.value, Object.assign({}, this.options));\n\t}\n\n\t/**\n\t * A string representation of current node\n\t */\n\tvalueOf() {\n\t\treturn `${this.name}=\"${this.value}\"`;\n\t}\n}\n\n/**\n * A parsed abbreviation AST node. Nodes build up an abbreviation AST tree\n */\nclass Node {\n\t/**\n\t * Creates a new node\n\t * @param {String} [name] Node name\n\t * @param {Array} [attributes] Array of attributes to add\n\t */\n\tconstructor(name, attributes) {\n\t\t// own properties\n\t\tthis.name = name || null;\n\t\tthis.value = null;\n\t\tthis.repeat = null;\n\t\tthis.selfClosing = false;\n\n\t\tthis.children = [];\n\n\t\t/** @type {Node} Pointer to parent node */\n\t\tthis.parent = null;\n\n\t\t/** @type {Node} Pointer to next sibling */\n\t\tthis.next = null;\n\n\t\t/** @type {Node} Pointer to previous sibling */\n\t\tthis.previous = null;\n\n\t\tthis._attributes = [];\n\n\t\tif (Array.isArray(attributes)) {\n\t\t\tattributes.forEach(attr => this.setAttribute(attr));\n\t\t}\n\t}\n\n\t/**\n\t * Array of current node attributes\n\t * @return {Attribute[]} Array of attributes\n\t */\n\tget attributes() {\n\t\treturn this._attributes;\n\t}\n\n\t/**\n\t * A shorthand to retreive node attributes as map\n\t * @return {Object}\n\t */\n\tget attributesMap() {\n\t\treturn this.attributes.reduce((out, attr) => {\n\t\t\tout[attr.name] = attr.options.boolean ? attr.name : attr.value;\n\t\t\treturn out;\n\t\t}, {});\n\t}\n\n\t/**\n\t * Check if current node is a grouping one, e.g. has no actual representation\n\t * and is used for grouping subsequent nodes only\n\t * @return {Boolean}\n\t */\n\tget isGroup() {\n\t\treturn !this.name && !this.value && !this._attributes.length;\n\t}\n\n\t/**\n\t * Check if given node is a text-only node, e.g. contains only value\n\t * @return {Boolean}\n\t */\n\tget isTextOnly() {\n\t\treturn !this.name && !!this.value && !this._attributes.length;\n\t}\n\n\t/**\n\t * Returns first child node\n\t * @return {Node}\n\t */\n\tget firstChild() {\n\t\treturn this.children[0];\n\t}\n\n\t/**\n\t * Returns last child of current node\n\t * @return {Node}\n\t */\n\tget lastChild() {\n\t\treturn this.children[this.children.length - 1];\n\t}\n\n\t/**\n\t * Return index of current node in its parent child list\n\t * @return {Number} Returns -1 if current node is a root one\n\t */\n\tget childIndex() {\n\t\treturn this.parent ? this.parent.children.indexOf(this) : -1;\n\t}\n\n\t/**\n\t * Returns next sibling of current node\n\t * @return {Node}\n\t */\n\tget nextSibling() {\n\t\treturn this.next;\n\t}\n\n\t/**\n\t * Returns previous sibling of current node\n\t * @return {Node}\n\t */\n\tget previousSibling() {\n\t\treturn this.previous;\n\t}\n\n\t/**\n\t * Returns array of unique class names in current node\n\t * @return {String[]}\n\t */\n\tget classList() {\n\t\tconst attr = this.getAttribute('class');\n\t\treturn attr && attr.value\n\t\t\t? attr.value.split(/\\s+/g).filter(uniqueClass)\n\t\t\t: [];\n\t}\n\n\t/**\n\t * Convenient alias to create a new node instance\n\t * @param {String} [name] Node name\n\t * @param {Object} [attributes] Attributes hash\n\t * @return {Node}\n\t */\n\tcreate(name, attributes) {\n\t\treturn new Node(name, attributes);\n\t}\n\n\t/**\n\t * Sets given attribute for current node\n\t * @param {String|Object|Attribute} name Attribute name or attribute object\n\t * @param {String} [value] Attribute value\n\t */\n\tsetAttribute(name, value) {\n\t\tconst attr = createAttribute(name, value);\n\t\tconst curAttr = this.getAttribute(name);\n\t\tif (curAttr) {\n\t\t\tthis.replaceAttribute(curAttr, attr);\n\t\t} else {\n\t\t\tthis._attributes.push(attr);\n\t\t}\n\t}\n\n\t/**\n\t * Check if attribute with given name exists in node\n\t * @param  {String} name\n\t * @return {Boolean}\n\t */\n\thasAttribute(name) {\n\t\treturn !!this.getAttribute(name);\n\t}\n\n\t/**\n\t * Returns attribute object by given name\n\t * @param  {String} name\n\t * @return {Attribute}\n\t */\n\tgetAttribute(name) {\n\t\tif (typeof name === 'object') {\n\t\t\tname = name.name;\n\t\t}\n\n\t\tfor (var i = 0; i < this._attributes.length; i++) {\n\t\t\tconst attr = this._attributes[i];\n\t\t\tif (attr.name === name) {\n\t\t\t\treturn attr;\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Replaces attribute with new instance\n\t * @param {String|Attribute} curAttribute Current attribute name or instance\n\t * to replace\n\t * @param {String|Object|Attribute} newName New attribute name or attribute object\n\t * @param {String} [newValue] New attribute value\n\t */\n\treplaceAttribute(curAttribute, newName, newValue) {\n\t\tif (typeof curAttribute === 'string') {\n\t\t\tcurAttribute = this.getAttribute(curAttribute);\n\t\t}\n\n\t\tconst ix = this._attributes.indexOf(curAttribute);\n\t\tif (ix !== -1) {\n\t\t\tthis._attributes.splice(ix, 1, createAttribute(newName, newValue));\n\t\t}\n\t}\n\n\t/**\n\t * Removes attribute with given name\n\t * @param  {String|Attribute} attr Atrtibute name or instance\n\t */\n\tremoveAttribute(attr) {\n\t\tif (typeof attr === 'string') {\n\t\t\tattr = this.getAttribute(attr);\n\t\t}\n\n\t\tconst ix = this._attributes.indexOf(attr);\n\t\tif (ix !== -1) {\n\t\t\tthis._attributes.splice(ix, 1);\n\t\t}\n\t}\n\n\t/**\n\t * Removes all attributes from current node\n\t */\n\tclearAttributes() {\n\t\tthis._attributes.length = 0;\n\t}\n\n\t/**\n\t * Adds given class name to class attribute\n\t * @param {String} token Class name token\n\t */\n\taddClass(token) {\n\t\ttoken = normalize(token);\n\n\t\tif (!this.hasAttribute('class')) {\n\t\t\tthis.setAttribute('class', token);\n\t\t} else if (token && !this.hasClass(token)) {\n\t\t\tthis.setAttribute('class', this.classList.concat(token).join(' '));\n\t\t}\n\t}\n\n\t/**\n\t * Check if current node contains given class name\n\t * @param {String} token Class name token\n\t * @return {Boolean}\n\t */\n\thasClass(token) {\n\t\treturn this.classList.indexOf(normalize(token)) !== -1;\n\t}\n\n\t/**\n\t * Removes given class name from class attribute\n\t * @param {String} token Class name token\n\t */\n\tremoveClass(token) {\n\t\ttoken = normalize(token);\n\t\tif (this.hasClass(token)) {\n\t\t\tthis.setAttribute('class', this.classList.filter(name => name !== token).join(' '));\n\t\t}\n\t}\n\n\t/**\n\t * Appends child to current node\n\t * @param {Node} node\n\t */\n\tappendChild(node) {\n\t\tthis.insertAt(node, this.children.length);\n\t}\n\n\t/**\n\t * Inserts given `newNode` before `refNode` child node\n\t * @param {Node} newNode\n\t * @param {Node} refNode\n\t */\n\tinsertBefore(newNode, refNode) {\n\t\tthis.insertAt(newNode, this.children.indexOf(refNode));\n\t}\n\n\t/**\n\t * Insert given `node` at `pos` position of child list\n\t * @param {Node} node\n\t * @param {Number} pos\n\t */\n\tinsertAt(node, pos) {\n\t\tif (pos < 0 || pos > this.children.length) {\n\t\t\tthrow new Error('Unable to insert node: position is out of child list range');\n\t\t}\n\n\t\tconst prev = this.children[pos - 1];\n\t\tconst next = this.children[pos];\n\n\t\tnode.remove();\n\t\tnode.parent = this;\n\t\tthis.children.splice(pos, 0, node);\n\n\t\tif (prev) {\n\t\t\tnode.previous = prev;\n\t\t\tprev.next = node;\n\t\t}\n\n\t\tif (next) {\n\t\t\tnode.next = next;\n\t\t\tnext.previous = node;\n\t\t}\n\t}\n\n\t/**\n\t * Removes given child from current node\n\t * @param {Node} node\n\t */\n\tremoveChild(node) {\n\t\tconst ix = this.children.indexOf(node);\n\t\tif (ix !== -1) {\n\t\t\tthis.children.splice(ix, 1);\n\t\t\tif (node.previous) {\n\t\t\t\tnode.previous.next = node.next;\n\t\t\t}\n\n\t\t\tif (node.next) {\n\t\t\t\tnode.next.previous = node.previous;\n\t\t\t}\n\n\t\t\tnode.parent = node.next = node.previous = null;\n\t\t}\n\t}\n\n\t/**\n\t * Removes current node from its parent\n\t */\n\tremove() {\n\t\tif (this.parent) {\n\t\t\tthis.parent.removeChild(this);\n\t\t}\n\t}\n\n\t/**\n\t * Creates a detached copy of current node\n\t * @param {Boolean} deep Clone node contents as well\n\t * @return {Node}\n\t */\n\tclone(deep) {\n\t\tconst clone = new Node(this.name);\n\t\tclone.value = this.value;\n\t\tclone.selfClosing = this.selfClosing;\n\t\tif (this.repeat) {\n\t\t\tclone.repeat = Object.assign({}, this.repeat);\n\t\t}\n\n\t\tthis._attributes.forEach(attr => clone.setAttribute(attr.clone()));\n\n\t\tif (deep) {\n\t\t\tthis.children.forEach(child => clone.appendChild(child.clone(true)));\n\t\t}\n\n\t\treturn clone;\n\t}\n\n\t/**\n\t * Walks on each descendant node and invokes given `fn` function on it.\n\t * The function receives two arguments: the node itself and its depth level\n\t * from current node. If function returns `false`, it stops walking\n\t * @param {Function} fn\n\t */\n\twalk(fn, _level) {\n\t\t_level = _level || 0;\n\t\tlet ctx = this.firstChild;\n\n\t\twhile (ctx) {\n\t\t\t// in case if context node will be detached during `fn` call\n\t\t\tconst next = ctx.next;\n\n\t\t\tif (fn(ctx, _level) === false || ctx.walk(fn, _level + 1) === false) {\n\t\t\t\treturn false;\n\t\t\t}\n\n\t\t\tctx = next;\n\t\t}\n\t}\n\n\t/**\n\t * A helper method for transformation chaining: runs given `fn` function on\n\t * current node and returns the same node\n\t */\n\tuse(fn) {\n\t\tconst args = [this];\n\t\tfor (var i = 1; i < arguments.length; i++) {\n\t\t\targs.push(arguments[i]);\n\t\t}\n\n\t\tfn.apply(null, args);\n\t\treturn this;\n\t}\n\n\ttoString() {\n\t\tconst attrs = this.attributes.map(attr => {\n\t\t\tattr = this.getAttribute(attr.name);\n\t\t\tconst opt = attr.options;\n\t\t\tlet out = `${opt && opt.implied ? '!' : ''}${attr.name || ''}`;\n\t\t\tif (opt && opt.boolean) {\n\t\t\t\tout += '.';\n\t\t\t} else if (attr.value != null) {\n\t\t\t\tout += `=\"${attr.value}\"`;\n\t\t\t}\n\t\t\treturn out;\n\t\t});\n\n\t\tlet out = `${this.name || ''}`;\n\t\tif (attrs.length) {\n\t\t\tout += `[${attrs.join(' ')}]`;\n\t\t}\n\n\t\tif (this.value != null) {\n\t\t\tout += `{${this.value}}`;\n\t\t}\n\n\t\tif (this.selfClosing) {\n\t\t\tout += '/';\n\t\t}\n\n\t\tif (this.repeat) {\n\t\t\tout += `*${this.repeat.count ? this.repeat.count : ''}`;\n\t\t\tif (this.repeat.value != null) {\n\t\t\t\tout += `@${this.repeat.value}`;\n\t\t\t}\n\t\t}\n\n\t\treturn out;\n\t}\n}\n\n/**\n * Attribute factory\n * @param  {String|Attribute|Object} name  Attribute name or attribute descriptor\n * @param  {*} value Attribute value\n * @return {Attribute}\n */\nfunction createAttribute(name, value) {\n\tif (name instanceof Attribute) {\n\t\treturn name;\n\t}\n\n\tif (typeof name === 'string') {\n\t\treturn new Attribute(name, value);\n\t}\n\n\tif (name && typeof name === 'object') {\n\t\treturn new Attribute(name.name, name.value, name.options);\n\t}\n}\n\n/**\n * @param  {String} str\n * @return {String}\n */\nfunction normalize(str) {\n\treturn String(str).trim();\n}\n\nfunction uniqueClass(item, i, arr) {\n\treturn item && arr.indexOf(item) === i;\n}\n\nmodule.exports = Node;\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n/**\n * Methods for consuming quoted values\n */\n\nconst SINGLE_QUOTE = 39; // '\nconst DOUBLE_QUOTE = 34; // \"\n\nconst defaultOptions = {\n\tescape: 92,   // \\ character\n\tthrows: false\n};\n\n/**\n * Consumes 'single' or \"double\"-quoted string from given string, if possible\n * @param  {StreamReader} stream\n * @param  {Number}  options.escape A character code of quote-escape symbol\n * @param  {Boolean} options.throws Throw error if quotes string can’t be properly consumed\n * @return {Boolean} `true` if quoted string was consumed. The contents\n *                   of quoted string will be availabe as `stream.current()`\n */\nvar eatQuoted = function(stream, options) {\n\toptions = options ? Object.assign({}, defaultOptions, options) : defaultOptions;\n\tconst start = stream.pos;\n\tconst quote = stream.peek();\n\n\tif (stream.eat(isQuote)) {\n\t\twhile (!stream.eof()) {\n\t\t\tswitch (stream.next()) {\n\t\t\t\tcase quote:\n\t\t\t\t\tstream.start = start;\n\t\t\t\t\treturn true;\n\n\t\t\t\tcase options.escape:\n\t\t\t\t\tstream.next();\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\t// If we’re here then stream wasn’t properly consumed.\n\t\t// Revert stream and decide what to do\n\t\tstream.pos = start;\n\n\t\tif (options.throws) {\n\t\t\tthrow stream.error('Unable to consume quoted string');\n\t\t}\n\t}\n\n\treturn false;\n};\n\nfunction isQuote(code) {\n\treturn code === SINGLE_QUOTE || code === DOUBLE_QUOTE;\n}\n\n/**\n * Check if given code is a number\n * @param  {Number}  code\n * @return {Boolean}\n */\nfunction isNumber(code) {\n\treturn code > 47 && code < 58;\n}\n\n/**\n * Check if given character code is alpha code (letter through A to Z)\n * @param  {Number}  code\n * @param  {Number}  [from]\n * @param  {Number}  [to]\n * @return {Boolean}\n */\nfunction isAlpha(code, from, to) {\n\tfrom = from || 65; // A\n\tto   = to   || 90; // Z\n\tcode &= ~32; // quick hack to convert any char code to uppercase char code\n\n\treturn code >= from && code <= to;\n}\n\n/**\n * Check if given character code is alpha-numeric (letter through A to Z or number)\n * @param  {Number}  code\n * @return {Boolean}\n */\nfunction isAlphaNumeric(code) {\n\treturn isNumber(code) || isAlpha(code);\n}\n\nfunction isWhiteSpace(code) {\n\treturn code === 32   /* space */\n\t\t|| code === 9    /* tab */\n\t\t|| code === 160; /* non-breaking space */\n}\n\n/**\n * Check if given character code is a space\n * @param  {Number}  code\n * @return {Boolean}\n */\nfunction isSpace(code) {\n\treturn isWhiteSpace(code)\n\t\t|| code === 10  /* LF */\n\t\t|| code === 13; /* CR */\n}\n\nconst defaultOptions$1 = {\n\tescape: 92,   // \\ character\n\tthrows: false\n};\n\n/**\n * Eats paired characters substring, for example `(foo)` or `[bar]`\n * @param  {StreamReader} stream\n * @param  {Number} open      Character code of pair openinig\n * @param  {Number} close     Character code of pair closing\n * @param  {Object} [options]\n * @return {Boolean}       Returns `true` if chacarter pair was successfully\n *                         consumed, it’s content will be available as `stream.current()`\n */\nfunction eatPair(stream, open, close, options) {\n\toptions = options ? Object.assign({}, defaultOptions$1, options) : defaultOptions$1;\n\tconst start = stream.pos;\n\n\tif (stream.eat(open)) {\n\t\tlet stack = 1, ch;\n\n\t\twhile (!stream.eof()) {\n\t\t\tif (eatQuoted(stream, options)) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tch = stream.next();\n\t\t\tif (ch === open) {\n\t\t\t\tstack++;\n\t\t\t} else if (ch === close) {\n\t\t\t\tstack--;\n\t\t\t\tif (!stack) {\n\t\t\t\t\tstream.start = start;\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t} else if (ch === options.escape) {\n\t\t\t\tstream.next();\n\t\t\t}\n\t\t}\n\n\t\t// If we’re here then paired character can’t be consumed\n\t\tstream.pos = start;\n\n\t\tif (options.throws) {\n\t\t\tthrow stream.error(`Unable to find matching pair for ${String.fromCharCode(open)}`);\n\t\t}\n\t}\n\n\treturn false;\n}\n\nexports.eatQuoted = eatQuoted;\nexports.isQuote = isQuote;\nexports.isAlpha = isAlpha;\nexports.isNumber = isNumber;\nexports.isAlphaNumeric = isAlphaNumeric;\nexports.isSpace = isSpace;\nexports.isWhiteSpace = isWhiteSpace;\nexports.eatPair = eatPair;\n","'use strict';\n\n/**\n * A streaming, character code-based string reader\n */\nclass StreamReader {\n\tconstructor(string, start, end) {\n\t\tif (end == null && typeof string === 'string') {\n\t\t\tend = string.length;\n\t\t}\n\n\t\tthis.string = string;\n\t\tthis.pos = this.start = start || 0;\n\t\tthis.end = end;\n\t}\n\n\t/**\n\t * Returns true only if the stream is at the end of the file.\n\t * @returns {Boolean}\n\t */\n\teof() {\n\t\treturn this.pos >= this.end;\n\t}\n\n\t/**\n\t * Creates a new stream instance which is limited to given `start` and `end`\n\t * range. E.g. its `eof()` method will look at `end` property, not actual\n\t * stream end\n\t * @param  {Point} start\n\t * @param  {Point} end\n\t * @return {StreamReader}\n\t */\n\tlimit(start, end) {\n\t\treturn new this.constructor(this.string, start, end);\n\t}\n\n\t/**\n\t * Returns the next character code in the stream without advancing it.\n\t * Will return NaN at the end of the file.\n\t * @returns {Number}\n\t */\n\tpeek() {\n\t\treturn this.string.charCodeAt(this.pos);\n\t}\n\n\t/**\n\t * Returns the next character in the stream and advances it.\n\t * Also returns <code>undefined</code> when no more characters are available.\n\t * @returns {Number}\n\t */\n\tnext() {\n\t\tif (this.pos < this.string.length) {\n\t\t\treturn this.string.charCodeAt(this.pos++);\n\t\t}\n\t}\n\n\t/**\n\t * `match` can be a character code or a function that takes a character code\n\t * and returns a boolean. If the next character in the stream 'matches'\n\t * the given argument, it is consumed and returned.\n\t * Otherwise, `false` is returned.\n\t * @param {Number|Function} match\n\t * @returns {Boolean}\n\t */\n\teat(match) {\n\t\tconst ch = this.peek();\n\t\tconst ok = typeof match === 'function' ? match(ch) : ch === match;\n\n\t\tif (ok) {\n\t\t\tthis.next();\n\t\t}\n\n\t\treturn ok;\n\t}\n\n\t/**\n\t * Repeatedly calls <code>eat</code> with the given argument, until it\n\t * fails. Returns <code>true</code> if any characters were eaten.\n\t * @param {Object} match\n\t * @returns {Boolean}\n\t */\n\teatWhile(match) {\n\t\tconst start = this.pos;\n\t\twhile (!this.eof() && this.eat(match)) {}\n\t\treturn this.pos !== start;\n\t}\n\n\t/**\n\t * Backs up the stream n characters. Backing it up further than the\n\t * start of the current token will cause things to break, so be careful.\n\t * @param {Number} n\n\t */\n\tbackUp(n) {\n\t\tthis.pos -= (n || 1);\n\t}\n\n\t/**\n\t * Get the string between the start of the current token and the\n\t * current stream position.\n\t * @returns {String}\n\t */\n\tcurrent() {\n\t\treturn this.string.slice(this.start, this.pos);\n\t}\n\n\t/**\n\t * Creates error object with current stream state\n\t * @param {String} message\n\t * @return {Error}\n\t */\n\terror(message) {\n\t\tconst err = new Error(`${message} at char ${this.pos + 1}`);\n\t\terr.originalMessage = message;\n\t\terr.pos = this.pos;\n\t\terr.string = this.string;\n\t\treturn err;\n\t}\n}\n\nmodule.exports = StreamReader;\n","'use strict';\n\nfunction _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }\n\nvar Node = _interopDefault(require('@emmetio/node'));\nvar StreamReader = _interopDefault(require('@emmetio/stream-reader'));\nvar _emmetio_streamReaderUtils = require('@emmetio/stream-reader-utils');\n\nconst ASTERISK = 42; // *\n\n/**\n * Consumes node repeat token from current stream position and returns its\n * parsed value\n * @param  {StringReader} stream\n * @return {Object}\n */\nvar consumeRepeat = function(stream) {\n\tif (stream.eat(ASTERISK)) {\n\t\tstream.start = stream.pos;\n\n\t\t// XXX think about extending repeat syntax with through numbering\n\t\treturn { count: stream.eatWhile(_emmetio_streamReaderUtils.isNumber) ? +stream.current() : null };\n\t}\n};\n\nconst opt = { throws: true };\n\n/**\n * Consumes quoted literal from current stream position and returns it’s inner,\n * unquoted, value\n * @param  {StringReader} stream\n * @return {String} Returns `null` if unable to consume quoted value from current\n * position\n */\nvar consumeQuoted = function(stream) {\n\tif (_emmetio_streamReaderUtils.eatQuoted(stream, opt)) {\n\t\treturn stream.current().slice(1, -1);\n\t}\n};\n\nconst LCURLY = 123; // {\nconst RCURLY = 125; // }\n\nconst opt$1 = { throws: true };\n\n/**\n * Consumes text node, e.g. contents of `{...}` and returns its inner value\n * @param  {StringReader} stream\n * @return {String} Consumed text content or `null` otherwise\n */\nvar consumeTextNode = function(stream) {\n\treturn _emmetio_streamReaderUtils.eatPair(stream, LCURLY, RCURLY, opt$1)\n\t\t? stream.current().slice(1, -1)\n\t\t: null;\n};\n\nconst EXCL       = 33; // .\nconst DOT$1        = 46; // .\nconst EQUALS     = 61; // =\nconst ATTR_OPEN  = 91; // [\nconst ATTR_CLOSE = 93; // ]\n\nconst reAttributeName = /^\\!?[\\w\\-:\\$@]+\\.?$/;\n\n/**\n * Consumes attributes defined in square braces from given stream.\n * Example:\n * [attr col=3 title=\"Quoted string\" selected. support={react}]\n * @param {StringReader} stream\n * @returns {Array} Array of consumed attributes\n */\nvar consumeAttributes = function(stream) {\n\tif (!stream.eat(ATTR_OPEN)) {\n\t\treturn null;\n\t}\n\n\tconst result = [];\n\tlet token, attr;\n\n\twhile (!stream.eof()) {\n\t\tstream.eatWhile(_emmetio_streamReaderUtils.isWhiteSpace);\n\n\t\tif (stream.eat(ATTR_CLOSE)) {\n\t\t\treturn result; // End of attribute set\n\t\t} else if ((token = consumeQuoted(stream)) != null) {\n\t\t\t// Consumed quoted value: anonymous attribute\n\t\t\tresult.push({\n\t\t\t\tname: null,\n\t\t\t\tvalue: token\n\t\t\t});\n\t\t} else if (eatUnquoted(stream)) {\n\t\t\t// Consumed next word: could be either attribute name or unquoted default value\n\t\t\ttoken = stream.current();\n\t\t\tif (!reAttributeName.test(token)) {\n\t\t\t\t// anonymous attribute\n\t\t\t\tresult.push({ name: null, value: token });\n\t\t\t} else {\n\t\t\t\t// Looks like a regular attribute\n\t\t\t\tattr = parseAttributeName(token);\n\t\t\t\tresult.push(attr);\n\n\t\t\t\tif (stream.eat(EQUALS)) {\n\t\t\t\t\t// Explicitly defined value. Could be a word, a quoted string\n\t\t\t\t\t// or React-like expression\n\t\t\t\t\tif ((token = consumeQuoted(stream)) != null) {\n\t\t\t\t\t\tattr.value = token;\n\t\t\t\t\t} else if ((token = consumeTextNode(stream)) != null) {\n\t\t\t\t\t\tattr.value = token;\n\t\t\t\t\t\tattr.options = {\n\t\t\t\t\t\t\tbefore: '{',\n\t\t\t\t\t\t\tafter: '}'\n\t\t\t\t\t\t};\n\t\t\t\t\t} else if (eatUnquoted(stream)) {\n\t\t\t\t\t\tattr.value = stream.current();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tthrow stream.error('Expected attribute name');\n\t\t}\n\t}\n\n\tthrow stream.error('Expected closing \"]\" brace');\n};\n\nfunction parseAttributeName(name) {\n\tconst options = {};\n\n\t// If a first character in attribute name is `!` — it’s an implied\n\t// default attribute\n\tif (name.charCodeAt(0) === EXCL) {\n\t\tname = name.slice(1);\n\t\toptions.implied = true;\n\t}\n\n\t// Check for last character: if it’s a `.`, user wants boolean attribute\n\tif (name.charCodeAt(name.length - 1) === DOT$1) {\n\t\tname = name.slice(0, name.length - 1);\n\t\toptions.boolean = true;\n\t}\n\n\tconst attr = { name };\n\tif (Object.keys(options).length) {\n\t\tattr.options = options;\n\t}\n\n\treturn attr;\n}\n\n/**\n * Eats token that can be an unquoted value from given stream\n * @param  {StreamReader} stream\n * @return {Boolean}\n */\nfunction eatUnquoted(stream) {\n\tconst start = stream.pos;\n\tif (stream.eatWhile(isUnquoted)) {\n\t\tstream.start = start;\n\t\treturn true;\n\t}\n}\n\nfunction isUnquoted(code) {\n\treturn !_emmetio_streamReaderUtils.isSpace(code) && !_emmetio_streamReaderUtils.isQuote(code)\n\t\t&& code !== ATTR_OPEN && code !== ATTR_CLOSE && code !== EQUALS;\n}\n\nconst HASH    = 35; // #\nconst DOT     = 46; // .\nconst SLASH   = 47; // /\n\n/**\n * Consumes a single element node from current abbreviation stream\n * @param  {StringReader} stream\n * @return {Node}\n */\nvar consumeElement = function(stream) {\n\t// consume element name, if provided\n\tconst start = stream.pos;\n\tconst node = new Node(eatName(stream));\n\tlet next;\n\n\twhile (!stream.eof()) {\n\t\tif (stream.eat(DOT)) {\n\t\t\tnode.addClass(eatName(stream));\n\t\t} else if (stream.eat(HASH)) {\n\t\t\tnode.setAttribute('id', eatName(stream));\n\t\t} else if (stream.eat(SLASH)) {\n\t\t\t// A self-closing indicator must be at the end of non-grouping node\n\t\t\tif (node.isGroup) {\n\t\t\t\tstream.backUp(1);\n\t\t\t\tthrow stream.error('Unexpected self-closing indicator');\n\t\t\t}\n\t\t\tnode.selfClosing = true;\n\t\t\tif (next = consumeRepeat(stream)) {\n\t\t\t\tnode.repeat = next;\n\t\t\t}\n\t\t\tbreak;\n\t\t} else if (next = consumeAttributes(stream)) {\n\t\t\tfor (let i = 0, il = next.length; i < il; i++) {\n\t\t\t\tnode.setAttribute(next[i]);\n\t\t\t}\n\t\t} else if ((next = consumeTextNode(stream)) !== null) {\n\t\t\tnode.value = next;\n\t\t} else if (next = consumeRepeat(stream)) {\n\t\t\tnode.repeat = next;\n\t\t} else {\n\t\t\tbreak;\n\t\t}\n\t}\n\n\tif (start === stream.pos) {\n\t\tthrow stream.error(`Unable to consume abbreviation node, unexpected ${stream.peek()}`);\n\t}\n\n\treturn node;\n};\n\nfunction eatName(stream) {\n\tstream.start = stream.pos;\n\tstream.eatWhile(isName);\n\treturn stream.current();\n}\n\nfunction isName(code) {\n\treturn _emmetio_streamReaderUtils.isAlphaNumeric(code)\n\t\t|| code === 45 /* - */\n\t\t|| code === 58 /* : */\n\t\t|| code === 36 /* $ */\n\t\t|| code === 64 /* @ */\n\t\t|| code === 33 /* ! */\n\t\t|| code === 37 /* % */;\n}\n\nconst GROUP_START = 40; // (\nconst GROUP_END   = 41; // )\nconst OP_SIBLING  = 43; // +\nconst OP_CHILD    = 62; // >\nconst OP_CLIMB    = 94; // ^\n\n/**\n * Parses given string into a node tree\n * @param  {String} str Abbreviation to parse\n * @return {Node}\n */\nfunction parse(str) {\n\tconst stream = new StreamReader(str.trim());\n\tconst root = new Node();\n\tlet ctx = root, groupStack = [], ch;\n\n\twhile (!stream.eof()) {\n\t\tch = stream.peek();\n\n\t\tif (ch === GROUP_START) { // start of group\n\t\t\t// The grouping node should be detached to properly handle\n\t\t\t// out-of-bounds `^` operator. Node will be attached right on group end\n\t\t\tconst node = new Node();\n\t\t\tconst groupCtx = groupStack.length ? last(groupStack)[0] : ctx;\n\t\t\tgroupStack.push([node, groupCtx, stream.pos]);\n\t\t\tctx = node;\n\t\t\tstream.next();\n\t\t\tcontinue;\n\t\t} else if (ch === GROUP_END) { // end of group\n\t\t\tconst lastGroup = groupStack.pop();\n\t\t\tif (!lastGroup) {\n\t\t\t\tthrow stream.error('Unexpected \")\" group end');\n\t\t\t}\n\n\t\t\tconst node = lastGroup[0];\n\t\t\tctx = lastGroup[1];\n\t\t\tstream.next();\n\n\t\t\t// a group can have a repeater\n\t\t\tif (node.repeat = consumeRepeat(stream)) {\n\t\t\t\tctx.appendChild(node);\n\t\t\t} else {\n\t\t\t\t// move all children of group into parent node\n\t\t\t\twhile (node.firstChild) {\n\t\t\t\t\tctx.appendChild(node.firstChild);\n\t\t\t\t}\n\t\t\t\t// for convenience, groups can be joined with optional `+` operator\n\t\t\t\tstream.eat(OP_SIBLING);\n\t\t\t}\n\n\t\t\tcontinue;\n\t\t}\n\n\t\tconst node = consumeElement(stream);\n\t\tctx.appendChild(node);\n\n\t\tif (stream.eof()) {\n\t\t\tbreak;\n\t\t}\n\n\t\tswitch (stream.peek()) {\n\t\t\tcase OP_SIBLING:\n\t\t\t\tstream.next();\n\t\t\t\tcontinue;\n\n\t\t\tcase OP_CHILD:\n\t\t\t\tstream.next();\n\t\t\t\tctx = node;\n\t\t\t\tcontinue;\n\n\t\t\tcase OP_CLIMB:\n\t\t\t\t// it’s perfectly valid to have multiple `^` operators\n\t\t\t\twhile (stream.eat(OP_CLIMB)) {\n\t\t\t\t\tctx = ctx.parent || ctx;\n\t\t\t\t}\n\t\t\t\tcontinue;\n\t\t}\n\t}\n\n\tif (groupStack.length) {\n\t\tstream.pos = groupStack.pop()[2];\n\t\tthrow stream.error('Expected group close');\n\t}\n\n\treturn root;\n}\n\nfunction last(arr) {\n\treturn arr[arr.length - 1];\n}\n\n/**\n * Parses given abbreviation and un-rolls it into a full tree: recursively\n * replaces repeated elements with actual nodes\n * @param  {String} abbr\n * @return {Node}\n */\nvar index = function(abbr) {\n\tconst tree = parse(abbr);\n\ttree.walk(unroll);\n\treturn tree;\n};\n\nfunction unroll(node) {\n\tif (!node.repeat || !node.repeat.count) {\n\t\treturn;\n\t}\n\n\tfor (let i = 1; i < node.repeat.count; i++) {\n\t\tconst clone = node.clone(true);\n\t\tclone.repeat.value = i;\n\t\tclone.walk(unroll);\n\t\tnode.parent.insertBefore(clone, node);\n\t}\n\n\tnode.repeat.value = node.repeat.count;\n}\n\nmodule.exports = index;\n"]} | |
require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){ | |
'use strict'; | |
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'); | |
} | |
module.exports = resolveImplicitName; | |
},{}],"@emmetio/html-transform":[function(require,module,exports){ | |
'use strict'; | |
function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } | |
var resolveImplicitTag = _interopDefault(require('@emmetio/implicit-tag')); | |
/** | |
* 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 = resolveImplicitTag(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 => 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]; | |
str = str.substring(0, r[0]) | |
+ (typeof value === 'function' ? value(str.substr(r[0], r[1])) : value) | |
+ str.substring(r[0] + r[1]); | |
} | |
return str; | |
} | |
function 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; | |
node.name = replaceNumbering(node.name, value); | |
node.value = replaceNumbering(node.value, value); | |
node.attributes.forEach(attr => { | |
const copy = node.getAttribute(attr.name).clone(); | |
copy.name = replaceNumbering(attr.name, value); | |
copy.value = replaceNumbering(attr.value, value); | |
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) { | |
// 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); | |
} | |
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) { | |
const replaced = replaceRanges(str, ranges, token => { | |
let _value = String(value); | |
// 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(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(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 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 `<a>` 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 defaultOptions = { | |
element: '__', | |
modifier: '_' | |
}; | |
const reElement = /^(-+)([a-z0-9]+)/i; | |
const reModifier = /^(_+)([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 = Object.assign({}, 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 from class name to get a base element name | |
const ix = cl.indexOf(options.modifier); | |
if (ix !== -1) { | |
out.add(cl.slice(0, ix)); | |
} | |
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 (may contain multiple) | |
while (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()); | |
node.setAttribute('class', Array.from(classNames).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; | |
while (node.parent && depth--) { | |
node = node.parent; | |
} | |
return lookup.get(node); | |
} | |
function find(arr, filter) { | |
return arr.filter(filter)[0]; | |
} | |
/** | |
* 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 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); | |
}; | |
module.exports = index; | |
},{"@emmetio/implicit-tag":1}]},{},[]) | |
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/browser-pack/_prelude.js","node_modules/@emmetio/implicit-tag/dist/implicit-tag.cjs.js","@emmetio%2Fhtml-transform"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","'use strict';\n\nconst 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(','));\nconst elementMap = {\n    p: 'span',\n    ul: 'li',\n    ol: 'li',\n    table: 'tr',\n    tr: 'td',\n    tbody: 'tr',\n    thead: 'tr',\n    tfoot: 'tr',\n    colgroup: 'col',\n    select: 'option',\n    optgroup: 'option',\n    audio: 'source',\n    video: 'source',\n    object: 'param',\n    map: 'area'\n};\n\n/**\n * Returns best child node name for given parent node name\n * @param  {String} parentName Name of parent node\n * @return {String}\n */\nfunction resolveImplicitName(parentName) {\n    parentName = (parentName || '').toLowerCase();\n    return elementMap[parentName]\n        || (inlineElements.has(parentName) ? 'span' : 'div');\n}\n\nmodule.exports = resolveImplicitName;\n","'use strict';\n\nfunction _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }\n\nvar resolveImplicitTag = _interopDefault(require('@emmetio/implicit-tag'));\n\n/**\n * Adds missing tag names for given tree depending on node’s parent name\n */\nvar implicitTags = function(tree) {\n    tree.walk(node => {\n        // resolve only nameless nodes without content\n        if (node.name == null && node.attributes.length) {\n            node.name = resolveImplicitTag(node.parent.name);\n        }\n    });\n    return tree;\n};\n\n/**\n * Locates all occurances of given `token` which are not escaped (e.g. are not\n * preceded with `\\`) given in `str`\n * @param  {String} str\n * @return {Array}  Array of token ranges\n */\nfunction findUnescapedTokens(str, token) {\n    const result = new Set();\n    const tlen = token.length;\n\n    // 1. Find all occurances of tokens\n    let pos = 0;\n    while ((pos = str.indexOf(token, pos)) !== -1) {\n        result.add(pos);\n        pos += tlen;\n    }\n\n    if (result.size) {\n        // 2. Remove ones that escaped\n        let pos = 0;\n        const len = str.length;\n\n        while (pos < len) {\n            if (str[pos++] === '\\\\') {\n                result.delete(pos++);\n            }\n        }\n    }\n\n    return Array.from(result).map(ix => range(ix, tlen));\n}\n\n/**\n * Replaces `ranges`, generated by `range()` function, with given `value` in `str`\n * @param  {String} str    Where to replace ranges\n * @param  {Array} ranges Ranes, created by `range()` function\n * @param  {String|Function} value  Replacement value. If it’s a function, it\n * will take a range value as argument and should return a new string\n * @return {String}\n */\nfunction replaceRanges(str, ranges, value) {\n\t// should walk from the end of array to keep ranges valid after replacement\n\tfor (let i = ranges.length - 1; i >= 0; i--) {\n\t\tconst r = ranges[i];\n\n\t\tstr = str.substring(0, r[0])\n\t\t\t+ (typeof value === 'function' ? value(str.substr(r[0], r[1])) : value)\n\t\t\t+ str.substring(r[0] + r[1]);\n\t}\n\n\treturn str;\n}\n\nfunction range(start, length) {\n    return [start, length];\n}\n\nconst numberingToken = '$';\n\n/**\n * Numbering of expanded abbreviation: finds all nodes with `$` in value\n * or attributes and replaces its occurances with repeater value\n */\nvar applyNumbering = function(tree) {\n    tree.walk(applyNumbering$1);\n    return tree;\n};\n\n/**\n * Applies numbering for given node: replaces occurances of numbering token\n * in node’s name, content and attributes\n * @param  {Node} node\n * @return {Node}\n */\nfunction applyNumbering$1(node) {\n    const repeater = findRepeater(node);\n\n    if (repeater && repeater.value != null) {\n        // NB replace numbering in nodes with explicit repeater only:\n        // it solves issues with abbreviations like `xsl:if[test=$foo]` where\n        // `$foo` is preferred output\n        const value = repeater.value;\n\n        node.name = replaceNumbering(node.name, value);\n        node.value = replaceNumbering(node.value, value);\n        node.attributes.forEach(attr => {\n            const copy = node.getAttribute(attr.name).clone();\n            copy.name = replaceNumbering(attr.name, value);\n            copy.value = replaceNumbering(attr.value, value);\n            node.replaceAttribute(attr.name, copy);\n        });\n    }\n\n    return node;\n}\n\n/**\n * Returns repeater object for given node\n * @param  {Node} node\n * @return {Object}\n */\nfunction findRepeater(node) {\n    while (node) {\n        if (node.repeat) {\n            return node.repeat;\n        }\n\n        node = node.parent;\n    }\n}\n\n/**\n * Replaces numbering in given string\n * @param  {String} str\n * @param  {Number} value\n * @return {String}\n */\nfunction replaceNumbering(str, value) {\n    // replace numbering in strings only: skip explicit wrappers that could\n    // contain unescaped numbering tokens\n    if (typeof str === 'string') {\n        const ranges = getNumberingRanges(str);\n        return replaceNumberingRanges(str, ranges, value);\n    }\n\n    return str;\n}\n\n/**\n * Returns numbering ranges, e.g. ranges of `$` occurances, in given string.\n * Multiple adjacent ranges are combined\n * @param  {String} str\n * @return {Array}\n */\nfunction getNumberingRanges(str) {\n    return findUnescapedTokens(str || '', numberingToken)\n    .reduce((out, range$$1) => {\n        // skip ranges that actually belongs to output placeholder or tabstops\n        if (!/[#{]/.test(str[range$$1[0] + 1] || '')) {\n            const lastRange = out[out.length - 1];\n            if (lastRange && lastRange[0] + lastRange[1] === range$$1[0]) {\n                lastRange[1] += range$$1[1];\n            } else {\n                out.push(range$$1);\n            }\n        }\n\n        return out;\n    }, []);\n}\n\n/**\n * @param  {String} str\n * @param  {Array} ranges\n * @param  {Number} value\n * @return {String}\n */\nfunction replaceNumberingRanges(str, ranges, value) {\n    const replaced = replaceRanges(str, ranges, token => {\n        let _value = String(value);\n        // pad values for multiple numbering tokens, e.g. 3 for $$$ becomes 003\n        while (_value.length < token.length) {\n            _value = '0' + _value;\n        }\n        return _value;\n    });\n\n    // unescape screened numbering tokens\n    return unescapeString(replaced);\n}\n\n/**\n * Unescapes characters, screened with `\\`, in given string\n * @param  {String} str\n * @return {String}\n */\nfunction unescapeString(str) {\n    let i = 0, result = '';\n    const len = str.length;\n\n    while (i < len) {\n        const ch = str[i++];\n        result += (ch === '\\\\') ? (str[i++] || '') : ch;\n    }\n\n    return result;\n}\n\n/** Placeholder for inserted content */\nconst placeholder = '$#';\n\n/** Placeholder for caret */\nconst caret = '|';\n\nconst reUrl = /^((?:https?|ftp|file):\\/\\/)?([\\da-z\\.-]+)\\.([a-z\\.]{2,6})([\\/\\w \\.-]*)*\\/?$/;\nconst reEmail = /^([a-z0-9_\\.-]+)@([\\da-z\\.-]+)\\.([a-z\\.]{2,6})$/;\nconst reProto = /^([a-z]+:)?\\/\\//i;\n\n/**\n * Inserts content into node with implicit repeat count: this node is then\n * duplicated for each content item and content itself is inserted either into\n * deepest child or instead of a special token.\n *\n * This method uses two distinct steps: `prepare()` and `insert()` since most\n * likely these steps will be used separately to properly insert content\n * with unescaped `$` numbering markers.\n *\n * @param {Node} tree Parsed abbreviation\n * @param {String[]} content Array of content items to insert\n * @return {Node}\n */\n/**\n * Finds nodes with implicit repeat and creates `amount` copies of it in tree\n * @param  {Node} tree\n * @param  {Number} amount\n * @return {Node}\n */\nfunction prepare(tree, amount) {\n    amount = amount || 1;\n    tree.walk(node => {\n        if (node.repeat && node.repeat.count === null) {\n            for (let i = 0; i < amount; i++) {\n                const clone = node.clone(true);\n                clone.repeat.implicit = true;\n                clone.repeat.count = amount;\n                clone.repeat.value = i + 1;\n                clone.repeat.index = i;\n                node.parent.insertBefore(clone, node);\n            }\n\n            node.remove();\n        }\n    });\n\n    return tree;\n}\n\n/**\n * Inserts content into implicitly repeated nodes, created by `prepare()` method\n * @param  {Node} tree\n * @param  {String[]} content\n * @return {Node}\n */\nfunction insert(tree, content) {\n    if (Array.isArray(content) && content.length) {\n        let updated = false;\n        tree.walk(node => {\n            if (node.repeat && node.repeat.implicit) {\n                updated = true;\n                insertContent(node, content[node.repeat.index]);\n            }\n        });\n\n        if (!updated) {\n            // no node with implicit repeat was found, insert content as\n            // deepest child\n            setNodeContent(findDeepestNode(tree), content.join('\\n'));\n        }\n    }\n\n    return tree;\n}\n\n/**\n * Inserts `content` into given `node`: either replaces output placeholders\n * or inserts it into deepest child node\n * @param  {Node} node\n * @param  {String} content\n * @return {Node}\n */\nfunction insertContent(node, content) {\n\tlet inserted = insertContentIntoPlaceholder(node, content);\n\tnode.walk(child => inserted |= insertContentIntoPlaceholder(child, content));\n\n\tif (!inserted) {\n\t\t// no placeholders were found in node, insert content into deepest child\n\t\tsetNodeContent(findDeepestNode(node), content);\n\t}\n\n\treturn node;\n}\n\n/**\n * Inserts given `content` into placeholders for given `node`. Placeholders\n * might be available in attribute values and node content\n * @param  {Node} node\n * @param  {String} content\n * @return {Boolean} Returns `true` if placeholders were found and replaced in node\n */\nfunction insertContentIntoPlaceholder(node, content) {\n\tconst state = {replaced: false};\n\n\tnode.value = replacePlaceholder(node.value, content, state);\n\tnode.attributes.forEach(attr => {\n\t\tif (attr.value) {\n\t\t\tnode.setAttribute(attr.name, replacePlaceholder(attr.value, content, state));\n\t\t}\n\t});\n\n\treturn state.replaced;\n}\n\n/**\n * Replaces all placeholder occurances in given `str` with `value`\n * @param  {String} str\n * @param  {String} value\n * @param  {Object} [_state] If provided, set `replaced` property of given\n * object to `true` if placeholder was found and replaced\n * @return {String}\n */\nfunction replacePlaceholder(str, value, _state) {\n\tif (typeof str === 'string') {\n\t\tconst ranges = findUnescapedTokens(str, placeholder);\n\t\tif (ranges.length) {\n\t\t\tif (_state) {\n\t\t\t\t_state.replaced = true;\n\t\t\t}\n\n\t\t\tstr = replaceRanges(str, ranges, value);\n\t\t}\n\t}\n\n\treturn str;\n}\n\n/**\n * Finds node which is the deepest for in current node or node iteself.\n * @param  {Node} node\n * @return {Node}\n */\nfunction findDeepestNode(node) {\n\twhile (node.children.length) {\n\t\tnode = node.children[node.children.length - 1];\n\t}\n\n\treturn node;\n}\n\n/**\n * Updates content of given node\n * @param {Node} node\n * @param {String} content\n */\nfunction setNodeContent(node, content) {\n\t// find caret position and replace it with content, if possible\n\tif (node.value) {\n\t\tconst ranges = findUnescapedTokens(node.value, caret);\n\t\tif (ranges.length) {\n\t\t\tnode.value = replaceRanges(node.value, ranges, content);\n\t\t\treturn;\n\t\t}\n\t}\n\n\tif (node.name.toLowerCase('a') || node.hasAttribute('href')) {\n\t\t// special case: inserting content into `<a>` tag\n\t\tif (reUrl.test(content)) {\n\t\t\tnode.setAttribute('href', (reProto.test(content) ? '' : 'http://') + content);\n\t\t} else if (reEmail.test(content)) {\n\t\t\tnode.setAttribute('href', 'mailto:' + content);\n\t\t}\n\t}\n\n\tnode.value = content;\n}\n\nconst defaultOptions = {\n\telement: '__',\n\tmodifier: '_'\n};\n\nconst reElement  = /^(-+)([a-z0-9]+)/i;\nconst reModifier = /^(_+)([a-z0-9]+)/i;\nconst blockCandidates1 = className => /^[a-z]\\-/i.test(className);\nconst blockCandidates2 = className => /^[a-z]/i.test(className);\n\n/**\n * BEM transformer: updates class names written as `-element` and\n * `_modifier` into full class names as described in BEM specs. Also adds missing\n * class names: fir example, if node contains `.block_modifier` class, ensures\n * that element contains `.block` class as well\n */\nvar bem = function(tree, options) {\n\toptions = Object.assign({}, defaultOptions, options);\n\n\ttree.walk(node => expandClassNames(node, options));\n\n\tconst lookup = createBlockLookup(tree);\n    tree.walk(node => expandShortNotation(node, lookup, options));\n\n\treturn tree;\n};\n\n/**\n * Expands existing class names in BEM notation in given `node`.\n * For example, if node contains `b__el_mod` class name, this method ensures\n * that element contains `b__el` class as well\n * @param  {Node} node\n * @param  {Object} options\n * @return {Set}\n */\nfunction expandClassNames(node, options) {\n\tconst classNames = node.classList.reduce((out, cl) => {\n\t\t// remove all modifiers from class name to get a base element name\n\t\tconst ix = cl.indexOf(options.modifier);\n\t\tif (ix !== -1) {\n\t\t\tout.add(cl.slice(0, ix));\n\t\t}\n\n\t\treturn out.add(cl);\n\t}, new Set());\n\n\tif (classNames.size) {\n\t\tnode.setAttribute('class', Array.from(classNames).join(' '));\n\t}\n}\n\n/**\n * Expands short BEM notation, e.g. `-element` and `_modifier`\n * @param  {Node} node      Parsed Emmet abbreviation node\n * @param  {Map} lookup     BEM block name lookup\n * @param  {Object} options\n */\nfunction expandShortNotation(node, lookup, options) {\n\tconst classNames = node.classList.reduce((out, cl) => {\n\t\tlet prefix, m;\n\t\tconst originalClass = cl;\n\n\t\t// parse element definition (could be only one)\n\t\tif (m = cl.match(reElement)) {\n\t\t\tprefix = getBlockName(node, lookup, m[1]) + options.element + m[2];\n\t\t\tout.add(prefix);\n\t\t\tcl = cl.slice(m[0].length);\n\t\t}\n\n\t\t// parse modifiers definitions (may contain multiple)\n\t\twhile (m = cl.match(reModifier)) {\n\t\t\tif (!prefix) {\n\t\t\t\tprefix = getBlockName(node, lookup, m[1]);\n\t\t\t\tout.add(prefix);\n\t\t\t}\n\n\t\t\tout.add(`${prefix}${options.modifier}${m[2]}`);\n\t\t\tcl = cl.slice(m[0].length);\n\t\t}\n\n\t\tif (cl === originalClass) {\n\t\t\t// class name wasn’t modified: it’s not a BEM-specific class,\n\t\t\t// add it as-is into output\n\t\t\tout.add(originalClass);\n\t\t}\n\n\t\treturn out;\n\t}, new Set());\n\n\tnode.setAttribute('class', Array.from(classNames).join(' '));\n}\n\n/**\n * Creates block name lookup for each node in given tree, e.g. finds block\n * name explicitly for each node\n * @param  {Node} tree\n * @return {Map}\n */\nfunction createBlockLookup(tree) {\n\tconst lookup = new Map();\n\n\ttree.walk(node => {\n\t\tconst classNames = node.classList;\n\t\tif (classNames.length) {\n\t\t\t// guess best block name from class or use parent’s block name\n\t\t\tlookup.set(node,\n\t\t\t\tfind(classNames, blockCandidates1)\n\t\t\t\t|| find(classNames, blockCandidates2)\n\t\t\t\t|| lookup.get(node.parent)\n\t\t\t);\n\t\t}\n\t});\n\n\treturn lookup;\n}\n\n/**\n * Returns block name for given `node` by `prefix`, which tells the depth of\n * of parent node lookup\n * @param  {Node} node\n * @param  {Map} lookup\n * @param  {String} prefix\n * @return {String}\n */\nfunction getBlockName(node, lookup, prefix) {\n\tlet depth = prefix.length > 1 ? prefix.length : 0;\n\twhile (node.parent && depth--) {\n\t\tnode = node.parent;\n\t}\n\n\treturn lookup.get(node);\n}\n\nfunction find(arr, filter) {\n\treturn arr.filter(filter)[0];\n}\n\n/**\n * JSX transformer: replaces `class` and `for` attributes with `className` and\n * `htmlFor` attributes respectively\n */\nvar jsx = function(tree) {\n\ttree.walk(node => {\n\t\treplace(node, 'class', 'className');\n\t\treplace(node, 'for', 'htmlFor');\n\t});\n\treturn tree;\n};\n\nfunction replace(node, oldName, newName) {\n\tlet attr = node.getAttribute(oldName);\n\tif (attr) {\n\t\tattr.name = newName;\n\t}\n}\n\nconst reSupporterNames = /^xsl:(variable|with\\-param)$/i;\n\n/**\n * XSL transformer: removes `select` attributes from certain nodes that contain\n * children\n */\nvar xsl = function(tree) {\n\ttree.walk(node => {\n\t\tif (reSupporterNames.test(node.name || '') && (node.children.length || node.value)) {\n\t\t\tnode.removeAttribute('select');\n\t\t}\n\t});\n\treturn tree;\n};\n\nconst supportedAddons = { bem, jsx, xsl };\n\n/**\n * Runs additional transforms on given tree.\n * These transforms may introduce side-effects and unexpected result\n * so they are not applied by default, authors must specify which addons\n * in `addons` argument as `{addonName: addonOptions}`\n * @param {Node} tree Parsed Emmet abbreviation\n * @param {Object} addons Add-ons to apply and their options\n */\nvar addons = function(tree, addons) {\n    Object.keys(addons || {}).forEach(key => {\n        if (key in supportedAddons) {\n            const addonOpt = typeof addons[key] === 'object' ? addons[key] : null;\n            tree = tree.use(supportedAddons[key], addonOpt);\n        }\n    });\n\n    return tree;\n};\n\n/**\n * Applies basic HTML-specific transformations for given parsed abbreviation:\n * – resolve implied tag names\n * – insert repeated content\n * – resolve node numbering\n */\nvar index = function(tree, content, appliedAddons) {\n    if (typeof content === 'string') {\n        content = [content];\n    } else if (content && typeof content === 'object' && !Array.isArray(content)) {\n        appliedAddons = content;\n        content = null;\n    }\n\n    return tree\n    .use(implicitTags)\n    .use(prepare, Array.isArray(content) ? content.length : null)\n    .use(applyNumbering)\n    .use(insert, content)\n    .use(addons, appliedAddons);\n};\n\nmodule.exports = index;\n"]} | |
// Welcome! require() some modules from npm (like you were using browserify) | |
// and then hit Run Code to run your code on the right side. | |
// Modules get downloaded from browserify-cdn and bundled in your browser. | |
require('@emmetio/abbreviation'); | |
require('@emmetio/html-transform'); | |
;}, 0) |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
{ | |
"name": "requirebin-sketch", | |
"version": "1.0.0", | |
"dependencies": { | |
"@emmetio/abbreviation": "0.6.0", | |
"@emmetio/html-transform": "0.3.1" | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
<!-- contents of this file will be placed inside the <body> --> |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
<!-- contents of this file will be placed inside the <head> --> |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment