{"version":3,"sources":["webpack:///./node_modules/base64-js/index.js","webpack:///./node_modules/ieee754/index.js","webpack:///./node_modules/buffer/index.js","webpack:///./node_modules/emmet/emmet.js","webpack:///./node_modules/isarray/index.js"],"names":["exports","byteLength","toByteArray","fromByteArray","lookup","revLookup","Arr","Uint8Array","Array","code","i","len","length","charCodeAt","getLens","b64","Error","validLen","indexOf","placeHoldersLen","lens","_byteLength","tmp","arr","curByte","tripletToBase64","num","encodeChunk","uint8","start","end","output","push","join","extraBytes","parts","maxChunkLength","len2","read","buffer","offset","isLE","mLen","nBytes","e","m","eLen","eMax","eBias","nBits","d","s","NaN","Infinity","Math","pow","write","value","c","rt","abs","isNaN","floor","log","LN2","base64","ieee754","isArray","typedArraySupport","__proto__","prototype","foo","subarray","kMaxLength","Buffer","TYPED_ARRAY_SUPPORT","createBuffer","that","RangeError","arg","encodingOrOffset","this","allocUnsafe","from","TypeError","ArrayBuffer","fromArrayBuffer","fromString","fromObject","assertSize","size","alloc","fill","encoding","undefined","checked","string","isEncoding","actual","slice","fromArrayLike","array","byteOffset","obj","isBuffer","copy","isnan","type","data","toString","SlowBuffer","isView","loweredCase","utf8ToBytes","base64ToBytes","toLowerCase","slowToString","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","b","n","bidirectionalIndexOf","val","dir","arrayIndexOf","call","lastIndexOf","indexSize","arrLength","valLength","String","buf","readUInt16BE","foundIndex","found","j","hexWrite","Number","remaining","strLen","parsed","parseInt","substr","utf8Write","blitBuffer","asciiWrite","asciiToBytes","latin1Write","base64Write","ucs2Write","utf16leToBytes","min","res","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","codePoint","bytesPerSequence","decodeCodePointsArray","INSPECT_MAX_BYTES","global","poolSize","_augment","Symbol","species","Object","defineProperty","configurable","allocUnsafeSlow","_isBuffer","compare","a","x","y","concat","list","pos","swap16","swap32","swap64","arguments","apply","equals","inspect","str","max","match","target","thisStart","thisEnd","thisCopy","targetCopy","includes","isFinite","toJSON","_arr","MAX_ARGUMENTS_LENGTH","codePoints","fromCharCode","ret","out","toHex","bytes","checkOffset","ext","checkInt","objectWriteUInt16","littleEndian","objectWriteUInt32","checkIEEE754","writeFloat","noAssert","writeDouble","newBuf","sliceLen","readUIntLE","mul","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUIntLE","maxBytes","writeUIntBE","writeUInt8","writeUInt16LE","writeUInt16BE","writeUInt32LE","writeUInt32BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","set","INVALID_BASE64_RE","base64clean","stringtrim","replace","trim","units","leadSurrogate","byteArray","hi","lo","src","dst","f","module","window","self","emmet","define","outer","modules","cache","entry","newRequire","name","jumped","id","require","snippets","setVocabulary","factory","utils","actions","parser","file","preferences","resources","profile","ciu","logger","sliceFn","getFileName","path","re","exec","normalizeProfile","indent","self_closing_tag","expandAbbreviation","abbr","syntax","contextNode","expand","run","loadExtensions","fileList","payload","userSnippets","filter","getExt","reader","readText","bind","next","shift","err","content","eval","fileName","parseJSON","test","deepMerge","loadUserData","loadPreferences","load","loadSnippets","userData","getVocabulary","loadSystemSnippets","loadCIU","resetSnippets","profiles","loadProfiles","caniuse","syntaxProfiles","syntaxprofiles","loadSyntaxProfiles","resetUserData","reset","keys","forEach","options","create","tabStops","htmlMatcher","common","action","editor","editorUtils","actionUtils","range","cssEditTree","cssSections","lastMatch","last","balanceHTML","direction","info","outputInfo","sel","getSelectionRange","equal","close","outerRange","innerRange","narrowed","narrowToNonSpace","find","createSelection","rangesForCSSRule","rule","ranges","valueRange","nestedSections","nestedSectionsInRule","items","POSITIVE_INFINITY","namePosition","create2","prop","propertyFromPosition","_unterminated","getCSSRanges","ruleRange","matchEnclosingRule","parse","substring","item","unique","valueOf","balanceCSS","sort","bestMatch","r","include","inside","bestMatchIx","outerRanges","balance","isSupportedCSS","balanceInwardAction","balanceOutwardAction","goToMatchingPairAction","getContent","caretPos","getCaretPos","charAt","tag","open","setCaretPos","startsWith","token","text","encodeToBase64","imgPath","editorFile","getFilePath","defaultMimeType","locateFile","realImgPath","encode","mimeTypes","replaceContent","decodeFromBase64","filePath","prompt","createPath","absPath","save","decode","encodeDecodeDataUrlAction","filepath","getSelection","findNewEditPoint","inc","curPoint","maxLen","nextPoint","reEmptyLine","getLine","ix","curChar","nextChar","prevChar","previousEditPointAction","curPos","newPoint","nextEditPointAction","math","evaluateMathAction","chars","findExpressionBounds","ch","isNumeric","expr","result","prettifyNumber","evaluate","handlerList","prefs","cssGradient","findAbbreviation","curLine","getCurrentLineRange","extractAbbreviation","handlers","add","captureContext","replaceFrom","replaceTo","cssSyntaxes","getArray","curContent","order","expandAbbreviationHandler","expandAbbreviationAction","args","toArray","expandAbbreviationWithTabAction","selRange","padString","replaceRange","_defaultHandler","ctx","addHandler","fn","removeHandler","remove","intLength","split","increment01Action","incrementNumber","increment1Action","increment10Action","decrement01Action","decrement1Action","decrement10Action","step","hasSign","hasDecimal","strNum","parseFloat","minus","RegExp","$1","zeroPadString","xmlSyntaxes","insertLineBreakAction","insertLineBreakOnlyAction","curPadding","getCurrentLinePadding","nl","lineRange","nextPadding","pad","getCaretPlaceholder","append","get","hasCloseBrace","il","insValue","actionModules","editPoints","evaluateMath","incrementDecrement","lineBreaks","mergeLines","reflectCSSValue","removeTag","selectItem","selectLine","splitJoinTag","toggleComment","updateImageSize","wrapWithAbbreviation","updateTag","addAction","label","humanizeActionName","toUpperCase","method","hidden","prefix","suffix","actionId","actionMethod","actionLabel","getAll","getList","all","map","key","getMenu","skipActions","actionName","menuName","submenu","pop","getActionNameForMenuTitle","title","menu","mergeLinesAction","selection","pair","lines","splitByLines","textLen","escapeText","cssResolver","doCSSReflection","cssRule","parseFromPosition","property","itemFromPosition","oldRule","source","caretDelta","caret","getReflectedCSSName","baseName","vendorPrefix","reflectValueParts","reVendor","propPrefix","findParts","reverse","part","partValue","prefixes","vendorPrefixes","replaceSubstring","reflectValue","donor","receiver","getReflectedValue","curName","curValue","refName","refValue","reflectCSSValueAction","getSyntax","compoundUpdate","reName","parent","p","reflectValueHandler","removeTagAction","tagContentRange","startLineBounds","findNewlineBounds","startLinePad","getLinePadding","tagContent","unindentString","stringStream","xmlParser","startTag","findItem","isBackward","extractFn","rangeFn","itemRange","rng","contentLength","prevRange","searchPos","loop","clone","findNextHTMLItem","isFirst","findOpeningTagFromPosition","getOpeningTagFromPosition","getRangeForHTMLItem","findPrevHTMLItem","makePossibleRangesHTML","tokens","attrValueRange","tagName","attrStart","attrName","attrValue","tok","isQuote","classNameRanges","className","stream","eatSpace","curRange","matchedRanges","html","findInnerRanges","nameRange","section","_selectorEnd","makePossibleRangesCSS","valueParts","backUp","skipToPair","fnBody","current","matchedRangeForCSSProperty","nested","findNextCSSItem","locateRule","getRangeForNextItemInCSS","findPrevCSSItem","getRangeForPrevItemInCSS","tree","selectNextItemAction","selectPreviousItemAction","selectLineAction","matcher","joinTag","slash","selfClosing","splitTag","tag_nl","outerContent","splitJoinTagAction","profileName","curProfile","toggleHTMLComment","genericCommentToggle","toggleCSSComment","cssItemFromPosition","absPos","relPos","reSafeChar","searchComment","startToken","endToken","commentStart","commentEnd","hasMatch","contentLen","newContent","removeComment","escapeForRegexp","commentRange","overlap","unindent","toggleCommentAction","xmlEditTree","updateImageSizeHTML","xmlElem","getImageSizeForSource","compoundData","width","height","extend","updateImageSizeCSS","callback","fileContent","getImageSize","updateImageSizeAction","updateAttributes","abbrNode","classNames","attribute","replaceCounter","counter","addClass","removeClass","attributeList","attr","tagAttr","updateTagAction","getUpdatedTag","children","node","el","wrapWithAbbreviationAction","pastedContent","cssDB","vendorsDB","erasDB","intersection","arr1","arr2","smaller","larger","parseDB","optimized","JSON","optimize","vendors","css","era","parseVendors","parseCSS","parseEra","agents","agent","versions","cats","CSS","kw","stats","eras","getVendorsList","allVendors","getVersionSlice","db","amd","resolvePrefixes","propStats","vendor","v","vendorVesions","factories","reAttrs","commonFactory","elem","is","elementName","attrs","isEmpty","is_empty","attributes","isDefault","isImplied","HandlerList","_list","splice","listFn","skipValue","h","reOpenTag","reCloseTag","openTag","selfClose","closeTag","comment","createMatcher","memo","matches","clean","pattern","findClosingPair","stack","jl","cmp","contains","_c","innerContent","console","defaults","_dbgDefaults","_dbgPreferences","toBoolean","isValueObj","description","k","getDict","json","exportModified","_startTest","_stopTest","defaultProfile","tag_case","attr_case","attr_quotes","tag_nl_leaf","place_cursor","inline_break","compact_bool","filters","extraFilters","OutputProfile","stringCase","caseValue","createProfile","createDefaultProfiles","attributeName","attributeQuote","cursor","isBoolean","boolAttrs","allowCompactBoolean","plain","op","Range","delta","union","loc","left","right","isRange","elements","stringScore","VOC_SYSTEM","VOC_USER","reTag","systemSettings","userSettings","resolvers","each","normalizeCaretPlaceholder","replaceUnescapedSymbol","parseItem","parseAbbreviation","normalizeName","expandSnippetsDefinition","voc","_section","subsection","getMatchedResource","findSnippet","getVariable","getSection","setVariable","variables","hasSyntax","addResolver","removeResolver","subsections","topSection","names","matchedItem","some","sectionName","fuzzyFindSnippet","minScore","fuzzyFindMatches","parsedValue","getAllSnippets","score","nk","cacheKey","sectionKey","stackItem","getNewline","setNewline","resolve","StringStream","_length","eol","sol","peek","eat","ok","eatWhile","skipToEnd","skipTo","skipString","braceCount","skipQuoted","noBackup","quote","consume","caseInsensitive","cased","startPlaceholderNum","tabstopIndex","defaultOptions","replaceCarets","escape","tabstop","variable","extract","placeholders","carets","marks","placeholder","group","processText","lastIx","mark","ph","tabstops","upgrade","maxNum","variablesResolver","placeholderMemo","varName","varValue","replaceVariables","vars","resolver","p1","newValue","resetTabstopIndex","abbrOutputProcessor","tsOptions","TokenIterator","_position","hasNext","_i","_il","position","itemNext","itemPrev","nextUntil","t","klass","EditContainer","_children","_positions","initialize","EditElement","nameToken","valueToken","_name","_value","_pos","isAbsolute","_updateSource","update","recursiveUpdate","indexes","element","fullRange","values","valuePosition","createToken","editTree","cssParser","tokenIterator","styleBefore","styleSeparator","reSpaceStart","reSpaceEnd","WHITESPACE_REMOVE_FROM_START","WHITESPACE_REMOVE_FROM_END","trimWhitespaceInRange","mask","consumeSingleProperty","it","ws","isAtProperty","lastNewline","sep","consumeProperties","extractPropertiesFromSource","CSSEditElement","nameText","valueText","endText","CSSEditContainer","toSource","allRules","findAllRules","currentRule","topLevelRules","isTopLevel","tr","selectorRange","contentStart","_contentStart","sectionOffset","_saveStyle","styles","pick","_end","isUpdating","allItems","isIncomplete","constructor","__super__","bounds","cssProp","styleQuote","XMLEditContainer","attrToken","XMLEditElement","classVal","classList","reClass","extractTag","htmlFilter","abbreviationUtils","shouldRunHtmlFilter","getSeparators","modifier","bemParse","isSnippet","__bem","block","normalizeClassName","reBlockName","processClassName","flatten","shortSymbol","repeatString","transformClassName","separators","modifiers","blockModifiers","entityType","reSep","depth","cleanName","process","template","abbrUtils","addComments","templateBefore","templateAfter","trigger","shouldAdd","padding","before","after","nodeBefore","nodeAfter","isBlock","isVeryFirstChild","index","level","charMap","escapeChars","getIndentation","hasBlockSibling","hasBlockChildren","shouldAddLineBreak","shouldFormatInline","shouldBreakChild","nodeCount","child","isTextNode","isInline","isRoot","processSnippet","shouldBreakInsideInline","hasBlockElems","processTag","isUnary","forceNl","forceIndentTags","hasTagsInContent","formatFilter","condenseDataAttrs","reData","stringifyAttrs","attrQuote","makeAttributesString","otherAttrs","reNl","reIndentedText","reSpace","processTagContent","attrMap","_attributes","registeredFilters","haml","jade","jsx","slim","xsl","bem","basicFilters","composeList","additionalFilters","rePad","getAttrWrapper","attrWrap","tags","trimAttribute","langs","en","words","sp","ru","randint","to","round","random","sample","count","iterations","randIx","choice","sentence","insertCommas","totalCommas","word","paragraph","lang","wordCount","startWithCommon","totalWords","addLang","preprocessor","allowCommon","findAll","wordCound","isRepeating","lorem","procPastedContent","procTagName","procResourceMatcher","procAttributes","procHref","reValidName","reWord","DEFAULT_ATTR_NAME","pairs","spliceFn","preprocessors","postprocessors","outputProcessors","AbbreviationNode","abbreviation","_text","repeatCount","hasImplicitRepeat","_data","stripped","multiplier","root","context","addChild","loopProtector","consumeAbbr","isMarker","isAllowedChar","inner","_setRepeat","setAbbreviation","splitAttributes","attrSet","unquote","extractAttributes","reAttrName","parseAttributes","nameEnd","optimizeAttributes","la","extractText","unroll","maxCount","updateProperty","squash","isGroup","charCode","specialChars","amount","state","elemName","vals","attrNames","abbrText","abbrAttrs","insertChildContent","keepVariable","hasEmptyChildren","hasImplicitName","isElement","deepestChild","mod","postprocessor","attrLookup","defaultSyntax","outputTree","filtersList","addPreprocessor","removeFilter","addPostprocessor","removePostprocessor","addOutputProcessor","removeOutputProcessor","session","walker","init","chnum","isNameChar","cc","isDigit","isOp","opsa","opsmatcha","ops","opsmatch","matchattr","tokener","getPosInfo","w","errPos","fullLine","chunkSize","formattedLine","line","hint","raiseError","message","error","errObj","white","cnext","eatString","q","brace","stop","identifier","pre","nondigit","point","tokenize","lex","toks","findDefault","findImplied","findEmpty","resolveDefaultAttrs","attrList","defaultAttrValue","defaultAttr","oldVal","newVal","pc","reUrl","reEmail","reProto","outputPlaceholder","locateOutputPlaceholder","replaceOutputPlaceholders","hasOutputPlaceholder","insertPastedContent","overwrite","nodesWithPlaceholders","unshift","deepest","targets","matchResources","elemType","subtree","repeatedChildren","resolveNodeNames","Kludges","autoSelfClosers","implicitlyClosed","contextGrabbers","doNotIndent","allowUnquoted","allowMissing","inText","chain","inBlock","doctype","inTag","inAttribute","style","terminator","setStyle","curState","pass","cont","pushContext","startOfLine","noIndent","hasOwnProperty","prev","indented","popContext","endtag","endclosetag","maybePopContext","callee","nextTagName","parentTagName","attvalue","attvaluemaybe","startState","comb","_transport","bts","isURL","fs","http","https","_parseParams","params","_read","req","bufs","totalLength","finished","on","chunk","abort","fd","openSync","bytesRead","readFileSync","dirname","existsSync","stat","isFile","writeFile","prefixObj","obsolete","transformName","properties","getProperties","supports","defaultValue","descTemplate","descAddonTemplate","props","isSingleProperty","snippet","normalizeValue","normalizeHexColor","getKeyword","hex","opacity","repeat","color","toRgba","g","aliases","getUnit","isValidKeyword","keyword","hasPrefix","findVendorPrefixes","findInternalPrefixes","noAutofill","prefixMap","addPrefix","getSyntaxPreference","formatProperty","transformSnippet","isImportant","addon","without","resolvePrefixedValues","snippetObj","supportsPrefix","expandToSnippet","prefixed","listPrefixes","getPrefix","removePrefix","extractPrefixes","findValuesInAbbreviation","keywords","lastPart","parseValues","extractValues","abbrValues","unitlessProps","unit","autoInsertPrefixes","prefixData","valuesData","abbrData","endsWith","splitSnippet","propName","pads","getStringsPads","linearGradient","resolvePropertyName","getGradientPrefixes","getPropertiesForGradient","gradients","propertyName","omitDir","gradient","colorStops","insertGradientsIntoCSSValue","oldWebkit","omitDefaultDirection","stringifyOldWebkit","stringify","matchedPart","similarPropertyNames","similarProps","pasteGradient","alignVendor","propsToInsert","valuePads","namePads","isValidCaretPosition","findGradients","isLinearGradient","gradientsFromCSSProperty","grd","cssProperty","ruleStart","ruleEnd","insertPos","_gradients","resolvedName","expandGradientOutsideValue","fakeCSS","localGradients","localValue","dfn","directions","defaultDirections","reLinearGradient","reDeg","reKeyword","LinearGradient","cur","addColorStop","resolveDirection","normalizeSpace","top","bottom","stringifyDirection","oldStyle","reNewStyle","oldWebkitDirection","parseColorStop","colorStop","cs","_fillImpliedPositions","toFixed","cs2","elementTypes","empty","blockLevel","inlineLevel","elementMap","getMapping","isInlineLevel","isTypeOf","isBlockLevel","isEmptyElement","addMapping","removeMapping","addElementToCollection","collection","col","getCollection","removeElementFromCollection","matchesTag","childContent","appendIfNoChild","childVariableReplaced","getLinePaddingFromPosition","abbreviationParser","curOffset","startIndex","groupCount","textCount","endsWithTag","pngMagicNum","jpgMagicNum","gifMagicNum","nextByte","l","marker","allowedSyntaxes","tagTree","exprStart","exprEnd","detectSyntax","isStyle","isInlineCSS","detectProfile","isXHTML","search","styleTagRange","styleAttrRange","input","chr1","chr2","chr3","enc1","enc2","enc3","enc4","cdp1","cdp2","cdp3","o1","o2","o3","h1","h2","h3","h4","bits","ac","tmpArr","reHasComment","strip","ch2","replaceRanges","replaceWith","caretPlaceholder","removeEmpty","howMany","strings","lengths","reduce","pl","symbol","sl","matchCount","curSl","replaceData","total","matchNum","base","decrement","unescapeText","setCaretPlaceholder","specials","fraction","noRepeat","fragments","repl","copyIsArray","comparator","sliceIx","commentsUtils","idCounter","maxId","reSpaceTrim","getId","CSSSection","nextSibling","previousSibling","_source","_content","lastChild","matchDeep","allRanges","sanitize","saveRule","extractSelector","matchBracesRanges","endPos","selector","rules","subrange","ctxRule","sectionTree","insert","isInsideTag","getProfileName","getCurrentLine","normalize","newline","indentation","tabs","space","object","o","F","TNUMBER","TOP1","TOP2","TVAR","TFUNCALL","Token","type_","index_","prio_","number_","Expression","ops1","ops2","functions","escapable","meta","escapeValue","lastIndex","div","neg","fac","pyt","sqrt","Parser","success","errormsg","expression","tokennumber","tokenprio","tokenindex","tmpprio","sin","cos","tan","asin","acos","atan","ceil","exp","atan2","consts","E","PI","simplify","n1","n2","nstack","newexpression","L","substitute","expritem","replitem","toJS","toJSFunction","param","Function","PRIMARY","OPERATOR","FUNCTION","LPAREN","RPAREN","COMMA","SIGN","CALL","NULLARY_CALL","operstack","tokenstack","expected","noperators","isOperator","isSign","isNegativeSign","addfunc","isComment","error_parsing","isNumber","isString","isLeftParenth","isRightParenth","isComma","isConst","consttoken","isOp2","isOp1","isVar","vartoken","isWhite","column","msg","operator","unescape","escaping","startpos","isPositiveSign","parseArgs","parseFunctionCall","fnName","evalArg","fnArgs","ctor","inherits","protoProps","staticProps","classProps","fuzziness","start_of_string_bonus","abbreviation_score","final_score","character_score","index_in_string","index_c_lowercase","index_c_uppercase","min_index","total_character_score","abbreviation_length","string_length","fuzzies"],"mappings":"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","file":"js/chunk-b1acf4ba.605c70bb.js","sourcesContent":["'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n  var validLen = b64.indexOf('=')\n  if (validLen === -1) validLen = len\n\n  var placeHoldersLen = validLen === len\n    ? 0\n    : 4 - (validLen % 4)\n\n  return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n  var tmp\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n  var curByte = 0\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  var len = placeHoldersLen > 0\n    ? validLen - 4\n    : validLen\n\n  var i\n  for (i = 0; i < len; i += 4) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 18) |\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n      revLookup[b64.charCodeAt(i + 3)]\n    arr[curByte++] = (tmp >> 16) & 0xFF\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 2) |\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 10) |\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] +\n    lookup[num >> 12 & 0x3F] +\n    lookup[num >> 6 & 0x3F] +\n    lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp =\n      ((uint8[i] << 16) & 0xFF0000) +\n      ((uint8[i + 1] << 8) & 0xFF00) +\n      (uint8[i + 2] & 0xFF)\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(\n      uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)\n    ))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 2] +\n      lookup[(tmp << 4) & 0x3F] +\n      '=='\n    )\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 10] +\n      lookup[(tmp >> 4) & 0x3F] +\n      lookup[(tmp << 2) & 0x3F] +\n      '='\n    )\n  }\n\n  return parts.join('')\n}\n","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n  ? global.TYPED_ARRAY_SUPPORT\n  : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n  try {\n    var arr = new Uint8Array(1)\n    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n    return arr.foo() === 42 && // typed array instances can be augmented\n        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n  } catch (e) {\n    return false\n  }\n}\n\nfunction kMaxLength () {\n  return Buffer.TYPED_ARRAY_SUPPORT\n    ? 0x7fffffff\n    : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length')\n  }\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = new Uint8Array(length)\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    if (that === null) {\n      that = new Buffer(length)\n    }\n    that.length = length\n  }\n\n  return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length)\n  }\n\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error(\n        'If encoding is specified then the first argument must be a string'\n      )\n    }\n    return allocUnsafe(this, arg)\n  }\n  return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n  arr.__proto__ = Buffer.prototype\n  return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n  if (typeof value === 'number') {\n    throw new TypeError('\"value\" argument must not be a number')\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return fromArrayBuffer(that, value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'string') {\n    return fromString(that, value, encodingOrOffset)\n  }\n\n  return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype\n  Buffer.__proto__ = Uint8Array\n  if (typeof Symbol !== 'undefined' && Symbol.species &&\n      Buffer[Symbol.species] === Buffer) {\n    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n    Object.defineProperty(Buffer, Symbol.species, {\n      value: null,\n      configurable: true\n    })\n  }\n}\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be a number')\n  } else if (size < 0) {\n    throw new RangeError('\"size\" argument must not be negative')\n  }\n}\n\nfunction alloc (that, size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(that, size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(that, size).fill(fill, encoding)\n      : createBuffer(that, size).fill(fill)\n  }\n  return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n  assertSize(size)\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0\n    }\n  }\n  return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('\"encoding\" must be a valid string encoding')\n  }\n\n  var length = byteLength(string, encoding) | 0\n  that = createBuffer(that, length)\n\n  var actual = that.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    that = that.slice(0, actual)\n  }\n\n  return that\n}\n\nfunction fromArrayLike (that, array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  that = createBuffer(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n  array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\\'offset\\' is out of bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\\'length\\' is out of bounds')\n  }\n\n  if (byteOffset === undefined && length === undefined) {\n    array = new Uint8Array(array)\n  } else if (length === undefined) {\n    array = new Uint8Array(array, byteOffset)\n  } else {\n    array = new Uint8Array(array, byteOffset, length)\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = array\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromArrayLike(that, array)\n  }\n  return that\n}\n\nfunction fromObject (that, obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    that = createBuffer(that, len)\n\n    if (that.length === 0) {\n      return that\n    }\n\n    obj.copy(that, 0, 0, len)\n    return that\n  }\n\n  if (obj) {\n    if ((typeof ArrayBuffer !== 'undefined' &&\n        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0)\n      }\n      return fromArrayLike(that, obj)\n    }\n\n    if (obj.type === 'Buffer' && isArray(obj.data)) {\n      return fromArrayLike(that, obj.data)\n    }\n  }\n\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < kMaxLength()` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers')\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length)\n  var pos = 0\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i]\n    if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    }\n    buf.copy(buffer, pos)\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    string = '' + string\n  }\n\n  var len = string.length\n  if (len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) return utf8ToBytes(string).length // assume utf8\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  var i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  var len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  var len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  var len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length | 0\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n    if (this.length > max) str += ' ... '\n  }\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer')\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  var x = thisEnd - thisStart\n  var y = end - start\n  var len = Math.min(x, y)\n\n  var thisCopy = this.slice(thisStart, thisEnd)\n  var targetCopy = target.slice(start, end)\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset  // Coerce to Number.\n  if (isNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (Buffer.TYPED_ARRAY_SUPPORT &&\n        typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1\n  var arrLength = arr.length\n  var valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  var i\n  if (dir) {\n    var foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (isNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0\n    if (isFinite(length)) {\n      length = length | 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n      : (firstByte > 0xBF) ? 2\n      : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = this.subarray(start, end)\n    newBuf.__proto__ = Buffer.prototype\n  } else {\n    var sliceLen = end - start\n    newBuf = new Buffer(sliceLen, undefined)\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start]\n    }\n  }\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n      (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = (value >>> 24)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 1] = (value >>> 8)\n    this[offset] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 3] = (value >>> 24)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n  var i\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; ++i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, start + len),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if (code < 256) {\n        val = code\n      }\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  var i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val)\n      ? val\n      : utf8ToBytes(new Buffer(val, encoding).toString())\n    var len = bytes.length\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\nfunction isnan (val) {\n  return val !== val // eslint-disable-line no-self-compare\n}\n","!function(e){var val=e(); if(\"object\"==typeof exports&&\"undefined\"!=typeof module)module.exports=val;if(\"function\"==typeof define&&define.amd)define(\"emmet\",[],val);{var f;\"undefined\"!=typeof window?f=window:\"undefined\"!=typeof global?f=global:\"undefined\"!=typeof self&&(f=self),f.emmet=val}}(function(){var define,module,exports;return (function outer (modules, cache, entry) {\n    // Save the require from previous bundle to this closure if any\n    var previousRequire = typeof require == \"function\" && require;\n\n    function newRequire(name, jumped){\n        if(!cache[name]) {\n            if(!modules[name]) {\n                // if we cannot find the the module within our internal map or\n                // cache jump to the current global require ie. the last bundle\n                // that was added to the page.\n                var currentRequire = typeof require == \"function\" && require;\n                if (!jumped && currentRequire) return currentRequire(name, true);\n\n                // If there are other bundles on this page the require from the\n                // previous one is saved to 'previousRequire'. Repeat this as\n                // many times as there are bundles until the module is found or\n                // we exhaust the require chain.\n                if (previousRequire) return previousRequire(name, true);\n                var err = new Error('Cannot find module \\'' + name + '\\'');\n                err.code = 'MODULE_NOT_FOUND';\n                throw err;\n            }\n            var m = cache[name] = {exports:{}};\n            modules[name][0].call(m.exports, function(x){\n                var id = modules[name][1][x];\n                return newRequire(id ? id : x);\n            },m,m.exports,outer,modules,cache,entry);\n        }\n        return cache[name].exports;\n    }\n    for(var i=0;i<entry.length;i++) newRequire(entry[i]);\n\n    // Override the current require with this new one\n    return newRequire;\n})\n({\"./bundles/snippets.js\":[function(require,module,exports){\n/**\n * Bundler, used in builder script to statically\n * include snippets.json into bundle\n */\nvar res = require('../lib/assets/resources');\nvar snippets = require('../lib/snippets.json');\nres.setVocabulary(snippets, 'system');\n\n},{\"../lib/assets/resources\":\"assets\\\\resources.js\",\"../lib/snippets.json\":\"snippets.json\"}],\"./lib/emmet.js\":[function(require,module,exports){\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar global = typeof self != 'undefined' ? self : this;\n\n\tvar utils = require('./utils/common');\n\tvar actions = require('./action/main');\n\tvar parser = require('./parser/abbreviation');\n\tvar file = require('./plugin/file');\n\n\tvar preferences = require('./assets/preferences');\n\tvar resources = require('./assets/resources');\n\tvar profile = require('./assets/profile');\n\tvar ciu = require('./assets/caniuse');\n\tvar logger = require('./assets/logger');\n\n\tvar sliceFn = Array.prototype.slice;\n\n\t/**\n\t * Returns file name part from path\n\t * @param {String} path Path to file\n\t * @return {String}\n\t */\n\tfunction getFileName(path) {\n\t\tvar re = /([\\w\\.\\-]+)$/i;\n\t\tvar m = re.exec(path);\n\t\treturn m ? m[1] : '';\n\t}\n\n\t/**\n\t * Normalizes profile definition: converts some\n\t * properties to valid data types\n\t * @param {Object} profile\n\t * @return {Object}\n\t */\n\tfunction normalizeProfile(profile) {\n\t\tif (typeof profile === 'object') {\n\t\t\tif ('indent' in profile) {\n\t\t\t\tprofile.indent = !!profile.indent;\n\t\t\t}\n\n\t\t\tif ('self_closing_tag' in profile) {\n\t\t\t\tif (typeof profile.self_closing_tag === 'number') {\n\t\t\t\t\tprofile.self_closing_tag = !!profile.self_closing_tag;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn profile;\n\t}\n\n\treturn {\n\t\t/**\n\t\t * The essential function that expands Emmet abbreviation\n\t\t * @param {String} abbr Abbreviation to parse\n\t\t * @param {String} syntax Abbreviation's context syntax\n\t\t * @param {String} profile Output profile (or its name)\n\t\t * @param {Object} contextNode Contextual node where abbreviation is\n\t\t * written\n\t\t * @return {String}\n\t\t */\n\t\texpandAbbreviation: function(abbr, syntax, profile, contextNode) {\n\t\t\treturn parser.expand(abbr, {\n\t\t\t\tsyntax: syntax,\n\t\t\t\tprofile: profile,\n\t\t\t\tcontextNode: contextNode\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Runs given action\n\t\t * @param  {String} name Action name\n\t\t * @param  {IEmmetEditor} editor Editor instance\n\t\t * @return {Boolean} Returns true if action was performed successfully\n\t\t */\n\t\trun: function(name) {\n\t\t\treturn actions.run.apply(actions, sliceFn.call(arguments, 0));\n\t\t},\n\n\t\t/**\n\t\t * Loads Emmet extensions. Extensions are simple .js files that\n\t\t * uses Emmet modules and resources to create new actions, modify\n\t\t * existing ones etc.\n\t\t * @param {Array} fileList List of absolute paths to files in extensions\n\t\t * folder. Back-end app should not filter this list (e.g. by extension)\n\t\t * but return it \"as-is\" so bootstrap can decide how to load contents\n\t\t * of each file.\n\t\t * This method requires a <code>file</code> module of <code>IEmmetFile</code>\n\t\t * interface to be implemented.\n\t\t * @memberOf bootstrap\n\t\t */\n\t\tloadExtensions: function(fileList) {\n\t\t\tvar payload = {};\n\t\t\tvar userSnippets = null;\n\t\t\tvar that = this;\n\n\t\t\t// make sure file list contians only valid extension files\n\t\t\tfileList = fileList.filter(function(f) {\n\t\t\t\tvar ext = file.getExt(f);\n\t\t\t\treturn ext === 'json' || ext === 'js';\n\t\t\t});\n\n\t\t\tvar reader = (file.readText || file.read).bind(file);\n\t\t\tvar next = function() {\n\t\t\t\tif (fileList.length) {\n\t\t\t\t\tvar f = fileList.shift();\n\t\t\t\t\treader(f, function(err, content) {\n\t\t\t\t\t\tif (err) {\n\t\t\t\t\t\t\tlogger.log('Unable to read \"' + f + '\" file: '+ err);\n\t\t\t\t\t\t\treturn next();\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tswitch (file.getExt(f)) {\n\t\t\t\t\t\t\tcase 'js':\n\t\t\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\t\t\teval(content);\n\t\t\t\t\t\t\t\t} catch (e) {\n\t\t\t\t\t\t\t\t\tlogger.log('Unable to eval \"' + f + '\" file: '+ e);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\tcase 'json':\n\t\t\t\t\t\t\t\tvar fileName = getFileName(f).toLowerCase().replace(/\\.json$/, '');\n\t\t\t\t\t\t\t\tcontent = utils.parseJSON(content);\n\t\t\t\t\t\t\t\tif (/^snippets/.test(fileName)) {\n\t\t\t\t\t\t\t\t\tif (fileName === 'snippets') {\n\t\t\t\t\t\t\t\t\t\t// data in snippets.json is more important to user\n\t\t\t\t\t\t\t\t\t\tuserSnippets = content;\n\t\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\t\tpayload.snippets = utils.deepMerge(payload.snippets || {}, content);\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\tpayload[fileName] = content;\n\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tnext();\n\t\t\t\t\t});\n\t\t\t\t} else {\n\t\t\t\t\t// complete\n\t\t\t\t\tif (userSnippets) {\n\t\t\t\t\t\tpayload.snippets = utils.deepMerge(payload.snippets || {}, userSnippets);\n\t\t\t\t\t}\n\n\t\t\t\t\tthat.loadUserData(payload);\n\t\t\t\t}\n\t\t\t};\n\n\t\t\tnext();\n\t\t},\n\n\t\t/**\n\t\t * Loads preferences from JSON object (or string representation of JSON)\n\t\t * @param {Object} data\n\t\t * @returns\n\t\t */\n\t\tloadPreferences: function(data) {\n\t\t\tpreferences.load(utils.parseJSON(data));\n\t\t},\n\n\t\t/**\n\t\t * Loads user snippets and abbreviations. It doesn’t replace current\n\t\t * user resource vocabulary but merges it with passed one. If you need\n\t\t * to <i>replaces</i> user snippets you should call\n\t\t * <code>resetSnippets()</code> method first\n\t\t */\n\t\tloadSnippets: function(data) {\n\t\t\tdata = utils.parseJSON(data);\n\n\t\t\tvar userData = resources.getVocabulary('user') || {};\n\t\t\tresources.setVocabulary(utils.deepMerge(userData, data), 'user');\n\t\t},\n\n\t\t/**\n\t\t * Helper function that loads default snippets, defined in project’s\n\t\t * <i>snippets.json</i>\n\t\t * @param {Object} data\n\t\t */\n\t\tloadSystemSnippets: function(data) {\n\t\t\tresources.setVocabulary(utils.parseJSON(data), 'system');\n\t\t},\n\n\t\t/**\n\t\t * Helper function that loads Can I Use database\n\t\t * @param {Object} data\n\t\t */\n\t\tloadCIU: function(data) {\n\t\t\tciu.load(utils.parseJSON(data));\n\t\t},\n\n\t\t/**\n\t\t * Removes all user-defined snippets\n\t\t */\n\t\tresetSnippets: function() {\n\t\t\tresources.setVocabulary({}, 'user');\n\t\t},\n\n\t\t/**\n\t\t * Helper function that loads all user data (snippets and preferences)\n\t\t * defined as a single JSON object. This is useful for loading data\n\t\t * stored in a common storage, for example <code>NSUserDefaults</code>\n\t\t * @param {Object} data\n\t\t */\n\t\tloadUserData: function(data) {\n\t\t\tdata = utils.parseJSON(data);\n\t\t\tif (data.snippets) {\n\t\t\t\tthis.loadSnippets(data.snippets);\n\t\t\t}\n\n\t\t\tif (data.preferences) {\n\t\t\t\tthis.loadPreferences(data.preferences);\n\t\t\t}\n\n\t\t\tif (data.profiles) {\n\t\t\t\tthis.loadProfiles(data.profiles);\n\t\t\t}\n\n\t\t\tif (data.caniuse) {\n\t\t\t\tthis.loadCIU(data.caniuse);\n\t\t\t}\n\n\t\t\tvar profiles = data.syntaxProfiles || data.syntaxprofiles;\n\t\t\tif (profiles) {\n\t\t\t\tthis.loadSyntaxProfiles(profiles);\n\t\t\t}\n\t\t},\n\n\t\t/**\n\t\t * Resets all user-defined data: preferences, snippets etc.\n\t\t * @returns\n\t\t */\n\t\tresetUserData: function() {\n\t\t\tthis.resetSnippets();\n\t\t\tpreferences.reset();\n\t\t\tprofile.reset();\n\t\t},\n\n\t\t/**\n\t\t * Load syntax-specific output profiles. These are essentially\n\t\t * an extension to syntax snippets\n\t\t * @param {Object} profiles Dictionary of profiles\n\t\t */\n\t\tloadSyntaxProfiles: function(profiles) {\n\t\t\tprofiles = utils.parseJSON(profiles);\n\t\t\tvar snippets = {};\n\t\t\tObject.keys(profiles).forEach(function(syntax) {\n\t\t\t\tvar options = profiles[syntax];\n\t\t\t\tif (!(syntax in snippets)) {\n\t\t\t\t\tsnippets[syntax] = {};\n\t\t\t\t}\n\t\t\t\tsnippets[syntax].profile = normalizeProfile(options);\n\t\t\t});\n\n\t\t\tthis.loadSnippets(snippets);\n\t\t},\n\n\t\t/**\n\t\t * Load named profiles\n\t\t * @param {Object} profiles\n\t\t */\n\t\tloadProfiles: function(profiles) {\n\t\t\tprofiles = utils.parseJSON(profiles);\n\t\t\tObject.keys(profiles).forEach(function(name) {\n\t\t\t\tprofile.create(name, normalizeProfile(profiles[name]));\n\t\t\t});\n\t\t},\n\n\t\t// expose some useful data for plugin authors\n\t\tactions: actions,\n\t\tparser: parser,\n\t\tfile: file,\n\t\tpreferences: preferences,\n\t\tresources: resources,\n\t\tprofile: profile,\n\t\ttabStops: require('./assets/tabStops'),\n\t\thtmlMatcher: require('./assets/htmlMatcher'),\n\t\tutils: {\n\t\t\tcommon: utils,\n\t\t\taction: require('./utils/action'),\n\t\t\teditor: require('./utils/editor')\n\t\t}\n\t};\n});\n\n},{\"./action/main\":\"action\\\\main.js\",\"./assets/caniuse\":\"assets\\\\caniuse.js\",\"./assets/htmlMatcher\":\"assets\\\\htmlMatcher.js\",\"./assets/logger\":\"assets\\\\logger.js\",\"./assets/preferences\":\"assets\\\\preferences.js\",\"./assets/profile\":\"assets\\\\profile.js\",\"./assets/resources\":\"assets\\\\resources.js\",\"./assets/tabStops\":\"assets\\\\tabStops.js\",\"./parser/abbreviation\":\"parser\\\\abbreviation.js\",\"./plugin/file\":\"plugin\\\\file.js\",\"./utils/action\":\"utils\\\\action.js\",\"./utils/common\":\"utils\\\\common.js\",\"./utils/editor\":\"utils\\\\editor.js\"}],\"action\\\\balance.js\":[function(require,module,exports){\n/**\n * HTML pair matching (balancing) actions\n * @constructor\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar htmlMatcher = require('../assets/htmlMatcher');\n\tvar utils = require('../utils/common');\n\tvar editorUtils = require('../utils/editor');\n\tvar actionUtils = require('../utils/action');\n\tvar range = require('../assets/range');\n\tvar cssEditTree = require('../editTree/css');\n\tvar cssSections = require('../utils/cssSections');\n\tvar lastMatch = null;\n\n\tfunction last(arr) {\n\t\treturn arr[arr.length - 1];\n\t}\n\n\tfunction balanceHTML(editor, direction) {\n\t\tvar info = editorUtils.outputInfo(editor);\n\t\tvar content = info.content;\n\t\tvar sel = range(editor.getSelectionRange());\n\t\t\n\t\t// validate previous match\n\t\tif (lastMatch && !lastMatch.range.equal(sel)) {\n\t\t\tlastMatch = null;\n\t\t}\n\t\t\n\t\tif (lastMatch && sel.length()) {\n\t\t\tif (direction == 'in') {\n\t\t\t\t// user has previously selected tag and wants to move inward\n\t\t\t\tif (lastMatch.type == 'tag' && !lastMatch.close) {\n\t\t\t\t\t// unary tag was selected, can't move inward\n\t\t\t\t\treturn false;\n\t\t\t\t} else {\n\t\t\t\t\tif (lastMatch.range.equal(lastMatch.outerRange)) {\n\t\t\t\t\t\tlastMatch.range = lastMatch.innerRange;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tvar narrowed = utils.narrowToNonSpace(content, lastMatch.innerRange);\n\t\t\t\t\t\tlastMatch = htmlMatcher.find(content, narrowed.start + 1);\n\t\t\t\t\t\tif (lastMatch && lastMatch.range.equal(sel) && lastMatch.outerRange.equal(sel)) {\n\t\t\t\t\t\t\tlastMatch.range = lastMatch.innerRange;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif (\n\t\t\t\t\t!lastMatch.innerRange.equal(lastMatch.outerRange) \n\t\t\t\t\t&& lastMatch.range.equal(lastMatch.innerRange) \n\t\t\t\t\t&& sel.equal(lastMatch.range)) {\n\t\t\t\t\tlastMatch.range = lastMatch.outerRange;\n\t\t\t\t} else {\n\t\t\t\t\tlastMatch = htmlMatcher.find(content, sel.start);\n\t\t\t\t\tif (lastMatch && lastMatch.range.equal(sel) && lastMatch.innerRange.equal(sel)) {\n\t\t\t\t\t\tlastMatch.range = lastMatch.outerRange;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tlastMatch = htmlMatcher.find(content, sel.start);\n\t\t}\n\n\t\tif (lastMatch) {\n\t\t\tif (lastMatch.innerRange.equal(sel)) {\n\t\t\t\tlastMatch.range = lastMatch.outerRange;\n\t\t\t}\n\n\t\t\tif (!lastMatch.range.equal(sel)) {\n\t\t\t\teditor.createSelection(lastMatch.range.start, lastMatch.range.end);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\t\n\t\tlastMatch = null;\n\t\treturn false;\n\t}\n\n\tfunction rangesForCSSRule(rule, pos) {\n\t\t// find all possible ranges\n\t\tvar ranges = [rule.range(true)];\n\n\t\t// braces content\n\t\tranges.push(rule.valueRange(true));\n\n\t\t// find nested sections\n\t\tvar nestedSections = cssSections.nestedSectionsInRule(rule);\n\n\t\t// real content, e.g. from first property name to\n\t\t// last property value\n\t\tvar items = rule.list();\n\t\tif (items.length || nestedSections.length) {\n\t\t\tvar start = Number.POSITIVE_INFINITY, end = -1;\n\t\t\tif (items.length) {\n\t\t\t\tstart = items[0].namePosition(true);\n\t\t\t\tend = last(items).range(true).end;\n\t\t\t}\n\n\t\t\tif (nestedSections.length) {\n\t\t\t\tif (nestedSections[0].start < start) {\n\t\t\t\t\tstart = nestedSections[0].start;\n\t\t\t\t}\n\n\t\t\t\tif (last(nestedSections).end > end) {\n\t\t\t\t\tend = last(nestedSections).end;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tranges.push(range.create2(start, end));\n\t\t}\n\n\t\tranges = ranges.concat(nestedSections);\n\n\t\tvar prop = cssEditTree.propertyFromPosition(rule, pos) || items[0];\n\t\tif (prop) {\n\t\t\tranges.push(prop.range(true));\n\t\t\tvar valueRange = prop.valueRange(true);\n\t\t\tif (!prop.end()) {\n\t\t\t\tvalueRange._unterminated = true;\n\t\t\t}\n\t\t\tranges.push(valueRange);\n\t\t}\n\n\t\treturn ranges;\n\t}\n\n\t/**\n\t * Returns all possible selection ranges for given caret position\n\t * @param  {String} content CSS content\n\t * @param  {Number} pos     Caret position(where to start searching)\n\t * @return {Array}\n\t */\n\tfunction getCSSRanges(content, pos) {\n\t\tvar rule;\n\t\tif (typeof content === 'string') {\n\t\t\tvar ruleRange = cssSections.matchEnclosingRule(content, pos);\n\t\t\tif (ruleRange) {\n\t\t\t\trule = cssEditTree.parse(ruleRange.substring(content), {\n\t\t\t\t\toffset: ruleRange.start\n\t\t\t\t});\n\t\t\t}\n\t\t} else {\n\t\t\t// passed parsed CSS rule\n\t\t\trule = content;\n\t\t}\n\n\t\tif (!rule) {\n\t\t\treturn null;\n\t\t}\n\n\t\t// find all possible ranges\n\t\tvar ranges = rangesForCSSRule(rule, pos);\n\n\t\t// remove empty ranges\n\t\tranges = ranges.filter(function(item) {\n\t\t\treturn !!item.length;\n\t\t});\n\n\t\treturn utils.unique(ranges, function(item) {\n\t\t\treturn item.valueOf();\n\t\t});\n\t}\n\n\tfunction balanceCSS(editor, direction) {\n\t\tvar info = editorUtils.outputInfo(editor);\n\t\tvar content = info.content;\n\t\tvar sel = range(editor.getSelectionRange());\n\n\t\tvar ranges = getCSSRanges(info.content, sel.start);\n\t\tif (!ranges && sel.length()) {\n\t\t\t// possible reason: user has already selected\n\t\t\t// CSS rule from last match\n\t\t\ttry {\n\t\t\t\tvar rule = cssEditTree.parse(sel.substring(info.content), {\n\t\t\t\t\toffset: sel.start\n\t\t\t\t});\n\t\t\t\tranges = getCSSRanges(rule, sel.start);\n\t\t\t} catch(e) {}\n\t\t}\n\n\t\tif (!ranges) {\n\t\t\treturn false;\n\t\t}\n\n\t\tranges = range.sort(ranges, true);\n\n\t\t// edge case: find match that equals current selection,\n\t\t// in case if user moves inward after selecting full CSS rule\n\t\tvar bestMatch = utils.find(ranges, function(r) {\n\t\t\treturn r.equal(sel);\n\t\t});\n\n\t\tif (!bestMatch) {\n\t\t\tbestMatch = utils.find(ranges, function(r) {\n\t\t\t\t// Check for edge case: caret right after CSS value\n\t\t\t\t// but it doesn‘t contains terminating semicolon.\n\t\t\t\t// In this case we have to check full value range\n\t\t\t\treturn r._unterminated ? r.include(sel.start) : r.inside(sel.start);\n\t\t\t});\n\t\t}\n\n\t\tif (!bestMatch) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// if best match equals to current selection, move index\n\t\t// one position up or down, depending on direction\n\t\tvar bestMatchIx = ranges.indexOf(bestMatch);\n\t\tif (bestMatch.equal(sel)) {\n\t\t\tbestMatchIx += direction == 'out' ? 1 : -1;\n\t\t}\n\n\t\tif (bestMatchIx < 0 || bestMatchIx >= ranges.length) {\n\t\t\tif (bestMatchIx >= ranges.length && direction == 'out') {\n\t\t\t\tpos = bestMatch.start - 1;\n\n\t\t\t\tvar outerRanges = getCSSRanges(content, pos);\n\t\t\t\tif (outerRanges) {\n\t\t\t\t\tbestMatch = last(outerRanges.filter(function(r) {\n\t\t\t\t\t\treturn r.inside(pos);\n\t\t\t\t\t}));\n\t\t\t\t}\n\t\t\t} else if (bestMatchIx < 0 && direction == 'in') {\n\t\t\t\tbestMatch = null;\n\t\t\t} else {\n\t\t\t\tbestMatch = null;\n\t\t\t}\n\t\t} else {\n\t\t\tbestMatch = ranges[bestMatchIx];\t\n\t\t}\n\n\t\tif (bestMatch) {\n\t\t\teditor.createSelection(bestMatch.start, bestMatch.end);\n\t\t\treturn true;\n\t\t}\n\t\t\n\t\treturn false;\n\t}\n\t\n\treturn {\n\t\t/**\n\t\t * Find and select HTML tag pair\n\t\t * @param {IEmmetEditor} editor Editor instance\n\t\t * @param {String} direction Direction of pair matching: 'in' or 'out'. \n\t\t * Default is 'out'\n\t\t */\n\t\tbalance: function(editor, direction) {\n\t\t\tdirection = String((direction || 'out').toLowerCase());\n\t\t\tvar info = editorUtils.outputInfo(editor);\n\t\t\tif (actionUtils.isSupportedCSS(info.syntax)) {\n\t\t\t\treturn balanceCSS(editor, direction);\n\t\t\t}\n\t\t\t\n\t\t\treturn balanceHTML(editor, direction);\n\t\t},\n\n\t\tbalanceInwardAction: function(editor) {\n\t\t\treturn this.balance(editor, 'in');\n\t\t},\n\n\t\tbalanceOutwardAction: function(editor) {\n\t\t\treturn this.balance(editor, 'out');\t\n\t\t},\n\n\t\t/**\n\t\t * Moves caret to matching opening or closing tag\n\t\t * @param {IEmmetEditor} editor\n\t\t */\n\t\tgoToMatchingPairAction: function(editor) {\n\t\t\tvar content = String(editor.getContent());\n\t\t\tvar caretPos = editor.getCaretPos();\n\t\t\t\n\t\t\tif (content.charAt(caretPos) == '<') \n\t\t\t\t// looks like caret is outside of tag pair  \n\t\t\t\tcaretPos++;\n\t\t\t\t\n\t\t\tvar tag = htmlMatcher.tag(content, caretPos);\n\t\t\tif (tag && tag.close) { // exclude unary tags\n\t\t\t\tif (tag.open.range.inside(caretPos)) {\n\t\t\t\t\teditor.setCaretPos(tag.close.range.start);\n\t\t\t\t} else {\n\t\t\t\t\teditor.setCaretPos(tag.open.range.start);\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\t\n\t\t\treturn false;\n\t\t}\n\t};\n});\n},{\"../assets/htmlMatcher\":\"assets\\\\htmlMatcher.js\",\"../assets/range\":\"assets\\\\range.js\",\"../editTree/css\":\"editTree\\\\css.js\",\"../utils/action\":\"utils\\\\action.js\",\"../utils/common\":\"utils\\\\common.js\",\"../utils/cssSections\":\"utils\\\\cssSections.js\",\"../utils/editor\":\"utils\\\\editor.js\"}],\"action\\\\base64.js\":[function(require,module,exports){\n/**\n * Encodes/decodes image under cursor to/from base64\n * @param {IEmmetEditor} editor\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar file = require('../plugin/file');\n\tvar base64 = require('../utils/base64');\n\tvar actionUtils = require('../utils/action');\n\tvar editorUtils = require('../utils/editor');\n\n\t/**\n\t * Test if <code>text</code> starts with <code>token</code> at <code>pos</code>\n\t * position. If <code>pos</code> is omitted, search from beginning of text \n\t * @param {String} token Token to test\n\t * @param {String} text Where to search\n\t * @param {Number} pos Position where to start search\n\t * @return {Boolean}\n\t * @since 0.65\n\t */\n\tfunction startsWith(token, text, pos) {\n\t\tpos = pos || 0;\n\t\treturn text.charAt(pos) == token.charAt(0) && text.substr(pos, token.length) == token;\n\t}\n\n\t/**\n\t * Encodes image to base64\n\t * \n\t * @param {IEmmetEditor} editor\n\t * @param {String} imgPath Path to image\n\t * @param {Number} pos Caret position where image is located in the editor\n\t * @return {Boolean}\n\t */\n\tfunction encodeToBase64(editor, imgPath, pos) {\n\t\tvar editorFile = editor.getFilePath();\n\t\tvar defaultMimeType = 'application/octet-stream';\n\n\t\tif (editorFile === null) {\n\t\t\tthrow \"You should save your file before using this action\";\n\t\t}\n\n\t\t// locate real image path\n\t\tfile.locateFile(editorFile, imgPath, function(realImgPath) {\n\t\t\tif (realImgPath === null) {\n\t\t\t\tthrow \"Can't find \" + imgPath + ' file';\n\t\t\t}\n\n\t\t\tfile.read(realImgPath, function(err, content) {\n\t\t\t\tif (err) {\n\t\t\t\t\tthrow 'Unable to read ' + realImgPath + ': ' + err;\n\t\t\t\t}\n\n\t\t\t\tvar b64 = base64.encode(String(content));\n\t\t\t\tif (!b64) {\n\t\t\t\t\tthrow \"Can't encode file content to base64\";\n\t\t\t\t}\n\n\t\t\t\tb64 = 'data:' + (actionUtils.mimeTypes[String(file.getExt(realImgPath))] || defaultMimeType) +\n\t\t\t\t\t';base64,' + b64;\n\n\t\t\t\teditor.replaceContent('$0' + b64, pos, pos + imgPath.length);\n\t\t\t});\n\t\t});\n\n\t\treturn true;\n\t}\n\n\t/**\n\t * Decodes base64 string back to file.\n\t * @param {IEmmetEditor} editor\n\t * @param {String} filePath to new image\n\t * @param {String} data Base64-encoded file content\n\t * @param {Number} pos Caret position where image is located in the editor\n\t */\n\tfunction decodeFromBase64(editor, filePath, data, pos) {\n\t\t// ask user to enter path to file\n\t\tfilePath = filePath || String(editor.prompt('Enter path to file (absolute or relative)'));\n\t\tif (!filePath) {\n\t\t\treturn false;\n\t\t}\n\n\t\tvar editorFile = editor.getFilePath();\n\t\tfile.createPath(editorFile, filePath, function(err, absPath) {\n\t\t\tif (err || !absPath) {\n\t\t\t\tthrow \"Can't save file\";\n\t\t\t}\n\n\t\t\tvar content = data.replace(/^data\\:.+?;.+?,/, '');\n\t\t\tfile.save(absPath, base64.decode(content), function(err) {\n\t\t\t\tif (err) {\n\t\t\t\t\tthrow 'Unable to save ' + absPath + ': ' + err;\n\t\t\t\t}\n\n\t\t\t\teditor.replaceContent('$0' + filePath, pos, pos + data.length);\n\t\t\t});\n\t\t});\n\n\t\treturn true;\n\t}\n\n\treturn {\n\t\t/**\n\t\t * Action to encode or decode file to data:url\n\t\t * @param  {IEmmetEditor} editor  Editor instance\n\t\t * @param  {String} syntax  Current document syntax\n\t\t * @param  {String} profile Output profile name\n\t\t * @return {Boolean}\n\t\t */\n\t\tencodeDecodeDataUrlAction: function(editor, filepath) {\n\t\t\tvar data = String(editor.getSelection());\n\t\t\tvar caretPos = editor.getCaretPos();\n\t\t\tvar info = editorUtils.outputInfo(editor);\n\n\t\t\tif (!data) {\n\t\t\t\t// no selection, try to find image bounds from current caret position\n\t\t\t\tvar text = info.content, m;\n\t\t\t\twhile (caretPos-- >= 0) {\n\t\t\t\t\tif (startsWith('src=', text, caretPos)) { // found <img src=\"\">\n\t\t\t\t\t\tif ((m = text.substr(caretPos).match(/^(src=([\"'])?)([^'\"<>\\s]+)\\1?/))) {\n\t\t\t\t\t\t\tdata = m[3];\n\t\t\t\t\t\t\tcaretPos += m[1].length;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t} else if (startsWith('url(', text, caretPos)) { // found CSS url() pattern\n\t\t\t\t\t\tif ((m = text.substr(caretPos).match(/^(url\\((['\"])?)([^'\"\\)\\s]+)\\1?/))) {\n\t\t\t\t\t\t\tdata = m[3];\n\t\t\t\t\t\t\tcaretPos += m[1].length;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (data) {\n\t\t\t\tif (startsWith('data:', data)) {\n\t\t\t\t\treturn decodeFromBase64(editor, filepath, data, caretPos);\n\t\t\t\t} else {\n\t\t\t\t\treturn encodeToBase64(editor, data, caretPos);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn false;\n\t\t}\n\t};\n});\n\n},{\"../plugin/file\":\"plugin\\\\file.js\",\"../utils/action\":\"utils\\\\action.js\",\"../utils/base64\":\"utils\\\\base64.js\",\"../utils/editor\":\"utils\\\\editor.js\"}],\"action\\\\editPoints.js\":[function(require,module,exports){\n/**\n * Move between next/prev edit points. 'Edit points' are places between tags \n * and quotes of empty attributes in html\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\t/**\n\t * Search for new caret insertion point\n\t * @param {IEmmetEditor} editor Editor instance\n\t * @param {Number} inc Search increment: -1 — search left, 1 — search right\n\t * @param {Number} offset Initial offset relative to current caret position\n\t * @return {Number} Returns -1 if insertion point wasn't found\n\t */\n\tfunction findNewEditPoint(editor, inc, offset) {\n\t\tinc = inc || 1;\n\t\toffset = offset || 0;\n\t\t\n\t\tvar curPoint = editor.getCaretPos() + offset;\n\t\tvar content = String(editor.getContent());\n\t\tvar maxLen = content.length;\n\t\tvar nextPoint = -1;\n\t\tvar reEmptyLine = /^\\s+$/;\n\t\t\n\t\tfunction getLine(ix) {\n\t\t\tvar start = ix;\n\t\t\twhile (start >= 0) {\n\t\t\t\tvar c = content.charAt(start);\n\t\t\t\tif (c == '\\n' || c == '\\r')\n\t\t\t\t\tbreak;\n\t\t\t\tstart--;\n\t\t\t}\n\t\t\t\n\t\t\treturn content.substring(start, ix);\n\t\t}\n\t\t\t\n\t\twhile (curPoint <= maxLen && curPoint >= 0) {\n\t\t\tcurPoint += inc;\n\t\t\tvar curChar = content.charAt(curPoint);\n\t\t\tvar nextChar = content.charAt(curPoint + 1);\n\t\t\tvar prevChar = content.charAt(curPoint - 1);\n\t\t\t\t\n\t\t\tswitch (curChar) {\n\t\t\t\tcase '\"':\n\t\t\t\tcase '\\'':\n\t\t\t\t\tif (nextChar == curChar && prevChar == '=') {\n\t\t\t\t\t\t// empty attribute\n\t\t\t\t\t\tnextPoint = curPoint + 1;\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\tcase '>':\n\t\t\t\t\tif (nextChar == '<') {\n\t\t\t\t\t\t// between tags\n\t\t\t\t\t\tnextPoint = curPoint + 1;\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\tcase '\\n':\n\t\t\t\tcase '\\r':\n\t\t\t\t\t// empty line\n\t\t\t\t\tif (reEmptyLine.test(getLine(curPoint - 1))) {\n\t\t\t\t\t\tnextPoint = curPoint;\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t\t\n\t\t\tif (nextPoint != -1)\n\t\t\t\tbreak;\n\t\t}\n\t\t\n\t\treturn nextPoint;\n\t}\n\t\n\treturn {\n\t\t/**\n\t\t * Move to previous edit point\n\t\t * @param  {IEmmetEditor} editor  Editor instance\n\t\t * @param  {String} syntax  Current document syntax\n\t\t * @param  {String} profile Output profile name\n\t\t * @return {Boolean}\n\t\t */\n\t\tpreviousEditPointAction: function(editor, syntax, profile) {\n\t\t\tvar curPos = editor.getCaretPos();\n\t\t\tvar newPoint = findNewEditPoint(editor, -1);\n\t\t\t\t\n\t\t\tif (newPoint == curPos)\n\t\t\t\t// we're still in the same point, try searching from the other place\n\t\t\t\tnewPoint = findNewEditPoint(editor, -1, -2);\n\t\t\t\n\t\t\tif (newPoint != -1) {\n\t\t\t\teditor.setCaretPos(newPoint);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\t\n\t\t\treturn false;\n\t\t},\n\n\t\t/**\n\t\t * Move to next edit point\n\t\t * @param  {IEmmetEditor} editor  Editor instance\n\t\t * @param  {String} syntax  Current document syntax\n\t\t * @param  {String} profile Output profile name\n\t\t * @return {Boolean}\n\t\t */\n\t\tnextEditPointAction: function(editor, syntax, profile) {\n\t\t\tvar newPoint = findNewEditPoint(editor, 1);\n\t\t\tif (newPoint != -1) {\n\t\t\t\teditor.setCaretPos(newPoint);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\t\n\t\t\treturn false;\n\t\t}\n\t};\n});\n},{}],\"action\\\\evaluateMath.js\":[function(require,module,exports){\n/**\n * Evaluates simple math expression under caret\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar actionUtils = require('../utils/action');\n\tvar utils = require('../utils/common');\n\tvar math = require('../utils/math');\n\tvar range = require('../assets/range');\n\n\treturn {\n\t\t/**\n\t\t * Evaluates math expression under the caret\n\t\t * @param  {IEmmetEditor} editor\n\t\t * @return {Boolean}\n\t\t */\n\t\tevaluateMathAction: function(editor) {\n\t\t\tvar content = editor.getContent();\n\t\t\tvar chars = '.+-*/\\\\';\n\t\t\t\n\t\t\t/** @type Range */\n\t\t\tvar sel = range(editor.getSelectionRange());\n\t\t\tif (!sel.length()) {\n\t\t\t\tsel = actionUtils.findExpressionBounds(editor, function(ch) {\n\t\t\t\t\treturn utils.isNumeric(ch) || chars.indexOf(ch) != -1;\n\t\t\t\t});\n\t\t\t}\n\t\t\t\n\t\t\tif (sel && sel.length()) {\n\t\t\t\tvar expr = sel.substring(content);\n\t\t\t\t\n\t\t\t\t// replace integral division: 11\\2 => Math.round(11/2) \n\t\t\t\texpr = expr.replace(/([\\d\\.\\-]+)\\\\([\\d\\.\\-]+)/g, 'round($1/$2)');\n\t\t\t\t\n\t\t\t\ttry {\n\t\t\t\t\tvar result = utils.prettifyNumber(math.evaluate(expr));\n\t\t\t\t\teditor.replaceContent(result, sel.start, sel.end);\n\t\t\t\t\teditor.setCaretPos(sel.start + result.length);\n\t\t\t\t\treturn true;\n\t\t\t\t} catch (e) {}\n\t\t\t}\n\t\t\t\n\t\t\treturn false;\n\t\t}\n\t};\n});\n\n},{\"../assets/range\":\"assets\\\\range.js\",\"../utils/action\":\"utils\\\\action.js\",\"../utils/common\":\"utils\\\\common.js\",\"../utils/math\":\"utils\\\\math.js\"}],\"action\\\\expandAbbreviation.js\":[function(require,module,exports){\n/**\n * 'Expand abbreviation' editor action: extracts abbreviation from current caret \n * position and replaces it with formatted output. \n * <br><br>\n * This behavior can be overridden with custom handlers which can perform \n * different actions when 'Expand Abbreviation' action is called.\n * For example, a CSS gradient handler that produces vendor-prefixed gradient\n * definitions registers its own expand abbreviation handler.  \n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar handlerList = require('../assets/handlerList');\n\tvar range = require('../assets/range');\n\tvar prefs = require('../assets/preferences');\n\tvar utils = require('../utils/common');\n\tvar editorUtils = require('../utils/editor');\n\tvar actionUtils = require('../utils/action');\n\tvar cssGradient = require('../resolver/cssGradient');\n\tvar parser = require('../parser/abbreviation');\n\n\t/**\n\t * Search for abbreviation in editor from current caret position\n\t * @param {IEmmetEditor} editor Editor instance\n\t * @return {String}\n\t */\n\tfunction findAbbreviation(editor) {\n\t\tvar r = range(editor.getSelectionRange());\n\t\tvar content = String(editor.getContent());\n\t\tif (r.length()) {\n\t\t\t// abbreviation is selected by user\n\t\t\treturn r.substring(content);\n\t\t}\n\t\t\n\t\t// search for new abbreviation from current caret position\n\t\tvar curLine = editor.getCurrentLineRange();\n\t\treturn actionUtils.extractAbbreviation(content.substring(curLine.start, r.start));\n\t}\n\n\t/**\n\t * @type HandlerList List of registered handlers\n\t */\n\tvar handlers = handlerList.create();\n\n\t// XXX setup default expand handlers\n\t\n\t/**\n\t * Extracts abbreviation from current caret \n\t * position and replaces it with formatted output \n\t * @param {IEmmetEditor} editor Editor instance\n\t * @param {String} syntax Syntax type (html, css, etc.)\n\t * @param {String} profile Output profile name (html, xml, xhtml)\n\t * @return {Boolean} Returns <code>true</code> if abbreviation was expanded \n\t * successfully\n\t */\n\thandlers.add(function(editor, syntax, profile) {\n\t\tvar caretPos = editor.getSelectionRange().end;\n\t\tvar abbr = findAbbreviation(editor);\n\t\t\t\n\t\tif (abbr) {\n\t\t\tvar content = parser.expand(abbr, {\n\t\t\t\tsyntax: syntax, \n\t\t\t\tprofile: profile, \n\t\t\t\tcontextNode: actionUtils.captureContext(editor)\n\t\t\t});\n\n\t\t\tif (content) {\n\t\t\t\tvar replaceFrom = caretPos - abbr.length;\n\t\t\t\tvar replaceTo = caretPos;\n\n\t\t\t\t// a special case for CSS: if editor already contains\n\t\t\t\t// semicolon right after current caret position — replace it too\n\t\t\t\tvar cssSyntaxes = prefs.getArray('css.syntaxes');\n\t\t\t\tif (cssSyntaxes && ~cssSyntaxes.indexOf(syntax)) {\n\t\t\t\t\tvar curContent = editor.getContent();\n\t\t\t\t\tif (curContent.charAt(caretPos) == ';' && content.charAt(content.length - 1) == ';') {\n\t\t\t\t\t\treplaceTo++;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\teditor.replaceContent(content, replaceFrom, replaceTo);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\t\n\t\treturn false;\n\t}, {order: -1});\n\thandlers.add(cssGradient.expandAbbreviationHandler.bind(cssGradient));\n\t\t\n\treturn {\n\t\t/**\n\t\t * The actual “Expand Abbreviation“ action routine\n\t\t * @param  {IEmmetEditor} editor  Editor instance\n\t\t * @param  {String} syntax  Current document syntax\n\t\t * @param  {String} profile Output profile name\n\t\t * @return {Boolean}\n\t\t */\n\t\texpandAbbreviationAction: function(editor, syntax, profile) {\n\t\t\tvar args = utils.toArray(arguments);\n\t\t\t\n\t\t\t// normalize incoming arguments\n\t\t\tvar info = editorUtils.outputInfo(editor, syntax, profile);\n\t\t\targs[1] = info.syntax;\n\t\t\targs[2] = info.profile;\n\t\t\t\n\t\t\treturn handlers.exec(false, args);\n\t\t},\n\n\t\t/**\n\t\t * A special case of “Expand Abbreviation“ action, invoked by Tab key.\n\t\t * In this case if abbreviation wasn’t expanded successfully or there’s a selecetion, \n\t\t * the current line/selection will be indented. \n\t\t * @param  {IEmmetEditor} editor  Editor instance\n\t\t * @param  {String} syntax  Current document syntax\n\t\t * @param  {String} profile Output profile name\n\t\t * @return {Boolean}\n\t\t */\n\t\texpandAbbreviationWithTabAction: function(editor, syntax, profile) {\n\t\t\tvar sel = editor.getSelection();\n\t\t\tvar indent = '\\t';\n\n\t\t\t// if something is selected in editor,\n\t\t\t// we should indent the selected content\n\t\t\tif (sel) {\n\t\t\t\tvar selRange = range(editor.getSelectionRange());\n\t\t\t\tvar content = utils.padString(sel, indent);\n\t\t\t\t\n\t\t\t\teditor.replaceContent(indent + '${0}', editor.getCaretPos());\n\t\t\t\tvar replaceRange = range(editor.getCaretPos(), selRange.length());\n\t\t\t\teditor.replaceContent(content, replaceRange.start, replaceRange.end, true);\n\t\t\t\teditor.createSelection(replaceRange.start, replaceRange.start + content.length);\n\t\t\t\treturn true;\n\t\t\t}\n\t\n\t\t\t// nothing selected, try to expand\n\t\t\tif (!this.expandAbbreviationAction(editor, syntax, profile)) {\n\t\t\t\teditor.replaceContent(indent, editor.getCaretPos());\n\t\t\t}\n\t\t\t\n\t\t\treturn true;\n\t\t},\n\n\t\t\n\t\t_defaultHandler: function(editor, syntax, profile) {\n\t\t\tvar caretPos = editor.getSelectionRange().end;\n\t\t\tvar abbr = this.findAbbreviation(editor);\n\t\t\t\t\n\t\t\tif (abbr) {\n\t\t\t\tvar ctx = actionUtils.captureContext(editor);\n\t\t\t\tvar content = parser.expand(abbr, syntax, profile, ctx);\n\t\t\t\tif (content) {\n\t\t\t\t\teditor.replaceContent(content, caretPos - abbr.length, caretPos);\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\treturn false;\n\t\t},\n\n\t\t/**\n\t\t * Adds custom expand abbreviation handler. The passed function should \n\t\t * return <code>true</code> if it was performed successfully, \n\t\t * <code>false</code> otherwise.\n\t\t * \n\t\t * Added handlers will be called when 'Expand Abbreviation' is called\n\t\t * in order they were added\n\t\t * @memberOf expandAbbreviation\n\t\t * @param {Function} fn\n\t\t * @param {Object} options\n\t\t */\n\t\taddHandler: function(fn, options) {\n\t\t\thandlers.add(fn, options);\n\t\t},\n\t\t\n\t\t/**\n\t\t * Removes registered handler\n\t\t * @returns\n\t\t */\n\t\tremoveHandler: function(fn) {\n\t\t\thandlers.remove(fn);\n\t\t},\n\t\t\n\t\tfindAbbreviation: findAbbreviation\n\t};\n});\n},{\"../assets/handlerList\":\"assets\\\\handlerList.js\",\"../assets/preferences\":\"assets\\\\preferences.js\",\"../assets/range\":\"assets\\\\range.js\",\"../parser/abbreviation\":\"parser\\\\abbreviation.js\",\"../resolver/cssGradient\":\"resolver\\\\cssGradient.js\",\"../utils/action\":\"utils\\\\action.js\",\"../utils/common\":\"utils\\\\common.js\",\"../utils/editor\":\"utils\\\\editor.js\"}],\"action\\\\incrementDecrement.js\":[function(require,module,exports){\n/**\n * Increment/decrement number under cursor\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar utils = require('../utils/common');\n\tvar actionUtils = require('../utils/action');\n\n\t/**\n\t * Returns length of integer part of number\n\t * @param {String} num\n\t */\n\tfunction intLength(num) {\n\t\tnum = num.replace(/^\\-/, '');\n\t\tif (~num.indexOf('.')) {\n\t\t\treturn num.split('.')[0].length;\n\t\t}\n\t\t\n\t\treturn num.length;\n\t}\n\n\treturn {\n\t\tincrement01Action: function(editor) {\n\t\t\treturn this.incrementNumber(editor, .1);\n\t\t},\n\n\t\tincrement1Action: function(editor) {\n\t\t\treturn this.incrementNumber(editor, 1);\n\t\t},\n\n\t\tincrement10Action: function(editor) {\n\t\t\treturn this.incrementNumber(editor, 10);\n\t\t},\n\n\t\tdecrement01Action: function(editor) {\n\t\t\treturn this.incrementNumber(editor, -.1);\n\t\t},\n\n\t\tdecrement1Action: function(editor) {\n\t\t\treturn this.incrementNumber(editor, -1);\n\t\t},\n\n\t\tdecrement10Action: function(editor) {\n\t\t\treturn this.incrementNumber(editor, -10);\n\t\t},\n\n\t\t/**\n\t\t * Default method to increment/decrement number under\n\t\t * caret with given step\n\t\t * @param  {IEmmetEditor} editor\n\t\t * @param  {Number} step\n\t\t * @return {Boolean}\n\t\t */\n\t\tincrementNumber: function(editor, step) {\n\t\t\tvar hasSign = false;\n\t\t\tvar hasDecimal = false;\n\t\t\t\t\n\t\t\tvar r = actionUtils.findExpressionBounds(editor, function(ch, pos, content) {\n\t\t\t\tif (utils.isNumeric(ch))\n\t\t\t\t\treturn true;\n\t\t\t\tif (ch == '.') {\n\t\t\t\t\t// make sure that next character is numeric too\n\t\t\t\t\tif (!utils.isNumeric(content.charAt(pos + 1)))\n\t\t\t\t\t\treturn false;\n\t\t\t\t\t\n\t\t\t\t\treturn hasDecimal ? false : hasDecimal = true;\n\t\t\t\t}\n\t\t\t\tif (ch == '-')\n\t\t\t\t\treturn hasSign ? false : hasSign = true;\n\t\t\t\t\t\n\t\t\t\treturn false;\n\t\t\t});\n\t\t\t\t\n\t\t\tif (r && r.length()) {\n\t\t\t\tvar strNum = r.substring(String(editor.getContent()));\n\t\t\t\tvar num = parseFloat(strNum);\n\t\t\t\tif (!isNaN(num)) {\n\t\t\t\t\tnum = utils.prettifyNumber(num + step);\n\t\t\t\t\t\n\t\t\t\t\t// do we have zero-padded number?\n\t\t\t\t\tif (/^(\\-?)0+[1-9]/.test(strNum)) {\n\t\t\t\t\t\tvar minus = '';\n\t\t\t\t\t\tif (RegExp.$1) {\n\t\t\t\t\t\t\tminus = '-';\n\t\t\t\t\t\t\tnum = num.substring(1);\n\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\n\t\t\t\t\t\tvar parts = num.split('.');\n\t\t\t\t\t\tparts[0] = utils.zeroPadString(parts[0], intLength(strNum));\n\t\t\t\t\t\tnum = minus + parts.join('.');\n\t\t\t\t\t}\n\t\t\t\t\t\n\t\t\t\t\teditor.replaceContent(num, r.start, r.end);\n\t\t\t\t\teditor.createSelection(r.start, r.start + num.length);\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\treturn false;\n\t\t}\n\t};\n});\n},{\"../utils/action\":\"utils\\\\action.js\",\"../utils/common\":\"utils\\\\common.js\"}],\"action\\\\lineBreaks.js\":[function(require,module,exports){\n/**\n * Actions to insert line breaks. Some simple editors (like browser's \n * &lt;textarea&gt;, for example) do not provide such simple things\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar prefs = require('../assets/preferences');\n\tvar utils = require('../utils/common');\n\tvar resources = require('../assets/resources');\n\tvar htmlMatcher = require('../assets/htmlMatcher');\n\tvar editorUtils = require('../utils/editor');\n\n\tvar xmlSyntaxes = ['html', 'xml', 'xsl'];\n\n\t// setup default preferences\n\tprefs.define('css.closeBraceIndentation', '\\n',\n\t\t\t'Indentation before closing brace of CSS rule. Some users prefere ' \n\t\t\t+ 'indented closing brace of CSS rule for better readability. '\n\t\t\t+ 'This preference’s value will be automatically inserted before '\n\t\t\t+ 'closing brace when user adds newline in newly created CSS rule '\n\t\t\t+ '(e.g. when “Insert formatted linebreak” action will be performed ' \n\t\t\t+ 'in CSS file). If you’re such user, you may want to write put a value ' \n\t\t\t+ 'like <code>\\\\n\\\\t</code> in this preference.');\n\n\treturn {\n\t\t/**\n\t\t * Inserts newline character with proper indentation. This action is used in\n\t\t * editors that doesn't have indentation control (like textarea element) to \n\t\t * provide proper indentation for inserted newlines\n\t\t * @param {IEmmetEditor} editor Editor instance\n\t\t */\n\t\tinsertLineBreakAction: function(editor) {\n\t\t\tif (!this.insertLineBreakOnlyAction(editor)) {\n\t\t\t\tvar curPadding = editorUtils.getCurrentLinePadding(editor);\n\t\t\t\tvar content = String(editor.getContent());\n\t\t\t\tvar caretPos = editor.getCaretPos();\n\t\t\t\tvar len = content.length;\n\t\t\t\tvar nl = '\\n';\n\t\t\t\t\t\n\t\t\t\t// check out next line padding\n\t\t\t\tvar lineRange = editor.getCurrentLineRange();\n\t\t\t\tvar nextPadding = '';\n\t\t\t\t\t\n\t\t\t\tfor (var i = lineRange.end, ch; i < len; i++) {\n\t\t\t\t\tch = content.charAt(i);\n\t\t\t\t\tif (ch == ' ' || ch == '\\t')\n\t\t\t\t\t\tnextPadding += ch;\n\t\t\t\t\telse\n\t\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tif (nextPadding.length > curPadding.length) {\n\t\t\t\t\teditor.replaceContent(nl + nextPadding, caretPos, caretPos, true);\n\t\t\t\t} else {\n\t\t\t\t\teditor.replaceContent(nl, caretPos);\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\treturn true;\n\t\t},\n\n\t\t/**\n\t\t * Inserts newline character with proper indentation in specific positions only.\n\t\t * @param {IEmmetEditor} editor\n\t\t * @return {Boolean} Returns <code>true</code> if line break was inserted \n\t\t */\n\t\tinsertLineBreakOnlyAction: function(editor) {\n\t\t\tvar info = editorUtils.outputInfo(editor);\n\t\t\tvar caretPos = editor.getCaretPos();\n\t\t\tvar nl = '\\n';\n\t\t\tvar pad = '\\t';\n\t\t\t\n\t\t\tif (~xmlSyntaxes.indexOf(info.syntax)) {\n\t\t\t\t// let's see if we're breaking newly created tag\n\t\t\t\tvar tag = htmlMatcher.tag(info.content, caretPos);\n\t\t\t\tif (tag && !tag.innerRange.length()) {\n\t\t\t\t\teditor.replaceContent(nl + pad + utils.getCaretPlaceholder() + nl, caretPos);\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t} else if (info.syntax == 'css') {\n\t\t\t\t/** @type String */\n\t\t\t\tvar content = info.content;\n\t\t\t\tif (caretPos && content.charAt(caretPos - 1) == '{') {\n\t\t\t\t\tvar append = prefs.get('css.closeBraceIndentation');\n\t\t\t\t\t\n\t\t\t\t\tvar hasCloseBrace = content.charAt(caretPos) == '}';\n\t\t\t\t\tif (!hasCloseBrace) {\n\t\t\t\t\t\t// do we really need special formatting here?\n\t\t\t\t\t\t// check if this is really a newly created rule,\n\t\t\t\t\t\t// look ahead for a closing brace\n\t\t\t\t\t\tfor (var i = caretPos, il = content.length, ch; i < il; i++) {\n\t\t\t\t\t\t\tch = content.charAt(i);\n\t\t\t\t\t\t\tif (ch == '{') {\n\t\t\t\t\t\t\t\t// ok, this is a new rule without closing brace\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\tif (ch == '}') {\n\t\t\t\t\t\t\t\t// not a new rule, just add indentation\n\t\t\t\t\t\t\t\tappend = '';\n\t\t\t\t\t\t\t\thasCloseBrace = true;\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\t\n\t\t\t\t\tif (!hasCloseBrace) {\n\t\t\t\t\t\tappend += '}';\n\t\t\t\t\t}\n\t\t\t\t\t\n\t\t\t\t\t// defining rule set\n\t\t\t\t\tvar insValue = nl + pad + utils.getCaretPlaceholder() + append;\n\t\t\t\t\teditor.replaceContent(insValue, caretPos);\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t}\n\t\t\t\t\n\t\t\treturn false;\n\t\t}\n\t};\n});\n\n},{\"../assets/htmlMatcher\":\"assets\\\\htmlMatcher.js\",\"../assets/preferences\":\"assets\\\\preferences.js\",\"../assets/resources\":\"assets\\\\resources.js\",\"../utils/common\":\"utils\\\\common.js\",\"../utils/editor\":\"utils\\\\editor.js\"}],\"action\\\\main.js\":[function(require,module,exports){\n/**\n * Module describes and performs Emmet actions. The actions themselves are\n * defined in <i>actions</i> folder\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar utils = require('../utils/common');\n\n\t// all registered actions\n\tvar actions = {};\n\n\t// load all default actions\n\tvar actionModules = {\n\t\tbase64: require('./base64'),\n\t\teditPoints: require('./editPoints'),\n\t\tevaluateMath: require('./evaluateMath'),\n\t\texpandAbbreviation: require('./expandAbbreviation'),\n\t\tincrementDecrement: require('./incrementDecrement'),\n\t\tlineBreaks: require('./lineBreaks'),\n\t\tbalance: require('./balance'),\n\t\tmergeLines: require('./mergeLines'),\n\t\treflectCSSValue: require('./reflectCSSValue'),\n\t\tremoveTag: require('./removeTag'),\n\t\tselectItem: require('./selectItem'),\n\t\tselectLine: require('./selectLine'),\n\t\tsplitJoinTag: require('./splitJoinTag'),\n\t\ttoggleComment: require('./toggleComment'),\n\t\tupdateImageSize: require('./updateImageSize'),\n\t\twrapWithAbbreviation: require('./wrapWithAbbreviation'),\n\t\tupdateTag: require('./updateTag')\n\t};\n\n\tfunction addAction(name, fn, options) {\n\t\tname = name.toLowerCase();\n\t\toptions = options || {};\n\t\t\n\t\tif (typeof options === 'string') {\n\t\t\toptions = {label: options};\n\t\t}\n\n\t\tif (!options.label) {\n\t\t\toptions.label = humanizeActionName(name);\n\t\t}\n\t\t\n\t\tactions[name] = {\n\t\t\tname: name,\n\t\t\tfn: fn,\n\t\t\toptions: options\n\t\t};\n\t}\n\t\n\t/**\n\t * “Humanizes” action name, makes it more readable for people\n\t * @param {String} name Action name (like 'expand_abbreviation')\n\t * @return Humanized name (like 'Expand Abbreviation')\n\t */\n\tfunction humanizeActionName(name) {\n\t\treturn utils.trim(name.charAt(0).toUpperCase() \n\t\t\t+ name.substring(1).replace(/_[a-z]/g, function(str) {\n\t\t\t\treturn ' ' + str.charAt(1).toUpperCase();\n\t\t\t}));\n\t}\n\n\tvar bind = function(name, method) {\n\t\tvar m = actionModules[name];\n\t\treturn m[method].bind(m);\n\t};\n\n\t// XXX register default actions\n\taddAction('encode_decode_data_url', bind('base64', 'encodeDecodeDataUrlAction'), 'Encode\\\\Decode data:URL image');\n\taddAction('prev_edit_point', bind('editPoints', 'previousEditPointAction'), 'Previous Edit Point');\n\taddAction('next_edit_point', bind('editPoints', 'nextEditPointAction'), 'Next Edit Point');\n\taddAction('evaluate_math_expression', bind('evaluateMath', 'evaluateMathAction'), 'Numbers/Evaluate Math Expression');\n\taddAction('expand_abbreviation_with_tab', bind('expandAbbreviation', 'expandAbbreviationWithTabAction'), {hidden: true});\n\taddAction('expand_abbreviation', bind('expandAbbreviation', 'expandAbbreviationAction'), 'Expand Abbreviation');\n\taddAction('insert_formatted_line_break_only', bind('lineBreaks', 'insertLineBreakOnlyAction'), {hidden: true});\n\taddAction('insert_formatted_line_break', bind('lineBreaks', 'insertLineBreakAction'), {hidden: true});\n\taddAction('balance_inward', bind('balance', 'balanceInwardAction'), 'Balance (inward)');\n\taddAction('balance_outward', bind('balance', 'balanceOutwardAction'), 'Balance (outward)');\n\taddAction('matching_pair', bind('balance', 'goToMatchingPairAction'), 'HTML/Go To Matching Tag Pair');\n\taddAction('merge_lines', bind('mergeLines', 'mergeLinesAction'), 'Merge Lines');\n\taddAction('reflect_css_value', bind('reflectCSSValue', 'reflectCSSValueAction'), 'CSS/Reflect Value');\n\taddAction('remove_tag', bind('removeTag', 'removeTagAction'), 'HTML/Remove Tag');\n\taddAction('select_next_item', bind('selectItem', 'selectNextItemAction'), 'Select Next Item');\n\taddAction('select_previous_item', bind('selectItem', 'selectPreviousItemAction'), 'Select Previous Item');\n\taddAction('split_join_tag', bind('splitJoinTag', 'splitJoinTagAction'), 'HTML/Split\\\\Join Tag Declaration');\n\taddAction('toggle_comment', bind('toggleComment', 'toggleCommentAction'), 'Toggle Comment');\n\taddAction('update_image_size', bind('updateImageSize', 'updateImageSizeAction'), 'Update Image Size');\n\taddAction('wrap_with_abbreviation', bind('wrapWithAbbreviation', 'wrapWithAbbreviationAction'), 'Wrap With Abbreviation');\n\taddAction('update_tag', bind('updateTag', 'updateTagAction'), 'HTML/Update Tag');\n\n\t[1, -1, 10, -10, 0.1, -0.1].forEach(function(num) {\n\t\tvar prefix = num > 0 ? 'increment' : 'decrement';\n\t\tvar suffix = String(Math.abs(num)).replace('.', '').substring(0, 2);\n\t\tvar actionId = prefix + '_number_by_' + suffix;\n\t\tvar actionMethod = prefix + suffix + 'Action';\n\t\tvar actionLabel = 'Numbers/' + prefix.charAt(0).toUpperCase() + prefix.substring(1) + ' number by ' + Math.abs(num);\n\t\taddAction(actionId, bind('incrementDecrement', actionMethod), actionLabel);\n\t});\n\t\n\treturn {\n\t\t/**\n\t\t * Registers new action\n\t\t * @param {String} name Action name\n\t\t * @param {Function} fn Action function\n\t\t * @param {Object} options Custom action options:<br>\n\t\t * <b>label</b> : (<code>String</code>) – Human-readable action name. \n\t\t * May contain '/' symbols as submenu separators<br>\n\t\t * <b>hidden</b> : (<code>Boolean</code>) – Indicates whether action\n\t\t * should be displayed in menu (<code>getMenu()</code> method)\n\t\t */\n\t\tadd: addAction,\n\t\t\n\t\t/**\n\t\t * Returns action object\n\t\t * @param {String} name Action name\n\t\t * @returns {Object}\n\t\t */\n\t\tget: function(name) {\n\t\t\treturn actions[name.toLowerCase()];\n\t\t},\n\t\t\n\t\t/**\n\t\t * Runs Emmet action. For list of available actions and their\n\t\t * arguments see <i>actions</i> folder.\n\t\t * @param {String} name Action name \n\t\t * @param {Array} args Additional arguments. It may be array of arguments\n\t\t * or inline arguments. The first argument should be <code>IEmmetEditor</code> instance\n\t\t * @returns {Boolean} Status of performed operation, <code>true</code>\n\t\t * means action was performed successfully.\n\t\t * @example\n\t\t * require('action/main').run('expand_abbreviation', editor);  \n\t\t * require('action/main').run('wrap_with_abbreviation', [editor, 'div']);  \n\t\t */\n\t\trun: function(name, args) {\n\t\t\tif (!Array.isArray(args)) {\n\t\t\t\targs = utils.toArray(arguments, 1);\n\t\t\t}\n\t\t\t\n\t\t\tvar action = this.get(name);\n\t\t\tif (!action) {\n\t\t\t\tthrow new Error('Action \"' + name + '\" is not defined');\n\t\t\t}\n\n\t\t\treturn action.fn.apply(action, args);\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns all registered actions as object\n\t\t * @returns {Object}\n\t\t */\n\t\tgetAll: function() {\n\t\t\treturn actions;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns all registered actions as array\n\t\t * @returns {Array}\n\t\t */\n\t\tgetList: function() {\n\t\t\tvar all = this.getAll();\n\t\t\treturn Object.keys(all).map(function(key) {\n\t\t\t\treturn all[key];\n\t\t\t});\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns actions list as structured menu. If action has <i>label</i>,\n\t\t * it will be splitted by '/' symbol into submenus (for example: \n\t\t * CSS/Reflect Value) and grouped with other items\n\t\t * @param {Array} skipActions List of action identifiers that should be \n\t\t * skipped from menu\n\t\t * @returns {Array}\n\t\t */\n\t\tgetMenu: function(skipActions) {\n\t\t\tvar result = [];\n\t\t\tskipActions = skipActions || [];\n\t\t\tthis.getList().forEach(function(action) {\n\t\t\t\tif (action.options.hidden || ~skipActions.indexOf(action.name))\n\t\t\t\t\treturn;\n\t\t\t\t\n\t\t\t\tvar actionName = humanizeActionName(action.name);\n\t\t\t\tvar ctx = result;\n\t\t\t\tif (action.options.label) {\n\t\t\t\t\tvar parts = action.options.label.split('/');\n\t\t\t\t\tactionName = parts.pop();\n\t\t\t\t\t\n\t\t\t\t\t// create submenus, if needed\n\t\t\t\t\tvar menuName, submenu;\n\t\t\t\t\twhile ((menuName = parts.shift())) {\n\t\t\t\t\t\tsubmenu = utils.find(ctx, function(item) {\n\t\t\t\t\t\t\treturn item.type == 'submenu' && item.name == menuName;\n\t\t\t\t\t\t});\n\t\t\t\t\t\t\n\t\t\t\t\t\tif (!submenu) {\n\t\t\t\t\t\t\tsubmenu = {\n\t\t\t\t\t\t\t\tname: menuName,\n\t\t\t\t\t\t\t\ttype: 'submenu',\n\t\t\t\t\t\t\t\titems: []\n\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\tctx.push(submenu);\n\t\t\t\t\t\t}\n\t\t\t\t\t\t\n\t\t\t\t\t\tctx = submenu.items;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tctx.push({\n\t\t\t\t\ttype: 'action',\n\t\t\t\t\tname: action.name,\n\t\t\t\t\tlabel: actionName\n\t\t\t\t});\n\t\t\t});\n\t\t\t\n\t\t\treturn result;\n\t\t},\n\n\t\t/**\n\t\t * Returns action name associated with menu item title\n\t\t * @param {String} title\n\t\t * @returns {String}\n\t\t */\n\t\tgetActionNameForMenuTitle: function(title, menu) {\n\t\t\treturn utils.find(menu || this.getMenu(), function(val) {\n\t\t\t\tif (val.type == 'action') {\n\t\t\t\t\tif (val.label == title || val.name == title) {\n\t\t\t\t\t\treturn val.name;\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\treturn this.getActionNameForMenuTitle(title, val.items);\n\t\t\t\t}\n\t\t\t}, this);\n\t\t}\n\t};\n});\n},{\"../utils/common\":\"utils\\\\common.js\",\"./balance\":\"action\\\\balance.js\",\"./base64\":\"action\\\\base64.js\",\"./editPoints\":\"action\\\\editPoints.js\",\"./evaluateMath\":\"action\\\\evaluateMath.js\",\"./expandAbbreviation\":\"action\\\\expandAbbreviation.js\",\"./incrementDecrement\":\"action\\\\incrementDecrement.js\",\"./lineBreaks\":\"action\\\\lineBreaks.js\",\"./mergeLines\":\"action\\\\mergeLines.js\",\"./reflectCSSValue\":\"action\\\\reflectCSSValue.js\",\"./removeTag\":\"action\\\\removeTag.js\",\"./selectItem\":\"action\\\\selectItem.js\",\"./selectLine\":\"action\\\\selectLine.js\",\"./splitJoinTag\":\"action\\\\splitJoinTag.js\",\"./toggleComment\":\"action\\\\toggleComment.js\",\"./updateImageSize\":\"action\\\\updateImageSize.js\",\"./updateTag\":\"action\\\\updateTag.js\",\"./wrapWithAbbreviation\":\"action\\\\wrapWithAbbreviation.js\"}],\"action\\\\mergeLines.js\":[function(require,module,exports){\n/**\n * Merges selected lines or lines between XHTML tag pairs\n * @param {Function} require\n * @param {Underscore} _\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar htmlMatcher = require('../assets/htmlMatcher');\n\tvar utils = require('../utils/common');\n\tvar editorUtils = require('../utils/editor');\n\tvar range = require('../assets/range');\n\n\treturn {\n\t\tmergeLinesAction: function(editor) {\n\t\t\tvar info = editorUtils.outputInfo(editor);\n\t\t\n\t\t\tvar selection = range(editor.getSelectionRange());\n\t\t\tif (!selection.length()) {\n\t\t\t\t// find matching tag\n\t\t\t\tvar pair = htmlMatcher.find(info.content, editor.getCaretPos());\n\t\t\t\tif (pair) {\n\t\t\t\t\tselection = pair.outerRange;\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\tif (selection.length()) {\n\t\t\t\t// got range, merge lines\n\t\t\t\tvar text =  selection.substring(info.content);\n\t\t\t\tvar lines = utils.splitByLines(text);\n\t\t\t\t\n\t\t\t\tfor (var i = 1; i < lines.length; i++) {\n\t\t\t\t\tlines[i] = lines[i].replace(/^\\s+/, '');\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\ttext = lines.join('').replace(/\\s{2,}/, ' ');\n\t\t\t\tvar textLen = text.length;\n\t\t\t\ttext = utils.escapeText(text);\n\t\t\t\teditor.replaceContent(text, selection.start, selection.end);\n\t\t\t\teditor.createSelection(selection.start, selection.start + textLen);\n\t\t\t\t\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\t\n\t\t\treturn false;\n\t\t}\n\t};\n});\n},{\"../assets/htmlMatcher\":\"assets\\\\htmlMatcher.js\",\"../assets/range\":\"assets\\\\range.js\",\"../utils/common\":\"utils\\\\common.js\",\"../utils/editor\":\"utils\\\\editor.js\"}],\"action\\\\reflectCSSValue.js\":[function(require,module,exports){\n/**\n * Reflect CSS value: takes rule's value under caret and pastes it for the same \n * rules with vendor prefixes\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar handlerList = require('../assets/handlerList');\n\tvar prefs = require('../assets/preferences');\n\tvar cssResolver = require('../resolver/css');\n\tvar cssEditTree = require('../editTree/css');\n\tvar utils = require('../utils/common');\n\tvar actionUtils = require('../utils/action');\n\tvar editorUtils = require('../utils/editor');\n\tvar cssGradient = require('../resolver/cssGradient');\n\n\tprefs.define('css.reflect.oldIEOpacity', false, 'Support IE6/7/8 opacity notation, e.g. <code>filter:alpha(opacity=...)</code>.\\\n\t\tNote that CSS3 and SVG also provides <code>filter</code> property so this option is disabled by default.')\n\n\t/**\n\t * @type HandlerList List of registered handlers\n\t */\n\tvar handlers = handlerList.create();\n\t\n\tfunction doCSSReflection(editor) {\n\t\tvar outputInfo = editorUtils.outputInfo(editor);\n\t\tvar caretPos = editor.getCaretPos();\n\t\t\n\t\tvar cssRule = cssEditTree.parseFromPosition(outputInfo.content, caretPos);\n\t\tif (!cssRule) return;\n\t\t\n\t\tvar property = cssRule.itemFromPosition(caretPos, true);\n\t\t// no property under cursor, nothing to reflect\n\t\tif (!property) return;\n\t\t\n\t\tvar oldRule = cssRule.source;\n\t\tvar offset = cssRule.options.offset;\n\t\tvar caretDelta = caretPos - offset - property.range().start;\n\t\t\n\t\thandlers.exec(false, [property]);\n\t\t\n\t\tif (oldRule !== cssRule.source) {\n\t\t\treturn {\n\t\t\t\tdata:  cssRule.source,\n\t\t\t\tstart: offset,\n\t\t\t\tend:   offset + oldRule.length,\n\t\t\t\tcaret: offset + property.range().start + caretDelta\n\t\t\t};\n\t\t}\n\t}\n\t\n\t/**\n\t * Returns regexp that should match reflected CSS property names\n\t * @param {String} name Current CSS property name\n\t * @return {RegExp}\n\t */\n\tfunction getReflectedCSSName(name) {\n\t\tname = cssEditTree.baseName(name);\n\t\tvar vendorPrefix = '^(?:\\\\-\\\\w+\\\\-)?', m;\n\t\t\n\t\tif ((name == 'opacity' || name == 'filter') && prefs.get('css.reflect.oldIEOpacity')) {\n\t\t\treturn new RegExp(vendorPrefix + '(?:opacity|filter)$');\n\t\t} else if ((m = name.match(/^border-radius-(top|bottom)(left|right)/))) {\n\t\t\t// Mozilla-style border radius\n\t\t\treturn new RegExp(vendorPrefix + '(?:' + name + '|border-' + m[1] + '-' + m[2] + '-radius)$');\n\t\t} else if ((m = name.match(/^border-(top|bottom)-(left|right)-radius/))) { \n\t\t\treturn new RegExp(vendorPrefix + '(?:' + name + '|border-radius-' + m[1] + m[2] + ')$');\n\t\t}\n\t\t\n\t\treturn new RegExp(vendorPrefix + name + '$');\n\t}\n\n\t/**\n\t * Reflects inner CSS properites in given value\n\t * agains name‘s vendor prefix. In other words, it tries\n\t * to modify `transform 0.2s linear` value for `-webkit-transition`\n\t * property\n\t * @param  {String} name  Reciever CSS property name\n\t * @param  {String} value New property value\n\t * @return {String}\n\t */\n\tfunction reflectValueParts(name, value) {\n\t\t// detects and updates vendor-specific properties in value,\n\t\t// e.g. -webkit-transition: -webkit-transform\n\t\t\n\t\tvar reVendor = /^\\-(\\w+)\\-/;\n\t\tvar propPrefix = reVendor.test(name) ? RegExp.$1.toLowerCase() : '';\n\t\tvar parts = cssEditTree.findParts(value);\n\n\t\tparts.reverse();\n\t\tparts.forEach(function(part) {\n\t\t\tvar partValue = part.substring(value).replace(reVendor, '');\n\t\t\tvar prefixes = cssResolver.vendorPrefixes(partValue);\n\t\t\tif (prefixes) {\n\t\t\t\t// if prefixes are not null then given value can\n\t\t\t\t// be resolved against Can I Use database and may or\n\t\t\t\t// may not contain prefixed variant\n\t\t\t\tif (propPrefix && ~prefixes.indexOf(propPrefix)) {\n\t\t\t\t\tpartValue = '-' + propPrefix + '-' + partValue;\n\t\t\t\t}\n\n\t\t\t\tvalue = utils.replaceSubstring(value, partValue, part);\n\t\t\t}\n\t\t});\n\n\t\treturn value;\n\t}\n\t\n\t/**\n\t * Reflects value from <code>donor</code> into <code>receiver</code>\n\t * @param {CSSProperty} donor Donor CSS property from which value should\n\t * be reflected\n\t * @param {CSSProperty} receiver Property that should receive reflected \n\t * value from donor\n\t */\n\tfunction reflectValue(donor, receiver) {\n\t\tvar value = getReflectedValue(donor.name(), donor.value(), \n\t\t\t\treceiver.name(), receiver.value());\n\t\t\n\t\tvalue = reflectValueParts(receiver.name(), value);\n\t\treceiver.value(value);\n\t}\n\t\n\t/**\n\t * Returns value that should be reflected for <code>refName</code> CSS property\n\t * from <code>curName</code> property. This function is used for special cases,\n\t * when the same result must be achieved with different properties for different\n\t * browsers. For example: opаcity:0.5; → filter:alpha(opacity=50);<br><br>\n\t * \n\t * This function does value conversion between different CSS properties\n\t * \n\t * @param {String} curName Current CSS property name\n\t * @param {String} curValue Current CSS property value\n\t * @param {String} refName Receiver CSS property's name \n\t * @param {String} refValue Receiver CSS property's value\n\t * @return {String} New value for receiver property\n\t */\n\tfunction getReflectedValue(curName, curValue, refName, refValue) {\n\t\tcurName = cssEditTree.baseName(curName);\n\t\trefName = cssEditTree.baseName(refName);\n\t\t\n\t\tif (curName == 'opacity' && refName == 'filter') {\n\t\t\treturn refValue.replace(/opacity=[^)]*/i, 'opacity=' + Math.floor(parseFloat(curValue) * 100));\n\t\t} else if (curName == 'filter' && refName == 'opacity') {\n\t\t\tvar m = curValue.match(/opacity=([^)]*)/i);\n\t\t\treturn m ? utils.prettifyNumber(parseInt(m[1], 10) / 100) : refValue;\n\t\t}\n\t\t\n\t\treturn curValue;\n\t}\n\t\n\tmodule = module || {};\n\tmodule.exports = {\n\t\treflectCSSValueAction: function(editor) {\n\t\t\tif (editor.getSyntax() != 'css') {\n\t\t\t\treturn false;\n\t\t\t}\n\n\t\t\treturn actionUtils.compoundUpdate(editor, doCSSReflection(editor));\n\t\t},\n\n\t\t_defaultHandler: function(property) {\n\t\t\tvar reName = getReflectedCSSName(property.name());\n\t\t\tproperty.parent.list().forEach(function(p) {\n\t\t\t\tif (reName.test(p.name())) {\n\t\t\t\t\treflectValue(property, p);\n\t\t\t\t}\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Adds custom reflect handler. The passed function will receive matched\n\t\t * CSS property (as <code>CSSEditElement</code> object) and should\n\t\t * return <code>true</code> if it was performed successfully (handled \n\t\t * reflection), <code>false</code> otherwise.\n\t\t * @param {Function} fn\n\t\t * @param {Object} options\n\t\t */\n\t\taddHandler: function(fn, options) {\n\t\t\thandlers.add(fn, options);\n\t\t},\n\t\t\n\t\t/**\n\t\t * Removes registered handler\n\t\t * @returns\n\t\t */\n\t\tremoveHandler: function(fn) {\n\t\t\thandlers.remove(fn);\n\t\t}\n\t};\n\n\t// XXX add default handlers\n\thandlers.add(module.exports._defaultHandler.bind(module.exports), {order: -1});\n\thandlers.add(cssGradient.reflectValueHandler.bind(cssGradient));\n\n\treturn module.exports;\n});\n},{\"../assets/handlerList\":\"assets\\\\handlerList.js\",\"../assets/preferences\":\"assets\\\\preferences.js\",\"../editTree/css\":\"editTree\\\\css.js\",\"../resolver/css\":\"resolver\\\\css.js\",\"../resolver/cssGradient\":\"resolver\\\\cssGradient.js\",\"../utils/action\":\"utils\\\\action.js\",\"../utils/common\":\"utils\\\\common.js\",\"../utils/editor\":\"utils\\\\editor.js\"}],\"action\\\\removeTag.js\":[function(require,module,exports){\n/**\n * Gracefully removes tag under cursor\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar utils = require('../utils/common');\n\tvar editorUtils = require('../utils/editor');\n\tvar htmlMatcher = require('../assets/htmlMatcher');\n\n\treturn {\n\t\tremoveTagAction: function(editor) {\n\t\t\tvar info = editorUtils.outputInfo(editor);\n\t\t\t\n\t\t\t// search for tag\n\t\t\tvar tag = htmlMatcher.tag(info.content, editor.getCaretPos());\n\t\t\tif (tag) {\n\t\t\t\tif (!tag.close) {\n\t\t\t\t\t// simply remove unary tag\n\t\t\t\t\teditor.replaceContent(utils.getCaretPlaceholder(), tag.range.start, tag.range.end);\n\t\t\t\t} else {\n\t\t\t\t\t// remove tag and its newlines\n\t\t\t\t\t/** @type Range */\n\t\t\t\t\tvar tagContentRange = utils.narrowToNonSpace(info.content, tag.innerRange);\n\t\t\t\t\t/** @type Range */\n\t\t\t\t\tvar startLineBounds = utils.findNewlineBounds(info.content, tagContentRange.start);\n\t\t\t\t\tvar startLinePad = utils.getLinePadding(startLineBounds.substring(info.content));\n\t\t\t\t\tvar tagContent = tagContentRange.substring(info.content);\n\t\t\t\t\t\n\t\t\t\t\ttagContent = utils.unindentString(tagContent, startLinePad);\n\t\t\t\t\teditor.replaceContent(utils.getCaretPlaceholder() + utils.escapeText(tagContent), tag.outerRange.start, tag.outerRange.end);\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\t\n\t\t\treturn false;\n\t\t}\n\t};\n});\n\n},{\"../assets/htmlMatcher\":\"assets\\\\htmlMatcher.js\",\"../utils/common\":\"utils\\\\common.js\",\"../utils/editor\":\"utils\\\\editor.js\"}],\"action\\\\selectItem.js\":[function(require,module,exports){\n/**\n * Actions that use stream parsers and tokenizers for traversing:\n * -- Search for next/previous items in HTML\n * -- Search for next/previous items in CSS\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar range = require('../assets/range');\n\tvar utils = require('../utils/common');\n\tvar editorUtils = require('../utils/editor');\n\tvar actionUtils = require('../utils/action');\n\tvar stringStream = require('../assets/stringStream');\n\tvar xmlParser = require('../parser/xml');\n\tvar cssEditTree = require('../editTree/css');\n\tvar cssSections = require('../utils/cssSections');\n\n\tvar startTag = /^<([\\w\\:\\-]+)((?:\\s+[\\w\\-:]+(?:\\s*=\\s*(?:(?:\"[^\"]*\")|(?:'[^']*')|[^>\\s]+))?)*)\\s*(\\/?)>/;\n\n\t/**\n\t * Generic function for searching for items to select\n\t * @param {IEmmetEditor} editor\n\t * @param {Boolean} isBackward Search backward (search forward otherwise)\n\t * @param {Function} extractFn Function that extracts item content\n\t * @param {Function} rangeFn Function that search for next token range\n\t */\n\tfunction findItem(editor, isBackward, extractFn, rangeFn) {\n\t\tvar content = editorUtils.outputInfo(editor).content;\n\t\t\n\t\tvar contentLength = content.length;\n\t\tvar itemRange, rng;\n\t\t/** @type Range */\n\t\tvar prevRange = range(-1, 0);\n\t\t/** @type Range */\n\t\tvar sel = range(editor.getSelectionRange());\n\t\t\n\t\tvar searchPos = sel.start, loop = 100000; // endless loop protection\n\t\twhile (searchPos >= 0 && searchPos < contentLength && --loop > 0) {\n\t\t\tif ( (itemRange = extractFn(content, searchPos, isBackward)) ) {\n\t\t\t\tif (prevRange.equal(itemRange)) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tprevRange = itemRange.clone();\n\t\t\t\trng = rangeFn(itemRange.substring(content), itemRange.start, sel.clone());\n\t\t\t\t\n\t\t\t\tif (rng) {\n\t\t\t\t\teditor.createSelection(rng.start, rng.end);\n\t\t\t\t\treturn true;\n\t\t\t\t} else {\n\t\t\t\t\tsearchPos = isBackward ? itemRange.start : itemRange.end - 1;\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\tsearchPos += isBackward ? -1 : 1;\n\t\t}\n\t\t\n\t\treturn false;\n\t}\n\t\n\t// XXX HTML section\n\t\n\t/**\n\t * Find next HTML item\n\t * @param {IEmmetEditor} editor\n\t */\n\tfunction findNextHTMLItem(editor) {\n\t\tvar isFirst = true;\n\t\treturn findItem(editor, false, function(content, searchPos){\n\t\t\tif (isFirst) {\n\t\t\t\tisFirst = false;\n\t\t\t\treturn findOpeningTagFromPosition(content, searchPos);\n\t\t\t} else {\n\t\t\t\treturn getOpeningTagFromPosition(content, searchPos);\n\t\t\t}\n\t\t}, function(tag, offset, selRange) {\n\t\t\treturn getRangeForHTMLItem(tag, offset, selRange, false);\n\t\t});\n\t}\n\t\n\t/**\n\t * Find previous HTML item\n\t * @param {IEmmetEditor} editor\n\t */\n\tfunction findPrevHTMLItem(editor) {\n\t\treturn findItem(editor, true, getOpeningTagFromPosition, function (tag, offset, selRange) {\n\t\t\treturn getRangeForHTMLItem(tag, offset, selRange, true);\n\t\t});\n\t}\n\t\n\t/**\n\t * Creates possible selection ranges for HTML tag\n\t * @param {String} source Original HTML source for tokens\n\t * @param {Array} tokens List of HTML tokens\n\t * @returns {Array}\n\t */\n\tfunction makePossibleRangesHTML(source, tokens, offset) {\n\t\toffset = offset || 0;\n\t\tvar result = [];\n\t\tvar attrStart = -1, attrName = '', attrValue = '', attrValueRange, tagName;\n\t\ttokens.forEach(function(tok) {\n\t\t\tswitch (tok.type) {\n\t\t\t\tcase 'tag':\n\t\t\t\t\ttagName = source.substring(tok.start, tok.end);\n\t\t\t\t\tif (/^<[\\w\\:\\-]/.test(tagName)) {\n\t\t\t\t\t\t// add tag name\n\t\t\t\t\t\tresult.push(range({\n\t\t\t\t\t\t\tstart: tok.start + 1, \n\t\t\t\t\t\t\tend: tok.end\n\t\t\t\t\t\t}));\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\tcase 'attribute':\n\t\t\t\t\tattrStart = tok.start;\n\t\t\t\t\tattrName = source.substring(tok.start, tok.end);\n\t\t\t\t\tbreak;\n\t\t\t\t\t\n\t\t\t\tcase 'string':\n\t\t\t\t\t// attribute value\n\t\t\t\t\t// push full attribute first\n\t\t\t\t\tresult.push(range(attrStart, tok.end - attrStart));\n\t\t\t\t\t\n\t\t\t\t\tattrValueRange = range(tok);\n\t\t\t\t\tattrValue = attrValueRange.substring(source);\n\t\t\t\t\t\n\t\t\t\t\t// is this a quoted attribute?\n\t\t\t\t\tif (isQuote(attrValue.charAt(0)))\n\t\t\t\t\t\tattrValueRange.start++;\n\t\t\t\t\t\n\t\t\t\t\tif (isQuote(attrValue.charAt(attrValue.length - 1)))\n\t\t\t\t\t\tattrValueRange.end--;\n\t\t\t\t\t\n\t\t\t\t\tresult.push(attrValueRange);\n\t\t\t\t\t\n\t\t\t\t\tif (attrName == 'class') {\n\t\t\t\t\t\tresult = result.concat(classNameRanges(attrValueRange.substring(source), attrValueRange.start));\n\t\t\t\t\t}\n\t\t\t\t\t\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t});\n\t\t\n\t\t// offset ranges\n\t\tresult = result.filter(function(item) {\n\t\t\tif (item.length()) {\n\t\t\t\titem.shift(offset);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t});\n\n\t\t// remove duplicates\n\t\treturn utils.unique(result, function(item) {\n\t\t\treturn item.toString();\n\t\t});\n\t}\n\t\n\t/**\n\t * Returns ranges of class names in \"class\" attribute value\n\t * @param {String} className\n\t * @returns {Array}\n\t */\n\tfunction classNameRanges(className, offset) {\n\t\toffset = offset || 0;\n\t\tvar result = [];\n\t\t/** @type StringStream */\n\t\tvar stream = stringStream.create(className);\n\t\t\n\t\t// skip whitespace\n\t\tstream.eatSpace();\n\t\tstream.start = stream.pos;\n\t\t\n\t\tvar ch;\n\t\twhile ((ch = stream.next())) {\n\t\t\tif (/[\\s\\u00a0]/.test(ch)) {\n\t\t\t\tresult.push(range(stream.start + offset, stream.pos - stream.start - 1));\n\t\t\t\tstream.eatSpace();\n\t\t\t\tstream.start = stream.pos;\n\t\t\t}\n\t\t}\n\t\t\n\t\tresult.push(range(stream.start + offset, stream.pos - stream.start));\n\t\treturn result;\n\t}\n\t\n\t/**\n\t * Returns best HTML tag range match for current selection\n\t * @param {String} tag Tag declaration\n\t * @param {Number} offset Tag's position index inside content\n\t * @param {Range} selRange Selection range\n\t * @return {Range} Returns range if next item was found, <code>null</code> otherwise\n\t */\n\tfunction getRangeForHTMLItem(tag, offset, selRange, isBackward) {\n\t\tvar ranges = makePossibleRangesHTML(tag, xmlParser.parse(tag), offset);\n\t\t\n\t\tif (isBackward)\n\t\t\tranges.reverse();\n\t\t\n\t\t// try to find selected range\n\t\tvar curRange = utils.find(ranges, function(r) {\n\t\t\treturn r.equal(selRange);\n\t\t});\n\t\t\n\t\tif (curRange) {\n\t\t\tvar ix = ranges.indexOf(curRange);\n\t\t\tif (ix < ranges.length - 1)\n\t\t\t\treturn ranges[ix + 1];\n\t\t\t\n\t\t\treturn null;\n\t\t}\n\t\t\n\t\t// no selected range, find nearest one\n\t\tif (isBackward)\n\t\t\t// search backward\n\t\t\treturn utils.find(ranges, function(r) {\n\t\t\t\treturn r.start < selRange.start;\n\t\t\t});\n\t\t\n\t\t// search forward\n\t\t// to deal with overlapping ranges (like full attribute definition\n\t\t// and attribute value) let's find range under caret first\n\t\tif (!curRange) {\n\t\t\tvar matchedRanges = ranges.filter(function(r) {\n\t\t\t\treturn r.inside(selRange.end);\n\t\t\t});\n\t\t\t\n\t\t\tif (matchedRanges.length > 1)\n\t\t\t\treturn matchedRanges[1];\n\t\t}\n\t\t\n\t\t\n\t\treturn utils.find(ranges, function(r) {\n\t\t\treturn r.end > selRange.end;\n\t\t});\n\t}\n\t\n\t/**\n\t * Search for opening tag in content, starting at specified position\n\t * @param {String} html Where to search tag\n\t * @param {Number} pos Character index where to start searching\n\t * @return {Range} Returns range if valid opening tag was found,\n\t * <code>null</code> otherwise\n\t */\n\tfunction findOpeningTagFromPosition(html, pos) {\n\t\tvar tag;\n\t\twhile (pos >= 0) {\n\t\t\tif ((tag = getOpeningTagFromPosition(html, pos)))\n\t\t\t\treturn tag;\n\t\t\tpos--;\n\t\t}\n\t\t\n\t\treturn null;\n\t}\n\t\n\t/**\n\t * @param {String} html Where to search tag\n\t * @param {Number} pos Character index where to start searching\n\t * @return {Range} Returns range if valid opening tag was found,\n\t * <code>null</code> otherwise\n\t */\n\tfunction getOpeningTagFromPosition(html, pos) {\n\t\tvar m;\n\t\tif (html.charAt(pos) == '<' && (m = html.substring(pos, html.length).match(startTag))) {\n\t\t\treturn range(pos, m[0]);\n\t\t}\n\t}\n\t\n\tfunction isQuote(ch) {\n\t\treturn ch == '\"' || ch == \"'\";\n\t}\n\n\t/**\n\t * Returns all ranges inside given rule, available for selection\n\t * @param  {CSSEditContainer} rule\n\t * @return {Array}\n\t */\n\tfunction findInnerRanges(rule) {\n\t\t// rule selector\n\t\tvar ranges = [rule.nameRange(true)];\n\n\t\t// find nested sections, keep selectors only\n\t\tvar nestedSections = cssSections.nestedSectionsInRule(rule);\n\t\tnestedSections.forEach(function(section) {\n\t\t\tranges.push(range.create2(section.start, section._selectorEnd));\n\t\t});\n\n\t\t// add full property ranges and values\n\t\trule.list().forEach(function(property) {\n\t\t\tranges = ranges.concat(makePossibleRangesCSS(property));\n\t\t});\n\n\t\tranges = range.sort(ranges);\n\n\t\t// optimize result: remove empty ranges and duplicates\n\t\tranges = ranges.filter(function(item) {\n\t\t\treturn !!item.length();\n\t\t});\n\t\treturn utils.unique(ranges, function(item) {\n\t\t\treturn item.toString();\n\t\t});\n\t}\n\t\n\t/**\n\t * Makes all possible selection ranges for specified CSS property\n\t * @param {CSSProperty} property\n\t * @returns {Array}\n\t */\n\tfunction makePossibleRangesCSS(property) {\n\t\t// find all possible ranges, sorted by position and size\n\t\tvar valueRange = property.valueRange(true);\n\t\tvar result = [property.range(true), valueRange];\n\t\t\n\t\t// locate parts of complex values.\n\t\t// some examples:\n\t\t// – 1px solid red: 3 parts\n\t\t// – arial, sans-serif: enumeration, 2 parts\n\t\t// – url(image.png): function value part\n\t\tvar value = property.value();\n\t\tproperty.valueParts().forEach(function(r) {\n\t\t\t// add absolute range\n\t\t\tvar clone = r.clone();\n\t\t\tresult.push(clone.shift(valueRange.start));\n\t\t\t\n\t\t\t/** @type StringStream */\n\t\t\tvar stream = stringStream.create(r.substring(value));\n\t\t\tif (stream.match(/^[\\w\\-]+\\(/, true)) {\n\t\t\t\t// we have a function, find values in it.\n\t\t\t\t// but first add function contents\n\t\t\t\tstream.start = stream.pos;\n\t\t\t\tstream.backUp(1);\n\t\t\t\tstream.skipToPair('(', ')');\n\t\t\t\tstream.backUp(1);\n\t\t\t\tvar fnBody = stream.current();\n\t\t\t\tresult.push(range(clone.start + stream.start, fnBody));\n\t\t\t\t\n\t\t\t\t// find parts\n\t\t\t\tcssEditTree.findParts(fnBody).forEach(function(part) {\n\t\t\t\t\tresult.push(range(clone.start + stream.start + part.start, part.substring(fnBody)));\n\t\t\t\t});\n\t\t\t}\n\t\t});\n\n\t\treturn result;\n\t}\n\t\n\t/**\n\t * Tries to find matched CSS property and nearest range for selection\n\t * @param {CSSRule} rule\n\t * @param {Range} selRange\n\t * @param {Boolean} isBackward\n\t * @returns {Range}\n\t */\n\tfunction matchedRangeForCSSProperty(rule, selRange, isBackward) {\n\t\tvar ranges = findInnerRanges(rule);\n\t\tif (isBackward) {\n\t\t\tranges.reverse();\n\t\t}\n\t\t\n\t\t// return next to selected range, if possible\n\t\tvar r = utils.find(ranges, function(item) {\n\t\t\treturn item.equal(selRange);\n\t\t});\n\n\t\tif (r) {\n\t\t\treturn ranges[ranges.indexOf(r) + 1];\n\t\t}\n\n\t\t// find matched and (possibly) overlapping ranges\n\t\tvar nested = ranges.filter(function(item) {\n\t\t\treturn item.inside(selRange.end);\n\t\t});\n\n\t\tif (nested.length) {\n\t\t\treturn nested.sort(function(a, b) {\n\t\t\t\treturn a.length() - b.length();\n\t\t\t})[0];\n\t\t}\n\n\t\t// return range next to caret\n\t\tvar test = \n\t\tr = utils.find(ranges, isBackward \n\t\t\t? function(item) {return item.end < selRange.start;}\n\t\t\t: function(item) {return item.end > selRange.start;}\n\t\t);\n\n\t\tif (!r) {\n\t\t\t// can’t find anything, just pick first one\n\t\t\tr = ranges[0];\n\t\t}\n\n\t\treturn r;\n\t}\n\t\n\tfunction findNextCSSItem(editor) {\n\t\treturn findItem(editor, false, cssSections.locateRule.bind(cssSections), getRangeForNextItemInCSS);\n\t}\n\t\n\tfunction findPrevCSSItem(editor) {\n\t\treturn findItem(editor, true, cssSections.locateRule.bind(cssSections), getRangeForPrevItemInCSS);\n\t}\n\t\n\t/**\n\t * Returns range for item to be selected in CSS after current caret \n\t * (selection) position\n\t * @param {String} rule CSS rule declaration\n\t * @param {Number} offset Rule's position index inside content\n\t * @param {Range} selRange Selection range\n\t * @return {Range} Returns range if next item was found, <code>null</code> otherwise\n\t */\n\tfunction getRangeForNextItemInCSS(rule, offset, selRange) {\n\t\tvar tree = cssEditTree.parse(rule, {\n\t\t\toffset: offset\n\t\t});\n\n\t\treturn matchedRangeForCSSProperty(tree, selRange, false);\n\t}\n\t\n\t/**\n\t * Returns range for item to be selected in CSS before current caret \n\t * (selection) position\n\t * @param {String} rule CSS rule declaration\n\t * @param {Number} offset Rule's position index inside content\n\t * @param {Range} selRange Selection range\n\t * @return {Range} Returns range if previous item was found, <code>null</code> otherwise\n\t */\n\tfunction getRangeForPrevItemInCSS(rule, offset, selRange) {\n\t\tvar tree = cssEditTree.parse(rule, {\n\t\t\toffset: offset\n\t\t});\n\n\t\treturn matchedRangeForCSSProperty(tree, selRange, true);\n\t}\n\n\treturn {\n\t\tselectNextItemAction: function(editor) {\n\t\t\tif (actionUtils.isSupportedCSS(editor.getSyntax())) {\n\t\t\t\treturn findNextCSSItem(editor);\n\t\t\t} else {\n\t\t\t\treturn findNextHTMLItem(editor);\n\t\t\t}\n\t\t},\n\n\t\tselectPreviousItemAction: function(editor) {\n\t\t\tif (actionUtils.isSupportedCSS(editor.getSyntax())) {\n\t\t\t\treturn findPrevCSSItem(editor);\n\t\t\t} else {\n\t\t\t\treturn findPrevHTMLItem(editor);\n\t\t\t}\n\t\t}\n\t};\n});\n},{\"../assets/range\":\"assets\\\\range.js\",\"../assets/stringStream\":\"assets\\\\stringStream.js\",\"../editTree/css\":\"editTree\\\\css.js\",\"../parser/xml\":\"parser\\\\xml.js\",\"../utils/action\":\"utils\\\\action.js\",\"../utils/common\":\"utils\\\\common.js\",\"../utils/cssSections\":\"utils\\\\cssSections.js\",\"../utils/editor\":\"utils\\\\editor.js\"}],\"action\\\\selectLine.js\":[function(require,module,exports){\n/**\n * Select current line (for simple editors like browser's &lt;textarea&gt;)\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\treturn {\n\t\tselectLineAction: function(editor) {\n\t\t\tvar range = editor.getCurrentLineRange();\n\t\t\teditor.createSelection(range.start, range.end);\n\t\t\treturn true;\n\t\t}\n\t};\n});\n},{}],\"action\\\\splitJoinTag.js\":[function(require,module,exports){\n/**\n * Splits or joins tag, e.g. transforms it into a short notation and vice versa:<br>\n * &lt;div&gt;&lt;/div&gt; → &lt;div /&gt; : join<br>\n * &lt;div /&gt; → &lt;div&gt;&lt;/div&gt; : split\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar utils = require('../utils/common');\n\tvar resources = require('../assets/resources');\n\tvar matcher = require('../assets/htmlMatcher');\n\tvar editorUtils = require('../utils/editor');\n\tvar profile = require('../assets/profile');\n\n\t/**\n\t * @param {IEmmetEditor} editor\n\t * @param {Object} profile\n\t * @param {Object} tag\n\t */\n\tfunction joinTag(editor, profile, tag) {\n\t\t// empty closing slash is a nonsense for this action\n\t\tvar slash = profile.selfClosing() || ' /';\n\t\tvar content = tag.open.range.substring(tag.source).replace(/\\s*>$/, slash + '>');\n\t\t\n\t\tvar caretPos = editor.getCaretPos();\n\t\t\n\t\t// update caret position\n\t\tif (content.length + tag.outerRange.start < caretPos) {\n\t\t\tcaretPos = content.length + tag.outerRange.start;\n\t\t}\n\t\t\n\t\tcontent = utils.escapeText(content);\n\t\teditor.replaceContent(content, tag.outerRange.start, tag.outerRange.end);\n\t\teditor.setCaretPos(caretPos);\n\t\treturn true;\n\t}\n\t\n\tfunction splitTag(editor, profile, tag) {\n\t\tvar caretPos = editor.getCaretPos();\n\t\t\n\t\t// define tag content depending on profile\n\t\tvar tagContent = (profile.tag_nl === true) ? '\\n\\t\\n' : '';\n\t\tvar content = tag.outerContent().replace(/\\s*\\/>$/, '>');\n\t\tcaretPos = tag.outerRange.start + content.length;\n\t\tcontent += tagContent + '</' + tag.open.name + '>';\n\t\t\n\t\tcontent = utils.escapeText(content);\n\t\teditor.replaceContent(content, tag.outerRange.start, tag.outerRange.end);\n\t\teditor.setCaretPos(caretPos);\n\t\treturn true;\n\t}\n\n\treturn {\n\t\tsplitJoinTagAction: function(editor, profileName) {\n\t\t\tvar info = editorUtils.outputInfo(editor, null, profileName);\n\t\t\tvar curProfile = profile.get(info.profile);\n\t\t\t\n\t\t\t// find tag at current position\n\t\t\tvar tag = matcher.tag(info.content, editor.getCaretPos());\n\t\t\tif (tag) {\n\t\t\t\treturn tag.close \n\t\t\t\t\t? joinTag(editor, curProfile, tag) \n\t\t\t\t\t: splitTag(editor, curProfile, tag);\n\t\t\t}\n\t\t\t\n\t\t\treturn false;\n\t\t}\n\t};\n});\n},{\"../assets/htmlMatcher\":\"assets\\\\htmlMatcher.js\",\"../assets/profile\":\"assets\\\\profile.js\",\"../assets/resources\":\"assets\\\\resources.js\",\"../utils/common\":\"utils\\\\common.js\",\"../utils/editor\":\"utils\\\\editor.js\"}],\"action\\\\toggleComment.js\":[function(require,module,exports){\n/**\n * Toggles HTML and CSS comments depending on current caret context. Unlike\n * the same action in most editors, this action toggles comment on currently\n * matched item—HTML tag or CSS selector—when nothing is selected.\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar prefs = require('../assets/preferences');\n\tvar range = require('../assets/range');\n\tvar utils = require('../utils/common');\n\tvar actionUtils = require('../utils/action');\n\tvar editorUtils = require('../utils/editor');\n\tvar htmlMatcher = require('../assets/htmlMatcher');\n\tvar cssEditTree = require('../editTree/css');\n\n\t/**\n\t * Toggle HTML comment on current selection or tag\n\t * @param {IEmmetEditor} editor\n\t * @return {Boolean} Returns <code>true</code> if comment was toggled\n\t */\n\tfunction toggleHTMLComment(editor) {\n\t\t/** @type Range */\n\t\tvar r = range(editor.getSelectionRange());\n\t\tvar info = editorUtils.outputInfo(editor);\n\t\t\t\n\t\tif (!r.length()) {\n\t\t\t// no selection, find matching tag\n\t\t\tvar tag = htmlMatcher.tag(info.content, editor.getCaretPos());\n\t\t\tif (tag) { // found pair\n\t\t\t\tr = tag.outerRange;\n\t\t\t}\n\t\t}\n\t\t\n\t\treturn genericCommentToggle(editor, '<!--', '-->', r);\n\t}\n\n\t/**\n\t * Simple CSS commenting\n\t * @param {IEmmetEditor} editor\n\t * @return {Boolean} Returns <code>true</code> if comment was toggled\n\t */\n\tfunction toggleCSSComment(editor) {\n\t\t/** @type Range */\n\t\tvar rng = range(editor.getSelectionRange());\n\t\tvar info = editorUtils.outputInfo(editor);\n\t\t\t\n\t\tif (!rng.length()) {\n\t\t\t// no selection, try to get current rule\n\t\t\t/** @type CSSRule */\n\t\t\tvar rule = cssEditTree.parseFromPosition(info.content, editor.getCaretPos());\n\t\t\tif (rule) {\n\t\t\t\tvar property = cssItemFromPosition(rule, editor.getCaretPos());\n\t\t\t\trng = property \n\t\t\t\t\t? property.range(true) \n\t\t\t\t\t: range(rule.nameRange(true).start, rule.source);\n\t\t\t}\n\t\t}\n\t\t\n\t\tif (!rng.length()) {\n\t\t\t// still no selection, get current line\n\t\t\trng = range(editor.getCurrentLineRange());\n\t\t\tutils.narrowToNonSpace(info.content, rng);\n\t\t}\n\t\t\n\t\treturn genericCommentToggle(editor, '/*', '*/', rng);\n\t}\n\t\n\t/**\n\t * Returns CSS property from <code>rule</code> that matches passed position\n\t * @param {EditContainer} rule\n\t * @param {Number} absPos\n\t * @returns {EditElement}\n\t */\n\tfunction cssItemFromPosition(rule, absPos) {\n\t\t// do not use default EditContainer.itemFromPosition() here, because\n\t\t// we need to make a few assumptions to make CSS commenting more reliable\n\t\tvar relPos = absPos - (rule.options.offset || 0);\n\t\tvar reSafeChar = /^[\\s\\n\\r]/;\n\t\treturn utils.find(rule.list(), function(item) {\n\t\t\tif (item.range().end === relPos) {\n\t\t\t\t// at the end of property, but outside of it\n\t\t\t\t// if there’s a space character at current position,\n\t\t\t\t// use current property\n\t\t\t\treturn reSafeChar.test(rule.source.charAt(relPos));\n\t\t\t}\n\t\t\t\n\t\t\treturn item.range().inside(relPos);\n\t\t});\n\t}\n\n\t/**\n\t * Search for nearest comment in <code>str</code>, starting from index <code>from</code>\n\t * @param {String} text Where to search\n\t * @param {Number} from Search start index\n\t * @param {String} start_token Comment start string\n\t * @param {String} end_token Comment end string\n\t * @return {Range} Returns null if comment wasn't found\n\t */\n\tfunction searchComment(text, from, startToken, endToken) {\n\t\tvar commentStart = -1;\n\t\tvar commentEnd = -1;\n\t\t\n\t\tvar hasMatch = function(str, start) {\n\t\t\treturn text.substr(start, str.length) == str;\n\t\t};\n\t\t\t\n\t\t// search for comment start\n\t\twhile (from--) {\n\t\t\tif (hasMatch(startToken, from)) {\n\t\t\t\tcommentStart = from;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\t\n\t\tif (commentStart != -1) {\n\t\t\t// search for comment end\n\t\t\tfrom = commentStart;\n\t\t\tvar contentLen = text.length;\n\t\t\twhile (contentLen >= from++) {\n\t\t\t\tif (hasMatch(endToken, from)) {\n\t\t\t\t\tcommentEnd = from + endToken.length;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\t\n\t\treturn (commentStart != -1 && commentEnd != -1) \n\t\t\t? range(commentStart, commentEnd - commentStart) \n\t\t\t: null;\n\t}\n\n\t/**\n\t * Generic comment toggling routine\n\t * @param {IEmmetEditor} editor\n\t * @param {String} commentStart Comment start token\n\t * @param {String} commentEnd Comment end token\n\t * @param {Range} range Selection range\n\t * @return {Boolean}\n\t */\n\tfunction genericCommentToggle(editor, commentStart, commentEnd, range) {\n\t\tvar content = editorUtils.outputInfo(editor).content;\n\t\tvar caretPos = editor.getCaretPos();\n\t\tvar newContent = null;\n\t\t\t\n\t\t/**\n\t\t * Remove comment markers from string\n\t\t * @param {Sting} str\n\t\t * @return {String}\n\t\t */\n\t\tfunction removeComment(str) {\n\t\t\treturn str\n\t\t\t\t.replace(new RegExp('^' + utils.escapeForRegexp(commentStart) + '\\\\s*'), function(str){\n\t\t\t\t\tcaretPos -= str.length;\n\t\t\t\t\treturn '';\n\t\t\t\t}).replace(new RegExp('\\\\s*' + utils.escapeForRegexp(commentEnd) + '$'), '');\n\t\t}\n\t\t\n\t\t// first, we need to make sure that this substring is not inside \n\t\t// comment\n\t\tvar commentRange = searchComment(content, caretPos, commentStart, commentEnd);\n\t\tif (commentRange && commentRange.overlap(range)) {\n\t\t\t// we're inside comment, remove it\n\t\t\trange = commentRange;\n\t\t\tnewContent = removeComment(range.substring(content));\n\t\t} else {\n\t\t\t// should add comment\n\t\t\t// make sure that there's no comment inside selection\n\t\t\tnewContent = commentStart + ' ' +\n\t\t\t\trange.substring(content)\n\t\t\t\t\t.replace(new RegExp(utils.escapeForRegexp(commentStart) + '\\\\s*|\\\\s*' + utils.escapeForRegexp(commentEnd), 'g'), '') +\n\t\t\t\t' ' + commentEnd;\n\t\t\t\t\n\t\t\t// adjust caret position\n\t\t\tcaretPos += commentStart.length + 1;\n\t\t}\n\n\t\t// replace editor content\n\t\tif (newContent !== null) {\n\t\t\tnewContent = utils.escapeText(newContent);\n\t\t\teditor.setCaretPos(range.start);\n\t\t\teditor.replaceContent(editorUtils.unindent(editor, newContent), range.start, range.end);\n\t\t\teditor.setCaretPos(caretPos);\n\t\t\treturn true;\n\t\t}\n\t\t\n\t\treturn false;\n\t}\n\t\n\treturn {\n\t\t/**\n\t\t * Toggle comment on current editor's selection or HTML tag/CSS rule\n\t\t * @param {IEmmetEditor} editor\n\t\t */\n\t\ttoggleCommentAction: function(editor) {\n\t\t\tvar info = editorUtils.outputInfo(editor);\n\t\t\tif (actionUtils.isSupportedCSS(info.syntax)) {\n\t\t\t\t// in case our editor is good enough and can recognize syntax from \n\t\t\t\t// current token, we have to make sure that cursor is not inside\n\t\t\t\t// 'style' attribute of html element\n\t\t\t\tvar caretPos = editor.getCaretPos();\n\t\t\t\tvar tag = htmlMatcher.tag(info.content, caretPos);\n\t\t\t\tif (tag && tag.open.range.inside(caretPos)) {\n\t\t\t\t\tinfo.syntax = 'html';\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\tvar cssSyntaxes = prefs.getArray('css.syntaxes');\n\t\t\tif (~cssSyntaxes.indexOf(info.syntax)) {\n\t\t\t\treturn toggleCSSComment(editor);\n\t\t\t}\n\t\t\t\n\t\t\treturn toggleHTMLComment(editor);\n\t\t}\n\t};\n});\n},{\"../assets/htmlMatcher\":\"assets\\\\htmlMatcher.js\",\"../assets/preferences\":\"assets\\\\preferences.js\",\"../assets/range\":\"assets\\\\range.js\",\"../editTree/css\":\"editTree\\\\css.js\",\"../utils/action\":\"utils\\\\action.js\",\"../utils/common\":\"utils\\\\common.js\",\"../utils/editor\":\"utils\\\\editor.js\"}],\"action\\\\updateImageSize.js\":[function(require,module,exports){\n/**\n * Automatically updates image size attributes in HTML's &lt;img&gt; element or\n * CSS rule\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar utils = require('../utils/common');\n\tvar editorUtils = require('../utils/editor');\n\tvar actionUtils = require('../utils/action');\n\tvar xmlEditTree = require('../editTree/xml');\n\tvar cssEditTree = require('../editTree/css');\n\tvar base64 = require('../utils/base64');\n\tvar file = require('../plugin/file');\n\n\t/**\n\t * Updates image size of &lt;img src=\"\"&gt; tag\n\t * @param {IEmmetEditor} editor\n\t */\n\tfunction updateImageSizeHTML(editor) {\n\t\tvar offset = editor.getCaretPos();\n\n\t\t// find tag from current caret position\n\t\tvar info = editorUtils.outputInfo(editor);\n\t\tvar xmlElem = xmlEditTree.parseFromPosition(info.content, offset, true);\n\t\tif (xmlElem && (xmlElem.name() || '').toLowerCase() == 'img') {\n\t\t\tgetImageSizeForSource(editor, xmlElem.value('src'), function(size) {\n\t\t\t\tif (size) {\n\t\t\t\t\tvar compoundData = xmlElem.range(true);\n\t\t\t\t\txmlElem.value('width', size.width);\n\t\t\t\t\txmlElem.value('height', size.height, xmlElem.indexOf('width') + 1);\n\n\t\t\t\t\tactionUtils.compoundUpdate(editor, utils.extend(compoundData, {\n\t\t\t\t\t\tdata: xmlElem.toString(),\n\t\t\t\t\t\tcaret: offset\n\t\t\t\t\t}));\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t}\n\n\t/**\n\t * Updates image size of CSS property\n\t * @param {IEmmetEditor} editor\n\t */\n\tfunction updateImageSizeCSS(editor) {\n\t\tvar offset = editor.getCaretPos();\n\n\t\t// find tag from current caret position\n\t\tvar info = editorUtils.outputInfo(editor);\n\t\tvar cssRule = cssEditTree.parseFromPosition(info.content, offset, true);\n\t\tif (cssRule) {\n\t\t\t// check if there is property with image under caret\n\t\t\tvar prop = cssRule.itemFromPosition(offset, true), m;\n\t\t\tif (prop && (m = /url\\(([\"']?)(.+?)\\1\\)/i.exec(prop.value() || ''))) {\n\t\t\t\tgetImageSizeForSource(editor, m[2], function(size) {\n\t\t\t\t\tif (size) {\n\t\t\t\t\t\tvar compoundData = cssRule.range(true);\n\t\t\t\t\t\tcssRule.value('width', size.width + 'px');\n\t\t\t\t\t\tcssRule.value('height', size.height + 'px', cssRule.indexOf('width') + 1);\n\n\t\t\t\t\t\tactionUtils.compoundUpdate(editor, utils.extend(compoundData, {\n\t\t\t\t\t\t\tdata: cssRule.toString(),\n\t\t\t\t\t\t\tcaret: offset\n\t\t\t\t\t\t}));\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Returns image dimensions for source\n\t * @param {IEmmetEditor} editor\n\t * @param {String} src Image source (path or data:url)\n\t */\n\tfunction getImageSizeForSource(editor, src, callback) {\n\t\tvar fileContent;\n\t\tif (src) {\n\t\t\t// check if it is data:url\n\t\t\tif (/^data:/.test(src)) {\n\t\t\t\tfileContent = base64.decode( src.replace(/^data\\:.+?;.+?,/, '') );\n\t\t\t\treturn callback(actionUtils.getImageSize(fileContent));\n\t\t\t}\n\n\t\t\tvar filePath = editor.getFilePath();\n\t\t\tfile.locateFile(filePath, src, function(absPath) {\n\t\t\t\tif (absPath === null) {\n\t\t\t\t\tthrow \"Can't find \" + src + ' file';\n\t\t\t\t}\n\n\t\t\t\tfile.read(absPath, function(err, content) {\n\t\t\t\t\tif (err) {\n\t\t\t\t\t\tthrow 'Unable to read ' + absPath + ': ' + err;\n\t\t\t\t\t}\n\n\t\t\t\t\tcontent = String(content);\n\t\t\t\t\tcallback(actionUtils.getImageSize(content));\n\t\t\t\t});\n\t\t\t});\n\t\t}\n\t}\n\n\treturn {\n\t\tupdateImageSizeAction: function(editor) {\n\t\t\t// this action will definitely won’t work in SASS dialect,\n\t\t\t// but may work in SCSS or LESS\n\t\t\tif (actionUtils.isSupportedCSS(editor.getSyntax())) {\n\t\t\t\tupdateImageSizeCSS(editor);\n\t\t\t} else {\n\t\t\t\tupdateImageSizeHTML(editor);\n\t\t\t}\n\n\t\t\treturn true;\n\t\t}\n\t};\n});\n},{\"../editTree/css\":\"editTree\\\\css.js\",\"../editTree/xml\":\"editTree\\\\xml.js\",\"../plugin/file\":\"plugin\\\\file.js\",\"../utils/action\":\"utils\\\\action.js\",\"../utils/base64\":\"utils\\\\base64.js\",\"../utils/common\":\"utils\\\\common.js\",\"../utils/editor\":\"utils\\\\editor.js\"}],\"action\\\\updateTag.js\":[function(require,module,exports){\n/**\n * Update Tag action: allows users to update existing HTML tags and add/remove\n * attributes or even tag name\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar xmlEditTree = require('../editTree/xml');\n\tvar editorUtils = require('../utils/editor');\n\tvar actionUtils = require('../utils/action');\n\tvar utils = require('../utils/common');\n\tvar parser = require('../parser/abbreviation');\n\n\tfunction updateAttributes(tag, abbrNode, ix) {\n\t\tvar classNames = (abbrNode.attribute('class') || '').split(/\\s+/g);\n\t\tif (ix) {\n\t\t\tclassNames.push('+' + abbrNode.name());\n\t\t}\n\n\t\tvar r = function(str) {\n\t\t\treturn utils.replaceCounter(str, abbrNode.counter);\n\t\t};\n\n\t\t// update class\n\t\tclassNames.forEach(function(className) {\n\t\t\tif (!className) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tclassName = r(className);\n\t\t\tvar ch = className.charAt(0);\n\t\t\tif (ch == '+') {\n\t\t\t\ttag.addClass(className.substr(1));\n\t\t\t} else if (ch == '-') {\n\t\t\t\ttag.removeClass(className.substr(1));\n\t\t\t} else {\n\t\t\t\ttag.value('class', className);\n\t\t\t}\n\t\t});\n\n\t\t// update attributes\n\t\tabbrNode.attributeList().forEach(function(attr) {\n\t\t\tif (attr.name.toLowerCase() == 'class') {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tvar ch = attr.name.charAt(0);\n\t\t\tif (ch == '+') {\n\t\t\t\tvar attrName = attr.name.substr(1);\n\t\t\t\tvar tagAttr = tag.get(attrName);\n\t\t\t\tif (tagAttr) {\n\t\t\t\t\ttagAttr.value(tagAttr.value() + r(attr.value));\n\t\t\t\t} else {\n\t\t\t\t\ttag.value(attrName, r(attr.value));\n\t\t\t\t}\n\t\t\t} else if (ch == '-') {\n\t\t\t\ttag.remove(attr.name.substr(1));\n\t\t\t} else {\n\t\t\t\ttag.value(attr.name, r(attr.value));\n\t\t\t}\n\t\t});\n\t}\n\t\n\treturn {\n\t\t/**\n\t\t * Matches HTML tag under caret and updates its definition\n\t\t * according to given abbreviation\n\t\t * @param {IEmmetEditor} Editor instance\n\t\t * @param {String} abbr Abbreviation to update with\n\t\t */\n\t\tupdateTagAction: function(editor, abbr) {\n\t\t\tabbr = abbr || editor.prompt(\"Enter abbreviation\");\n\n\t\t\tif (!abbr) {\n\t\t\t\treturn false;\n\t\t\t}\n\n\t\t\tvar content = editor.getContent();\n\t\t\tvar ctx = actionUtils.captureContext(editor);\n\t\t\tvar tag = this.getUpdatedTag(abbr, ctx, content);\n\n\t\t\tif (!tag) {\n\t\t\t\t// nothing to update\n\t\t\t\treturn false;\n\t\t\t}\n\n\t\t\t// check if tag name was updated\n\t\t\tif (tag.name() != ctx.name && ctx.match.close) {\n\t\t\t\teditor.replaceContent('</' + tag.name() + '>', ctx.match.close.range.start, ctx.match.close.range.end, true);\n\t\t\t}\n\n\t\t\teditor.replaceContent(tag.source, ctx.match.open.range.start, ctx.match.open.range.end, true);\n\t\t\treturn true;\n\t\t},\n\n\t\t/**\n\t\t * Returns XMLEditContainer node with updated tag structure\n\t\t * of existing tag context.\n\t\t * This data can be used to modify existing tag\n\t\t * @param  {String} abbr    Abbreviation\n\t\t * @param  {Object} ctx     Tag to be updated (captured with `htmlMatcher`)\n\t\t * @param  {String} content Original editor content\n\t\t * @return {XMLEditContainer}\n\t\t */\n\t\tgetUpdatedTag: function(abbr, ctx, content, options) {\n\t\t\tif (!ctx) {\n\t\t\t\t// nothing to update\n\t\t\t\treturn null;\n\t\t\t}\n\n\t\t\tvar tree = parser.parse(abbr, options || {});\n\n\t\t\t// for this action some characters in abbreviation has special\n\t\t\t// meaning. For example, `.-c2` means “remove `c2` class from\n\t\t\t// element” and `.+c3` means “append class `c3` to exising one.\n\t\t\t// \n\t\t\t// But `.+c3` abbreviation will actually produce two elements:\n\t\t\t// <div class=\"\"> and <c3>. Thus, we have to walk on each element\n\t\t\t// of parsed tree and use their definitions to update current element\n\t\t\tvar tag = xmlEditTree.parse(ctx.match.open.range.substring(content), {\n\t\t\t\toffset: ctx.match.outerRange.start\n\t\t\t});\n\n\t\t\ttree.children.forEach(function(node, i) {\n\t\t\t\tupdateAttributes(tag, node, i);\n\t\t\t});\n\n\t\t\t// if tag name was resolved by implicit tag name resolver,\n\t\t\t// then user omitted it in abbreviation and wants to keep\n\t\t\t// original tag name\n\t\t\tvar el = tree.children[0];\n\t\t\tif (!el.data('nameResolved')) {\n\t\t\t\ttag.name(el.name());\n\t\t\t}\n\n\t\t\treturn tag;\n\t\t}\n\t};\n});\n},{\"../editTree/xml\":\"editTree\\\\xml.js\",\"../parser/abbreviation\":\"parser\\\\abbreviation.js\",\"../utils/action\":\"utils\\\\action.js\",\"../utils/common\":\"utils\\\\common.js\",\"../utils/editor\":\"utils\\\\editor.js\"}],\"action\\\\wrapWithAbbreviation.js\":[function(require,module,exports){\n/**\n * Action that wraps content with abbreviation. For convenience, action is \n * defined as reusable module\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar range = require('../assets/range');\n\tvar htmlMatcher = require('../assets/htmlMatcher');\n\tvar utils = require('../utils/common');\n\tvar editorUtils = require('../utils/editor');\n\tvar actionUtils = require('../utils/action');\n\tvar parser = require('../parser/abbreviation');\n\t\n\treturn {\n\t\t/**\n\t\t * Wraps content with abbreviation\n\t\t * @param {IEmmetEditor} Editor instance\n\t\t * @param {String} abbr Abbreviation to wrap with\n\t\t * @param {String} syntax Syntax type (html, css, etc.)\n\t\t * @param {String} profile Output profile name (html, xml, xhtml)\n\t\t */\n\t\twrapWithAbbreviationAction: function(editor, abbr, syntax, profile) {\n\t\t\tvar info = editorUtils.outputInfo(editor, syntax, profile);\n\t\t\tabbr = abbr || editor.prompt(\"Enter abbreviation\");\n\t\t\t\n\t\t\tif (!abbr) {\n\t\t\t\treturn null;\n\t\t\t}\n\t\t\t\n\t\t\tabbr = String(abbr);\n\t\t\t\n\t\t\tvar r = range(editor.getSelectionRange());\n\t\t\t\n\t\t\tif (!r.length()) {\n\t\t\t\t// no selection, find tag pair\n\t\t\t\tvar match = htmlMatcher.tag(info.content, r.start);\n\t\t\t\tif (!match) {  // nothing to wrap\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tr = utils.narrowToNonSpace(info.content, match.range);\n\t\t\t}\n\t\t\t\n\t\t\tvar newContent = utils.escapeText(r.substring(info.content));\n\t\t\tvar result = parser.expand(abbr, {\n\t\t\t\tpastedContent: editorUtils.unindent(editor, newContent),\n\t\t\t\tsyntax: info.syntax,\n\t\t\t\tprofile: info.profile,\n\t\t\t\tcontextNode: actionUtils.captureContext(editor)\n\t\t\t});\n\t\t\t\n\t\t\tif (result) {\n\t\t\t\teditor.replaceContent(result, r.start, r.end);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\t\n\t\t\treturn false;\n\t\t}\n\t};\n});\n},{\"../assets/htmlMatcher\":\"assets\\\\htmlMatcher.js\",\"../assets/range\":\"assets\\\\range.js\",\"../parser/abbreviation\":\"parser\\\\abbreviation.js\",\"../utils/action\":\"utils\\\\action.js\",\"../utils/common\":\"utils\\\\common.js\",\"../utils/editor\":\"utils\\\\editor.js\"}],\"assets\\\\caniuse.js\":[function(require,module,exports){\n/**\n * Parsed resources (snippets, abbreviations, variables, etc.) for Emmet.\n * Contains convenient method to get access for snippets with respect of\n * inheritance. Also provides ability to store data in different vocabularies\n * ('system' and 'user') for fast and safe resource update\n * @author Sergey Chikuyonok (serge.che@gmail.com)\n * @link http://chikuyonok.ru\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar prefs = require('./preferences');\n\tvar utils = require('../utils/common');\n\n\tprefs.define('caniuse.enabled', true, 'Enable support of Can I Use database. When enabled,\\\n\t\tCSS abbreviation resolver will look at Can I Use database first before detecting\\\n\t\tCSS properties that should be resolved');\n\n\tprefs.define('caniuse.vendors', 'all', 'A comma-separated list vendor identifiers\\\n\t\t(as described in Can I Use database) that should be supported\\\n\t\twhen resolving vendor-prefixed properties. Set value to <code>all</code>\\\n\t\tto support all available properties');\n\n\tprefs.define('caniuse.era', 'e-2', 'Browser era, as defined in Can I Use database.\\\n\t\tExamples: <code>e0</code> (current version), <code>e1</code> (near future)\\\n\t\t<code>e-2</code> (2 versions back) and so on.');\n\n\tvar cssSections = {\n\t\t'border-image': ['border-image'],\n\t\t'css-boxshadow': ['box-shadow'],\n\t\t'css3-boxsizing': ['box-sizing'],\n\t\t'multicolumn': ['column-width', 'column-count', 'columns', 'column-gap', 'column-rule-color', 'column-rule-style', 'column-rule-width', 'column-rule', 'column-span', 'column-fill'],\n\t\t'border-radius': ['border-radius', 'border-top-left-radius', 'border-top-right-radius', 'border-bottom-right-radius', 'border-bottom-left-radius'],\n\t\t'transforms2d': ['transform'],\n\t\t'css-hyphens': ['hyphens'],\n\t\t'css-transitions': ['transition', 'transition-property', 'transition-duration', 'transition-timing-function', 'transition-delay'],\n\t\t'font-feature': ['font-feature-settings'],\n\t\t'css-animation': ['animation', 'animation-name', 'animation-duration', 'animation-timing-function', 'animation-iteration-count', 'animation-direction', 'animation-play-state', 'animation-delay', 'animation-fill-mode', '@keyframes'],\n\t\t'css-gradients': ['linear-gradient'],\n\t\t'css-masks': ['mask-image', 'mask-source-type', 'mask-repeat', 'mask-position', 'mask-clip', 'mask-origin', 'mask-size', 'mask', 'mask-type', 'mask-box-image-source', 'mask-box-image-slice', 'mask-box-image-width', 'mask-box-image-outset', 'mask-box-image-repeat', 'mask-box-image', 'clip-path', 'clip-rule'],\n\t\t'css-featurequeries': ['@supports'],\n\t\t'flexbox': ['flex', 'inline-flex', 'flex-direction', 'flex-wrap', 'flex-flow', 'order', 'flex'],\n\t\t'calc': ['calc'],\n\t\t'object-fit': ['object-fit', 'object-position'],\n\t\t'css-grid': ['grid', 'inline-grid', 'grid-template-rows', 'grid-template-columns', 'grid-template-areas', 'grid-template', 'grid-auto-rows', 'grid-auto-columns', ' grid-auto-flow', 'grid-auto-position', 'grid', ' grid-row-start', 'grid-column-start', 'grid-row-end', 'grid-column-end', 'grid-column', 'grid-row', 'grid-area', 'justify-self', 'justify-items', 'align-self', 'align-items'],\n\t\t'css-repeating-gradients': ['repeating-linear-gradient'],\n\t\t'css-filters': ['filter'],\n\t\t'user-select-none': ['user-select'],\n\t\t'intrinsic-width': ['min-content', 'max-content', 'fit-content', 'fill-available'],\n\t\t'css3-tabsize': ['tab-size']\n\t};\n\n\t/** @type {Object} The Can I Use database for CSS */\n\tvar cssDB = null;\n\t/** @type {Object} A list of available vendors (browsers) and their prefixes */\n\tvar vendorsDB = null;\n\tvar erasDB = null;\n\n\tfunction intersection(arr1, arr2) {\n\t\tvar result = [];\n\t\tvar smaller = arr1, larger = arr2;\n\t\tif (smaller.length > larger.length) {\n\t\t\tsmaller = arr2;\n\t\t\tlarger = arr1;\n\t\t}\n\t\tlarger.forEach(function(item) {\n\t\t\tif (~smaller.indexOf(item)) {\n\t\t\t\tresult.push(item);\n\t\t\t}\n\t\t});\n\t\treturn result;\n\t}\n\n\t/**\n\t * Parses raw Can I Use database for better lookups\n\t * @param  {String} data Raw database\n\t * @param  {Boolean} optimized Pass `true` if given `data` is already optimized\n\t * @return {Object}\n\t */\n\tfunction parseDB(data, optimized) {\n\t\tif (typeof data == 'string') {\n\t\t\tdata = JSON.parse(data);\n\t\t}\n\n\t\tif (!optimized) {\n\t\t\tdata = optimize(data);\n\t\t}\n\n\t\tvendorsDB = data.vendors;\n\t\tcssDB = data.css;\n\t\terasDB = data.era;\n\t}\n\n\t/**\n\t * Extract required data only from CIU database\n\t * @param  {Object} data Raw Can I Use database\n\t * @return {Object}      Optimized database\n\t */\n\tfunction optimize(data) {\n\t\tif (typeof data == 'string') {\n\t\t\tdata = JSON.parse(data);\n\t\t}\n\n\t\treturn {\n\t\t\tvendors: parseVendors(data),\n\t\t\tcss: parseCSS(data),\n\t\t\tera: parseEra(data)\n\t\t};\n\t}\n\n\t/**\n\t * Parses vendor data\n\t * @param  {Object} data\n\t * @return {Object}\n\t */\n\tfunction parseVendors(data) {\n\t\tvar out = {};\n\t\tObject.keys(data.agents).forEach(function(name) {\n\t\t\tvar agent = data.agents[name];\n\t\t\tout[name] = {\n\t\t\t\tprefix: agent.prefix,\n\t\t\t\tversions: agent.versions\n\t\t\t};\n\t\t});\n\t\treturn out;\n\t}\n\n\t/**\n\t * Parses CSS data from Can I Use raw database\n\t * @param  {Object} data\n\t * @return {Object}\n\t */\n\tfunction parseCSS(data) {\n\t\tvar out = {};\n\t\tvar cssCategories = data.cats.CSS;\n\t\tObject.keys(data.data).forEach(function(name) {\n\t\t\tvar section = data.data[name];\n\t\t\tif (name in cssSections) {\n\t\t\t\tcssSections[name].forEach(function(kw) {\n\t\t\t\t\tout[kw] = section.stats;\n\t\t\t\t});\n\t\t\t}\n\t\t});\n\n\t\treturn out;\n\t}\n\n\t/**\n\t * Parses era data from Can I Use raw database\n\t * @param  {Object} data\n\t * @return {Array}\n\t */\n\tfunction parseEra(data) {\n\t\t// some runtimes (like Mozilla Rhino) does not preserves\n\t\t// key order so we have to sort values manually\n\t\treturn Object.keys(data.eras).sort(function(a, b) {\n\t\t\treturn parseInt(a.substr(1)) - parseInt(b.substr(1));\n\t\t});\n\t}\n\n\t/**\n\t * Returs list of supported vendors, depending on user preferences\n\t * @return {Array}\n\t */\n\tfunction getVendorsList() {\n\t\tvar allVendors = Object.keys(vendorsDB);\n\t\tvar vendors = prefs.getArray('caniuse.vendors');\n\t\tif (!vendors || vendors[0] == 'all') {\n\t\t\treturn allVendors;\n\t\t}\n\n\t\treturn intersection(allVendors, vendors);\n\t}\n\n\t/**\n\t * Returns size of version slice as defined by era identifier\n\t * @return {Number}\n\t */\n\tfunction getVersionSlice() {\n\t\tvar era = prefs.get('caniuse.era');\n\t\tvar ix = erasDB.indexOf(era);\n\t\tif (!~ix) {\n\t\t\tix = erasDB.indexOf('e-2');\n\t\t}\n\n\t\treturn ix;\n\t}\n\n\t// try to load caniuse database\n\t// hide it from Require.JS parser\n\tvar db = null;\n\t(function(r) {\n\t\tif (typeof define === 'undefined' || !define.amd) {\n\t\t\ttry {\n\t\t\t\tdb = r('caniuse-db/data.json');\n\t\t\t} catch(e) {}\n\t\t}\n\t})(require);\n\n\tif (db) {\n\t\tparseDB(db);\n\t}\n\n\treturn {\n\t\tload: parseDB,\n\t\toptimize: optimize,\n\n\t\t/**\n\t\t * Resolves prefixes for given property\n\t\t * @param {String} property A property to resolve. It can start with `@` symbol\n\t\t * (CSS section, like `@keyframes`) or `:` (CSS value, like `flex`)\n\t\t * @return {Array} Array of resolved prefixes or <code>null</code>\n\t\t * if prefixes can't be resolved. Empty array means property has no vendor\n\t\t * prefixes\n\t\t */\n\t\tresolvePrefixes: function(property) {\n\t\t\tif (!prefs.get('caniuse.enabled') || !cssDB || !(property in cssDB)) {\n\t\t\t\treturn null;\n\t\t\t}\n\n\t\t\tvar prefixes = [];\n\t\t\tvar propStats = cssDB[property];\n\t\t\tvar versions = getVersionSlice();\n\n\t\t\tgetVendorsList().forEach(function(vendor) {\n\t\t\t\tvar vendorVesions = vendorsDB[vendor].versions.slice(versions);\n\t\t\t\tfor (var i = 0, v; i < vendorVesions.length; i++) {\n\t\t\t\t\tv = vendorVesions[i];\n\t\t\t\t\tif (!v) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\n\t\t\t\t\tif (~propStats[vendor][v].indexOf('x')) {\n\t\t\t\t\t\tprefixes.push(vendorsDB[vendor].prefix);\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t});\n\n\t\t\treturn utils.unique(prefixes).sort(function(a, b) {\n\t\t\t\treturn b.length - a.length;\n\t\t\t});\n\t\t}\n\t};\n});\n\n},{\"../utils/common\":\"utils\\\\common.js\",\"./preferences\":\"assets\\\\preferences.js\"}],\"assets\\\\elements.js\":[function(require,module,exports){\n/**\n * Module that contains factories for element types used by Emmet\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar factories = {};\n\tvar reAttrs = /([@\\!]?)([\\w\\-:]+)\\s*=\\s*(['\"])(.*?)\\3/g;\n\n\t// register resource references\n\tfunction commonFactory(value) {\n\t\treturn {data: value};\n\t}\n\n\tmodule = module || {};\n\tmodule.exports = {\n\t\t/**\n\t\t * Create new element factory\n\t\t * @param {String} name Element identifier\n\t\t * @param {Function} factory Function that produces element of specified \n\t\t * type. The object generated by this factory is automatically \n\t\t * augmented with <code>type</code> property pointing to element\n\t\t * <code>name</code>\n\t\t * @memberOf elements\n\t\t */\n\t\tadd: function(name, factory) {\n\t\t\tvar that = this;\n\t\t\tfactories[name] = function() {\n\t\t\t\tvar elem = factory.apply(that, arguments);\n\t\t\t\tif (elem)\n\t\t\t\t\telem.type = name;\n\t\t\t\t\n\t\t\t\treturn elem;\n\t\t\t};\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns factory for specified name\n\t\t * @param {String} name\n\t\t * @returns {Function}\n\t\t */\n\t\tget: function(name) {\n\t\t\treturn factories[name];\n\t\t},\n\t\t\n\t\t/**\n\t\t * Creates new element with specified type\n\t\t * @param {String} name\n\t\t * @returns {Object}\n\t\t */\n\t\tcreate: function(name) {\n\t\t\tvar args = [].slice.call(arguments, 1);\n\t\t\tvar factory = this.get(name);\n\t\t\treturn factory ? factory.apply(this, args) : null;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Check if passed element is of specified type\n\t\t * @param {Object} elem\n\t\t * @param {String} type\n\t\t * @returns {Boolean}\n\t\t */\n\t\tis: function(elem, type) {\n\t\t\treturn this.type(elem) === type;\n\t\t},\n\n\t\t/**\n\t\t * Returns type of element\n\t\t * @param  {Object} elem\n\t\t * @return {String}\n\t\t */\n\t\ttype: function(elem) {\n\t\t\treturn elem && elem.type;\n\t\t}\n\t};\n\t\n\t/**\n\t * Element factory\n\t * @param {String} elementName Name of output element\n\t * @param {String} attrs Attributes definition. You may also pass\n\t * <code>Array</code> where each contains object with <code>name</code> \n\t * and <code>value</code> properties, or <code>Object</code>\n\t * @param {Boolean} isEmpty Is expanded element should be empty\n\t */\n\tmodule.exports.add('element', function(elementName, attrs, isEmpty) {\n\t\tvar ret = {\n\t\t\tname: elementName,\n\t\t\tis_empty: !!isEmpty\n\t\t};\n\n\t\tif (attrs) {\n\t\t\tret.attributes = [];\n\t\t\tif (Array.isArray(attrs)) {\n\t\t\t\tret.attributes = attrs;\n\t\t\t} else if (typeof attrs === 'string') {\n\t\t\t\tvar m;\n\t\t\t\twhile ((m = reAttrs.exec(attrs))) {\n\t\t\t\t\tret.attributes.push({\n\t\t\t\t\t\tname: m[2],\n\t\t\t\t\t\tvalue: m[4],\n\t\t\t\t\t\tisDefault: m[1] == '@',\n\t\t\t\t\t\tisImplied: m[1] == '!'\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tret.attributes = Object.keys(attrs).map(function(name) {\n\t\t\t\t\treturn {\n\t\t\t\t\t\tname: name, \n\t\t\t\t\t\tvalue: attrs[name]\n\t\t\t\t\t};\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t\t\n\t\treturn ret;\n\t});\n\t\n\tmodule.exports.add('snippet', commonFactory);\n\tmodule.exports.add('reference', commonFactory);\n\tmodule.exports.add('empty', function() {\n\t\treturn {};\n\t});\n\t\n\treturn module.exports;\n});\n},{}],\"assets\\\\handlerList.js\":[function(require,module,exports){\n/**\n * Utility module that provides ordered storage of function handlers. \n * Many Emmet modules' functionality can be extended/overridden by custom\n * function. This modules provides unified storage of handler functions, their \n * management and execution\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar utils = require('../utils/common');\n\t\n\t/**\n\t * @type HandlerList\n\t * @constructor\n\t */\n\tfunction HandlerList() {\n\t\tthis._list = [];\n\t}\n\t\n\tHandlerList.prototype = {\n\t\t/**\n\t\t * Adds function handler\n\t\t * @param {Function} fn Handler\n\t\t * @param {Object} options Handler options. Possible values are:<br><br>\n\t\t * <b>order</b> : (<code>Number</code>) – order in handler list. Handlers\n\t\t * with higher order value will be executed earlier.\n\t\t */\n\t\tadd: function(fn, options) {\n\t\t\t// TODO hack for stable sort, remove after fixing `list()`\n\t\t\tvar order = this._list.length;\n\t\t\tif (options && 'order' in options) {\n\t\t\t\torder = options.order * 10000;\n\t\t\t}\n\t\t\tthis._list.push(utils.extend({}, options, {order: order, fn: fn}));\n\t\t},\n\t\t\n\t\t/**\n\t\t * Removes handler from list\n\t\t * @param {Function} fn\n\t\t */\n\t\tremove: function(fn) {\n\t\t\tvar item = utils.find(this._list, function(item) {\n\t\t\t\treturn item.fn === fn;\n\t\t\t});\n\t\t\tif (item) {\n\t\t\t\tthis._list.splice(this._list.indexOf(item), 1);\n\t\t\t}\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns ordered list of handlers. By default, handlers \n\t\t * with the same <code>order</code> option returned in reverse order, \n\t\t * i.e. the latter function was added into the handlers list, the higher \n\t\t * it will be in the returned array \n\t\t * @returns {Array}\n\t\t */\n\t\tlist: function() {\n\t\t\t// TODO make stable sort\n\t\t\treturn this._list.sort(function(a, b) {\n\t\t\t\treturn b.order - a.order;\n\t\t\t});\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns ordered list of handler functions\n\t\t * @returns {Array}\n\t\t */\n\t\tlistFn: function() {\n\t\t\treturn this.list().map(function(item) {\n\t\t\t\treturn item.fn;\n\t\t\t});\n\t\t},\n\t\t\n\t\t/**\n\t\t * Executes handler functions in their designated order. If function\n\t\t * returns <code>skipVal</code>, meaning that function was unable to \n\t\t * handle passed <code>args</code>, the next function will be executed\n\t\t * and so on.\n\t\t * @param {Object} skipValue If function returns this value, execute \n\t\t * next handler.\n\t\t * @param {Array} args Arguments to pass to handler function\n\t\t * @returns {Boolean} Whether any of registered handlers performed\n\t\t * successfully  \n\t\t */\n\t\texec: function(skipValue, args) {\n\t\t\targs = args || [];\n\t\t\tvar result = null;\n\t\t\tutils.find(this.list(), function(h) {\n\t\t\t\tresult = h.fn.apply(h, args);\n\t\t\t\tif (result !== skipValue) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t});\n\t\t\t\n\t\t\treturn result;\n\t\t}\n\t};\n\t\n\treturn {\n\t\t/**\n\t\t * Factory method that produces <code>HandlerList</code> instance\n\t\t * @returns {HandlerList}\n\t\t * @memberOf handlerList\n\t\t */\n\t\tcreate: function() {\n\t\t\treturn new HandlerList();\n\t\t}\n\t};\n});\n},{\"../utils/common\":\"utils\\\\common.js\"}],\"assets\\\\htmlMatcher.js\":[function(require,module,exports){\n/**\n * HTML matcher: takes string and searches for HTML tag pairs for given position \n * \n * Unlike “classic” matchers, it parses content from the specified \n * position, not from the start, so it may work even outside HTML documents\n * (for example, inside strings of programming languages like JavaScript, Python \n * etc.)\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar range = require('./range');\n\n\t// Regular Expressions for parsing tags and attributes\n\tvar reOpenTag = /^<([\\w\\:\\-]+)((?:\\s+[\\w\\-:]+(?:\\s*=\\s*(?:(?:\"[^\"]*\")|(?:'[^']*')|[^>\\s]+))?)*)\\s*(\\/?)>/;\n\tvar reCloseTag = /^<\\/([\\w\\:\\-]+)[^>]*>/;\n\n\tfunction openTag(i, match) {\n\t\treturn {\n\t\t\tname: match[1],\n\t\t\tselfClose: !!match[3],\n\t\t\t/** @type Range */\n\t\t\trange: range(i, match[0]),\n\t\t\ttype: 'open'\n\t\t};\n\t}\n\t\n\tfunction closeTag(i, match) {\n\t\treturn {\n\t\t\tname: match[1],\n\t\t\t/** @type Range */\n\t\t\trange: range(i, match[0]),\n\t\t\ttype: 'close'\n\t\t};\n\t}\n\t\n\tfunction comment(i, match) {\n\t\treturn {\n\t\t\t/** @type Range */\n\t\t\trange: range(i, typeof match == 'number' ? match - i : match[0]),\n\t\t\ttype: 'comment'\n\t\t};\n\t}\n\t\n\t/**\n\t * Creates new tag matcher session\n\t * @param {String} text\n\t */\n\tfunction createMatcher(text) {\n\t\tvar memo = {}, m;\n\t\treturn {\n\t\t\t/**\n\t\t\t * Test if given position matches opening tag\n\t\t\t * @param {Number} i\n\t\t\t * @returns {Object} Matched tag object\n\t\t\t */\n\t\t\topen: function(i) {\n\t\t\t\tvar m = this.matches(i);\n\t\t\t\treturn m && m.type == 'open' ? m : null;\n\t\t\t},\n\t\t\t\n\t\t\t/**\n\t\t\t * Test if given position matches closing tag\n\t\t\t * @param {Number} i\n\t\t\t * @returns {Object} Matched tag object\n\t\t\t */\n\t\t\tclose: function(i) {\n\t\t\t\tvar m = this.matches(i);\n\t\t\t\treturn m && m.type == 'close' ? m : null;\n\t\t\t},\n\t\t\t\n\t\t\t/**\n\t\t\t * Matches either opening or closing tag for given position\n\t\t\t * @param i\n\t\t\t * @returns\n\t\t\t */\n\t\t\tmatches: function(i) {\n\t\t\t\tvar key = 'p' + i;\n\t\t\t\t\n\t\t\t\tif (!(key in memo)) {\n\t\t\t\t\tmemo[key] = false;\n\t\t\t\t\tif (text.charAt(i) == '<') {\n\t\t\t\t\t\tvar substr = text.slice(i);\n\t\t\t\t\t\tif ((m = substr.match(reOpenTag))) {\n\t\t\t\t\t\t\tmemo[key] = openTag(i, m);\n\t\t\t\t\t\t} else if ((m = substr.match(reCloseTag))) {\n\t\t\t\t\t\t\tmemo[key] = closeTag(i, m);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\treturn memo[key];\n\t\t\t},\n\t\t\t\n\t\t\t/**\n\t\t\t * Returns original text\n\t\t\t * @returns {String}\n\t\t\t */\n\t\t\ttext: function() {\n\t\t\t\treturn text;\n\t\t\t},\n\n\t\t\tclean: function() {\n\t\t\t\tmemo = text = m = null;\n\t\t\t}\n\t\t};\n\t}\n\t\n\tfunction matches(text, pos, pattern) {\n\t\treturn text.substring(pos, pos + pattern.length) == pattern;\n\t}\n\t\n\t/**\n\t * Search for closing pair of opening tag\n\t * @param {Object} open Open tag instance\n\t * @param {Object} matcher Matcher instance\n\t */\n\tfunction findClosingPair(open, matcher) {\n\t\tvar stack = [], tag = null;\n\t\tvar text = matcher.text();\n\t\t\n\t\tfor (var pos = open.range.end, len = text.length; pos < len; pos++) {\n\t\t\tif (matches(text, pos, '<!--')) {\n\t\t\t\t// skip to end of comment\n\t\t\t\tfor (var j = pos; j < len; j++) {\n\t\t\t\t\tif (matches(text, j, '-->')) {\n\t\t\t\t\t\tpos = j + 3;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\tif ((tag = matcher.matches(pos))) {\n\t\t\t\tif (tag.type == 'open' && !tag.selfClose) {\n\t\t\t\t\tstack.push(tag.name);\n\t\t\t\t} else if (tag.type == 'close') {\n\t\t\t\t\tif (!stack.length) { // found valid pair?\n\t\t\t\t\t\treturn tag.name == open.name ? tag : null;\n\t\t\t\t\t}\n\t\t\t\t\t\n\t\t\t\t\t// check if current closing tag matches previously opened one\n\t\t\t\t\tif (stack[stack.length - 1] == tag.name) {\n\t\t\t\t\t\tstack.pop();\n\t\t\t\t\t} else {\n\t\t\t\t\t\tvar found = false;\n\t\t\t\t\t\twhile (stack.length && !found) {\n\t\t\t\t\t\t\tvar last = stack.pop();\n\t\t\t\t\t\t\tif (last == tag.name) {\n\t\t\t\t\t\t\t\tfound = true;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\t\n\t\t\t\t\t\tif (!stack.length && !found) {\n\t\t\t\t\t\t\treturn tag.name == open.name ? tag : null;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tpos = tag.range.end - 1;\n\t\t\t}\n\t\t}\n\t}\n\t\n\treturn {\n\t\t/**\n\t\t * Main function: search for tag pair in <code>text</code> for given \n\t\t * position\n\t\t * @memberOf htmlMatcher\n\t\t * @param {String} text \n\t\t * @param {Number} pos\n\t\t * @returns {Object}\n\t\t */\n\t\tfind: function(text, pos) {\n\t\t\tvar matcher = createMatcher(text); \n\t\t\tvar open = null, close = null;\n\t\t\tvar j, jl;\n\t\t\t\n\t\t\tfor (var i = pos; i >= 0; i--) {\n\t\t\t\tif ((open = matcher.open(i))) {\n\t\t\t\t\t// found opening tag\n\t\t\t\t\tif (open.selfClose) {\n\t\t\t\t\t\tif (open.range.cmp(pos, 'lt', 'gt')) {\n\t\t\t\t\t\t\t// inside self-closing tag, found match\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t\t\n\t\t\t\t\t\t// outside self-closing tag, continue\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\t\n\t\t\t\t\tclose = findClosingPair(open, matcher);\n\t\t\t\t\tif (close) {\n\t\t\t\t\t\t// found closing tag.\n\t\t\t\t\t\tvar r = range.create2(open.range.start, close.range.end);\n\t\t\t\t\t\tif (r.contains(pos)) {\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t} else if (open.range.contains(pos)) {\n\t\t\t\t\t\t// we inside empty HTML tag like <br>\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t\t\n\t\t\t\t\topen = null;\n\t\t\t\t} else if (matches(text, i, '-->')) {\n\t\t\t\t\t// skip back to comment start\n\t\t\t\t\tfor (j = i - 1; j >= 0; j--) {\n\t\t\t\t\t\tif (matches(text, j, '-->')) {\n\t\t\t\t\t\t\t// found another comment end, do nothing\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t} else if (matches(text, j, '<!--')) {\n\t\t\t\t\t\t\ti = j;\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} else if (matches(text, i, '<!--')) {\n\t\t\t\t\t// we're inside comment, match it\n\t\t\t\t\tfor (j = i + 4, jl = text.length; j < jl; j++) {\n\t\t\t\t\t\tif (matches(text, j, '-->')) {\n\t\t\t\t\t\t\tj += 3;\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\t\n\t\t\t\t\topen = comment(i, j);\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\tmatcher.clean();\n\n\t\t\tif (open) {\n\t\t\t\tvar outerRange = null;\n\t\t\t\tvar innerRange = null;\n\t\t\t\t\n\t\t\t\tif (close) {\n\t\t\t\t\touterRange = range.create2(open.range.start, close.range.end);\n\t\t\t\t\tinnerRange = range.create2(open.range.end, close.range.start);\n\t\t\t\t} else {\n\t\t\t\t\touterRange = innerRange = range.create2(open.range.start, open.range.end);\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tif (open.type == 'comment') {\n\t\t\t\t\t// adjust positions of inner range for comment\n\t\t\t\t\tvar _c = outerRange.substring(text);\n\t\t\t\t\tinnerRange.start += _c.length - _c.replace(/^<\\!--\\s*/, '').length;\n\t\t\t\t\tinnerRange.end -= _c.length - _c.replace(/\\s*-->$/, '').length;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\treturn {\n\t\t\t\t\topen: open,\n\t\t\t\t\tclose: close,\n\t\t\t\t\ttype: open.type == 'comment' ? 'comment' : 'tag',\n\t\t\t\t\tinnerRange: innerRange,\n\t\t\t\t\tinnerContent: function() {\n\t\t\t\t\t\treturn this.innerRange.substring(text);\n\t\t\t\t\t},\n\t\t\t\t\touterRange: outerRange,\n\t\t\t\t\touterContent: function() {\n\t\t\t\t\t\treturn this.outerRange.substring(text);\n\t\t\t\t\t},\n\t\t\t\t\trange: !innerRange.length() || !innerRange.cmp(pos, 'lte', 'gte') ? outerRange : innerRange,\n\t\t\t\t\tcontent: function() {\n\t\t\t\t\t\treturn this.range.substring(text);\n\t\t\t\t\t},\n\t\t\t\t\tsource: text\n\t\t\t\t};\n\t\t\t}\n\t\t},\n\t\t\n\t\t/**\n\t\t * The same as <code>find()</code> method, but restricts matched result \n\t\t * to <code>tag</code> type\n\t\t * @param {String} text \n\t\t * @param {Number} pos\n\t\t * @returns {Object}\n\t\t */\n\t\ttag: function(text, pos) {\n\t\t\tvar result = this.find(text, pos);\n\t\t\tif (result && result.type == 'tag') {\n\t\t\t\treturn result;\n\t\t\t}\n\t\t}\n\t};\n});\n},{\"./range\":\"assets\\\\range.js\"}],\"assets\\\\logger.js\":[function(require,module,exports){\n/**\n * Simple logger for Emmet\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\treturn {\n\t\tlog: function() {\n\t\t\tif (typeof console != 'undefined' && console.log) {\n\t\t\t\tconsole.log.apply(console, arguments);\n\t\t\t}\n\t\t}\n\t}\n})\n},{}],\"assets\\\\preferences.js\":[function(require,module,exports){\n/**\n * Common module's preferences storage. This module \n * provides general storage for all module preferences, their description and\n * default values.<br><br>\n * \n * This module can also be used to list all available properties to create \n * UI for updating properties\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar utils = require('../utils/common');\n\n\tvar preferences = {};\n\tvar defaults = {};\n\tvar _dbgDefaults = null;\n\tvar _dbgPreferences = null;\n\n\tfunction toBoolean(val) {\n\t\tif (typeof val === 'string') {\n\t\t\tval = val.toLowerCase();\n\t\t\treturn val == 'yes' || val == 'true' || val == '1';\n\t\t}\n\n\t\treturn !!val;\n\t}\n\t\n\tfunction isValueObj(obj) {\n\t\treturn typeof obj === 'object'\n\t\t\t&& !Array.isArray(obj) \n\t\t\t&& 'value' in obj \n\t\t\t&& Object.keys(obj).length < 3;\n\t}\n\t\n\treturn {\n\t\t/**\n\t\t * Creates new preference item with default value\n\t\t * @param {String} name Preference name. You can also pass object\n\t\t * with many options\n\t\t * @param {Object} value Preference default value\n\t\t * @param {String} description Item textual description\n\t\t * @memberOf preferences\n\t\t */\n\t\tdefine: function(name, value, description) {\n\t\t\tvar prefs = name;\n\t\t\tif (typeof name === 'string') {\n\t\t\t\tprefs = {};\n\t\t\t\tprefs[name] = {\n\t\t\t\t\tvalue: value,\n\t\t\t\t\tdescription: description\n\t\t\t\t};\n\t\t\t}\n\t\t\t\n\t\t\tObject.keys(prefs).forEach(function(k) {\n\t\t\t\tvar v = prefs[k];\n\t\t\t\tdefaults[k] = isValueObj(v) ? v : {value: v};\n\t\t\t});\n\t\t},\n\t\t\n\t\t/**\n\t\t * Updates preference item value. Preference value should be defined\n\t\t * first with <code>define</code> method.\n\t\t * @param {String} name Preference name. You can also pass object\n\t\t * with many options\n\t\t * @param {Object} value Preference default value\n\t\t * @memberOf preferences\n\t\t */\n\t\tset: function(name, value) {\n\t\t\tvar prefs = name;\n\t\t\tif (typeof name === 'string') {\n\t\t\t\tprefs = {};\n\t\t\t\tprefs[name] = value;\n\t\t\t}\n\t\t\t\n\t\t\tObject.keys(prefs).forEach(function(k) {\n\t\t\t\tvar v = prefs[k];\n\t\t\t\tif (!(k in defaults)) {\n\t\t\t\t\tthrow new Error('Property \"' + k + '\" is not defined. You should define it first with `define` method of current module');\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\t// do not set value if it equals to default value\n\t\t\t\tif (v !== defaults[k].value) {\n\t\t\t\t\t// make sure we have value of correct type\n\t\t\t\t\tswitch (typeof defaults[k].value) {\n\t\t\t\t\t\tcase 'boolean':\n\t\t\t\t\t\t\tv = toBoolean(v);\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\tcase 'number':\n\t\t\t\t\t\t\tv = parseInt(v + '', 10) || 0;\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\tdefault: // convert to string\n\t\t\t\t\t\t\tif (v !== null) {\n\t\t\t\t\t\t\t\tv += '';\n\t\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\tpreferences[k] = v;\n\t\t\t\t} else if (k in preferences) {\n\t\t\t\t\tdelete preferences[k];\n\t\t\t\t}\n\t\t\t});\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns preference value\n\t\t * @param {String} name\n\t\t * @returns {String} Returns <code>undefined</code> if preference is \n\t\t * not defined\n\t\t */\n\t\tget: function(name) {\n\t\t\tif (name in preferences) {\n\t\t\t\treturn preferences[name];\n\t\t\t}\n\t\t\t\n\t\t\tif (name in defaults) {\n\t\t\t\treturn defaults[name].value;\n\t\t\t}\n\t\t\t\n\t\t\treturn void 0;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns comma-separated preference value as array of values\n\t\t * @param {String} name\n\t\t * @returns {Array} Returns <code>undefined</code> if preference is \n\t\t * not defined, <code>null</code> if string cannot be converted to array\n\t\t */\n\t\tgetArray: function(name) {\n\t\t\tvar val = this.get(name);\n\t\t\tif (typeof val === 'undefined' || val === null || val === '')  {\n\t\t\t\treturn null;\n\t\t\t}\n\n\t\t\tval = val.split(',').map(utils.trim);\n\t\t\tif (!val.length) {\n\t\t\t\treturn null;\n\t\t\t}\n\t\t\t\n\t\t\treturn val;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns comma and colon-separated preference value as dictionary\n\t\t * @param {String} name\n\t\t * @returns {Object}\n\t\t */\n\t\tgetDict: function(name) {\n\t\t\tvar result = {};\n\t\t\tthis.getArray(name).forEach(function(val) {\n\t\t\t\tvar parts = val.split(':');\n\t\t\t\tresult[parts[0]] = parts[1];\n\t\t\t});\n\t\t\t\n\t\t\treturn result;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns description of preference item\n\t\t * @param {String} name Preference name\n\t\t * @returns {Object}\n\t\t */\n\t\tdescription: function(name) {\n\t\t\treturn name in defaults ? defaults[name].description : void 0;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Completely removes specified preference(s)\n\t\t * @param {String} name Preference name (or array of names)\n\t\t */\n\t\tremove: function(name) {\n\t\t\tif (!Array.isArray(name)) {\n\t\t\t\tname = [name];\n\t\t\t}\n\t\t\t\n\t\t\tname.forEach(function(key) {\n\t\t\t\tif (key in preferences) {\n\t\t\t\t\tdelete preferences[key];\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tif (key in defaults) {\n\t\t\t\t\tdelete defaults[key];\n\t\t\t\t}\n\t\t\t});\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns sorted list of all available properties\n\t\t * @returns {Array}\n\t\t */\n\t\tlist: function() {\n\t\t\treturn Object.keys(defaults).sort().map(function(key) {\n\t\t\t\treturn {\n\t\t\t\t\tname: key,\n\t\t\t\t\tvalue: this.get(key),\n\t\t\t\t\ttype: typeof defaults[key].value,\n\t\t\t\t\tdescription: defaults[key].description\n\t\t\t\t};\n\t\t\t}, this);\n\t\t},\n\t\t\n\t\t/**\n\t\t * Loads user-defined preferences from JSON\n\t\t * @param {Object} json\n\t\t * @returns\n\t\t */\n\t\tload: function(json) {\n\t\t\tObject.keys(json).forEach(function(key) {\n\t\t\t\tthis.set(key, json[key]);\n\t\t\t}, this);\n\t\t},\n\n\t\t/**\n\t\t * Returns hash of user-modified preferences\n\t\t * @returns {Object}\n\t\t */\n\t\texportModified: function() {\n\t\t\treturn utils.extend({}, preferences);\n\t\t},\n\t\t\n\t\t/**\n\t\t * Reset to defaults\n\t\t * @returns\n\t\t */\n\t\treset: function() {\n\t\t\tpreferences = {};\n\t\t},\n\t\t\n\t\t/**\n\t\t * For unit testing: use empty storage\n\t\t */\n\t\t_startTest: function() {\n\t\t\t_dbgDefaults = defaults;\n\t\t\t_dbgPreferences = preferences;\n\t\t\tdefaults = {};\n\t\t\tpreferences = {};\n\t\t},\n\t\t\n\t\t/**\n\t\t * For unit testing: restore original storage\n\t\t */\n\t\t_stopTest: function() {\n\t\t\tdefaults = _dbgDefaults;\n\t\t\tpreferences = _dbgPreferences;\n\t\t}\n\t};\n});\n},{\"../utils/common\":\"utils\\\\common.js\"}],\"assets\\\\profile.js\":[function(require,module,exports){\n/**\n * Output profile module.\n * Profile defines how XHTML output data should look like\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar utils = require('../utils/common');\n\tvar resources = require('./resources');\n\tvar prefs = require('./preferences');\n\n\tprefs.define('profile.allowCompactBoolean', true, \n\t\t'This option can be used to globally disable compact form of boolean ' + \n\t\t'attribues (attributes where name and value are equal). With compact' +\n\t\t'form enabled, HTML tags can be outputted as <code>&lt;div contenteditable&gt;</code> ' +\n\t\t'instead of <code>&lt;div contenteditable=\"contenteditable\"&gt;</code>');\n\n\tprefs.define('profile.booleanAttributes', '^contenteditable|seamless|async|autofocus|autoplay|checked|controls|defer|disabled|formnovalidate|hidden|ismap|loop|multiple|muted|novalidate|readonly|required|reversed|selected|typemustmatch$', \n\t\t'A regular expression for attributes that should be boolean by default.' + \n\t\t'If attribute name matches this expression, you don’t have to write dot ' +\n\t\t'after attribute name in Emmet abbreviation to mark it as boolean.');\n\n\tvar profiles = {};\n\t\n\tvar defaultProfile = {\n\t\ttag_case: 'asis',\n\t\tattr_case: 'asis',\n\t\tattr_quotes: 'double',\n\t\t\n\t\t// Each tag on new line\n\t\ttag_nl: 'decide',\n\t\t\n\t\t// With tag_nl === true, defines if leaf node (e.g. node with no children)\n\t\t// should have formatted line breaks\n\t\ttag_nl_leaf: false,\n\t\t\n\t\tplace_cursor: true,\n\t\t\n\t\t// Indent tags\n\t\tindent: true,\n\t\t\n\t\t// How many inline elements should be to force line break \n\t\t// (set to 0 to disable)\n\t\tinline_break: 3,\n\n\t\t// Produce compact notation of boolean attribues:\n\t\t// attributes where name and value are equal.\n\t\t// With this option enabled, HTML filter will\n\t\t// produce <div contenteditable> instead of <div contenteditable=\"contenteditable\">\n\t\tcompact_bool: false,\n\t\t\n\t\t// Use self-closing style for writing empty elements, e.g. <br /> or <br>\n\t\tself_closing_tag: 'xhtml',\n\t\t\n\t\t// Profile-level output filters, re-defines syntax filters \n\t\tfilters: '',\n\t\t\n\t\t// Additional filters applied to abbreviation.\n\t\t// Unlike \"filters\", this preference doesn't override default filters\n\t\t// but add the instead every time given profile is chosen\n\t\textraFilters: ''\n\t};\n\t\n\t/**\n\t * @constructor\n\t * @type OutputProfile\n\t * @param {Object} options\n\t */\n\tfunction OutputProfile(options) {\n\t\tutils.extend(this, defaultProfile, options);\n\t}\n\t\n\tOutputProfile.prototype = {\n\t\t/**\n\t\t * Transforms tag name case depending on current profile settings\n\t\t * @param {String} name String to transform\n\t\t * @returns {String}\n\t\t */\n\t\ttagName: function(name) {\n\t\t\treturn stringCase(name, this.tag_case);\n\t\t},\n\t\t\n\t\t/**\n\t\t * Transforms attribute name case depending on current profile settings \n\t\t * @param {String} name String to transform\n\t\t * @returns {String}\n\t\t */\n\t\tattributeName: function(name) {\n\t\t\treturn stringCase(name, this.attr_case);\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns quote character for current profile\n\t\t * @returns {String}\n\t\t */\n\t\tattributeQuote: function() {\n\t\t\treturn this.attr_quotes == 'single' ? \"'\" : '\"';\n\t\t},\n\n\t\t/**\n\t\t * Returns self-closing tag symbol for current profile\n\t\t * @returns {String}\n\t\t */\n\t\tselfClosing: function() {\n\t\t\tif (this.self_closing_tag == 'xhtml')\n\t\t\t\treturn ' /';\n\t\t\t\n\t\t\tif (this.self_closing_tag === true)\n\t\t\t\treturn '/';\n\t\t\t\n\t\t\treturn '';\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns cursor token based on current profile settings\n\t\t * @returns {String}\n\t\t */\n\t\tcursor: function() {\n\t\t\treturn this.place_cursor ? utils.getCaretPlaceholder() : '';\n\t\t},\n\n\t\t/**\n\t\t * Check if attribute with given name is boolean,\n\t\t * e.g. written as `contenteditable` instead of \n\t\t * `contenteditable=\"contenteditable\"`\n\t\t * @param  {String}  name Attribute name\n\t\t * @return {Boolean}\n\t\t */\n\t\tisBoolean: function(name, value) {\n\t\t\tif (name == value) {\n\t\t\t\treturn true;\n\t\t\t}\n\n\t\t\tvar boolAttrs = prefs.get('profile.booleanAttributes');\n\t\t\tif (!value && boolAttrs) {\n\t\t\t\tboolAttrs = new RegExp(boolAttrs, 'i');\n\t\t\t\treturn boolAttrs.test(name);\n\t\t\t}\n\n\t\t\treturn false;\n\t\t},\n\n\t\t/**\n\t\t * Check if compact boolean attribute record is \n\t\t * allowed for current profile\n\t\t * @return {Boolean}\n\t\t */\n\t\tallowCompactBoolean: function() {\n\t\t\treturn this.compact_bool && prefs.get('profile.allowCompactBoolean');\n\t\t}\n\t};\n\t\n\t/**\n\t * Helper function that converts string case depending on \n\t * <code>caseValue</code> \n\t * @param {String} str String to transform\n\t * @param {String} caseValue Case value: can be <i>lower</i>, \n\t * <i>upper</i> and <i>leave</i>\n\t * @returns {String}\n\t */\n\tfunction stringCase(str, caseValue) {\n\t\tswitch (String(caseValue || '').toLowerCase()) {\n\t\t\tcase 'lower':\n\t\t\t\treturn str.toLowerCase();\n\t\t\tcase 'upper':\n\t\t\t\treturn str.toUpperCase();\n\t\t}\n\t\t\n\t\treturn str;\n\t}\n\t\n\t/**\n\t * Creates new output profile\n\t * @param {String} name Profile name\n\t * @param {Object} options Profile options\n\t */\n\tfunction createProfile(name, options) {\n\t\treturn profiles[name.toLowerCase()] = new OutputProfile(options);\n\t}\n\t\n\tfunction createDefaultProfiles() {\n\t\tcreateProfile('xhtml');\n\t\tcreateProfile('html', {self_closing_tag: false, compact_bool: true});\n\t\tcreateProfile('xml', {self_closing_tag: true, tag_nl: true});\n\t\tcreateProfile('plain', {tag_nl: false, indent: false, place_cursor: false});\n\t\tcreateProfile('line', {tag_nl: false, indent: false, extraFilters: 's'});\n\t\tcreateProfile('css', {tag_nl: true});\n\t\tcreateProfile('css_line', {tag_nl: false});\n\t}\n\t\n\tcreateDefaultProfiles();\n\t\n\treturn  {\n\t\t/**\n\t\t * Creates new output profile and adds it into internal dictionary\n\t\t * @param {String} name Profile name\n\t\t * @param {Object} options Profile options\n\t\t * @memberOf emmet.profile\n\t\t * @returns {Object} New profile\n\t\t */\n\t\tcreate: function(name, options) {\n\t\t\tif (arguments.length == 2)\n\t\t\t\treturn createProfile(name, options);\n\t\t\telse\n\t\t\t\t// create profile object only\n\t\t\t\treturn new OutputProfile(utils.defaults(name || {}, defaultProfile));\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns profile by its name. If profile wasn't found, returns\n\t\t * 'plain' profile\n\t\t * @param {String} name Profile name. Might be profile itself\n\t\t * @param {String} syntax. Optional. Current editor syntax. If defined,\n\t\t * profile is searched in resources first, then in predefined profiles\n\t\t * @returns {Object}\n\t\t */\n\t\tget: function(name, syntax) {\n\t\t\tif (!name && syntax) {\n\t\t\t\t// search in user resources first\n\t\t\t\tvar profile = resources.findItem(syntax, 'profile');\n\t\t\t\tif (profile) {\n\t\t\t\t\tname = profile;\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\tif (!name) {\n\t\t\t\treturn profiles.plain;\n\t\t\t}\n\t\t\t\n\t\t\tif (name instanceof OutputProfile) {\n\t\t\t\treturn name;\n\t\t\t}\n\t\t\t\n\t\t\tif (typeof name === 'string' && name.toLowerCase() in profiles) {\n\t\t\t\treturn profiles[name.toLowerCase()];\n\t\t\t}\n\t\t\t\n\t\t\treturn this.create(name);\n\t\t},\n\t\t\n\t\t/**\n\t\t * Deletes profile with specified name\n\t\t * @param {String} name Profile name\n\t\t */\n\t\tremove: function(name) {\n\t\t\tname = (name || '').toLowerCase();\n\t\t\tif (name in profiles)\n\t\t\t\tdelete profiles[name];\n\t\t},\n\t\t\n\t\t/**\n\t\t * Resets all user-defined profiles\n\t\t */\n\t\treset: function() {\n\t\t\tprofiles = {};\n\t\t\tcreateDefaultProfiles();\n\t\t},\n\t\t\n\t\t/**\n\t\t * Helper function that converts string case depending on \n\t\t * <code>caseValue</code> \n\t\t * @param {String} str String to transform\n\t\t * @param {String} caseValue Case value: can be <i>lower</i>, \n\t\t * <i>upper</i> and <i>leave</i>\n\t\t * @returns {String}\n\t\t */\n\t\tstringCase: stringCase\n\t};\n});\n\n},{\"../utils/common\":\"utils\\\\common.js\",\"./preferences\":\"assets\\\\preferences.js\",\"./resources\":\"assets\\\\resources.js\"}],\"assets\\\\range.js\":[function(require,module,exports){\n/**\n * Helper module to work with ranges\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tfunction cmp(a, b, op) {\n\t\tswitch (op) {\n\t\t\tcase 'eq':\n\t\t\tcase '==':\n\t\t\t\treturn a === b;\n\t\t\tcase 'lt':\n\t\t\tcase '<':\n\t\t\t\treturn a < b;\n\t\t\tcase 'lte':\n\t\t\tcase '<=':\n\t\t\t\treturn a <= b;\n\t\t\tcase 'gt':\n\t\t\tcase '>':\n\t\t\t\treturn a > b;\n\t\t\tcase 'gte':\n\t\t\tcase '>=':\n\t\t\t\treturn a >= b;\n\t\t}\n\t}\n\t\n\t\n\t/**\n\t * @type Range\n\t * @constructor\n\t * @param {Object} start\n\t * @param {Number} len\n\t */\n\tfunction Range(start, len) {\n\t\tif (typeof start === 'object' && 'start' in start) {\n\t\t\t// create range from object stub\n\t\t\tthis.start = Math.min(start.start, start.end);\n\t\t\tthis.end = Math.max(start.start, start.end);\n\t\t} else if (Array.isArray(start)) {\n\t\t\tthis.start = start[0];\n\t\t\tthis.end = start[1];\n\t\t} else {\n\t\t\tlen = typeof len === 'string' ? len.length : +len;\n\t\t\tthis.start = start;\n\t\t\tthis.end = start + len;\n\t\t}\n\t}\n\t\n\tRange.prototype = {\n\t\tlength: function() {\n\t\t\treturn Math.abs(this.end - this.start);\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns <code>true</code> if passed range is equals to current one\n\t\t * @param {Range} range\n\t\t * @returns {Boolean}\n\t\t */\n\t\tequal: function(range) {\n\t\t\treturn this.cmp(range, 'eq', 'eq');\n//\t\t\treturn this.start === range.start && this.end === range.end;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Shifts indexes position with passed <code>delta</code>\n\t\t * @param {Number} delta\n\t\t * @returns {Range} range itself\n\t\t */\n\t\tshift: function(delta) {\n\t\t\tthis.start += delta;\n\t\t\tthis.end += delta;\n\t\t\treturn this;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Check if two ranges are overlapped\n\t\t * @param {Range} range\n\t\t * @returns {Boolean}\n\t\t */\n\t\toverlap: function(range) {\n\t\t\treturn range.start <= this.end && range.end >= this.start;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Finds intersection of two ranges\n\t\t * @param {Range} range\n\t\t * @returns {Range} <code>null</code> if ranges does not overlap\n\t\t */\n\t\tintersection: function(range) {\n\t\t\tif (this.overlap(range)) {\n\t\t\t\tvar start = Math.max(range.start, this.start);\n\t\t\t\tvar end = Math.min(range.end, this.end);\n\t\t\t\treturn new Range(start, end - start);\n\t\t\t}\n\t\t\t\n\t\t\treturn null;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns the union of the thow ranges.\n\t\t * @param {Range} range\n\t\t * @returns {Range} <code>null</code> if ranges are not overlapped\n\t\t */\n\t\tunion: function(range) {\n\t\t\tif (this.overlap(range)) {\n\t\t\t\tvar start = Math.min(range.start, this.start);\n\t\t\t\tvar end = Math.max(range.end, this.end);\n\t\t\t\treturn new Range(start, end - start);\n\t\t\t}\n\t\t\t\n\t\t\treturn null;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns a Boolean value that indicates whether a specified position \n\t\t * is in a given range.\n\t\t * @param {Number} loc\n\t\t */\n\t\tinside: function(loc) {\n\t\t\treturn this.cmp(loc, 'lte', 'gt');\n//\t\t\treturn this.start <= loc && this.end > loc;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns a Boolean value that indicates whether a specified position \n\t\t * is in a given range, but not equals bounds.\n\t\t * @param {Number} loc\n\t\t */\n\t\tcontains: function(loc) {\n\t\t\treturn this.cmp(loc, 'lt', 'gt');\n\t\t},\n\t\t\n\t\t/**\n\t\t * Check if current range completely includes specified one\n\t\t * @param {Range} r\n\t\t * @returns {Boolean} \n\t\t */\n\t\tinclude: function(r) {\n\t\t\treturn this.cmp(r, 'lte', 'gte');\n//\t\t\treturn this.start <= r.start && this.end >= r.end;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Low-level comparision method\n\t\t * @param {Number} loc\n\t\t * @param {String} left Left comparison operator\n\t\t * @param {String} right Right comaprison operator\n\t\t */\n\t\tcmp: function(loc, left, right) {\n\t\t\tvar a, b;\n\t\t\tif (loc instanceof Range) {\n\t\t\t\ta = loc.start;\n\t\t\t\tb = loc.end;\n\t\t\t} else {\n\t\t\t\ta = b = loc;\n\t\t\t}\n\t\t\t\n\t\t\treturn cmp(this.start, a, left || '<=') && cmp(this.end, b, right || '>');\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns substring of specified <code>str</code> for current range\n\t\t * @param {String} str\n\t\t * @returns {String}\n\t\t */\n\t\tsubstring: function(str) {\n\t\t\treturn this.length() > 0 \n\t\t\t\t? str.substring(this.start, this.end) \n\t\t\t\t: '';\n\t\t},\n\t\t\n\t\t/**\n\t\t * Creates copy of current range\n\t\t * @returns {Range}\n\t\t */\n\t\tclone: function() {\n\t\t\treturn new Range(this.start, this.length());\n\t\t},\n\t\t\n\t\t/**\n\t\t * @returns {Array}\n\t\t */\n\t\ttoArray: function() {\n\t\t\treturn [this.start, this.end];\n\t\t},\n\t\t\n\t\ttoString: function() {\n\t\t\treturn this.valueOf();\n\t\t},\n\n\t\tvalueOf: function() {\n\t\t\treturn '{' + this.start + ', ' + this.length() + '}';\n\t\t}\n\t};\n\n\t/**\n\t * Creates new range object instance\n\t * @param {Object} start Range start or array with 'start' and 'end'\n\t * as two first indexes or object with 'start' and 'end' properties\n\t * @param {Number} len Range length or string to produce range from\n\t * @returns {Range}\n\t */\n\tmodule.exports = function(start, len) {\n\t\tif (typeof start == 'undefined' || start === null)\n\t\t\treturn null;\n\t\t\t\n\t\tif (start instanceof Range)\n\t\t\treturn start;\n\t\t\n\t\tif (typeof start == 'object' && 'start' in start && 'end' in start) {\n\t\t\tlen = start.end - start.start;\n\t\t\tstart = start.start;\n\t\t}\n\t\t\t\n\t\treturn new Range(start, len);\n\t};\n\n\tmodule.exports.create = module.exports;\n\n\tmodule.exports.isRange = function(val) {\n\t\treturn val instanceof Range;\n\t};\n\n\t/**\n\t * <code>Range</code> object factory, the same as <code>this.create()</code>\n\t * but last argument represents end of range, not length\n\t * @returns {Range}\n\t */\n\tmodule.exports.create2 = function(start, end) {\n\t\tif (typeof start === 'number' && typeof end === 'number') {\n\t\t\tend -= start;\n\t\t}\n\t\t\n\t\treturn this.create(start, end);\n\t};\n\n\t/**\n\t * Helper function that sorts ranges in order as they\n\t * appear in text\n\t * @param  {Array} ranges\n\t * @return {Array}\n\t */\n\tmodule.exports.sort = function(ranges, reverse) {\n\t\tranges = ranges.sort(function(a, b) {\n\t\t\tif (a.start === b.start) {\n\t\t\t\treturn b.end - a.end;\n\t\t\t}\n\n\t\t\treturn a.start - b.start;\n\t\t});\n\n\t\treverse && ranges.reverse();\n\t\treturn ranges;\n\t};\n\n\treturn module.exports;\n});\n},{}],\"assets\\\\resources.js\":[function(require,module,exports){\n/**\n * Parsed resources (snippets, abbreviations, variables, etc.) for Emmet.\n * Contains convenient method to get access for snippets with respect of\n * inheritance. Also provides ability to store data in different vocabularies\n * ('system' and 'user') for fast and safe resource update\n * @author Sergey Chikuyonok (serge.che@gmail.com)\n * @link http://chikuyonok.ru\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar handlerList = require('./handlerList');\n\tvar utils = require('../utils/common');\n\tvar elements = require('./elements');\n\tvar logger = require('../assets/logger');\n\tvar stringScore = require('../vendor/stringScore');\n\tvar cssResolver = require('../resolver/css');\n\n\tvar VOC_SYSTEM = 'system';\n\tvar VOC_USER = 'user';\n\n\tvar cache = {};\n\n\t/** Regular expression for XML tag matching */\n\tvar reTag = /^<(\\w+\\:?[\\w\\-]*)((?:\\s+[@\\!]?[\\w\\:\\-]+\\s*=\\s*(['\"]).*?\\3)*)\\s*(\\/?)>/;\n\n\tvar systemSettings = {};\n\tvar userSettings = {};\n\n\t/** @type HandlerList List of registered abbreviation resolvers */\n\tvar resolvers = handlerList.create();\n\n\tfunction each(obj, fn) {\n\t\tif (!obj) {\n\t\t\treturn;\n\t\t}\n\n\t\tObject.keys(obj).forEach(function(key) {\n\t\t\tfn(obj[key], key);\n\t\t});\n\t}\n\n\t/**\n\t * Normalizes caret plceholder in passed text: replaces | character with\n\t * default caret placeholder\n\t * @param {String} text\n\t * @returns {String}\n\t */\n\tfunction normalizeCaretPlaceholder(text) {\n\t\treturn utils.replaceUnescapedSymbol(text, '|', utils.getCaretPlaceholder());\n\t}\n\n\tfunction parseItem(name, value, type) {\n\t\tvalue = normalizeCaretPlaceholder(value);\n\n\t\tif (type == 'snippets') {\n\t\t\treturn elements.create('snippet', value);\n\t\t}\n\n\t\tif (type == 'abbreviations') {\n\t\t\treturn parseAbbreviation(name, value);\n\t\t}\n\t}\n\n\t/**\n\t * Parses single abbreviation\n\t * @param {String} key Abbreviation name\n\t * @param {String} value Abbreviation value\n\t * @return {Object}\n\t */\n\tfunction parseAbbreviation(key, value) {\n\t\tkey = utils.trim(key);\n\t\tvar m;\n\t\tif ((m = reTag.exec(value))) {\n\t\t\treturn elements.create('element', m[1], m[2], m[4] == '/');\n\t\t} else {\n\t\t\t// assume it's reference to another abbreviation\n\t\t\treturn elements.create('reference', value);\n\t\t}\n\t}\n\n\t/**\n\t * Normalizes snippet key name for better fuzzy search\n\t * @param {String} str\n\t * @returns {String}\n\t */\n\tfunction normalizeName(str) {\n\t\treturn str.replace(/:$/, '').replace(/:/g, '-');\n\t}\n\n\tfunction expandSnippetsDefinition(snippets) {\n\t\tvar out = {};\n\t\teach(snippets, function(val, key) {\n\t\t\tvar items = key.split('|');\n\t\t\t// do not use iterators for better performance\n\t\t\tfor (var i = items.length - 1; i >= 0; i--) {\n\t\t\t\tout[items[i]] = val;\n\t\t\t}\n\t\t});\n\n\t\treturn out;\n\t}\n\n\tutils.extend(exports, {\n\t\t/**\n\t\t * Sets new unparsed data for specified settings vocabulary\n\t\t * @param {Object} data\n\t\t * @param {String} type Vocabulary type ('system' or 'user')\n\t\t * @memberOf resources\n\t\t */\n\t\tsetVocabulary: function(data, type) {\n\t\t\tcache = {};\n\n\t\t\t// sections like \"snippets\" and \"abbreviations\" could have\n\t\t\t// definitions like `\"f|fs\": \"fieldset\"` which is the same as distinct\n\t\t\t// \"f\" and \"fs\" keys both equals to \"fieldset\".\n\t\t\t// We should parse these definitions first\n\t\t\tvar voc = {};\n\t\t\teach(data, function(section, syntax) {\n\t\t\t\tvar _section = {};\n\t\t\t\teach(section, function(subsection, name) {\n\t\t\t\t\tif (name == 'abbreviations' || name == 'snippets') {\n\t\t\t\t\t\tsubsection = expandSnippetsDefinition(subsection);\n\t\t\t\t\t}\n\t\t\t\t\t_section[name] = subsection;\n\t\t\t\t});\n\n\t\t\t\tvoc[syntax] = _section;\n\t\t\t});\n\n\n\t\t\tif (type == VOC_SYSTEM) {\n\t\t\t\tsystemSettings = voc;\n\t\t\t} else {\n\t\t\t\tuserSettings = voc;\n\t\t\t}\n\t\t},\n\n\t\t/**\n\t\t * Returns resource vocabulary by its name\n\t\t * @param {String} name Vocabulary name ('system' or 'user')\n\t\t * @return {Object}\n\t\t */\n\t\tgetVocabulary: function(name) {\n\t\t\treturn name == VOC_SYSTEM ? systemSettings : userSettings;\n\t\t},\n\n\t\t/**\n\t\t * Returns resource (abbreviation, snippet, etc.) matched for passed\n\t\t * abbreviation\n\t\t * @param {AbbreviationNode} node\n\t\t * @param {String} syntax\n\t\t * @returns {Object}\n\t\t */\n\t\tgetMatchedResource: function(node, syntax) {\n\t\t\treturn resolvers.exec(null, utils.toArray(arguments))\n\t\t\t\t|| this.findSnippet(syntax, node.name());\n\t\t},\n\n\t\t/**\n\t\t * Returns variable value\n\t\t * @return {String}\n\t\t */\n\t\tgetVariable: function(name) {\n\t\t\treturn (this.getSection('variables') || {})[name];\n\t\t},\n\n\t\t/**\n\t\t * Store runtime variable in user storage\n\t\t * @param {String} name Variable name\n\t\t * @param {String} value Variable value\n\t\t */\n\t\tsetVariable: function(name, value){\n\t\t\tvar voc = this.getVocabulary('user') || {};\n\t\t\tif (!('variables' in voc))\n\t\t\t\tvoc.variables = {};\n\n\t\t\tvoc.variables[name] = value;\n\t\t\tthis.setVocabulary(voc, 'user');\n\t\t},\n\n\t\t/**\n\t\t * Check if there are resources for specified syntax\n\t\t * @param {String} syntax\n\t\t * @return {Boolean}\n\t\t */\n\t\thasSyntax: function(syntax) {\n\t\t\treturn syntax in this.getVocabulary(VOC_USER)\n\t\t\t\t|| syntax in this.getVocabulary(VOC_SYSTEM);\n\t\t},\n\n\t\t/**\n\t\t * Registers new abbreviation resolver.\n\t\t * @param {Function} fn Abbreviation resolver which will receive\n\t\t * abbreviation as first argument and should return parsed abbreviation\n\t\t * object if abbreviation has handled successfully, <code>null</code>\n\t\t * otherwise\n\t\t * @param {Object} options Options list as described in\n\t\t * {@link HandlerList#add()} method\n\t\t */\n\t\taddResolver: function(fn, options) {\n\t\t\tresolvers.add(fn, options);\n\t\t},\n\n\t\tremoveResolver: function(fn) {\n\t\t\tresolvers.remove(fn);\n\t\t},\n\n\t\t/**\n\t\t * Returns actual section data, merged from both\n\t\t * system and user data\n\t\t * @param {String} name Section name (syntax)\n\t\t * @param {String} ...args Subsections\n\t\t * @returns\n\t\t */\n\t\tgetSection: function(name) {\n\t\t\tif (!name)\n\t\t\t\treturn null;\n\n\t\t\tif (!(name in cache)) {\n\t\t\t\tcache[name] = utils.deepMerge({}, systemSettings[name], userSettings[name]);\n\t\t\t}\n\n\t\t\tvar data = cache[name], subsections = utils.toArray(arguments, 1), key;\n\t\t\twhile (data && (key = subsections.shift())) {\n\t\t\t\tif (key in data) {\n\t\t\t\t\tdata = data[key];\n\t\t\t\t} else {\n\t\t\t\t\treturn null;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn data;\n\t\t},\n\n\t\t/**\n\t\t * Recursively searches for a item inside top level sections (syntaxes)\n\t\t * with respect of `extends` attribute\n\t\t * @param {String} topSection Top section name (syntax)\n\t\t * @param {String} subsection Inner section name\n\t\t * @returns {Object}\n\t\t */\n\t\tfindItem: function(topSection, subsection) {\n\t\t\tvar data = this.getSection(topSection);\n\t\t\twhile (data) {\n\t\t\t\tif (subsection in data)\n\t\t\t\t\treturn data[subsection];\n\n\t\t\t\tdata = this.getSection(data['extends']);\n\t\t\t}\n\t\t},\n\n\t\t/**\n\t\t * Recursively searches for a snippet definition inside syntax section.\n\t\t * Definition is searched inside `snippets` and `abbreviations`\n\t\t * subsections\n\t\t * @param {String} syntax Top-level section name (syntax)\n\t\t * @param {String} name Snippet name\n\t\t * @returns {Object}\n\t\t */\n\t\tfindSnippet: function(syntax, name, memo) {\n\t\t\tif (!syntax || !name)\n\t\t\t\treturn null;\n\n\t\t\tmemo = memo || [];\n\n\t\t\tvar names = [name];\n\t\t\t// create automatic aliases to properties with colons,\n\t\t\t// e.g. pos-a == pos:a\n\t\t\tif (~name.indexOf('-')) {\n\t\t\t\tnames.push(name.replace(/\\-/g, ':'));\n\t\t\t}\n\n\t\t\tvar data = this.getSection(syntax), matchedItem = null;\n\t\t\t['snippets', 'abbreviations'].some(function(sectionName) {\n\t\t\t\tvar data = this.getSection(syntax, sectionName);\n\t\t\t\tif (data) {\n\t\t\t\t\treturn names.some(function(n) {\n\t\t\t\t\t\tif (data[n]) {\n\t\t\t\t\t\t\treturn matchedItem = parseItem(n, data[n], sectionName);\n\t\t\t\t\t\t}\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}, this);\n\n\t\t\tmemo.push(syntax);\n\t\t\tif (!matchedItem && data['extends'] && !~memo.indexOf(data['extends'])) {\n\t\t\t\t// try to find item in parent syntax section\n\t\t\t\treturn this.findSnippet(data['extends'], name, memo);\n\t\t\t}\n\n\t\t\treturn matchedItem;\n\t\t},\n\n\t\t/**\n\t\t * Performs fuzzy search of snippet definition\n\t\t * @param {String} syntax Top-level section name (syntax)\n\t\t * @param {String} name Snippet name\n\t\t * @returns\n\t\t */\n\t\tfuzzyFindSnippet: function(syntax, name, minScore) {\n\t\t\tvar result = this.fuzzyFindMatches(syntax, name, minScore)[0];\n\t\t\tif (result) {\n\t\t\t\treturn result.value.parsedValue;\n\t\t\t}\n\t\t},\n\n\t\tfuzzyFindMatches: function(syntax, name, minScore) {\n\t\t\tminScore = minScore || 0.3;\n\t\t\tname = normalizeName(name);\n\t\t\tvar snippets = this.getAllSnippets(syntax);\n\n\t\t\treturn Object.keys(snippets)\n\t\t\t\t.map(function(key) {\n\t\t\t\t\tvar value = snippets[key];\n\t\t\t\t\treturn {\n\t\t\t\t\t\tkey: key,\n\t\t\t\t\t\tscore: stringScore.score(value.nk, name, 0.1),\n\t\t\t\t\t\tvalue: value\n\t\t\t\t\t};\n\t\t\t\t})\n\t\t\t\t.filter(function(item) {\n\t\t\t\t\treturn item.score >= minScore;\n\t\t\t\t})\n\t\t\t\t.sort(function(a, b) {\n\t\t\t\t\treturn a.score - b.score;\n\t\t\t\t})\n\t\t\t\t.reverse();\n\t\t},\n\n\t\t/**\n\t\t * Returns plain dictionary of all available abbreviations and snippets\n\t\t * for specified syntax with respect of inheritance\n\t\t * @param {String} syntax\n\t\t * @returns {Object}\n\t\t */\n\t\tgetAllSnippets: function(syntax) {\n\t\t\tvar cacheKey = 'all-' + syntax;\n\t\t\tif (!cache[cacheKey]) {\n\t\t\t\tvar stack = [], sectionKey = syntax;\n\t\t\t\tvar memo = [];\n\n\t\t\t\tdo {\n\t\t\t\t\tvar section = this.getSection(sectionKey);\n\t\t\t\t\tif (!section)\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t['snippets', 'abbreviations'].forEach(function(sectionName) {\n\t\t\t\t\t\tvar stackItem = {};\n\t\t\t\t\t\teach(section[sectionName] || null, function(v, k) {\n\t\t\t\t\t\t\tstackItem[k] = {\n\t\t\t\t\t\t\t\tnk: normalizeName(k),\n\t\t\t\t\t\t\t\tvalue: v,\n\t\t\t\t\t\t\t\tparsedValue: parseItem(k, v, sectionName),\n\t\t\t\t\t\t\t\ttype: sectionName\n\t\t\t\t\t\t\t};\n\t\t\t\t\t\t});\n\n\t\t\t\t\t\tstack.push(stackItem);\n\t\t\t\t\t});\n\n\t\t\t\t\tmemo.push(sectionKey);\n\t\t\t\t\tsectionKey = section['extends'];\n\t\t\t\t} while (sectionKey && !~memo.indexOf(sectionKey));\n\n\n\t\t\t\tcache[cacheKey] = utils.extend.apply(utils, stack.reverse());\n\t\t\t}\n\n\t\t\treturn cache[cacheKey];\n\t\t},\n\n\t\t/**\n\t\t * Returns newline character\n\t\t * @returns {String}\n\t\t */\n\t\tgetNewline: function() {\n\t\t\tvar nl = this.getVariable('newline');\n\t\t\treturn typeof nl === 'string' ? nl : '\\n';\n\t\t},\n\n\t\t/**\n\t\t * Sets new newline character that will be used in output\n\t\t * @param {String} str\n\t\t */\n\t\tsetNewline: function(str) {\n\t\t\tthis.setVariable('newline', str);\n\t\t\tthis.setVariable('nl', str);\n\t\t}\n\t});\n\n\t// XXX add default resolvers\n\texports.addResolver(cssResolver.resolve.bind(cssResolver));\n\n\t// try to load snippets\n\t// hide it from Require.JS parser\n\t(function(r) {\n\t\tif (typeof define === 'undefined' || !define.amd) {\n\t\t\ttry {\n\t\t\t\texports.setVocabulary(r('../snippets.json'), VOC_SYSTEM);\n\t\t\t} catch (e) {}\n\t\t}\n\t})(require);\n\n\n\treturn exports;\n});\n\n},{\"../assets/logger\":\"assets\\\\logger.js\",\"../resolver/css\":\"resolver\\\\css.js\",\"../utils/common\":\"utils\\\\common.js\",\"../vendor/stringScore\":\"vendor\\\\stringScore.js\",\"./elements\":\"assets\\\\elements.js\",\"./handlerList\":\"assets\\\\handlerList.js\"}],\"assets\\\\stringStream.js\":[function(require,module,exports){\n/**\n * A trimmed version of CodeMirror's StringStream module for string parsing\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\t/**\n\t * @type StringStream\n\t * @constructor\n\t * @param {String} string Assuming that bound string should be\n\t * immutable\n\t */\n\tfunction StringStream(string) {\n\t\tthis.pos = this.start = 0;\n\t\tthis.string = string;\n\t\tthis._length = string.length;\n\t}\n\t\n\tStringStream.prototype = {\n\t\t/**\n\t\t * Returns true only if the stream is at the end of the line.\n\t\t * @returns {Boolean}\n\t\t */\n\t\teol: function() {\n\t\t\treturn this.pos >= this._length;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns true only if the stream is at the start of the line\n\t\t * @returns {Boolean}\n\t\t */\n\t\tsol: function() {\n\t\t\treturn this.pos === 0;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns the next character in the stream without advancing it. \n\t\t * Will return <code>undefined</code> at the end of the line.\n\t\t * @returns {String}\n\t\t */\n\t\tpeek: function() {\n\t\t\treturn this.string.charAt(this.pos);\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns the next character in the stream and advances it.\n\t\t * Also returns <code>undefined</code> when no more characters are available.\n\t\t * @returns {String}\n\t\t */\n\t\tnext: function() {\n\t\t\tif (this.pos < this._length)\n\t\t\t\treturn this.string.charAt(this.pos++);\n\t\t},\n\t\t\n\t\t/**\n\t\t * match can be a character, a regular expression, or a function that\n\t\t * takes a character and returns a boolean. If the next character in the\n\t\t * stream 'matches' the given argument, it is consumed and returned.\n\t\t * Otherwise, undefined is returned.\n\t\t * @param {Object} match\n\t\t * @returns {String}\n\t\t */\n\t\teat: function(match) {\n\t\t\tvar ch = this.string.charAt(this.pos), ok;\n\t\t\tif (typeof match == \"string\")\n\t\t\t\tok = ch == match;\n\t\t\telse\n\t\t\t\tok = ch && (match.test ? match.test(ch) : match(ch));\n\t\t\t\n\t\t\tif (ok) {\n\t\t\t\t++this.pos;\n\t\t\t\treturn ch;\n\t\t\t}\n\t\t},\n\t\t\n\t\t/**\n\t\t * Repeatedly calls <code>eat</code> with the given argument, until it\n\t\t * fails. Returns <code>true</code> if any characters were eaten.\n\t\t * @param {Object} match\n\t\t * @returns {Boolean}\n\t\t */\n\t\teatWhile: function(match) {\n\t\t\tvar start = this.pos;\n\t\t\twhile (this.eat(match)) {}\n\t\t\treturn this.pos > start;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Shortcut for <code>eatWhile</code> when matching white-space.\n\t\t * @returns {Boolean}\n\t\t */\n\t\teatSpace: function() {\n\t\t\tvar start = this.pos;\n\t\t\twhile (/[\\s\\u00a0]/.test(this.string.charAt(this.pos)))\n\t\t\t\t++this.pos;\n\t\t\treturn this.pos > start;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Moves the position to the end of the line.\n\t\t */\n\t\tskipToEnd: function() {\n\t\t\tthis.pos = this._length;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Skips to the next occurrence of the given character, if found on the\n\t\t * current line (doesn't advance the stream if the character does not\n\t\t * occur on the line). Returns true if the character was found.\n\t\t * @param {String} ch\n\t\t * @returns {Boolean}\n\t\t */\n\t\tskipTo: function(ch) {\n\t\t\tvar found = this.string.indexOf(ch, this.pos);\n\t\t\tif (found > -1) {\n\t\t\t\tthis.pos = found;\n\t\t\t\treturn true;\n\t\t\t}\n\t\t},\n\t\t\n\t\t/**\n\t\t * Skips to <code>close</code> character which is pair to <code>open</code>\n\t\t * character, considering possible pair nesting. This function is used\n\t\t * to consume pair of characters, like opening and closing braces\n\t\t * @param {String} open\n\t\t * @param {String} close\n\t\t * @returns {Boolean} Returns <code>true</code> if pair was successfully\n\t\t * consumed\n\t\t */\n\t\tskipToPair: function(open, close, skipString) {\n\t\t\tvar braceCount = 0, ch;\n\t\t\tvar pos = this.pos, len = this._length;\n\t\t\twhile (pos < len) {\n\t\t\t\tch = this.string.charAt(pos++);\n\t\t\t\tif (ch == open) {\n\t\t\t\t\tbraceCount++;\n\t\t\t\t} else if (ch == close) {\n\t\t\t\t\tbraceCount--;\n\t\t\t\t\tif (braceCount < 1) {\n\t\t\t\t\t\tthis.pos = pos;\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t}\n\t\t\t\t} else if (skipString && (ch == '\"' || ch == \"'\")) {\n\t\t\t\t\tthis.skipString(ch);\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\treturn false;\n\t\t},\n\n\t\t/**\n\t\t * A helper function which, in case of either single or\n\t\t * double quote was found in current position, skips entire\n\t\t * string (quoted value)\n\t\t * @return {Boolean} Wether quoted string was skipped\n\t\t */\n\t\tskipQuoted: function(noBackup) {\n\t\t\tvar ch = this.string.charAt(noBackup ? this.pos : this.pos - 1);\n\t\t\tif (ch === '\"' || ch === \"'\") {\n\t\t\t\tif (noBackup) {\n\t\t\t\t\tthis.pos++;\n\t\t\t\t}\n\t\t\t\treturn this.skipString(ch);\n\t\t\t}\n\t\t},\n\n\t\t/**\n\t\t * A custom function to skip string literal, e.g. a \"double-quoted\"\n\t\t * or 'single-quoted' value\n\t\t * @param  {String} quote An opening quote\n\t\t * @return {Boolean}\n\t\t */\n\t\tskipString: function(quote) {\n\t\t\tvar pos = this.pos, len = this._length, ch;\n\t\t\twhile (pos < len) {\n\t\t\t\tch = this.string.charAt(pos++);\n\t\t\t\tif (ch == '\\\\') {\n\t\t\t\t\tcontinue;\n\t\t\t\t} else if (ch == quote) {\n\t\t\t\t\tthis.pos = pos;\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn false;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Backs up the stream n characters. Backing it up further than the\n\t\t * start of the current token will cause things to break, so be careful.\n\t\t * @param {Number} n\n\t\t */\n\t\tbackUp : function(n) {\n\t\t\tthis.pos -= n;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Act like a multi-character <code>eat</code>—if <code>consume</code> is true or\n\t\t * not given—or a look-ahead that doesn't update the stream position—if\n\t\t * it is false. <code>pattern</code> can be either a string or a\n\t\t * regular expression starting with ^. When it is a string,\n\t\t * <code>caseInsensitive</code> can be set to true to make the match\n\t\t * case-insensitive. When successfully matching a regular expression,\n\t\t * the returned value will be the array returned by <code>match</code>,\n\t\t * in case you need to extract matched groups.\n\t\t * \n\t\t * @param {RegExp} pattern\n\t\t * @param {Boolean} consume\n\t\t * @param {Boolean} caseInsensitive\n\t\t * @returns\n\t\t */\n\t\tmatch: function(pattern, consume, caseInsensitive) {\n\t\t\tif (typeof pattern == \"string\") {\n\t\t\t\tvar cased = caseInsensitive\n\t\t\t\t\t? function(str) {return str.toLowerCase();}\n\t\t\t\t\t: function(str) {return str;};\n\t\t\t\t\n\t\t\t\tif (cased(this.string).indexOf(cased(pattern), this.pos) == this.pos) {\n\t\t\t\t\tif (consume !== false)\n\t\t\t\t\t\tthis.pos += pattern.length;\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tvar match = this.string.slice(this.pos).match(pattern);\n\t\t\t\tif (match && consume !== false)\n\t\t\t\t\tthis.pos += match[0].length;\n\t\t\t\treturn match;\n\t\t\t}\n\t\t},\n\t\t\n\t\t/**\n\t\t * Get the string between the start of the current token and the \n\t\t * current stream position.\n\t\t * @returns {String}\n\t\t */\n\t\tcurrent: function(backUp) {\n\t\t\treturn this.string.slice(this.start, this.pos - (backUp ? 1 : 0));\n\t\t}\n\t};\n\n\tmodule.exports = function(string) {\n\t\treturn new StringStream(string);\n\t};\n\n\t/** @deprecated */\n\tmodule.exports.create = module.exports;\n\treturn module.exports;\n});\n},{}],\"assets\\\\tabStops.js\":[function(require,module,exports){\n/**\n * Utility module for handling tabstops tokens generated by Emmet's \n * \"Expand Abbreviation\" action. The main <code>extract</code> method will take\n * raw text (for example: <i>${0} some ${1:text}</i>), find all tabstops \n * occurrences, replace them with tokens suitable for your editor of choice and \n * return object with processed text and list of found tabstops and their ranges.\n * For sake of portability (Objective-C/Java) the tabstops list is a plain \n * sorted array with plain objects.\n * \n * Placeholders with the same are meant to be <i>linked</i> in your editor.\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar utils = require('../utils/common');\n\tvar stringStream = require('./stringStream');\n\tvar resources = require('./resources');\n\n\t/**\n\t * Global placeholder value, automatically incremented by \n\t * <code>variablesResolver()</code> function\n\t */\n\tvar startPlaceholderNum = 100;\n\tvar tabstopIndex = 0;\n\t\n\tvar defaultOptions = {\n\t\treplaceCarets: false,\n\t\tescape: function(ch) {\n\t\t\treturn '\\\\' + ch;\n\t\t},\n\t\ttabstop: function(data) {\n\t\t\treturn data.token;\n\t\t},\n\t\tvariable: function(data) {\n\t\t\treturn data.token;\n\t\t}\n\t};\n\t\n\treturn {\n\t\t/**\n\t\t * Main function that looks for a tabstops in provided <code>text</code>\n\t\t * and returns a processed version of <code>text</code> with expanded \n\t\t * placeholders and list of tabstops found.\n\t\t * @param {String} text Text to process\n\t\t * @param {Object} options List of processor options:<br>\n\t\t * \n\t\t * <b>replaceCarets</b> : <code>Boolean</code> — replace all default\n\t\t * caret placeholders (like <i>{%::emmet-caret::%}</i>) with <i>${0:caret}</i><br>\n\t\t * \n\t\t * <b>escape</b> : <code>Function</code> — function that handle escaped\n\t\t * characters (mostly '$'). By default, it returns the character itself \n\t\t * to be displayed as is in output, but sometimes you will use \n\t\t * <code>extract</code> method as intermediate solution for further \n\t\t * processing and want to keep character escaped. Thus, you should override\n\t\t * <code>escape</code> method to return escaped symbol (e.g. '\\\\$')<br>\n\t\t * \n\t\t * <b>tabstop</b> : <code>Function</code> – a tabstop handler. Receives \n\t\t * a single argument – an object describing token: its position, number \n\t\t * group, placeholder and token itself. Should return a replacement \n\t\t * string that will appear in final output\n\t\t * \n\t\t * <b>variable</b> : <code>Function</code> – variable handler. Receives \n\t\t * a single argument – an object describing token: its position, name \n\t\t * and original token itself. Should return a replacement \n\t\t * string that will appear in final output\n\t\t * \n\t\t * @returns {Object} Object with processed <code>text</code> property\n\t\t * and array of <code>tabstops</code> found\n\t\t * @memberOf tabStops\n\t\t */\n\t\textract: function(text, options) {\n\t\t\t// prepare defaults\n\t\t\tvar placeholders = {carets: ''};\n\t\t\tvar marks = [];\n\t\t\t\n\t\t\toptions = utils.extend({}, defaultOptions, options, {\n\t\t\t\ttabstop: function(data) {\n\t\t\t\t\tvar token = data.token;\n\t\t\t\t\tvar ret = '';\n\t\t\t\t\tif (data.placeholder == 'cursor') {\n\t\t\t\t\t\tmarks.push({\n\t\t\t\t\t\t\tstart: data.start,\n\t\t\t\t\t\t\tend: data.start + token.length,\n\t\t\t\t\t\t\tgroup: 'carets',\n\t\t\t\t\t\t\tvalue: ''\n\t\t\t\t\t\t});\n\t\t\t\t\t} else {\n\t\t\t\t\t\t// unify placeholder value for single group\n\t\t\t\t\t\tif ('placeholder' in data)\n\t\t\t\t\t\t\tplaceholders[data.group] = data.placeholder;\n\t\t\t\t\t\t\n\t\t\t\t\t\tif (data.group in placeholders)\n\t\t\t\t\t\t\tret = placeholders[data.group];\n\t\t\t\t\t\t\n\t\t\t\t\t\tmarks.push({\n\t\t\t\t\t\t\tstart: data.start,\n\t\t\t\t\t\t\tend: data.start + token.length,\n\t\t\t\t\t\t\tgroup: data.group,\n\t\t\t\t\t\t\tvalue: ret\n\t\t\t\t\t\t});\n\t\t\t\t\t}\n\t\t\t\t\t\n\t\t\t\t\treturn token;\n\t\t\t\t}\n\t\t\t});\n\t\t\t\n\t\t\tif (options.replaceCarets) {\n\t\t\t\ttext = text.replace(new RegExp( utils.escapeForRegexp( utils.getCaretPlaceholder() ), 'g'), '${0:cursor}');\n\t\t\t}\n\t\t\t\n\t\t\t// locate tabstops and unify group's placeholders\n\t\t\ttext = this.processText(text, options);\n\t\t\t\n\t\t\t// now, replace all tabstops with placeholders\n\t\t\tvar buf = '', lastIx = 0;\n\t\t\tvar tabStops = marks.map(function(mark) {\n\t\t\t\tbuf += text.substring(lastIx, mark.start);\n\t\t\t\t\n\t\t\t\tvar pos = buf.length;\n\t\t\t\tvar ph = placeholders[mark.group] || '';\n\t\t\t\t\n\t\t\t\tbuf += ph;\n\t\t\t\tlastIx = mark.end;\n\t\t\t\t\n\t\t\t\treturn {\n\t\t\t\t\tgroup: mark.group,\n\t\t\t\t\tstart: pos,\n\t\t\t\t\tend:  pos + ph.length\n\t\t\t\t};\n\t\t\t});\n\t\t\t\n\t\t\tbuf += text.substring(lastIx);\n\t\t\t\n\t\t\treturn {\n\t\t\t\ttext: buf,\n\t\t\t\ttabstops: tabStops.sort(function(a, b) {\n\t\t\t\t\treturn a.start - b.start;\n\t\t\t\t})\n\t\t\t};\n\t\t},\n\t\t\n\t\t/**\n\t\t * Text processing routine. Locates escaped characters and tabstops and\n\t\t * replaces them with values returned by handlers defined in \n\t\t * <code>options</code>\n\t\t * @param {String} text\n\t\t * @param {Object} options See <code>extract</code> method options \n\t\t * description\n\t\t * @returns {String}\n\t\t */\n\t\tprocessText: function(text, options) {\n\t\t\toptions = utils.extend({}, defaultOptions, options);\n\t\t\t\n\t\t\tvar buf = '';\n\t\t\t/** @type StringStream */\n\t\t\tvar stream = stringStream.create(text);\n\t\t\tvar ch, m, a;\n\t\t\t\n\t\t\twhile ((ch = stream.next())) {\n\t\t\t\tif (ch == '\\\\' && !stream.eol()) {\n\t\t\t\t\t// handle escaped character\n\t\t\t\t\tbuf += options.escape(stream.next());\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\ta = ch;\n\t\t\t\t\n\t\t\t\tif (ch == '$') {\n\t\t\t\t\t// looks like a tabstop\n\t\t\t\t\tstream.start = stream.pos - 1;\n\t\t\t\t\t\n\t\t\t\t\tif ((m = stream.match(/^[0-9]+/))) {\n\t\t\t\t\t\t// it's $N\n\t\t\t\t\t\ta = options.tabstop({\n\t\t\t\t\t\t\tstart: buf.length, \n\t\t\t\t\t\t\tgroup: stream.current().substr(1),\n\t\t\t\t\t\t\ttoken: stream.current()\n\t\t\t\t\t\t});\n\t\t\t\t\t} else if ((m = stream.match(/^\\{([a-z_\\-][\\w\\-]*)\\}/))) {\n\t\t\t\t\t\t// ${variable}\n\t\t\t\t\t\ta = options.variable({\n\t\t\t\t\t\t\tstart: buf.length, \n\t\t\t\t\t\t\tname: m[1],\n\t\t\t\t\t\t\ttoken: stream.current()\n\t\t\t\t\t\t});\n\t\t\t\t\t} else if ((m = stream.match(/^\\{([0-9]+)(:.+?)?\\}/, false))) {\n\t\t\t\t\t\t// ${N:value} or ${N} placeholder\n\t\t\t\t\t\t// parse placeholder, including nested ones\n\t\t\t\t\t\tstream.skipToPair('{', '}');\n\t\t\t\t\t\t\n\t\t\t\t\t\tvar obj = {\n\t\t\t\t\t\t\tstart: buf.length, \n\t\t\t\t\t\t\tgroup: m[1],\n\t\t\t\t\t\t\ttoken: stream.current()\n\t\t\t\t\t\t};\n\t\t\t\t\t\t\n\t\t\t\t\t\tvar placeholder = obj.token.substring(obj.group.length + 2, obj.token.length - 1);\n\t\t\t\t\t\t\n\t\t\t\t\t\tif (placeholder) {\n\t\t\t\t\t\t\tobj.placeholder = placeholder.substr(1);\n\t\t\t\t\t\t}\n\t\t\t\t\t\t\n\t\t\t\t\t\ta = options.tabstop(obj);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tbuf += a;\n\t\t\t}\n\t\t\t\n\t\t\treturn buf;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Upgrades tabstops in output node in order to prevent naming conflicts\n\t\t * @param {AbbreviationNode} node\n\t\t * @param {Number} offset Tab index offset\n\t\t * @returns {Number} Maximum tabstop index in element\n\t\t */\n\t\tupgrade: function(node, offset) {\n\t\t\tvar maxNum = 0;\n\t\t\tvar options = {\n\t\t\t\ttabstop: function(data) {\n\t\t\t\t\tvar group = parseInt(data.group, 10);\n\t\t\t\t\tif (group > maxNum) maxNum = group;\n\t\t\t\t\t\t\n\t\t\t\t\tif (data.placeholder)\n\t\t\t\t\t\treturn '${' + (group + offset) + ':' + data.placeholder + '}';\n\t\t\t\t\telse\n\t\t\t\t\t\treturn '${' + (group + offset) + '}';\n\t\t\t\t}\n\t\t\t};\n\t\t\t\n\t\t\t['start', 'end', 'content'].forEach(function(p) {\n\t\t\t\tnode[p] = this.processText(node[p], options);\n\t\t\t}, this);\n\t\t\t\n\t\t\treturn maxNum;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Helper function that produces a callback function for \n\t\t * <code>replaceVariables()</code> method from {@link utils}\n\t\t * module. This callback will replace variable definitions (like \n\t\t * ${var_name}) with their value defined in <i>resource</i> module,\n\t\t * or outputs tabstop with variable name otherwise.\n\t\t * @param {AbbreviationNode} node Context node\n\t\t * @returns {Function}\n\t\t */\n\t\tvariablesResolver: function(node) {\n\t\t\tvar placeholderMemo = {};\n\t\t\treturn function(str, varName) {\n\t\t\t\t// do not mark `child` variable as placeholder – it‘s a reserved\n\t\t\t\t// variable name\n\t\t\t\tif (varName == 'child') {\n\t\t\t\t\treturn str;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tif (varName == 'cursor') {\n\t\t\t\t\treturn utils.getCaretPlaceholder();\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tvar attr = node.attribute(varName);\n\t\t\t\tif (typeof attr !== 'undefined' && attr !== str) {\n\t\t\t\t\treturn attr;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tvar varValue = resources.getVariable(varName);\n\t\t\t\tif (varValue) {\n\t\t\t\t\treturn varValue;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\t// output as placeholder\n\t\t\t\tif (!placeholderMemo[varName]) {\n\t\t\t\t\tplaceholderMemo[varName] = startPlaceholderNum++;\n\t\t\t\t}\n\t\t\t\t\t\n\t\t\t\treturn '${' + placeholderMemo[varName] + ':' + varName + '}';\n\t\t\t};\n\t\t},\n\n\t\t/**\n\t\t * Replace variables like ${var} in string\n\t\t * @param {String} str\n\t\t * @param {Object} vars Variable set (defaults to variables defined in \n\t\t * <code>snippets.json</code>) or variable resolver (<code>Function</code>)\n\t\t * @return {String}\n\t\t */\n\t\treplaceVariables: function(str, vars) {\n\t\t\tvars = vars || {};\n\t\t\tvar resolver = typeof vars === 'function' ? vars : function(str, p1) {\n\t\t\t\treturn p1 in vars ? vars[p1] : null;\n\t\t\t};\n\t\t\t\n\t\t\treturn this.processText(str, {\n\t\t\t\tvariable: function(data) {\n\t\t\t\t\tvar newValue = resolver(data.token, data.name, data);\n\t\t\t\t\tif (newValue === null) {\n\t\t\t\t\t\t// try to find variable in resources\n\t\t\t\t\t\tnewValue = resources.getVariable(data.name);\n\t\t\t\t\t}\n\t\t\t\t\t\n\t\t\t\t\tif (newValue === null || typeof newValue === 'undefined')\n\t\t\t\t\t\t// nothing found, return token itself\n\t\t\t\t\t\tnewValue = data.token;\n\t\t\t\t\treturn newValue;\n\t\t\t\t}\n\t\t\t});\n\t\t},\n\t\t\n\t\t/**\n\t\t * Resets global tabstop index. When parsed tree is converted to output\n\t\t * string (<code>AbbreviationNode.toString()</code>), all tabstops \n\t\t * defined in snippets and elements are upgraded in order to prevent\n\t\t * naming conflicts of nested. For example, <code>${1}</code> of a node\n\t\t * should not be linked with the same placehilder of the child node.\n\t\t * By default, <code>AbbreviationNode.toString()</code> automatically\n\t\t * upgrades tabstops of the same index for each node and writes maximum\n\t\t * tabstop index into the <code>tabstopIndex</code> variable. To keep\n\t\t * this variable at reasonable value, it is recommended to call \n\t\t * <code>resetTabstopIndex()</code> method each time you expand variable \n\t\t * @returns\n\t\t */\n\t\tresetTabstopIndex: function() {\n\t\t\ttabstopIndex = 0;\n\t\t\tstartPlaceholderNum = 100;\n\t\t},\n\n\t\t/**\n\t\t * Output processor for abbreviation parser that will upgrade tabstops \n\t\t * of parsed node in order to prevent tabstop index conflicts\n\t\t */\n\t\tabbrOutputProcessor: function(text, node, type) {\n\t\t\tvar maxNum = 0;\n\t\t\tvar that = this;\n\t\t\t\n\t\t\tvar tsOptions = {\n\t\t\t\ttabstop: function(data) {\n\t\t\t\t\tvar group = parseInt(data.group, 10);\n\t\t\t\t\tif (group === 0)\n\t\t\t\t\t\treturn '${0}';\n\t\t\t\t\t\n\t\t\t\t\tif (group > maxNum) maxNum = group;\n\t\t\t\t\tif (data.placeholder) {\n\t\t\t\t\t\t// respect nested placeholders\n\t\t\t\t\t\tvar ix = group + tabstopIndex;\n\t\t\t\t\t\tvar placeholder = that.processText(data.placeholder, tsOptions);\n\t\t\t\t\t\treturn '${' + ix + ':' + placeholder + '}';\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn '${' + (group + tabstopIndex) + '}';\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t};\n\t\t\t\n\t\t\t// upgrade tabstops\n\t\t\ttext = this.processText(text, tsOptions);\n\t\t\t\n\t\t\t// resolve variables\n\t\t\ttext = this.replaceVariables(text, this.variablesResolver(node));\n\t\t\t\n\t\t\ttabstopIndex += maxNum + 1;\n\t\t\treturn text;\n\t\t}\n\t};\n});\n},{\"../utils/common\":\"utils\\\\common.js\",\"./resources\":\"assets\\\\resources.js\",\"./stringStream\":\"assets\\\\stringStream.js\"}],\"assets\\\\tokenIterator.js\":[function(require,module,exports){\n/**\n * Helper class for convenient token iteration\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\t/**\n\t * @type TokenIterator\n\t * @param {Array} tokens\n\t * @type TokenIterator\n\t * @constructor\n\t */\n\tfunction TokenIterator(tokens) {\n\t\t/** @type Array */\n\t\tthis.tokens = tokens;\n\t\tthis._position = 0;\n\t\tthis.reset();\n\t}\n\t\n\tTokenIterator.prototype = {\n\t\tnext: function() {\n\t\t\tif (this.hasNext()) {\n\t\t\t\tvar token = this.tokens[++this._i];\n\t\t\t\tthis._position = token.start;\n\t\t\t\treturn token;\n\t\t\t} else {\n\t\t\t\tthis._i = this._il;\n\t\t\t}\n\t\t\t\n\t\t\treturn null;\n\t\t},\n\t\t\n\t\tcurrent: function() {\n\t\t\treturn this.tokens[this._i];\n\t\t},\n\n\t\tpeek: function() {\n\t\t\treturn this.tokens[this._i + i];\n\t\t},\n\t\t\n\t\tposition: function() {\n\t\t\treturn this._position;\n\t\t},\n\t\t\n\t\thasNext: function() {\n\t\t\treturn this._i < this._il - 1;\n\t\t},\n\t\t\n\t\treset: function() {\n\t\t\tthis._i = 0;\n\t\t\tthis._il = this.tokens.length;\n\t\t},\n\t\t\n\t\titem: function() {\n\t\t\treturn this.tokens[this._i];\n\t\t},\n\t\t\n\t\titemNext: function() {\n\t\t\treturn this.tokens[this._i + 1];\n\t\t},\n\t\t\n\t\titemPrev: function() {\n\t\t\treturn this.tokens[this._i - 1];\n\t\t},\n\t\t\n\t\tnextUntil: function(type, callback) {\n\t\t\tvar token;\n\t\t\tvar test = typeof type == 'string' \n\t\t\t\t? function(t){return t.type == type;} \n\t\t\t\t: type;\n\t\t\t\n\t\t\twhile ((token = this.next())) {\n\t\t\t\tif (callback)\n\t\t\t\t\tcallback.call(this, token);\n\t\t\t\tif (test.call(this, token))\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t};\n\t\n\treturn {\n\t\tcreate: function(tokens) {\n\t\t\treturn new TokenIterator(tokens);\n\t\t}\n\t};\n});\n},{}],\"editTree\\\\base.js\":[function(require,module,exports){\n/**\n * Abstract implementation of edit tree interface.\n * Edit tree is a named container of editable “name-value” child elements, \n * parsed from <code>source</code>. This container provides convenient methods\n * for editing/adding/removing child elements. All these update actions are\n * instantly reflected in the <code>source</code> code with respect of formatting.\n * <br><br>\n * For example, developer can create an edit tree from CSS rule and add or \n * remove properties from it–all changes will be immediately reflected in the \n * original source.\n * <br><br>\n * All classes defined in this module should be extended the same way as in\n * Backbone framework: using <code>extend</code> method to create new class and \n * <code>initialize</code> method to define custom class constructor.\n * \n * @example\n * <pre><code>\n * var MyClass = require('editTree/base').EditElement.extend({\n *     initialize: function() {\n *     // constructor code here\n *   }\n * });\n * \n * var elem = new MyClass(); \n * </code></pre>\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar range = require('../assets/range');\n\tvar utils = require('../utils/common');\n\tvar klass = require('../vendor/klass');\n\t\n\t/**\n\t * Named container of edited source\n\t * @type EditContainer\n\t * @param {String} source\n\t * @param {Object} options\n\t */\n\tfunction EditContainer(source, options) {\n\t\tthis.options = utils.extend({offset: 0}, options);\n\t\t/**\n\t\t * Source code of edited structure. All changes in the structure are \n\t\t * immediately reflected into this property\n\t\t */\n\t\tthis.source = source;\n\t\t\n\t\t/** \n\t\t * List of all editable children\n\t\t * @private \n\t\t */\n\t\tthis._children = [];\n\t\t\n\t\t/**\n\t\t * Hash of all positions of container\n\t\t * @private\n\t\t */\n\t\tthis._positions = {\n\t\t\tname: 0\n\t\t};\n\t\t\n\t\tthis.initialize.apply(this, arguments);\n\t}\n\t\n\t/**\n\t * The self-propagating extend function for classes.\n\t * @type Function\n\t */\n\tEditContainer.extend = klass.extend;\n\t\n\tEditContainer.prototype = {\n\t\ttype: 'container',\n\t\t/**\n\t\t * Child class constructor\n\t\t */\n\t\tinitialize: function() {},\n\n\t\t/**\n\t\t * Make position absolute\n\t\t * @private\n\t\t * @param {Number} num\n\t\t * @param {Boolean} isAbsolute\n\t\t * @returns {Boolean}\n\t\t */\n\t\t_pos: function(num, isAbsolute) {\n\t\t\treturn num + (isAbsolute ? this.options.offset : 0);\n\t\t},\n\t\t\n\t\t/**\n\t\t * Replace substring of tag's source\n\t\t * @param {String} value\n\t\t * @param {Number} start\n\t\t * @param {Number} end\n\t\t * @private\n\t\t */\n\t\t_updateSource: function(value, start, end) {\n\t\t\t// create modification range\n\t\t\tvar r = range.create(start, typeof end === 'undefined' ? 0 : end - start);\n\t\t\tvar delta = value.length - r.length();\n\t\t\t\n\t\t\tvar update = function(obj) {\n\t\t\t\tObject.keys(obj).forEach(function(k) {\n\t\t\t\t\tif (obj[k] >= r.end) {\n\t\t\t\t\t\tobj[k] += delta;\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t};\n\t\t\t\n\t\t\t// update affected positions of current container\n\t\t\tupdate(this._positions);\n\t\t\t\n\t\t\t// update affected positions of children\n\t\t\tvar recursiveUpdate = function(items) {\n\t\t\t\titems.forEach(function(item) {\n\t\t\t\t\tupdate(item._positions);\n\t\t\t\t\tif (item.type == 'container') {\n\t\t\t\t\t\trecursiveUpdate(item.list());\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t};\n\n\t\t\trecursiveUpdate(this.list());\n\t\t\tthis.source = utils.replaceSubstring(this.source, value, r);\n\t\t},\n\t\t\t\n\t\t\t\n\t\t/**\n\t\t * Adds new attribute \n\t\t * @param {String} name Property name\n\t\t * @param {String} value Property value\n\t\t * @param {Number} pos Position at which to insert new property. By \n\t\t * default the property is inserted at the end of rule \n\t\t * @returns {EditElement} Newly created element\n\t\t */\n\t\tadd: function(name, value, pos) {\n\t\t\t// this is abstract implementation\n\t\t\tvar item = new EditElement(name, value);\n\t\t\tthis._children.push(item);\n\t\t\treturn item;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns attribute object\n\t\t * @param {String} name Attribute name or its index\n\t\t * @returns {EditElement}\n\t\t */\n\t\tget: function(name) {\n\t\t\tif (typeof name === 'number') {\n\t\t\t\treturn this.list()[name];\n\t\t\t}\n\t\t\t\n\t\t\tif (typeof name === 'string') {\n\t\t\t\treturn utils.find(this.list(), function(prop) {\n\t\t\t\t\treturn prop.name() === name;\n\t\t\t\t});\n\t\t\t}\n\t\t\t\n\t\t\treturn name;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns all children by name or indexes\n\t\t * @param {Object} name Element name(s) or indexes (<code>String</code>,\n\t\t * <code>Array</code>, <code>Number</code>)\n\t\t * @returns {Array}\n\t\t */\n\t\tgetAll: function(name) {\n\t\t\tif (!Array.isArray(name))\n\t\t\t\tname = [name];\n\t\t\t\n\t\t\t// split names and indexes\n\t\t\tvar names = [], indexes = [];\n\t\t\tname.forEach(function(item) {\n\t\t\t\tif (typeof item === 'string') {\n\t\t\t\t\tnames.push(item);\n\t\t\t\t} else if (typeof item === 'number') {\n\t\t\t\t\tindexes.push(item);\n\t\t\t\t}\n\t\t\t});\n\t\t\t\n\t\t\treturn this.list().filter(function(attribute, i) {\n\t\t\t\treturn ~indexes.indexOf(i) || ~names.indexOf(attribute.name());\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Returns list of all editable child elements\n\t\t * @returns {Array}\n\t\t */\n\t\tlist: function() {\n\t\t\treturn this._children;\n\t\t},\n\n\t\t/**\n\t\t * Remove child element\n\t\t * @param {String} name Property name or its index\n\t\t */\n\t\tremove: function(name) {\n\t\t\tvar element = this.get(name);\n\t\t\tif (element) {\n\t\t\t\tthis._updateSource('', element.fullRange());\n\t\t\t\tvar ix = this._children.indexOf(element);\n\t\t\t\tif (~ix) {\n\t\t\t\t\tthis._children.splice(ix, 1);\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns index of editble child in list\n\t\t * @param {Object} item\n\t\t * @returns {Number}\n\t\t */\n\t\tindexOf: function(item) {\n\t\t\treturn this.list().indexOf(this.get(item));\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns or updates element value. If such element doesn't exists,\n\t\t * it will be created automatically and added at the end of child list.\n\t\t * @param {String} name Element name or its index\n\t\t * @param {String} value New element value\n\t\t * @returns {String}\n\t\t */\n\t\tvalue: function(name, value, pos) {\n\t\t\tvar element = this.get(name);\n\t\t\tif (element)\n\t\t\t\treturn element.value(value);\n\t\t\t\n\t\t\tif (typeof value !== 'undefined') {\n\t\t\t\t// no such element — create it\n\t\t\t\treturn this.add(name, value, pos);\n\t\t\t}\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns all values of child elements found by <code>getAll()</code>\n\t\t * method\n\t\t * @param {Object} name Element name(s) or indexes (<code>String</code>,\n\t\t * <code>Array</code>, <code>Number</code>)\n\t\t * @returns {Array}\n\t\t */\n\t\tvalues: function(name) {\n\t\t\treturn this.getAll(name).map(function(element) {\n\t\t\t\treturn element.value();\n\t\t\t});\n\t\t},\n\t\t\n\t\t/**\n\t\t * Sets or gets container name\n\t\t * @param {String} val New name. If not passed, current \n\t\t * name is returned\n\t\t * @return {String}\n\t\t */\n\t\tname: function(val) {\n\t\t\tif (typeof val !== 'undefined' && this._name !== (val = String(val))) {\n\t\t\t\tthis._updateSource(val, this._positions.name, this._positions.name + this._name.length);\n\t\t\t\tthis._name = val;\n\t\t\t}\n\t\t\t\n\t\t\treturn this._name;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns name range object\n\t\t * @param {Boolean} isAbsolute Return absolute range (with respect of \n\t\t * rule offset)\n\t\t * @returns {Range}\n\t\t */\n\t\tnameRange: function(isAbsolute) {\n\t\t\treturn range.create(this._positions.name + (isAbsolute ? this.options.offset : 0), this.name());\n\t\t},\n\n\t\t/**\n\t\t * Returns range of current source\n\t\t * @param {Boolean} isAbsolute\n\t\t */\n\t\trange: function(isAbsolute) {\n\t\t\treturn range.create(isAbsolute ? this.options.offset : 0, this.valueOf());\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns element that belongs to specified position\n\t\t * @param {Number} pos\n\t\t * @param {Boolean} isAbsolute\n\t\t * @returns {EditElement}\n\t\t */\n\t\titemFromPosition: function(pos, isAbsolute) {\n\t\t\treturn utils.find(this.list(), function(elem) {\n\t\t\t\treturn elem.range(isAbsolute).inside(pos);\n\t\t\t});\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns source code of current container \n\t\t * @returns {String}\n\t\t */\n\t\ttoString: function() {\n\t\t\treturn this.valueOf();\n\t\t},\n\n\t\tvalueOf: function() {\n\t\t\treturn this.source;\n\t\t}\n\t};\n\t\n\t/**\n\t * @param {EditContainer} parent\n\t * @param {Object} nameToken\n\t * @param {Object} valueToken\n\t */\n\tfunction EditElement(parent, nameToken, valueToken) {\n\t\t/** @type EditContainer */\n\t\tthis.parent = parent;\n\t\t\n\t\tthis._name = nameToken.value;\n\t\tthis._value = valueToken ? valueToken.value : '';\n\t\t\n\t\tthis._positions = {\n\t\t\tname: nameToken.start,\n\t\t\tvalue: valueToken ? valueToken.start : -1\n\t\t};\n\t\t\n\t\tthis.initialize.apply(this, arguments);\n\t}\n\t\n\t/**\n\t * The self-propagating extend function for classes.\n\t * @type Function\n\t */\n\tEditElement.extend = klass.extend;\n\t\n\tEditElement.prototype = {\n\t\ttype: 'element',\n\n\t\t/**\n\t\t * Child class constructor\n\t\t */\n\t\tinitialize: function() {},\n\t\t\n\t\t/**\n\t\t * Make position absolute\n\t\t * @private\n\t\t * @param {Number} num\n\t\t * @param {Boolean} isAbsolute\n\t\t * @returns {Boolean}\n\t\t */\n\t\t_pos: function(num, isAbsolute) {\n\t\t\treturn num + (isAbsolute ? this.parent.options.offset : 0);\n\t\t},\n\t\t\t\n\t\t/**\n\t\t * Sets of gets element value\n\t\t * @param {String} val New element value. If not passed, current \n\t\t * value is returned\n\t\t * @returns {String}\n\t\t */\n\t\tvalue: function(val) {\n\t\t\tif (typeof val !== 'undefined' && this._value !== (val = String(val))) {\n\t\t\t\tthis.parent._updateSource(val, this.valueRange());\n\t\t\t\tthis._value = val;\n\t\t\t}\n\t\t\t\n\t\t\treturn this._value;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Sets of gets element name\n\t\t * @param {String} val New element name. If not passed, current \n\t\t * name is returned\n\t\t * @returns {String}\n\t\t */\n\t\tname: function(val) {\n\t\t\tif (typeof val !== 'undefined' && this._name !== (val = String(val))) {\n\t\t\t\tthis.parent._updateSource(val, this.nameRange());\n\t\t\t\tthis._name = val;\n\t\t\t}\n\t\t\t\n\t\t\treturn this._name;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns position of element name token\n\t\t * @param {Boolean} isAbsolute Return absolute position\n\t\t * @returns {Number}\n\t\t */\n\t\tnamePosition: function(isAbsolute) {\n\t\t\treturn this._pos(this._positions.name, isAbsolute);\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns position of element value token\n\t\t * @param {Boolean} isAbsolute Return absolute position\n\t\t * @returns {Number}\n\t\t */\n\t\tvaluePosition: function(isAbsolute) {\n\t\t\treturn this._pos(this._positions.value, isAbsolute);\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns element name\n\t\t * @param {Boolean} isAbsolute Return absolute range \n\t\t * @returns {Range}\n\t\t */\n\t\trange: function(isAbsolute) {\n\t\t\treturn range.create(this.namePosition(isAbsolute), this.valueOf());\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns full element range, including possible indentation\n\t\t * @param {Boolean} isAbsolute Return absolute range\n\t\t * @returns {Range}\n\t\t */\n\t\tfullRange: function(isAbsolute) {\n\t\t\treturn this.range(isAbsolute);\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns element name range\n\t\t * @param {Boolean} isAbsolute Return absolute range\n\t\t * @returns {Range}\n\t\t */\n\t\tnameRange: function(isAbsolute) {\n\t\t\treturn range.create(this.namePosition(isAbsolute), this.name());\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns element value range\n\t\t * @param {Boolean} isAbsolute Return absolute range\n\t\t * @returns {Range}\n\t\t */\n\t\tvalueRange: function(isAbsolute) {\n\t\t\treturn range.create(this.valuePosition(isAbsolute), this.value());\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns current element string representation\n\t\t * @returns {String}\n\t\t */\n\t\ttoString: function() {\n\t\t\treturn this.valueOf();\n\t\t},\n\t\t\n\t\tvalueOf: function() {\n\t\t\treturn this.name() + this.value();\n\t\t}\n\t};\n\t\n\treturn {\n\t\tEditContainer: EditContainer,\n\t\tEditElement: EditElement,\n\t\t\n\t\t/**\n\t\t * Creates token that can be fed to <code>EditElement</code>\n\t\t * @param {Number} start\n\t\t * @param {String} value\n\t\t * @param {String} type\n\t\t * @returns\n\t\t */\n\t\tcreateToken: function(start, value, type) {\n\t\t\tvar obj = {\n\t\t\t\tstart: start || 0,\n\t\t\t\tvalue: value || '',\n\t\t\t\ttype: type\n\t\t\t};\n\t\t\t\n\t\t\tobj.end = obj.start + obj.value.length;\n\t\t\treturn obj;\n\t\t}\n\t};\n});\n},{\"../assets/range\":\"assets\\\\range.js\",\"../utils/common\":\"utils\\\\common.js\",\"../vendor/klass\":\"vendor\\\\klass.js\"}],\"editTree\\\\css.js\":[function(require,module,exports){\n/**\n * CSS EditTree is a module that can parse a CSS rule into a tree with \n * convenient methods for adding, modifying and removing CSS properties. These \n * changes can be written back to string with respect of code formatting.\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar utils = require('../utils/common');\n\tvar editTree = require('./base');\n\tvar cssParser = require('../parser/css');\n\tvar cssSections = require('../utils/cssSections');\n\tvar range = require('../assets/range');\n\tvar stringStream = require('../assets/stringStream');\n\tvar tokenIterator = require('../assets/tokenIterator');\n\n\tvar defaultOptions = {\n\t\tstyleBefore: '\\n\\t',\n\t\tstyleSeparator: ': ',\n\t\toffset: 0\n\t};\n\t\n\tvar reSpaceStart = /^\\s+/;\n\tvar reSpaceEnd = /\\s+$/;\n\tvar WHITESPACE_REMOVE_FROM_START = 1;\n\tvar WHITESPACE_REMOVE_FROM_END   = 2;\n\t\n\t/**\n\t * Modifies given range to remove whitespace from beginning\n\t * and/or from the end\n\t * @param  {Range} rng Range to modify\n\t * @param  {String} text  Text that range belongs to\n\t * @param  {Number} mask  Mask indicating from which end \n\t * whitespace should be removed\n\t * @return {Range}\n\t */\n\tfunction trimWhitespaceInRange(rng, text, mask) {\n\t\tmask = mask || (WHITESPACE_REMOVE_FROM_START | WHITESPACE_REMOVE_FROM_END);\n\t\ttext = rng.substring(text);\n\t\tvar m;\n\t\tif ((mask & WHITESPACE_REMOVE_FROM_START) && (m = text.match(reSpaceStart))) {\n\t\t\trng.start += m[0].length;\n\t\t}\n\n\t\tif ((mask & WHITESPACE_REMOVE_FROM_END) && (m = text.match(reSpaceEnd))) {\n\t\t\trng.end -= m[0].length;\n\t\t}\n\n\t\t// in case given range is just a whatespace\n\t\tif (rng.end < rng.start) {\n\t\t\trng.end = rng.start;\n\t\t}\n\n\t\treturn rng;\n\t}\n\n\t/**\n\t * Consumes CSS property and value from current token\n\t * iterator state. Offsets iterator pointer into token\n\t * that can be used for next value consmption\n\t * @param  {TokenIterator} it\n\t * @param  {String} text\n\t * @return {Object}    Object with `name` and `value` properties \n\t * ar ranges. Value range can be zero-length.\n\t */\n\tfunction consumeSingleProperty(it, text) {\n\t\tvar name, value, end;\n\t\tvar token = it.current();\n\n\t\tif (!token) {\n\t\t\treturn null;\n\t\t}\n\n\t\t// skip whitespace\n\t\tvar ws = {'white': 1, 'line': 1, 'comment': 1};\n\t\twhile ((token = it.current())) {\n\t\t\tif (!(token.type in ws)) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tit.next();\n\t\t}\n\n\t\tif (!it.hasNext()) {\n\t\t\treturn null;\n\t\t}\n\n\t\t// consume property name\n\t\ttoken = it.current();\n\t\tname = range(token.start, token.value);\n\t\tvar isAtProperty = token.value.charAt(0) == '@';\n\t\twhile (token = it.next()) {\n\t\t\tname.end = token.end;\n\t\t\tif (token.type == ':' || token.type == 'white') {\n\t\t\t\tname.end = token.start;\n\t\t\t\tit.next();\n\t\t\t\tif (token.type == ':' || isAtProperty) {\n\t\t\t\t\t// XXX I really ashame of this hardcode, but I need\n\t\t\t\t\t// to stop parsing if this is an SCSS mixin call,\n\t\t\t\t\t// for example: @include border-radius(10px)\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t} else if (token.type == ';' || token.type == 'line') {\n\t\t\t\t// there’s no value, looks like a mixin\n\t\t\t\t// or a special use case:\n\t\t\t\t// user is writing a new property or abbreviation\n\t\t\t\tname.end = token.start;\n\t\t\t\tvalue = range(token.start, 0);\n\t\t\t\tit.next();\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\ttoken = it.current();\n\t\tif (!value && token) {\n\t\t\tif (token.type == 'line') {\n\t\t\t\tlastNewline = token;\n\t\t\t}\n\t\t\t// consume value\n\t\t\tvalue = range(token.start, token.value);\n\t\t\tvar lastNewline;\n\t\t\twhile ((token = it.next())) {\n\t\t\t\tvalue.end = token.end;\n\t\t\t\tif (token.type == 'line') {\n\t\t\t\t\tlastNewline = token;\n\t\t\t\t} else if (token.type == '}' || token.type == ';') {\n\t\t\t\t\tvalue.end = token.start;\n\t\t\t\t\tif (token.type == ';') {\n\t\t\t\t\t\tend = range(token.start, token.value);\n\t\t\t\t\t}\n\t\t\t\t\tit.next();\n\t\t\t\t\tbreak;\n\t\t\t\t} else if (token.type == ':' && lastNewline) {\n\t\t\t\t\t// A special case: \n\t\t\t\t\t// user is writing a value before existing\n\t\t\t\t\t// property, but didn’t inserted closing semi-colon.\n\t\t\t\t\t// In this case, limit value range to previous\n\t\t\t\t\t// newline\n\t\t\t\t\tvalue.end = lastNewline.start;\n\t\t\t\t\tit._i = it.tokens.indexOf(lastNewline);\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (!value) {\n\t\t\tvalue = range(name.end, 0);\n\t\t}\n\n\t\treturn {\n\t\t\tname: trimWhitespaceInRange(name, text),\n\t\t\tvalue: trimWhitespaceInRange(value, text, WHITESPACE_REMOVE_FROM_START | (end ? WHITESPACE_REMOVE_FROM_END : 0)),\n\t\t\tend: end || range(value.end, 0)\n\t\t};\n\t}\n\n\t/**\n\t * Finds parts of complex CSS value\n\t * @param {String} str\n\t * @returns {Array} Returns list of <code>Range</code>'s\n\t */\n\tfunction findParts(str) {\n\t\t/** @type StringStream */\n\t\tvar stream = stringStream.create(str);\n\t\tvar ch;\n\t\tvar result = [];\n\t\tvar sep = /[\\s\\u00a0,;]/;\n\t\t\n\t\tvar add = function() {\n\t\t\tstream.next();\n\t\t\tresult.push(range(stream.start, stream.current()));\n\t\t\tstream.start = stream.pos;\n\t\t};\n\t\t\n\t\t// skip whitespace\n\t\tstream.eatSpace();\n\t\tstream.start = stream.pos;\n\t\t\n\t\twhile ((ch = stream.next())) {\n\t\t\tif (ch == '\"' || ch == \"'\") {\n\t\t\t\tstream.next();\n\t\t\t\tif (!stream.skipTo(ch)) break;\n\t\t\t\tadd();\n\t\t\t} else if (ch == '(') {\n\t\t\t\t// function found, may have nested function\n\t\t\t\tstream.backUp(1);\n\t\t\t\tif (!stream.skipToPair('(', ')')) break;\n\t\t\t\tstream.backUp(1);\n\t\t\t\tadd();\n\t\t\t} else {\n\t\t\t\tif (sep.test(ch)) {\n\t\t\t\t\tresult.push(range(stream.start, stream.current().length - 1));\n\t\t\t\t\tstream.eatWhile(sep);\n\t\t\t\t\tstream.start = stream.pos;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\t\n\t\tadd();\n\n\t\treturn utils.unique(result.filter(function(item) {\n\t\t\treturn !!item.length();\n\t\t}));\n\t}\n\t\n\t/**\n\t * Parses CSS properties from given CSS source\n\t * and adds them to CSSEditContainer node\n\t * @param  {CSSEditContainer} node\n\t * @param  {String} source CSS source\n\t * @param {Number} offset Offset of properties subset from original source\n\t */\n\tfunction consumeProperties(node, source, offset) {\n\t\tvar list = extractPropertiesFromSource(source, offset);\n\n\t\tlist.forEach(function(property) {\n\t\t\tnode._children.push(new CSSEditElement(node,\n\t\t\t\teditTree.createToken(property.name.start, property.nameText),\n\t\t\t\teditTree.createToken(property.value.start, property.valueText),\n\t\t\t\teditTree.createToken(property.end.start, property.endText)\n\t\t\t\t));\n\t\t});\n\t}\n\n\t/**\n\t * Parses given CSS source and returns list of ranges of located CSS properties.\n\t * Normally, CSS source must contain properties only, it must be,\n\t * for example, a content of CSS selector or text between nested\n\t * CSS sections\n\t * @param  {String} source CSS source\n\t * @param {Number} offset Offset of properties subset from original source.\n\t * Used to provide proper ranges of locates items\n\t */\n\tfunction extractPropertiesFromSource(source, offset) {\n\t\toffset = offset || 0;\n\t\tsource = source.replace(reSpaceEnd, '');\n\t\tvar out = [];\n\n\t\tif (!source) {\n\t\t\treturn out;\n\t\t}\n\n\t\tvar tokens = cssParser.parse(source);\n\t\tvar it = tokenIterator.create(tokens);\n\t\tvar property;\n\n\t\twhile ((property = consumeSingleProperty(it, source))) {\n\t\t\tout.push({\n\t\t\t\tnameText: property.name.substring(source),\n\t\t\t\tname: property.name.shift(offset),\n\n\t\t\t\tvalueText: property.value.substring(source),\n\t\t\t\tvalue: property.value.shift(offset),\n\n\t\t\t\tendText: property.end.substring(source),\n\t\t\t\tend: property.end.shift(offset)\n\t\t\t});\n\t\t}\n\n\t\treturn out;\n\t}\n\t\n\t/**\n\t * @class\n\t * @extends EditContainer\n\t */\n\tvar CSSEditContainer = editTree.EditContainer.extend({\n\t\tinitialize: function(source, options) {\n\t\t\tutils.extend(this.options, defaultOptions, options);\n\t\t\t\n\t\t\tif (Array.isArray(source)) {\n\t\t\t\tsource = cssParser.toSource(source);\n\t\t\t}\n\n\t\t\tvar allRules = cssSections.findAllRules(source);\n\t\t\tvar currentRule = allRules.shift();\n\n\t\t\t// keep top-level rules only since they will\n\t\t\t// be parsed by nested CSSEditContainer call\n\t\t\tvar topLevelRules = [];\n\t\t\tallRules.forEach(function(r) {\n\t\t\t\tvar isTopLevel = !utils.find(topLevelRules, function(tr) {\n\t\t\t\t\treturn tr.contains(r);\n\t\t\t\t});\n\n\t\t\t\tif (isTopLevel) {\n\t\t\t\t\ttopLevelRules.push(r);\n\t\t\t\t}\n\t\t\t});\n\n\n\t\t\tvar selectorRange = range.create2(currentRule.start, currentRule._selectorEnd);\n\t\t\tthis._name = selectorRange.substring(source);\n\t\t\tthis._positions.name = selectorRange.start;\n\t\t\tthis._positions.contentStart = currentRule._contentStart + 1;\n\n\t\t\tvar sectionOffset = currentRule._contentStart + 1;\n\t\t\tvar sectionEnd = currentRule.end - 1;\n\n\t\t\t// parse properties between nested rules\n\t\t\t// and add nested rules as children\n\t\t\tvar that = this;\n\t\t\ttopLevelRules.forEach(function(r) {\n\t\t\t\tconsumeProperties(that, source.substring(sectionOffset, r.start), sectionOffset);\n\t\t\t\tvar opt = utils.extend({}, that.options, {offset: r.start + that.options.offset});\n\t\t\t\t// XXX I think I don’t need nested containers here\n\t\t\t\t// They should be handled separately\n\t\t\t\t// that._children.push(new CSSEditContainer(r.substring(source), opt));\n\t\t\t\tsectionOffset = r.end;\n\t\t\t});\n\n\t\t\t// consume the rest of data\n\t\t\tconsumeProperties(this, source.substring(sectionOffset, currentRule.end - 1), sectionOffset);\n\t\t\tthis._saveStyle();\n\t\t},\n\t\t\n\t\t/**\n\t\t * Remembers all styles of properties\n\t\t * @private\n\t\t */\n\t\t_saveStyle: function() {\n\t\t\tvar start = this._positions.contentStart;\n\t\t\tvar source = this.source;\n\t\t\t\n\t\t\tthis.list().forEach(function(p) {\n\t\t\t\tif (p.type === 'container') {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tp.styleBefore = source.substring(start, p.namePosition());\n\t\t\t\t// a small hack here:\n\t\t\t\t// Sometimes users add empty lines before properties to logically\n\t\t\t\t// separate groups of properties. In this case, a blind copy of\n\t\t\t\t// characters between rules may lead to undesired behavior,\n\t\t\t\t// especially when current rule is duplicated or used as a donor\n\t\t\t\t// to create new rule.\n\t\t\t\t// To solve this issue, we‘ll take only last newline indentation\n\t\t\t\tvar lines = utils.splitByLines(p.styleBefore);\n\t\t\t\tif (lines.length > 1) {\n\t\t\t\t\tp.styleBefore = '\\n' + lines[lines.length - 1];\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tp.styleSeparator = source.substring(p.nameRange().end, p.valuePosition());\n\t\t\t\t\n\t\t\t\t// graceful and naive comments removal \n\t\t\t\tvar parts = p.styleBefore.split('*/');\n\t\t\t\tp.styleBefore = parts[parts.length - 1];\n\t\t\t\tp.styleSeparator = p.styleSeparator.replace(/\\/\\*.*?\\*\\//g, '');\n\t\t\t\t\n\t\t\t\tstart = p.range().end;\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Returns position of element name token\n\t\t * @param {Boolean} isAbsolute Return absolute position\n\t\t * @returns {Number}\n\t\t */\n\t\tnamePosition: function(isAbsolute) {\n\t\t\treturn this._pos(this._positions.name, isAbsolute);\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns position of element value token\n\t\t * @param {Boolean} isAbsolute Return absolute position\n\t\t * @returns {Number}\n\t\t */\n\t\tvaluePosition: function(isAbsolute) {\n\t\t\treturn this._pos(this._positions.contentStart, isAbsolute);\n\t\t},\n\n\t\t/**\n\t\t * Returns element value range\n\t\t * @param {Boolean} isAbsolute Return absolute range\n\t\t * @returns {Range}\n\t\t */\n\t\tvalueRange: function(isAbsolute) {\n\t\t\treturn range.create2(this.valuePosition(isAbsolute), this._pos(this.valueOf().length, isAbsolute) - 1);\n\t\t},\n\t\t\n\t\t/**\n\t\t * Adds new CSS property \n\t\t * @param {String} name Property name\n\t\t * @param {String} value Property value\n\t\t * @param {Number} pos Position at which to insert new property. By \n\t\t * default the property is inserted at the end of rule \n\t\t * @returns {CSSEditProperty}\n\t\t */\n\t\tadd: function(name, value, pos) {\n\t\t\tvar list = this.list();\n\t\t\tvar start = this._positions.contentStart;\n\t\t\tvar styles = utils.pick(this.options, 'styleBefore', 'styleSeparator');\n\t\t\t\n\t\t\tif (typeof pos === 'undefined') {\n\t\t\t\tpos = list.length;\n\t\t\t}\n\t\t\t\n\t\t\t/** @type CSSEditProperty */\n\t\t\tvar donor = list[pos];\n\t\t\tif (donor) {\n\t\t\t\tstart = donor.fullRange().start;\n\t\t\t} else if ((donor = list[pos - 1])) {\n\t\t\t\t// make sure that donor has terminating semicolon\n\t\t\t\tdonor.end(';');\n\t\t\t\tstart = donor.range().end;\n\t\t\t}\n\t\t\t\n\t\t\tif (donor) {\n\t\t\t\tstyles = utils.pick(donor, 'styleBefore', 'styleSeparator');\n\t\t\t}\n\t\t\t\n\t\t\tvar nameToken = editTree.createToken(start + styles.styleBefore.length, name);\n\t\t\tvar valueToken = editTree.createToken(nameToken.end + styles.styleSeparator.length, value);\n\t\t\t\n\t\t\tvar property = new CSSEditElement(this, nameToken, valueToken,\n\t\t\t\t\teditTree.createToken(valueToken.end, ';'));\n\t\t\t\n\t\t\tutils.extend(property, styles);\n\t\t\t\n\t\t\t// write new property into the source\n\t\t\tthis._updateSource(property.styleBefore + property.toString(), start);\n\t\t\t\n\t\t\t// insert new property\n\t\t\tthis._children.splice(pos, 0, property);\n\t\t\treturn property;\n\t\t}\n\t});\n\t\n\t/**\n\t * @class\n\t * @type CSSEditElement\n\t * @constructor\n\t */\n\tvar CSSEditElement = editTree.EditElement.extend({\n\t\tinitialize: function(rule, name, value, end) {\n\t\t\tthis.styleBefore = rule.options.styleBefore;\n\t\t\tthis.styleSeparator = rule.options.styleSeparator;\n\t\t\t\n\t\t\tthis._end = end.value;\n\t\t\tthis._positions.end = end.start;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns ranges of complex value parts\n\t\t * @returns {Array} Returns <code>null</code> if value is not complex\n\t\t */\n\t\tvalueParts: function(isAbsolute) {\n\t\t\tvar parts = findParts(this.value());\n\t\t\tif (isAbsolute) {\n\t\t\t\tvar offset = this.valuePosition(true);\n\t\t\t\tparts.forEach(function(p) {\n\t\t\t\t\tp.shift(offset);\n\t\t\t\t});\n\t\t\t}\n\t\t\t\n\t\t\treturn parts;\n\t\t},\n\n\t\t/**\n\t\t * Sets of gets element value. \n\t\t * When setting value, this implementation will ensure that your have \n\t\t * proper name-value separator\n\t\t * @param {String} val New element value. If not passed, current \n\t\t * value is returned\n\t\t * @returns {String}\n\t\t */\n\t\tvalue: function(val) {\n\t\t\tvar isUpdating = typeof val !== 'undefined';\n\t\t\tvar allItems = this.parent.list();\n\t\t\tif (isUpdating && this.isIncomplete()) {\n\t\t\t\tvar self = this;\n\t\t\t\tvar donor = utils.find(allItems, function(item) {\n\t\t\t\t\treturn item !== self && !item.isIncomplete();\n\t\t\t\t});\n\n\t\t\t\tthis.styleSeparator = donor \n\t\t\t\t\t? donor.styleSeparator \n\t\t\t\t\t: this.parent.options.styleSeparator;\n\t\t\t\tthis.parent._updateSource(this.styleSeparator, range(this.valueRange().start, 0));\n\t\t\t}\n\n\t\t\tvar value = this.constructor.__super__.value.apply(this, arguments);\n\t\t\tif (isUpdating) {\n\t\t\t\t// make sure current property has terminating semi-colon\n\t\t\t\t// if it’s not the last one\n\t\t\t\tvar ix = allItems.indexOf(this);\n\t\t\t\tif (ix !== allItems.length - 1 && !this.end()) {\n\t\t\t\t\tthis.end(';');\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn value;\n\t\t},\n\n\t\t/**\n\t\t * Test if current element is incomplete, e.g. has no explicit\n\t\t * name-value separator\n\t\t * @return {Boolean} [description]\n\t\t */\n\t\tisIncomplete: function() {\n\t\t\treturn this.nameRange().end === this.valueRange().start;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Sets of gets property end value (basically, it's a semicolon)\n\t\t * @param {String} val New end value. If not passed, current \n\t\t * value is returned\n\t\t */\n\t\tend: function(val) {\n\t\t\tif (typeof val !== 'undefined' && this._end !== val) {\n\t\t\t\tthis.parent._updateSource(val, this._positions.end, this._positions.end + this._end.length);\n\t\t\t\tthis._end = val;\n\t\t\t}\n\t\t\t\n\t\t\treturn this._end;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns full rule range, with indentation\n\t\t * @param {Boolean} isAbsolute Return absolute range (with respect of\n\t\t * rule offset)\n\t\t * @returns {Range}\n\t\t */\n\t\tfullRange: function(isAbsolute) {\n\t\t\tvar r = this.range(isAbsolute);\n\t\t\tr.start -= this.styleBefore.length;\n\t\t\treturn r;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns item string representation\n\t\t * @returns {String}\n\t\t */\n\t\tvalueOf: function() {\n\t\t\treturn this.name() + this.styleSeparator + this.value() + this.end();\n\t\t}\n\t});\n\t\n\treturn {\n\t\t/**\n\t\t * Parses CSS rule into editable tree\n\t\t * @param {String} source\n\t\t * @param {Object} options\n\t\t * @memberOf emmet.cssEditTree\n\t\t * @returns {EditContainer}\n\t\t */\n\t\tparse: function(source, options) {\n\t\t\treturn new CSSEditContainer(source, options);\n\t\t},\n\t\t\n\t\t/**\n\t\t * Extract and parse CSS rule from specified position in <code>content</code> \n\t\t * @param {String} content CSS source code\n\t\t * @param {Number} pos Character position where to start source code extraction\n\t\t * @returns {EditContainer}\n\t\t */\n\t\tparseFromPosition: function(content, pos, isBackward) {\n\t\t\tvar bounds = cssSections.locateRule(content, pos, isBackward);\n\t\t\tif (!bounds || !bounds.inside(pos)) {\n\t\t\t\t// no matching CSS rule or caret outside rule bounds\n\t\t\t\treturn null;\n\t\t\t}\n\t\t\t\n\t\t\treturn this.parse(bounds.substring(content), {\n\t\t\t\toffset: bounds.start\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Locates CSS property in given CSS code fragment under specified character position\n\t\t * @param  {String} css CSS code or parsed CSSEditContainer\n\t\t * @param  {Number} pos Character position where to search CSS property\n\t\t * @return {CSSEditElement}\n\t\t */\n\t\tpropertyFromPosition: function(css, pos) {\n\t\t\tvar cssProp = null;\n\t\t\t/** @type EditContainer */\n\t\t\tvar cssRule = typeof css === 'string' ? this.parseFromPosition(css, pos, true) : css;\n\t\t\tif (cssRule) {\n\t\t\t\tcssProp = cssRule.itemFromPosition(pos, true);\n\t\t\t\tif (!cssProp) {\n\t\t\t\t\t// in case user just started writing CSS property\n\t\t\t\t\t// and didn't include semicolon–try another approach\n\t\t\t\t\tcssProp = utils.find(cssRule.list(), function(elem) {\n\t\t\t\t\t\treturn elem.range(true).end == pos;\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn cssProp;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Removes vendor prefix from CSS property\n\t\t * @param {String} name CSS property\n\t\t * @return {String}\n\t\t */\n\t\tbaseName: function(name) {\n\t\t\treturn name.replace(/^\\s*\\-\\w+\\-/, '');\n\t\t},\n\t\t\n\t\t/**\n\t\t * Finds parts of complex CSS value\n\t\t * @param {String} str\n\t\t * @returns {Array}\n\t\t */\n\t\tfindParts: findParts,\n\n\t\textractPropertiesFromSource: extractPropertiesFromSource\n\t};\n});\n},{\"../assets/range\":\"assets\\\\range.js\",\"../assets/stringStream\":\"assets\\\\stringStream.js\",\"../assets/tokenIterator\":\"assets\\\\tokenIterator.js\",\"../parser/css\":\"parser\\\\css.js\",\"../utils/common\":\"utils\\\\common.js\",\"../utils/cssSections\":\"utils\\\\cssSections.js\",\"./base\":\"editTree\\\\base.js\"}],\"editTree\\\\xml.js\":[function(require,module,exports){\n/**\n * XML EditTree is a module that can parse an XML/HTML element into a tree with \n * convenient methods for adding, modifying and removing attributes. These \n * changes can be written back to string with respect of code formatting.\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar editTree = require('./base');\n\tvar xmlParser = require('../parser/xml');\n\tvar range = require('../assets/range');\n\tvar utils = require('../utils/common');\n\n\tvar defaultOptions = {\n\t\tstyleBefore: ' ',\n\t\tstyleSeparator: '=',\n\t\tstyleQuote: '\"',\n\t\toffset: 0\n\t};\n\t\n\tvar startTag = /^<([\\w\\:\\-]+)((?:\\s+[\\w\\-:]+(?:\\s*=\\s*(?:(?:\"[^\"]*\")|(?:'[^']*')|[^>\\s]+))?)*)\\s*(\\/?)>/m;\n\t\n\tvar XMLEditContainer = editTree.EditContainer.extend({\n\t\tinitialize: function(source, options) {\n\t\t\tutils.defaults(this.options, defaultOptions);\n\t\t\tthis._positions.name = 1;\n\t\t\t\n\t\t\tvar attrToken = null;\n\t\t\tvar tokens = xmlParser.parse(source);\n\t\t\t\n\t\t\ttokens.forEach(function(token) {\n\t\t\t\ttoken.value = range.create(token).substring(source);\n\t\t\t\tswitch (token.type) {\n\t\t\t\t\tcase 'tag':\n\t\t\t\t\t\tif (/^<[^\\/]+/.test(token.value)) {\n\t\t\t\t\t\t\tthis._name = token.value.substring(1);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\n\t\t\t\t\tcase 'attribute':\n\t\t\t\t\t\t// add empty attribute\n\t\t\t\t\t\tif (attrToken) {\n\t\t\t\t\t\t\tthis._children.push(new XMLEditElement(this, attrToken));\n\t\t\t\t\t\t}\n\t\t\t\t\t\t\n\t\t\t\t\t\tattrToken = token;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\n\t\t\t\t\tcase 'string':\n\t\t\t\t\t\tthis._children.push(new XMLEditElement(this, attrToken, token));\n\t\t\t\t\t\tattrToken = null;\n\t\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}, this);\n\t\t\t\n\t\t\tif (attrToken) {\n\t\t\t\tthis._children.push(new XMLEditElement(this, attrToken));\n\t\t\t}\n\t\t\t\n\t\t\tthis._saveStyle();\n\t\t},\n\t\t\n\t\t/**\n\t\t * Remembers all styles of properties\n\t\t * @private\n\t\t */\n\t\t_saveStyle: function() {\n\t\t\tvar start = this.nameRange().end;\n\t\t\tvar source = this.source;\n\t\t\t\n\t\t\tthis.list().forEach(function(p) {\n\t\t\t\tp.styleBefore = source.substring(start, p.namePosition());\n\t\t\t\t\n\t\t\t\tif (p.valuePosition() !== -1) {\n\t\t\t\t\tp.styleSeparator = source.substring(p.namePosition() + p.name().length, p.valuePosition() - p.styleQuote.length);\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tstart = p.range().end;\n\t\t\t});\n\t\t},\n\t\t\n\t\t/**\n\t\t * Adds new attribute \n\t\t * @param {String} name Property name\n\t\t * @param {String} value Property value\n\t\t * @param {Number} pos Position at which to insert new property. By \n\t\t * default the property is inserted at the end of rule \n\t\t */\n\t\tadd: function(name, value, pos) {\n\t\t\tvar list = this.list();\n\t\t\tvar start = this.nameRange().end;\n\t\t\tvar styles = utils.pick(this.options, 'styleBefore', 'styleSeparator', 'styleQuote');\n\t\t\t\n\t\t\tif (typeof pos === 'undefined') {\n\t\t\t\tpos = list.length;\n\t\t\t}\n\t\t\t\n\t\t\t\n\t\t\t/** @type XMLEditAttribute */\n\t\t\tvar donor = list[pos];\n\t\t\tif (donor) {\n\t\t\t\tstart = donor.fullRange().start;\n\t\t\t} else if ((donor = list[pos - 1])) {\n\t\t\t\tstart = donor.range().end;\n\t\t\t}\n\t\t\t\n\t\t\tif (donor) {\n\t\t\t\tstyles = utils.pick(donor, 'styleBefore', 'styleSeparator', 'styleQuote');\n\t\t\t}\n\t\t\t\n\t\t\tvalue = styles.styleQuote + value + styles.styleQuote;\n\t\t\t\n\t\t\tvar attribute = new XMLEditElement(this, \n\t\t\t\t\teditTree.createToken(start + styles.styleBefore.length, name),\n\t\t\t\t\teditTree.createToken(start + styles.styleBefore.length + name.length \n\t\t\t\t\t\t\t+ styles.styleSeparator.length, value)\n\t\t\t\t\t);\n\t\t\t\n\t\t\tutils.extend(attribute, styles);\n\t\t\t\n\t\t\t// write new attribute into the source\n\t\t\tthis._updateSource(attribute.styleBefore + attribute.toString(), start);\n\t\t\t\n\t\t\t// insert new attribute\n\t\t\tthis._children.splice(pos, 0, attribute);\n\t\t\treturn attribute;\n\t\t},\n\n\t\t/**\n\t\t * A special case of attribute editing: adds class value to existing\n\t\t * `class` attribute\n\t\t * @param {String} value\n\t\t */\n\t\taddClass: function(value) {\n\t\t\tvar attr = this.get('class');\n\t\t\tvalue = utils.trim(value);\n\t\t\tif (!attr) {\n\t\t\t\treturn this.add('class', value);\n\t\t\t}\n\n\t\t\tvar classVal = attr.value();\n\t\t\tvar classList = ' ' + classVal.replace(/\\n/g, ' ') + ' ';\n\t\t\tif (!~classList.indexOf(' ' + value + ' ')) {\n\t\t\t\tattr.value(classVal + ' ' + value);\n\t\t\t}\n\t\t},\n\n\t\t/**\n\t\t * A special case of attribute editing: removes class value from existing\n\t\t * `class` attribute\n\t\t * @param {String} value\n\t\t */\n\t\tremoveClass: function(value) {\n\t\t\tvar attr = this.get('class');\n\t\t\tvalue = utils.trim(value);\n\t\t\tif (!attr) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tvar reClass = new RegExp('(^|\\\\s+)' + utils.escapeForRegexp(value));\n\t\t\tvar classVal = attr.value().replace(reClass, '');\n\t\t\tif (!utils.trim(classVal)) {\n\t\t\t\tthis.remove('class');\n\t\t\t} else {\n\t\t\t\tattr.value(classVal);\n\t\t\t}\n\t\t}\n\t});\n\t\n\tvar XMLEditElement = editTree.EditElement.extend({\n\t\tinitialize: function(parent, nameToken, valueToken) {\n\t\t\tthis.styleBefore = parent.options.styleBefore;\n\t\t\tthis.styleSeparator = parent.options.styleSeparator;\n\t\t\t\n\t\t\tvar value = '', quote = parent.options.styleQuote;\n\t\t\tif (valueToken) {\n\t\t\t\tvalue = valueToken.value;\n\t\t\t\tquote = value.charAt(0);\n\t\t\t\tif (quote == '\"' || quote == \"'\") {\n\t\t\t\t\tvalue = value.substring(1);\n\t\t\t\t} else {\n\t\t\t\t\tquote = '';\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tif (quote && value.charAt(value.length - 1) == quote) {\n\t\t\t\t\tvalue = value.substring(0, value.length - 1);\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\tthis.styleQuote = quote;\n\t\t\t\n\t\t\tthis._value = value;\n\t\t\tthis._positions.value = valueToken ? valueToken.start + quote.length : -1;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns full rule range, with indentation\n\t\t * @param {Boolean} isAbsolute Return absolute range (with respect of\n\t\t * rule offset)\n\t\t * @returns {Range}\n\t\t */\n\t\tfullRange: function(isAbsolute) {\n\t\t\tvar r = this.range(isAbsolute);\n\t\t\tr.start -= this.styleBefore.length;\n\t\t\treturn r;\n\t\t},\n\t\t\n\t\tvalueOf: function() {\n\t\t\treturn this.name() + this.styleSeparator\n\t\t\t\t+ this.styleQuote + this.value() + this.styleQuote;\n\t\t}\n\t});\n\t\n\treturn {\n\t\t/**\n\t\t * Parses HTML element into editable tree\n\t\t * @param {String} source\n\t\t * @param {Object} options\n\t\t * @memberOf emmet.htmlEditTree\n\t\t * @returns {EditContainer}\n\t\t */\n\t\tparse: function(source, options) {\n\t\t\treturn new XMLEditContainer(source, options);\n\t\t},\n\t\t\n\t\t/**\n\t\t * Extract and parse HTML from specified position in <code>content</code> \n\t\t * @param {String} content CSS source code\n\t\t * @param {Number} pos Character position where to start source code extraction\n\t\t * @returns {XMLEditElement}\n\t\t */\n\t\tparseFromPosition: function(content, pos, isBackward) {\n\t\t\tvar bounds = this.extractTag(content, pos, isBackward);\n\t\t\tif (!bounds || !bounds.inside(pos))\n\t\t\t\t// no matching HTML tag or caret outside tag bounds\n\t\t\t\treturn null;\n\t\t\t\n\t\t\treturn this.parse(bounds.substring(content), {\n\t\t\t\toffset: bounds.start\n\t\t\t});\n\t\t},\n\t\t\n\t\t/**\n\t\t * Extracts nearest HTML tag range from <code>content</code>, starting at \n\t\t * <code>pos</code> position\n\t\t * @param {String} content\n\t\t * @param {Number} pos\n\t\t * @param {Boolean} isBackward\n\t\t * @returns {Range}\n\t\t */\n\t\textractTag: function(content, pos, isBackward) {\n\t\t\tvar len = content.length, i;\n\t\t\t\n\t\t\t// max extraction length. I don't think there may be tags larger \n\t\t\t// than 2000 characters length\n\t\t\tvar maxLen = Math.min(2000, len);\n\t\t\t\n\t\t\t/** @type Range */\n\t\t\tvar r = null;\n\t\t\t\n\t\t\tvar match = function(pos) {\n\t\t\t\tvar m;\n\t\t\t\tif (content.charAt(pos) == '<' && (m = content.substr(pos, maxLen).match(startTag)))\n\t\t\t\t\treturn range.create(pos, m[0]);\n\t\t\t};\n\t\t\t\n\t\t\t// lookup backward, in case we are inside tag already\n\t\t\tfor (i = pos; i >= 0; i--) {\n\t\t\t\tif ((r = match(i))) break;\n\t\t\t}\n\t\t\t\n\t\t\tif (r && (r.inside(pos) || isBackward))\n\t\t\t\treturn r;\n\t\t\t\n\t\t\tif (!r && isBackward)\n\t\t\t\treturn null;\n\t\t\t\n\t\t\t// search forward\n\t\t\tfor (i = pos; i < len; i++) {\n\t\t\t\tif ((r = match(i)))\n\t\t\t\t\treturn r;\n\t\t\t}\n\t\t}\n\t};\n});\n},{\"../assets/range\":\"assets\\\\range.js\",\"../parser/xml\":\"parser\\\\xml.js\",\"../utils/common\":\"utils\\\\common.js\",\"./base\":\"editTree\\\\base.js\"}],\"filter\\\\bem.js\":[function(require,module,exports){\n/**\n * Filter for aiding of writing elements with complex class names as described\n * in Yandex's BEM (Block, Element, Modifier) methodology. This filter will\n * automatically inherit block and element names from parent elements and insert\n * them into child element classes\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar htmlFilter = require('./html');\n\tvar prefs = require('../assets/preferences');\n\tvar abbreviationUtils = require('../utils/abbreviation');\n\tvar utils = require('../utils/common');\n\n\tprefs.define('bem.elementSeparator', '__', 'Class name’s element separator.');\n\tprefs.define('bem.modifierSeparator', '_', 'Class name’s modifier separator.');\n\tprefs.define('bem.shortElementPrefix', '-', \n\t\t\t'Symbol for describing short “block-element” notation. Class names '\n\t\t\t+ 'prefixed with this symbol will be treated as element name for parent‘s '\n\t\t\t+ 'block name. Each symbol instance traverses one level up in parsed ' \n\t\t\t+ 'tree for block name lookup. Empty value will disable short notation.');\n\t\n\tvar shouldRunHtmlFilter = false;\n\t\n\tfunction getSeparators() {\n\t\treturn {\n\t\t\telement: prefs.get('bem.elementSeparator'),\n\t\t\tmodifier: prefs.get('bem.modifierSeparator')\n\t\t};\n\t}\n\n\t/**\n\t * @param {AbbreviationNode} item\n\t */\n\tfunction bemParse(item) {\n\t\tif (abbreviationUtils.isSnippet(item))\n\t\t\treturn item;\n\t\t\n\t\t// save BEM stuff in cache for faster lookups\n\t\titem.__bem = {\n\t\t\tblock: '',\n\t\t\telement: '',\n\t\t\tmodifier: ''\n\t\t};\n\t\t\n\t\tvar classNames = normalizeClassName(item.attribute('class')).split(' ');\n\t\t\n\t\t// guess best match for block name\n\t\tvar reBlockName = /^[a-z]\\-/i;\n\t\titem.__bem.block = utils.find(classNames, function(name) {\n\t\t\treturn reBlockName.test(name);\n\t\t});\n\t\t\n\t\t// guessing doesn't worked, pick first class name as block name\n\t\tif (!item.__bem.block) {\n\t\t\treBlockName = /^[a-z]/i;\n\t\t\titem.__bem.block = utils.find(classNames, function(name) {\n\t\t\t\treturn reBlockName.test(name);\n\t\t\t}) || '';\n\t\t}\n\n\t\tclassNames = classNames.map(function(name) {\n\t\t\treturn processClassName(name, item);\n\t\t});\n\n\t\tclassNames = utils.unique(utils.flatten(classNames)).join(' ');\n\t\tif (classNames) {\n\t\t\titem.attribute('class', classNames);\n\t\t}\n\t\t\n\t\treturn item;\n\t}\n\t\n\t/**\n\t * @param {String} className\n\t * @returns {String}\n\t */\n\tfunction normalizeClassName(className) {\n\t\tclassName = (' ' + (className || '') + ' ').replace(/\\s+/g, ' ');\n\t\t\n\t\tvar shortSymbol = prefs.get('bem.shortElementPrefix');\n\t\tif (shortSymbol) {\n\t\t\tvar re = new RegExp('\\\\s(' + utils.escapeForRegexp(shortSymbol) + '+)', 'g');\n\t\t\tclassName = className.replace(re, function(str, p1) {\n\t\t\t\treturn ' ' + utils.repeatString(getSeparators().element, p1.length);\n\t\t\t});\n\t\t}\n\t\t\n\t\treturn utils.trim(className);\n\t}\n\t\n\t/**\n\t * Processes class name\n\t * @param {String} name Class name item to process\n\t * @param {AbbreviationNode} item Host node for provided class name\n\t * @returns Processed class name. May return <code>Array</code> of\n\t * class names \n\t */\n\tfunction processClassName(name, item) {\n\t\tname = transformClassName(name, item, 'element');\n\t\tname = transformClassName(name, item, 'modifier');\n\t\t\n\t\t// expand class name\n\t\t// possible values:\n\t\t// * block__element\n\t\t// * block__element_modifier\n\t\t// * block__element_modifier1_modifier2\n\t\t// * block_modifier\n\t\tvar block = '', element = '', modifier = '';\n\t\tvar separators = getSeparators();\n\t\tif (~name.indexOf(separators.element)) {\n\t\t\tvar elements = name.split(separators.element);\n\t\t\tblock = elements.shift();\n\n\t\t\tvar modifiers = elements.pop().split(separators.modifier);\n\t\t\telements.push(modifiers.shift());\n\t\t\telement = elements.join(separators.element);\n\t\t\tmodifier = modifiers.join(separators.modifier);\n\t\t} else if (~name.indexOf(separators.modifier)) {\n\t\t\tvar blockModifiers = name.split(separators.modifier);\n\t\t\t\n\t\t\tblock = blockModifiers.shift();\n\t\t\tmodifier = blockModifiers.join(separators.modifier);\n\t\t}\n\t\t\n\t\tif (block || element || modifier) {\n\t\t\tif (!block) {\n\t\t\t\tblock = item.__bem.block;\n\t\t\t}\n\t\t\t\n\t\t\t// inherit parent bem element, if exists\n//\t\t\tif (item.parent && item.parent.__bem && item.parent.__bem.element)\n//\t\t\t\telement = item.parent.__bem.element + separators.element + element;\n\t\t\t\n\t\t\t// produce multiple classes\n\t\t\tvar prefix = block;\n\t\t\tvar result = [];\n\t\t\t\n\t\t\tif (element) {\n\t\t\t\tprefix += separators.element + element;\n\t\t\t\tresult.push(prefix);\n\t\t\t} else {\n\t\t\t\tresult.push(prefix);\n\t\t\t}\n\t\t\t\n\t\t\tif (modifier) {\n\t\t\t\tresult.push(prefix + separators.modifier + modifier);\n\t\t\t}\n\t\t\t\n\t\t\tif (!item.__bem.block || modifier) {\n\t\t\t\titem.__bem.block = block;\n\t\t\t}\n\t\t\t\n\t\t\titem.__bem.element = element;\n\t\t\titem.__bem.modifier = modifier;\n\t\t\t\n\t\t\treturn result;\n\t\t}\n\t\t\n\t\t// ...otherwise, return processed or original class name\n\t\treturn name;\n\t}\n\t\n\t/**\n\t * Low-level function to transform user-typed class name into full BEM class\n\t * @param {String} name Class name item to process\n\t * @param {AbbreviationNode} item Host node for provided class name\n\t * @param {String} entityType Type of entity to be tried to transform \n\t * ('element' or 'modifier')\n\t * @returns {String} Processed class name or original one if it can't be\n\t * transformed\n\t */\n\tfunction transformClassName(name, item, entityType) {\n\t\tvar separators = getSeparators();\n\t\tvar reSep = new RegExp('^(' + separators[entityType] + ')+', 'g');\n\t\tif (reSep.test(name)) {\n\t\t\tvar depth = 0; // parent lookup depth\n\t\t\tvar cleanName = name.replace(reSep, function(str) {\n\t\t\t\tdepth = str.length / separators[entityType].length;\n\t\t\t\treturn '';\n\t\t\t});\n\t\t\t\n\t\t\t// find donor element\n\t\t\tvar donor = item;\n\t\t\twhile (donor.parent && depth--) {\n\t\t\t\tdonor = donor.parent;\n\t\t\t}\n\t\t\t\n\t\t\tif (!donor || !donor.__bem)\n\t\t\t\tdonor = item;\n\t\t\t\n\t\t\tif (donor && donor.__bem) {\n\t\t\t\tvar prefix = donor.__bem.block;\n\t\t\t\t\n\t\t\t\t// decide if we should inherit element name\n//\t\t\t\tif (entityType == 'element') {\n//\t\t\t\t\tvar curElem = cleanName.split(separators.modifier, 1)[0];\n//\t\t\t\t\tif (donor.__bem.element && donor.__bem.element != curElem)\n//\t\t\t\t\t\tprefix += separators.element + donor.__bem.element;\n//\t\t\t\t}\n\t\t\t\t\n\t\t\t\tif (entityType == 'modifier' &&  donor.__bem.element)\n\t\t\t\t\tprefix += separators.element + donor.__bem.element;\n\t\t\t\t\n\t\t\t\treturn prefix + separators[entityType] + cleanName;\n\t\t\t}\n\t\t}\n\t\t\n\t\treturn name;\n\t}\n\t\n\t/**\n\t * Recursive function for processing tags, which extends class names \n\t * according to BEM specs: http://bem.github.com/bem-method/pages/beginning/beginning.ru.html\n\t * <br><br>\n\t * It does several things:<br>\n\t * <ul>\n\t * <li>Expands complex class name (according to BEM symbol semantics):\n\t * .block__elem_modifier → .block.block__elem.block__elem_modifier\n\t * </li>\n\t * <li>Inherits block name on child elements: \n\t * .b-block > .__el > .__el → .b-block > .b-block__el > .b-block__el__el\n\t * </li>\n\t * <li>Treats first dash symbol as '__'</li>\n\t * <li>Double underscore (or typographic '–') is also treated as an element \n\t * level lookup, e.g. ____el will search for element definition in parent’s \n\t * parent element:\n\t * .b-block > .__el1 > .____el2 → .b-block > .b-block__el1 > .b-block__el2\n\t * </li>\n\t * </ul>\n\t * \n\t * @param {AbbreviationNode} tree\n\t * @param {Object} profile\n\t */\n\tfunction process(tree, profile) {\n\t\tif (tree.name) {\n\t\t\tbemParse(tree, profile);\n\t\t}\n\t\t\n\t\ttree.children.forEach(function(item) {\n\t\t\tprocess(item, profile);\n\t\t\tif (!abbreviationUtils.isSnippet(item) && item.start) {\n\t\t\t\tshouldRunHtmlFilter = true;\n\t\t\t}\n\t\t});\n\t\t\n\t\treturn tree;\n\t}\n\n\treturn function(tree, profile) {\n\t\tshouldRunHtmlFilter = false;\n\t\ttree = process(tree, profile);\n\t\t// in case 'bem' filter is applied after 'html' filter: run it again\n\t\t// to update output\n\t\tif (shouldRunHtmlFilter) {\n\t\t\ttree = htmlFilter(tree, profile);\n\t\t}\n\t\t\n\t\treturn tree;\n\t};\n});\n\n},{\"../assets/preferences\":\"assets\\\\preferences.js\",\"../utils/abbreviation\":\"utils\\\\abbreviation.js\",\"../utils/common\":\"utils\\\\common.js\",\"./html\":\"filter\\\\html.js\"}],\"filter\\\\comment.js\":[function(require,module,exports){\n/**\n * Comment important tags (with 'id' and 'class' attributes)\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar prefs = require('../assets/preferences');\n\tvar utils = require('../utils/common');\n\tvar template = require('../utils/template');\n\tvar abbrUtils = require('../utils/abbreviation');\n\tvar filterCore = require('./main');\n\t\n\tprefs.define('filter.commentAfter', \n\t\t\t'\\n<!-- /<%= attr(\"id\", \"#\") %><%= attr(\"class\", \".\") %> -->',\n\t\t\t'A definition of comment that should be placed <i>after</i> matched '\n\t\t\t+ 'element when <code>comment</code> filter is applied. This definition '\n\t\t\t+ 'is an ERB-style template passed to <code>_.template()</code> '\n\t\t\t+ 'function (see Underscore.js docs for details). In template context, '\n\t\t\t+ 'the following properties and functions are availabe:\\n'\n\t\t\t+ '<ul>'\n\t\t\t\n\t\t\t+ '<li><code>attr(name, before, after)</code> – a function that outputs' \n\t\t\t+ 'specified attribute value concatenated with <code>before</code> ' \n\t\t\t+ 'and <code>after</code> strings. If attribute doesn\\'t exists, the ' \n\t\t\t+ 'empty string will be returned.</li>'\n\t\t\t\n\t\t\t+ '<li><code>node</code> – current node (instance of <code>AbbreviationNode</code>)</li>'\n\t\t\t\n\t\t\t+ '<li><code>name</code> – name of current tag</li>'\n\t\t\t\n\t\t\t+ '<li><code>padding</code> – current string padding, can be used ' \n\t\t\t+ 'for formatting</li>'\n\t\t\t\n\t\t\t+'</ul>');\n\t\n\tprefs.define('filter.commentBefore', \n\t\t\t'',\n\t\t\t'A definition of comment that should be placed <i>before</i> matched '\n\t\t\t+ 'element when <code>comment</code> filter is applied. '\n\t\t\t+ 'For more info, read description of <code>filter.commentAfter</code> '\n\t\t\t+ 'property');\n\t\n\tprefs.define('filter.commentTrigger', 'id, class',\n\t\t\t'A comma-separated list of attribute names that should exist in abbreviatoin '\n\t\t\t+ 'where comment should be added. If you wish to add comment for '\n\t\t\t+ 'every element, set this option to <code>*</code>');\n\t\n\t/**\n\t * Add comments to tag\n\t * @param {AbbreviationNode} node\n\t */\n\tfunction addComments(node, templateBefore, templateAfter) {\n\t\t// check if comments should be added\n\t\tvar trigger = prefs.get('filter.commentTrigger');\n\t\tif (trigger != '*') {\n\t\t\tvar shouldAdd = utils.find(trigger.split(','), function(name) {\n\t\t\t\treturn !!node.attribute(utils.trim(name));\n\t\t\t});\n\n\t\t\tif (!shouldAdd) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t}\n\t\t\n\t\tvar ctx = {\n\t\t\tnode: node,\n\t\t\tname: node.name(),\n\t\t\tpadding: node.parent ? node.parent.padding : '',\n\t\t\tattr: function(name, before, after) {\n\t\t\t\tvar attr = node.attribute(name);\n\t\t\t\tif (attr) {\n\t\t\t\t\treturn (before || '') + attr + (after || '');\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\treturn '';\n\t\t\t}\n\t\t};\n\t\t\n\t\tvar nodeBefore = templateBefore ? templateBefore(ctx) : '';\n\t\tvar nodeAfter = templateAfter ? templateAfter(ctx) : '';\n\t\t\n\t\tnode.start = node.start.replace(/</, nodeBefore + '<');\n\t\tnode.end = node.end.replace(/>/, '>' + nodeAfter);\n\t}\n\t\n\tfunction process(tree, before, after) {\n\t\ttree.children.forEach(function(item) {\n\t\t\tif (abbrUtils.isBlock(item)) {\n\t\t\t\taddComments(item, before, after);\n\t\t\t}\n\t\t\t\n\t\t\tprocess(item, before, after);\n\t\t});\n\t\t\t\n\t\treturn tree;\n\t}\n\n\treturn function(tree) {\n\t\tvar templateBefore = template(prefs.get('filter.commentBefore'));\n\t\tvar templateAfter = template(prefs.get('filter.commentAfter'));\n\t\t\n\t\treturn process(tree, templateBefore, templateAfter);\n\t};\n});\n\n},{\"../assets/preferences\":\"assets\\\\preferences.js\",\"../utils/abbreviation\":\"utils\\\\abbreviation.js\",\"../utils/common\":\"utils\\\\common.js\",\"../utils/template\":\"utils\\\\template.js\",\"./main\":\"filter\\\\main.js\"}],\"filter\\\\css.js\":[function(require,module,exports){\n/**\n * Filter for outputting CSS and alike\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\t/**\n\t * Test if passed item is very first child in parsed tree\n\t * @param {AbbreviationNode} item\n\t */\n\tfunction isVeryFirstChild(item) {\n\t\treturn item.parent && !item.parent.parent && !item.index();\n\t}\n\n\treturn function process(tree, profile, level) {\n\t\tlevel = level || 0;\n\t\t\n\t\ttree.children.forEach(function(item) {\n\t\t\tif (!isVeryFirstChild(item) && profile.tag_nl !== false) {\n\t\t\t\titem.start = '\\n' + item.start;\n\t\t\t}\n\t\t\tprocess(item, profile, level + 1);\n\t\t});\n\t\t\n\t\treturn tree;\n\t};\n});\n},{}],\"filter\\\\escape.js\":[function(require,module,exports){\n/**\n * Filter for escaping unsafe XML characters: <, >, &\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar charMap = {\n\t\t'<': '&lt;',\n\t\t'>': '&gt;',\n\t\t'&': '&amp;'\n\t};\n\t\n\tfunction escapeChars(str) {\n\t\treturn str.replace(/([<>&])/g, function(str, p1){\n\t\t\treturn charMap[p1];\n\t\t});\n\t}\n\t\n\treturn function process(tree) {\n\t\ttree.children.forEach(function(item) {\n\t\t\titem.start = escapeChars(item.start);\n\t\t\titem.end = escapeChars(item.end);\n\t\t\titem.content = escapeChars(item.content);\n\t\t\tprocess(item);\n\t\t});\n\t\t\n\t\treturn tree;\n\t};\n});\n},{}],\"filter\\\\format.js\":[function(require,module,exports){\n/**\n * Generic formatting filter: creates proper indentation for each tree node,\n * placing \"%s\" placeholder where the actual output should be. You can use\n * this filter to preformat tree and then replace %s placeholder to whatever you\n * need. This filter should't be called directly from editor as a part \n * of abbreviation.\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar utils = require('../utils/common');\n\tvar abbrUtils = require('../utils/abbreviation');\n\tvar prefs = require('../assets/preferences');\n\tvar resources = require('../assets/resources');\n\n\tprefs.define('format.noIndentTags', 'html', \n\t\t\t'A comma-separated list of tag names that should not get inner indentation.');\n\t\n\tprefs.define('format.forceIndentationForTags', 'body', \n\t\t'A comma-separated list of tag names that should <em>always</em> get inner indentation.');\n\n\tvar placeholder = '%s';\n\t\n\t/**\n\t * Get indentation for given node\n\t * @param {AbbreviationNode} node\n\t * @returns {String}\n\t */\n\tfunction getIndentation(node) {\n\t\tvar items = prefs.getArray('format.noIndentTags') || [];\n\t\tif (~items.indexOf(node.name())) {\n\t\t\treturn '';\n\t\t}\n\t\t\n\t\treturn '\\t';\n\t}\n\t\n\t/**\n\t * Test if passed node has block-level sibling element\n\t * @param {AbbreviationNode} item\n\t * @return {Boolean}\n\t */\n\tfunction hasBlockSibling(item) {\n\t\treturn item.parent && abbrUtils.hasBlockChildren(item.parent);\n\t}\n\t\n\t/**\n\t * Test if passed item is very first child in parsed tree\n\t * @param {AbbreviationNode} item\n\t */\n\tfunction isVeryFirstChild(item) {\n\t\treturn item.parent && !item.parent.parent && !item.index();\n\t}\n\t\n\t/**\n\t * Check if a newline should be added before element\n\t * @param {AbbreviationNode} node\n\t * @param {OutputProfile} profile\n\t * @return {Boolean}\n\t */\n\tfunction shouldAddLineBreak(node, profile) {\n\t\tif (profile.tag_nl === true || abbrUtils.isBlock(node))\n\t\t\treturn true;\n\t\t\n\t\tif (!node.parent || !profile.inline_break)\n\t\t\treturn false;\n\t\t\n\t\t// check if there are required amount of adjacent inline element\n\t\treturn shouldFormatInline(node.parent, profile);\n}\n\t\n\t/**\n\t * Need to add newline because <code>item</code> has too many inline children\n\t * @param {AbbreviationNode} node\n\t * @param {OutputProfile} profile\n\t */\n\tfunction shouldBreakChild(node, profile) {\n\t\t// we need to test only one child element, because \n\t\t// hasBlockChildren() method will do the rest\n\t\treturn node.children.length && shouldAddLineBreak(node.children[0], profile);\n\t}\n\t\n\tfunction shouldFormatInline(node, profile) {\n\t\tvar nodeCount = 0;\n\t\treturn !!utils.find(node.children, function(child) {\n\t\t\tif (child.isTextNode() || !abbrUtils.isInline(child))\n\t\t\t\tnodeCount = 0;\n\t\t\telse if (abbrUtils.isInline(child))\n\t\t\t\tnodeCount++;\n\t\t\t\n\t\t\tif (nodeCount >= profile.inline_break)\n\t\t\t\treturn true;\n\t\t});\n\t}\n\t\n\tfunction isRoot(item) {\n\t\treturn !item.parent;\n\t}\n\t\n\t/**\n\t * Processes element with matched resource of type <code>snippet</code>\n\t * @param {AbbreviationNode} item\n\t * @param {OutputProfile} profile\n\t */\n\tfunction processSnippet(item, profile) {\n\t\titem.start = item.end = '';\n\t\tif (!isVeryFirstChild(item) && profile.tag_nl !== false && shouldAddLineBreak(item, profile)) {\n\t\t\t// check if we’re not inside inline element\n\t\t\tif (isRoot(item.parent) || !abbrUtils.isInline(item.parent)) {\n\t\t\t\titem.start = '\\n' + item.start;\n\t\t\t}\n\t\t}\n\t\t\n\t\treturn item;\n\t}\n\t\n\t/**\n\t * Check if we should add line breaks inside inline element\n\t * @param {AbbreviationNode} node\n\t * @param {OutputProfile} profile\n\t * @return {Boolean}\n\t */\n\tfunction shouldBreakInsideInline(node, profile) {\n\t\tvar hasBlockElems = node.children.some(function(child) {\n\t\t\tif (abbrUtils.isSnippet(child))\n\t\t\t\treturn false;\n\t\t\t\n\t\t\treturn !abbrUtils.isInline(child);\n\t\t});\n\t\t\n\t\tif (!hasBlockElems) {\n\t\t\treturn shouldFormatInline(node, profile);\n\t\t}\n\t\t\n\t\treturn true;\n\t}\n\t\n\t/**\n\t * Processes element with <code>tag</code> type\n\t * @param {AbbreviationNode} item\n\t * @param {OutputProfile} profile\n\t */\n\tfunction processTag(item, profile) {\n\t\titem.start = item.end = placeholder;\n\t\tvar isUnary = abbrUtils.isUnary(item);\n\t\tvar nl = '\\n';\n\t\tvar indent = getIndentation(item);\n\t\t\t\n\t\t// formatting output\n\t\tif (profile.tag_nl !== false) {\n\t\t\tvar forceNl = profile.tag_nl === true && (profile.tag_nl_leaf || item.children.length);\n\t\t\tif (!forceNl) {\n\t\t\t\tvar forceIndentTags = prefs.getArray('format.forceIndentationForTags') || [];\n\t\t\t\tforceNl = ~forceIndentTags.indexOf(item.name());\n\t\t\t}\n\t\t\t\n\t\t\t// formatting block-level elements\n\t\t\tif (!item.isTextNode()) {\n\t\t\t\tif (shouldAddLineBreak(item, profile)) {\n\t\t\t\t\t// - do not indent the very first element\n\t\t\t\t\t// - do not indent first child of a snippet\n\t\t\t\t\tif (!isVeryFirstChild(item) && (!abbrUtils.isSnippet(item.parent) || item.index()))\n\t\t\t\t\t\titem.start = nl + item.start;\n\t\t\t\t\t\t\n\t\t\t\t\tif (abbrUtils.hasBlockChildren(item) || shouldBreakChild(item, profile) || (forceNl && !isUnary))\n\t\t\t\t\t\titem.end = nl + item.end;\n\t\t\t\t\t\t\n\t\t\t\t\tif (abbrUtils.hasTagsInContent(item) || (forceNl && !item.children.length && !isUnary))\n\t\t\t\t\t\titem.start += nl + indent;\n\t\t\t\t} else if (abbrUtils.isInline(item) && hasBlockSibling(item) && !isVeryFirstChild(item)) {\n\t\t\t\t\titem.start = nl + item.start;\n\t\t\t\t} else if (abbrUtils.isInline(item) && shouldBreakInsideInline(item, profile)) {\n\t\t\t\t\titem.end = nl + item.end;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\titem.padding = indent;\n\t\t\t}\n\t\t}\n\t\t\n\t\treturn item;\n\t}\n\n\t/**\n\t * Processes simplified tree, making it suitable for output as HTML structure\n\t * @param {AbbreviationNode} tree\n\t * @param {OutputProfile} profile\n\t * @param {Number} level Depth level\n\t */\n\treturn function process(tree, profile, level) {\n\t\tlevel = level || 0;\n\t\n\t\ttree.children.forEach(function(item) {\n\t\t\tif (abbrUtils.isSnippet(item)) {\n\t\t\t\tprocessSnippet(item, profile, level);\n\t\t\t} else {\n\t\t\t\tprocessTag(item, profile, level);\n\t\t\t}\n\t\t\t\n\t\t\tprocess(item, profile, level + 1);\n\t\t});\n\t\t\n\t\treturn tree;\n\t};\n});\n},{\"../assets/preferences\":\"assets\\\\preferences.js\",\"../assets/resources\":\"assets\\\\resources.js\",\"../utils/abbreviation\":\"utils\\\\abbreviation.js\",\"../utils/common\":\"utils\\\\common.js\"}],\"filter\\\\haml.js\":[function(require,module,exports){\n/**\n * Filter for producing HAML code from abbreviation.\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar utils = require('../utils/common');\n\tvar abbrUtils = require('../utils/abbreviation');\n\tvar formatFilter = require('./format');\n\n\tfunction transformClassName(className) {\n\t\treturn utils.trim(className).replace(/\\s+/g, '.');\n\t}\n\n\t/**\n\t * Condenses all \"data-\" attributes into a single entry.\n\t * HAML allows data attributes to be ouputted as a sub-hash\n\t * of `:data` key\n\t * @param  {Array} attrs\n\t * @return {Array}\n\t */\n\tfunction condenseDataAttrs(attrs) {\n\t\tvar out = [], data = null;\n\t\tvar reData = /^data-/i;\n\t\tattrs.forEach(function(attr) {\n\t\t\tif (reData.test(attr.name)) {\n\t\t\t\tif (!data) {\n\t\t\t\t\tdata = [];\n\t\t\t\t\tout.push({\n\t\t\t\t\t\tname: 'data',\n\t\t\t\t\t\tvalue: data\n\t\t\t\t\t});\n\t\t\t\t}\n\n\t\t\t\tdata.push(utils.extend({}, attr, {name: attr.name.replace(reData, '')}));\n\t\t\t} else {\n\t\t\t\tout.push(attr);\n\t\t\t}\n\t\t});\n\n\t\treturn out;\n\t}\n\n\tfunction stringifyAttrs(attrs, profile) {\n\t\tvar attrQuote = profile.attributeQuote();\n\t\treturn '{' + attrs.map(function(attr) {\n\t\t\tvar value = attrQuote + attr.value + attrQuote;\n\t\t\tif (Array.isArray(attr.value)) {\n\t\t\t\tvalue = stringifyAttrs(attr.value, profile);\n\t\t\t} else if (attr.isBoolean) {\n\t\t\t\tvalue = 'true';\n\t\t\t}\n\n\t\t\treturn ':' + attr.name + ' => ' + value\n\t\t}).join(', ') + '}';\n\t}\n\t\n\t/**\n\t * Creates HAML attributes string from tag according to profile settings\n\t * @param {AbbreviationNode} tag\n\t * @param {Object} profile\n\t */\n\tfunction makeAttributesString(tag, profile) {\n\t\tvar attrs = '';\n\t\tvar otherAttrs = [];\n\t\tvar attrQuote = profile.attributeQuote();\n\t\tvar cursor = profile.cursor();\n\t\t\n\t\ttag.attributeList().forEach(function(a) {\n\t\t\tvar attrName = profile.attributeName(a.name);\n\t\t\tswitch (attrName.toLowerCase()) {\n\t\t\t\t// use short notation for ID and CLASS attributes\n\t\t\t\tcase 'id':\n\t\t\t\t\tattrs += '#' + (a.value || cursor);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 'class':\n\t\t\t\t\tattrs += '.' + transformClassName(a.value || cursor);\n\t\t\t\t\tbreak;\n\t\t\t\t// process other attributes\n\t\t\t\tdefault:\n\t\t\t\t\totherAttrs.push({\n\t\t\t\t\t\tname: attrName,\n\t\t\t\t\t\tvalue: a.value || cursor,\n\t\t\t\t\t\tisBoolean: profile.isBoolean(a.name, a.value)\n\t\t\t\t\t});\n\t\t\t}\n\t\t});\n\t\t\n\t\tif (otherAttrs.length) {\n\t\t\tattrs += stringifyAttrs(condenseDataAttrs(otherAttrs), profile);\n\t\t}\n\t\t\n\t\treturn attrs;\n\t}\n\t\n\t/**\n\t * Processes element with <code>tag</code> type\n\t * @param {AbbreviationNode} item\n\t * @param {OutputProfile} profile\n\t */\n\tfunction processTag(item, profile) {\n\t\tif (!item.parent)\n\t\t\t// looks like it's root element\n\t\t\treturn item;\n\t\t\n\t\tvar attrs = makeAttributesString(item, profile);\n\t\tvar cursor = profile.cursor();\n\t\tvar isUnary = abbrUtils.isUnary(item);\n\t\tvar selfClosing = profile.self_closing_tag && isUnary ? '/' : '';\n\t\tvar start= '';\n\t\t\t\n\t\t// define tag name\n\t\tvar tagName = '%' + profile.tagName(item.name());\n\t\tif (tagName.toLowerCase() == '%div' && attrs && attrs.indexOf('{') == -1)\n\t\t\t// omit div tag\n\t\t\ttagName = '';\n\t\t\t\n\t\titem.end = '';\n\t\tstart = tagName + attrs + selfClosing;\n\t\tif (item.content && !/^\\s/.test(item.content)) {\n\t\t\titem.content = ' ' + item.content;\n\t\t}\n\t\t\n\t\tvar placeholder = '%s';\n\t\t// We can't just replace placeholder with new value because\n\t\t// JavaScript will treat double $ character as a single one, assuming\n\t\t// we're using RegExp literal.\n\t\titem.start = utils.replaceSubstring(item.start, start, item.start.indexOf(placeholder), placeholder);\n\t\t\n\t\tif (!item.children.length && !isUnary)\n\t\t\titem.start += cursor;\n\t\t\n\t\treturn item;\n\t}\n\n\treturn function process(tree, profile, level) {\n\t\tlevel = level || 0;\n\t\t\n\t\tif (!level) {\n\t\t\ttree = formatFilter(tree, '_format', profile);\n\t\t}\n\t\t\n\t\ttree.children.forEach(function(item) {\n\t\t\tif (!abbrUtils.isSnippet(item)) {\n\t\t\t\tprocessTag(item, profile, level);\n\t\t\t}\n\t\t\t\n\t\t\tprocess(item, profile, level + 1);\n\t\t});\n\t\t\n\t\treturn tree;\n\t};\n});\n},{\"../utils/abbreviation\":\"utils\\\\abbreviation.js\",\"../utils/common\":\"utils\\\\common.js\",\"./format\":\"filter\\\\format.js\"}],\"filter\\\\html.js\":[function(require,module,exports){\n/**\n * Filter that produces HTML tree\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar abbrUtils = require('../utils/abbreviation');\n\tvar utils = require('../utils/common');\n\tvar tabStops = require('../assets/tabStops');\n\tvar formatFilter = require('./format');\n\n\t/**\n\t * Creates HTML attributes string from tag according to profile settings\n\t * @param {AbbreviationNode} node\n\t * @param {OutputProfile} profile\n\t */\n\tfunction makeAttributesString(node, profile) {\n\t\tvar attrQuote = profile.attributeQuote();\n\t\tvar cursor = profile.cursor();\n\t\t\n\t\treturn node.attributeList().map(function(a) {\n\t\t\tvar isBoolean = profile.isBoolean(a.name, a.value);\n\t\t\tvar attrName = profile.attributeName(a.name);\n\t\t\tvar attrValue = isBoolean ? attrName : a.value;\n\t\t\tif (isBoolean && profile.allowCompactBoolean()) {\n\t\t\t\treturn ' ' + attrName;\n\t\t\t}\n\t\t\treturn ' ' + attrName + '=' + attrQuote + (attrValue || cursor) + attrQuote;\n\t\t}).join('');\n\t}\n\t\n\t/**\n\t * Processes element with <code>tag</code> type\n\t * @param {AbbreviationNode} item\n\t * @param {OutputProfile} profile\n\t */\n\tfunction processTag(item, profile) {\n\t\tif (!item.parent) { // looks like it's root element\n\t\t\treturn item;\n\t\t}\n\t\t\n\t\tvar attrs = makeAttributesString(item, profile); \n\t\tvar cursor = profile.cursor();\n\t\tvar isUnary = abbrUtils.isUnary(item);\n\t\tvar start = '';\n\t\tvar end = '';\n\t\t\t\n\t\t// define opening and closing tags\n\t\tif (!item.isTextNode()) {\n\t\t\tvar tagName = profile.tagName(item.name());\n\t\t\tif (isUnary) {\n\t\t\t\tstart = '<' + tagName + attrs + profile.selfClosing() + '>';\n\t\t\t\titem.end = '';\n\t\t\t} else {\n\t\t\t\tstart = '<' + tagName + attrs + '>';\n\t\t\t\tend = '</' + tagName + '>';\n\t\t\t}\n\t\t}\n\t\t\n\t\tvar placeholder = '%s';\n\t\t// We can't just replace placeholder with new value because\n\t\t// JavaScript will treat double $ character as a single one, assuming\n\t\t// we're using RegExp literal.\n\t\titem.start = utils.replaceSubstring(item.start, start, item.start.indexOf(placeholder), placeholder);\n\t\titem.end = utils.replaceSubstring(item.end, end, item.end.indexOf(placeholder), placeholder);\n\t\t\n\t\t// should we put caret placeholder after opening tag?\n\t\tif (\n\t\t\t\t!item.children.length \n\t\t\t\t&& !isUnary \n\t\t\t\t&& !~item.content.indexOf(cursor)\n\t\t\t\t&& !tabStops.extract(item.content).tabstops.length\n\t\t\t) {\n\t\t\titem.start += cursor;\n\t\t}\n\t\t\n\t\treturn item;\n\t}\n\n\treturn function process(tree, profile, level) {\n\t\tlevel = level || 0;\n\t\t\n\t\tif (!level) {\n\t\t\ttree = formatFilter(tree, profile, level)\n\t\t}\n\t\t\n\t\ttree.children.forEach(function(item) {\n\t\t\tif (!abbrUtils.isSnippet(item)) {\n\t\t\t\tprocessTag(item, profile, level);\n\t\t\t}\n\t\t\t\n\t\t\tprocess(item, profile, level + 1);\n\t\t});\n\t\t\n\t\treturn tree;\n\t};\n});\n},{\"../assets/tabStops\":\"assets\\\\tabStops.js\",\"../utils/abbreviation\":\"utils\\\\abbreviation.js\",\"../utils/common\":\"utils\\\\common.js\",\"./format\":\"filter\\\\format.js\"}],\"filter\\\\jade.js\":[function(require,module,exports){\n/**\n * Filter for producing Jade code from abbreviation.\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar utils = require('../utils/common');\n\tvar abbrUtils = require('../utils/abbreviation');\n\tvar formatFilter = require('./format');\n\tvar tabStops = require('../assets/tabStops');\n\tvar profile = require('../assets/profile');\n\n\tvar reNl = /[\\n\\r]/;\n\tvar reIndentedText = /^\\s*\\|/;\n\tvar reSpace = /^\\s/;\n\n\tfunction transformClassName(className) {\n\t\treturn utils.trim(className).replace(/\\s+/g, '.');\n\t}\n\n\tfunction stringifyAttrs(attrs, profile) {\n\t\tvar attrQuote = profile.attributeQuote();\n\t\treturn '(' + attrs.map(function(attr) {\n\t\t\tif (attr.isBoolean) {\n\t\t\t\treturn attr.name;\n\t\t\t}\n\n\t\t\treturn attr.name + '=' + attrQuote + attr.value + attrQuote;\n\t\t}).join(', ') + ')';\n\t}\n\t\n\t/**\n\t * Creates HAML attributes string from tag according to profile settings\n\t * @param {AbbreviationNode} tag\n\t * @param {Object} profile\n\t */\n\tfunction makeAttributesString(tag, profile) {\n\t\tvar attrs = '';\n\t\tvar otherAttrs = [];\n\t\tvar attrQuote = profile.attributeQuote();\n\t\tvar cursor = profile.cursor();\n\t\t\n\t\ttag.attributeList().forEach(function(a) {\n\t\t\tvar attrName = profile.attributeName(a.name);\n\t\t\tswitch (attrName.toLowerCase()) {\n\t\t\t\t// use short notation for ID and CLASS attributes\n\t\t\t\tcase 'id':\n\t\t\t\t\tattrs += '#' + (a.value || cursor);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 'class':\n\t\t\t\t\tattrs += '.' + transformClassName(a.value || cursor);\n\t\t\t\t\tbreak;\n\t\t\t\t// process other attributes\n\t\t\t\tdefault:\n\t\t\t\t\totherAttrs.push({\n\t\t\t\t\t\tname: attrName,\n\t\t\t\t\t\tvalue: a.value || cursor,\n\t\t\t\t\t\tisBoolean: profile.isBoolean(a.name, a.value)\n\t\t\t\t\t});\n\t\t\t}\n\t\t});\n\t\t\n\t\tif (otherAttrs.length) {\n\t\t\tattrs += stringifyAttrs(otherAttrs, profile);\n\t\t}\n\t\t\n\t\treturn attrs;\n\t}\n\n\tfunction processTagContent(item) {\n\t\tif (!item.content) {\n\t\t\treturn;\n\t\t}\n\n\t\tvar content = tabStops.replaceVariables(item.content, function(str, name) {\n\t\t\tif (name === 'nl' || name === 'newline') {\n\t\t\t\treturn '\\n';\n\t\t\t}\n\t\t\treturn str;\n\t\t});\n\n\t\tif (reNl.test(content) && !reIndentedText.test(content)) {\n\t\t\t// multiline content: pad it with indentation and pipe\n\t\t\tvar pad = '| ';\n\t\t\titem.content = '\\n' + pad + utils.padString(content, pad);\n\t\t} else if (!reSpace.test(content)) {\n\t\t\titem.content = ' ' + content;\n\t\t}\n\t}\n\t\n\t/**\n\t * Processes element with <code>tag</code> type\n\t * @param {AbbreviationNode} item\n\t * @param {OutputProfile} profile\n\t */\n\tfunction processTag(item, profile) {\n\t\tif (!item.parent)\n\t\t\t// looks like it's a root (empty) element\n\t\t\treturn item;\n\t\t\n\t\tvar attrs = makeAttributesString(item, profile);\n\t\tvar cursor = profile.cursor();\n\t\tvar isUnary = abbrUtils.isUnary(item);\n\t\t\t\n\t\t// define tag name\n\t\tvar tagName = profile.tagName(item.name());\n\t\tif (tagName.toLowerCase() == 'div' && attrs && attrs.charAt(0) != '(')\n\t\t\t// omit div tag\n\t\t\ttagName = '';\n\t\t\t\n\t\titem.end = '';\n\t\tvar start = tagName + attrs;\n\t\tprocessTagContent(item);\n\n\t\tvar placeholder = '%s';\n\t\t// We can't just replace placeholder with new value because\n\t\t// JavaScript will treat double $ character as a single one, assuming\n\t\t// we're using RegExp literal.\n\t\titem.start = utils.replaceSubstring(item.start, start, item.start.indexOf(placeholder), placeholder);\n\t\t\n\t\tif (!item.children.length && !isUnary)\n\t\t\titem.start += cursor;\n\t\t\n\t\treturn item;\n\t}\n\n\treturn function process(tree, curProfile, level) {\n\t\tlevel = level || 0;\n\t\t\n\t\tif (!level) {\n\t\t\t// always format with `xml` profile since\n\t\t\t// Jade requires all tags to be on separate lines\n\t\t\ttree = formatFilter(tree, profile.get('xml'));\n\t\t}\n\t\t\n\t\ttree.children.forEach(function(item) {\n\t\t\tif (!abbrUtils.isSnippet(item)) {\n\t\t\t\tprocessTag(item, curProfile, level);\n\t\t\t}\n\t\t\t\n\t\t\tprocess(item, curProfile, level + 1);\n\t\t});\n\t\t\n\t\treturn tree;\n\t};\n});\n},{\"../assets/profile\":\"assets\\\\profile.js\",\"../assets/tabStops\":\"assets\\\\tabStops.js\",\"../utils/abbreviation\":\"utils\\\\abbreviation.js\",\"../utils/common\":\"utils\\\\common.js\",\"./format\":\"filter\\\\format.js\"}],\"filter\\\\jsx.js\":[function(require,module,exports){\n/**\n * A filter for React.js (JSX):\n * ranames attributes like `class` and `for`\n * for proper representation in JSX\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar attrMap = {\n\t\t'class': 'className',\n\t\t'for': 'htmlFor'\n\t};\n\n\treturn function process(tree) {\n\t\ttree.children.forEach(function(item) {\n\t\t\titem._attributes.forEach(function(attr) {\n\t\t\t\tif (attr.name in attrMap) {\n\t\t\t\t\tattr.name = attrMap[attr.name]\n\t\t\t\t}\n\t\t\t});\n\t\t\tprocess(item);\n\t\t});\n\n\t\treturn tree;\n\t};\n});\n},{}],\"filter\\\\main.js\":[function(require,module,exports){\n/**\n * Module for handling filters\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar utils = require('../utils/common');\n\tvar profile = require('../assets/profile');\n\tvar resources = require('../assets/resources');\n\n\t/** List of registered filters */\n\tvar registeredFilters = {\n\t\thtml: require('./html'),\n\t\thaml: require('./haml'),\n\t\tjade: require('./jade'),\n\t\tjsx: require('./jsx'),\n\t\tslim: require('./slim'),\n\t\txsl: require('./xsl'),\n\t\tcss: require('./css'),\n\t\tbem: require('./bem'),\n\t\tc: require('./comment'),\n\t\te: require('./escape'),\n\t\ts: require('./singleLine'),\n\t\tt: require('./trim')\n\t};\n\t\n\t/** Filters that will be applied for unknown syntax */\n\tvar basicFilters = 'html';\n\t\n\tfunction list(filters) {\n\t\tif (!filters)\n\t\t\treturn [];\n\t\t\n\t\tif (typeof filters === 'string') {\n\t\t\treturn filters.split(/[\\|,]/g);\n\t\t}\n\t\t\n\t\treturn filters;\n\t}\n\t\n\treturn  {\n\t\t/**\n\t\t * Register new filter\n\t\t * @param {String} name Filter name\n\t\t * @param {Function} fn Filter function\n\t\t */\n\t\tadd: function(name, fn) {\n\t\t\tregisteredFilters[name] = fn;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Apply filters for final output tree\n\t\t * @param {AbbreviationNode} tree Output tree\n\t\t * @param {Array} filters List of filters to apply. Might be a \n\t\t * <code>String</code>\n\t\t * @param {Object} profile Output profile, defined in <i>profile</i> \n\t\t * module. Filters defined it profile are not used, <code>profile</code>\n\t\t * is passed to filter function\n\t\t * @memberOf emmet.filters\n\t\t * @returns {AbbreviationNode}\n\t\t */\n\t\tapply: function(tree, filters, profileName) {\n\t\t\tprofileName = profile.get(profileName);\n\t\t\t\n\t\t\tlist(filters).forEach(function(filter) {\n\t\t\t\tvar name = utils.trim(filter.toLowerCase());\n\t\t\t\tif (name && name in registeredFilters) {\n\t\t\t\t\ttree = registeredFilters[name](tree, profileName);\n\t\t\t\t}\n\t\t\t});\n\t\t\t\n\t\t\treturn tree;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Composes list of filters that should be applied to a tree, based on \n\t\t * passed data\n\t\t * @param {String} syntax Syntax name ('html', 'css', etc.)\n\t\t * @param {Object} profile Output profile\n\t\t * @param {String} additionalFilters List or pipe-separated\n\t\t * string of additional filters to apply\n\t\t * @returns {Array}\n\t\t */\n\t\tcomposeList: function(syntax, profileName, additionalFilters) {\n\t\t\tprofileName = profile.get(profileName);\n\t\t\tvar filters = list(profileName.filters || resources.findItem(syntax, 'filters') || basicFilters);\n\t\t\t\n\t\t\tif (profileName.extraFilters) {\n\t\t\t\tfilters = filters.concat(list(profileName.extraFilters));\n\t\t\t}\n\t\t\t\t\n\t\t\tif (additionalFilters) {\n\t\t\t\tfilters = filters.concat(list(additionalFilters));\n\t\t\t}\n\t\t\t\t\n\t\t\tif (!filters || !filters.length) {\n\t\t\t\t// looks like unknown syntax, apply basic filters\n\t\t\t\tfilters = list(basicFilters);\n\t\t\t}\n\t\t\t\t\n\t\t\treturn filters;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Extracts filter list from abbreviation\n\t\t * @param {String} abbr\n\t\t * @returns {Array} Array with cleaned abbreviation and list of \n\t\t * extracted filters\n\t\t */\n\t\textract: function(abbr) {\n\t\t\tvar filters = '';\n\t\t\tabbr = abbr.replace(/\\|([\\w\\|\\-]+)$/, function(str, p1){\n\t\t\t\tfilters = p1;\n\t\t\t\treturn '';\n\t\t\t});\n\t\t\t\n\t\t\treturn [abbr, list(filters)];\n\t\t}\n\t};\n});\n},{\"../assets/profile\":\"assets\\\\profile.js\",\"../assets/resources\":\"assets\\\\resources.js\",\"../utils/common\":\"utils\\\\common.js\",\"./bem\":\"filter\\\\bem.js\",\"./comment\":\"filter\\\\comment.js\",\"./css\":\"filter\\\\css.js\",\"./escape\":\"filter\\\\escape.js\",\"./haml\":\"filter\\\\haml.js\",\"./html\":\"filter\\\\html.js\",\"./jade\":\"filter\\\\jade.js\",\"./jsx\":\"filter\\\\jsx.js\",\"./singleLine\":\"filter\\\\singleLine.js\",\"./slim\":\"filter\\\\slim.js\",\"./trim\":\"filter\\\\trim.js\",\"./xsl\":\"filter\\\\xsl.js\"}],\"filter\\\\singleLine.js\":[function(require,module,exports){\n/**\n * Output abbreviation on a single line (i.e. no line breaks)\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar abbrUtils = require('../utils/abbreviation');\n\tvar rePad = /^\\s+/;\n\tvar reNl = /[\\n\\r]/g;\n\n\treturn function process(tree) {\n\t\ttree.children.forEach(function(item) {\n\t\t\tif (!abbrUtils.isSnippet(item)) {\n\t\t\t\t// remove padding from item \n\t\t\t\titem.start = item.start.replace(rePad, '');\n\t\t\t\titem.end = item.end.replace(rePad, '');\n\t\t\t}\n\t\t\t\n\t\t\t// remove newlines \n\t\t\titem.start = item.start.replace(reNl, '');\n\t\t\titem.end = item.end.replace(reNl, '');\n\t\t\titem.content = item.content.replace(reNl, '');\n\t\t\t\n\t\t\tprocess(item);\n\t\t});\n\t\t\n\t\treturn tree;\n\t};\n});\n\n},{\"../utils/abbreviation\":\"utils\\\\abbreviation.js\"}],\"filter\\\\slim.js\":[function(require,module,exports){\n/**\n * Filter for producing Jade code from abbreviation.\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar utils = require('../utils/common');\n\tvar abbrUtils = require('../utils/abbreviation');\n\tvar formatFilter = require('./format');\n\tvar tabStops = require('../assets/tabStops');\n\tvar prefs = require('../assets/preferences');\n\tvar profile = require('../assets/profile');\n\n\tvar reNl = /[\\n\\r]/;\n\tvar reIndentedText = /^\\s*\\|/;\n\tvar reSpace = /^\\s/;\n\n\tprefs.define('slim.attributesWrapper', 'none', \n\t\t'Defines how attributes will be wrapped:' +\n\t\t'<ul>' +\n\t\t'<li><code>none</code> – no wrapping;</li>' +\n\t\t'<li><code>round</code> — wrap attributes with round braces;</li>' +\n\t\t'<li><code>square</code> — wrap attributes with round braces;</li>' +\n\t\t'<li><code>curly</code> — wrap attributes with curly braces.</li>' +\n\t\t'</ul>');\n\n\tfunction transformClassName(className) {\n\t\treturn utils.trim(className).replace(/\\s+/g, '.');\n\t}\n\n\tfunction getAttrWrapper() {\n\t\tvar start = ' ', end = '';\n\t\tswitch (prefs.get('slim.attributesWrapper')) {\n\t\t\tcase 'round':\n\t\t\t\tstart = '(';\n\t\t\t\tend = ')';\n\t\t\t\tbreak;\n\t\t\tcase 'square':\n\t\t\t\tstart = '[';\n\t\t\t\tend = ']';\n\t\t\t\tbreak;\n\t\t\tcase 'curly':\n\t\t\t\tstart = '{';\n\t\t\t\tend = '}';\n\t\t\t\tbreak;\n\t\t}\n\n\t\treturn {\n\t\t\tstart: start,\n\t\t\tend: end\n\t\t};\n\t}\n\n\tfunction stringifyAttrs(attrs, profile) {\n\t\tvar attrQuote = profile.attributeQuote();\n\t\tvar attrWrap = getAttrWrapper();\n\t\treturn attrWrap.start + attrs.map(function(attr) {\n\t\t\tvar value = attrQuote + attr.value + attrQuote;\n\t\t\tif (attr.isBoolean) {\n\t\t\t\tif (!attrWrap.end) {\n\t\t\t\t\tvalue = 'true';\n\t\t\t\t} else {\n\t\t\t\t\treturn attr.name;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn attr.name + '=' + value;\n\t\t}).join(' ') + attrWrap.end;\n\t}\n\t\n\t/**\n\t * Creates HAML attributes string from tag according to profile settings\n\t * @param {AbbreviationNode} tag\n\t * @param {Object} profile\n\t */\n\tfunction makeAttributesString(tag, profile) {\n\t\tvar attrs = '';\n\t\tvar otherAttrs = [];\n\t\tvar attrQuote = profile.attributeQuote();\n\t\tvar cursor = profile.cursor();\n\t\t\n\t\ttag.attributeList().forEach(function(a) {\n\t\t\tvar attrName = profile.attributeName(a.name);\n\t\t\tswitch (attrName.toLowerCase()) {\n\t\t\t\t// use short notation for ID and CLASS attributes\n\t\t\t\tcase 'id':\n\t\t\t\t\tattrs += '#' + (a.value || cursor);\n\t\t\t\t\tbreak;\n\t\t\t\tcase 'class':\n\t\t\t\t\tattrs += '.' + transformClassName(a.value || cursor);\n\t\t\t\t\tbreak;\n\t\t\t\t// process other attributes\n\t\t\t\tdefault:\n\t\t\t\t\totherAttrs.push({\n\t\t\t\t\t\tname: attrName,\n\t\t\t\t\t\tvalue: a.value || cursor,\n\t\t\t\t\t\tisBoolean: profile.isBoolean(a.name, a.value)\n\t\t\t\t\t});\n\t\t\t}\n\t\t});\n\t\t\n\t\tif (otherAttrs.length) {\n\t\t\tattrs += stringifyAttrs(otherAttrs, profile);\n\t\t}\n\t\t\n\t\treturn attrs;\n\t}\n\n\tfunction processTagContent(item) {\n\t\tif (!item.content) {\n\t\t\treturn;\n\t\t}\n\n\t\tvar content = tabStops.replaceVariables(item.content, function(str, name) {\n\t\t\tif (name === 'nl' || name === 'newline') {\n\t\t\t\treturn '\\n';\n\t\t\t}\n\t\t\treturn str;\n\t\t});\n\n\t\tif (reNl.test(content) && !reIndentedText.test(content)) {\n\t\t\t// multiline content: pad it with indentation and pipe\n\t\t\tvar pad = '  ';\n\t\t\titem.content = '\\n| ' + utils.padString(content, pad);\n\t\t} else if (!reSpace.test(content)) {\n\t\t\titem.content = ' ' + content;\n\t\t}\n\t}\n\t\n\t/**\n\t * Processes element with <code>tag</code> type\n\t * @param {AbbreviationNode} item\n\t * @param {OutputProfile} profile\n\t */\n\tfunction processTag(item, profile) {\n\t\tif (!item.parent)\n\t\t\t// looks like it's a root (empty) element\n\t\t\treturn item;\n\t\t\n\t\tvar attrs = makeAttributesString(item, profile);\n\t\tvar cursor = profile.cursor();\n\t\tvar isUnary = abbrUtils.isUnary(item);\n\t\tvar selfClosing = profile.self_closing_tag && isUnary ? '/' : '';\n\t\t\t\n\t\t// define tag name\n\t\tvar tagName = profile.tagName(item.name());\n\t\tif (tagName.toLowerCase() == 'div' && attrs && '([{'.indexOf(attrs.charAt(0)) == -1)\n\t\t\t// omit div tag\n\t\t\ttagName = '';\n\t\t\t\n\t\titem.end = '';\n\t\tvar start = tagName + attrs + selfClosing;\n\t\tprocessTagContent(item);\n\n\t\tvar placeholder = '%s';\n\t\t// We can't just replace placeholder with new value because\n\t\t// JavaScript will treat double $ character as a single one, assuming\n\t\t// we're using RegExp literal.\n\t\titem.start = utils.replaceSubstring(item.start, start, item.start.indexOf(placeholder), placeholder);\n\t\t\n\t\tif (!item.children.length && !isUnary)\n\t\t\titem.start += cursor;\n\t\t\n\t\treturn item;\n\t}\n\n\treturn function process(tree, curProfile, level) {\n\t\tlevel = level || 0;\n\t\t\n\t\tif (!level) {\n\t\t\t// always format with `xml` profile since\n\t\t\t// Slim requires all tags to be on separate lines\n\t\t\ttree = formatFilter(tree, profile.get('xml'));\n\t\t}\n\t\t\n\t\ttree.children.forEach(function(item) {\n\t\t\tif (!abbrUtils.isSnippet(item)) {\n\t\t\t\tprocessTag(item, curProfile, level);\n\t\t\t}\n\t\t\t\n\t\t\tprocess(item, curProfile, level + 1);\n\t\t});\n\t\t\n\t\treturn tree;\n\t};\n});\n},{\"../assets/preferences\":\"assets\\\\preferences.js\",\"../assets/profile\":\"assets\\\\profile.js\",\"../assets/tabStops\":\"assets\\\\tabStops.js\",\"../utils/abbreviation\":\"utils\\\\abbreviation.js\",\"../utils/common\":\"utils\\\\common.js\",\"./format\":\"filter\\\\format.js\"}],\"filter\\\\trim.js\":[function(require,module,exports){\n/**\n * Trim filter: removes characters at the beginning of the text\n * content that indicates lists: numbers, #, *, -, etc.\n * \n * Useful for wrapping lists with abbreviation.\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar prefs = require('../assets/preferences');\n\tprefs.define('filter.trimRegexp', \n\t\t'[\\\\s|\\\\u00a0]*[\\\\d|#|\\\\-|\\*|\\\\u2022]+\\\\.?\\\\s*',\n\t\t'Regular expression used to remove list markers (numbers, dashes, ' \n\t\t+ 'bullets, etc.) in <code>t</code> (trim) filter. The trim filter '\n\t\t+ 'is useful for wrapping with abbreviation lists, pased from other ' \n\t\t+ 'documents (for example, Word documents).');\n\t\n\tfunction process(tree, re) {\n\t\ttree.children.forEach(function(item) {\n\t\t\tif (item.content) {\n\t\t\t\titem.content = item.content.replace(re, '');\n\t\t\t}\n\t\t\t\n\t\t\tprocess(item, re);\n\t\t});\n\t\t\n\t\treturn tree;\n\t}\n\n\treturn function(tree) {\n\t\tvar re = new RegExp(prefs.get('filter.trimRegexp'));\n\t\treturn process(tree, re);\n\t};\n});\n\n},{\"../assets/preferences\":\"assets\\\\preferences.js\"}],\"filter\\\\xsl.js\":[function(require,module,exports){\n/**\n * Filter for trimming \"select\" attributes from some tags that contains\n * child elements\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar abbrUtils = require('../utils/abbreviation');\n\n\tvar tags = {\n\t\t'xsl:variable': 1,\n\t\t'xsl:with-param': 1\n\t};\n\t\n\t/**\n\t * Removes \"select\" attribute from node\n\t * @param {AbbreviationNode} node\n\t */\n\tfunction trimAttribute(node) {\n\t\tnode.start = node.start.replace(/\\s+select\\s*=\\s*(['\"]).*?\\1/, '');\n\t}\n\n\treturn function process(tree) {\n\t\ttree.children.forEach(function(item) {\n\t\t\tif (!abbrUtils.isSnippet(item)\n\t\t\t\t\t&& (item.name() || '').toLowerCase() in tags \n\t\t\t\t\t&& item.children.length)\n\t\t\t\ttrimAttribute(item);\n\t\t\tprocess(item);\n\t\t});\n\t\t\n\t\treturn tree;\n\t};\n});\n},{\"../utils/abbreviation\":\"utils\\\\abbreviation.js\"}],\"generator\\\\lorem.js\":[function(require,module,exports){\n/**\n * \"Lorem ipsum\" text generator. Matches <code>lipsum(num)?</code> or \n * <code>lorem(num)?</code> abbreviation.\n * This code is based on Django's contribution: \n * https://code.djangoproject.com/browser/django/trunk/django/contrib/webdesign/lorem_ipsum.py\n * <br><br>\n * Examples to test:<br>\n * <code>lipsum</code> – generates 30 words text.<br>\n * <code>lipsum*6</code> – generates 6 paragraphs (autowrapped with &lt;p&gt; element) of text.<br>\n * <code>ol>lipsum10*5</code> — generates ordered list with 5 list items (autowrapped with &lt;li&gt; tag)\n * with text of 10 words on each line.<br>\n * <code>span*3>lipsum20</code> – generates 3 paragraphs of 20-words text, each wrapped with &lt;span&gt; element.\n * Each paragraph phrase is unique.   \n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar prefs = require('../assets/preferences');\n\n\tvar langs = {\n\t\ten: {\n\t\t\tcommon: ['lorem', 'ipsum', 'dolor', 'sit', 'amet', 'consectetur', 'adipisicing', 'elit'],\n\t\t\twords: ['exercitationem', 'perferendis', 'perspiciatis', 'laborum', 'eveniet',\n\t\t\t\t'sunt', 'iure', 'nam', 'nobis', 'eum', 'cum', 'officiis', 'excepturi',\n\t\t\t\t'odio', 'consectetur', 'quasi', 'aut', 'quisquam', 'vel', 'eligendi',\n\t\t\t\t'itaque', 'non', 'odit', 'tempore', 'quaerat', 'dignissimos',\n\t\t\t\t'facilis', 'neque', 'nihil', 'expedita', 'vitae', 'vero', 'ipsum',\n\t\t\t\t'nisi', 'animi', 'cumque', 'pariatur', 'velit', 'modi', 'natus',\n\t\t\t\t'iusto', 'eaque', 'sequi', 'illo', 'sed', 'ex', 'et', 'voluptatibus',\n\t\t\t\t'tempora', 'veritatis', 'ratione', 'assumenda', 'incidunt', 'nostrum',\n\t\t\t\t'placeat', 'aliquid', 'fuga', 'provident', 'praesentium', 'rem',\n\t\t\t\t'necessitatibus', 'suscipit', 'adipisci', 'quidem', 'possimus',\n\t\t\t\t'voluptas', 'debitis', 'sint', 'accusantium', 'unde', 'sapiente',\n\t\t\t\t'voluptate', 'qui', 'aspernatur', 'laudantium', 'soluta', 'amet',\n\t\t\t\t'quo', 'aliquam', 'saepe', 'culpa', 'libero', 'ipsa', 'dicta',\n\t\t\t\t'reiciendis', 'nesciunt', 'doloribus', 'autem', 'impedit', 'minima',\n\t\t\t\t'maiores', 'repudiandae', 'ipsam', 'obcaecati', 'ullam', 'enim',\n\t\t\t\t'totam', 'delectus', 'ducimus', 'quis', 'voluptates', 'dolores',\n\t\t\t\t'molestiae', 'harum', 'dolorem', 'quia', 'voluptatem', 'molestias',\n\t\t\t\t'magni', 'distinctio', 'omnis', 'illum', 'dolorum', 'voluptatum', 'ea',\n\t\t\t\t'quas', 'quam', 'corporis', 'quae', 'blanditiis', 'atque', 'deserunt',\n\t\t\t\t'laboriosam', 'earum', 'consequuntur', 'hic', 'cupiditate',\n\t\t\t\t'quibusdam', 'accusamus', 'ut', 'rerum', 'error', 'minus', 'eius',\n\t\t\t\t'ab', 'ad', 'nemo', 'fugit', 'officia', 'at', 'in', 'id', 'quos',\n\t\t\t\t'reprehenderit', 'numquam', 'iste', 'fugiat', 'sit', 'inventore',\n\t\t\t\t'beatae', 'repellendus', 'magnam', 'recusandae', 'quod', 'explicabo',\n\t\t\t\t'doloremque', 'aperiam', 'consequatur', 'asperiores', 'commodi',\n\t\t\t\t'optio', 'dolor', 'labore', 'temporibus', 'repellat', 'veniam',\n\t\t\t\t'architecto', 'est', 'esse', 'mollitia', 'nulla', 'a', 'similique',\n\t\t\t\t'eos', 'alias', 'dolore', 'tenetur', 'deleniti', 'porro', 'facere',\n\t\t\t\t'maxime', 'corrupti']\n\t\t},\n\t\tsp: {\n\t\t\tcommon: ['mujer', 'uno', 'dolor', 'más', 'de', 'poder', 'mismo', 'si'],\n\t\t\twords: ['ejercicio', 'preferencia', 'perspicacia', 'laboral', 'paño',\n\t\t\t\t'suntuoso', 'molde', 'namibia', 'planeador', 'mirar', 'demás', 'oficinista', 'excepción',\n\t\t\t\t'odio', 'consecuencia', 'casi', 'auto', 'chicharra', 'velo', 'elixir',\n\t\t\t\t'ataque', 'no', 'odio', 'temporal', 'cuórum', 'dignísimo',\n\t\t\t\t'facilismo', 'letra', 'nihilista', 'expedición', 'alma', 'alveolar', 'aparte',\n\t\t\t\t'león', 'animal', 'como', 'paria', 'belleza', 'modo', 'natividad',\n\t\t\t\t'justo', 'ataque', 'séquito', 'pillo', 'sed', 'ex', 'y', 'voluminoso',\n\t\t\t\t'temporalidad', 'verdades', 'racional', 'asunción', 'incidente', 'marejada',\n\t\t\t\t'placenta', 'amanecer', 'fuga', 'previsor', 'presentación', 'lejos',\n\t\t\t\t'necesariamente', 'sospechoso', 'adiposidad', 'quindío', 'pócima',\n\t\t\t\t'voluble', 'débito', 'sintió', 'accesorio', 'falda', 'sapiencia',\n\t\t\t\t'volutas', 'queso', 'permacultura', 'laudo', 'soluciones', 'entero',\n\t\t\t\t'pan', 'litro', 'tonelada', 'culpa', 'libertario', 'mosca', 'dictado',\n\t\t\t\t'reincidente', 'nascimiento', 'dolor', 'escolar', 'impedimento', 'mínima',\n\t\t\t\t'mayores', 'repugnante', 'dulce', 'obcecado', 'montaña', 'enigma',\n\t\t\t\t'total', 'deletéreo', 'décima', 'cábala', 'fotografía', 'dolores',\n\t\t\t\t'molesto', 'olvido', 'paciencia', 'resiliencia', 'voluntad', 'molestias',\n\t\t\t\t'magnífico', 'distinción', 'ovni', 'marejada', 'cerro', 'torre', 'y',\n\t\t\t\t'abogada', 'manantial', 'corporal', 'agua', 'crepúsculo', 'ataque', 'desierto',\n\t\t\t\t'laboriosamente', 'angustia', 'afortunado', 'alma', 'encefalograma',\n\t\t\t\t'materialidad', 'cosas', 'o', 'renuncia', 'error', 'menos', 'conejo',\n\t\t\t\t'abadía', 'analfabeto', 'remo', 'fugacidad', 'oficio', 'en', 'almácigo', 'vos', 'pan',\n\t\t\t\t'represión', 'números', 'triste', 'refugiado', 'trote', 'inventor',\n\t\t\t\t'corchea', 'repelente', 'magma', 'recusado', 'patrón', 'explícito',\n\t\t\t\t'paloma', 'síndrome', 'inmune', 'autoinmune', 'comodidad',\n\t\t\t\t'ley', 'vietnamita', 'demonio', 'tasmania', 'repeler', 'apéndice',\n\t\t\t\t'arquitecto', 'columna', 'yugo', 'computador', 'mula', 'a', 'propósito',\n\t\t\t\t'fantasía', 'alias', 'rayo', 'tenedor', 'deleznable', 'ventana', 'cara',\n\t\t\t\t'anemia', 'corrupto']\n\t\t},\n\t\tru: {\n\t\t\tcommon: ['далеко-далеко', 'за', 'словесными', 'горами', 'в стране', 'гласных', 'и согласных', 'живут', 'рыбные', 'тексты'],\n\t\t\twords: ['вдали', 'от всех', 'они', 'буквенных', 'домах', 'на берегу', 'семантика', \n\t\t\t\t'большого', 'языкового', 'океана', 'маленький', 'ручеек', 'даль', \n\t\t\t\t'журчит', 'по всей', 'обеспечивает', 'ее','всеми', 'необходимыми', \n\t\t\t\t'правилами', 'эта', 'парадигматическая', 'страна', 'которой', 'жаренные', \n\t\t\t\t'предложения', 'залетают', 'прямо', 'рот', 'даже', 'всемогущая', \n\t\t\t\t'пунктуация', 'не', 'имеет', 'власти', 'над', 'рыбными', 'текстами', \n\t\t\t\t'ведущими', 'безорфографичный', 'образ', 'жизни', 'однажды', 'одна', \n\t\t\t\t'маленькая', 'строчка','рыбного', 'текста', 'имени', 'lorem', 'ipsum', \n\t\t\t\t'решила', 'выйти', 'большой', 'мир', 'грамматики', 'великий', 'оксмокс', \n\t\t\t\t'предупреждал', 'о', 'злых', 'запятых', 'диких', 'знаках', 'вопроса', \n\t\t\t\t'коварных', 'точках', 'запятой', 'но', 'текст', 'дал', 'сбить', \n\t\t\t\t'себя', 'толку', 'он', 'собрал', 'семь', 'своих', 'заглавных', 'букв', \n\t\t\t\t'подпоясал', 'инициал', 'за', 'пояс', 'пустился', 'дорогу', \n\t\t\t\t'взобравшись', 'первую', 'вершину', 'курсивных', 'гор', 'бросил', \n\t\t\t\t'последний', 'взгляд', 'назад', 'силуэт', 'своего', 'родного', 'города', \n\t\t\t\t'буквоград', 'заголовок', 'деревни', 'алфавит', 'подзаголовок', 'своего', \n\t\t\t\t'переулка', 'грустный', 'реторический', 'вопрос', 'скатился', 'его', \n\t\t\t\t'щеке', 'продолжил', 'свой', 'путь', 'дороге', 'встретил', 'рукопись', \n\t\t\t\t'она', 'предупредила',  'моей', 'все', 'переписывается', 'несколько', \n\t\t\t\t'раз', 'единственное', 'что', 'меня', 'осталось', 'это', 'приставка', \n\t\t\t\t'возвращайся', 'ты', 'лучше', 'свою', 'безопасную', 'страну', 'послушавшись', \n\t\t\t\t'рукописи', 'наш', 'продолжил', 'свой', 'путь', 'вскоре', 'ему', \n\t\t\t\t'повстречался', 'коварный', 'составитель', 'рекламных', 'текстов', \n\t\t\t\t'напоивший', 'языком', 'речью', 'заманивший', 'свое', 'агентство', \n\t\t\t\t'которое', 'использовало', 'снова', 'снова', 'своих', 'проектах', \n\t\t\t\t'если', 'переписали', 'то', 'живет', 'там', 'до', 'сих', 'пор']\n\t\t}\n\t};\n\n\t\n\tprefs.define('lorem.defaultLang', 'en', \n\t\t'Default language of generated dummy text. Currently, <code>en</code>\\\n\t\tand <code>ru</code> are supported, but users can add their own syntaxes\\\n\t\tsee <a href=\"http://docs.emmet.io/abbreviations/lorem-ipsum/\">docs</a>.');\n\tprefs.define('lorem.omitCommonPart', false,\n\t\t'Omit commonly used part (e.g. “Lorem ipsum dolor sit amet“) from generated text.');\n\t\n\t/**\n\t * Returns random integer between <code>from</code> and <code>to</code> values\n\t * @param {Number} from\n\t * @param {Number} to\n\t * @returns {Number}\n\t */\n\tfunction randint(from, to) {\n\t\treturn Math.round(Math.random() * (to - from) + from);\n\t}\n\t\n\t/**\n\t * @param {Array} arr\n\t * @param {Number} count\n\t * @returns {Array}\n\t */\n\tfunction sample(arr, count) {\n\t\tvar len = arr.length;\n\t\tvar iterations = Math.min(len, count);\n\t\tvar result = [];\n\t\twhile (result.length < iterations) {\n\t\t\tvar randIx = randint(0, len - 1);\n\t\t\tif (!~result.indexOf(randIx)) {\n\t\t\t\tresult.push(randIx);\n\t\t\t}\n\t\t}\n\t\t\n\t\treturn result.map(function(ix) {\n\t\t\treturn arr[ix];\n\t\t});\n\t}\n\t\n\tfunction choice(val) {\n\t\tif (typeof val === 'string')\n\t\t\treturn val.charAt(randint(0, val.length - 1));\n\t\t\n\t\treturn val[randint(0, val.length - 1)];\n\t}\n\t\n\tfunction sentence(words, end) {\n\t\tif (words.length) {\n\t\t\twords[0] = words[0].charAt(0).toUpperCase() + words[0].substring(1);\n\t\t}\n\t\t\n\t\treturn words.join(' ') + (end || choice('?!...')); // more dots than question marks\n\t}\n\t\n\t/**\n\t * Insert commas at randomly selected words. This function modifies values\n\t * inside <code>words</code> array \n\t * @param {Array} words\n\t */\n\tfunction insertCommas(words) {\n\t\tvar len = words.length;\n\n\t\tif (len < 2) {\n\t\t\treturn;\n\t\t}\n\n\t\tvar totalCommas = 0;\n\t\tif (len > 3 && len <= 6) {\n\t\t\ttotalCommas = randint(0, 1);\n\t\t} else if (len > 6 && len <= 12) {\n\t\t\ttotalCommas = randint(0, 2);\n\t\t} else {\n\t\t\ttotalCommas = randint(1, 4);\n\t\t}\n\n\t\tfor (var i = 0, pos, word; i < totalCommas; i++) {\n\t\t\tpos = randint(0, words.length - 2);\n\t\t\tword = words[pos];\n\t\t\tif (word.charAt(word.length - 1) !== ',') {\n\t\t\t\twords[pos] += ',';\n\t\t\t}\n\t\t}\n\t}\n\t\n\t/**\n\t * Generate a paragraph of \"Lorem ipsum\" text\n\t * @param {Number} wordCount Words count in paragraph\n\t * @param {Boolean} startWithCommon Should paragraph start with common \n\t * \"lorem ipsum\" sentence.\n\t * @returns {String}\n\t */\n\tfunction paragraph(lang, wordCount, startWithCommon) {\n\t\tvar data = langs[lang];\n\t\tif (!data) {\n\t\t\treturn '';\n\t\t}\n\n\t\tvar result = [];\n\t\tvar totalWords = 0;\n\t\tvar words;\n\t\t\n\t\twordCount = parseInt(wordCount, 10);\n\t\t\n\t\tif (startWithCommon && data.common) {\n\t\t\twords = data.common.slice(0, wordCount);\n\t\t\tif (words.length > 5) {\n\t\t\t\twords[4] += ',';\n\t\t\t}\n\t\t\ttotalWords += words.length;\n\t\t\tresult.push(sentence(words, '.'));\n\t\t}\n\t\t\n\t\twhile (totalWords < wordCount) {\n\t\t\twords = sample(data.words, Math.min(randint(2, 30), wordCount - totalWords));\n\t\t\ttotalWords += words.length;\n\t\t\tinsertCommas(words);\n\t\t\tresult.push(sentence(words));\n\t\t}\n\t\t\n\t\treturn result.join(' ');\n\t}\n\n\treturn {\n\t\t/**\n\t\t * Adds new language words for Lorem Ipsum generator\n\t\t * @param {String} lang Two-letter lang definition\n\t\t * @param {Object} data Words for language. Maight be either a space-separated \n\t\t * list of words (String), Array of words or object with <code>text</code> and\n\t\t * <code>common</code> properties\n\t\t */\n\t\taddLang: function(lang, data) {\n\t\t\tif (typeof data === 'string') {\n\t\t\t\tdata = {\n\t\t\t\t\twords: data.split(' ').filter(function(item) {\n\t\t\t\t\t\treturn !!item;\n\t\t\t\t\t})\n\t\t\t\t};\n\t\t\t} else if (Array.isArray(data)) {\n\t\t\t\tdata = {words: data};\n\t\t\t}\n\n\t\t\tlangs[lang] = data;\n\t\t},\n\t\tpreprocessor: function(tree) {\n\t\t\tvar re = /^(?:lorem|lipsum)([a-z]{2})?(\\d*)$/i, match;\n\t\t\tvar allowCommon = !prefs.get('lorem.omitCommonPart');\n\t\t\t\n\t\t\t/** @param {AbbreviationNode} node */\n\t\t\ttree.findAll(function(node) {\n\t\t\t\tif (node._name && (match = node._name.match(re))) {\n\t\t\t\t\tvar wordCound = match[2] || 30;\n\t\t\t\t\tvar lang = match[1] || prefs.get('lorem.defaultLang') || 'en';\n\t\t\t\t\t\n\t\t\t\t\t// force node name resolving if node should be repeated\n\t\t\t\t\t// or contains attributes. In this case, node should be outputed\n\t\t\t\t\t// as tag, otherwise as text-only node\n\t\t\t\t\tnode._name = '';\n\t\t\t\t\tnode.data('forceNameResolving', node.isRepeating() || node.attributeList().length);\n\t\t\t\t\tnode.data('pasteOverwrites', true);\n\t\t\t\t\tnode.data('paste', function(i) {\n\t\t\t\t\t\treturn paragraph(lang, wordCound, !i && allowCommon);\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t};\n});\n\n},{\"../assets/preferences\":\"assets\\\\preferences.js\"}],\"parser\\\\abbreviation.js\":[function(require,module,exports){\n/**\n * Emmet abbreviation parser.\n * Takes string abbreviation and recursively parses it into a tree. The parsed \n * tree can be transformed into a string representation with \n * <code>toString()</code> method. Note that string representation is defined\n * by custom processors (called <i>filters</i>), not by abbreviation parser \n * itself.\n * \n * This module can be extended with custom pre-/post-processors to shape-up\n * final tree or its representation. Actually, many features of abbreviation \n * engine are defined in other modules as tree processors\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar tabStops = require('../assets/tabStops');\n\tvar profile = require('../assets/profile');\n\tvar filters = require('../filter/main');\n\tvar utils = require('../utils/common');\n\tvar abbreviationUtils = require('../utils/abbreviation');\n\tvar stringStream = require('../assets/stringStream');\n\n\t// pre- and post-processorcs\n\tvar lorem = require('../generator/lorem');\n\tvar procPastedContent = require('./processor/pastedContent');\n\tvar procTagName = require('./processor/tagName');\n\tvar procResourceMatcher = require('./processor/resourceMatcher');\n\tvar procAttributes = require('./processor/attributes');\n\tvar procHref = require('./processor/href');\n\n\tvar reValidName = /^[\\w\\-\\$\\:@\\!%]+\\+?$/i;\n\tvar reWord = /[\\w\\-:\\$@]/;\n\tvar DEFAULT_ATTR_NAME = '%default';\n\t\n\tvar pairs = {\n\t\t'[': ']',\n\t\t'(': ')',\n\t\t'{': '}'\n\t};\n\t\n\tvar spliceFn = Array.prototype.splice;\n\t\n\tvar preprocessors = [];\n\tvar postprocessors = [];\n\tvar outputProcessors = [];\n\t\n\t/**\n\t * @type AbbreviationNode\n\t */\n\tfunction AbbreviationNode(parent) {\n\t\t/** @type AbbreviationNode */\n\t\tthis.parent = null;\n\t\tthis.children = [];\n\t\tthis._attributes = [];\n\t\t\n\t\t/** @type String Raw abbreviation for current node */\n\t\tthis.abbreviation = '';\n\t\tthis.counter = 1;\n\t\tthis._name = null;\n\t\tthis._text = '';\n\t\tthis.repeatCount = 1;\n\t\tthis.hasImplicitRepeat = false;\n\t\t\n\t\t/** Custom data dictionary */\n\t\tthis._data = {};\n\t\t\n\t\t// output properties\n\t\tthis.start = '';\n\t\tthis.end = '';\n\t\tthis.content = '';\n\t\tthis.padding = '';\n\t}\n\t\n\tAbbreviationNode.prototype = {\n\t\t/**\n\t\t * Adds passed node as child or creates new child\n\t\t * @param {AbbreviationNode} child\n\t\t * @param {Number} position Index in children array where child should \n\t\t * be inserted\n\t\t * @return {AbbreviationNode}\n\t\t */\n\t\taddChild: function(child, position) {\n\t\t\tchild = child || new AbbreviationNode();\n\t\t\tchild.parent = this;\n\t\t\t\n\t\t\tif (typeof position === 'undefined') {\n\t\t\t\tthis.children.push(child);\n\t\t\t} else {\n\t\t\t\tthis.children.splice(position, 0, child);\n\t\t\t}\n\t\t\t\n\t\t\treturn child;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Creates a deep copy of current node\n\t\t * @returns {AbbreviationNode}\n\t\t */\n\t\tclone: function() {\n\t\t\tvar node = new AbbreviationNode();\n\t\t\tvar attrs = ['abbreviation', 'counter', '_name', '_text', 'repeatCount', 'hasImplicitRepeat', 'start', 'end', 'content', 'padding'];\n\t\t\tattrs.forEach(function(a) {\n\t\t\t\tnode[a] = this[a];\n\t\t\t}, this);\n\t\t\t\n\t\t\t// clone attributes\n\t\t\tnode._attributes = this._attributes.map(function(attr) {\n\t\t\t\treturn utils.extend({}, attr);\n\t\t\t});\n\t\t\t\n\t\t\tnode._data = utils.extend({}, this._data);\n\t\t\t\n\t\t\t// clone children\n\t\t\tnode.children = this.children.map(function(child) {\n\t\t\t\tchild = child.clone();\n\t\t\t\tchild.parent = node;\n\t\t\t\treturn child;\n\t\t\t});\n\t\t\t\n\t\t\treturn node;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Removes current node from parent‘s child list\n\t\t * @returns {AbbreviationNode} Current node itself\n\t\t */\n\t\tremove: function() {\n\t\t\tif (this.parent) {\n\t\t\t\tvar ix = this.parent.children.indexOf(this);\n\t\t\t\tif (~ix) {\n\t\t\t\t\tthis.parent.children.splice(ix, 1);\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\treturn this;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Replaces current node in parent‘s children list with passed nodes\n\t\t * @param {AbbreviationNode} node Replacement node or array of nodes\n\t\t */\n\t\treplace: function() {\n\t\t\tvar parent = this.parent;\n\t\t\tvar ix = parent.children.indexOf(this);\n\t\t\tvar items = utils.flatten(arguments);\n\t\t\tspliceFn.apply(parent.children, [ix, 1].concat(items));\n\t\t\t\n\t\t\t// update parent\n\t\t\titems.forEach(function(item) {\n\t\t\t\titem.parent = parent;\n\t\t\t});\n\t\t},\n\t\t\n\t\t/**\n\t\t * Recursively sets <code>property</code> to <code>value</code> of current\n\t\t * node and its children \n\t\t * @param {String} name Property to update\n\t\t * @param {Object} value New property value\n\t\t */\n\t\tupdateProperty: function(name, value) {\n\t\t\tthis[name] = value;\n\t\t\tthis.children.forEach(function(child) {\n\t\t\t\tchild.updateProperty(name, value);\n\t\t\t});\n\t\t\t\n\t\t\treturn this;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Finds first child node that matches truth test for passed \n\t\t * <code>fn</code> function\n\t\t * @param {Function} fn\n\t\t * @returns {AbbreviationNode}\n\t\t */\n\t\tfind: function(fn) {\n\t\t\treturn this.findAll(fn, {amount: 1})[0];\n\t\t},\n\t\t\n\t\t/**\n\t\t * Finds all child nodes that matches truth test for passed \n\t\t * <code>fn</code> function\n\t\t * @param {Function} fn\n\t\t * @returns {Array}\n\t\t */\n\t\tfindAll: function(fn, state) {\n\t\t\tstate = utils.extend({amount: 0, found: 0}, state || {});\n\n\t\t\tif (typeof fn !== 'function') {\n\t\t\t\tvar elemName = fn.toLowerCase();\n\t\t\t\tfn = function(item) {return item.name().toLowerCase() == elemName;};\n\t\t\t}\n\t\t\t\t\n\t\t\tvar result = [];\n\t\t\tthis.children.forEach(function(child) {\n\t\t\t\tif (fn(child)) {\n\t\t\t\t\tresult.push(child);\n\t\t\t\t\tstate.found++;\n\t\t\t\t\tif (state.amount && state.found >= state.amount) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tresult = result.concat(child.findAll(fn));\n\t\t\t});\n\t\t\t\n\t\t\treturn result.filter(function(item) {\n\t\t\t\treturn !!item;\n\t\t\t});\n\t\t},\n\t\t\n\t\t/**\n\t\t * Sets/gets custom data\n\t\t * @param {String} name\n\t\t * @param {Object} value\n\t\t * @returns {Object}\n\t\t */\n\t\tdata: function(name, value) {\n\t\t\tif (arguments.length == 2) {\n\t\t\t\tthis._data[name] = value;\n\t\t\t}\n\t\t\t\n\t\t\treturn this._data[name];\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns name of current node\n\t\t * @returns {String}\n\t\t */\n\t\tname: function() {\n\t\t\treturn this._name;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns list of attributes for current node\n\t\t * @returns {Array}\n\t\t */\n\t\tattributeList: function() {\n\t\t\treturn optimizeAttributes(this._attributes.slice(0));\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns or sets attribute value\n\t\t * @param {String} name Attribute name\n\t\t * @param {String} value New attribute value. `Null` value \n\t\t * will remove attribute\n\t\t * @returns {String}\n\t\t */\n\t\tattribute: function(name, value) {\n\t\t\tif (arguments.length == 2) {\n\t\t\t\tif (value === null) {\n\t\t\t\t\t// remove attribute\n\t\t\t\t\tvar vals = this._attributes.filter(function(attr) {\n\t\t\t\t\t\treturn attr.name === name;\n\t\t\t\t\t});\n\n\t\t\t\t\tvar that = this;\n\t\t\t\t\tvals.forEach(function(attr) {\n\t\t\t\t\t\tvar ix = that._attributes.indexOf(attr);\n\t\t\t\t\t\tif (~ix) {\n\t\t\t\t\t\t\tthat._attributes.splice(ix, 1);\n\t\t\t\t\t\t}\n\t\t\t\t\t});\n\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\t// modify attribute\n\t\t\t\tvar attrNames = this._attributes.map(function(attr) {\n\t\t\t\t\treturn attr.name;\n\t\t\t\t});\n\t\t\t\tvar ix = attrNames.indexOf(name.toLowerCase());\n\t\t\t\tif (~ix) {\n\t\t\t\t\tthis._attributes[ix].value = value;\n\t\t\t\t} else {\n\t\t\t\t\tthis._attributes.push({\n\t\t\t\t\t\tname: name,\n\t\t\t\t\t\tvalue: value\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\treturn (utils.find(this.attributeList(), function(attr) {\n\t\t\t\treturn attr.name == name;\n\t\t\t}) || {}).value;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns index of current node in parent‘s children list\n\t\t * @returns {Number}\n\t\t */\n\t\tindex: function() {\n\t\t\treturn this.parent ? this.parent.children.indexOf(this) : -1;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Sets how many times current element should be repeated\n\t\t * @private\n\t\t */\n\t\t_setRepeat: function(count) {\n\t\t\tif (count) {\n\t\t\t\tthis.repeatCount = parseInt(count, 10) || 1;\n\t\t\t} else {\n\t\t\t\tthis.hasImplicitRepeat = true;\n\t\t\t}\n\t\t},\n\t\t\n\t\t/**\n\t\t * Sets abbreviation that belongs to current node\n\t\t * @param {String} abbr\n\t\t */\n\t\tsetAbbreviation: function(abbr) {\n\t\t\tabbr = abbr || '';\n\t\t\t\n\t\t\tvar that = this;\n\t\t\t\n\t\t\t// find multiplier\n\t\t\tabbr = abbr.replace(/\\*(\\d+)?$/, function(str, repeatCount) {\n\t\t\t\tthat._setRepeat(repeatCount);\n\t\t\t\treturn '';\n\t\t\t});\n\t\t\t\n\t\t\tthis.abbreviation = abbr;\n\t\t\t\n\t\t\tvar abbrText = extractText(abbr);\n\t\t\tif (abbrText) {\n\t\t\t\tabbr = abbrText.element;\n\t\t\t\tthis.content = this._text = abbrText.text;\n\t\t\t}\n\t\t\t\n\t\t\tvar abbrAttrs = parseAttributes(abbr);\n\t\t\tif (abbrAttrs) {\n\t\t\t\tabbr = abbrAttrs.element;\n\t\t\t\tthis._attributes = abbrAttrs.attributes;\n\t\t\t}\n\t\t\t\n\t\t\tthis._name = abbr;\n\t\t\t\n\t\t\t// validate name\n\t\t\tif (this._name && !reValidName.test(this._name)) {\n\t\t\t\tthrow new Error('Invalid abbreviation');\n\t\t\t}\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns string representation of current node\n\t\t * @return {String}\n\t\t */\n\t\tvalueOf: function() {\n\t\t\tvar start = this.start;\n\t\t\tvar end = this.end;\n\t\t\tvar content = this.content;\n\t\t\t\n\t\t\t// apply output processors\n\t\t\tvar node = this;\n\t\t\toutputProcessors.forEach(function(fn) {\n\t\t\t\tstart = fn(start, node, 'start');\n\t\t\t\tcontent = fn(content, node, 'content');\n\t\t\t\tend = fn(end, node, 'end');\n\t\t\t});\n\t\t\t\n\t\t\t\n\t\t\tvar innerContent = this.children.map(function(child) {\n\t\t\t\treturn child.valueOf();\n\t\t\t}).join('');\n\t\t\t\n\t\t\tcontent = abbreviationUtils.insertChildContent(content, innerContent, {\n\t\t\t\tkeepVariable: false\n\t\t\t});\n\t\t\t\n\t\t\treturn start + utils.padString(content, this.padding) + end;\n\t\t},\n\n\t\ttoString: function() {\n\t\t\treturn this.valueOf();\n\t\t},\n\t\t\n\t\t/**\n\t\t * Check if current node contains children with empty <code>expr</code>\n\t\t * property\n\t\t * @return {Boolean}\n\t\t */\n\t\thasEmptyChildren: function() {\n\t\t\treturn !!utils.find(this.children, function(child) {\n\t\t\t\treturn child.isEmpty();\n\t\t\t});\n\t\t},\n\t\t\n\t\t/**\n\t\t * Check if current node has implied name that should be resolved\n\t\t * @returns {Boolean}\n\t\t */\n\t\thasImplicitName: function() {\n\t\t\treturn !this._name && !this.isTextNode();\n\t\t},\n\t\t\n\t\t/**\n\t\t * Indicates that current element is a grouping one, e.g. has no \n\t\t * representation but serves as a container for other nodes\n\t\t * @returns {Boolean}\n\t\t */\n\t\tisGroup: function() {\n\t\t\treturn !this.abbreviation;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Indicates empty node (i.e. without abbreviation). It may be a \n\t\t * grouping node and should not be outputted\n\t\t * @return {Boolean}\n\t\t */\n\t\tisEmpty: function() {\n\t\t\treturn !this.abbreviation && !this.children.length;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Indicates that current node should be repeated\n\t\t * @returns {Boolean}\n\t\t */\n\t\tisRepeating: function() {\n\t\t\treturn this.repeatCount > 1 || this.hasImplicitRepeat;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Check if current node is a text-only node\n\t\t * @return {Boolean}\n\t\t */\n\t\tisTextNode: function() {\n\t\t\treturn !this.name() && !this.attributeList().length;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Indicates whether this node may be used to build elements or snippets\n\t\t * @returns {Boolean}\n\t\t */\n\t\tisElement: function() {\n\t\t\treturn !this.isEmpty() && !this.isTextNode();\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns latest and deepest child of current tree\n\t\t * @returns {AbbreviationNode}\n\t\t */\n\t\tdeepestChild: function() {\n\t\t\tif (!this.children.length)\n\t\t\t\treturn null;\n\t\t\t\t\n\t\t\tvar deepestChild = this;\n\t\t\twhile (deepestChild.children.length) {\n\t\t\t\tdeepestChild = deepestChild.children[deepestChild.children.length - 1];\n\t\t\t}\n\t\t\t\n\t\t\treturn deepestChild;\n\t\t}\n\t};\n\t\n\t/**\n\t * Returns stripped string: a string without first and last character.\n\t * Used for “unquoting” strings\n\t * @param {String} str\n\t * @returns {String}\n\t */\n\tfunction stripped(str) {\n\t\treturn str.substring(1, str.length - 1);\n\t}\n\t\n\tfunction consumeQuotedValue(stream, quote) {\n\t\tvar ch;\n\t\twhile ((ch = stream.next())) {\n\t\t\tif (ch === quote)\n\t\t\t\treturn true;\n\t\t\t\n\t\t\tif (ch == '\\\\')\n\t\t\t\tcontinue;\n\t\t}\n\t\t\n\t\treturn false;\n\t}\n\t\n\t/**\n\t * Parses abbreviation into a tree\n\t * @param {String} abbr\n\t * @returns {AbbreviationNode}\n\t */\n\tfunction parseAbbreviation(abbr) {\n\t\tabbr = utils.trim(abbr);\n\t\t\n\t\tvar root = new AbbreviationNode();\n\t\tvar context = root.addChild(), ch;\n\t\t\n\t\t/** @type StringStream */\n\t\tvar stream = stringStream.create(abbr);\n\t\tvar loopProtector = 1000, multiplier;\n\t\tvar addChild = function(child) {\n\t\t\tcontext.addChild(child);\n\t\t};\n\n\t\tvar consumeAbbr = function() {\n\t\t\tstream.start = stream.pos;\n\t\t\tstream.eatWhile(function(c) {\n\t\t\t\tif (c == '[' || c == '{') {\n\t\t\t\t\tif (stream.skipToPair(c, pairs[c])) {\n\t\t\t\t\t\tstream.backUp(1);\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t}\n\t\t\t\t\t\n\t\t\t\t\tthrow new Error('Invalid abbreviation: mo matching \"' + pairs[c] + '\" found for character at ' + stream.pos);\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tif (c == '+') {\n\t\t\t\t\t// let's see if this is an expando marker\n\t\t\t\t\tstream.next();\n\t\t\t\t\tvar isMarker = stream.eol() ||  ~'+>^*'.indexOf(stream.peek());\n\t\t\t\t\tstream.backUp(1);\n\t\t\t\t\treturn isMarker;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\treturn c != '(' && isAllowedChar(c);\n\t\t\t});\n\t\t};\n\t\t\n\t\twhile (!stream.eol() && --loopProtector > 0) {\n\t\t\tch = stream.peek();\n\t\t\t\n\t\t\tswitch (ch) {\n\t\t\t\tcase '(': // abbreviation group\n\t\t\t\t\tstream.start = stream.pos;\n\t\t\t\t\tif (stream.skipToPair('(', ')')) {\n\t\t\t\t\t\tvar inner = parseAbbreviation(stripped(stream.current()));\n\t\t\t\t\t\tif ((multiplier = stream.match(/^\\*(\\d+)?/, true))) {\n\t\t\t\t\t\t\tcontext._setRepeat(multiplier[1]);\n\t\t\t\t\t\t}\n\t\t\t\t\t\t\n\t\t\t\t\t\tinner.children.forEach(addChild);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tthrow new Error('Invalid abbreviation: mo matching \")\" found for character at ' + stream.pos);\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\t\t\n\t\t\t\tcase '>': // child operator\n\t\t\t\t\tcontext = context.addChild();\n\t\t\t\t\tstream.next();\n\t\t\t\t\tbreak;\n\t\t\t\t\t\n\t\t\t\tcase '+': // sibling operator\n\t\t\t\t\tcontext = context.parent.addChild();\n\t\t\t\t\tstream.next();\n\t\t\t\t\tbreak;\n\t\t\t\t\t\n\t\t\t\tcase '^': // climb up operator\n\t\t\t\t\tvar parent = context.parent || context;\n\t\t\t\t\tcontext = (parent.parent || parent).addChild();\n\t\t\t\t\tstream.next();\n\t\t\t\t\tbreak;\n\t\t\t\t\t\n\t\t\t\tdefault: // consume abbreviation\n\t\t\t\t\tconsumeAbbr();\n\t\t\t\t\tcontext.setAbbreviation(stream.current());\n\t\t\t\t\tstream.start = stream.pos;\n\t\t\t}\n\t\t}\n\t\t\n\t\tif (loopProtector < 1) {\n\t\t\tthrow new Error('Endless loop detected');\n\t\t}\n\t\t\n\t\treturn root;\n\t}\n\n\t/**\n\t * Splits attribute set into a list of attributes string\n\t * @param  {String} attrSet \n\t * @return {Array}\n\t */\n\tfunction splitAttributes(attrSet) {\n\t\tattrSet = utils.trim(attrSet);\n\t\tvar parts = [];\n\n\t\t// split attribute set by spaces\n\t\tvar stream = stringStream(attrSet), ch;\n\t\twhile ((ch = stream.next())) {\n\t\t\tif (ch == ' ') {\n\t\t\t\tparts.push(utils.trim(stream.current()));\n\t\t\t\t// skip spaces\n\t\t\t\twhile (stream.peek() == ' ') {\n\t\t\t\t\tstream.next();\n\t\t\t\t}\n\n\t\t\t\tstream.start = stream.pos;\n\t\t\t} else if (ch == '\"' || ch == \"'\") {\n\t\t\t\t// skip values in strings\n\t\t\t\tif (!stream.skipString(ch)) {\n\t\t\t\t\tthrow new Error('Invalid attribute set');\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tparts.push(utils.trim(stream.current()));\n\t\treturn parts;\n\t}\n\n\t/**\n\t * Removes opening and closing quotes from given string\n\t * @param  {String} str\n\t * @return {String}\n\t */\n\tfunction unquote(str) {\n\t\tvar ch = str.charAt(0);\n\t\tif (ch == '\"' || ch == \"'\") {\n\t\t\tstr = str.substr(1);\n\t\t\tvar last = str.charAt(str.length - 1);\n\t\t\tif (last === ch) {\n\t\t\t\tstr = str.substr(0, str.length - 1);\n\t\t\t}\n\t\t}\n\n\t\treturn str;\n\t}\n\n\t/**\n\t * Extract attributes and their values from attribute set: \n\t * <code>[attr col=3 title=\"Quoted string\"]</code> (without square braces)\n\t * @param {String} attrSet\n\t * @returns {Array}\n\t */\n\tfunction extractAttributes(attrSet) {\n\t\tvar reAttrName = /^[\\w\\-:\\$@]+\\.?$/;\n\t\treturn splitAttributes(attrSet).map(function(attr) {\n\t\t\t// attribute name: [attr]\n\t\t\tif (reAttrName.test(attr)) {\n\t\t\t\tvar value = '';\n\t\t\t\tif (attr.charAt(attr.length - 1) == '.') {\n\t\t\t\t\t// a boolean attribute\n\t\t\t\t\tattr = attr.substr(0, attr.length - 1);\n\t\t\t\t\tvalue = attr;\n\t\t\t\t}\n\t\t\t\treturn {\n\t\t\t\t\tname: attr,\n\t\t\t\t\tvalue: value\n\t\t\t\t};\n\t\t\t}\n\n\t\t\t// attribute with value: [name=val], [name=\"val\"]\n\t\t\tif (~attr.indexOf('=')) {\n\t\t\t\tvar parts = attr.split('=');\n\t\t\t\treturn {\n\t\t\t\t\tname: parts.shift(),\n\t\t\t\t\tvalue: unquote(parts.join('='))\n\t\t\t\t};\n\t\t\t}\n\n\t\t\t// looks like it’s implied attribute\n\t\t\treturn {\n\t\t\t\tname: DEFAULT_ATTR_NAME,\n\t\t\t\tvalue: unquote(attr)\n\t\t\t};\n\t\t});\n\t}\n\t\n\t/**\n\t * Parses tag attributes extracted from abbreviation. If attributes found, \n\t * returns object with <code>element</code> and <code>attributes</code>\n\t * properties\n\t * @param {String} abbr\n\t * @returns {Object} Returns <code>null</code> if no attributes found in \n\t * abbreviation\n\t */\n\tfunction parseAttributes(abbr) {\n\t\t/*\n\t\t * Example of incoming data:\n\t\t * #header\n\t\t * .some.data\n\t\t * .some.data#header\n\t\t * [attr]\n\t\t * #item[attr=Hello other=\"World\"].class\n\t\t */\n\t\tvar result = [];\n\t\tvar attrMap = {'#': 'id', '.': 'class'};\n\t\tvar nameEnd = null;\n\t\t\n\t\t/** @type StringStream */\n\t\tvar stream = stringStream.create(abbr);\n\t\twhile (!stream.eol()) {\n\t\t\tswitch (stream.peek()) {\n\t\t\t\tcase '#': // id\n\t\t\t\tcase '.': // class\n\t\t\t\t\tif (nameEnd === null)\n\t\t\t\t\t\tnameEnd = stream.pos;\n\t\t\t\t\t\n\t\t\t\t\tvar attrName = attrMap[stream.peek()];\n\t\t\t\t\t\n\t\t\t\t\tstream.next();\n\t\t\t\t\tstream.start = stream.pos;\n\t\t\t\t\tstream.eatWhile(reWord);\n\t\t\t\t\tresult.push({\n\t\t\t\t\t\tname: attrName, \n\t\t\t\t\t\tvalue: stream.current()\n\t\t\t\t\t});\n\t\t\t\t\tbreak;\n\t\t\t\tcase '[': //begin attribute set\n\t\t\t\t\tif (nameEnd === null)\n\t\t\t\t\t\tnameEnd = stream.pos;\n\t\t\t\t\t\n\t\t\t\t\tstream.start = stream.pos;\n\t\t\t\t\tif (!stream.skipToPair('[', ']')) {\n\t\t\t\t\t\tthrow new Error('Invalid attribute set definition');\n\t\t\t\t\t}\n\t\t\t\t\t\n\t\t\t\t\tresult = result.concat(\n\t\t\t\t\t\textractAttributes(stripped(stream.current()))\n\t\t\t\t\t);\n\t\t\t\t\tbreak;\n\t\t\t\tdefault:\n\t\t\t\t\tstream.next();\n\t\t\t}\n\t\t}\n\t\t\n\t\tif (!result.length)\n\t\t\treturn null;\n\t\t\n\t\treturn {\n\t\t\telement: abbr.substring(0, nameEnd),\n\t\t\tattributes: optimizeAttributes(result)\n\t\t};\n\t}\n\t\n\t/**\n\t * Optimize attribute set: remove duplicates and merge class attributes\n\t * @param attrs\n\t */\n\tfunction optimizeAttributes(attrs) {\n\t\t// clone all attributes to make sure that original objects are \n\t\t// not modified\n\t\tattrs = attrs.map(function(attr) {\n\t\t\treturn utils.clone(attr);\n\t\t});\n\t\t\n\t\tvar lookup = {};\n\n\t\treturn attrs.filter(function(attr) {\n\t\t\tif (!(attr.name in lookup)) {\n\t\t\t\treturn lookup[attr.name] = attr;\n\t\t\t}\n\t\t\t\n\t\t\tvar la = lookup[attr.name];\n\t\t\t\n\t\t\tif (attr.name.toLowerCase() == 'class') {\n\t\t\t\tla.value += (la.value.length ? ' ' : '') + attr.value;\n\t\t\t} else {\n\t\t\t\tla.value = attr.value;\n\t\t\t\tla.isImplied = !!attr.isImplied;\n\t\t\t}\n\t\t\t\n\t\t\treturn false;\n\t\t});\n\t}\n\t\n\t/**\n\t * Extract text data from abbreviation: if <code>a{hello}</code> abbreviation\n\t * is passed, returns object <code>{element: 'a', text: 'hello'}</code>.\n\t * If nothing found, returns <code>null</code>\n\t * @param {String} abbr\n\t * \n\t */\n\tfunction extractText(abbr) {\n\t\tif (!~abbr.indexOf('{'))\n\t\t\treturn null;\n\t\t\n\t\t/** @type StringStream */\n\t\tvar stream = stringStream.create(abbr);\n\t\twhile (!stream.eol()) {\n\t\t\tswitch (stream.peek()) {\n\t\t\t\tcase '[':\n\t\t\t\tcase '(':\n\t\t\t\t\tstream.skipToPair(stream.peek(), pairs[stream.peek()]); break;\n\t\t\t\t\t\n\t\t\t\tcase '{':\n\t\t\t\t\tstream.start = stream.pos;\n\t\t\t\t\tstream.skipToPair('{', '}');\n\t\t\t\t\treturn {\n\t\t\t\t\t\telement: abbr.substring(0, stream.start),\n\t\t\t\t\t\ttext: stripped(stream.current())\n\t\t\t\t\t};\n\t\t\t\t\t\n\t\t\t\tdefault:\n\t\t\t\t\tstream.next();\n\t\t\t}\n\t\t}\n\t}\n\t\n\t/**\n\t * “Un-rolls“ contents of current node: recursively replaces all repeating \n\t * children with their repeated clones\n\t * @param {AbbreviationNode} node\n\t * @returns {AbbreviationNode}\n\t */\n\tfunction unroll(node) {\n\t\tfor (var i = node.children.length - 1, j, child, maxCount; i >= 0; i--) {\n\t\t\tchild = node.children[i];\n\t\t\t\n\t\t\tif (child.isRepeating()) {\n\t\t\t\tmaxCount = j = child.repeatCount;\n\t\t\t\tchild.repeatCount = 1;\n\t\t\t\tchild.updateProperty('counter', 1);\n\t\t\t\tchild.updateProperty('maxCount', maxCount);\n\t\t\t\twhile (--j > 0) {\n\t\t\t\t\tchild.parent.addChild(child.clone(), i + 1)\n\t\t\t\t\t\t.updateProperty('counter', j + 1)\n\t\t\t\t\t\t.updateProperty('maxCount', maxCount);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\t\n\t\t// to keep proper 'counter' property, we need to walk\n\t\t// on children once again\n\t\tnode.children.forEach(unroll);\n\t\t\n\t\treturn node;\n\t}\n\t\n\t/**\n\t * Optimizes tree node: replaces empty nodes with their children\n\t * @param {AbbreviationNode} node\n\t * @return {AbbreviationNode}\n\t */\n\tfunction squash(node) {\n\t\tfor (var i = node.children.length - 1; i >= 0; i--) {\n\t\t\t/** @type AbbreviationNode */\n\t\t\tvar n = node.children[i];\n\t\t\tif (n.isGroup()) {\n\t\t\t\tn.replace(squash(n).children);\n\t\t\t} else if (n.isEmpty()) {\n\t\t\t\tn.remove();\n\t\t\t}\n\t\t}\n\t\t\n\t\tnode.children.forEach(squash);\n\t\t\n\t\treturn node;\n\t}\n\t\n\tfunction isAllowedChar(ch) {\n\t\tvar charCode = ch.charCodeAt(0);\n\t\tvar specialChars = '#.*:$-_!@|%';\n\t\t\n\t\treturn (charCode > 64 && charCode < 91)       // uppercase letter\n\t\t\t\t|| (charCode > 96 && charCode < 123)  // lowercase letter\n\t\t\t\t|| (charCode > 47 && charCode < 58)   // number\n\t\t\t\t|| specialChars.indexOf(ch) != -1;    // special character\n\t}\n\n\t// XXX add counter replacer function as output processor\n\toutputProcessors.push(function(text, node) {\n\t\treturn utils.replaceCounter(text, node.counter, node.maxCount);\n\t});\n\n\t// XXX add tabstop updater\n\toutputProcessors.push(tabStops.abbrOutputProcessor.bind(tabStops));\n\n\t// include default pre- and postprocessors\n\t[lorem, procResourceMatcher, procAttributes, procPastedContent, procTagName, procHref].forEach(function(mod) {\n\t\tif (mod.preprocessor) {\n\t\t\tpreprocessors.push(mod.preprocessor.bind(mod));\n\t\t}\n\n\t\tif (mod.postprocessor) {\n\t\t\tpostprocessors.push(mod.postprocessor.bind(mod));\n\t\t}\n\t});\n\n\treturn {\n\t\tDEFAULT_ATTR_NAME: DEFAULT_ATTR_NAME,\n\n\t\t/**\n\t\t * Parses abbreviation into tree with respect of groups, \n\t\t * text nodes and attributes. Each node of the tree is a single \n\t\t * abbreviation. Tree represents actual structure of the outputted \n\t\t * result\n\t\t * @memberOf abbreviationParser\n\t\t * @param {String} abbr Abbreviation to parse\n\t\t * @param {Object} options Additional options for parser and processors\n\t\t * \n\t\t * @return {AbbreviationNode}\n\t\t */\n\t\tparse: function(abbr, options) {\n\t\t\toptions = options || {};\n\t\t\t\n\t\t\tvar tree = parseAbbreviation(abbr);\n\t\t\tvar that = this;\n\t\t\t\n\t\t\tif (options.contextNode) {\n\t\t\t\t// add info about context node –\n\t\t\t\t// a parent XHTML node in editor inside which abbreviation is \n\t\t\t\t// expanded\n\t\t\t\ttree._name = options.contextNode.name;\n\t\t\t\tvar attrLookup = {};\n\t\t\t\ttree._attributes.forEach(function(attr) {\n\t\t\t\t\tattrLookup[attr.name] = attr;\n\t\t\t\t});\n\t\t\t\t\n\t\t\t\toptions.contextNode.attributes.forEach(function(attr) {\n\t\t\t\t\tif (attr.name in attrLookup) {\n\t\t\t\t\t\tattrLookup[attr.name].value = attr.value;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tattr = utils.clone(attr);\n\t\t\t\t\t\ttree._attributes.push(attr);\n\t\t\t\t\t\tattrLookup[attr.name] = attr;\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\t\t\t\n\t\t\t// apply preprocessors\n\t\t\tpreprocessors.forEach(function(fn) {\n\t\t\t\tfn(tree, options, that);\n\t\t\t});\n\n\t\t\tif ('counter' in options) {\n\t\t\t\ttree.updateProperty('counter', options.counter);\n\t\t\t}\n\t\t\t\n\t\t\ttree = squash(unroll(tree));\n\t\t\t\n\t\t\t// apply postprocessors\n\t\t\tpostprocessors.forEach(function(fn) {\n\t\t\t\tfn(tree, options, that);\n\t\t\t});\n\t\t\t\n\t\t\treturn tree;\n\t\t},\n\n\t\t/**\n\t\t * Expands given abbreviation into a formatted code structure.\n\t\t * This is the main method that is used for expanding abbreviation\n\t\t * @param {String} abbr Abbreviation to expand\n\t\t * @param {Options} options Additional options for abbreviation\n\t\t * expanding and transformation: `syntax`, `profile`, `contextNode` etc.\n\t\t * @return {String}\n\t\t */\n\t\texpand: function(abbr, options) {\n\t\t\tif (!abbr) return '';\n\t\t\tif (typeof options == 'string') {\n\t\t\t\tthrow new Error('Deprecated use of `expand` method: `options` must be object');\n\t\t\t}\n\n\t\t\toptions = options || {};\n\n\t\t\tif (!options.syntax) {\n\t\t\t\toptions.syntax = utils.defaultSyntax();\n\t\t\t}\n\n\t\t\tvar p = profile.get(options.profile, options.syntax);\n\t\t\ttabStops.resetTabstopIndex();\n\t\t\t\n\t\t\tvar data = filters.extract(abbr);\n\t\t\tvar outputTree = this.parse(data[0], options);\n\n\t\t\tvar filtersList = filters.composeList(options.syntax, p, data[1]);\n\t\t\tfilters.apply(outputTree, filtersList, p);\n\n\t\t\treturn outputTree.valueOf();\n\t\t},\n\t\t\n\t\tAbbreviationNode: AbbreviationNode,\n\t\t\n\t\t/**\n\t\t * Add new abbreviation preprocessor. <i>Preprocessor</i> is a function\n\t\t * that applies to a parsed abbreviation tree right after it get parsed.\n\t\t * The passed tree is in unoptimized state.\n\t\t * @param {Function} fn Preprocessor function. This function receives\n\t\t * two arguments: parsed abbreviation tree (<code>AbbreviationNode</code>)\n\t\t * and <code>options</code> hash that was passed to <code>parse</code>\n\t\t * method\n\t\t */\n\t\taddPreprocessor: function(fn) {\n\t\t\tif (!~preprocessors.indexOf(fn)) {\n\t\t\t\tpreprocessors.push(fn);\n\t\t\t}\n\t\t},\n\t\t\n\t\t/**\n\t\t * Removes registered preprocessor\n\t\t */\n\t\tremoveFilter: function(fn) {\n\t\t\tvar ix = preprocessors.indexOf(fn);\n\t\t\tif (~ix) {\n\t\t\t\tpreprocessors.splice(ix, 1);\n\t\t\t}\n\t\t},\n\t\t\n\t\t/**\n\t\t * Adds new abbreviation postprocessor. <i>Postprocessor</i> is a \n\t\t * functinon that applies to <i>optimized</i> parsed abbreviation tree\n\t\t * right before it returns from <code>parse()</code> method\n\t\t * @param {Function} fn Postprocessor function. This function receives\n\t\t * two arguments: parsed abbreviation tree (<code>AbbreviationNode</code>)\n\t\t * and <code>options</code> hash that was passed to <code>parse</code>\n\t\t * method\n\t\t */\n\t\taddPostprocessor: function(fn) {\n\t\t\tif (!~postprocessors.indexOf(fn)) {\n\t\t\t\tpostprocessors.push(fn);\n\t\t\t}\n\t\t},\n\t\t\n\t\t/**\n\t\t * Removes registered postprocessor function\n\t\t */\n\t\tremovePostprocessor: function(fn) {\n\t\t\tvar ix = postprocessors.indexOf(fn);\n\t\t\tif (~ix) {\n\t\t\t\tpostprocessors.splice(ix, 1);\n\t\t\t}\n\t\t},\n\t\t\n\t\t/**\n\t\t * Registers output postprocessor. <i>Output processor</i> is a \n\t\t * function that applies to output part (<code>start</code>, \n\t\t * <code>end</code> and <code>content</code>) when \n\t\t * <code>AbbreviationNode.toString()</code> method is called\n\t\t */\n\t\taddOutputProcessor: function(fn) {\n\t\t\tif (!~outputProcessors.indexOf(fn)) {\n\t\t\t\toutputProcessors.push(fn);\n\t\t\t}\n\t\t},\n\t\t\n\t\t/**\n\t\t * Removes registered output processor\n\t\t */\n\t\tremoveOutputProcessor: function(fn) {\n\t\t\tvar ix = outputProcessors.indexOf(fn);\n\t\t\tif (~ix) {\n\t\t\t\toutputProcessors.splice(ix, 1);\n\t\t\t}\n\t\t},\n\t\t\n\t\t/**\n\t\t * Check if passed symbol is valid symbol for abbreviation expression\n\t\t * @param {String} ch\n\t\t * @return {Boolean}\n\t\t */\n\t\tisAllowedChar: function(ch) {\n\t\t\tch = String(ch); // convert Java object to JS\n\t\t\treturn isAllowedChar(ch) || ~'>+^[](){}'.indexOf(ch);\n\t\t}\n\t};\n});\n},{\"../assets/profile\":\"assets\\\\profile.js\",\"../assets/stringStream\":\"assets\\\\stringStream.js\",\"../assets/tabStops\":\"assets\\\\tabStops.js\",\"../filter/main\":\"filter\\\\main.js\",\"../generator/lorem\":\"generator\\\\lorem.js\",\"../utils/abbreviation\":\"utils\\\\abbreviation.js\",\"../utils/common\":\"utils\\\\common.js\",\"./processor/attributes\":\"parser\\\\processor\\\\attributes.js\",\"./processor/href\":\"parser\\\\processor\\\\href.js\",\"./processor/pastedContent\":\"parser\\\\processor\\\\pastedContent.js\",\"./processor/resourceMatcher\":\"parser\\\\processor\\\\resourceMatcher.js\",\"./processor/tagName\":\"parser\\\\processor\\\\tagName.js\"}],\"parser\\\\css.js\":[function(require,module,exports){\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar session = {tokens: null};\n\t\n\t// walks around the source\n\tvar walker = {\n\t\tinit: function (source) {\n\t\t\t// this.source = source.replace(/\\r\\n?/g, '\\n');\n\t\t\tthis.source = source;\n\t\t\tthis.ch = '';\n\t\t\tthis.chnum = -1;\n\t\t\n\t\t\t// advance\n\t\t\tthis.nextChar();\n\t\t},\n\t\tnextChar: function () {\n\t\t\treturn this.ch = this.source.charAt(++this.chnum);\n\t\t},\n\t\tpeek: function() {\n\t\t\treturn this.source.charAt(this.chnum + 1);\n\t\t}\n\t};\n\n\t// utility helpers\n\tfunction isNameChar(c, cc) {\n\t\tcc = cc || c.charCodeAt(0);\n\t\treturn (\n\t\t\t(cc >= 97 && cc <= 122 /* a-z */) || \n\t\t\t(cc >= 65 && cc <= 90 /* A-Z */) || \n\t\t\t/* \n\t\t\tExperimental: include cyrillic ranges \n\t\t\tsince some letters, similar to latin ones, can \n\t\t\taccidentally appear in CSS tokens\n\t\t\t*/\n\t\t\t(cc >= 1024 && cc <= 1279) || \n\t\t\tc === '&' || /* selector placeholder (LESS, SCSS) */\n\t\t\tc === '_' || \n\t\t\tc === '<' || /* comparisons (LESS, SCSS) */\n\t\t\tc === '>' || \n\t\t\tc === '=' || \n\t\t\tc === '-'\n\t\t);\n\t}\n\n\tfunction isDigit(c, cc) {\n\t\tcc = cc || c.charCodeAt(0);\n\t\treturn (cc >= 48 && cc <= 57);\n\t}\n\n\tvar isOp = (function () {\n\t\tvar opsa = \"{}[]()+*=.,;:>~|\\\\%$#@^!\".split(''),\n\t\t\topsmatcha = \"*^|$~\".split(''),\n\t\t\tops = {},\n\t\t\topsmatch = {},\n\t\t\ti = 0;\n\t\tfor (; i < opsa.length; i += 1) {\n\t\t\tops[opsa[i]] = true;\n\t\t}\n\t\tfor (i = 0; i < opsmatcha.length; i += 1) {\n\t\t\topsmatch[opsmatcha[i]] = true;\n\t\t}\n\t\treturn function (ch, matchattr) {\n\t\t\tif (matchattr) {\n\t\t\t\treturn ch in opsmatch;\n\t\t\t}\n\t\t\treturn ch in ops;\n\t\t};\n\t}());\n\t\n\t// creates token objects and pushes them to a list\n\tfunction tokener(value, type) {\n\t\tsession.tokens.push({\n\t\t\tvalue: value,\n\t\t\ttype:  type || value,\n\t\t\tstart: null,\n\t\t\tend:   null\n\t\t});\n\t}\n\n\tfunction getPosInfo(w) {\n\t\tvar errPos = w.chnum;\n\t\tvar source = w.source.replace(/\\r\\n?/g, '\\n');\n\t\tvar part = w.source.substring(0, errPos + 1).replace(/\\r\\n?/g, '\\n');\n\t\tvar lines = part.split('\\n');\n\t\tvar ch = (lines[lines.length - 1] || '').length;\n\t\tvar fullLine = source.split('\\n')[lines.length - 1] || '';\n\t\t\n\t\tvar chunkSize = 100;\n\t\tvar offset = Math.max(0, ch - chunkSize);\n\t\tvar formattedLine = fullLine.substr(offset, chunkSize * 2) + '\\n';\n\t\tfor (var i = 0; i < ch - offset - 1; i++) {\n\t\t\tformattedLine += '-';\n\t\t}\n\t\tformattedLine += '^';\n\n\t\treturn {\n\t\t\tline: lines.length,\n\t\t\tch: ch,\n\t\t\ttext: fullLine,\n\t\t\thint: formattedLine\n\t\t};\n\t}\n\n\tfunction raiseError(message) {\n\t\tvar err = error(message);\n\t\tvar errObj = new Error(err.message, '', err.line);\n\t\terrObj.line = err.line;\n\t\terrObj.ch = err.ch;\n\t\terrObj.name = err.name;\n\t\terrObj.hint = err.hint;\n\n\t\tthrow errObj;\n\t}\n\t\n\t// oops\n\tfunction error(m) { \n\t\tvar w = walker;\n\t\tvar info = getPosInfo(walker);\n\t\tvar tokens = session.tokens;\n\t\tsession.tokens = null;\n\n\t\tvar message = 'CSS parsing error at line ' + info.line + ', char ' + info.ch + ': ' + m;\n\t\tmessage += '\\n' +  info.hint;\n\t\treturn {\n\t\t\tname: \"ParseError\",\n\t\t\tmessage: message,\n\t\t\thint: info.hint,\n\t\t\tline: info.line,\n\t\t\tch: info.ch\n\t\t};\n\t}\n\n\n\t// token handlers follow for:\n\t// white space, comment, string, identifier, number, operator\n\tfunction white() {\n\t\tvar c = walker.ch,\n\t\t\ttoken = '';\n\t\n\t\twhile (c === \" \" || c === \"\\t\") {\n\t\t\ttoken += c;\n\t\t\tc = walker.nextChar();\n\t\t}\n\t\n\t\ttokener(token, 'white');\n\t\n\t}\n\n\tfunction comment() {\n\t\tvar w = walker,\n\t\t\tc = w.ch,\n\t\t\ttoken = c,\n\t\t\tcnext;\n\t \n\t\tcnext = w.nextChar();\n\n\t\tif (cnext === '/') {\n\t\t\t// inline comment in SCSS and LESS\n\t\t\twhile (c && !(cnext === \"\\n\" || cnext === \"\\r\")) {\n\t\t\t\ttoken += cnext;\n\t\t\t\tc = cnext;\n\t\t\t\tcnext = w.nextChar();\n\t\t\t}\n\t\t} else if (cnext === '*') {\n\t\t\t// multiline CSS commment\n\t\t\twhile (c && !(c === \"*\" && cnext === \"/\")) {\n\t\t\t\ttoken += cnext;\n\t\t\t\tc = cnext;\n\t\t\t\tcnext = w.nextChar();\n\t\t\t}\n\t\t} else {\n\t\t\t// oops, not a comment, just a /\n\t\t\treturn tokener(token, token);\n\t\t}\n\t\t\n\t\ttoken += cnext;\n\t\tw.nextChar();\n\t\ttokener(token, 'comment');\n\t}\n\n\tfunction eatString() {\n\t\tvar w = walker,\n\t\t\tc = w.ch,\n\t\t\tq = c,\n\t\t\ttoken = c,\n\t\t\tcnext;\n\t\n\t\tc = w.nextChar();\n\n\t\twhile (c !== q) {\n\t\t\tif (c === '\\n') {\n\t\t\t\tcnext = w.nextChar();\n\t\t\t\tif (cnext === \"\\\\\") {\n\t\t\t\t\ttoken += c + cnext;\n\t\t\t\t} else {\n\t\t\t\t\t// end of line with no \\ escape = bad\n\t\t\t\t\traiseError(\"Unterminated string\");\n\t\t\t\t}\n\t\t\t} else if (c === '') {\n\t\t\t\traiseError(\"Unterminated string\");\n\t\t\t} else {\n\t\t\t\tif (c === \"\\\\\") {\n\t\t\t\t\ttoken += c + w.nextChar();\n\t\t\t\t} else {\n\t\t\t\t\ttoken += c;\n\t\t\t\t}\n\t\t\t}\n\t\t\n\t\t\tc = w.nextChar();\n\t\t}\n\n\t\ttoken += c;\n\n\t\treturn token;\n\t}\n\n\tfunction str() {\n\t\tvar token = eatString();\n\t\twalker.nextChar();\n\t\ttokener(token, 'string');\n\t}\n\t\n\tfunction brace() {\n\t\tvar w = walker,\n\t\t\tc = w.ch,\n\t\t\tdepth = 1,\n\t\t\ttoken = c,\n\t\t\tstop = false;\n\t\n\t\tc = w.nextChar();\n\t\n\t\twhile (c && !stop) {\n\t\t\tif (c === '(') {\n\t\t\t\tdepth++;\n\t\t\t} else if (c === ')') {\n\t\t\t\tdepth--;\n\t\t\t\tif (!depth) {\n\t\t\t\t\tstop = true;\n\t\t\t\t}\n\t\t\t} else if (c === '\"' || c === \"'\") {\n\t\t\t\tc = eatString();\n\t\t\t} else if (c === '') {\n\t\t\t\traiseError(\"Unterminated brace\");\n\t\t\t}\n\t\t\t\n\t\t\ttoken += c;\n\t\t\tc = w.nextChar();\n\t\t}\n\t\t\n\t\ttokener(token, 'brace');\n\t}\n\n\tfunction identifier(pre) {\n\t\tvar c = walker.ch;\n\t\tvar token = pre ? pre + c : c;\n\t\t\t\n\t\tc = walker.nextChar();\n\t\tvar cc = c.charCodeAt(0);\n\t\twhile (isNameChar(c, cc) || isDigit(c, cc)) {\n\t\t\ttoken += c;\n\t\t\tc = walker.nextChar();\n\t\t\tcc = c.charCodeAt(0);\n\t\t}\n\t\n\t\ttokener(token, 'identifier');\n\t}\n\n\tfunction num() {\n\t\tvar w = walker,\n\t\t\tc = w.ch,\n\t\t\ttoken = c,\n\t\t\tpoint = token === '.',\n\t\t\tnondigit;\n\t\t\n\t\tc = w.nextChar();\n\t\tnondigit = !isDigit(c);\n\t\n\t\t// .2px or .classname?\n\t\tif (point && nondigit) {\n\t\t\t// meh, NaN, could be a class name, so it's an operator for now\n\t\t\treturn tokener(token, '.');    \n\t\t}\n\t\t\n\t\t// -2px or -moz-something\n\t\tif (token === '-' && nondigit) {\n\t\t\treturn identifier('-');\n\t\t}\n\t\n\t\twhile (c !== '' && (isDigit(c) || (!point && c === '.'))) { // not end of source && digit or first instance of .\n\t\t\tif (c === '.') {\n\t\t\t\tpoint = true;\n\t\t\t}\n\t\t\ttoken += c;\n\t\t\tc = w.nextChar();\n\t\t}\n\n\t\ttokener(token, 'number');    \n\t\n\t}\n\n\tfunction op() {\n\t\tvar w = walker,\n\t\t\tc = w.ch,\n\t\t\ttoken = c,\n\t\t\tnext = w.nextChar();\n\t\t\t\n\t\tif (next === \"=\" && isOp(token, true)) {\n\t\t\ttoken += next;\n\t\t\ttokener(token, 'match');\n\t\t\tw.nextChar();\n\t\t\treturn;\n\t\t} \n\t\t\n\t\ttokener(token, token);\n\t}\n\n\n\t// call the appropriate handler based on the first character in a token suspect\n\tfunction tokenize() {\n\t\tvar ch = walker.ch;\n\t\n\t\tif (ch === \" \" || ch === \"\\t\") {\n\t\t\treturn white();\n\t\t}\n\n\t\tif (ch === '/') {\n\t\t\treturn comment();\n\t\t} \n\n\t\tif (ch === '\"' || ch === \"'\") {\n\t\t\treturn str();\n\t\t}\n\t\t\n\t\tif (ch === '(') {\n\t\t\treturn brace();\n\t\t}\n\t\n\t\tif (ch === '-' || ch === '.' || isDigit(ch)) { // tricky - char: minus (-1px) or dash (-moz-stuff)\n\t\t\treturn num();\n\t\t}\n\t\n\t\tif (isNameChar(ch)) {\n\t\t\treturn identifier();\n\t\t}\n\n\t\tif (isOp(ch)) {\n\t\t\treturn op();\n\t\t}\n\n\t\tif (ch === '\\r') {\n\t\t\tif (walker.peek() === '\\n') {\n\t\t\t\tch += walker.nextChar();\n\t\t\t}\n\n\t\t\ttokener(ch, 'line');\n\t\t\twalker.nextChar();\n\t\t\treturn;\n\t\t}\n\t\t\n\t\tif (ch === '\\n') {\n\t\t\ttokener(ch, 'line');\n\t\t\twalker.nextChar();\n\t\t\treturn;\n\t\t}\n\t\t\n\t\traiseError(\"Unrecognized character '\" + ch + \"'\");\n\t}\n\n\treturn {\n\t\t/**\n\t\t * Sprits given source into tokens\n\t\t * @param {String} source\n\t\t * @returns {Array}\n\t\t */\n\t\tlex: function (source) {\n\t\t\twalker.init(source);\n\t\t\tsession.tokens = [];\n\n\t\t\t// for empty source, return single space token\n\t\t\tif (!source) {\n\t\t\t\tsession.tokens.push(this.white());\n\t\t\t} else {\n\t\t\t\twhile (walker.ch !== '') {\n\t\t\t\t\ttokenize();\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tvar tokens = session.tokens;\n\t\t\tsession.tokens = null;\n\t\t\treturn tokens;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Tokenizes CSS source. It's like `lex()` method,\n\t\t * but also stores proper token indexes in source, \n\t\t * so it's a bit slower\n\t\t * @param {String} source\n\t\t * @returns {Array}\n\t\t */\n\t\tparse: function(source) {\n\t\t\t// transform tokens\n\t\t\tvar tokens = this.lex(source), pos = 0, token;\n\t\t\tfor (var i = 0, il = tokens.length; i < il; i++) {\n\t\t\t\ttoken = tokens[i];\n\t\t\t\ttoken.start = pos;\n\t\t\t\ttoken.end = (pos += token.value.length);\n\t\t\t}\n\t\t\treturn tokens;\n\t\t},\n\n\t\twhite: function() {\n\t\t\treturn {\n\t\t\t\tvalue: '',\n\t\t\t\ttype:  'white',\n\t\t\t\tstart: 0,\n\t\t\t\tend:   0\n\t\t\t};\n\t\t},\n\t\t\n\t\ttoSource: function(toks) {\n\t\t\tvar i = 0, max = toks.length, src = '';\n\t\t\tfor (; i < max; i++) {\n\t\t\t\tsrc += toks[i].value;\n\t\t\t}\n\t\t\treturn src;\n\t\t}\n\t};\n});\n},{}],\"parser\\\\processor\\\\attributes.js\":[function(require,module,exports){\n/**\n * Resolves node attribute names: moves `default` attribute value\n * from stub to real attribute.\n *\n * This resolver should be applied *after* resource matcher\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar utils = require('../../utils/common');\n\n\tvar findDefault = function(attr) {\n\t\treturn attr.isDefault;\n\t};\n\n\tvar findImplied = function(attr) {\n\t\treturn attr.isImplied;\n\t};\n\n\tvar findEmpty = function(attr) {\n\t\treturn !attr.value;\n\t};\n\n\tfunction resolveDefaultAttrs(node, parser) {\n\t\tnode.children.forEach(function(item) {\n\t\t\tvar attrList = item.attributeList();\n\t\t\tvar defaultAttrValue = item.attribute(parser.DEFAULT_ATTR_NAME);\n\t\t\tif (typeof defaultAttrValue !== 'undefined') {\n\t\t\t\t// remove stub attribute\n\t\t\t\titem.attribute(parser.DEFAULT_ATTR_NAME, null);\n\t\t\t\t\n\t\t\t\tif (attrList.length) {\n\t\t\t\t\t// target for default value:\n\t\t\t\t\t// 1. default attribute\n\t\t\t\t\t// 2. implied attribute\n\t\t\t\t\t// 3. first empty attribute\n\t\t\t\t\n\t\t\t\t\t// find attribute marked as default\n\t\t\t\t\tvar defaultAttr = utils.find(attrList, findDefault) \n\t\t\t\t\t\t|| utils.find(attrList, findImplied) \n\t\t\t\t\t\t|| utils.find(attrList, findEmpty);\n\n\t\t\t\t\tif (defaultAttr) {\n\t\t\t\t\t\tvar oldVal = item.attribute(defaultAttr.name);\n\t\t\t\t\t\tvar newVal = utils.replaceUnescapedSymbol(oldVal, '|', defaultAttrValue);\n\t\t\t\t\t\t// no replacement, e.g. default value does not contains | symbol\n\t\t\t\t\t\tif (oldVal == newVal) {\n\t\t\t\t\t\t\tnewVal = defaultAttrValue\n\t\t\t\t\t\t}\n\t\t\t\t\t\t\n\t\t\t\t\t\titem.attribute(defaultAttr.name, newVal);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\t// if no default attribute value, remove implied attributes\n\t\t\t\tattrList.forEach(function(attr) {\n\t\t\t\t\tif (attr.isImplied) {\n\t\t\t\t\t\titem.attribute(attr.name, null);\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\n\t\t\tresolveDefaultAttrs(item, parser);\n\t\t});\n\t}\n\n\treturn {\n\t\t/**\n\t\t * @param  {AbbreviationNode} tree\n\t\t * @param  {Object} options\n\t\t * @param  {abbreviation} parser\n\t\t */\n\t\tpreprocessor: function(tree, options, parser) {\n\t\t\tresolveDefaultAttrs(tree, parser);\n\t\t}\n\t};\n});\n},{\"../../utils/common\":\"utils\\\\common.js\"}],\"parser\\\\processor\\\\href.js\":[function(require,module,exports){\n/**\n * A preptocessor for &lt;a&gt; tag: tests wrapped content\n * for common URL patterns and, if matched, inserts it as \n * `href` attribute\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar prefs = require('../../assets/preferences');\n\tvar utils = require('../../utils/common');\n\tvar pc = require('./pastedContent');\n\n\tprefs.define('href.autodetect', true, \n\t\t'Enables or disables automatic URL recognition when wrapping\\\n\t\ttext with <code>&lt;a&gt;</code> tag. With this option enabled,\\\n\t\tif wrapped text matches URL or e-mail pattern it will be automatically\\\n\t\tinserted into <code>href</code> attribute.');\n\tprefs.define('href.urlPattern', '^(?:(?:https?|ftp|file)://|www\\\\.|ftp\\\\.)(?:\\\\([-A-Z0-9+&@#/%=~_|$?!:,.]*\\\\)|[-A-Z0-9+&@#/%=~_|$?!:,.])*(?:\\\\([-A-Z0-9+&@#/%=~_|$?!:,.]*\\\\)|[A-Z0-9+&@#/%=~_|$])', \n\t\t'RegExp pattern to match wrapped URLs. Matched content will be inserts\\\n\t\tas-is into <code>href</code> attribute, only whitespace will be trimmed.');\n\n\tprefs.define('href.emailPattern', '^[a-z0-9._%+-]+@[a-z0-9.-]+\\\\.[a-z]{2,5}$', \n\t\t'RegExp pattern to match wrapped e-mails. Unlike <code>href.urlPattern</code>,\\\n\t\twrapped content will be prefixed with <code>mailto:</code> in <code>href</code>\\\n\t\tattribute');\n\n\treturn {\n\t\t/**\n\t\t * @param {AbbreviationNode} tree\n\t\t * @param {Object} options\n\t\t */\n\t\tpostprocessor: function(tree, options) {\n\t\t\tif (!prefs.get('href.autodetect')) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tvar reUrl = new RegExp(prefs.get('href.urlPattern'), 'i');\n\t\t\tvar reEmail = new RegExp(prefs.get('href.emailPattern'), 'i');\n\t\t\tvar reProto = /^([a-z]+:)?\\/\\//i;\n\n\t\t\ttree.findAll(function(item) {\n\t\t\t\tif (item.name().toLowerCase() != 'a' || item.attribute('href')) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tvar pastedContent = utils.trim(pc.pastedContent(item) || options.pastedContent);\n\t\t\t\tif (pastedContent) {\n\t\t\t\t\tif (reUrl.test(pastedContent)) {\n\t\t\t\t\t\t// do we have protocol?\n\t\t\t\t\t\tif (!reProto.test(pastedContent)) {\n\t\t\t\t\t\t\tpastedContent = 'http://' + pastedContent;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\titem.attribute('href', pastedContent);\n\t\t\t\t\t} else if (reEmail.test(pastedContent)) {\n\t\t\t\t\t\titem.attribute('href', 'mailto:' + pastedContent);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t};\n});\n},{\"../../assets/preferences\":\"assets\\\\preferences.js\",\"../../utils/common\":\"utils\\\\common.js\",\"./pastedContent\":\"parser\\\\processor\\\\pastedContent.js\"}],\"parser\\\\processor\\\\pastedContent.js\":[function(require,module,exports){\n/**\n * Pasted content abbreviation processor. A pasted content is a content that\n * should be inserted into implicitly repeated abbreviation nodes.\n * This processor powers “Wrap With Abbreviation” action\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar utils = require('../../utils/common');\n\tvar abbrUtils = require('../../utils/abbreviation');\n\tvar stringStream = require('../../assets/stringStream');\n\tvar range = require('../../assets/range');\n\n\tvar outputPlaceholder = '$#';\n\t\n\t/**\n\t * Locates output placeholders inside text\n\t * @param {String} text\n\t * @returns {Array} Array of ranges of output placeholder in text\n\t */\n\tfunction locateOutputPlaceholder(text) {\n\t\tvar result = [];\n\t\t\n\t\tvar stream = stringStream.create(text);\n\t\t\n\t\twhile (!stream.eol()) {\n\t\t\tif (stream.peek() == '\\\\') {\n\t\t\t\tstream.next();\n\t\t\t} else {\n\t\t\t\tstream.start = stream.pos;\n\t\t\t\tif (stream.match(outputPlaceholder, true)) {\n\t\t\t\t\tresult.push(range.create(stream.start, outputPlaceholder));\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t}\n\t\t\tstream.next();\n\t\t}\n\t\t\n\t\treturn result;\n\t}\n\t\n\t/**\n\t * Replaces output placeholders inside <code>source</code> with \n\t * <code>value</code>\n\t * @param {String} source\n\t * @param {String} value\n\t * @returns {String}\n\t */\n\tfunction replaceOutputPlaceholders(source, value) {\n\t\tvar ranges = locateOutputPlaceholder(source);\n\t\t\n\t\tranges.reverse().forEach(function(r) {\n\t\t\tsource = utils.replaceSubstring(source, value, r);\n\t\t});\n\t\t\n\t\treturn source;\n\t}\n\t\n\t/**\n\t * Check if parsed node contains output placeholder – a target where\n\t * pasted content should be inserted\n\t * @param {AbbreviationNode} node\n\t * @returns {Boolean}\n\t */\n\tfunction hasOutputPlaceholder(node) {\n\t\tif (locateOutputPlaceholder(node.content).length)\n\t\t\treturn true;\n\t\t\n\t\t// check if attributes contains placeholder\n\t\treturn !!utils.find(node.attributeList(), function(attr) {\n\t\t\treturn !!locateOutputPlaceholder(attr.value).length;\n\t\t});\n\t}\n\t\n\t/**\n\t * Insert pasted content into correct positions of parsed node\n\t * @param {AbbreviationNode} node\n\t * @param {String} content\n\t * @param {Boolean} overwrite Overwrite node content if no value placeholders\n\t * found instead of appending to existing content\n\t */\n\tfunction insertPastedContent(node, content, overwrite) {\n\t\tvar nodesWithPlaceholders = node.findAll(function(item) {\n\t\t\treturn hasOutputPlaceholder(item);\n\t\t});\n\t\t\n\t\tif (hasOutputPlaceholder(node))\n\t\t\tnodesWithPlaceholders.unshift(node);\n\t\t\n\t\tif (nodesWithPlaceholders.length) {\n\t\t\tnodesWithPlaceholders.forEach(function(item) {\n\t\t\t\titem.content = replaceOutputPlaceholders(item.content, content);\n\t\t\t\titem._attributes.forEach(function(attr) {\n\t\t\t\t\tattr.value = replaceOutputPlaceholders(attr.value, content);\n\t\t\t\t});\n\t\t\t});\n\t\t} else {\n\t\t\t// on output placeholders in subtree, insert content in the deepest\n\t\t\t// child node\n\t\t\tvar deepest = node.deepestChild() || node;\n\t\t\tif (overwrite) {\n\t\t\t\tdeepest.content = content;\n\t\t\t} else {\n\t\t\t\tdeepest.content = abbrUtils.insertChildContent(deepest.content, content);\n\t\t\t}\n\t\t}\n\t}\n\n\treturn {\n\t\tpastedContent: function(item) {\n\t\t\tvar content = item.data('paste');\n\t\t\tif (Array.isArray(content)) {\n\t\t\t\treturn content[item.counter - 1];\n\t\t\t} else if (typeof content === 'function') {\n\t\t\t\treturn content(item.counter - 1, item.content);\n\t\t\t} else if (content) {\n\t\t\t\treturn content;\n\t\t\t}\n\t\t},\n\n\t\t/**\n\t\t * @param {AbbreviationNode} tree\n\t\t * @param {Object} options\n\t\t */\n\t\tpreprocessor: function(tree, options) {\n\t\t\tif (options.pastedContent) {\n\t\t\t\tvar lines = utils.splitByLines(options.pastedContent, true).map(utils.trim);\n\t\t\t\t\n\t\t\t\t// set repeat count for implicitly repeated elements before\n\t\t\t\t// tree is unrolled\n\t\t\t\ttree.findAll(function(item) {\n\t\t\t\t\tif (item.hasImplicitRepeat) {\n\t\t\t\t\t\titem.data('paste', lines);\n\t\t\t\t\t\treturn item.repeatCount = lines.length;\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\t\t},\n\n\t\t/**\n\t\t * @param {AbbreviationNode} tree\n\t\t * @param {Object} options\n\t\t */\n\t\tpostprocessor: function(tree, options) {\n\t\t\tvar that = this;\n\t\t\t// for each node with pasted content, update text data\n\t\t\tvar targets = tree.findAll(function(item) {\n\t\t\t\tvar pastedContent = that.pastedContent(item);\n\t\t\t\tif (pastedContent) {\n\t\t\t\t\tinsertPastedContent(item, pastedContent, !!item.data('pasteOverwrites'));\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\treturn !!pastedContent;\n\t\t\t});\n\t\t\t\n\t\t\tif (!targets.length && options.pastedContent) {\n\t\t\t\t// no implicitly repeated elements, put pasted content in\n\t\t\t\t// the deepest child\n\t\t\t\tinsertPastedContent(tree, options.pastedContent);\n\t\t\t}\n\t\t}\n\t};\n});\n},{\"../../assets/range\":\"assets\\\\range.js\",\"../../assets/stringStream\":\"assets\\\\stringStream.js\",\"../../utils/abbreviation\":\"utils\\\\abbreviation.js\",\"../../utils/common\":\"utils\\\\common.js\"}],\"parser\\\\processor\\\\resourceMatcher.js\":[function(require,module,exports){\n/**\n * Processor function that matches parsed <code>AbbreviationNode</code>\n * against resources defined in <code>resource</code> module\n */ \nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar resources = require('../../assets/resources');\n\tvar elements = require('../../assets/elements');\n\tvar utils = require('../../utils/common');\n\tvar abbreviationUtils = require('../../utils/abbreviation');\n\n\t/**\n\t * Finds matched resources for child nodes of passed <code>node</code> \n\t * element. A matched resource is a reference to <i>snippets.json</i> entry\n\t * that describes output of parsed node \n\t * @param {AbbreviationNode} node\n\t * @param {String} syntax\n\t */\n\tfunction matchResources(node, syntax, parser) {\n\t\t// do a shallow copy because the children list can be modified during\n\t\t// resource matching\n\t\tnode.children.slice(0).forEach(function(child) {\n\t\t\tvar r = resources.getMatchedResource(child, syntax);\n\t\t\tif (typeof r === 'string') {\n\t\t\t\tr = elements.create('snippet', r);\n\t\t\t}\n\n\t\t\tchild.data('resource', r);\n\t\t\tvar elemType = elements.type(r);\n\n\t\t\tif (elemType == 'snippet') {\n\t\t\t\tvar content = r.data;\n\t\t\t\tvar curContent = child._text || child.content;\n\t\t\t\tif (curContent) {\n\t\t\t\t\tcontent = abbreviationUtils.insertChildContent(content, curContent);\n\t\t\t\t}\n\n\t\t\t\tchild.content = content;\n\t\t\t} else if (elemType == 'element') {\n\t\t\t\tchild._name = r.name;\n\t\t\t\tif (Array.isArray(r.attributes)) {\n\t\t\t\t\tchild._attributes = [].concat(r.attributes, child._attributes);\n\t\t\t\t}\n\t\t\t} else if (elemType == 'reference') {\n\t\t\t\t// it’s a reference to another abbreviation:\n\t\t\t\t// parse it and insert instead of current child\n\t\t\t\t/** @type AbbreviationNode */\n\t\t\t\tvar subtree = parser.parse(r.data, {\n\t\t\t\t\tsyntax: syntax\n\t\t\t\t});\n\n\t\t\t\t// if context element should be repeated, check if we need to \n\t\t\t\t// transfer repeated element to specific child node\n\t\t\t\tif (child.repeatCount > 1) {\n\t\t\t\t\tvar repeatedChildren = subtree.findAll(function(node) {\n\t\t\t\t\t\treturn node.hasImplicitRepeat;\n\t\t\t\t\t});\n\n\t\t\t\t\tif (!repeatedChildren.length) {\n\t\t\t\t\t\trepeatedChildren = subtree.children\n\t\t\t\t\t}\n\t\t\t\t\t\n\t\t\t\t\trepeatedChildren.forEach(function(node) {\n\t\t\t\t\t\tnode.repeatCount = child.repeatCount;\n\t\t\t\t\t\tnode.hasImplicitRepeat = false;\n\t\t\t\t\t});\n\t\t\t\t}\n\n\t\t\t\t// move child‘s children into the deepest child of new subtree\n\t\t\t\tvar deepestChild = subtree.deepestChild();\n\t\t\t\tif (deepestChild) {\n\t\t\t\t\tchild.children.forEach(function(c) {\n\t\t\t\t\t\tdeepestChild.addChild(c);\n\t\t\t\t\t});\n\t\t\t\t\tdeepestChild.content = child.content;\n\t\t\t\t}\n\n\t\t\t\t// copy current attributes to children\n\t\t\t\tsubtree.children.forEach(function(node) {\n\t\t\t\t\tchild.attributeList().forEach(function(attr) {\n\t\t\t\t\t\tnode.attribute(attr.name, attr.value);\n\t\t\t\t\t});\n\t\t\t\t});\n\t\t\t\t\n\t\t\t\tchild.replace(subtree.children);\n\t\t\t}\n\t\t\t\n\t\t\tmatchResources(child, syntax, parser);\n\t\t});\n\t}\n\t\n\treturn {\n\t\tpreprocessor: function(tree, options, parser) {\n\t\t\tvar syntax = options.syntax || utils.defaultSyntax();\n\t\t\tmatchResources(tree, syntax, parser);\n\t\t}\n\t};\n});\n},{\"../../assets/elements\":\"assets\\\\elements.js\",\"../../assets/resources\":\"assets\\\\resources.js\",\"../../utils/abbreviation\":\"utils\\\\abbreviation.js\",\"../../utils/common\":\"utils\\\\common.js\"}],\"parser\\\\processor\\\\tagName.js\":[function(require,module,exports){\n/**\n * Resolves tag names in abbreviations with implied name\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar tagName = require('../../resolver/tagName');\n\n\t/**\n\t * Resolves implicit node names in parsed tree\n\t * @param {AbbreviationNode} tree\n\t */\n\tfunction resolveNodeNames(tree) {\n\t\ttree.children.forEach(function(node) {\n\t\t\tif (node.hasImplicitName() || node.data('forceNameResolving')) {\n\t\t\t\tnode._name = tagName.resolve(node.parent.name());\n\t\t\t\tnode.data('nameResolved', true);\n\t\t\t}\n\t\t\tresolveNodeNames(node);\n\t\t});\n\t\t\n\t\treturn tree;\n\t}\n\n\treturn {\n\t\tpostprocessor: resolveNodeNames\n\t};\n});\n},{\"../../resolver/tagName\":\"resolver\\\\tagName.js\"}],\"parser\\\\xml.js\":[function(require,module,exports){\n/**\n * HTML tokenizer by Marijn Haverbeke\n * http://codemirror.net/\n * @constructor\n * @memberOf __xmlParseDefine\n * @param {Function} require\n * @param {Underscore} _\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar stringStream = require('../assets/stringStream');\n\n\tvar Kludges = {\n\t\tautoSelfClosers : {},\n\t\timplicitlyClosed : {},\n\t\tcontextGrabbers : {},\n\t\tdoNotIndent : {},\n\t\tallowUnquoted : true,\n\t\tallowMissing : true\n\t};\n\n\t// Return variables for tokenizers\n\tvar tagName = null, type = null;\n\n\tfunction inText(stream, state) {\n\t\tfunction chain(parser) {\n\t\t\tstate.tokenize = parser;\n\t\t\treturn parser(stream, state);\n\t\t}\n\n\t\tvar ch = stream.next();\n\t\tif (ch == \"<\") {\n\t\t\tif (stream.eat(\"!\")) {\n\t\t\t\tif (stream.eat(\"[\")) {\n\t\t\t\t\tif (stream.match(\"CDATA[\"))\n\t\t\t\t\t\treturn chain(inBlock(\"atom\", \"]]>\"));\n\t\t\t\t\telse\n\t\t\t\t\t\treturn null;\n\t\t\t\t} else if (stream.match(\"--\"))\n\t\t\t\t\treturn chain(inBlock(\"comment\", \"-->\"));\n\t\t\t\telse if (stream.match(\"DOCTYPE\", true, true)) {\n\t\t\t\t\tstream.eatWhile(/[\\w\\._\\-]/);\n\t\t\t\t\treturn chain(doctype(1));\n\t\t\t\t} else\n\t\t\t\t\treturn null;\n\t\t\t} else if (stream.eat(\"?\")) {\n\t\t\t\tstream.eatWhile(/[\\w\\._\\-]/);\n\t\t\t\tstate.tokenize = inBlock(\"meta\", \"?>\");\n\t\t\t\treturn \"meta\";\n\t\t\t} else {\n\t\t\t\ttype = stream.eat(\"/\") ? \"closeTag\" : \"openTag\";\n\t\t\t\tstream.eatSpace();\n\t\t\t\ttagName = \"\";\n\t\t\t\tvar c;\n\t\t\t\twhile ((c = stream.eat(/[^\\s\\u00a0=<>\\\"\\'\\/?]/)))\n\t\t\t\t\ttagName += c;\n\t\t\t\tstate.tokenize = inTag;\n\t\t\t\treturn \"tag\";\n\t\t\t}\n\t\t} else if (ch == \"&\") {\n\t\t\tvar ok;\n\t\t\tif (stream.eat(\"#\")) {\n\t\t\t\tif (stream.eat(\"x\")) {\n\t\t\t\t\tok = stream.eatWhile(/[a-fA-F\\d]/) && stream.eat(\";\");\n\t\t\t\t} else {\n\t\t\t\t\tok = stream.eatWhile(/[\\d]/) && stream.eat(\";\");\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tok = stream.eatWhile(/[\\w\\.\\-:]/) && stream.eat(\";\");\n\t\t\t}\n\t\t\treturn ok ? \"atom\" : \"error\";\n\t\t} else {\n\t\t\tstream.eatWhile(/[^&<]/);\n\t\t\treturn \"text\";\n\t\t}\n\t}\n\n\tfunction inTag(stream, state) {\n\t\tvar ch = stream.next();\n\t\tif (ch == \">\" || (ch == \"/\" && stream.eat(\">\"))) {\n\t\t\tstate.tokenize = inText;\n\t\t\ttype = ch == \">\" ? \"endTag\" : \"selfcloseTag\";\n\t\t\treturn \"tag\";\n\t\t} else if (ch == \"=\") {\n\t\t\ttype = \"equals\";\n\t\t\treturn null;\n\t\t} else if (/[\\'\\\"]/.test(ch)) {\n\t\t\tstate.tokenize = inAttribute(ch);\n\t\t\treturn state.tokenize(stream, state);\n\t\t} else {\n\t\t\tstream.eatWhile(/[^\\s\\u00a0=<>\\\"\\'\\/?]/);\n\t\t\treturn \"word\";\n\t\t}\n\t}\n\n\tfunction inAttribute(quote) {\n\t\treturn function(stream, state) {\n\t\t\twhile (!stream.eol()) {\n\t\t\t\tif (stream.next() == quote) {\n\t\t\t\t\tstate.tokenize = inTag;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn \"string\";\n\t\t};\n\t}\n\n\tfunction inBlock(style, terminator) {\n\t\treturn function(stream, state) {\n\t\t\twhile (!stream.eol()) {\n\t\t\t\tif (stream.match(terminator)) {\n\t\t\t\t\tstate.tokenize = inText;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tstream.next();\n\t\t\t}\n\t\t\treturn style;\n\t\t};\n\t}\n\t\n\tfunction doctype(depth) {\n\t\treturn function(stream, state) {\n\t\t\tvar ch;\n\t\t\twhile ((ch = stream.next()) !== null) {\n\t\t\t\tif (ch == \"<\") {\n\t\t\t\t\tstate.tokenize = doctype(depth + 1);\n\t\t\t\t\treturn state.tokenize(stream, state);\n\t\t\t\t} else if (ch == \">\") {\n\t\t\t\t\tif (depth == 1) {\n\t\t\t\t\t\tstate.tokenize = inText;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tstate.tokenize = doctype(depth - 1);\n\t\t\t\t\t\treturn state.tokenize(stream, state);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn \"meta\";\n\t\t};\n\t}\n\n\tvar curState = null, setStyle;\n\tfunction pass() {\n\t\tfor (var i = arguments.length - 1; i >= 0; i--)\n\t\t\tcurState.cc.push(arguments[i]);\n\t}\n\t\n\tfunction cont() {\n\t\tpass.apply(null, arguments);\n\t\treturn true;\n\t}\n\n\tfunction pushContext(tagName, startOfLine) {\n\t\tvar noIndent = Kludges.doNotIndent.hasOwnProperty(tagName) \n\t\t\t|| (curState.context && curState.context.noIndent);\n\t\tcurState.context = {\n\t\t\tprev : curState.context,\n\t\t\ttagName : tagName,\n\t\t\tindent : curState.indented,\n\t\t\tstartOfLine : startOfLine,\n\t\t\tnoIndent : noIndent\n\t\t};\n\t}\n\t\n\tfunction popContext() {\n\t\tif (curState.context)\n\t\t\tcurState.context = curState.context.prev;\n\t}\n\n\tfunction element(type) {\n\t\tif (type == \"openTag\") {\n\t\t\tcurState.tagName = tagName;\n\t\t\treturn cont(attributes, endtag(curState.startOfLine));\n\t\t} else if (type == \"closeTag\") {\n\t\t\tvar err = false;\n\t\t\tif (curState.context) {\n\t\t\t\tif (curState.context.tagName != tagName) {\n\t\t\t\t\tif (Kludges.implicitlyClosed.hasOwnProperty(curState.context.tagName.toLowerCase())) {\n\t\t\t\t\t\tpopContext();\n\t\t\t\t\t}\n\t\t\t\t\terr = !curState.context || curState.context.tagName != tagName;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\terr = true;\n\t\t\t}\n\t\t\t\n\t\t\tif (err)\n\t\t\t\tsetStyle = \"error\";\n\t\t\treturn cont(endclosetag(err));\n\t\t}\n\t\treturn cont();\n\t}\n\t\n\tfunction endtag(startOfLine) {\n\t\treturn function(type) {\n\t\t\tif (type == \"selfcloseTag\"\n\t\t\t\t\t|| (type == \"endTag\" && Kludges.autoSelfClosers\n\t\t\t\t\t\t\t.hasOwnProperty(curState.tagName\n\t\t\t\t\t\t\t\t\t.toLowerCase()))) {\n\t\t\t\tmaybePopContext(curState.tagName.toLowerCase());\n\t\t\t\treturn cont();\n\t\t\t}\n\t\t\tif (type == \"endTag\") {\n\t\t\t\tmaybePopContext(curState.tagName.toLowerCase());\n\t\t\t\tpushContext(curState.tagName, startOfLine);\n\t\t\t\treturn cont();\n\t\t\t}\n\t\t\treturn cont();\n\t\t};\n\t}\n\t\n\tfunction endclosetag(err) {\n\t\treturn function(type) {\n\t\t\tif (err)\n\t\t\t\tsetStyle = \"error\";\n\t\t\tif (type == \"endTag\") {\n\t\t\t\tpopContext();\n\t\t\t\treturn cont();\n\t\t\t}\n\t\t\tsetStyle = \"error\";\n\t\t\treturn cont(arguments.callee);\n\t\t};\n\t}\n\t\n\tfunction maybePopContext(nextTagName) {\n\t\tvar parentTagName;\n\t\twhile (true) {\n\t\t\tif (!curState.context) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tparentTagName = curState.context.tagName.toLowerCase();\n\t\t\tif (!Kludges.contextGrabbers.hasOwnProperty(parentTagName)\n\t\t\t\t\t|| !Kludges.contextGrabbers[parentTagName].hasOwnProperty(nextTagName)) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tpopContext();\n\t\t}\n\t}\n\n\tfunction attributes(type) {\n\t\tif (type == \"word\") {\n\t\t\tsetStyle = \"attribute\";\n\t\t\treturn cont(attribute, attributes);\n\t\t}\n\t\tif (type == \"endTag\" || type == \"selfcloseTag\")\n\t\t\treturn pass();\n\t\tsetStyle = \"error\";\n\t\treturn cont(attributes);\n\t}\n\t\n\tfunction attribute(type) {\n\t\tif (type == \"equals\")\n\t\t\treturn cont(attvalue, attributes);\n\t\tif (!Kludges.allowMissing)\n\t\t\tsetStyle = \"error\";\n\t\treturn (type == \"endTag\" || type == \"selfcloseTag\") ? pass()\n\t\t\t\t: cont();\n\t}\n\t\n\tfunction attvalue(type) {\n\t\tif (type == \"string\")\n\t\t\treturn cont(attvaluemaybe);\n\t\tif (type == \"word\" && Kludges.allowUnquoted) {\n\t\t\tsetStyle = \"string\";\n\t\t\treturn cont();\n\t\t}\n\t\tsetStyle = \"error\";\n\t\treturn (type == \"endTag\" || type == \"selfCloseTag\") ? pass()\n\t\t\t\t: cont();\n\t}\n\t\n\tfunction attvaluemaybe(type) {\n\t\tif (type == \"string\")\n\t\t\treturn cont(attvaluemaybe);\n\t\telse\n\t\t\treturn pass();\n\t}\n\t\n\tfunction startState() {\n\t\treturn {\n\t\t\ttokenize : inText,\n\t\t\tcc : [],\n\t\t\tindented : 0,\n\t\t\tstartOfLine : true,\n\t\t\ttagName : null,\n\t\t\tcontext : null\n\t\t};\n\t}\n\t\n\tfunction token(stream, state) {\n\t\tif (stream.sol()) {\n\t\t\tstate.startOfLine = true;\n\t\t\tstate.indented = 0;\n\t\t}\n\t\t\n\t\tif (stream.eatSpace())\n\t\t\treturn null;\n\n\t\tsetStyle = type = tagName = null;\n\t\tvar style = state.tokenize(stream, state);\n\t\tstate.type = type;\n\t\tif ((style || type) && style != \"comment\") {\n\t\t\tcurState = state;\n\t\t\twhile (true) {\n\t\t\t\tvar comb = state.cc.pop() || element;\n\t\t\t\tif (comb(type || style))\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\tstate.startOfLine = false;\n\t\treturn setStyle || style;\n\t}\n\n\treturn {\n\t\t/**\n\t\t * @memberOf emmet.xmlParser\n\t\t * @returns\n\t\t */\n\t\tparse: function(data, offset) {\n\t\t\toffset = offset || 0;\n\t\t\tvar state = startState();\n\t\t\tvar stream = stringStream.create(data);\n\t\t\tvar tokens = [];\n\t\t\twhile (!stream.eol()) {\n\t\t\t\ttokens.push({\n\t\t\t\t\ttype: token(stream, state),\n\t\t\t\t\tstart: stream.start + offset,\n\t\t\t\t\tend: stream.pos + offset\n\t\t\t\t});\n\t\t\t\tstream.start = stream.pos;\n\t\t\t}\n\t\t\t\n\t\t\treturn tokens;\n\t\t}\t\t\n\t};\n});\n\n},{\"../assets/stringStream\":\"assets\\\\stringStream.js\"}],\"plugin\\\\file.js\":[function(require,module,exports){\n/**\n * Module for working with file. Shall implement\n * IEmmetFile interface.\n *\n * Since implementation of this module depends\n * greatly on current runtime, this module must be\n * initialized with actual implementation first\n * before use. E.g.\n * require('./plugin/file')({\n * \tread: function() {...}\n * })\n *\n * By default, this module provides Node.JS implementation\n */\n\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar utils = require('../utils/common');\n\tvar _transport = {};\n\n\t// hide it from Require.JS parser\n\t(function(r) {\n\t\tif (typeof define === 'undefined' || !define.amd) {\n\t\t\ttry {\n\t\t\t\tfs = r('fs');\n\t\t\t\tpath = r('path');\n\t\t\t\t_transport.http = r('http');\n\t\t\t\t_transport.https = r('https');\n\t\t\t} catch(e) { }\n\t\t}\n\t})(require);\n\n\t// module is a function that can extend itself\n\tmodule.exports = function(obj) {\n\t\tif (obj) {\n\t\t\tutils.extend(module.exports, obj);\n\t\t}\n\t};\n\n\tfunction bts(bytes) {\n\t\tvar out = [];\n\t\tfor (var i = 0, il = bytes.length; i < il; i++) {\n\t\t\tout.push(String.fromCharCode(bytes[i]));\n\t\t}\n\t\treturn out.join('');\n\t}\n\n\tfunction isURL(path) {\n\t\tvar re = /^https?:\\/\\//;\n\t\treturn re.test(path);\n\t}\n\n\treturn utils.extend(module.exports, {\n\t\t_parseParams: function(args) {\n\t\t\tvar params = {\n\t\t\t\tpath: args[0],\n\t\t\t\tsize: 0\n\t\t\t};\n\n\t\t\targs = utils.toArray(args, 1);\n\t\t\tparams.callback = args[args.length - 1];\n\t\t\targs = args.slice(0, args.length - 1);\n\t\t\tif (args.length) {\n\t\t\t\tparams.size = args[0];\n\t\t\t}\n\n\t\t\treturn params;\n\t\t},\n\n\t\t_read: function(params, callback) {\n\t\t\tif (isURL(params.path)) {\n\t\t\t\tvar req = _transport[/^https:/.test(params.path) ? 'https' : 'http'].get(params.path, function(res) {\n\t\t\t\t\tvar bufs = [];\n\t\t\t\t\tvar totalLength = 0;\n\t\t\t\t\tvar finished = false;\n\t\t\t\t\tres\n\t\t\t\t\t\t.on('data', function(chunk) {\n\t\t\t\t\t\t\ttotalLength += chunk.length;\n\t\t\t\t\t\t\tbufs.push(chunk);\n\t\t\t\t\t\t\tif (params.size && totalLength >= params.size) {\n\t\t\t\t\t\t\t\tfinished = true;\n\t\t\t\t\t\t\t\tcallback(null, Buffer.concat(bufs));\n\t\t\t\t\t\t\t\treq.abort();\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t})\n\t\t\t\t\t\t.on('end', function() {\n\t\t\t\t\t\t\tif (!finished) {\n\t\t\t\t\t\t\t\tfinished = true;\n\t\t\t\t\t\t\t\tcallback(null, Buffer.concat(bufs));\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t});\n\t\t\t\t}).on('error', callback);\n\t\t\t} else {\n\t\t\t\tif (params.size) {\n\t\t\t\t\tvar fd = fs.openSync(params.path, 'r');\n\t\t\t\t\tvar buf = new Buffer(params.size);\n\t\t\t\t\tfs.read(fd, buf, 0, params.size, null, function(err, bytesRead) {\n\t\t\t\t\t\tcallback(err, buf)\n\t\t\t\t\t});\n\t\t\t\t} else {\n\t\t\t\t\tcallback(null, fs.readFileSync(params.path));\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\n\t\t/**\n\t\t * Reads binary file content and return it\n\t\t * @param {String} path File's relative or absolute path\n\t\t * @return {String}\n\t\t */\n\t\tread: function(path, size, callback) {\n\t\t\tvar params = this._parseParams(arguments);\n\t\t\tthis._read(params, function(err, buf) {\n\t\t\t\tparams.callback(err, err ? '' : bts(buf));\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Read file content and return it\n\t\t * @param {String} path File's relative or absolute path\n\t\t * @return {String}\n\t\t */\n\t\treadText: function(path, size, callback) {\n\t\t\tvar params = this._parseParams(arguments);\n\t\t\tthis._read(params, function(err, buf) {\n\t\t\t\tparams.callback(err, err ? '' : buf.toString());\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Locate <code>file_name</code> file that relates to <code>editor_file</code>.\n\t\t * File name may be absolute or relative path\n\t\t *\n\t\t * <b>Dealing with absolute path.</b>\n\t\t * Many modern editors have a \"project\" support as information unit, but you\n\t\t * should not rely on project path to find file with absolute path. First,\n\t\t * it requires user to create a project before using this method (and this\n\t\t * is not very convenient). Second, project path doesn't always points to\n\t\t * to website's document root folder: it may point, for example, to an\n\t\t * upper folder which contains server-side scripts.\n\t\t *\n\t\t * For better result, you should use the following algorithm in locating\n\t\t * absolute resources:\n\t\t * 1) Get parent folder for <code>editorFile</code> as a start point\n\t\t * 2) Append required <code>fileName</code> to start point and test if\n\t\t * file exists\n\t\t * 3) If it doesn't exists, move start point one level up (to parent folder)\n\t\t * and repeat step 2.\n\t\t *\n\t\t * @param {String} editorFile\n\t\t * @param {String} fileName\n\t\t * @return {String} Returns null if <code>fileName</code> cannot be located\n\t\t */\n\t\tlocateFile: function(editorFile, fileName, callback) {\n\t\t\tif (isURL(fileName)) {\n\t\t\t\treturn callback(fileName);\n\t\t\t}\n\n\t\t\tvar dirname = editorFile\n\t\t\tvar filepath;\n\t\t\tfileName = fileName.replace(/^\\/+/, '');\n\t\t\twhile (dirname && dirname !== path.dirname(dirname)) {\n\t\t\t\tdirname = path.dirname(dirname);\n\t\t\t\tfilepath = path.join(dirname, fileName);\n\t\t\t\tif (fs.existsSync(filepath))\n\t\t\t\t\treturn callback(filepath);\n\t\t\t}\n\n\t\t\tcallback(null);\n\t\t},\n\n\t\t/**\n\t\t * Creates absolute path by concatenating <code>parent</code> and <code>fileName</code>.\n\t\t * If <code>parent</code> points to file, its parent directory is used\n\t\t * @param {String} parent\n\t\t * @param {String} fileName\n\t\t * @return {String}\n\t\t */\n\t\tcreatePath: function(parent, fileName, callback) {\n\t\t\tfs.stat(parent, function(err, stat) {\n\t\t\t\tif (err) {\n\t\t\t\t\treturn callback(err);\n\t\t\t\t}\n\n\t\t\t\tif (stat.isFile()) {\n\t\t\t\t\tparent = path.dirname(parent);\n\t\t\t\t}\n\n\t\t\t\tvar filepath = path.resolve(parent, fileName);\n\t\t\t\tcallback(null, filepath);\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Saves <code>content</code> as <code>file</code>\n\t\t * @param {String} file File's absolute path\n\t\t * @param {String} content File content\n\t\t */\n\t\tsave: function(file, content, callback) {\n\t\t\tfs.writeFile(file, content, 'ascii', function(err) {\n\t\t\t\tcallback(err ? err : null);\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Returns file extension in lower case\n\t\t * @param {String} file\n\t\t * @return {String}\n\t\t */\n\t\tgetExt: function(file) {\n\t\t\tvar m = (file || '').match(/\\.([\\w\\-]+)$/);\n\t\t\treturn m ? m[1].toLowerCase() : '';\n\t\t}\n\n\t});\n});\n\n},{\"../utils/common\":\"utils\\\\common.js\"}],\"resolver\\\\css.js\":[function(require,module,exports){\n/**\n * Resolver for fast CSS typing. Handles abbreviations with the following \n * notation:<br>\n * \n * <code>(-vendor prefix)?property(value)*(!)?</code>\n * \n * <br><br>\n * <b>Abbreviation handling</b><br>\n * \n * By default, Emmet searches for matching snippet definition for provided abbreviation.\n * If snippet wasn't found, Emmet automatically generates element with \n * abbreviation's name. For example, <code>foo</code> abbreviation will generate\n * <code>&lt;foo&gt;&lt;/foo&gt;</code> output.\n * <br><br>\n * This module will capture all expanded properties and upgrade them with values, \n * vendor prefixes and !important declarations. All unmatched abbreviations will \n * be automatically transformed into <code>property-name: ${1}</code> snippets. \n * \n * <b>Vendor prefixes<b><br>\n * \n * If CSS-property is preceded with dash, resolver should output property with\n * all <i>known</i> vendor prefixes. For example, if <code>brad</code> \n * abbreviation generates <code>border-radius: ${value};</code> snippet,\n * the <code>-brad</code> abbreviation should generate:\n * <pre><code>\n * -webkit-border-radius: ${value};\n * -moz-border-radius: ${value};\n * border-radius: ${value};\n * </code></pre>\n * Note that <i>o</i> and <i>ms</i> prefixes are omitted since Opera and IE \n * supports unprefixed property.<br><br>\n * \n * Users can also provide an explicit list of one-character prefixes for any\n * CSS property. For example, <code>-wm-float</code> will produce\n * \n * <pre><code>\n * -webkit-float: ${1};\n * -moz-float: ${1};\n * float: ${1};\n * </code></pre>\n * \n * Although this example looks pointless, users can use this feature to write\n * cutting-edge properties implemented by browser vendors recently.  \n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar prefs = require('../assets/preferences');\n\tvar resources = require('../assets/resources');\n\tvar stringStream = require('../assets/stringStream');\n\tvar ciu = require('../assets/caniuse');\n\tvar utils = require('../utils/common');\n\tvar template = require('../utils/template');\n\tvar cssEditTree = require('../editTree/css');\n\n\tvar prefixObj = {\n\t\t/** Real vendor prefix name */\n\t\tprefix: 'emmet',\n\t\t\n\t\t/** \n\t\t * Indicates this prefix is obsolete and should't be used when user \n\t\t * wants to generate all-prefixed properties\n\t\t */\n\t\tobsolete: false,\n\t\t\n\t\t/**\n\t\t * Returns prefixed CSS property name\n\t\t * @param {String} name Unprefixed CSS property\n\t\t */\n\t\ttransformName: function(name) {\n\t\t\treturn '-' + this.prefix + '-' + name;\n\t\t},\n\t\t\n\t\t/**\n\t\t * List of unprefixed CSS properties that supported by \n\t\t * current prefix. This list is used to generate all-prefixed property\n\t\t * @returns {Array} \n\t\t */\n\t\tproperties: function() {\n\t\t\treturn getProperties('css.' + this.prefix + 'Properties') || [];\n\t\t},\n\t\t\n\t\t/**\n\t\t * Check if given property is supported by current prefix\n\t\t * @param name\n\t\t */\n\t\tsupports: function(name) {\n\t\t\treturn ~this.properties().indexOf(name);\n\t\t}\n\t};\n\t\n\t\n\t/** \n\t * List of registered one-character prefixes. Key is a one-character prefix, \n\t * value is an <code>prefixObj</code> object\n\t */\n\tvar vendorPrefixes = {};\n\t\n\tvar defaultValue = '${1};';\n\t\n\t// XXX module preferences\n\tprefs.define('css.valueSeparator', ': ',\n\t\t\t'Defines a symbol that should be placed between CSS property and ' \n\t\t\t+ 'value when expanding CSS abbreviations.');\n\tprefs.define('css.propertyEnd', ';',\n\t\t\t'Defines a symbol that should be placed at the end of CSS property  ' \n\t\t\t+ 'when expanding CSS abbreviations.');\n\t\n\tprefs.define('stylus.valueSeparator', ' ',\n\t\t\t'Defines a symbol that should be placed between CSS property and ' \n\t\t\t+ 'value when expanding CSS abbreviations in Stylus dialect.');\n\tprefs.define('stylus.propertyEnd', '',\n\t\t\t'Defines a symbol that should be placed at the end of CSS property  ' \n\t\t\t+ 'when expanding CSS abbreviations in Stylus dialect.');\n\t\n\tprefs.define('sass.propertyEnd', '',\n\t\t\t'Defines a symbol that should be placed at the end of CSS property  ' \n\t\t\t+ 'when expanding CSS abbreviations in SASS dialect.');\n\n\tprefs.define('css.syntaxes', 'css, less, sass, scss, stylus, styl',\n\t\t\t'List of syntaxes that should be treated as CSS dialects.');\n\t\n\tprefs.define('css.autoInsertVendorPrefixes', true,\n\t\t\t'Automatically generate vendor-prefixed copies of expanded CSS ' \n\t\t\t+ 'property. By default, Emmet will generate vendor-prefixed '\n\t\t\t+ 'properties only when you put dash before abbreviation ' \n\t\t\t+ '(e.g. <code>-bxsh</code>). With this option enabled, you don’t ' \n\t\t\t+ 'need dashes before abbreviations: Emmet will produce ' \n\t\t\t+ 'vendor-prefixed properties for you.');\n\n\tprefs.define('less.autoInsertVendorPrefixes', false, 'Same as <code>css.autoInsertVendorPrefixes</code> but for LESS syntax');\n\tprefs.define('scss.autoInsertVendorPrefixes', false, 'Same as <code>css.autoInsertVendorPrefixes</code> but for SCSS syntax');\n\tprefs.define('sass.autoInsertVendorPrefixes', false, 'Same as <code>css.autoInsertVendorPrefixes</code> but for SASS syntax');\n\tprefs.define('stylus.autoInsertVendorPrefixes', false, 'Same as <code>css.autoInsertVendorPrefixes</code> but for Stylus syntax');\n\t\n\tvar descTemplate = template('A comma-separated list of CSS properties that may have ' \n\t\t+ '<code><%= vendor %></code> vendor prefix. This list is used to generate '\n\t\t+ 'a list of prefixed properties when expanding <code>-property</code> '\n\t\t+ 'abbreviations. Empty list means that all possible CSS values may ' \n\t\t+ 'have <code><%= vendor %></code> prefix.');\n\t\n\tvar descAddonTemplate = template('A comma-separated list of <em>additional</em> CSS properties ' \n\t\t\t+ 'for <code>css.<%= vendor %>Preperties</code> preference. ' \n\t\t\t+ 'You should use this list if you want to add or remove a few CSS ' \n\t\t\t+ 'properties to original set. To add a new property, simply write its name, '\n\t\t\t+ 'to remove it, precede property with hyphen.<br>'\n\t\t\t+ 'For example, to add <em>foo</em> property and remove <em>border-radius</em> one, '\n\t\t\t+ 'the preference value will look like this: <code>foo, -border-radius</code>.');\n\t\n\t// properties list is created from cssFeatures.html file\n\tvar props = {\n\t\t'webkit': 'animation, animation-delay, animation-direction, animation-duration, animation-fill-mode, animation-iteration-count, animation-name, animation-play-state, animation-timing-function, appearance, backface-visibility, background-clip, background-composite, background-origin, background-size, border-fit, border-horizontal-spacing, border-image, border-vertical-spacing, box-align, box-direction, box-flex, box-flex-group, box-lines, box-ordinal-group, box-orient, box-pack, box-reflect, box-shadow, color-correction, column-break-after, column-break-before, column-break-inside, column-count, column-gap, column-rule-color, column-rule-style, column-rule-width, column-span, column-width, dashboard-region, font-smoothing, highlight, hyphenate-character, hyphenate-limit-after, hyphenate-limit-before, hyphens, line-box-contain, line-break, line-clamp, locale, margin-before-collapse, margin-after-collapse, marquee-direction, marquee-increment, marquee-repetition, marquee-style, mask-attachment, mask-box-image, mask-box-image-outset, mask-box-image-repeat, mask-box-image-slice, mask-box-image-source, mask-box-image-width, mask-clip, mask-composite, mask-image, mask-origin, mask-position, mask-repeat, mask-size, nbsp-mode, perspective, perspective-origin, rtl-ordering, text-combine, text-decorations-in-effect, text-emphasis-color, text-emphasis-position, text-emphasis-style, text-fill-color, text-orientation, text-security, text-stroke-color, text-stroke-width, transform, transition, transform-origin, transform-style, transition-delay, transition-duration, transition-property, transition-timing-function, user-drag, user-modify, user-select, writing-mode, svg-shadow, box-sizing, border-radius',\n\t\t'moz': 'animation-delay, animation-direction, animation-duration, animation-fill-mode, animation-iteration-count, animation-name, animation-play-state, animation-timing-function, appearance, backface-visibility, background-inline-policy, binding, border-bottom-colors, border-image, border-left-colors, border-right-colors, border-top-colors, box-align, box-direction, box-flex, box-ordinal-group, box-orient, box-pack, box-shadow, box-sizing, column-count, column-gap, column-rule-color, column-rule-style, column-rule-width, column-width, float-edge, font-feature-settings, font-language-override, force-broken-image-icon, hyphens, image-region, orient, outline-radius-bottomleft, outline-radius-bottomright, outline-radius-topleft, outline-radius-topright, perspective, perspective-origin, stack-sizing, tab-size, text-blink, text-decoration-color, text-decoration-line, text-decoration-style, text-size-adjust, transform, transform-origin, transform-style, transition, transition-delay, transition-duration, transition-property, transition-timing-function, user-focus, user-input, user-modify, user-select, window-shadow, background-clip, border-radius',\n\t\t'ms': 'accelerator, backface-visibility, background-position-x, background-position-y, behavior, block-progression, box-align, box-direction, box-flex, box-line-progression, box-lines, box-ordinal-group, box-orient, box-pack, content-zoom-boundary, content-zoom-boundary-max, content-zoom-boundary-min, content-zoom-chaining, content-zoom-snap, content-zoom-snap-points, content-zoom-snap-type, content-zooming, filter, flow-from, flow-into, font-feature-settings, grid-column, grid-column-align, grid-column-span, grid-columns, grid-layer, grid-row, grid-row-align, grid-row-span, grid-rows, high-contrast-adjust, hyphenate-limit-chars, hyphenate-limit-lines, hyphenate-limit-zone, hyphens, ime-mode, interpolation-mode, layout-flow, layout-grid, layout-grid-char, layout-grid-line, layout-grid-mode, layout-grid-type, line-break, overflow-style, perspective, perspective-origin, perspective-origin-x, perspective-origin-y, scroll-boundary, scroll-boundary-bottom, scroll-boundary-left, scroll-boundary-right, scroll-boundary-top, scroll-chaining, scroll-rails, scroll-snap-points-x, scroll-snap-points-y, scroll-snap-type, scroll-snap-x, scroll-snap-y, scrollbar-arrow-color, scrollbar-base-color, scrollbar-darkshadow-color, scrollbar-face-color, scrollbar-highlight-color, scrollbar-shadow-color, scrollbar-track-color, text-align-last, text-autospace, text-justify, text-kashida-space, text-overflow, text-size-adjust, text-underline-position, touch-action, transform, transform-origin, transform-origin-x, transform-origin-y, transform-origin-z, transform-style, transition, transition-delay, transition-duration, transition-property, transition-timing-function, user-select, word-break, wrap-flow, wrap-margin, wrap-through, writing-mode',\n\t\t'o': 'dashboard-region, animation, animation-delay, animation-direction, animation-duration, animation-fill-mode, animation-iteration-count, animation-name, animation-play-state, animation-timing-function, border-image, link, link-source, object-fit, object-position, tab-size, table-baseline, transform, transform-origin, transition, transition-delay, transition-duration, transition-property, transition-timing-function, accesskey, input-format, input-required, marquee-dir, marquee-loop, marquee-speed, marquee-style'\n\t};\n\t\n\tObject.keys(props).forEach(function(k) {\n\t\tprefs.define('css.' + k + 'Properties', props[k], descTemplate({vendor: k}));\n\t\tprefs.define('css.' + k + 'PropertiesAddon', '', descAddonTemplate({vendor: k}));\n\t});\n\t\n\tprefs.define('css.unitlessProperties', 'z-index, line-height, opacity, font-weight, zoom', \n\t\t\t'The list of properties whose values ​​must not contain units.');\n\t\n\tprefs.define('css.intUnit', 'px', 'Default unit for integer values');\n\tprefs.define('css.floatUnit', 'em', 'Default unit for float values');\n\t\n\tprefs.define('css.keywords', 'auto, inherit, all', \n\t\t\t'A comma-separated list of valid keywords that can be used in CSS abbreviations.');\n\t\n\tprefs.define('css.keywordAliases', 'a:auto, i:inherit, s:solid, da:dashed, do:dotted, t:transparent', \n\t\t\t'A comma-separated list of keyword aliases, used in CSS abbreviation. '\n\t\t\t+ 'Each alias should be defined as <code>alias:keyword_name</code>.');\n\t\n\tprefs.define('css.unitAliases', 'e:em, p:%, x:ex, r:rem', \n\t\t\t'A comma-separated list of unit aliases, used in CSS abbreviation. '\n\t\t\t+ 'Each alias should be defined as <code>alias:unit_value</code>.');\n\t\n\tprefs.define('css.color.short', true, \n\t\t\t'Should color values like <code>#ffffff</code> be shortened to '\n\t\t\t+ '<code>#fff</code> after abbreviation with color was expanded.');\n\t\n\tprefs.define('css.color.case', 'keep', \n\t\t\t'Letter case of color values generated by abbreviations with color '\n\t\t\t+ '(like <code>c#0</code>). Possible values are <code>upper</code>, '\n\t\t\t+ '<code>lower</code> and <code>keep</code>.');\n\t\n\tprefs.define('css.fuzzySearch', true, \n\t\t\t'Enable fuzzy search among CSS snippet names. When enabled, every ' \n\t\t\t+ '<em>unknown</em> snippet will be scored against available snippet '\n\t\t\t+ 'names (not values or CSS properties!). The match with best score '\n\t\t\t+ 'will be used to resolve snippet value. For example, with this ' \n\t\t\t+ 'preference enabled, the following abbreviations are equal: '\n\t\t\t+ '<code>ov:h</code> == <code>ov-h</code> == <code>o-h</code> == '\n\t\t\t+ '<code>oh</code>');\n\t\n\tprefs.define('css.fuzzySearchMinScore', 0.3, \n\t\t\t'The minium score (from 0 to 1) that fuzzy-matched abbreviation should ' \n\t\t\t+ 'achive. Lower values may produce many false-positive matches, '\n\t\t\t+ 'higher values may reduce possible matches.');\n\t\n\tprefs.define('css.alignVendor', false, \n\t\t\t'If set to <code>true</code>, all generated vendor-prefixed properties ' \n\t\t\t+ 'will be aligned by real property name.');\n\t\n\t\n\tfunction isNumeric(ch) {\n\t\tvar code = ch && ch.charCodeAt(0);\n\t\treturn (ch && ch == '.' || (code > 47 && code < 58));\n\t}\n\t\n\t/**\n\t * Check if provided snippet contains only one CSS property and value.\n\t * @param {String} snippet\n\t * @returns {Boolean}\n\t */\n\tfunction isSingleProperty(snippet) {\n\t\tsnippet = utils.trim(snippet);\n\t\t\n\t\t// check if it doesn't contain a comment and a newline\n\t\tif (/\\/\\*|\\n|\\r/.test(snippet)) {\n\t\t\treturn false;\n\t\t}\n\t\t\n\t\t// check if it's a valid snippet definition\n\t\tif (!/^[a-z0-9\\-]+\\s*\\:/i.test(snippet)) {\n\t\t\treturn false;\n\t\t}\n\t\t\n\t\treturn snippet.replace(/\\$\\{.+?\\}/g, '').split(':').length == 2;\n\t}\n\t\n\t/**\n\t * Normalizes abbreviated value to final CSS one\n\t * @param {String} value\n\t * @returns {String}\n\t */\n\tfunction normalizeValue(value) {\n\t\tif (value.charAt(0) == '-' && !/^\\-[\\.\\d]/.test(value)) {\n\t\t\tvalue = value.replace(/^\\-+/, '');\n\t\t}\n\t\t\n\t\tvar ch = value.charAt(0);\n\t\tif (ch == '#') {\n\t\t\treturn normalizeHexColor(value);\n\t\t}\n\n\t\tif (ch == '$') {\n\t\t\treturn utils.escapeText(value);\n\t\t}\n\n\t\treturn getKeyword(value);\n\t}\n\t\n\tfunction normalizeHexColor(value) {\n\t\tvar hex = value.replace(/^#+/, '') || '0';\n\t\tif (hex.toLowerCase() == 't') {\n\t\t\treturn 'transparent';\n\t\t}\n\n\t\tvar opacity = '';\n\t\thex = hex.replace(/\\.(\\d+)$/, function(str) {\n\t\t\topacity = '0' + str;\n\t\t\treturn '';\n\t\t});\n\t\t\n\t\tvar repeat = utils.repeatString;\n\t\tvar color = null;\n\t\tswitch (hex.length) {\n\t\t\tcase 1:\n\t\t\t\tcolor = repeat(hex, 6);\n\t\t\t\tbreak;\n\t\t\tcase 2:\n\t\t\t\tcolor = repeat(hex, 3);\n\t\t\t\tbreak;\n\t\t\tcase 3:\n\t\t\t\tcolor = hex.charAt(0) + hex.charAt(0) + hex.charAt(1) + hex.charAt(1) + hex.charAt(2) + hex.charAt(2);\n\t\t\t\tbreak;\n\t\t\tcase 4:\n\t\t\t\tcolor = hex + hex.substr(0, 2);\n\t\t\t\tbreak;\n\t\t\tcase 5:\n\t\t\t\tcolor = hex + hex.charAt(0);\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tcolor = hex.substr(0, 6);\n\t\t}\n\n\t\tif (opacity) {\n\t\t\treturn toRgba(color, opacity);\n\t\t}\n\t\t\n\t\t// color must be shortened?\n\t\tif (prefs.get('css.color.short')) {\n\t\t\tvar p = color.split('');\n\t\t\tif (p[0] == p[1] && p[2] == p[3] && p[4] == p[5]) {\n\t\t\t\tcolor = p[0] + p[2] + p[4];\n\t\t\t}\n\t\t}\n\t\t\n\t\t// should transform case?\n\t\tswitch (prefs.get('css.color.case')) {\n\t\t\tcase 'upper':\n\t\t\t\tcolor = color.toUpperCase();\n\t\t\t\tbreak;\n\t\t\tcase 'lower':\n\t\t\t\tcolor = color.toLowerCase();\n\t\t\t\tbreak;\n\t\t}\n\t\t\n\t\treturn '#' + color;\n\t}\n\n\t/**\n\t * Transforms HEX color definition into RGBA one\n\t * @param  {String} color   HEX color, 6 characters\n\t * @param  {String} opacity Opacity value\n\t * @return {String}\n\t */\n\tfunction toRgba(color, opacity) {\n\t\tvar r = parseInt(color.substr(0, 2), 16);\n\t\tvar g = parseInt(color.substr(2, 2), 16);\n\t\tvar b = parseInt(color.substr(4, 2), 16);\n\n\t\treturn 'rgba(' + [r, g, b, opacity].join(', ') + ')';\n\t}\n\t\n\tfunction getKeyword(name) {\n\t\tvar aliases = prefs.getDict('css.keywordAliases');\n\t\treturn name in aliases ? aliases[name] : name;\n\t}\n\t\n\tfunction getUnit(name) {\n\t\tvar aliases = prefs.getDict('css.unitAliases');\n\t\treturn name in aliases ? aliases[name] : name;\n\t}\n\t\n\tfunction isValidKeyword(keyword) {\n\t\treturn ~prefs.getArray('css.keywords').indexOf(getKeyword(keyword));\n\t}\n\t\n\t/**\n\t * Check if passed CSS property support specified vendor prefix \n\t * @param {String} property\n\t * @param {String} prefix\n\t */\n\tfunction hasPrefix(property, prefix) {\n\t\tvar info = vendorPrefixes[prefix];\n\t\t\n\t\tif (!info)\n\t\t\tinfo = utils.find(vendorPrefixes, function(data) {\n\t\t\t\treturn data.prefix == prefix;\n\t\t\t});\n\t\t\n\t\treturn info && info.supports(property);\n\t}\n\n\t/**\n\t * Finds available vendor prefixes for given CSS property.\n\t * Search is performed within Can I Use database and internal\n\t * property list\n\t * @param  {String} property CSS property name\n\t * @return {Array} Array of resolved prefixes or null if\n\t * prefixes are not available for this property at all.\n\t * Empty array means prefixes are not available for current\n\t * user-define era\n\t */\n\tfunction findVendorPrefixes(property) {\n\t\tvar prefixes = ciu.resolvePrefixes(property);\n\t\tif (!prefixes) {\n\t\t\t// Can I Use database is disabled or prefixes are not\n\t\t\t// available for this property\n\t\t\tprefixes = [];\n\t\t\tObject.keys(vendorPrefixes).forEach(function(key) {\n\t\t\t\tif (hasPrefix(property, key)) {\n\t\t\t\t\tprefixes.push(vendorPrefixes[key].prefix);\n\t\t\t\t}\n\t\t\t});\n\n\t\t\tif (!prefixes.length) {\n\t\t\t\tprefixes = null;\n\t\t\t}\n\t\t}\n\n\t\treturn prefixes;\n\t}\n\t\n\t/**\n\t * Search for a list of supported prefixes for CSS property. This list\n\t * is used to generate all-prefixed snippet\n\t * @param {String} property CSS property name\n\t * @returns {Array}\n\t */\n\tfunction findInternalPrefixes(property, noAutofill) {\n\t\tvar result = [];\n\t\tvar prefixes = findVendorPrefixes(property);\n\t\t\n\t\tif (prefixes) {\n\t\t\tvar prefixMap = {};\n\t\t\tObject.keys(vendorPrefixes).forEach(function(key) {\n\t\t\t\tprefixMap[vendorPrefixes[key].prefix] = key;\n\t\t\t});\n\n\t\t\tresult = prefixes.map(function(prefix) {\n\t\t\t\treturn prefixMap[prefix];\n\t\t\t});\n\t\t}\n\t\t\n\t\tif (!result.length && !noAutofill) {\n\t\t\t// add all non-obsolete prefixes\n\t\t\tObject.keys(vendorPrefixes).forEach(function(prefix) {\n\t\t\t\tif (!vendorPrefixes[prefix].obsolete) {\n\t\t\t\t\tresult.push(prefix);\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t\t\n\t\treturn result;\n\t}\n\t\n\tfunction addPrefix(name, obj) {\n\t\tif (typeof obj === 'string') {\n\t\t\tobj = {prefix: obj};\n\t\t}\n\t\t\n\t\tvendorPrefixes[name] = utils.extend({}, prefixObj, obj);\n\t}\n\t\n\tfunction getSyntaxPreference(name, syntax) {\n\t\tif (syntax) {\n\t\t\t// hacky alias for Stylus dialect\n\t\t\tif (syntax == 'styl') {\n\t\t\t\tsyntax = 'stylus';\n\t\t\t}\n\n\t\t\tvar val = prefs.get(syntax + '.' + name);\n\t\t\tif (typeof val !== 'undefined') {\n\t\t\t\treturn val;\n\t\t\t}\n\t\t}\n\t\t\n\t\treturn prefs.get('css.' + name);\n\t}\n\t\n\t/**\n\t * Format CSS property according to current syntax dialect\n\t * @param {String} property\n\t * @param {String} syntax\n\t * @returns {String}\n\t */\n\tfunction formatProperty(property, syntax) {\n\t\tvar ix = property.indexOf(':');\n\t\tproperty = property.substring(0, ix).replace(/\\s+$/, '') \n\t\t\t+ getSyntaxPreference('valueSeparator', syntax)\n\t\t\t+ utils.trim(property.substring(ix + 1));\n\t\t\n\t\treturn property.replace(/\\s*;\\s*$/, getSyntaxPreference('propertyEnd', syntax));\n\t}\n\t\n\t/**\n\t * Transforms snippet value if required. For example, this transformation\n\t * may add <i>!important</i> declaration to CSS property\n\t * @param {String} snippet\n\t * @param {Boolean} isImportant\n\t * @returns {String}\n\t */\n\tfunction transformSnippet(snippet, isImportant, syntax) {\n\t\tif (typeof snippet !== 'string') {\n\t\t\tsnippet = snippet.data;\n\t\t}\n\t\t\n\t\tif (!isSingleProperty(snippet)) {\n\t\t\treturn snippet;\n\t\t}\n\t\t\n\t\tif (isImportant) {\n\t\t\tif (~snippet.indexOf(';')) {\n\t\t\t\tsnippet = snippet.split(';').join(' !important;');\n\t\t\t} else {\n\t\t\t\tsnippet += ' !important';\n\t\t\t}\n\t\t}\n\t\t\n\t\treturn formatProperty(snippet, syntax);\n\t}\n\t\n\tfunction getProperties(key) {\n\t\tvar list = prefs.getArray(key);\n\t\tvar addon = prefs.getArray(key + 'Addon');\n\t\tif (addon) {\n\t\t\taddon.forEach(function(prop) {\n\t\t\t\tif (prop.charAt(0) == '-') {\n\t\t\t\t\tlist = utils.without(list, prop.substr(1));\n\t\t\t\t} else {\n\t\t\t\t\tif (prop.charAt(0) == '+')\n\t\t\t\t\t\tprop = prop.substr(1);\n\t\t\t\t\t\n\t\t\t\t\tlist.push(prop);\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t\t\n\t\treturn list;\n\t}\n\n\t/**\n\t * Tries to produce properties with vendor-prefixed value\n\t * @param  {Object} snippetObj Parsed snippet object\n\t * @return {Array} Array of properties with prefixed values\n\t */\n\tfunction resolvePrefixedValues(snippetObj, isImportant, syntax) {\n\t\tvar prefixes = [];\n\t\tvar lookup = {};\n\n\t\tvar parts = cssEditTree.findParts(snippetObj.value);\n\t\tparts.reverse();\n\t\tparts.forEach(function(p) {\n\t\t\tvar partValue = p.substring(snippetObj.value);\n\t\t\t(findVendorPrefixes(partValue) || []).forEach(function(prefix) {\n\t\t\t\tif (!lookup[prefix]) {\n\t\t\t\t\tlookup[prefix] = snippetObj.value;\n\t\t\t\t\tprefixes.push(prefix);\n\t\t\t\t}\n\n\t\t\t\tlookup[prefix] = utils.replaceSubstring(lookup[prefix], '-' + prefix + '-' + partValue, p);\n\t\t\t});\n\t\t});\n\n\t\treturn prefixes.map(function(prefix) {\n\t\t\treturn transformSnippet(snippetObj.name + ':' + lookup[prefix], isImportant, syntax);\n\t\t});\n\t}\n\t\n\t\n\t// TODO refactor, this looks awkward now\n\taddPrefix('w', {\n\t\tprefix: 'webkit'\n\t});\n\taddPrefix('m', {\n\t\tprefix: 'moz'\n\t});\n\taddPrefix('s', {\n\t\tprefix: 'ms'\n\t});\n\taddPrefix('o', {\n\t\tprefix: 'o'\n\t});\n\t\n\t\n\tmodule = module || {};\n\tmodule.exports = {\n\t\t/**\n\t\t * Adds vendor prefix\n\t\t * @param {String} name One-character prefix name\n\t\t * @param {Object} obj Object describing vendor prefix\n\t\t * @memberOf cssResolver\n\t\t */\n\t\taddPrefix: addPrefix,\n\t\t\n\t\t/**\n\t\t * Check if passed CSS property supports specified vendor prefix\n\t\t * @param {String} property\n\t\t * @param {String} prefix\n\t\t */\n\t\tsupportsPrefix: hasPrefix,\n\n\t\tresolve: function(node, syntax) {\n\t\t\tvar cssSyntaxes = prefs.getArray('css.syntaxes');\n\t\t\tif (cssSyntaxes && ~cssSyntaxes.indexOf(syntax) && node.isElement()) {\n\t\t\t\treturn this.expandToSnippet(node.abbreviation, syntax);\n\t\t\t}\n\t\t\t\n\t\t\treturn null;\n\t\t},\n\n\t\t/**\n\t\t * Returns prefixed version of passed CSS property, only if this\n\t\t * property supports such prefix\n\t\t * @param {String} property\n\t\t * @param {String} prefix\n\t\t * @returns\n\t\t */\n\t\tprefixed: function(property, prefix) {\n\t\t\treturn hasPrefix(property, prefix) \n\t\t\t\t? '-' + prefix + '-' + property \n\t\t\t\t: property;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns list of all registered vendor prefixes\n\t\t * @returns {Array}\n\t\t */\n\t\tlistPrefixes: function() {\n\t\t\treturn vendorPrefixes.map(function(obj) {\n\t\t\t\treturn obj.prefix;\n\t\t\t});\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns object describing vendor prefix\n\t\t * @param {String} name\n\t\t * @returns {Object}\n\t\t */\n\t\tgetPrefix: function(name) {\n\t\t\treturn vendorPrefixes[name];\n\t\t},\n\t\t\n\t\t/**\n\t\t * Removes prefix object\n\t\t * @param {String} name\n\t\t */\n\t\tremovePrefix: function(name) {\n\t\t\tif (name in vendorPrefixes)\n\t\t\t\tdelete vendorPrefixes[name];\n\t\t},\n\t\t\n\t\t/**\n\t\t * Extract vendor prefixes from abbreviation\n\t\t * @param {String} abbr\n\t\t * @returns {Object} Object containing array of prefixes and clean \n\t\t * abbreviation name\n\t\t */\n\t\textractPrefixes: function(abbr) {\n\t\t\tif (abbr.charAt(0) != '-') {\n\t\t\t\treturn {\n\t\t\t\t\tproperty: abbr,\n\t\t\t\t\tprefixes: null\n\t\t\t\t};\n\t\t\t}\n\t\t\t\n\t\t\t// abbreviation may either contain sequence of one-character prefixes\n\t\t\t// or just dash, meaning that user wants to produce all possible\n\t\t\t// prefixed properties\n\t\t\tvar i = 1, il = abbr.length, ch;\n\t\t\tvar prefixes = [];\n\t\t\t\n\t\t\twhile (i < il) {\n\t\t\t\tch = abbr.charAt(i);\n\t\t\t\tif (ch == '-') {\n\t\t\t\t\t// end-sequence character found, stop searching\n\t\t\t\t\ti++;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tif (ch in vendorPrefixes) {\n\t\t\t\t\tprefixes.push(ch);\n\t\t\t\t} else {\n\t\t\t\t\t// no prefix found, meaning user want to produce all\n\t\t\t\t\t// vendor-prefixed properties\n\t\t\t\t\tprefixes.length = 0;\n\t\t\t\t\ti = 1;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\ti++;\n\t\t\t}\n\t\t\t\n\t\t\t// reached end of abbreviation and no property name left\n\t\t\tif (i == il -1) {\n\t\t\t\ti = 1;\n\t\t\t\tprefixes.length = 1;\n\t\t\t}\n\t\t\t\n\t\t\treturn {\n\t\t\t\tproperty: abbr.substring(i),\n\t\t\t\tprefixes: prefixes.length ? prefixes : 'all'\n\t\t\t};\n\t\t},\n\t\t\n\t\t/**\n\t\t * Search for value substring in abbreviation\n\t\t * @param {String} abbr\n\t\t * @returns {String} Value substring\n\t\t */\n\t\tfindValuesInAbbreviation: function(abbr, syntax) {\n\t\t\tsyntax = syntax || 'css';\n\t\t\t\n\t\t\tvar i = 0, il = abbr.length, value = '', ch;\n\t\t\twhile (i < il) {\n\t\t\t\tch = abbr.charAt(i);\n\t\t\t\tif (isNumeric(ch) || ch == '#' || ch == '$' || (ch == '-' && isNumeric(abbr.charAt(i + 1)))) {\n\t\t\t\t\tvalue = abbr.substring(i);\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\ti++;\n\t\t\t}\n\t\t\t\n\t\t\t// try to find keywords in abbreviation\n\t\t\tvar property = abbr.substring(0, abbr.length - value.length);\n\t\t\tvar keywords = [];\n\t\t\t// try to extract some commonly-used properties\n\t\t\twhile (~property.indexOf('-') && !resources.findSnippet(syntax, property)) {\n\t\t\t\tvar parts = property.split('-');\n\t\t\t\tvar lastPart = parts.pop();\n\t\t\t\tif (!isValidKeyword(lastPart)) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tkeywords.unshift(lastPart);\n\t\t\t\tproperty = parts.join('-');\n\t\t\t}\n\n\t\t\treturn keywords.join('-') + value;\n\t\t},\n\t\t\n\t\tparseValues: function(str) {\n\t\t\t/** @type StringStream */\n\t\t\tvar stream = stringStream.create(str);\n\t\t\tvar values = [];\n\t\t\tvar ch = null;\n\t\t\t\n\t\t\twhile ((ch = stream.next())) {\n\t\t\t\tif (ch == '$') {\n\t\t\t\t\tstream.match(/^[^\\$]+/, true);\n\t\t\t\t\tvalues.push(stream.current());\n\t\t\t\t} else if (ch == '#') {\n\t\t\t\t\tstream.match(/^t|[0-9a-f]+(\\.\\d+)?/i, true);\n\t\t\t\t\tvalues.push(stream.current());\n\t\t\t\t} else if (ch == '-') {\n\t\t\t\t\tif (isValidKeyword(utils.last(values)) || \n\t\t\t\t\t\t\t( stream.start && isNumeric(str.charAt(stream.start - 1)) )\n\t\t\t\t\t\t) {\n\t\t\t\t\t\tstream.start = stream.pos;\n\t\t\t\t\t}\n\t\t\t\t\t\n\t\t\t\t\tstream.match(/^\\-?[0-9]*(\\.[0-9]+)?[a-z%\\.]*/, true);\n\t\t\t\t\tvalues.push(stream.current());\n\t\t\t\t} else {\n\t\t\t\t\tstream.match(/^[0-9]*(\\.[0-9]*)?[a-z%]*/, true);\n\t\t\t\t\tvalues.push(stream.current());\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tstream.start = stream.pos;\n\t\t\t}\n\t\t\t\n\t\t\treturn values\n\t\t\t\t.filter(function(item) {\n\t\t\t\t\treturn !!item;\n\t\t\t\t})\n\t\t\t\t.map(normalizeValue);\n\t\t},\n\t\t\n\t\t/**\n\t\t * Extracts values from abbreviation\n\t\t * @param {String} abbr\n\t\t * @returns {Object} Object containing array of values and clean \n\t\t * abbreviation name\n\t\t */\n\t\textractValues: function(abbr) {\n\t\t\t// search for value start\n\t\t\tvar abbrValues = this.findValuesInAbbreviation(abbr);\n\t\t\tif (!abbrValues) {\n\t\t\t\treturn {\n\t\t\t\t\tproperty: abbr,\n\t\t\t\t\tvalues: null\n\t\t\t\t};\n\t\t\t}\n\t\t\t\n\t\t\treturn {\n\t\t\t\tproperty: abbr.substring(0, abbr.length - abbrValues.length).replace(/-$/, ''),\n\t\t\t\tvalues: this.parseValues(abbrValues)\n\t\t\t};\n\t\t},\n\t\t\n\t\t/**\n\t\t * Normalizes value, defined in abbreviation.\n\t\t * @param {String} value\n\t\t * @param {String} property\n\t\t * @returns {String}\n\t\t */\n\t\tnormalizeValue: function(value, property) {\n\t\t\tproperty = (property || '').toLowerCase();\n\t\t\tvar unitlessProps = prefs.getArray('css.unitlessProperties');\n\t\t\treturn value.replace(/^(\\-?[0-9\\.]+)([a-z]*)$/, function(str, val, unit) {\n\t\t\t\tif (!unit && (val == '0' || ~unitlessProps.indexOf(property)))\n\t\t\t\t\treturn val;\n\t\t\t\t\n\t\t\t\tif (!unit)\n\t\t\t\t\treturn val.replace(/\\.$/, '') + prefs.get(~val.indexOf('.') ? 'css.floatUnit' : 'css.intUnit');\n\t\t\t\t\n\t\t\t\treturn val + getUnit(unit);\n\t\t\t});\n\t\t},\n\t\t\n\t\t/**\n\t\t * Expands abbreviation into a snippet\n\t\t * @param {String} abbr Abbreviation name to expand\n\t\t * @param {String} value Abbreviation value\n\t\t * @param {String} syntax Currect syntax or dialect. Default is 'css'\n\t\t * @returns {Object} Array of CSS properties and values or predefined\n\t\t * snippet (string or element)\n\t\t */\n\t\texpand: function(abbr, value, syntax) {\n\t\t\tsyntax = syntax || 'css';\n\t\t\tvar autoInsertPrefixes = prefs.get(syntax + '.autoInsertVendorPrefixes');\n\t\t\t\n\t\t\t// check if snippet should be transformed to !important\n\t\t\tvar isImportant = /^(.+)\\!$/.test(abbr);\n\t\t\tif (isImportant) {\n\t\t\t\tabbr = RegExp.$1;\n\t\t\t}\n\n\t\t\t// check if we have abbreviated resource\n\t\t\tvar snippet = resources.findSnippet(syntax, abbr);\n\t\t\tif (snippet && !autoInsertPrefixes) {\n\t\t\t\treturn transformSnippet(snippet, isImportant, syntax);\n\t\t\t}\n\t\t\t\n\t\t\t// no abbreviated resource, parse abbreviation\n\t\t\tvar prefixData = this.extractPrefixes(abbr);\n\t\t\tvar valuesData = this.extractValues(prefixData.property);\n\t\t\tvar abbrData = utils.extend(prefixData, valuesData);\n\n\t\t\tif (!snippet) {\n\t\t\t\tsnippet = resources.findSnippet(syntax, abbrData.property);\n\t\t\t} else {\n\t\t\t\tabbrData.values = null;\n\t\t\t}\n\t\t\t\n\t\t\tif (!snippet && prefs.get('css.fuzzySearch')) {\n\t\t\t\t// let’s try fuzzy search\n\t\t\t\tsnippet = resources.fuzzyFindSnippet(syntax, abbrData.property, parseFloat(prefs.get('css.fuzzySearchMinScore')));\n\t\t\t}\n\t\t\t\n\t\t\tif (!snippet) {\n\t\t\t\tif (!abbrData.property || abbrData.property.endsWith(':')) {\n\t\t\t\t\treturn null;\n\t\t\t\t}\n\t\t\t\tsnippet = abbrData.property + ':' + defaultValue;\n\t\t\t} else if (typeof snippet !== 'string') {\n\t\t\t\tsnippet = snippet.data;\n\t\t\t}\n\t\t\t\n\t\t\tif (!isSingleProperty(snippet)) {\n\t\t\t\treturn snippet;\n\t\t\t}\n\t\t\t\n\t\t\tvar snippetObj = this.splitSnippet(snippet);\n\t\t\tvar result = [];\n\t\t\tif (!value && abbrData.values) {\n\t\t\t\tvalue = abbrData.values.map(function(val) {\n\t\t\t\t\treturn this.normalizeValue(val, snippetObj.name);\n\t\t\t\t}, this).join(' ') + ';';\n\t\t\t}\n\t\t\t\n\t\t\tsnippetObj.value = value || snippetObj.value;\n\n\t\t\tvar prefixes = abbrData.prefixes == 'all' || (!abbrData.prefixes && autoInsertPrefixes) \n\t\t\t\t? findInternalPrefixes(snippetObj.name, autoInsertPrefixes && abbrData.prefixes != 'all')\n\t\t\t\t: abbrData.prefixes;\n\t\t\t\t\n\t\t\t\t\n\t\t\tvar names = [], propName;\n\t\t\t(prefixes || []).forEach(function(p) {\n\t\t\t\tif (p in vendorPrefixes) {\n\t\t\t\t\tpropName = vendorPrefixes[p].transformName(snippetObj.name);\n\t\t\t\t\tnames.push(propName);\n\t\t\t\t\tresult.push(transformSnippet(propName + ':' + snippetObj.value,\n\t\t\t\t\t\t\tisImportant, syntax));\n\t\t\t\t}\n\t\t\t});\n\t\t\t\n\t\t\t// put the original property\n\t\t\tresult.push(transformSnippet(snippetObj.name + ':' + snippetObj.value, isImportant, syntax));\n\t\t\tnames.push(snippetObj.name);\n\n\t\t\tresult = resolvePrefixedValues(snippetObj, isImportant, syntax).concat(result);\n\t\t\t\n\t\t\tif (prefs.get('css.alignVendor')) {\n\t\t\t\tvar pads = utils.getStringsPads(names);\n\t\t\t\tresult = result.map(function(prop, i) {\n\t\t\t\t\treturn pads[i] + prop;\n\t\t\t\t});\n\t\t\t}\n\t\t\t\n\t\t\treturn result;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Same as <code>expand</code> method but transforms output into \n\t\t * Emmet snippet\n\t\t * @param {String} abbr\n\t\t * @param {String} syntax\n\t\t * @returns {String}\n\t\t */\n\t\texpandToSnippet: function(abbr, syntax) {\n\t\t\tvar snippet = this.expand(abbr, null, syntax);\n\t\t\tif (snippet === null) {\n\t\t\t\treturn null;\n\t\t\t}\n\n\t\t\tif (Array.isArray(snippet)) {\n\t\t\t\treturn snippet.join('\\n');\n\t\t\t}\n\t\t\t\n\t\t\tif (typeof snippet !== 'string') {\n\t\t\t\treturn snippet.data;\n\t\t\t}\n\t\t\t\n\t\t\treturn snippet + '';\n\t\t},\n\t\t\n\t\t/**\n\t\t * Split snippet into a CSS property-value pair\n\t\t * @param {String} snippet\n\t\t */\n\t\tsplitSnippet: function(snippet) {\n\t\t\tsnippet = utils.trim(snippet);\n\t\t\tif (snippet.indexOf(':') == -1) {\n\t\t\t\treturn {\n\t\t\t\t\tname: snippet,\n\t\t\t\t\tvalue: defaultValue\n\t\t\t\t};\n\t\t\t}\n\t\t\t\n\t\t\tvar pair = snippet.split(':');\n\t\t\t\n\t\t\treturn {\n\t\t\t\tname: utils.trim(pair.shift()),\n\t\t\t\t// replace ${0} tabstop to produce valid vendor-prefixed values\n\t\t\t\t// where possible\n\t\t\t\tvalue: utils.trim(pair.join(':')).replace(/^(\\$\\{0\\}|\\$0)(\\s*;?)$/, '${1}$2')\n\t\t\t};\n\t\t},\n\t\t\n\t\tgetSyntaxPreference: getSyntaxPreference,\n\t\ttransformSnippet: transformSnippet,\n\t\tvendorPrefixes: findVendorPrefixes\n\t};\n\n\treturn module.exports;\n});\n},{\"../assets/caniuse\":\"assets\\\\caniuse.js\",\"../assets/preferences\":\"assets\\\\preferences.js\",\"../assets/resources\":\"assets\\\\resources.js\",\"../assets/stringStream\":\"assets\\\\stringStream.js\",\"../editTree/css\":\"editTree\\\\css.js\",\"../utils/common\":\"utils\\\\common.js\",\"../utils/template\":\"utils\\\\template.js\"}],\"resolver\\\\cssGradient.js\":[function(require,module,exports){\n/**\n * 'Expand Abbreviation' handler that parses gradient definition from under \n * cursor and updates CSS rule with vendor-prefixed values.\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar prefs = require('../assets/preferences');\n\tvar resources = require('../assets/resources');\n\tvar utils = require('../utils/common');\n\tvar stringStream = require('../assets/stringStream');\n\tvar cssResolver = require('./css');\n\tvar range = require('../assets/range');\n\tvar cssEditTree = require('../editTree/css');\n\tvar editorUtils = require('../utils/editor');\n\tvar linearGradient = require('./gradient/linear');\n\n\tvar cssSyntaxes = ['css', 'less', 'sass', 'scss', 'stylus', 'styl'];\n\t\n\t// XXX define preferences\n\tprefs.define('css.gradient.prefixes', 'webkit, moz, o',\n\t\t\t'A comma-separated list of vendor-prefixes for which values should ' \n\t\t\t+ 'be generated.');\n\t\n\tprefs.define('css.gradient.oldWebkit', false,\n\t\t\t'Generate gradient definition for old Webkit implementations');\n\t\n\tprefs.define('css.gradient.omitDefaultDirection', true,\n\t\t'Do not output default direction definition in generated gradients.');\n\t\n\tprefs.define('css.gradient.defaultProperty', 'background-image',\n\t\t'When gradient expanded outside CSS value context, it will produce '\n\t\t\t+ 'properties with this name.');\n\t\n\tprefs.define('css.gradient.fallback', false,\n\t\t\t'With this option enabled, CSS gradient generator will produce '\n\t\t\t+ '<code>background-color</code> property with gradient first color '\n\t\t\t+ 'as fallback for old browsers.');\n\n\t/**\n\t * Resolves property name (abbreviation): searches for snippet definition in \n\t * 'resources' and returns new name of matched property\n\t */\n\tfunction resolvePropertyName(name, syntax) {\n\t\tvar snippet = resources.findSnippet(syntax, name);\n\t\t\n\t\tif (!snippet && prefs.get('css.fuzzySearch')) {\n\t\t\tvar minScore = parseFloat(prefs.get('css.fuzzySearchMinScore'));\n\t\t\tsnippet = resources.fuzzyFindSnippet(syntax, name, minScore);\n\t\t}\n\t\t\n\t\tif (snippet) {\n\t\t\tif (typeof snippet !== 'string') {\n\t\t\t\tsnippet = snippet.data;\n\t\t\t}\n\t\t\t\n\t\t\treturn cssResolver.splitSnippet(snippet).name;\n\t\t}\n\t}\n\n\t/**\n\t * Returns vendor prefixes for given gradient type\n\t * @param {String} type Gradient type (currently, 'linear-gradient' \n\t * is the only supported value)\n\t * @return {Array}\n\t */\n\tfunction getGradientPrefixes(type) {\n\t\tvar prefixes = cssResolver.vendorPrefixes(type);\n\t\tif (!prefixes) {\n\t\t\t// disabled Can I Use, fallback to property list\n\t\t\tprefixes = prefs.getArray('css.gradient.prefixes');\n\t\t}\n\n\t\treturn prefixes || [];\n\t}\n\t\n\tfunction getPrefixedNames(type) {\n\t\tvar prefixes = getGradientPrefixes(type);\n\t\tvar names = prefixes \n\t\t\t? prefixes.map(function(p) {\n\t\t\t\treturn '-' + p + '-' + type;\n\t\t\t}) \n\t\t\t: [];\n\t\t\n\t\tnames.push(type);\n\t\t\n\t\treturn names;\n\t}\n\t\n\t/**\n\t * Returns list of CSS properties with gradient\n\t * @param {Array} gradient List of gradient objects\n\t * @param {CSSEditElement} property Original CSS property\n\t * @returns {Array}\n\t */\n\tfunction getPropertiesForGradient(gradients, property) {\n\t\tvar props = [];\n\t\tvar propertyName = property.name();\n\t\tvar omitDir = prefs.get('css.gradient.omitDefaultDirection');\n\t\t\n\t\tif (prefs.get('css.gradient.fallback') && ~propertyName.toLowerCase().indexOf('background')) {\n\t\t\tprops.push({\n\t\t\t\tname: 'background-color',\n\t\t\t\tvalue: '${1:' + gradients[0].gradient.colorStops[0].color + '}'\n\t\t\t});\n\t\t}\n\t\t\n\t\tvar value = property.value();\n\t\tgetGradientPrefixes('linear-gradient').forEach(function(prefix) {\n\t\t\tvar name = cssResolver.prefixed(propertyName, prefix);\n\t\t\tif (prefix == 'webkit' && prefs.get('css.gradient.oldWebkit')) {\n\t\t\t\ttry {\n\t\t\t\t\tprops.push({\n\t\t\t\t\t\tname: name,\n\t\t\t\t\t\tvalue: insertGradientsIntoCSSValue(gradients, value, {\n\t\t\t\t\t\t\tprefix: prefix, \n\t\t\t\t\t\t\toldWebkit: true,\n\t\t\t\t\t\t\tomitDefaultDirection: omitDir\n\t\t\t\t\t\t})\n\t\t\t\t\t});\n\t\t\t\t} catch(e) {}\n\t\t\t}\n\t\t\t\n\t\t\tprops.push({\n\t\t\t\tname: name,\n\t\t\t\tvalue: insertGradientsIntoCSSValue(gradients, value, {\n\t\t\t\t\tprefix: prefix,\n\t\t\t\t\tomitDefaultDirection: omitDir\n\t\t\t\t})\n\t\t\t});\n\t\t});\n\t\t\n\t\treturn props.sort(function(a, b) {\n\t\t\treturn b.name.length - a.name.length;\n\t\t});\n\t}\n\n\t/**\n\t * Replaces old gradient definitions in given CSS property value\n\t * with new ones, preserving original formatting\n\t * @param  {Array} gradients List of CSS gradients\n\t * @param  {String} value     Original CSS value\n\t * @param  {Object} options   Options for gradient’s stringify() method\n\t * @return {String}\n\t */\n\tfunction insertGradientsIntoCSSValue(gradients, value, options) {\n\t\t// gradients *should* passed in order they actually appear in CSS property\n\t\t// iterate over it in backward direction to preserve gradient locations\n\t\toptions = options || {};\n\t\tgradients = utils.clone(gradients);\n\t\tgradients.reverse().forEach(function(item, i) {\n\t\t\tvar suffix = !i && options.placeholder ? options.placeholder : '';\n\t\t\tvar str = options.oldWebkit ? item.gradient.stringifyOldWebkit(options) : item.gradient.stringify(options);\n\t\t\tvalue = utils.replaceSubstring(value, str + suffix, item.matchedPart);\n\t\t});\n\n\t\treturn value;\n\t}\n\n\t/**\n\t * Returns list of properties with the same meaning \n\t * (e.g. vendor-prefixed + original name)\n\t * @param  {String} property CSS property name\n\t * @return {Array}\n\t */\n\tfunction similarPropertyNames(property) {\n\t\tif (typeof property !== 'string') {\n\t\t\tproperty = property.name();\n\t\t}\n\n\t\tvar similarProps = (cssResolver.vendorPrefixes(property) || []).map(function(prefix) {\n\t\t\treturn '-' + prefix + '-' + property;\n\t\t});\n\t\tsimilarProps.push(property);\n\t\treturn similarProps;\n\t}\n\t\n\t/**\n\t * Pastes gradient definition into CSS rule with correct vendor-prefixes\n\t * @param {EditElement} property Matched CSS property\n\t * @param {Array} gradients List of gradients to insert\n\t */\n\tfunction pasteGradient(property, gradients) {\n\t\tvar rule = property.parent;\n\t\tvar alignVendor = prefs.get('css.alignVendor');\n\t\tvar omitDir = prefs.get('css.gradient.omitDefaultDirection');\n\t\t\n\t\t// we may have aligned gradient definitions: find the smallest value\n\t\t// separator\n\t\tvar sep = property.styleSeparator;\n\t\tvar before = property.styleBefore;\n\t\t\n\t\t// first, remove all properties within CSS rule with the same name and\n\t\t// gradient definition\n\t\trule.getAll(similarPropertyNames(property)).forEach(function(item) {\n\t\t\tif (item != property && /gradient/i.test(item.value())) {\n\t\t\t\tif (item.styleSeparator.length < sep.length) {\n\t\t\t\t\tsep = item.styleSeparator;\n\t\t\t\t}\n\t\t\t\tif (item.styleBefore.length < before.length) {\n\t\t\t\t\tbefore = item.styleBefore;\n\t\t\t\t}\n\t\t\t\trule.remove(item);\n\t\t\t}\n\t\t});\n\t\t\n\t\tif (alignVendor) {\n\t\t\t// update prefix\n\t\t\tif (before != property.styleBefore) {\n\t\t\t\tvar fullRange = property.fullRange();\n\t\t\t\trule._updateSource(before, fullRange.start, fullRange.start + property.styleBefore.length);\n\t\t\t\tproperty.styleBefore = before;\n\t\t\t}\n\t\t\t\n\t\t\t// update separator value\n\t\t\tif (sep != property.styleSeparator) {\n\t\t\t\trule._updateSource(sep, property.nameRange().end, property.valueRange().start);\n\t\t\t\tproperty.styleSeparator = sep;\n\t\t\t}\n\t\t}\n\t\t\n\t\tvar value = property.value();\n\n\t\t// create list of properties to insert\n\t\tvar propsToInsert = getPropertiesForGradient(gradients, property);\n\t\t\n\t\t// align prefixed values\n\t\tif (alignVendor) {\n\t\t\tvar names = [], values = [];\n\t\t\tpropsToInsert.forEach(function(item) {\n\t\t\t\tnames.push(item.name);\n\t\t\t\tvalues.push(item.value);\n\t\t\t});\n\t\t\tvalues.push(property.value());\n\t\t\tnames.push(property.name());\n\t\t\t\n\t\t\tvar valuePads = utils.getStringsPads(values.map(function(v) {\n\t\t\t\treturn v.substring(0, v.indexOf('('));\n\t\t\t}));\n\t\t\t\n\t\t\tvar namePads = utils.getStringsPads(names);\n\t\t\tproperty.name(namePads[namePads.length - 1] + property.name());\n\t\t\t\n\t\t\tpropsToInsert.forEach(function(prop, i) {\n\t\t\t\tprop.name = namePads[i] + prop.name;\n\t\t\t\tprop.value = valuePads[i] + prop.value;\n\t\t\t});\n\t\t\t\n\t\t\tproperty.value(valuePads[valuePads.length - 1] + property.value());\n\t\t}\n\t\t\n\t\t// put vendor-prefixed definitions before current rule\n\t\tpropsToInsert.forEach(function(prop) {\n\t\t\trule.add(prop.name, prop.value, rule.indexOf(property));\n\t\t});\n\n\t\t// put vanilla-clean gradient definition into current rule\n\t\tproperty.value(insertGradientsIntoCSSValue(gradients, value, {\n\t\t\tplaceholder: '${2}',\n\t\t\tomitDefaultDirection: omitDir\n\t\t}));\n\t}\n\n\t/**\n\t * Validates caret position relatively to located gradients\n\t * in CSS rule. In other words, it checks if it’s safe to \n\t * expand gradients for current caret position or not.\n\t * \n\t * See issue https://github.com/sergeche/emmet-sublime/issues/411\n\t * \n\t * @param  {Array} gradients List of parsed gradients\n\t * @param  {Number} caretPos  Current caret position\n\t * @param  {String} syntax    Current document syntax\n\t * @return {Boolean}\n\t */\n\tfunction isValidCaretPosition(gradients, caretPos, syntax) {\n\t\tsyntax = syntax || 'css';\n\t\tif (syntax == 'css' || syntax == 'less' || syntax == 'scss') {\n\t\t\treturn true;\n\t\t}\n\n\t\tvar offset = gradients.property.valueRange(true).start;\n\t\tvar parts = gradients.gradients;\n\n\t\t// in case of preprocessors where properties are separated with\n\t\t// newlines, make sure there’s no gradient definition past\n\t\t// current caret position. \n\t\tfor (var i = parts.length - 1; i >= 0; i--) {\n\t\t\tif (parts[i].matchedPart.start + offset >= caretPos) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\n\t\treturn true;\n\t}\n\t\n\tmodule = module || {};\n\treturn module.exports = {\n\t\t/**\n\t\t * Search for gradient definitions inside CSS property value\n\t\t * @returns {Array} Array of matched gradients\n\t\t */\n\t\tfindGradients: function(cssProp) {\n\t\t\tvar value = cssProp.value();\n\t\t\tvar gradients = [];\n\t\t\tvar that = this;\n\t\t\tcssProp.valueParts().forEach(function(part) {\n\t\t\t\tvar partValue = part.substring(value);\n\t\t\t\tif (linearGradient.isLinearGradient(partValue)) {\n\t\t\t\t\tvar gradient = linearGradient.parse(partValue);\n\t\t\t\t\tif (gradient) {\n\t\t\t\t\t\tgradients.push({\n\t\t\t\t\t\t\tgradient: gradient,\n\t\t\t\t\t\t\tmatchedPart: part\n\t\t\t\t\t\t});\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t});\n\t\t\t\n\t\t\treturn gradients.length ? gradients : null;\n\t\t},\n\n\t\t/**\n\t\t * Returns list of gradients found in CSS property\n\t\t * of given CSS code in specified (caret) position\n\t\t * @param  {String} css CSS code snippet\n\t\t * @param  {Number} pos Character index where to start searching for CSS property\n\t\t * @return {Array}\n\t\t */\n\t\tgradientsFromCSSProperty: function(css, pos) {\n\t\t\tvar cssProp = cssEditTree.propertyFromPosition(css, pos);\n\t\t\tif (cssProp) {\n\t\t\t\tvar grd = this.findGradients(cssProp);\n\t\t\t\tif (grd) {\n\t\t\t\t\treturn {\n\t\t\t\t\t\tproperty: cssProp,\n\t\t\t\t\t\tgradients: grd\n\t\t\t\t\t};\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn null;\n\t\t},\n\n\t\t/**\n\t\t * Handler for “Expand Abbreviation” action\n\t\t * @param  {IEmmetEditor} editor\n\t\t * @param  {String} syntax\n\t\t * @param  {String} profile\n\t\t * return {Boolean}\n\t\t */\n\t\texpandAbbreviationHandler: function(editor, syntax, profile) {\n\t\t\tvar info = editorUtils.outputInfo(editor, syntax, profile);\n\t\t\tif (!~cssSyntaxes.indexOf(info.syntax)) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t\t\n\t\t\t// let's see if we are expanding gradient definition\n\t\t\tvar caret = editor.getCaretPos();\n\t\t\tvar content = info.content;\n\t\t\tvar gradients = this.gradientsFromCSSProperty(content, caret);\n\t\t\tif (gradients) {\n\t\t\t\tif (!isValidCaretPosition(gradients, caret, info.syntax)) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\n\t\t\t\tvar cssProperty = gradients.property;\n\t\t\t\tvar cssRule = cssProperty.parent;\n\t\t\t\tvar ruleStart = cssRule.options.offset || 0;\n\t\t\t\tvar ruleEnd = ruleStart + cssRule.toString().length;\n\t\t\t\t\n\t\t\t\t// Handle special case:\n\t\t\t\t// user wrote gradient definition between existing CSS \n\t\t\t\t// properties and did not finished it with semicolon.\n\t\t\t\t// In this case, we have semicolon right after gradient \n\t\t\t\t// definition and re-parse rule again\n\t\t\t\tif (/[\\n\\r]/.test(cssProperty.value())) {\n\t\t\t\t\t// insert semicolon at the end of gradient definition\n\t\t\t\t\tvar insertPos = cssProperty.valueRange(true).start + utils.last(gradients.gradients).matchedPart.end;\n\t\t\t\t\tcontent = utils.replaceSubstring(content, ';', insertPos);\n\t\t\t\t\t\n\t\t\t\t\tvar _gradients = this.gradientsFromCSSProperty(content, caret);\n\t\t\t\t\tif (_gradients) {\n\t\t\t\t\t\tgradients = _gradients;\n\t\t\t\t\t\tcssProperty = gradients.property;\n\t\t\t\t\t\tcssRule = cssProperty.parent;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\t// make sure current property has terminating semicolon\n\t\t\t\tcssProperty.end(';');\n\t\t\t\t\n\t\t\t\t// resolve CSS property name\n\t\t\t\tvar resolvedName = resolvePropertyName(cssProperty.name(), syntax);\n\t\t\t\tif (resolvedName) {\n\t\t\t\t\tcssProperty.name(resolvedName);\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tpasteGradient(cssProperty, gradients.gradients);\n\t\t\t\teditor.replaceContent(cssRule.toString(), ruleStart, ruleEnd, true);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\t\n\t\t\treturn this.expandGradientOutsideValue(editor, syntax);\n\t\t},\n\n\t\t/**\n\t\t * Tries to expand gradient outside CSS value \n\t\t * @param {IEmmetEditor} editor\n\t\t * @param {String} syntax\n\t\t */\n\t\texpandGradientOutsideValue: function(editor, syntax) {\n\t\t\tvar propertyName = prefs.get('css.gradient.defaultProperty');\n\t\t\tvar omitDir = prefs.get('css.gradient.omitDefaultDirection');\n\t\t\t\n\t\t\tif (!propertyName) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t\t\n\t\t\t// assuming that gradient definition is written on new line,\n\t\t\t// do a simplified parsing\n\t\t\tvar content = String(editor.getContent());\n\t\t\t/** @type Range */\n\t\t\tvar lineRange = range.create(editor.getCurrentLineRange());\n\t\t\t\n\t\t\t// get line content and adjust range with padding\n\t\t\tvar line = lineRange.substring(content)\n\t\t\t\t.replace(/^\\s+/, function(pad) {\n\t\t\t\t\tlineRange.start += pad.length;\n\t\t\t\t\treturn '';\n\t\t\t\t})\n\t\t\t\t.replace(/\\s+$/, function(pad) {\n\t\t\t\t\tlineRange.end -= pad.length;\n\t\t\t\t\treturn '';\n\t\t\t\t});\n\n\t\t\t// trick parser: make it think that we’re parsing actual CSS property\n\t\t\tvar fakeCSS = 'a{' + propertyName + ': ' + line + ';}';\n\t\t\tvar gradients = this.gradientsFromCSSProperty(fakeCSS, fakeCSS.length - 2);\n\t\t\tif (gradients) {\n\t\t\t\tvar props = getPropertiesForGradient(gradients.gradients, gradients.property);\n\t\t\t\tprops.push({\n\t\t\t\t\tname: gradients.property.name(),\n\t\t\t\t\tvalue: insertGradientsIntoCSSValue(gradients.gradients, gradients.property.value(), {\n\t\t\t\t\t\tplaceholder: '${2}',\n\t\t\t\t\t\tomitDefaultDirection: omitDir\n\t\t\t\t\t})\n\t\t\t\t});\n\t\t\t\t\n\t\t\t\tvar sep = cssResolver.getSyntaxPreference('valueSeparator', syntax);\n\t\t\t\tvar end = cssResolver.getSyntaxPreference('propertyEnd', syntax);\n\t\t\t\t\n\t\t\t\tif (prefs.get('css.alignVendor')) {\n\t\t\t\t\tvar pads = utils.getStringsPads(props.map(function(prop) {\n\t\t\t\t\t\treturn prop.value.substring(0, prop.value.indexOf('('));\n\t\t\t\t\t}));\n\t\t\t\t\tprops.forEach(function(prop, i) {\n\t\t\t\t\t\tprop.value = pads[i] + prop.value;\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tprops = props.map(function(item) {\n\t\t\t\t\treturn item.name + sep + item.value + end;\n\t\t\t\t});\n\t\t\t\t\n\t\t\t\teditor.replaceContent(props.join('\\n'), lineRange.start, lineRange.end);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\t\n\t\t\treturn false;\n\t\t},\n\n\t\t/**\n\t\t * Handler for “Reflect CSS Value“ action\n\t\t * @param  {String} property\n\t\t */\n\t\treflectValueHandler: function(property) {\n\t\t\tvar omitDir = prefs.get('css.gradient.omitDefaultDirection');\n\t\t\tvar gradients = this.findGradients(property);\n\t\t\tif (!gradients) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t\t\n\t\t\tvar that = this;\n\t\t\tvar value = property.value();\n\t\t\t\n\t\t\t// reflect value for properties with the same name\n\t\t\tproperty.parent.getAll(similarPropertyNames(property)).forEach(function(prop) {\n\t\t\t\tif (prop === property) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\t// make sure current property contains gradient definition,\n\t\t\t\t// otherwise – skip it\n\t\t\t\tvar localGradients = that.findGradients(prop);\n\t\t\t\tif (localGradients) {\n\t\t\t\t\t// detect vendor prefix for current property\n\t\t\t\t\tvar localValue = prop.value();\n\t\t\t\t\tvar dfn = localGradients[0].matchedPart.substring(localValue);\n\t\t\t\t\tvar prefix = '';\n\t\t\t\t\tif (/^\\s*\\-([a-z]+)\\-/.test(dfn)) {\n\t\t\t\t\t\tprefix = RegExp.$1;\n\t\t\t\t\t}\n\n\t\t\t\t\tprop.value(insertGradientsIntoCSSValue(gradients, value, {\n\t\t\t\t\t\tprefix: prefix,\n\t\t\t\t\t\tomitDefaultDirection: omitDir\n\t\t\t\t\t}));\n\t\t\t\t}\n\t\t\t});\n\t\t\t\n\t\t\treturn true;\n\t\t}\n\t};\n});\n},{\"../assets/preferences\":\"assets\\\\preferences.js\",\"../assets/range\":\"assets\\\\range.js\",\"../assets/resources\":\"assets\\\\resources.js\",\"../assets/stringStream\":\"assets\\\\stringStream.js\",\"../editTree/css\":\"editTree\\\\css.js\",\"../utils/common\":\"utils\\\\common.js\",\"../utils/editor\":\"utils\\\\editor.js\",\"./css\":\"resolver\\\\css.js\",\"./gradient/linear\":\"resolver\\\\gradient\\\\linear.js\"}],\"resolver\\\\gradient\\\\linear.js\":[function(require,module,exports){\n/**\n * CSS linear gradient definition\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar stringStream = require('../../assets/stringStream');\n\tvar utils = require('../../utils/common');\n\n\t// all directions are expressed in “new style” degrees\n\tvar directions = {\n\t\t'bottom': 0,\n\t\t'bottom left': 45,\n\t\t'left': 90,\n\t\t'top left': 135,\n\t\t'top': 180,\n\t\t'top right': 225,\n\t\t'right': 270,\n\t\t'bottom right': 315,\n\t\t\n\t\t'to top': 0,\n\t\t'to top right': 45,\n\t\t'to right': 90,\n\t\t'to bottom right': 135,\n\t\t'to bottom': 180,\n\t\t'to bottom left': 225,\n\t\t'to left': 270,\n\t\t'to top left': 315\n\t};\n\n\tvar defaultDirections = ['top', 'to bottom', '0deg'];\n\n\n\tvar reLinearGradient = /^\\s*(\\-[a-z]+\\-)?(lg|linear\\-gradient)\\s*\\(/i;\n\tvar reDeg = /(\\d+)deg/i;\n\tvar reKeyword = /top|bottom|left|right/i;\n\n\tfunction LinearGradient(dfn) {\n\t\tthis.colorStops = [];\n\t\tthis.direction = 180;\n\n\t\t// extract tokens\n\t\tvar stream = stringStream.create(utils.trim(dfn));\n\t\tvar ch, cur;\n\t\twhile ((ch = stream.next())) {\n\t\t\tif (stream.peek() == ',') {\n\t\t\t\t// Is it a first entry? Check if it’s a direction\n\t\t\t\tcur = stream.current();\n\n\t\t\t\tif (!this.colorStops.length && (reDeg.test(cur) || reKeyword.test(cur))) {\n\t\t\t\t\tthis.direction = resolveDirection(cur);\n\t\t\t\t} else {\n\t\t\t\t\tthis.addColorStop(cur);\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tstream.next();\n\t\t\t\tstream.eatSpace();\n\t\t\t\tstream.start = stream.pos;\n\t\t\t} else if (ch == '(') { // color definition, like 'rgb(0,0,0)'\n\t\t\t\tstream.skipTo(')');\n\t\t\t}\n\t\t}\n\t\t\n\t\t// add last token\n\t\tthis.addColorStop(stream.current());\t\t\n\t}\n\n\tLinearGradient.prototype = {\n\t\ttype: 'linear-gradient',\n\t\taddColorStop: function(color, ix) {\n\t\t\tcolor = normalizeSpace(color || '');\n\t\t\tif (!color) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tcolor = this.parseColorStop(color);\n\n\t\t\tif (typeof ix === 'undefined') {\n\t\t\t\tthis.colorStops.push(color);\n\t\t\t} else {\n\t\t\t\tthis.colorStops.splice(ix, 0, color);\n\t\t\t}\n\t\t},\n\n\t\t/**\n\t\t * Parses color stop definition\n\t\t * @param {String} colorStop\n\t\t * @returns {Object}\n\t\t */\n\t\tparseColorStop: function(colorStop) {\n\t\t\tcolorStop = normalizeSpace(colorStop);\n\t\t\t\n\t\t\t// find color declaration\n\t\t\t// first, try complex color declaration, like rgb(0,0,0)\n\t\t\tvar color = null;\n\t\t\tcolorStop = colorStop.replace(/^(\\w+\\(.+?\\))\\s*/, function(str, c) {\n\t\t\t\tcolor = c;\n\t\t\t\treturn '';\n\t\t\t});\n\t\t\t\n\t\t\tif (!color) {\n\t\t\t\t// try simple declaration, like yellow, #fco, #ffffff, etc.\n\t\t\t\tvar parts = colorStop.split(' ');\n\t\t\t\tcolor = parts[0];\n\t\t\t\tcolorStop = parts[1] || '';\n\t\t\t}\n\t\t\t\n\t\t\tvar result = {\n\t\t\t\tcolor: color\n\t\t\t};\n\t\t\t\n\t\t\tif (colorStop) {\n\t\t\t\t// there's position in color stop definition\n\t\t\t\tcolorStop.replace(/^(\\-?[\\d\\.]+)([a-z%]+)?$/, function(str, pos, unit) {\n\t\t\t\t\tresult.position = pos;\n\t\t\t\t\tif (~pos.indexOf('.')) {\n\t\t\t\t\t\tunit = '';\n\t\t\t\t\t} else if (!unit) {\n\t\t\t\t\t\tunit = '%';\n\t\t\t\t\t}\n\t\t\t\t\t\n\t\t\t\t\tif (unit) {\n\t\t\t\t\t\tresult.unit = unit;\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\t\t\t\n\t\t\treturn result;\n\t\t},\n\n\t\tstringify: function(options) {\n\t\t\toptions = options || {};\n\t\t\tvar fn = 'linear-gradient';\n\t\t\tif (options.prefix) {\n\t\t\t\tfn = '-' + options.prefix + '-' + fn;\n\t\t\t}\n\t\t\t\t\n\t\t\t// transform color-stops\n\t\t\tvar parts = this.colorStops.map(function(cs) {\n\t\t\t\tvar pos = cs.position ? ' ' + cs.position + (cs.unit || '') : '';\n\t\t\t\treturn cs.color + pos;\n\t\t\t});\n\n\t\t\tvar dir = stringifyDirection(this.direction, !!options.prefix);\n\t\t\tif (!options.omitDefaultDirection || !~defaultDirections.indexOf(dir)) {\n\t\t\t\tparts.unshift(dir);\n\t\t\t}\n\n\t\t\treturn fn + '(' + parts.join(', ') + ')';\n\t\t},\n\n\t\tstringifyOldWebkit: function() {\n\t\t\tvar colorStops = this.colorStops.map(function(item) {\n\t\t\t\treturn utils.clone(item);\n\t\t\t});\n\t\t\t\n\t\t\t// normalize color-stops position\n\t\t\tcolorStops.forEach(function(cs) {\n\t\t\t\tif (!('position' in cs)) // implied position\n\t\t\t\t\treturn;\n\t\t\t\t\n\t\t\t\tif (~cs.position.indexOf('.') || cs.unit == '%') {\n\t\t\t\t\tcs.position = parseFloat(cs.position) / (cs.unit == '%' ? 100 : 1);\n\t\t\t\t} else {\n\t\t\t\t\tthrow \"Can't convert color stop '\" + (cs.position + (cs.unit || '')) + \"'\";\n\t\t\t\t}\n\t\t\t});\n\t\t\t\n\t\t\tthis._fillImpliedPositions(colorStops);\n\t\t\t\n\t\t\t// transform color-stops into string representation\n\t\t\tcolorStops = colorStops.map(function(cs, i) {\n\t\t\t\tif (!cs.position && !i) {\n\t\t\t\t\treturn 'from(' + cs.color + ')';\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tif (cs.position == 1 && i == colorStops.length - 1) {\n\t\t\t\t\treturn 'to(' + cs.color + ')';\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\treturn 'color-stop(' + (cs.position.toFixed(2).replace(/\\.?0+$/, '')) + ', ' + cs.color + ')';\n\t\t\t});\n\t\t\t\n\t\t\treturn '-webkit-gradient(linear, ' \n\t\t\t\t+ oldWebkitDirection((this.direction + 180) % 360)\n\t\t\t\t+ ', '\n\t\t\t\t+ colorStops.join(', ')\n\t\t\t\t+ ')';\n\t\t},\n\n\t\t/**\n\t\t * Fills-out implied positions in color-stops. This function is useful for\n\t\t * old Webkit gradient definitions\n\t\t */\n\t\t_fillImpliedPositions: function(colorStops) {\n\t\t\tvar from = 0;\n\t\t\t\n\t\t\tcolorStops.forEach(function(cs, i) {\n\t\t\t\t// make sure that first and last positions are defined\n\t\t\t\tif (!i) {\n\t\t\t\t\treturn cs.position = cs.position || 0;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tif (i == colorStops.length - 1 && !('position' in cs)) {\n\t\t\t\t\tcs.position = 1;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tif ('position' in cs) {\n\t\t\t\t\tvar start = colorStops[from].position || 0;\n\t\t\t\t\tvar step = (cs.position - start) / (i - from);\n\t\t\t\t\tcolorStops.slice(from, i).forEach(function(cs2, j) {\n\t\t\t\t\t\tcs2.position = start + step * j;\n\t\t\t\t\t});\n\t\t\t\t\t\n\t\t\t\t\tfrom = i;\n\t\t\t\t}\n\t\t\t});\n\t\t},\n\n\t\tvalueOf: function() {\n\t\t\treturn this.stringify();\n\t\t}\n\t};\n\n\tfunction normalizeSpace(str) {\n\t\treturn utils.trim(str).replace(/\\s+/g, ' ');\n\t}\n\n\t/**\n\t * Resolves textual direction to degrees\n\t * @param  {String} dir Direction to resolve\n\t * @return {Number}\n\t */\n\tfunction resolveDirection(dir) {\n\t\tif (typeof dir == 'number') {\n\t\t\treturn dir;\n\t\t}\n\n\t\tdir = normalizeSpace(dir).toLowerCase();\n\t\tif (reDeg.test(dir)) {\n\t\t\treturn +RegExp.$1;\n\t\t}\n\n\t\tvar prefix = /^to\\s/.test(dir) ? 'to ' : '';\n\t\tvar left   = ~dir.indexOf('left')   && 'left';\n\t\tvar right  = ~dir.indexOf('right')  && 'right';\n\t\tvar top    = ~dir.indexOf('top')    && 'top';\n\t\tvar bottom = ~dir.indexOf('bottom') && 'bottom';\n\n\t\tvar key = normalizeSpace(prefix + (top || bottom || '') + ' ' + (left || right || ''));\n\t\treturn directions[key] || 0;\n\t}\n\n\t/**\n\t * Tries to find keyword for given direction, expressed in degrees\n\t * @param  {Number} dir Direction (degrees)\n\t * @param {Boolean} oldStyle Use old style keywords (e.g. \"top\" instead of \"to bottom\")\n\t * @return {String}     Keyword or <code>Ndeg</code> expression\n\t */\n\tfunction stringifyDirection(dir, oldStyle) {\n\t\tvar reNewStyle = /^to\\s/;\n\t\tvar keys = Object.keys(directions).filter(function(k) {\n\t\t\tvar hasPrefix = reNewStyle.test(k);\n\t\t\treturn oldStyle ? !hasPrefix : hasPrefix;\n\t\t});\n\n\t\tfor (var i = 0; i < keys.length; i++) {\n\t\t\tif (directions[keys[i]] == dir) {\n\t\t\t\treturn keys[i];\n\t\t\t}\n\t\t}\n\n\t\tif (oldStyle) {\n\t\t\tdir = (dir + 270) % 360;\n\t\t}\n\n\t\treturn dir + 'deg';\n\t}\n\n\t/**\n\t * Creates direction definition for old Webkit gradients\n\t * @param {String} direction\n\t * @returns {String}\n\t */\n\tfunction oldWebkitDirection(dir) {\n\t\tdir = stringifyDirection(dir, true);\n\t\t\n\t\tif(reDeg.test(dir)) {\n\t\t\tthrow \"The direction is an angle that can’t be converted.\";\n\t\t}\n\t\t\n\t\tvar v = function(pos) {\n\t\t\treturn ~dir.indexOf(pos) ? '100%' : '0';\n\t\t};\n\t\t\n\t\treturn v('left') + ' ' + v('top') + ', ' + v('right') + ' ' + v('bottom');\n\t}\n\n\treturn {\n\t\t/**\n\t\t * Parses gradient definition into an object.\n\t\t * This object can be used to transform gradient into various\n\t\t * forms\n\t\t * @param  {String} gradient Gradient definition\n\t\t * @return {LinearGradient}\n\t\t */\n\t\tparse: function(gradient) {\n\t\t\t// cut out all redundant data\n\t\t\tif (this.isLinearGradient(gradient)) {\n\t\t\t\tgradient = gradient.replace(/^\\s*[\\-a-z]+\\s*\\(|\\)\\s*$/ig, '');\n\t\t\t} else {\n\t\t\t\tthrow 'Invalid linear gradient definition:\\n' + gradient;\n\t\t\t}\n\n\t\t\treturn new LinearGradient(gradient);\n\t\t},\n\n\t\t/**\n\t\t * Check if given string can be parsed as linear gradient\n\t\t * @param  {String}  str\n\t\t * @return {Boolean}\n\t\t */\n\t\tisLinearGradient: function(str) {\n\t\t\treturn reLinearGradient.test(str);\n\t\t},\n\n\t\tresolveDirection: resolveDirection,\n\t\tstringifyDirection: stringifyDirection\n\t};\n});\n},{\"../../assets/stringStream\":\"assets\\\\stringStream.js\",\"../../utils/common\":\"utils\\\\common.js\"}],\"resolver\\\\tagName.js\":[function(require,module,exports){\n/**\n * Module for resolving tag names: returns best matched tag name for child\n * element based on passed parent's tag name. Also provides utility function\n * for element type detection (inline, block-level, empty)\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar utils = require('../utils/common');\n\t\n\tvar elementTypes = {\n//\t\tempty: 'area,base,basefont,br,col,frame,hr,img,input,isindex,link,meta,param,embed,keygen,command'.split(','),\n\t\tempty: [],\n\t\tblockLevel: 'address,applet,blockquote,button,center,dd,del,dir,div,dl,dt,fieldset,form,frameset,hr,iframe,ins,isindex,li,link,map,menu,noframes,noscript,object,ol,p,pre,script,table,tbody,td,tfoot,th,thead,tr,ul,h1,h2,h3,h4,h5,h6'.split(','),\n\t\tinlineLevel: '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(',')\n\t};\n\t\n\tvar elementMap = {\n\t\t'p': 'span',\n\t\t'ul': 'li',\n\t\t'ol': 'li',\n\t\t'table': 'tr',\n\t\t'tr': 'td',\n\t\t'tbody': 'tr',\n\t\t'thead': 'tr',\n\t\t'tfoot': 'tr',\n\t\t'colgroup': 'col',\n\t\t'select': 'option',\n\t\t'optgroup': 'option',\n\t\t'audio': 'source',\n\t\t'video': 'source',\n\t\t'object': 'param',\n\t\t'map': 'area'\n\t};\n\t\n\treturn {\n\t\t/**\n\t\t * Returns best matched child element name for passed parent's\n\t\t * tag name\n\t\t * @param {String} name\n\t\t * @returns {String}\n\t\t * @memberOf tagName\n\t\t */\n\t\tresolve: function(name) {\n\t\t\tname = (name || '').toLowerCase();\n\t\t\t\n\t\t\tif (name in elementMap)\n\t\t\t\treturn this.getMapping(name);\n\t\t\t\n\t\t\tif (this.isInlineLevel(name))\n\t\t\t\treturn 'span';\n\t\t\t\n\t\t\treturn 'div';\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns mapped child element name for passed parent's name \n\t\t * @param {String} name\n\t\t * @returns {String}\n\t\t */\n\t\tgetMapping: function(name) {\n\t\t\treturn elementMap[name.toLowerCase()];\n\t\t},\n\t\t\n\t\t/**\n\t\t * Check if passed element name belongs to inline-level element\n\t\t * @param {String} name\n\t\t * @returns {Boolean}\n\t\t */\n\t\tisInlineLevel: function(name) {\n\t\t\treturn this.isTypeOf(name, 'inlineLevel');\n\t\t},\n\t\t\n\t\t/**\n\t\t * Check if passed element belongs to block-level element.\n\t\t * For better matching of unknown elements (for XML, for example), \n\t\t * you should use <code>!this.isInlineLevel(name)</code>\n\t\t * @returns {Boolean}\n\t\t */\n\t\tisBlockLevel: function(name) {\n\t\t\treturn this.isTypeOf(name, 'blockLevel');\n\t\t},\n\t\t\n\t\t/**\n\t\t * Check if passed element is void (i.e. should not have closing tag).\n\t\t * @returns {Boolean}\n\t\t */\n\t\tisEmptyElement: function(name) {\n\t\t\treturn this.isTypeOf(name, 'empty');\n\t\t},\n\t\t\n\t\t/**\n\t\t * Generic function for testing if element name belongs to specified\n\t\t * elements collection\n\t\t * @param {String} name Element name\n\t\t * @param {String} type Collection name\n\t\t * @returns {Boolean}\n\t\t */\n\t\tisTypeOf: function(name, type) {\n\t\t\treturn ~elementTypes[type].indexOf(name);\n\t\t},\n\t\t\n\t\t/**\n\t\t * Adds new parent–child mapping\n\t\t * @param {String} parent\n\t\t * @param {String} child\n\t\t */\n\t\taddMapping: function(parent, child) {\n\t\t\telementMap[parent] = child;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Removes parent-child mapping\n\t\t */\n\t\tremoveMapping: function(parent) {\n\t\t\tif (parent in elementMap)\n\t\t\t\tdelete elementMap[parent];\n\t\t},\n\t\t\n\t\t/**\n\t\t * Adds new element into collection\n\t\t * @param {String} name Element name\n\t\t * @param {String} collection Collection name\n\t\t */\n\t\taddElementToCollection: function(name, collection) {\n\t\t\tif (!elementTypes[collection])\n\t\t\t\telementTypes[collection] = [];\n\t\t\t\n\t\t\tvar col = this.getCollection(collection);\n\t\t\tif (!~col.indexOf(name)) {\n\t\t\t\tcol.push(name);\n\t\t\t}\n\t\t},\n\t\t\n\t\t/**\n\t\t * Removes element name from specified collection\n\t\t * @param {String} name Element name\n\t\t * @param {String} collection Collection name\n\t\t * @returns\n\t\t */\n\t\tremoveElementFromCollection: function(name, collection) {\n\t\t\tif (collection in elementTypes) {\n\t\t\t\telementTypes[collection] = utils.without(this.getCollection(collection), name);\n\t\t\t}\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns elements name collection\n\t\t * @param {String} name Collection name\n\t\t * @returns {Array}\n\t\t */\n\t\tgetCollection: function(name) {\n\t\t\treturn elementTypes[name];\n\t\t}\n\t};\n});\n},{\"../utils/common\":\"utils\\\\common.js\"}],\"snippets.json\":[function(require,module,exports){\nmodule.exports={\n\t\"variables\": {\n\t\t\"lang\": \"en\",\n\t\t\"locale\": \"en-US\",\n\t\t\"charset\": \"UTF-8\",\n\t\t\"indentation\": \"\\t\",\n\t\t\"newline\": \"\\n\"\n\t},\n\t\n\t\"css\": {\n\t\t\"filters\": \"css\",\n\t\t\"profile\": \"css\",\n\t\t\"snippets\": {\n\t\t\t\"@i\": \"@import url(|);\",\n\t\t\t\"@import\": \"@import url(|);\",\n\t\t\t\"@m\": \"@media ${1:screen} {\\n\\t|\\n}\",\n\t\t\t\"@media\": \"@media ${1:screen} {\\n\\t|\\n}\",\n\t\t\t\"@f\": \"@font-face {\\n\\tfont-family:|;\\n\\tsrc:url(|);\\n}\",\n\t\t\t\"@f+\": \"@font-face {\\n\\tfont-family: '${1:FontName}';\\n\\tsrc: url('${2:FileName}.eot');\\n\\tsrc: url('${2:FileName}.eot?#iefix') format('embedded-opentype'),\\n\\t\\t url('${2:FileName}.woff') format('woff'),\\n\\t\\t url('${2:FileName}.ttf') format('truetype'),\\n\\t\\t url('${2:FileName}.svg#${1:FontName}') format('svg');\\n\\tfont-style: ${3:normal};\\n\\tfont-weight: ${4:normal};\\n}\",\n\n\t\t\t\"@kf\": \"@-webkit-keyframes ${1:identifier} {\\n\\t${2:from} { ${3} }${6}\\n\\t${4:to} { ${5} }\\n}\\n@-o-keyframes ${1:identifier} {\\n\\t${2:from} { ${3} }${6}\\n\\t${4:to} { ${5} }\\n}\\n@-moz-keyframes ${1:identifier} {\\n\\t${2:from} { ${3} }${6}\\n\\t${4:to} { ${5} }\\n}\\n@keyframes ${1:identifier} {\\n\\t${2:from} { ${3} }${6}\\n\\t${4:to} { ${5} }\\n}\",\n\n\t\t\t\"anim\": \"animation:|;\",\n\t\t\t\"anim-\": \"animation:${1:name} ${2:duration} ${3:timing-function} ${4:delay} ${5:iteration-count} ${6:direction} ${7:fill-mode};\",\n\t\t\t\"animdel\": \"animation-delay:${1:time};\",\n\t\t\t\n\t\t\t\"animdir\": \"animation-direction:${1:normal};\",\n\t\t\t\"animdir:n\": \"animation-direction:normal;\",\n\t\t\t\"animdir:r\": \"animation-direction:reverse;\",\n\t\t\t\"animdir:a\": \"animation-direction:alternate;\",\n\t\t\t\"animdir:ar\": \"animation-direction:alternate-reverse;\",\n\t\t\t\n\t\t\t\"animdur\": \"animation-duration:${1:0}s;\",\n\t\t\t\n\t\t\t\"animfm\": \"animation-fill-mode:${1:both};\",\n\t\t\t\"animfm:f\": \"animation-fill-mode:forwards;\",\n\t\t\t\"animfm:b\": \"animation-fill-mode:backwards;\",\n\t\t\t\"animfm:bt\": \"animation-fill-mode:both;\",\n\t\t\t\"animfm:bh\": \"animation-fill-mode:both;\",\n\t\t\t\n\t\t\t\"animic\": \"animation-iteration-count:${1:1};\",\n\t\t\t\"animic:i\": \"animation-iteration-count:infinite;\",\n\t\t\t\n\t\t\t\"animn\": \"animation-name:${1:none};\",\n\n\t\t\t\"animps\": \"animation-play-state:${1:running};\",\n\t\t\t\"animps:p\": \"animation-play-state:paused;\",\n\t\t\t\"animps:r\": \"animation-play-state:running;\",\n\n\t\t\t\"animtf\": \"animation-timing-function:${1:linear};\",\n\t\t\t\"animtf:e\": \"animation-timing-function:ease;\",\n\t\t\t\"animtf:ei\": \"animation-timing-function:ease-in;\",\n\t\t\t\"animtf:eo\": \"animation-timing-function:ease-out;\",\n\t\t\t\"animtf:eio\": \"animation-timing-function:ease-in-out;\",\n\t\t\t\"animtf:l\": \"animation-timing-function:linear;\",\n\t\t\t\"animtf:cb\": \"animation-timing-function:cubic-bezier(${1:0.1}, ${2:0.7}, ${3:1.0}, ${3:0.1});\",\n\t\t\t\n\t\t\t\"ap\": \"appearance:${none};\",\n\n\t\t\t\"!\": \"!important\",\n\t\t\t\"pos\": \"position:${1:relative};\",\n\t\t\t\"pos:s\": \"position:static;\",\n\t\t\t\"pos:a\": \"position:absolute;\",\n\t\t\t\"pos:r\": \"position:relative;\",\n\t\t\t\"pos:f\": \"position:fixed;\",\n\t\t\t\"t\": \"top:|;\",\n\t\t\t\"t:a\": \"top:auto;\",\n\t\t\t\"r\": \"right:|;\",\n\t\t\t\"r:a\": \"right:auto;\",\n\t\t\t\"b\": \"bottom:|;\",\n\t\t\t\"b:a\": \"bottom:auto;\",\n\t\t\t\"l\": \"left:|;\",\n\t\t\t\"l:a\": \"left:auto;\",\n\t\t\t\"z\": \"z-index:|;\",\n\t\t\t\"z:a\": \"z-index:auto;\",\n\t\t\t\"fl\": \"float:${1:left};\",\n\t\t\t\"fl:n\": \"float:none;\",\n\t\t\t\"fl:l\": \"float:left;\",\n\t\t\t\"fl:r\": \"float:right;\",\n\t\t\t\"cl\": \"clear:${1:both};\",\n\t\t\t\"cl:n\": \"clear:none;\",\n\t\t\t\"cl:l\": \"clear:left;\",\n\t\t\t\"cl:r\": \"clear:right;\",\n\t\t\t\"cl:b\": \"clear:both;\",\n\n\t\t\t\"colm\": \"columns:|;\",\n\t\t\t\"colmc\": \"column-count:|;\",\n\t\t\t\"colmf\": \"column-fill:|;\",\n\t\t\t\"colmg\": \"column-gap:|;\",\n\t\t\t\"colmr\": \"column-rule:|;\",\n\t\t\t\"colmrc\": \"column-rule-color:|;\",\n\t\t\t\"colmrs\": \"column-rule-style:|;\",\n\t\t\t\"colmrw\": \"column-rule-width:|;\",\n\t\t\t\"colms\": \"column-span:|;\",\n\t\t\t\"colmw\": \"column-width:|;\",\n\n\t\t\t\"d\": \"display:${1:block};\",\n\t\t\t\"d:n\": \"display:none;\",\n\t\t\t\"d:b\": \"display:block;\",\n\t\t\t\"d:f\": \"display:flex;\",\n\t\t\t\"d:if\": \"display:inline-flex;\",\n\t\t\t\"d:i\": \"display:inline;\",\n\t\t\t\"d:ib\": \"display:inline-block;\",\n\t\t\t\"d:ib+\": \"display: inline-block;\\n*display: inline;\\n*zoom: 1;\",\n\t\t\t\"d:li\": \"display:list-item;\",\n\t\t\t\"d:ri\": \"display:run-in;\",\n\t\t\t\"d:cp\": \"display:compact;\",\n\t\t\t\"d:tb\": \"display:table;\",\n\t\t\t\"d:itb\": \"display:inline-table;\",\n\t\t\t\"d:tbcp\": \"display:table-caption;\",\n\t\t\t\"d:tbcl\": \"display:table-column;\",\n\t\t\t\"d:tbclg\": \"display:table-column-group;\",\n\t\t\t\"d:tbhg\": \"display:table-header-group;\",\n\t\t\t\"d:tbfg\": \"display:table-footer-group;\",\n\t\t\t\"d:tbr\": \"display:table-row;\",\n\t\t\t\"d:tbrg\": \"display:table-row-group;\",\n\t\t\t\"d:tbc\": \"display:table-cell;\",\n\t\t\t\"d:rb\": \"display:ruby;\",\n\t\t\t\"d:rbb\": \"display:ruby-base;\",\n\t\t\t\"d:rbbg\": \"display:ruby-base-group;\",\n\t\t\t\"d:rbt\": \"display:ruby-text;\",\n\t\t\t\"d:rbtg\": \"display:ruby-text-group;\",\n\t\t\t\"v\": \"visibility:${1:hidden};\",\n\t\t\t\"v:v\": \"visibility:visible;\",\n\t\t\t\"v:h\": \"visibility:hidden;\",\n\t\t\t\"v:c\": \"visibility:collapse;\",\n\t\t\t\"ov\": \"overflow:${1:hidden};\",\n\t\t\t\"ov:v\": \"overflow:visible;\",\n\t\t\t\"ov:h\": \"overflow:hidden;\",\n\t\t\t\"ov:s\": \"overflow:scroll;\",\n\t\t\t\"ov:a\": \"overflow:auto;\",\n\t\t\t\"ovx\": \"overflow-x:${1:hidden};\",\n\t\t\t\"ovx:v\": \"overflow-x:visible;\",\n\t\t\t\"ovx:h\": \"overflow-x:hidden;\",\n\t\t\t\"ovx:s\": \"overflow-x:scroll;\",\n\t\t\t\"ovx:a\": \"overflow-x:auto;\",\n\t\t\t\"ovy\": \"overflow-y:${1:hidden};\",\n\t\t\t\"ovy:v\": \"overflow-y:visible;\",\n\t\t\t\"ovy:h\": \"overflow-y:hidden;\",\n\t\t\t\"ovy:s\": \"overflow-y:scroll;\",\n\t\t\t\"ovy:a\": \"overflow-y:auto;\",\n\t\t\t\"ovs\": \"overflow-style:${1:scrollbar};\",\n\t\t\t\"ovs:a\": \"overflow-style:auto;\",\n\t\t\t\"ovs:s\": \"overflow-style:scrollbar;\",\n\t\t\t\"ovs:p\": \"overflow-style:panner;\",\n\t\t\t\"ovs:m\": \"overflow-style:move;\",\n\t\t\t\"ovs:mq\": \"overflow-style:marquee;\",\n\t\t\t\"zoo\": \"zoom:1;\",\n\t\t\t\"zm\": \"zoom:1;\",\n\t\t\t\"cp\": \"clip:|;\",\n\t\t\t\"cp:a\": \"clip:auto;\",\n\t\t\t\"cp:r\": \"clip:rect(${1:top} ${2:right} ${3:bottom} ${4:left});\",\n\t\t\t\"bxz\": \"box-sizing:${1:border-box};\",\n\t\t\t\"bxz:cb\": \"box-sizing:content-box;\",\n\t\t\t\"bxz:bb\": \"box-sizing:border-box;\",\n\t\t\t\"bxsh\": \"box-shadow:${1:inset }${2:hoff} ${3:voff} ${4:blur} ${5:color};\",\n\t\t\t\"bxsh:r\": \"box-shadow:${1:inset }${2:hoff} ${3:voff} ${4:blur} ${5:spread }rgb(${6:0}, ${7:0}, ${8:0});\",\n\t\t\t\"bxsh:ra\": \"box-shadow:${1:inset }${2:h} ${3:v} ${4:blur} ${5:spread }rgba(${6:0}, ${7:0}, ${8:0}, .${9:5});\",\n\t\t\t\"bxsh:n\": \"box-shadow:none;\",\n\t\t\t\"m\": \"margin:|;\",\n\t\t\t\"m:a\": \"margin:auto;\",\n\t\t\t\"mt\": \"margin-top:|;\",\n\t\t\t\"mt:a\": \"margin-top:auto;\",\n\t\t\t\"mr\": \"margin-right:|;\",\n\t\t\t\"mr:a\": \"margin-right:auto;\",\n\t\t\t\"mb\": \"margin-bottom:|;\",\n\t\t\t\"mb:a\": \"margin-bottom:auto;\",\n\t\t\t\"ml\": \"margin-left:|;\",\n\t\t\t\"ml:a\": \"margin-left:auto;\",\n\t\t\t\"p\": \"padding:|;\",\n\t\t\t\"pt\": \"padding-top:|;\",\n\t\t\t\"pr\": \"padding-right:|;\",\n\t\t\t\"pb\": \"padding-bottom:|;\",\n\t\t\t\"pl\": \"padding-left:|;\",\n\t\t\t\"w\": \"width:|;\",\n\t\t\t\"w:a\": \"width:auto;\",\n\t\t\t\"h\": \"height:|;\",\n\t\t\t\"h:a\": \"height:auto;\",\n\t\t\t\"maw\": \"max-width:|;\",\n\t\t\t\"maw:n\": \"max-width:none;\",\n\t\t\t\"mah\": \"max-height:|;\",\n\t\t\t\"mah:n\": \"max-height:none;\",\n\t\t\t\"miw\": \"min-width:|;\",\n\t\t\t\"mih\": \"min-height:|;\",\n\t\t\t\"mar\": \"max-resolution:${1:res};\",\n\t\t\t\"mir\": \"min-resolution:${1:res};\",\n\t\t\t\"ori\": \"orientation:|;\",\n\t\t\t\"ori:l\": \"orientation:landscape;\",\n\t\t\t\"ori:p\": \"orientation:portrait;\",\n\t\t\t\"ol\": \"outline:|;\",\n\t\t\t\"ol:n\": \"outline:none;\",\n\t\t\t\"olo\": \"outline-offset:|;\",\n\t\t\t\"olw\": \"outline-width:|;\",\n\t\t\t\"olw:tn\": \"outline-width:thin;\",\n\t\t\t\"olw:m\": \"outline-width:medium;\",\n\t\t\t\"olw:tc\": \"outline-width:thick;\",\n\t\t\t\"ols\": \"outline-style:|;\",\n\t\t\t\"ols:n\": \"outline-style:none;\",\n\t\t\t\"ols:dt\": \"outline-style:dotted;\",\n\t\t\t\"ols:ds\": \"outline-style:dashed;\",\n\t\t\t\"ols:s\": \"outline-style:solid;\",\n\t\t\t\"ols:db\": \"outline-style:double;\",\n\t\t\t\"ols:g\": \"outline-style:groove;\",\n\t\t\t\"ols:r\": \"outline-style:ridge;\",\n\t\t\t\"ols:i\": \"outline-style:inset;\",\n\t\t\t\"ols:o\": \"outline-style:outset;\",\n\t\t\t\"olc\": \"outline-color:#${1:000};\",\n\t\t\t\"olc:i\": \"outline-color:invert;\",\n\t\t\t\"bfv\": \"backface-visibility:|;\",\n\t\t\t\"bfv:h\": \"backface-visibility:hidden;\",\n\t\t\t\"bfv:v\": \"backface-visibility:visible;\",\n\t\t\t\"bd\": \"border:|;\",\n\t\t\t\"bd+\": \"border:${1:1px} ${2:solid} ${3:#000};\",\n\t\t\t\"bd:n\": \"border:none;\",\n\t\t\t\"bdbk\": \"border-break:${1:close};\",\n\t\t\t\"bdbk:c\": \"border-break:close;\",\n\t\t\t\"bdcl\": \"border-collapse:|;\",\n\t\t\t\"bdcl:c\": \"border-collapse:collapse;\",\n\t\t\t\"bdcl:s\": \"border-collapse:separate;\",\n\t\t\t\"bdc\": \"border-color:#${1:000};\",\n\t\t\t\"bdc:t\": \"border-color:transparent;\",\n\t\t\t\"bdi\": \"border-image:url(|);\",\n\t\t\t\"bdi:n\": \"border-image:none;\",\n\t\t\t\"bdti\": \"border-top-image:url(|);\",\n\t\t\t\"bdti:n\": \"border-top-image:none;\",\n\t\t\t\"bdri\": \"border-right-image:url(|);\",\n\t\t\t\"bdri:n\": \"border-right-image:none;\",\n\t\t\t\"bdbi\": \"border-bottom-image:url(|);\",\n\t\t\t\"bdbi:n\": \"border-bottom-image:none;\",\n\t\t\t\"bdli\": \"border-left-image:url(|);\",\n\t\t\t\"bdli:n\": \"border-left-image:none;\",\n\t\t\t\"bdci\": \"border-corner-image:url(|);\",\n\t\t\t\"bdci:n\": \"border-corner-image:none;\",\n\t\t\t\"bdci:c\": \"border-corner-image:continue;\",\n\t\t\t\"bdtli\": \"border-top-left-image:url(|);\",\n\t\t\t\"bdtli:n\": \"border-top-left-image:none;\",\n\t\t\t\"bdtli:c\": \"border-top-left-image:continue;\",\n\t\t\t\"bdtri\": \"border-top-right-image:url(|);\",\n\t\t\t\"bdtri:n\": \"border-top-right-image:none;\",\n\t\t\t\"bdtri:c\": \"border-top-right-image:continue;\",\n\t\t\t\"bdbri\": \"border-bottom-right-image:url(|);\",\n\t\t\t\"bdbri:n\": \"border-bottom-right-image:none;\",\n\t\t\t\"bdbri:c\": \"border-bottom-right-image:continue;\",\n\t\t\t\"bdbli\": \"border-bottom-left-image:url(|);\",\n\t\t\t\"bdbli:n\": \"border-bottom-left-image:none;\",\n\t\t\t\"bdbli:c\": \"border-bottom-left-image:continue;\",\n\t\t\t\"bdf\": \"border-fit:${1:repeat};\",\n\t\t\t\"bdf:c\": \"border-fit:clip;\",\n\t\t\t\"bdf:r\": \"border-fit:repeat;\",\n\t\t\t\"bdf:sc\": \"border-fit:scale;\",\n\t\t\t\"bdf:st\": \"border-fit:stretch;\",\n\t\t\t\"bdf:ow\": \"border-fit:overwrite;\",\n\t\t\t\"bdf:of\": \"border-fit:overflow;\",\n\t\t\t\"bdf:sp\": \"border-fit:space;\",\n\t\t\t\"bdlen\": \"border-length:|;\",\n\t\t\t\"bdlen:a\": \"border-length:auto;\",\n\t\t\t\"bdsp\": \"border-spacing:|;\",\n\t\t\t\"bds\": \"border-style:|;\",\n\t\t\t\"bds:n\": \"border-style:none;\",\n\t\t\t\"bds:h\": \"border-style:hidden;\",\n\t\t\t\"bds:dt\": \"border-style:dotted;\",\n\t\t\t\"bds:ds\": \"border-style:dashed;\",\n\t\t\t\"bds:s\": \"border-style:solid;\",\n\t\t\t\"bds:db\": \"border-style:double;\",\n\t\t\t\"bds:dtds\": \"border-style:dot-dash;\",\n\t\t\t\"bds:dtdtds\": \"border-style:dot-dot-dash;\",\n\t\t\t\"bds:w\": \"border-style:wave;\",\n\t\t\t\"bds:g\": \"border-style:groove;\",\n\t\t\t\"bds:r\": \"border-style:ridge;\",\n\t\t\t\"bds:i\": \"border-style:inset;\",\n\t\t\t\"bds:o\": \"border-style:outset;\",\n\t\t\t\"bdw\": \"border-width:|;\",\n\t\t\t\"bdtw\": \"border-top-width:|;\",\n\t\t\t\"bdrw\": \"border-right-width:|;\",\n\t\t\t\"bdbw\": \"border-bottom-width:|;\",\n\t\t\t\"bdlw\": \"border-left-width:|;\",\n\t\t\t\"bdt\": \"border-top:|;\",\n\t\t\t\"bt\": \"border-top:|;\",\n\t\t\t\"bdt+\": \"border-top:${1:1px} ${2:solid} ${3:#000};\",\n\t\t\t\"bdt:n\": \"border-top:none;\",\n\t\t\t\"bdts\": \"border-top-style:|;\",\n\t\t\t\"bdts:n\": \"border-top-style:none;\",\n\t\t\t\"bdtc\": \"border-top-color:#${1:000};\",\n\t\t\t\"bdtc:t\": \"border-top-color:transparent;\",\n\t\t\t\"bdr\": \"border-right:|;\",\n\t\t\t\"br\": \"border-right:|;\",\n\t\t\t\"bdr+\": \"border-right:${1:1px} ${2:solid} ${3:#000};\",\n\t\t\t\"bdr:n\": \"border-right:none;\",\n\t\t\t\"bdrst\": \"border-right-style:|;\",\n\t\t\t\"bdrst:n\": \"border-right-style:none;\",\n\t\t\t\"bdrc\": \"border-right-color:#${1:000};\",\n\t\t\t\"bdrc:t\": \"border-right-color:transparent;\",\n\t\t\t\"bdb\": \"border-bottom:|;\",\n\t\t\t\"bb\": \"border-bottom:|;\",\n\t\t\t\"bdb+\": \"border-bottom:${1:1px} ${2:solid} ${3:#000};\",\n\t\t\t\"bdb:n\": \"border-bottom:none;\",\n\t\t\t\"bdbs\": \"border-bottom-style:|;\",\n\t\t\t\"bdbs:n\": \"border-bottom-style:none;\",\n\t\t\t\"bdbc\": \"border-bottom-color:#${1:000};\",\n\t\t\t\"bdbc:t\": \"border-bottom-color:transparent;\",\n\t\t\t\"bdl\": \"border-left:|;\",\n\t\t\t\"bl\": \"border-left:|;\",\n\t\t\t\"bdl+\": \"border-left:${1:1px} ${2:solid} ${3:#000};\",\n\t\t\t\"bdl:n\": \"border-left:none;\",\n\t\t\t\"bdls\": \"border-left-style:|;\",\n\t\t\t\"bdls:n\": \"border-left-style:none;\",\n\t\t\t\"bdlc\": \"border-left-color:#${1:000};\",\n\t\t\t\"bdlc:t\": \"border-left-color:transparent;\",\n\t\t\t\"bdrs\": \"border-radius:|;\",\n\t\t\t\"bdtrrs\": \"border-top-right-radius:|;\",\n\t\t\t\"bdtlrs\": \"border-top-left-radius:|;\",\n\t\t\t\"bdbrrs\": \"border-bottom-right-radius:|;\",\n\t\t\t\"bdblrs\": \"border-bottom-left-radius:|;\",\n\t\t\t\"bg\": \"background:#${1:000};\",\n\t\t\t\"bg+\": \"background:${1:#fff} url(${2}) ${3:0} ${4:0} ${5:no-repeat};\",\n\t\t\t\"bg:n\": \"background:none;\",\n\t\t\t\"bg:ie\": \"filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src='${1:x}.png',sizingMethod='${2:crop}');\",\n\t\t\t\"bgc\": \"background-color:#${1:fff};\",\n\t\t\t\"bgc:t\": \"background-color:transparent;\",\n\t\t\t\"bgi\": \"background-image:url(|);\",\n\t\t\t\"bgi:n\": \"background-image:none;\",\n\t\t\t\"bgr\": \"background-repeat:|;\",\n\t\t\t\"bgr:n\": \"background-repeat:no-repeat;\",\n\t\t\t\"bgr:x\": \"background-repeat:repeat-x;\",\n\t\t\t\"bgr:y\": \"background-repeat:repeat-y;\",\n\t\t\t\"bgr:sp\": \"background-repeat:space;\",\n\t\t\t\"bgr:rd\": \"background-repeat:round;\",\n\t\t\t\"bga\": \"background-attachment:|;\",\n\t\t\t\"bga:f\": \"background-attachment:fixed;\",\n\t\t\t\"bga:s\": \"background-attachment:scroll;\",\n\t\t\t\"bgp\": \"background-position:${1:0} ${2:0};\",\n\t\t\t\"bgpx\": \"background-position-x:|;\",\n\t\t\t\"bgpy\": \"background-position-y:|;\",\n\t\t\t\"bgbk\": \"background-break:|;\",\n\t\t\t\"bgbk:bb\": \"background-break:bounding-box;\",\n\t\t\t\"bgbk:eb\": \"background-break:each-box;\",\n\t\t\t\"bgbk:c\": \"background-break:continuous;\",\n\t\t\t\"bgcp\": \"background-clip:${1:padding-box};\",\n\t\t\t\"bgcp:bb\": \"background-clip:border-box;\",\n\t\t\t\"bgcp:pb\": \"background-clip:padding-box;\",\n\t\t\t\"bgcp:cb\": \"background-clip:content-box;\",\n\t\t\t\"bgcp:nc\": \"background-clip:no-clip;\",\n\t\t\t\"bgo\": \"background-origin:|;\",\n\t\t\t\"bgo:pb\": \"background-origin:padding-box;\",\n\t\t\t\"bgo:bb\": \"background-origin:border-box;\",\n\t\t\t\"bgo:cb\": \"background-origin:content-box;\",\n\t\t\t\"bgsz\": \"background-size:|;\",\n\t\t\t\"bgsz:a\": \"background-size:auto;\",\n\t\t\t\"bgsz:ct\": \"background-size:contain;\",\n\t\t\t\"bgsz:cv\": \"background-size:cover;\",\n\t\t\t\"c\": \"color:#${1:000};\",\n\t\t\t\"c:r\": \"color:rgb(${1:0}, ${2:0}, ${3:0});\",\n\t\t\t\"c:ra\": \"color:rgba(${1:0}, ${2:0}, ${3:0}, .${4:5});\",\n\t\t\t\"cm\": \"/* |${child} */\",\n\t\t\t\"cnt\": \"content:'|';\",\n\t\t\t\"cnt:n\": \"content:normal;\",\n\t\t\t\"cnt:oq\": \"content:open-quote;\",\n\t\t\t\"cnt:noq\": \"content:no-open-quote;\",\n\t\t\t\"cnt:cq\": \"content:close-quote;\",\n\t\t\t\"cnt:ncq\": \"content:no-close-quote;\",\n\t\t\t\"cnt:a\": \"content:attr(|);\",\n\t\t\t\"cnt:c\": \"content:counter(|);\",\n\t\t\t\"cnt:cs\": \"content:counters(|);\",\n\n\t\t\t\"tbl\": \"table-layout:|;\",\n\t\t\t\"tbl:a\": \"table-layout:auto;\",\n\t\t\t\"tbl:f\": \"table-layout:fixed;\",\n\t\t\t\"cps\": \"caption-side:|;\",\n\t\t\t\"cps:t\": \"caption-side:top;\",\n\t\t\t\"cps:b\": \"caption-side:bottom;\",\n\t\t\t\"ec\": \"empty-cells:|;\",\n\t\t\t\"ec:s\": \"empty-cells:show;\",\n\t\t\t\"ec:h\": \"empty-cells:hide;\",\n\t\t\t\"lis\": \"list-style:|;\",\n\t\t\t\"lis:n\": \"list-style:none;\",\n\t\t\t\"lisp\": \"list-style-position:|;\",\n\t\t\t\"lisp:i\": \"list-style-position:inside;\",\n\t\t\t\"lisp:o\": \"list-style-position:outside;\",\n\t\t\t\"list\": \"list-style-type:|;\",\n\t\t\t\"list:n\": \"list-style-type:none;\",\n\t\t\t\"list:d\": \"list-style-type:disc;\",\n\t\t\t\"list:c\": \"list-style-type:circle;\",\n\t\t\t\"list:s\": \"list-style-type:square;\",\n\t\t\t\"list:dc\": \"list-style-type:decimal;\",\n\t\t\t\"list:dclz\": \"list-style-type:decimal-leading-zero;\",\n\t\t\t\"list:lr\": \"list-style-type:lower-roman;\",\n\t\t\t\"list:ur\": \"list-style-type:upper-roman;\",\n\t\t\t\"lisi\": \"list-style-image:|;\",\n\t\t\t\"lisi:n\": \"list-style-image:none;\",\n\t\t\t\"q\": \"quotes:|;\",\n\t\t\t\"q:n\": \"quotes:none;\",\n\t\t\t\"q:ru\": \"quotes:'\\\\00AB' '\\\\00BB' '\\\\201E' '\\\\201C';\",\n\t\t\t\"q:en\": \"quotes:'\\\\201C' '\\\\201D' '\\\\2018' '\\\\2019';\",\n\t\t\t\"ct\": \"content:|;\",\n\t\t\t\"ct:n\": \"content:normal;\",\n\t\t\t\"ct:oq\": \"content:open-quote;\",\n\t\t\t\"ct:noq\": \"content:no-open-quote;\",\n\t\t\t\"ct:cq\": \"content:close-quote;\",\n\t\t\t\"ct:ncq\": \"content:no-close-quote;\",\n\t\t\t\"ct:a\": \"content:attr(|);\",\n\t\t\t\"ct:c\": \"content:counter(|);\",\n\t\t\t\"ct:cs\": \"content:counters(|);\",\n\t\t\t\"coi\": \"counter-increment:|;\",\n\t\t\t\"cor\": \"counter-reset:|;\",\n\t\t\t\"va\": \"vertical-align:${1:top};\",\n\t\t\t\"va:sup\": \"vertical-align:super;\",\n\t\t\t\"va:t\": \"vertical-align:top;\",\n\t\t\t\"va:tt\": \"vertical-align:text-top;\",\n\t\t\t\"va:m\": \"vertical-align:middle;\",\n\t\t\t\"va:bl\": \"vertical-align:baseline;\",\n\t\t\t\"va:b\": \"vertical-align:bottom;\",\n\t\t\t\"va:tb\": \"vertical-align:text-bottom;\",\n\t\t\t\"va:sub\": \"vertical-align:sub;\",\n\t\t\t\"ta\": \"text-align:${1:left};\",\n\t\t\t\"ta:l\": \"text-align:left;\",\n\t\t\t\"ta:c\": \"text-align:center;\",\n\t\t\t\"ta:r\": \"text-align:right;\",\n\t\t\t\"ta:j\": \"text-align:justify;\",\n\t\t\t\"ta-lst\": \"text-align-last:|;\",\n\t\t\t\"tal:a\": \"text-align-last:auto;\",\n\t\t\t\"tal:l\": \"text-align-last:left;\",\n\t\t\t\"tal:c\": \"text-align-last:center;\",\n\t\t\t\"tal:r\": \"text-align-last:right;\",\n\t\t\t\"td\": \"text-decoration:${1:none};\",\n\t\t\t\"td:n\": \"text-decoration:none;\",\n\t\t\t\"td:u\": \"text-decoration:underline;\",\n\t\t\t\"td:o\": \"text-decoration:overline;\",\n\t\t\t\"td:l\": \"text-decoration:line-through;\",\n\t\t\t\"te\": \"text-emphasis:|;\",\n\t\t\t\"te:n\": \"text-emphasis:none;\",\n\t\t\t\"te:ac\": \"text-emphasis:accent;\",\n\t\t\t\"te:dt\": \"text-emphasis:dot;\",\n\t\t\t\"te:c\": \"text-emphasis:circle;\",\n\t\t\t\"te:ds\": \"text-emphasis:disc;\",\n\t\t\t\"te:b\": \"text-emphasis:before;\",\n\t\t\t\"te:a\": \"text-emphasis:after;\",\n\t\t\t\"th\": \"text-height:|;\",\n\t\t\t\"th:a\": \"text-height:auto;\",\n\t\t\t\"th:f\": \"text-height:font-size;\",\n\t\t\t\"th:t\": \"text-height:text-size;\",\n\t\t\t\"th:m\": \"text-height:max-size;\",\n\t\t\t\"ti\": \"text-indent:|;\",\n\t\t\t\"ti:-\": \"text-indent:-9999px;\",\n\t\t\t\"tj\": \"text-justify:|;\",\n\t\t\t\"tj:a\": \"text-justify:auto;\",\n\t\t\t\"tj:iw\": \"text-justify:inter-word;\",\n\t\t\t\"tj:ii\": \"text-justify:inter-ideograph;\",\n\t\t\t\"tj:ic\": \"text-justify:inter-cluster;\",\n\t\t\t\"tj:d\": \"text-justify:distribute;\",\n\t\t\t\"tj:k\": \"text-justify:kashida;\",\n\t\t\t\"tj:t\": \"text-justify:tibetan;\",\n\t\t\t\"tov\": \"text-overflow:${ellipsis};\",\n\t\t\t\"tov:e\": \"text-overflow:ellipsis;\",\n\t\t\t\"tov:c\": \"text-overflow:clip;\",\n\t\t\t\"to\": \"text-outline:|;\",\n\t\t\t\"to+\": \"text-outline:${1:0} ${2:0} ${3:#000};\",\n\t\t\t\"to:n\": \"text-outline:none;\",\n\t\t\t\"tr\": \"text-replace:|;\",\n\t\t\t\"tr:n\": \"text-replace:none;\",\n\t\t\t\"tt\": \"text-transform:${1:uppercase};\",\n\t\t\t\"tt:n\": \"text-transform:none;\",\n\t\t\t\"tt:c\": \"text-transform:capitalize;\",\n\t\t\t\"tt:u\": \"text-transform:uppercase;\",\n\t\t\t\"tt:l\": \"text-transform:lowercase;\",\n\t\t\t\"tw\": \"text-wrap:|;\",\n\t\t\t\"tw:n\": \"text-wrap:normal;\",\n\t\t\t\"tw:no\": \"text-wrap:none;\",\n\t\t\t\"tw:u\": \"text-wrap:unrestricted;\",\n\t\t\t\"tw:s\": \"text-wrap:suppress;\",\n\t\t\t\"tsh\": \"text-shadow:${1:hoff} ${2:voff} ${3:blur} ${4:#000};\",\n\t\t\t\"tsh:r\": \"text-shadow:${1:h} ${2:v} ${3:blur} rgb(${4:0}, ${5:0}, ${6:0});\",\n\t\t\t\"tsh:ra\": \"text-shadow:${1:h} ${2:v} ${3:blur} rgba(${4:0}, ${5:0}, ${6:0}, .${7:5});\",\n\t\t\t\"tsh+\": \"text-shadow:${1:0} ${2:0} ${3:0} ${4:#000};\",\n\t\t\t\"tsh:n\": \"text-shadow:none;\",\n\t\t\t\"trf\": \"transform:|;\",\n\t\t\t\"trf:skx\": \"transform: skewX(${1:angle});\",\n\t\t\t\"trf:sky\": \"transform: skewY(${1:angle});\",\n\t\t\t\"trf:sc\": \"transform: scale(${1:x}, ${2:y});\",\n\t\t\t\"trf:scx\": \"transform: scaleX(${1:x});\",\n\t\t\t\"trf:scy\": \"transform: scaleY(${1:y});\",\n\t\t\t\"trf:scz\": \"transform: scaleZ(${1:z});\",\n\t\t\t\"trf:sc3\": \"transform: scale3d(${1:x}, ${2:y}, ${3:z});\",\n\t\t\t\"trf:r\": \"transform: rotate(${1:angle});\",\n\t\t\t\"trf:rx\": \"transform: rotateX(${1:angle});\",\n\t\t\t\"trf:ry\": \"transform: rotateY(${1:angle});\",\n\t\t\t\"trf:rz\": \"transform: rotateZ(${1:angle});\",\n\t\t\t\"trf:t\": \"transform: translate(${1:x}, ${2:y});\",\n\t\t\t\"trf:tx\": \"transform: translateX(${1:x});\",\n\t\t\t\"trf:ty\": \"transform: translateY(${1:y});\",\n\t\t\t\"trf:tz\": \"transform: translateZ(${1:z});\",\n\t\t\t\"trf:t3\": \"transform: translate3d(${1:tx}, ${2:ty}, ${3:tz});\",\n\t\t\t\"trfo\": \"transform-origin:|;\",\n\t\t\t\"trfs\": \"transform-style:${1:preserve-3d};\",\n\t\t\t\"trs\": \"transition:${1:prop} ${2:time};\",\n\t\t\t\"trsde\": \"transition-delay:${1:time};\",\n\t\t\t\"trsdu\": \"transition-duration:${1:time};\",\n\t\t\t\"trsp\": \"transition-property:${1:prop};\",\n\t\t\t\"trstf\": \"transition-timing-function:${1:tfunc};\",\n\t\t\t\"lh\": \"line-height:|;\",\n\t\t\t\"whs\": \"white-space:|;\",\n\t\t\t\"whs:n\": \"white-space:normal;\",\n\t\t\t\"whs:p\": \"white-space:pre;\",\n\t\t\t\"whs:nw\": \"white-space:nowrap;\",\n\t\t\t\"whs:pw\": \"white-space:pre-wrap;\",\n\t\t\t\"whs:pl\": \"white-space:pre-line;\",\n\t\t\t\"whsc\": \"white-space-collapse:|;\",\n\t\t\t\"whsc:n\": \"white-space-collapse:normal;\",\n\t\t\t\"whsc:k\": \"white-space-collapse:keep-all;\",\n\t\t\t\"whsc:l\": \"white-space-collapse:loose;\",\n\t\t\t\"whsc:bs\": \"white-space-collapse:break-strict;\",\n\t\t\t\"whsc:ba\": \"white-space-collapse:break-all;\",\n\t\t\t\"wob\": \"word-break:|;\",\n\t\t\t\"wob:n\": \"word-break:normal;\",\n\t\t\t\"wob:k\": \"word-break:keep-all;\",\n\t\t\t\"wob:ba\": \"word-break:break-all;\",\n\t\t\t\"wos\": \"word-spacing:|;\",\n\t\t\t\"wow\": \"word-wrap:|;\",\n\t\t\t\"wow:nm\": \"word-wrap:normal;\",\n\t\t\t\"wow:n\": \"word-wrap:none;\",\n\t\t\t\"wow:u\": \"word-wrap:unrestricted;\",\n\t\t\t\"wow:s\": \"word-wrap:suppress;\",\n\t\t\t\"wow:b\": \"word-wrap:break-word;\",\n\t\t\t\"wm\": \"writing-mode:${1:lr-tb};\",\n\t\t\t\"wm:lrt\": \"writing-mode:lr-tb;\",\n\t\t\t\"wm:lrb\": \"writing-mode:lr-bt;\",\n\t\t\t\"wm:rlt\": \"writing-mode:rl-tb;\",\n\t\t\t\"wm:rlb\": \"writing-mode:rl-bt;\",\n\t\t\t\"wm:tbr\": \"writing-mode:tb-rl;\",\n\t\t\t\"wm:tbl\": \"writing-mode:tb-lr;\",\n\t\t\t\"wm:btl\": \"writing-mode:bt-lr;\",\n\t\t\t\"wm:btr\": \"writing-mode:bt-rl;\",\n\t\t\t\"lts\": \"letter-spacing:|;\",\n\t\t\t\"lts-n\": \"letter-spacing:normal;\",\n\t\t\t\"f\": \"font:|;\",\n\t\t\t\"f+\": \"font:${1:1em} ${2:Arial,sans-serif};\",\n\t\t\t\"fw\": \"font-weight:|;\",\n\t\t\t\"fw:n\": \"font-weight:normal;\",\n\t\t\t\"fw:b\": \"font-weight:bold;\",\n\t\t\t\"fw:br\": \"font-weight:bolder;\",\n\t\t\t\"fw:lr\": \"font-weight:lighter;\",\n\t\t\t\"fs\": \"font-style:${italic};\",\n\t\t\t\"fs:n\": \"font-style:normal;\",\n\t\t\t\"fs:i\": \"font-style:italic;\",\n\t\t\t\"fs:o\": \"font-style:oblique;\",\n\t\t\t\"fv\": \"font-variant:|;\",\n\t\t\t\"fv:n\": \"font-variant:normal;\",\n\t\t\t\"fv:sc\": \"font-variant:small-caps;\",\n\t\t\t\"fz\": \"font-size:|;\",\n\t\t\t\"fza\": \"font-size-adjust:|;\",\n\t\t\t\"fza:n\": \"font-size-adjust:none;\",\n\t\t\t\"ff\": \"font-family:|;\",\n\t\t\t\"ff:s\": \"font-family:serif;\",\n\t\t\t\"ff:ss\": \"font-family:sans-serif;\",\n\t\t\t\"ff:c\": \"font-family:cursive;\",\n\t\t\t\"ff:f\": \"font-family:fantasy;\",\n\t\t\t\"ff:m\": \"font-family:monospace;\",\n\t\t\t\"ff:a\": \"font-family: Arial, \\\"Helvetica Neue\\\", Helvetica, sans-serif;\",\n\t\t\t\"ff:t\": \"font-family: \\\"Times New Roman\\\", Times, Baskerville, Georgia, serif;\",\n\t\t\t\"ff:v\": \"font-family: Verdana, Geneva, sans-serif;\",\n\t\t\t\"fef\": \"font-effect:|;\",\n\t\t\t\"fef:n\": \"font-effect:none;\",\n\t\t\t\"fef:eg\": \"font-effect:engrave;\",\n\t\t\t\"fef:eb\": \"font-effect:emboss;\",\n\t\t\t\"fef:o\": \"font-effect:outline;\",\n\t\t\t\"fem\": \"font-emphasize:|;\",\n\t\t\t\"femp\": \"font-emphasize-position:|;\",\n\t\t\t\"femp:b\": \"font-emphasize-position:before;\",\n\t\t\t\"femp:a\": \"font-emphasize-position:after;\",\n\t\t\t\"fems\": \"font-emphasize-style:|;\",\n\t\t\t\"fems:n\": \"font-emphasize-style:none;\",\n\t\t\t\"fems:ac\": \"font-emphasize-style:accent;\",\n\t\t\t\"fems:dt\": \"font-emphasize-style:dot;\",\n\t\t\t\"fems:c\": \"font-emphasize-style:circle;\",\n\t\t\t\"fems:ds\": \"font-emphasize-style:disc;\",\n\t\t\t\"fsm\": \"font-smooth:|;\",\n\t\t\t\"fsm:a\": \"font-smooth:auto;\",\n\t\t\t\"fsm:n\": \"font-smooth:never;\",\n\t\t\t\"fsm:aw\": \"font-smooth:always;\",\n\t\t\t\"fst\": \"font-stretch:|;\",\n\t\t\t\"fst:n\": \"font-stretch:normal;\",\n\t\t\t\"fst:uc\": \"font-stretch:ultra-condensed;\",\n\t\t\t\"fst:ec\": \"font-stretch:extra-condensed;\",\n\t\t\t\"fst:c\": \"font-stretch:condensed;\",\n\t\t\t\"fst:sc\": \"font-stretch:semi-condensed;\",\n\t\t\t\"fst:se\": \"font-stretch:semi-expanded;\",\n\t\t\t\"fst:e\": \"font-stretch:expanded;\",\n\t\t\t\"fst:ee\": \"font-stretch:extra-expanded;\",\n\t\t\t\"fst:ue\": \"font-stretch:ultra-expanded;\",\n\t\t\t\"op\": \"opacity:|;\",\n\t\t\t\"op+\": \"opacity: $1;\\nfilter: alpha(opacity=$2);\",\n\t\t\t\"op:ie\": \"filter:progid:DXImageTransform.Microsoft.Alpha(Opacity=100);\",\n\t\t\t\"op:ms\": \"-ms-filter:'progid:DXImageTransform.Microsoft.Alpha(Opacity=100)';\",\n\t\t\t\"rsz\": \"resize:|;\",\n\t\t\t\"rsz:n\": \"resize:none;\",\n\t\t\t\"rsz:b\": \"resize:both;\",\n\t\t\t\"rsz:h\": \"resize:horizontal;\",\n\t\t\t\"rsz:v\": \"resize:vertical;\",\n\t\t\t\"cur\": \"cursor:${pointer};\",\n\t\t\t\"cur:a\": \"cursor:auto;\",\n\t\t\t\"cur:d\": \"cursor:default;\",\n\t\t\t\"cur:c\": \"cursor:crosshair;\",\n\t\t\t\"cur:ha\": \"cursor:hand;\",\n\t\t\t\"cur:he\": \"cursor:help;\",\n\t\t\t\"cur:m\": \"cursor:move;\",\n\t\t\t\"cur:p\": \"cursor:pointer;\",\n\t\t\t\"cur:t\": \"cursor:text;\",\n\t\t\t\"fxd\": \"flex-direction:|;\",\n\t\t\t\"fxd:r\": \"flex-direction:row;\",\n\t\t\t\"fxd:rr\": \"flex-direction:row-reverse;\",\n\t\t\t\"fxd:c\": \"flex-direction:column;\",\n\t\t\t\"fxd:cr\": \"flex-direction:column-reverse;\",\n\t\t\t\"fxw\": \"flex-wrap: |;\",\n\t\t\t\"fxw:n\": \"flex-wrap:nowrap;\",\n\t\t\t\"fxw:w\": \"flex-wrap:wrap;\",\n\t\t\t\"fxw:wr\": \"flex-wrap:wrap-reverse;\",\n\t\t\t\"fxf\": \"flex-flow:|;\",\n\t\t\t\"jc\": \"justify-content:|;\",\n\t\t\t\"jc:fs\": \"justify-content:flex-start;\",\n\t\t\t\"jc:fe\": \"justify-content:flex-end;\",\n\t\t\t\"jc:c\": \"justify-content:center;\",\n\t\t\t\"jc:sb\": \"justify-content:space-between;\",\n\t\t\t\"jc:sa\": \"justify-content:space-around;\",\n\t\t\t\"ai\": \"align-items:|;\",\n\t\t\t\"ai:fs\": \"align-items:flex-start;\",\n\t\t\t\"ai:fe\": \"align-items:flex-end;\",\n\t\t\t\"ai:c\": \"align-items:center;\",\n\t\t\t\"ai:b\": \"align-items:baseline;\",\n\t\t\t\"ai:s\": \"align-items:stretch;\",\n\t\t\t\"ac\": \"align-content:|;\",\n\t\t\t\"ac:fs\": \"align-content:flex-start;\",\n\t\t\t\"ac:fe\": \"align-content:flex-end;\",\n\t\t\t\"ac:c\": \"align-content:center;\",\n\t\t\t\"ac:sb\": \"align-content:space-between;\",\n\t\t\t\"ac:sa\": \"align-content:space-around;\",\n\t\t\t\"ac:s\": \"align-content:stretch;\",\n\t\t\t\"ord\": \"order:|;\",\n\t\t\t\"fxg\": \"flex-grow:|;\",\n\t\t\t\"fxsh\": \"flex-shrink:|;\",\n\t\t\t\"fxb\": \"flex-basis:|;\",\n\t\t\t\"fx\": \"flex:|;\",\n\t\t\t\"as\": \"align-self:|;\",\n\t\t\t\"as:a\": \"align-self:auto;\",\n\t\t\t\"as:fs\": \"align-self:flex-start;\",\n\t\t\t\"as:fe\": \"align-self:flex-end;\",\n\t\t\t\"as:c\": \"align-self:center;\",\n\t\t\t\"as:b\": \"align-self:baseline;\",\n\t\t\t\"as:s\": \"align-self:stretch;\",\n\t\t\t\"pgbb\": \"page-break-before:|;\",\n\t\t\t\"pgbb:au\": \"page-break-before:auto;\",\n\t\t\t\"pgbb:al\": \"page-break-before:always;\",\n\t\t\t\"pgbb:l\": \"page-break-before:left;\",\n\t\t\t\"pgbb:r\": \"page-break-before:right;\",\n\t\t\t\"pgbi\": \"page-break-inside:|;\",\n\t\t\t\"pgbi:au\": \"page-break-inside:auto;\",\n\t\t\t\"pgbi:av\": \"page-break-inside:avoid;\",\n\t\t\t\"pgba\": \"page-break-after:|;\",\n\t\t\t\"pgba:au\": \"page-break-after:auto;\",\n\t\t\t\"pgba:al\": \"page-break-after:always;\",\n\t\t\t\"pgba:l\": \"page-break-after:left;\",\n\t\t\t\"pgba:r\": \"page-break-after:right;\",\n\t\t\t\"orp\": \"orphans:|;\",\n\t\t\t\"us\": \"user-select:${none};\",\n\t\t\t\"wid\": \"widows:|;\",\n\t\t\t\"wfsm\": \"-webkit-font-smoothing:${antialiased};\",\n\t\t\t\"wfsm:a\": \"-webkit-font-smoothing:antialiased;\",\n\t\t\t\"wfsm:s\": \"-webkit-font-smoothing:subpixel-antialiased;\",\n\t\t\t\"wfsm:sa\": \"-webkit-font-smoothing:subpixel-antialiased;\",\n\t\t\t\"wfsm:n\": \"-webkit-font-smoothing:none;\"\n\t\t}\n\t},\n\t\n\t\"html\": {\n\t\t\"filters\": \"html\",\n\t\t\"profile\": \"html\",\n\t\t\"snippets\": {\n\t\t\t\"!!!\":    \"<!DOCTYPE html>\",\n\t\t\t\"!!!4t\":  \"<!DOCTYPE HTML PUBLIC \\\"-//W3C//DTD HTML 4.01 Transitional//EN\\\" \\\"http://www.w3.org/TR/html4/loose.dtd\\\">\",\n\t\t\t\"!!!4s\":  \"<!DOCTYPE HTML PUBLIC \\\"-//W3C//DTD HTML 4.01//EN\\\" \\\"http://www.w3.org/TR/html4/strict.dtd\\\">\",\n\t\t\t\"!!!xt\":  \"<!DOCTYPE html PUBLIC \\\"-//W3C//DTD XHTML 1.0 Transitional//EN\\\" \\\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\\\">\",\n\t\t\t\"!!!xs\":  \"<!DOCTYPE html PUBLIC \\\"-//W3C//DTD XHTML 1.0 Strict//EN\\\" \\\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\\\">\",\n\t\t\t\"!!!xxs\": \"<!DOCTYPE html PUBLIC \\\"-//W3C//DTD XHTML 1.1//EN\\\" \\\"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd\\\">\",\n\n\t\t\t\"c\": \"<!-- |${child} -->\",\n\t\t\t\"cc:ie6\": \"<!--[if lte IE 6]>\\n\\t${child}|\\n<![endif]-->\",\n\t\t\t\"cc:ie\": \"<!--[if IE]>\\n\\t${child}|\\n<![endif]-->\",\n\t\t\t\"cc:noie\": \"<!--[if !IE]><!-->\\n\\t${child}|\\n<!--<![endif]-->\"\n\t\t},\n\t\t\n\t\t\"abbreviations\": {\n\t\t\t\"!\": \"html:5\",\n\t\t\t\"a\": \"<a href=\\\"\\\">\",\n\t\t\t\"a:link\": \"<a href=\\\"http://|\\\">\",\n\t\t\t\"a:mail\": \"<a href=\\\"mailto:|\\\">\",\n\t\t\t\"abbr\": \"<abbr title=\\\"\\\">\",\n\t\t\t\"acr|acronym\": \"<acronym title=\\\"\\\">\",\n\t\t\t\"base\": \"<base href=\\\"\\\" />\",\n\t\t\t\"basefont\": \"<basefont/>\",\n\t\t\t\"br\": \"<br/>\",\n\t\t\t\"frame\": \"<frame/>\",\n\t\t\t\"hr\": \"<hr/>\",\n\t\t\t\"bdo\": \"<bdo dir=\\\"\\\">\",\n\t\t\t\"bdo:r\": \"<bdo dir=\\\"rtl\\\">\",\n\t\t\t\"bdo:l\": \"<bdo dir=\\\"ltr\\\">\",\n\t\t\t\"col\": \"<col/>\",\n\t\t\t\"link\": \"<link rel=\\\"stylesheet\\\" href=\\\"\\\" />\",\n\t\t\t\"link:css\": \"<link rel=\\\"stylesheet\\\" href=\\\"${1:style}.css\\\" />\",\n\t\t\t\"link:print\": \"<link rel=\\\"stylesheet\\\" href=\\\"${1:print}.css\\\" media=\\\"print\\\" />\",\n\t\t\t\"link:favicon\": \"<link rel=\\\"shortcut icon\\\" type=\\\"image/x-icon\\\" href=\\\"${1:favicon.ico}\\\" />\",\n\t\t\t\"link:touch\": \"<link rel=\\\"apple-touch-icon\\\" href=\\\"${1:favicon.png}\\\" />\",\n\t\t\t\"link:rss\": \"<link rel=\\\"alternate\\\" type=\\\"application/rss+xml\\\" title=\\\"RSS\\\" href=\\\"${1:rss.xml}\\\" />\",\n\t\t\t\"link:atom\": \"<link rel=\\\"alternate\\\" type=\\\"application/atom+xml\\\" title=\\\"Atom\\\" href=\\\"${1:atom.xml}\\\" />\",\n\t\t\t\"link:im|link:import\": \"<link rel=\\\"import\\\" href=\\\"${1:component}.html\\\" />\",\n\t\t\t\"meta\": \"<meta/>\",\n\t\t\t\"meta:utf\": \"<meta http-equiv=\\\"Content-Type\\\" content=\\\"text/html;charset=UTF-8\\\" />\",\n\t\t\t\"meta:win\": \"<meta http-equiv=\\\"Content-Type\\\" content=\\\"text/html;charset=windows-1251\\\" />\",\n\t\t\t\"meta:edge\": \"<meta http-equiv=\\\"X-UA-Compatible\\\" content=\\\"${1:ie=edge}\\\" />\",\n\t\t\t\"meta:vp\": \"<meta name=\\\"viewport\\\" content=\\\"width=${1:device-width}, initial-scale=${3:1.0}\\\" />\",\n\t\t\t\"meta:compat\": \"<meta http-equiv=\\\"X-UA-Compatible\\\" content=\\\"${1:IE=7}\\\" />\",\n\t\t\t\"meta:redirect\": \"<meta http-equiv=\\\"refresh\\\" content=\\\"0; url=${1:http://example.com}\\\" />\",\n\t\t\t\"style\": \"<style>\",\n\t\t\t\"script\": \"<script !src=\\\"\\\">\",\n\t\t\t\"script:src\": \"<script src=\\\"\\\">\",\n\t\t\t\"img\": \"<img src=\\\"\\\" alt=\\\"\\\" />\",\n\t\t\t\"img:s|img:srcset\": \"<img srcset=\\\"\\\" src=\\\"\\\" alt=\\\"\\\" />\",\n\t\t\t\"img:z|img:sizes\": \"<img sizes=\\\"\\\" srcset=\\\"\\\" src=\\\"\\\" alt=\\\"\\\" />\",\n\t\t\t\"picture\": \"<picture>\",\n\t\t\t\"src|source\": \"<source/>\",\n\t\t\t\"src:sc|source:src\": \"<source src=\\\"\\\" type=\\\"\\\"/>\",\n\t\t\t\"src:s|source:srcset\": \"<source srcset=\\\"\\\"/>\",\n\t\t\t\"src:m|source:media\": \"<source media=\\\"(${1:min-width: })\\\" srcset=\\\"\\\"/>\",\n\t\t\t\"src:t|source:type\": \"<source srcset=\\\"|\\\" type=\\\"${1:image/}\\\"/>\",\n\t\t\t\"src:z|source:sizes\": \"<source sizes=\\\"\\\" srcset=\\\"\\\"/>\",\n\t\t\t\"src:mt|source:media:type\": \"<source media=\\\"(${1:min-width: })\\\" srcset=\\\"\\\" type=\\\"${2:image/}\\\"/>\",\n\t\t\t\"src:mz|source:media:sizes\": \"<source media=\\\"(${1:min-width: })\\\" sizes=\\\"\\\" srcset=\\\"\\\"/>\",\n\t\t\t\"src:zt|source:sizes:type\": \"<source sizes=\\\"\\\" srcset=\\\"\\\" type=\\\"${1:image/}\\\"/>\",\n\t\t\t\"iframe\": \"<iframe src=\\\"\\\" frameborder=\\\"0\\\">\",\n\t\t\t\"embed\": \"<embed src=\\\"\\\" type=\\\"\\\" />\",\n\t\t\t\"object\": \"<object data=\\\"\\\" type=\\\"\\\">\",\n\t\t\t\"param\": \"<param name=\\\"\\\" value=\\\"\\\" />\",\n\t\t\t\"map\": \"<map name=\\\"\\\">\",\n\t\t\t\"area\": \"<area shape=\\\"\\\" coords=\\\"\\\" href=\\\"\\\" alt=\\\"\\\" />\",\n\t\t\t\"area:d\": \"<area shape=\\\"default\\\" href=\\\"\\\" alt=\\\"\\\" />\",\n\t\t\t\"area:c\": \"<area shape=\\\"circle\\\" coords=\\\"\\\" href=\\\"\\\" alt=\\\"\\\" />\",\n\t\t\t\"area:r\": \"<area shape=\\\"rect\\\" coords=\\\"\\\" href=\\\"\\\" alt=\\\"\\\" />\",\n\t\t\t\"area:p\": \"<area shape=\\\"poly\\\" coords=\\\"\\\" href=\\\"\\\" alt=\\\"\\\" />\",\n\t\t\t\"form\": \"<form action=\\\"\\\">\",\n\t\t\t\"form:get\": \"<form action=\\\"\\\" method=\\\"get\\\">\",\n\t\t\t\"form:post\": \"<form action=\\\"\\\" method=\\\"post\\\">\",\n\t\t\t\"label\": \"<label for=\\\"\\\">\",\n\t\t\t\"input\": \"<input type=\\\"${1:text}\\\" />\",\n\t\t\t\"inp\": \"<input type=\\\"${1:text}\\\" name=\\\"\\\" id=\\\"\\\" />\",\n\t\t\t\"input:h|input:hidden\": \"input[type=hidden name]\",\n\t\t\t\"input:t|input:text\": \"inp\",\n\t\t\t\"input:search\": \"inp[type=search]\",\n\t\t\t\"input:email\": \"inp[type=email]\",\n\t\t\t\"input:url\": \"inp[type=url]\",\n\t\t\t\"input:p|input:password\": \"inp[type=password]\",\n\t\t\t\"input:datetime\": \"inp[type=datetime]\",\n\t\t\t\"input:date\": \"inp[type=date]\",\n\t\t\t\"input:datetime-local\": \"inp[type=datetime-local]\",\n\t\t\t\"input:month\": \"inp[type=month]\",\n\t\t\t\"input:week\": \"inp[type=week]\",\n\t\t\t\"input:time\": \"inp[type=time]\",\n\t\t\t\"input:tel\": \"inp[type=tel]\",\n\t\t\t\"input:number\": \"inp[type=number]\",\n\t\t\t\"input:color\": \"inp[type=color]\",\n\t\t\t\"input:c|input:checkbox\": \"inp[type=checkbox]\",\n\t\t\t\"input:r|input:radio\": \"inp[type=radio]\",\n\t\t\t\"input:range\": \"inp[type=range]\",\n\t\t\t\"input:f|input:file\": \"inp[type=file]\",\n\t\t\t\"input:s|input:submit\": \"<input type=\\\"submit\\\" value=\\\"\\\" />\",\n\t\t\t\"input:i|input:image\": \"<input type=\\\"image\\\" src=\\\"\\\" alt=\\\"\\\" />\",\n\t\t\t\"input:b|input:button\": \"<input type=\\\"button\\\" value=\\\"\\\" />\",\n\t\t\t\"isindex\": \"<isindex/>\",\n\t\t\t\"input:reset\": \"input:button[type=reset]\",\n\t\t\t\"select\": \"<select name=\\\"\\\" id=\\\"\\\">\",\n\t\t\t\"select:d|select:disabled\": \"select[disabled.]\",\n\t\t\t\"opt|option\": \"<option value=\\\"\\\">\",\n\t\t\t\"textarea\": \"<textarea name=\\\"\\\" id=\\\"\\\" cols=\\\"${1:30}\\\" rows=\\\"${2:10}\\\">\",\n\t\t\t\"marquee\": \"<marquee behavior=\\\"\\\" direction=\\\"\\\">\",\n\t\t\t\"menu:c|menu:context\": \"menu[type=context]>\",\n\t\t\t\"menu:t|menu:toolbar\": \"menu[type=toolbar]>\",\n\t\t\t\"video\": \"<video src=\\\"\\\">\",\n\t\t\t\"audio\": \"<audio src=\\\"\\\">\",\n\t\t\t\"html:xml\": \"<html xmlns=\\\"http://www.w3.org/1999/xhtml\\\">\",\n\t\t\t\"keygen\": \"<keygen/>\",\n\t\t\t\"command\": \"<command/>\",\n\t\t\t\"btn:s|button:s|button:submit\" : \"button[type=submit]\",\n\t\t\t\"btn:r|button:r|button:reset\" : \"button[type=reset]\",\n\t\t\t\"btn:d|button:d|button:disabled\" : \"button[disabled.]\",\n\t\t\t\"fst:d|fset:d|fieldset:d|fieldset:disabled\" : \"fieldset[disabled.]\",\n\t\t\t\n\t\t\t\"bq\": \"blockquote\",\n\t\t\t\"fig\": \"figure\",\n\t\t\t\"figc\": \"figcaption\",\n\t\t\t\"pic\": \"picture\",\n\t\t\t\"ifr\": \"iframe\",\n\t\t\t\"emb\": \"embed\",\n\t\t\t\"obj\": \"object\",\n\t\t\t\"cap\": \"caption\",\n\t\t\t\"colg\": \"colgroup\",\n\t\t\t\"fst\": \"fieldset\",\n\t\t\t\"btn\": \"button\",\n\t\t\t\"optg\": \"optgroup\",\n\t\t\t\"tarea\": \"textarea\",\n\t\t\t\"leg\": \"legend\",\n\t\t\t\"sect\": \"section\",\n\t\t\t\"art\": \"article\",\n\t\t\t\"hdr\": \"header\",\n\t\t\t\"ftr\": \"footer\",\n\t\t\t\"adr\": \"address\",\n\t\t\t\"dlg\": \"dialog\",\n\t\t\t\"str\": \"strong\",\n\t\t\t\"prog\": \"progress\",\n\t\t\t\"mn\": \"main\",\n\t\t\t\"tem\": \"template\",\n\t\t\t\"fset\": \"fieldset\",\n\t\t\t\"datag\": \"datagrid\",\n\t\t\t\"datal\": \"datalist\",\n\t\t\t\"kg\": \"keygen\",\n\t\t\t\"out\": \"output\",\n\t\t\t\"det\": \"details\",\n\t\t\t\"cmd\": \"command\",\n\n\t\t\t\"doc\": \"html>(head>meta[charset=${charset}]+meta:vp+meta:edge+title{${1:Document}})+body\",\n\t\t\t\"doc4\": \"html>(head>meta[http-equiv=\\\"Content-Type\\\" content=\\\"text/html;charset=${charset}\\\"]+title{${1:Document}})+body\",\n\n\t\t\t\"ri:d|ri:dpr\": \"img:s\",\n\t\t\t\"ri:v|ri:viewport\": \"img:z\",\n\t\t\t\"ri:a|ri:art\": \"pic>src:m+img\",\n\t\t\t\"ri:t|ri:type\": \"pic>src:t+img\",\n\n\t\t\t\"html:4t\":  \"!!!4t+doc4[lang=${lang}]\",\n\t\t\t\"html:4s\":  \"!!!4s+doc4[lang=${lang}]\",\n\t\t\t\"html:xt\":  \"!!!xt+doc4[xmlns=http://www.w3.org/1999/xhtml xml:lang=${lang}]\",\n\t\t\t\"html:xs\":  \"!!!xs+doc4[xmlns=http://www.w3.org/1999/xhtml xml:lang=${lang}]\",\n\t\t\t\"html:xxs\": \"!!!xxs+doc4[xmlns=http://www.w3.org/1999/xhtml xml:lang=${lang}]\",\n\t\t\t\"html:5\":   \"!!!+doc[lang=${lang}]\",\n\t\t\t\n\t\t\t\"ol+\": \"ol>li\",\n\t\t\t\"ul+\": \"ul>li\",\n\t\t\t\"dl+\": \"dl>dt+dd\",\n\t\t\t\"map+\": \"map>area\",\n\t\t\t\"table+\": \"table>tr>td\",\n\t\t\t\"colgroup+\": \"colgroup>col\",\n\t\t\t\"colg+\": \"colgroup>col\",\n\t\t\t\"tr+\": \"tr>td\",\n\t\t\t\"select+\": \"select>option\",\n\t\t\t\"optgroup+\": \"optgroup>option\",\n\t\t\t\"optg+\": \"optgroup>option\",\n\t\t\t\"pic+\": \"picture>source:srcset+img\"\n\t\t}\n\t},\n\t\n\t\"xml\": {\n\t\t\"extends\": \"html\",\n\t\t\"profile\": \"xml\",\n\t\t\"filters\": \"html\"\n\t},\n\t\n\t\"svg\": {\n\t\t\"filters\": \"html\",\n\t\t\"profile\": \"xml\",\n\t\t\"snippets\": {\n\t\t\t\"!!!\": \"<?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\" standalone=\\\"no\\\"?>\",\n\t\t\t\"svgdoc\": \"<!DOCTYPE svg PUBLIC \\\"-//W3C//DTD SVG 1.1//EN\\\" \\\"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\\\">\"\n\t\t},\n\t\t\"abbreviations\": {\n\t\t\t\"!svg\": \"!!!+svgdoc+svg\",\n\t\t\t\"svg\": \"<svg version=\\\"1.1\\\" xmlns=\\\"http://www.w3.org/2000/svg\\\">\",\n\t\t\t\"a\": \"<a xlink:href=\\\"\\\">\",\n\t\t\t\"ag\": \"altGliph\",\n\t\t\t\"agd\": \"altGliphDef\",\n\t\t\t\"agi\": \"altGliphItem\",\n\t\t\t\"anim|animate\": \"<animate attributeType=\\\"\\\" attributeName=\\\"\\\" from=\\\"\\\" to=\\\"\\\" dur=\\\"\\\" repeatCount=\\\"indefinite\\\">\",\n\t\t\t\"ac\": \"<animateColor>\",\n\t\t\t\"am\": \"<animateMotion>\",\n\t\t\t\"at\": \"<animateTransform>\",\n\t\t\t\"c\": \"circle\",\n\t\t\t\"cp\": \"colorPath\",\n\t\t\t\"c-p\": \"color-profile\",\n\t\t\t\"cur\": \"cursor\",\n\t\t\t\"df\": \"defs\",\n\t\t\t\"e|ellipse\": \"<ellipse  cx=\\\"\\\" cy=\\\"\\\" rx=\\\"\\\" ry=\\\"\\\"/>\",\n\t\t\t\"ff\": \"<font-face>\",\n\t\t\t\"fff\": \"<font-face-format>\",\n\t\t\t\"ffn\": \"<font-face-name>\",\n\t\t\t\"ffs\": \"<font-face-src>\",\n\t\t\t\"ffu\": \"<font-face-uri>\",\n\t\t\t\"fo\": \"<foreignObject>\",\n\t\t\t\"g\": \"<g>\",\n\t\t\t\"gl\": \"<glyph>\",\n\t\t\t\"glr\": \"<glyphRef>\",\n\t\t\t\"hk\": \"<hkern>\",\n\t\t\t\"i|image\": \"<image xlink:href=\\\"\\\" x=\\\"\\\" y=\\\"\\\" width=\\\"\\\" height=\\\"\\\"/>\",\n\t\t\t\"l\": \"<line>\",\n\t\t\t\"lg\": \"<linearGradient>\",\n\t\t\t\"marker\": \"<marker>\",\n\t\t\t\"mask\": \"<mask>\",\n\t\t\t\"md\": \"<metadata>\",\n\t\t\t\"mg\": \"<missing-glyph>\",\n\t\t\t\"mp\": \"<mpath>\",\n\t\t\t\"path\": \"<path d=\\\"\\\">\",\n\t\t\t\"patt\": \"<pattern>\",\n\t\t\t\"pg\": \"<polygon points=\\\"\\\">\",\n\t\t\t\"pl\": \"<polyline points=\\\"\\\">\",\n\t\t\t\"rg\": \"<radialGradient>\",\n\t\t\t\"r\": \"<rect x=\\\"\\\" y=\\\"\\\" width=\\\"\\\" height=\\\"\\\"/>\",\n\t\t\t\"scr\": \"<script>\",\n\t\t\t\"sb\": \"<symbol>\",\n\t\t\t\"txt\": \"<text>\",\n\t\t\t\"tp\": \"<textPath>\",\n\t\t\t\"ts\": \"<tspan>\",\n\t\t\t\"u|use\": \"<use xlink:href=\\\"\\\"/>\",\n\t\t\t\"v\": \"<view>\",\n\t\t\t\"vk\": \"<vkern>\"\n\t\t}\n\t},\n\t\n\t\"xsl\": {\n\t\t\"extends\": \"html\",\n\t\t\"profile\": \"xml\",\n\t\t\"filters\": \"html, xsl\",\n\t\t\"abbreviations\": {\n\t\t\t\"tm|tmatch\": \"<xsl:template match=\\\"\\\" mode=\\\"\\\">\",\n\t\t\t\"tn|tname\": \"<xsl:template name=\\\"\\\">\",\n\t\t\t\"call\": \"<xsl:call-template name=\\\"\\\"/>\",\n\t\t\t\"ap\": \"<xsl:apply-templates select=\\\"\\\" mode=\\\"\\\"/>\",\n\t\t\t\"api\": \"<xsl:apply-imports/>\",\n\t\t\t\"imp\": \"<xsl:import href=\\\"\\\"/>\",\n\t\t\t\"inc\": \"<xsl:include href=\\\"\\\"/>\",\n\n\t\t\t\"ch\": \"<xsl:choose>\",\n\t\t\t\"wh|xsl:when\": \"<xsl:when test=\\\"\\\">\",\n\t\t\t\"ot\": \"<xsl:otherwise>\",\n\t\t\t\"if\": \"<xsl:if test=\\\"\\\">\",\n\n\t\t\t\"par\": \"<xsl:param name=\\\"\\\">\",\n\t\t\t\"pare\": \"<xsl:param name=\\\"\\\" select=\\\"\\\"/>\",\n\t\t\t\"var\": \"<xsl:variable name=\\\"\\\">\",\n\t\t\t\"vare\": \"<xsl:variable name=\\\"\\\" select=\\\"\\\"/>\",\n\t\t\t\"wp\": \"<xsl:with-param name=\\\"\\\" select=\\\"\\\"/>\",\n\t\t\t\"key\": \"<xsl:key name=\\\"\\\" match=\\\"\\\" use=\\\"\\\"/>\",\n\n\t\t\t\"elem\": \"<xsl:element name=\\\"\\\">\",\n\t\t\t\"attr\": \"<xsl:attribute name=\\\"\\\">\",\n\t\t\t\"attrs\": \"<xsl:attribute-set name=\\\"\\\">\",\n\n\t\t\t\"cp\": \"<xsl:copy select=\\\"\\\"/>\",\n\t\t\t\"co\": \"<xsl:copy-of select=\\\"\\\"/>\",\n\t\t\t\"val\": \"<xsl:value-of select=\\\"\\\"/>\",\n\t\t\t\"for|each\": \"<xsl:for-each select=\\\"\\\">\",\n\t\t\t\"tex\": \"<xsl:text></xsl:text>\",\n\n\t\t\t\"com\": \"<xsl:comment>\",\n\t\t\t\"msg\": \"<xsl:message terminate=\\\"no\\\">\",\n\t\t\t\"fall\": \"<xsl:fallback>\",\n\t\t\t\"num\": \"<xsl:number value=\\\"\\\"/>\",\n\t\t\t\"nam\": \"<namespace-alias stylesheet-prefix=\\\"\\\" result-prefix=\\\"\\\"/>\",\n\t\t\t\"pres\": \"<xsl:preserve-space elements=\\\"\\\"/>\",\n\t\t\t\"strip\": \"<xsl:strip-space elements=\\\"\\\"/>\",\n\t\t\t\"proc\": \"<xsl:processing-instruction name=\\\"\\\">\",\n\t\t\t\"sort\": \"<xsl:sort select=\\\"\\\" order=\\\"\\\"/>\",\n\n\t\t\t\"choose+\": \"xsl:choose>xsl:when+xsl:otherwise\",\n\t\t\t\"xsl\": \"!!!+xsl:stylesheet[version=1.0 xmlns:xsl=http://www.w3.org/1999/XSL/Transform]>{\\n|}\"\n\t\t}, \n\t\t\"snippets\": {\n\t\t\t\"!!!\": \"<?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\"?>\"\n\t\t}\n\t},\n\t\n\t\"haml\": {\n\t\t\"filters\": \"haml\",\n\t\t\"extends\": \"html\",\n\t\t\"profile\": \"xml\"\n\t},\n\n\t\"jade\": {\n\t\t\"filters\": \"jade\",\n\t\t\"extends\": \"html\",\n\t\t\"profile\": \"xml\"\n\t},\n\n\t\"jsx\": {\n\t\t\"filters\": \"jsx, html\",\n\t\t\"extends\": \"html\",\n\t\t\"profile\": \"xml\"\n\t},\n\n\t\"slim\": {\n\t\t\"filters\": \"slim\",\n\t\t\"extends\": \"html\",\n\t\t\"profile\": \"xml\"\n\t},\n\t\n\t\"scss\": {\n\t\t\"extends\": \"css\"\n\t},\n\t\n\t\"sass\": {\n\t\t\"extends\": \"css\"\n\t},\n\t\n\t\"less\": {\n\t\t\"extends\": \"css\"\n\t},\n\t\n\t\"stylus\": {\n\t\t\"extends\": \"css\"\n\t},\n\n\t\"styl\": {\n\t\t\"extends\": \"stylus\"\n\t}\n}\n\n},{}],\"utils\\\\abbreviation.js\":[function(require,module,exports){\n/**\n * Utility functions to work with <code>AbbreviationNode</code> as HTML element\n * @param {Function} require\n * @param {Underscore} _\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar elements = require('../assets/elements');\n\tvar tabStops = require('../assets/tabStops');\n\tvar utils = require('../utils/common');\n\tvar tagName = require('../resolver/tagName');\n\n\treturn {\n\t\t/**\n\t\t * Test if passed node is unary (no closing tag)\n\t\t * @param {AbbreviationNode} node\n\t\t * @return {Boolean}\n\t\t */\n\t\tisUnary: function(node) {\n\t\t\tif (node.children.length || node._text || this.isSnippet(node)) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t\t\n\t\t\tvar r = node.data('resource');\n\t\t\treturn r && r.is_empty;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Test if passed node is inline-level (like &lt;strong&gt;, &lt;img&gt;)\n\t\t * @param {AbbreviationNode} node\n\t\t * @return {Boolean}\n\t\t */\n\t\tisInline: function(node) {\n\t\t\treturn node.isTextNode() \n\t\t\t\t|| !node.name() \n\t\t\t\t|| tagName.isInlineLevel(node.name());\n\t\t},\n\t\t\n\t\t/**\n\t\t * Test if passed node is block-level\n\t\t * @param {AbbreviationNode} node\n\t\t * @return {Boolean}\n\t\t */\n\t\tisBlock: function(node) {\n\t\t\treturn this.isSnippet(node) || !this.isInline(node);\n\t\t},\n\t\t\n\t\t/**\n\t\t * Test if given node is a snippet\n\t\t * @param {AbbreviationNode} node\n\t\t * @return {Boolean}\n\t\t */\n\t\tisSnippet: function(node) {\n\t\t\treturn elements.is(node.data('resource'), 'snippet');\n\t\t},\n\t\t\n\t\t/**\n\t\t * This function tests if passed node content contains HTML tags. \n\t\t * This function is mostly used for output formatting\n\t\t * @param {AbbreviationNode} node\n\t\t * @returns {Boolean}\n\t\t */\n\t\thasTagsInContent: function(node) {\n\t\t\treturn utils.matchesTag(node.content);\n\t\t},\n\t\t\n\t\t/**\n\t\t * Test if current element contains block-level children\n\t\t * @param {AbbreviationNode} node\n\t\t * @return {Boolean}\n\t\t */\n\t\thasBlockChildren: function(node) {\n\t\t\treturn (this.hasTagsInContent(node) && this.isBlock(node)) \n\t\t\t\t|| node.children.some(function(child) {\n\t\t\t\t\treturn this.isBlock(child);\n\t\t\t\t}, this);\n\t\t},\n\t\t\n\t\t/**\n\t\t * Utility function that inserts content instead of <code>${child}</code>\n\t\t * variables on <code>text</code>\n\t\t * @param {String} text Text where child content should be inserted\n\t\t * @param {String} childContent Content to insert\n\t\t * @param {Object} options\n\t\t * @returns {String\n\t\t */\n\t\tinsertChildContent: function(text, childContent, options) {\n\t\t\toptions = utils.extend({\n\t\t\t\tkeepVariable: true,\n\t\t\t\tappendIfNoChild: true\n\t\t\t}, options || {});\n\t\t\t\n\t\t\tvar childVariableReplaced = false;\n\t\t\ttext = tabStops.replaceVariables(text, function(variable, name, data) {\n\t\t\t\tvar output = variable;\n\t\t\t\tif (name == 'child') {\n\t\t\t\t\t// add correct indentation\n\t\t\t\t\toutput = utils.padString(childContent, utils.getLinePaddingFromPosition(text, data.start));\n\t\t\t\t\tchildVariableReplaced = true;\n\t\t\t\t\tif (options.keepVariable)\n\t\t\t\t\t\toutput += variable;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\treturn output;\n\t\t\t});\n\t\t\t\n\t\t\tif (!childVariableReplaced && options.appendIfNoChild) {\n\t\t\t\ttext += childContent;\n\t\t\t}\n\t\t\t\n\t\t\treturn text;\n\t\t}\n\t};\n});\n},{\"../assets/elements\":\"assets\\\\elements.js\",\"../assets/tabStops\":\"assets\\\\tabStops.js\",\"../resolver/tagName\":\"resolver\\\\tagName.js\",\"../utils/common\":\"utils\\\\common.js\"}],\"utils\\\\action.js\":[function(require,module,exports){\n/**\n * Utility methods for Emmet actions\n * @author Sergey Chikuyonok (serge.che@gmail.com) <http://chikuyonok.ru>\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar utils = require('./common');\n\tvar cssSections = require('./cssSections');\n\tvar abbreviationParser = require('../parser/abbreviation');\n\tvar htmlMatcher = require('../assets/htmlMatcher');\n\tvar xmlEditTree = require('../editTree/xml');\n\tvar range = require('../assets/range');\n\tvar resources = require('../assets/resources');\n\n\treturn {\n\t\tmimeTypes: {\n\t\t\t'gif' : 'image/gif',\n\t\t\t'png' : 'image/png',\n\t\t\t'jpg' : 'image/jpeg',\n\t\t\t'jpeg': 'image/jpeg',\n\t\t\t'svg' : 'image/svg+xml',\n\t\t\t'html': 'text/html',\n\t\t\t'htm' : 'text/html'\n\t\t},\n\t\t\n\t\t/**\n\t\t * Extracts abbreviations from text stream, starting from the end\n\t\t * @param {String} str\n\t\t * @return {String} Abbreviation or empty string\n\t\t * @memberOf emmet.actionUtils\n\t\t */\n\t\textractAbbreviation: function(str) {\n\t\t\tvar curOffset = str.length;\n\t\t\tvar startIndex = -1;\n\t\t\tvar groupCount = 0;\n\t\t\tvar braceCount = 0;\n\t\t\tvar textCount = 0;\n\t\t\t\n\t\t\twhile (true) {\n\t\t\t\tcurOffset--;\n\t\t\t\tif (curOffset < 0) {\n\t\t\t\t\t// moved to the beginning of the line\n\t\t\t\t\tstartIndex = 0;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tvar ch = str.charAt(curOffset);\n\t\t\t\t\n\t\t\t\tif (ch == ']') {\n\t\t\t\t\tbraceCount++;\n\t\t\t\t} else if (ch == '[') {\n\t\t\t\t\tif (!braceCount) { // unexpected brace\n\t\t\t\t\t\tstartIndex = curOffset + 1;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t\tbraceCount--;\n\t\t\t\t} else if (ch == '}') {\n\t\t\t\t\ttextCount++;\n\t\t\t\t} else if (ch == '{') {\n\t\t\t\t\tif (!textCount) { // unexpected brace\n\t\t\t\t\t\tstartIndex = curOffset + 1;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t\ttextCount--;\n\t\t\t\t} else if (ch == ')') {\n\t\t\t\t\tgroupCount++;\n\t\t\t\t} else if (ch == '(') {\n\t\t\t\t\tif (!groupCount) { // unexpected brace\n\t\t\t\t\t\tstartIndex = curOffset + 1;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t\tgroupCount--;\n\t\t\t\t} else {\n\t\t\t\t\tif (braceCount || textCount) \n\t\t\t\t\t\t// respect all characters inside attribute sets or text nodes\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\telse if (!abbreviationParser.isAllowedChar(ch) || (ch == '>' && utils.endsWithTag(str.substring(0, curOffset + 1)))) {\n\t\t\t\t\t\t// found stop symbol\n\t\t\t\t\t\tstartIndex = curOffset + 1;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\tif (startIndex != -1 && !textCount && !braceCount && !groupCount) \n\t\t\t\t// found something, remove some invalid symbols from the \n\t\t\t\t// beginning and return abbreviation\n\t\t\t\treturn str.substring(startIndex).replace(/^[\\*\\+\\>\\^]+/, '');\n\t\t\telse\n\t\t\t\treturn '';\n\t\t},\n\t\t\n\t\t/**\n\t\t * Gets image size from image byte stream.\n\t\t * @author http://romeda.org/rePublish/\n\t\t * @param {String} stream Image byte stream (use <code>IEmmetFile.read()</code>)\n\t\t * @return {Object} Object with <code>width</code> and <code>height</code> properties\n\t\t */\n\t\tgetImageSize: function(stream) {\n\t\t\tvar pngMagicNum = \"\\211PNG\\r\\n\\032\\n\",\n\t\t\t\tjpgMagicNum = \"\\377\\330\",\n\t\t\t\tgifMagicNum = \"GIF8\",\n\t\t\t\tpos = 0,\n\t\t\t\tnextByte = function() {\n\t\t\t\t\treturn stream.charCodeAt(pos++);\n\t\t\t\t};\n\t\t\n\t\t\tif (stream.substr(0, 8) === pngMagicNum) {\n\t\t\t\t// PNG. Easy peasy.\n\t\t\t\tpos = stream.indexOf('IHDR') + 4;\n\t\t\t\n\t\t\t\treturn {\n\t\t\t\t\twidth:  (nextByte() << 24) | (nextByte() << 16) | (nextByte() <<  8) | nextByte(),\n\t\t\t\t\theight: (nextByte() << 24) | (nextByte() << 16) | (nextByte() <<  8) | nextByte()\n\t\t\t\t};\n\t\t\t\n\t\t\t} else if (stream.substr(0, 4) === gifMagicNum) {\n\t\t\t\tpos = 6;\n\t\t\t\n\t\t\t\treturn {\n\t\t\t\t\twidth:  nextByte() | (nextByte() << 8),\n\t\t\t\t\theight: nextByte() | (nextByte() << 8)\n\t\t\t\t};\n\t\t\t\n\t\t\t} else if (stream.substr(0, 2) === jpgMagicNum) {\n\t\t\t\tpos = 2;\n\t\t\t\n\t\t\t\tvar l = stream.length;\n\t\t\t\twhile (pos < l) {\n\t\t\t\t\tif (nextByte() != 0xFF) return;\n\t\t\t\t\n\t\t\t\t\tvar marker = nextByte();\n\t\t\t\t\tif (marker == 0xDA) break;\n\t\t\t\t\n\t\t\t\t\tvar size = (nextByte() << 8) | nextByte();\n\t\t\t\t\n\t\t\t\t\tif (marker >= 0xC0 && marker <= 0xCF && !(marker & 0x4) && !(marker & 0x8)) {\n\t\t\t\t\t\tpos += 1;\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\theight: (nextByte() << 8) | nextByte(),\n\t\t\t\t\t\t\twidth: (nextByte() << 8) | nextByte()\n\t\t\t\t\t\t};\n\t\t\t\t\n\t\t\t\t\t} else {\n\t\t\t\t\t\tpos += size - 2;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\t\n\t\t/**\n\t\t * Captures context XHTML element from editor under current caret position.\n\t\t * This node can be used as a helper for abbreviation extraction\n\t\t * @param {IEmmetEditor} editor\n\t\t * @returns {Object}\n\t\t */\n\t\tcaptureContext: function(editor, pos) {\n\t\t\tvar allowedSyntaxes = {'html': 1, 'xml': 1, 'xsl': 1, 'jsx': 1};\n\t\t\tvar syntax = editor.getSyntax();\n\t\t\tif (syntax in allowedSyntaxes) {\n\t\t\t\tvar content = editor.getContent();\n\t\t\t\tif (typeof pos === 'undefined') {\n\t\t\t\t\tpos = editor.getCaretPos();\n\t\t\t\t}\n\n\t\t\t\tvar tag = htmlMatcher.find(content, pos);\n\t\t\t\tif (tag && tag.type == 'tag') {\n\t\t\t\t\tvar startTag = tag.open;\n\t\t\t\t\tvar contextNode = {\n\t\t\t\t\t\tname: startTag.name,\n\t\t\t\t\t\tattributes: [],\n\t\t\t\t\t\tmatch: tag\n\t\t\t\t\t};\n\t\t\t\t\t\n\t\t\t\t\t// parse attributes\n\t\t\t\t\tvar tagTree = xmlEditTree.parse(startTag.range.substring(content));\n\t\t\t\t\tif (tagTree) {\n\t\t\t\t\t\tcontextNode.attributes = tagTree.getAll().map(function(item) {\n\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\tname: item.name(),\n\t\t\t\t\t\t\t\tvalue: item.value()\n\t\t\t\t\t\t\t};\n\t\t\t\t\t\t});\n\t\t\t\t\t}\n\t\t\t\t\t\n\t\t\t\t\treturn contextNode;\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\treturn null;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Find expression bounds in current editor at caret position. \n\t\t * On each character a <code>fn</code> function will be called and must \n\t\t * return <code>true</code> if current character meets requirements, \n\t\t * <code>false</code> otherwise\n\t\t * @param {IEmmetEditor} editor\n\t\t * @param {Function} fn Function to test each character of expression\n\t\t * @return {Range}\n\t\t */\n\t\tfindExpressionBounds: function(editor, fn) {\n\t\t\tvar content = String(editor.getContent());\n\t\t\tvar il = content.length;\n\t\t\tvar exprStart = editor.getCaretPos() - 1;\n\t\t\tvar exprEnd = exprStart + 1;\n\t\t\t\t\n\t\t\t// start by searching left\n\t\t\twhile (exprStart >= 0 && fn(content.charAt(exprStart), exprStart, content)) exprStart--;\n\t\t\t\n\t\t\t// then search right\n\t\t\twhile (exprEnd < il && fn(content.charAt(exprEnd), exprEnd, content)) exprEnd++;\n\t\t\t\n\t\t\tif (exprEnd > exprStart) {\n\t\t\t\treturn range([++exprStart, exprEnd]);\n\t\t\t}\n\t\t},\n\t\t\n\t\t/**\n\t\t * @param {IEmmetEditor} editor\n\t\t * @param {Object} data\n\t\t * @returns {Boolean}\n\t\t */\n\t\tcompoundUpdate: function(editor, data) {\n\t\t\tif (data) {\n\t\t\t\tvar sel = editor.getSelectionRange();\n\t\t\t\teditor.replaceContent(data.data, data.start, data.end, true);\n\t\t\t\teditor.createSelection(data.caret, data.caret + sel.end - sel.start);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\t\n\t\t\treturn false;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Common syntax detection method for editors that doesn’t provide any\n\t\t * info about current syntax scope. \n\t\t * @param {IEmmetEditor} editor Current editor\n\t\t * @param {String} hint Any syntax hint that editor can provide \n\t\t * for syntax detection. Default is 'html'\n\t\t * @returns {String} \n\t\t */\n\t\tdetectSyntax: function(editor, hint) {\n\t\t\tvar syntax = hint || 'html';\n\t\t\t\n\t\t\tif (!resources.hasSyntax(syntax)) {\n\t\t\t\tsyntax = 'html';\n\t\t\t}\n\t\t\t\n\t\t\tif (syntax == 'html' && (this.isStyle(editor) || this.isInlineCSS(editor))) {\n\t\t\t\tsyntax = 'css';\n\t\t\t}\n\n\t\t\tif (syntax == 'styl') {\n\t\t\t\tsyntax = 'stylus';\n\t\t\t}\n\t\t\t\n\t\t\treturn syntax;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Common method for detecting output profile\n\t\t * @param {IEmmetEditor} editor\n\t\t * @returns {String}\n\t\t */\n\t\tdetectProfile: function(editor) {\n\t\t\tvar syntax = editor.getSyntax();\n\t\t\t\n\t\t\t// get profile from syntax definition\n\t\t\tvar profile = resources.findItem(syntax, 'profile');\n\t\t\tif (profile) {\n\t\t\t\treturn profile;\n\t\t\t}\n\t\t\t\n\t\t\tswitch(syntax) {\n\t\t\t\tcase 'xml':\n\t\t\t\tcase 'xsl':\n\t\t\t\t\treturn 'xml';\n\t\t\t\tcase 'css':\n\t\t\t\t\tif (this.isInlineCSS(editor)) {\n\t\t\t\t\t\treturn 'line';\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\tcase 'html':\n\t\t\t\t\tprofile = resources.getVariable('profile');\n\t\t\t\t\tif (!profile) { // no forced profile, guess from content\n\t\t\t\t\t\t// html or xhtml?\n\t\t\t\t\t\tprofile = this.isXHTML(editor) ? 'xhtml': 'html';\n\t\t\t\t\t}\n\n\t\t\t\t\treturn profile;\n\t\t\t}\n\n\t\t\treturn 'xhtml';\n\t\t},\n\t\t\n\t\t/**\n\t\t * Tries to detect if current document is XHTML one.\n\t\t * @param {IEmmetEditor} editor\n\t\t * @returns {Boolean}\n\t\t */\n\t\tisXHTML: function(editor) {\n\t\t\treturn editor.getContent().search(/<!DOCTYPE[^>]+XHTML/i) != -1;\n\t\t},\n\n\t\t/**\n\t\t * Check if current caret position is inside &lt;style&gt; tag\n\t\t * @param {IEmmetEditor} editor\n\t\t * @returns {Range} Inner range of &lt;style&gt; tag\n\t\t */\n\t\tisStyle: function(editor) {\n\t\t\treturn !!cssSections.styleTagRange(editor.getContent(), editor.getCaretPos());\n\t\t},\n\n\t\t/**\n\t\t * Check if given CSS dialect is supported by CSS actions\n\t\t * @param  {String}  syntax\n\t\t * @return {Boolean}\n\t\t */\n\t\tisSupportedCSS: function(syntax) {\n\t\t\treturn syntax == 'css' || syntax == 'less' || syntax == 'scss';\n\t\t},\n\t\t\n\t\t/**\n\t\t * Check if current caret position is inside \"style\" attribute of HTML\n\t\t * element\n\t\t * @param {IEmmetEditor} editor\n\t\t * @returns {Range} Inner range of style attribute\n\t\t */\n\t\tisInlineCSS: function(editor) {\n\t\t\treturn !!cssSections.styleAttrRange(editor.getContent(), editor.getCaretPos());\n\t\t}\n\t};\n});\n},{\"../assets/htmlMatcher\":\"assets\\\\htmlMatcher.js\",\"../assets/range\":\"assets\\\\range.js\",\"../assets/resources\":\"assets\\\\resources.js\",\"../editTree/xml\":\"editTree\\\\xml.js\",\"../parser/abbreviation\":\"parser\\\\abbreviation.js\",\"./common\":\"utils\\\\common.js\",\"./cssSections\":\"utils\\\\cssSections.js\"}],\"utils\\\\base64.js\":[function(require,module,exports){\n/**\n * @author Sergey Chikuyonok (serge.che@gmail.com)\n * @link http://chikuyonok.ru\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';\n\t\n\treturn {\n\t\t/**\n\t\t * Encodes data using base64 algorithm\n\t\t * @author Tyler Akins (http://rumkin.com)\n\t\t * @param {String} input\n\t\t * @returns {String}\n\t\t */\n\t\tencode : function(input) {\n\t\t\tvar output = [];\n\t\t\tvar chr1, chr2, chr3, enc1, enc2, enc3, enc4, cdp1, cdp2, cdp3;\n\t\t\tvar i = 0, il = input.length, b64 = chars;\n\n\t\t\twhile (i < il) {\n\n\t\t\t\tcdp1 = input.charCodeAt(i++);\n\t\t\t\tcdp2 = input.charCodeAt(i++);\n\t\t\t\tcdp3 = input.charCodeAt(i++);\n\n\t\t\t\tchr1 = cdp1 & 0xff;\n\t\t\t\tchr2 = cdp2 & 0xff;\n\t\t\t\tchr3 = cdp3 & 0xff;\n\n\t\t\t\tenc1 = chr1 >> 2;\n\t\t\t\tenc2 = ((chr1 & 3) << 4) | (chr2 >> 4);\n\t\t\t\tenc3 = ((chr2 & 15) << 2) | (chr3 >> 6);\n\t\t\t\tenc4 = chr3 & 63;\n\n\t\t\t\tif (isNaN(cdp2)) {\n\t\t\t\t\tenc3 = enc4 = 64;\n\t\t\t\t} else if (isNaN(cdp3)) {\n\t\t\t\t\tenc4 = 64;\n\t\t\t\t}\n\n\t\t\t\toutput.push(b64.charAt(enc1) + b64.charAt(enc2) + b64.charAt(enc3) + b64.charAt(enc4));\n\t\t\t}\n\n\t\t\treturn output.join('');\n\t\t},\n\n\t\t/**\n\t\t * Decodes string using MIME base64 algorithm\n\t\t * \n\t\t * @author Tyler Akins (http://rumkin.com)\n\t\t * @param {String} data\n\t\t * @return {String}\n\t\t */\n\t\tdecode : function(data) {\n\t\t\tvar o1, o2, o3, h1, h2, h3, h4, bits, i = 0, ac = 0, tmpArr = [];\n\t\t\tvar b64 = chars, il = data.length;\n\n\t\t\tif (!data) {\n\t\t\t\treturn data;\n\t\t\t}\n\n\t\t\tdata += '';\n\n\t\t\tdo { // unpack four hexets into three octets using index points in b64\n\t\t\t\th1 = b64.indexOf(data.charAt(i++));\n\t\t\t\th2 = b64.indexOf(data.charAt(i++));\n\t\t\t\th3 = b64.indexOf(data.charAt(i++));\n\t\t\t\th4 = b64.indexOf(data.charAt(i++));\n\n\t\t\t\tbits = h1 << 18 | h2 << 12 | h3 << 6 | h4;\n\n\t\t\t\to1 = bits >> 16 & 0xff;\n\t\t\t\to2 = bits >> 8 & 0xff;\n\t\t\t\to3 = bits & 0xff;\n\n\t\t\t\tif (h3 == 64) {\n\t\t\t\t\ttmpArr[ac++] = String.fromCharCode(o1);\n\t\t\t\t} else if (h4 == 64) {\n\t\t\t\t\ttmpArr[ac++] = String.fromCharCode(o1, o2);\n\t\t\t\t} else {\n\t\t\t\t\ttmpArr[ac++] = String.fromCharCode(o1, o2, o3);\n\t\t\t\t}\n\t\t\t} while (i < il);\n\n\t\t\treturn tmpArr.join('');\n\t\t}\n\t};\n});\n},{}],\"utils\\\\comments.js\":[function(require,module,exports){\n/**\n * Utility module for working with comments in source code\n * (mostly stripping it from source)\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar utils = require('./common');\n\tvar range = require('../assets/range');\n\tvar stringStream = require('../assets/stringStream');\n\tvar reHasComment = /\\/\\*|\\/\\//;\n\n\treturn {\n\t\t/**\n\t\t * Replaces all comments in given CSS source with spaces,\n\t\t * which allows more reliable (and faster) token search\n\t\t * in CSS content\n\t\t * @param  {String} content CSS content\n\t\t * @return {String}\n\t\t */\n\t\tstrip: function(content) {\n\t\t\tif (!reHasComment.test(content)) {\n\t\t\t\treturn content;\n\t\t\t}\n\n\t\t\tvar stream = stringStream(content);\n\t\t\tvar replaceRanges = [];\n\t\t\tvar ch, ch2;\n\n\t\t\twhile ((ch = stream.next())) {\n\t\t\t\tif (ch === '/') {\n\t\t\t\t\tch2 = stream.peek();\n\t\t\t\t\tif (ch2 === '*') { // multiline CSS comment\n\t\t\t\t\t\tstream.start = stream.pos - 1;\n\n\t\t\t\t\t\tif (stream.skipTo('*/')) {\n\t\t\t\t\t\t\tstream.pos += 2;\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t// unclosed comment\n\t\t\t\t\t\t\tstream.skipToEnd();\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\treplaceRanges.push([stream.start, stream.pos]);\n\t\t\t\t\t} else if (ch2 === '/') {\n\t\t\t\t\t\t// preprocessor’s single line comments\n\t\t\t\t\t\tstream.start = stream.pos - 1;\n\t\t\t\t\t\twhile ((ch2 = stream.next())) {\n\t\t\t\t\t\t\tif (ch2 === '\\n' || ch2 == '\\r') {\n\t\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\treplaceRanges.push([stream.start, stream.pos]);\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tstream.skipQuoted();\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn utils.replaceWith(content, replaceRanges, ' ');\n\t\t}\n\t};\n});\n},{\"../assets/range\":\"assets\\\\range.js\",\"../assets/stringStream\":\"assets\\\\stringStream.js\",\"./common\":\"utils\\\\common.js\"}],\"utils\\\\common.js\":[function(require,module,exports){\n/**\n * Common utility helper for Emmet\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar range = require('../assets/range');\n\n\t/** \n\t * Special token used as a placeholder for caret positions inside \n\t * generated output \n\t */\n\tvar caretPlaceholder = '${0}';\n\t\n\treturn {\n\t\treTag: /<\\/?[\\w:\\-]+(?:\\s+[\\w\\-:]+(?:\\s*=\\s*(?:(?:\"[^\"]*\")|(?:'[^']*')|[^>\\s]+))?)*\\s*(\\/?)>$/,\n\n\t\tdefaultSyntax: function() {\n\t\t\treturn 'html';\n\t\t},\n\n\t\tdefaultProfile: function() {\n\t\t\treturn 'plain';\n\t\t},\n\t\t\n\t\t/**\n\t\t * Test if passed string ends with XHTML tag. This method is used for testing\n\t\t * '>' character: it belongs to tag or it's a part of abbreviation? \n\t\t * @param {String} str\n\t\t * @return {Boolean}\n\t\t */\n\t\tendsWithTag: function(str) {\n\t\t\treturn this.reTag.test(str);\n\t\t},\n\t\t\n\t\t/**\n\t\t * Check if passed symbol is a number\n\t\t * @param {String} ch\n\t\t * @returns {Boolean}\n\t\t */\n\t\tisNumeric: function(ch) {\n\t\t\tif (typeof(ch) == 'string')\n\t\t\t\tch = ch.charCodeAt(0);\n\t\t\t\t\n\t\t\treturn (ch && ch > 47 && ch < 58);\n\t\t},\n\t\t\n\t\t/**\n\t\t * Trim whitespace from string\n\t\t * @param {String} text\n\t\t * @return {String}\n\t\t */\n\t\ttrim: (function() {\n\t\t\tif (String.prototype.trim) {\n\t\t\t\treturn function(text) {\n\t\t\t\t\treturn text ? text.trim() : '';\n\t\t\t\t};\n\t\t\t}\n\n\t\t\treturn function(text) {\n\t\t\t\treturn (text || \"\").replace(/^\\s+|\\s+$/g, \"\");\n\t\t\t}\n\t\t})(),\n\t\t\n\t\t/**\n\t\t * Split text into lines. Set <code>remove_empty</code> to true to filter\n\t\t * empty lines\n\t\t * @param {String} text Text to split\n\t\t * @param {Boolean} removeEmpty Remove empty lines from result\n\t\t * @return {Array}\n\t\t */\n\t\tsplitByLines: function(text, removeEmpty) {\n\t\t\t// IE fails to split string by regexp, \n\t\t\t// need to normalize newlines first\n\t\t\t// Also, Mozilla's Rhiho JS engine has a weird newline bug\n\t\t\tvar nl = '\\n';\n\t\t\tvar lines = (text || '')\n\t\t\t\t.replace(/\\r\\n/g, '\\n')\n\t\t\t\t.replace(/\\n\\r/g, '\\n')\n\t\t\t\t.replace(/\\r/g, '\\n')\n\t\t\t\t.replace(/\\n/g, nl)\n\t\t\t\t.split(nl);\n\t\t\t\n\t\t\tif (removeEmpty) {\n\t\t\t\tlines = lines.filter(function(line) {\n\t\t\t\t\treturn line.length && !!this.trim(line);\n\t\t\t\t}, this);\n\t\t\t}\n\t\t\t\n\t\t\treturn lines;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Repeats string <code>howMany</code> times\n\t\t * @param {String} str\n\t\t * @param {Number} how_many\n\t\t * @return {String}\n\t\t */\n\t\trepeatString: function(str, howMany) {\n\t\t\tvar out = '';\n\t\t\twhile (howMany--) {\n\t\t\t\tout += str;\n\t\t\t}\n\n\t\t\treturn out;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns list of paddings that should be used to align passed string\n\t\t * @param {Array} strings\n\t\t * @returns {Array}\n\t\t */\n\t\tgetStringsPads: function(strings) {\n\t\t\tvar lengths = strings.map(function(s) {\n\t\t\t\treturn typeof s === 'string' ? s.length : +s;\n\t\t\t});\n\t\t\t\n\t\t\tvar max = lengths.reduce(function(prev, cur) {\n\t\t\t\treturn typeof prev === 'undefined' ? cur : Math.max(prev, cur);\n\t\t\t});\n\t\t\treturn lengths.map(function(l) {\n\t\t\t\tvar pad = max - l;\n\t\t\t\treturn pad ? this.repeatString(' ', pad) : '';\n\t\t\t}, this);\n\t\t},\n\t\t\n\t\t/**\n\t\t * Indents text with padding\n\t\t * @param {String} text Text to indent\n\t\t * @param {String} pad Padding size (number) or padding itself (string)\n\t\t * @return {String}\n\t\t */\n\t\tpadString: function(text, pad) {\n\t\t\tvar result = [];\n\t\t\tvar lines = this.splitByLines(text);\n\t\t\tvar nl = '\\n';\n\t\t\t\t\n\t\t\tresult.push(lines[0]);\n\t\t\tfor (var j = 1; j < lines.length; j++) \n\t\t\t\tresult.push(nl + pad + lines[j]);\n\t\t\t\t\n\t\t\treturn result.join('');\n\t\t},\n\t\t\n\t\t/**\n\t\t * Pad string with zeroes\n\t\t * @param {String} str String to pad\n\t\t * @param {Number} pad Desired string length\n\t\t * @return {String}\n\t\t */\n\t\tzeroPadString: function(str, pad) {\n\t\t\tvar padding = '';\n\t\t\tvar il = str.length;\n\t\t\t\t\n\t\t\twhile (pad > il++) padding += '0';\n\t\t\treturn padding + str; \n\t\t},\n\t\t\n\t\t/**\n\t\t * Removes padding at the beginning of each text's line\n\t\t * @param {String} text\n\t\t * @param {String} pad\n\t\t */\n\t\tunindentString: function(text, pad) {\n\t\t\tvar lines = this.splitByLines(text);\n\t\t\tvar pl = pad.length;\n\t\t\tfor (var i = 0, il = lines.length, line; i < il; i++) {\n\t\t\t\tline = lines[i];\n\t\t\t\tif (line.substr(0, pl) === pad) {\n\t\t\t\t\tlines[i] = line.substr(pl);\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\treturn lines.join('\\n');\n\t\t},\n\t\t\n\t\t/**\n\t\t * Replaces unescaped symbols in <code>str</code>. For example, the '$' symbol\n\t\t * will be replaced in 'item$count', but not in 'item\\$count'.\n\t\t * @param {String} str Original string\n\t\t * @param {String} symbol Symbol to replace\n\t\t * @param {String} replace Symbol replacement. Might be a function that \n\t\t * returns new value\n\t\t * @return {String}\n\t\t */\n\t\treplaceUnescapedSymbol: function(str, symbol, replace) {\n\t\t\tvar i = 0;\n\t\t\tvar il = str.length;\n\t\t\tvar sl = symbol.length;\n\t\t\tvar matchCount = 0;\n\t\t\t\t\n\t\t\twhile (i < il) {\n\t\t\t\tif (str.charAt(i) == '\\\\') {\n\t\t\t\t\t// escaped symbol, skip next character\n\t\t\t\t\ti += sl + 1;\n\t\t\t\t} else if (str.substr(i, sl) == symbol) {\n\t\t\t\t\t// have match\n\t\t\t\t\tvar curSl = sl;\n\t\t\t\t\tmatchCount++;\n\t\t\t\t\tvar newValue = replace;\n\t\t\t\t\tif (typeof replace === 'function') {\n\t\t\t\t\t\tvar replaceData = replace(str, symbol, i, matchCount);\n\t\t\t\t\t\tif (replaceData) {\n\t\t\t\t\t\t\tcurSl = replaceData[0].length;\n\t\t\t\t\t\t\tnewValue = replaceData[1];\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tnewValue = false;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\t\n\t\t\t\t\tif (newValue === false) { // skip replacement\n\t\t\t\t\t\ti++;\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\t\n\t\t\t\t\tstr = str.substring(0, i) + newValue + str.substring(i + curSl);\n\t\t\t\t\t// adjust indexes\n\t\t\t\t\til = str.length;\n\t\t\t\t\ti += newValue.length;\n\t\t\t\t} else {\n\t\t\t\t\ti++;\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\treturn str;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Replaces '$' character in string assuming it might be escaped with '\\'\n\t\t * @param {String} str String where character should be replaced\n\t\t * @param {String} value New value\n\t\t * @return {String}\n\t\t */\n\t\treplaceCounter: function(str, value, total) {\n\t\t\tvar symbol = '$';\n\t\t\t// in case we received strings from Java, convert the to native strings\n\t\t\tstr = String(str);\n\t\t\tvalue = String(value);\n\t\t\t\n\t\t\tif (/^\\-?\\d+$/.test(value)) {\n\t\t\t\tvalue = +value;\n\t\t\t}\n\t\t\t\n\t\t\tvar that = this;\n\t\t\t\n\t\t\treturn this.replaceUnescapedSymbol(str, symbol, function(str, symbol, pos, matchNum){\n\t\t\t\tif (str.charAt(pos + 1) == '{' || that.isNumeric(str.charAt(pos + 1)) ) {\n\t\t\t\t\t// it's a variable, skip it\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\t// replace sequense of $ symbols with padded number  \n\t\t\t\tvar j = pos + 1;\n\t\t\t\twhile(str.charAt(j) == '$' && str.charAt(j + 1) != '{') j++;\n\t\t\t\tvar pad = j - pos;\n\t\t\t\t\n\t\t\t\t// get counter base\n\t\t\t\tvar base = 0, decrement = false, m;\n\t\t\t\tif ((m = str.substr(j).match(/^@(\\-?)(\\d*)/))) {\n\t\t\t\t\tj += m[0].length;\n\t\t\t\t\t\n\t\t\t\t\tif (m[1]) {\n\t\t\t\t\t\tdecrement = true;\n\t\t\t\t\t}\n\t\t\t\t\t\n\t\t\t\t\tbase = parseInt(m[2] || 1, 10) - 1;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tif (decrement && total && typeof value === 'number') {\n\t\t\t\t\tvalue = total - value + 1;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tvalue += base;\n\t\t\t\t\n\t\t\t\treturn [str.substring(pos, j), that.zeroPadString(value + '', pad)];\n\t\t\t});\n\t\t},\n\t\t\n\t\t/**\n\t\t * Check if string matches against <code>reTag</code> regexp. This \n\t\t * function may be used to test if provided string contains HTML tags\n\t\t * @param {String} str\n\t\t * @returns {Boolean}\n\t\t */\n\t\tmatchesTag: function(str) {\n\t\t\treturn this.reTag.test(str || '');\n\t\t},\n\t\t\n\t\t/**\n\t\t * Escapes special characters used in Emmet, like '$', '|', etc.\n\t\t * Use this method before passing to actions like \"Wrap with Abbreviation\"\n\t\t * to make sure that existing special characters won't be altered\n\t\t * @param {String} text\n\t\t * @return {String}\n\t\t */\n\t\tescapeText: function(text) {\n\t\t\treturn text.replace(/([\\$\\\\])/g, '\\\\$1');\n\t\t},\n\t\t\n\t\t/**\n\t\t * Unescapes special characters used in Emmet, like '$', '|', etc.\n\t\t * @param {String} text\n\t\t * @return {String}\n\t\t */\n\t\tunescapeText: function(text) {\n\t\t\treturn text.replace(/\\\\(.)/g, '$1');\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns caret placeholder\n\t\t * @returns {String}\n\t\t */\n\t\tgetCaretPlaceholder: function() {\n\t\t\treturn typeof caretPlaceholder === 'function'\n\t\t\t\t? caretPlaceholder.apply(this, arguments)\n\t\t\t\t: caretPlaceholder;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Sets new representation for carets in generated output\n\t\t * @param {String} value New caret placeholder. Might be a \n\t\t * <code>Function</code>\n\t\t */\n\t\tsetCaretPlaceholder: function(value) {\n\t\t\tcaretPlaceholder = value;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns line padding\n\t\t * @param {String} line\n\t\t * @return {String}\n\t\t */\n\t\tgetLinePadding: function(line) {\n\t\t\treturn (line.match(/^(\\s+)/) || [''])[0];\n\t\t},\n\t\t\n\t\t/**\n\t\t * Helper function that returns padding of line of <code>pos</code>\n\t\t * position in <code>content</code>\n\t\t * @param {String} content\n\t\t * @param {Number} pos\n\t\t * @returns {String}\n\t\t */\n\t\tgetLinePaddingFromPosition: function(content, pos) {\n\t\t\tvar lineRange = this.findNewlineBounds(content, pos);\n\t\t\treturn this.getLinePadding(lineRange.substring(content));\n\t\t},\n\t\t\n\t\t/**\n\t\t * Escape special regexp chars in string, making it usable for creating dynamic\n\t\t * regular expressions\n\t\t * @param {String} str\n\t\t * @return {String}\n\t\t */\n\t\tescapeForRegexp: function(str) {\n\t\t\tvar specials = new RegExp(\"[.*+?|()\\\\[\\\\]{}\\\\\\\\]\", \"g\"); // .*+?|()[]{}\\\n\t\t\treturn str.replace(specials, \"\\\\$&\");\n\t\t},\n\t\t\n\t\t/**\n\t\t * Make decimal number look good: convert it to fixed precision end remove\n\t\t * traling zeroes \n\t\t * @param {Number} num\n\t\t * @param {Number} fracion Fraction numbers (default is 2)\n\t\t * @return {String}\n\t\t */\n\t\tprettifyNumber: function(num, fraction) {\n\t\t\treturn num.toFixed(typeof fraction == 'undefined' ? 2 : fraction).replace(/\\.?0+$/, '');\n\t\t},\n\t\t\n\t\t/**\n\t\t * Replace substring of <code>str</code> with <code>value</code>\n\t\t * @param {String} str String where to replace substring\n\t\t * @param {String} value New substring value\n\t\t * @param {Number} start Start index of substring to replace. May also\n\t\t * be a <code>Range</code> object: in this case, the <code>end</code>\n\t\t * argument is not required\n\t\t * @param {Number} end End index of substring to replace. If ommited, \n\t\t * <code>start</code> argument is used\n\t\t */\n\t\treplaceSubstring: function(str, value, start, end) {\n\t\t\tif (typeof start === 'object' && 'end' in start) {\n\t\t\t\tend = start.end;\n\t\t\t\tstart = start.start;\n\t\t\t}\n\t\t\t\n\t\t\tif (typeof end === 'string') {\n\t\t\t\tend = start + end.length;\n\t\t\t}\n\t\t\t\n\t\t\tif (typeof end === 'undefined') {\n\t\t\t\tend = start;\n\t\t\t}\n\t\t\t\n\t\t\tif (start < 0 || start > str.length)\n\t\t\t\treturn str;\n\t\t\t\n\t\t\treturn str.substring(0, start) + value + str.substring(end);\n\t\t},\n\n\t\t/**\n\t\t * Fills substrings in `content`, defined by given ranges,\n\t\t * wich `ch` character\n\t\t * @param  {String} content\n\t\t * @param  {Array} ranges\n\t\t * @return {String}\n\t\t */\n\t\treplaceWith: function(content, ranges, ch, noRepeat) {\n\t\t\tif (ranges.length) {\n\t\t\t\tvar offset = 0, fragments = [];\n\t\t\t\tranges.forEach(function(r) {\n\t\t\t\t\tvar repl = noRepeat ? ch : this.repeatString(ch, r[1] - r[0]);\n\t\t\t\t\tfragments.push(content.substring(offset, r[0]), repl);\n\t\t\t\t\toffset = r[1];\n\t\t\t\t}, this);\n\n\t\t\t\tcontent = fragments.join('') + content.substring(offset);\n\t\t\t}\n\n\t\t\treturn content;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Narrows down text range, adjusting selection to non-space characters\n\t\t * @param {String} text\n\t\t * @param {Number} start Starting range in <code>text</code> where \n\t\t * slection should be adjusted. Can also be any object that is accepted\n\t\t * by <code>Range</code> class\n\t\t * @return {Range}\n\t\t */\n\t\tnarrowToNonSpace: function(text, start, end) {\n\t\t\tvar rng = range.create(start, end);\n\t\t\t\n\t\t\tvar reSpace = /[\\s\\n\\r\\u00a0]/;\n\t\t\t// narrow down selection until first non-space character\n\t\t\twhile (rng.start < rng.end) {\n\t\t\t\tif (!reSpace.test(text.charAt(rng.start)))\n\t\t\t\t\tbreak;\n\t\t\t\t\t\n\t\t\t\trng.start++;\n\t\t\t}\n\t\t\t\n\t\t\twhile (rng.end > rng.start) {\n\t\t\t\trng.end--;\n\t\t\t\tif (!reSpace.test(text.charAt(rng.end))) {\n\t\t\t\t\trng.end++;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\treturn rng;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Find start and end index of text line for <code>from</code> index\n\t\t * @param {String} text \n\t\t * @param {Number} from\n\t\t */\n\t\tfindNewlineBounds: function(text, from) {\n\t\t\tvar len = text.length,\n\t\t\t\tstart = 0,\n\t\t\t\tend = len - 1, \n\t\t\t\tch;\n\n\t\t\t\n\t\t\t// search left\n\t\t\tfor (var i = from - 1; i > 0; i--) {\n\t\t\t\tch = text.charAt(i);\n\t\t\t\tif (ch == '\\n' || ch == '\\r') {\n\t\t\t\t\tstart = i + 1;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\t// search right\n\t\t\tfor (var j = from; j < len; j++) {\n\t\t\t\tch = text.charAt(j);\n\t\t\t\tif (ch == '\\n' || ch == '\\r') {\n\t\t\t\t\tend = j;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\treturn range.create(start, end - start);\n\t\t},\n\n\t\t/**\n\t\t * Deep merge of two or more objects. Taken from jQuery.extend()\n\t\t */\n\t\tdeepMerge: function() {\n\t\t\tvar options, name, src, copy, copyIsArray, clone,\n\t\t\t\ttarget = arguments[0] || {},\n\t\t\t\ti = 1,\n\t\t\t\tlength = arguments.length;\n\n\n\t\t\t// Handle case when target is a string or something (possible in deep copy)\n\t\t\tif (typeof target !== 'object' && typeof target !== 'function') {\n\t\t\t\ttarget = {};\n\t\t\t}\n\n\t\t\tfor ( ; i < length; i++ ) {\n\t\t\t\t// Only deal with non-null/undefined values\n\t\t\t\tif ( (options = arguments[ i ]) !== null ) {\n\t\t\t\t\t// Extend the base object\n\t\t\t\t\tfor ( name in options ) {\n\t\t\t\t\t\tsrc = target[ name ];\n\t\t\t\t\t\tcopy = options[ name ];\n\n\t\t\t\t\t\t// Prevent never-ending loop\n\t\t\t\t\t\tif ( target === copy ) {\n\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Recurse if we're merging plain objects or arrays\n\t\t\t\t\t\tif ( copy && ( typeof copy === 'object' || (copyIsArray = Array.isArray(copy)) ) ) {\n\t\t\t\t\t\t\tif ( copyIsArray ) {\n\t\t\t\t\t\t\t\tcopyIsArray = false;\n\t\t\t\t\t\t\t\tclone = src && Array.isArray(src) ? src : [];\n\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tclone = src && typeof src === 'object' ? src : {};\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t// Never move original objects, clone them\n\t\t\t\t\t\t\ttarget[ name ] = this.deepMerge(clone, copy );\n\n\t\t\t\t\t\t// Don't bring in undefined values\n\t\t\t\t\t\t} else if ( copy !== undefined ) {\n\t\t\t\t\t\t\ttarget[ name ] = copy;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Return the modified object\n\t\t\treturn target;\n\t\t},\n\n\t\t/**\n\t\t * Dead simple string-to-JSON parser\n\t\t * @param {String} str\n\t\t * @returns {Object}\n\t\t */\n\t\tparseJSON: function(str) {\n\t\t\tif (typeof str == 'object') {\n\t\t\t\treturn str;\n\t\t\t}\n\t\t\t\n\t\t\ttry {\n\t\t\t\treturn JSON.parse(str);\n\t\t\t} catch(e) {\n\t\t\t\treturn {};\n\t\t\t}\n\t\t},\n\n\n\t\t/**************************\n\t\t * Utility belt\n\t\t **************************/\n\t\tunique: function(arr, comparator) {\n\t\t\tvar lookup = [];\n\t\t\treturn arr.filter(function(item) {\n\t\t\t\tvar val = comparator ? comparator(item) : item;\n\t\t\t\tif (lookup.indexOf(val) < 0) {\n\t\t\t\t\tlookup.push(val);\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Return a copy of the object, filtered to only have values for \n\t\t * the whitelisted keys. \n\t\t * @param  {Object} obj\n\t\t * @return {Object}\n\t\t */\n\t\tpick: function(obj) {\n\t\t\tvar result = {};\n\t\t\tvar keys = this.toArray(arguments, 1);\n\t\t\tObject.keys(obj).forEach(function(key) {\n\t\t\t\tif (~keys.indexOf(key)) {\n\t\t\t\t\tresult[key] = obj[key];\n\t\t\t\t}\n\t\t\t});\n\t\t\treturn result;\n\t\t},\n\n\t\tfind: function(arr, comparator, ctx) {\n\t\t\tvar result;\n\t\t\tif (ctx) {\n\t\t\t\tcomparator = comparator.bind(ctx);\n\t\t\t}\n\n\t\t\tif (Array.isArray(arr)) {\n\t\t\t\tarr.some(function(item, i) {\n\t\t\t\t\tif (comparator(item, i)) {\n\t\t\t\t\t\treturn result = item;\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t} else {\n\t\t\t\tObject.keys(arr).some(function(key, i) {\n\t\t\t\t\tif (comparator(arr[key], i)) {\n\t\t\t\t\t\treturn result = arr[key];\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\n\t\t\treturn result;\n\t\t},\n\n\t\ttoArray: function(obj, sliceIx) {\n\t\t\tif (Array.isArray(obj) && !sliceIx) {\n\t\t\t\treturn obj;\n\t\t\t}\n\t\t\treturn Array.prototype.slice.call(obj, sliceIx || 0);\n\t\t},\n\n\t\textend: function(obj) {\n\t\t\tfor (var i = 1, il = arguments.length, a; i < il; i++) {\n\t\t\t\ta = arguments[i];\n\t\t\t\tif (a) {\n\t\t\t\t\tObject.keys(a).forEach(function(key) {\n\t\t\t\t\t\tobj[key] = a[key];\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn obj;\n\t\t},\n\n\t\tdefaults: function(obj) {\n\t\t\tfor (var i = 1, il = arguments.length, a; i < il; i++) {\n\t\t\t\ta = arguments[i];\n\t\t\t\tif (a) {\n\t\t\t\t\tObject.keys(a).forEach(function(key) {\n\t\t\t\t\t\tif (!(key in obj)) {\n\t\t\t\t\t\t\tobj[key] = a[key];\n\t\t\t\t\t\t}\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn obj;\n\t\t},\n\n\t\tflatten: function(arr, out) {\n\t\t\tout = out || [];\n\t\t\tvar self = this;\n\t\t\tself.toArray(arr).forEach(function(item) {\n\t\t\t\tif (Array.isArray(item)) {\n\t\t\t\t\tself.flatten(item, out);\n\t\t\t\t} else {\n\t\t\t\t\tout.push(item);\n\t\t\t\t}\n\t\t\t});\n\n\t\t\treturn out;\n\t\t},\n\n\t\tclone: function(obj) {\n\t\t\tif (Array.isArray(obj)) {\n\t\t\t\treturn obj.slice(0);\n\t\t\t}\n\n\t\t\treturn this.extend({}, obj);\n\t\t},\n\n\t\twithout: function(arr) {\n\t\t\tthis.toArray(arguments, 1).forEach(function(item) {\n\t\t\t\tvar ix;\n\t\t\t\twhile (~(ix = arr.indexOf(item))) {\n\t\t\t\t\tarr.splice(ix, 1);\n\t\t\t\t}\n\t\t\t});\n\t\t\treturn arr;\n\t\t},\n\n\t\tlast: function(arr) {\n\t\t\treturn arr[arr.length - 1];\n\t\t}\n\t};\n});\n\n},{\"../assets/range\":\"assets\\\\range.js\"}],\"utils\\\\cssSections.js\":[function(require,module,exports){\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar utils = require('./common');\n\tvar commentsUtils = require('./comments');\n\tvar range = require('../assets/range');\n\tvar stringStream = require('../assets/stringStream');\n\tvar cssParser = require('../parser/css');\n\tvar htmlMatcher = require('../assets/htmlMatcher');\n\tvar xmlEditTree = require('../editTree/xml');\n\n\tvar idCounter = 1;\n\tvar maxId = 1000000;\n\n\tvar reSpaceTrim = /^(\\s*).+?(\\s*)$/;\n\tvar reSpace = /\\s/g;\n\tvar reComma = /,/;\n\n\tfunction isQuote(ch) {\n\t\treturn ch == '\"' || ch == \"'\";\n\t}\n\n\tfunction getId() {\n\t\tidCounter = (idCounter + 1) % maxId;\n\t\treturn 's' + idCounter;\n\t}\n\n\t/**\n\t * @param {Range} range Full selector range with additional\n\t * properties for matching name and content (@see findAllRules())\n\t * @param {String} source CSS source\n\t */\n\tfunction CSSSection(rng, source) {\n\t\tthis.id = getId();\n\t\t/** @type {CSSSection} */\n\t\tthis.parent = null;\n\t\t/** @type {CSSSection} */\n\t\tthis.nextSibling = null;\n\t\t/** @type {CSSSection} */\n\t\tthis.previousSibling = null;\n\t\tthis._source = source;\n\t\tthis._name = null;\n\t\tthis._content = null;\n\n\t\t/**\n\t\t * Custom data for current nodes, used by other modules for\n\t\t * caching etc.\n\t\t * @type {Object}\n\t\t */\n\t\tthis._data = {};\n\n\t\tif (!rng && source) {\n\t\t\trng = range(0, source);\n\t\t}\n\n\t\tthis.range = rng;\n\t\tthis.children = [];\n\t}\n\n\tCSSSection.prototype = {\n\t\taddChild: function(section) {\n\t\t\tif (!(section instanceof CSSSection)) {\n\t\t\t\tsection = new CSSSection(section);\n\t\t\t}\n\n\t\t\tvar lastChild = utils.last(this.children);\n\t\t\tif (lastChild) {\n\t\t\t\tlastChild.nextSibling = section;\n\t\t\t\tsection.previousSibling = lastChild;\n\t\t\t}\n\t\t\tsection.parent = this;\n\n\t\t\tthis.children.push(section);\n\t\t\treturn section;\n\t\t},\n\n\t\t/**\n\t\t * Returns root node\n\t\t * @return {CSSSection}\n\t\t */\n\t\troot: function() {\n\t\t\tvar root = this;\n\t\t\tdo {\n\t\t\t\tif (!root.parent) {\n\t\t\t\t\treturn root;\n\t\t\t\t}\n\t\t\t} while(root = root.parent);\n\n\t\t\treturn root;\n\t\t},\n\n\t\t/**\n\t\t * Returns currect CSS source\n\t\t * @return {String}\n\t\t */\n\t\tsource: function() {\n\t\t\treturn this._source || this.root()._source;\n\t\t},\n\n\t\t/**\n\t\t * Returns section name\n\t\t * @return {String}\n\t\t */\n\t\tname: function() {\n\t\t\tif (this._name === null) {\n\t\t\t\tvar range = this.nameRange();\n\t\t\t\tif (range) {\n\t\t\t\t\tthis._name = range.substring(this.source());\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn this._name;\n\t\t},\n\n\t\t/**\n\t\t * Returns section name range\n\t\t * @return {[type]} [description]\n\t\t */\n\t\tnameRange: function() {\n\t\t\tif (this.range && '_selectorEnd' in this.range) {\n\t\t\t\treturn range.create2(this.range.start, this.range._selectorEnd);\n\t\t\t}\n\t\t},\n\n\t\t/**\n\t\t * Returns deepest child of current section (or section itself) \n\t\t * which includes given position.\n\t\t * @param  {Number} pos\n\t\t * @return {CSSSection}\n\t\t */\n\t\tmatchDeep: function(pos) {\n\t\t\tif (!this.range.inside(pos)) {\n\t\t\t\treturn null;\n\t\t\t}\n\n\t\t\tfor (var i = 0, il = this.children.length, m; i < il; i++) {\n\t\t\t\tm = this.children[i].matchDeep(pos);\n\t\t\t\tif (m) {\n\t\t\t\t\treturn m;\n\t\t\t\t}\n\t\t\t};\n\n\t\t\treturn this.parent ? this : null;\n\t\t},\n\n\t\t/**\n\t\t * Returns current and all nested sections ranges\n\t\t * @return {Array}\n\t\t */\n\t\tallRanges: function() {\n\t\t\tvar out = [];\n\t\t\tif (this.parent) {\n\t\t\t\t// add current range if it is not root node\n\t\t\t\tout.push(this.range);\n\t\t\t}\n\n\t\t\tthis.children.forEach(function(child) {\n\t\t\t\tout = out.concat(child.allRanges());\n\t\t\t});\n\n\t\t\treturn out;\n\t\t},\n\n\t\tdata: function(key, value) {\n\t\t\tif (typeof value !== 'undefined') {\n\t\t\t\tthis._data[key] = value;\n\t\t\t}\n\n\t\t\treturn this._data[key];\n\t\t},\n\n\t\tstringify: function(indent) {\n\t\t\tindent = indent || '';\n\t\t\tvar out = '';\n\t\t\tthis.children.forEach(function(item) {\n\t\t\t\tout += indent + item.name().replace(/\\n/g, '\\\\n') + '\\n';\n\t\t\t\tout += item.stringify(indent + '--');\n\t\t\t});\n\n\t\t\treturn out;\n\t\t},\n\n\t\t/**\n\t\t * Returns current section’s actual content,\n\t\t * e.g. content without nested sections\n\t\t * @return {String} \n\t\t */\n\t\tcontent: function() {\n\t\t\tif (this._content !== null) {\n\t\t\t\treturn this._content;\n\t\t\t}\n\n\t\t\tif (!this.range || !('_contentStart' in this.range)) {\n\t\t\t\treturn '';\n\t\t\t}\n\n\t\t\tvar r = range.create2(this.range._contentStart + 1, this.range.end - 1);\n\t\t\tvar source = this.source();\n\t\t\tvar start = r.start;\n\t\t\tvar out = '';\n\n\t\t\tthis.children.forEach(function(child) {\n\t\t\t\tout += source.substring(start, child.range.start);\n\t\t\t\tstart = child.range.end;\n\t\t\t});\n\n\t\t\tout += source.substring(start, r.end);\n\t\t\treturn this._content = utils.trim(out);\n\t\t}\n\t};\n\n\treturn {\n\t\t/**\n\t\t * Finds all CSS rules‘ ranges in given CSS source\n\t\t * @param  {String} content CSS source\n\t\t * @return {Array} Array of ranges\n\t\t */\n\t\tfindAllRules: function(content) {\n\t\t\tcontent = this.sanitize(content);\n\t\t\tvar stream = stringStream(content);\n\t\t\tvar ranges = [], matchedRanges;\n\t\t\tvar self = this;\n\n\t\t\tvar saveRule = function(r) {\n\t\t\t\tvar selRange = self.extractSelector(content, r.start);\n\t\t\t\tvar rule = range.create2(selRange.start, r.end);\n\t\t\t\trule._selectorEnd = selRange.end;\n\t\t\t\trule._contentStart = r.start;\n\t\t\t\tranges.push(rule);\n\t\t\t};\n\n\t\t\tvar ch;\n\t\t\twhile (ch = stream.next()) {\n\t\t\t\tif (isQuote(ch)) {\n\t\t\t\t\tif (!stream.skipString(ch)) {\n\t\t\t\t\t\tbreak; // unterminated string\n\t\t\t\t\t}\n\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\tif (ch == '{') {\n\t\t\t\t\tmatchedRanges = this.matchBracesRanges(content, stream.pos - 1);\n\t\t\t\t\tmatchedRanges.forEach(saveRule);\n\n\t\t\t\t\tif (matchedRanges.length) {\n\t\t\t\t\t\tstream.pos = utils.last(matchedRanges).end;\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t} \n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\treturn ranges.sort(function(a, b) {\n\t\t\t\treturn a.start - b.start;\n\t\t\t});\n\t\t},\n\n\t\t/**\n\t\t * Matches curly braces content right after given position\n\t\t * @param  {String} content CSS content. Must not contain comments!\n\t\t * @param  {Number} pos     Search start position\n\t\t * @return {Range}\n\t\t */\n\t\tmatchBracesRanges: function(content, pos, sanitize) {\n\t\t\tif (sanitize) {\n\t\t\t\tcontent = this.sanitize(content);\n\t\t\t}\n\n\t\t\tvar stream = stringStream(content);\n\t\t\tstream.start = stream.pos = pos;\n\t\t\tvar stack = [], ranges = [];\n\t\t\tvar ch;\n\t\t\twhile (ch = stream.next()) {\n\t\t\t\tif (ch == '{') {\n\t\t\t\t\tstack.push(stream.pos - 1);\n\t\t\t\t} else if (ch == '}') {\n\t\t\t\t\tif (!stack.length) {\n\t\t\t\t\t\tthrow 'Invalid source structure (check for curly braces)';\n\t\t\t\t\t}\n\t\t\t\t\tranges.push(range.create2(stack.pop(), stream.pos));\n\t\t\t\t\tif (!stack.length) {\n\t\t\t\t\t\treturn ranges;\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tstream.skipQuoted();\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn ranges;\n\t\t},\n\n\t\t/**\n\t\t * Extracts CSS selector from CSS document from\n\t\t * given position. The selector is located by moving backward\n\t\t * from given position which means that passed position\n\t\t * must point to the end of selector \n\t\t * @param  {String}  content CSS source\n\t\t * @param  {Number}  pos     Search position\n\t\t * @param  {Boolean} sanitize Sanitize CSS source before processing.\n\t\t * Off by default and assumes that CSS must be comment-free already\n\t\t * (for performance)\n\t\t * @return {Range}\n\t\t */\n\t\textractSelector: function(content, pos, sanitize) {\n\t\t\tif (sanitize) {\n\t\t\t\tcontent = this.sanitize(content);\n\t\t\t}\n\n\t\t\tvar skipString = function() {\n\t\t\t\tvar quote = content.charAt(pos);\n\t\t\t\tif (quote == '\"' || quote == \"'\") {\n\t\t\t\t\twhile (--pos >= 0) {\n\t\t\t\t\t\tif (content.charAt(pos) == quote && content.charAt(pos - 1) != '\\\\') {\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\n\t\t\t\treturn false;\n\t\t\t};\n\n\t\t\t// find CSS selector\n\t\t\tvar ch;\n\t\t\tvar endPos = pos;\n\t\t\twhile (--pos >= 0) {\n\t\t\t\tif (skipString()) continue;\n\n\t\t\t\tch = content.charAt(pos);\n\t\t\t\tif (ch == ')') {\n\t\t\t\t\t// looks like it’s a preprocessor thing,\n\t\t\t\t\t// most likely a mixin arguments list, e.g.\n\t\t\t\t\t// .mixin (@arg1; @arg2) {...}\n\t\t\t\t\twhile (--pos >= 0) {\n\t\t\t\t\t\tif (skipString()) continue;\n\n\t\t\t\t\t\tif (content.charAt(pos) == '(') {\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\tif (ch == '{' || ch == '}' || ch == ';') {\n\t\t\t\t\tpos++;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (pos < 0) {\n\t\t\t\tpos = 0;\n\t\t\t}\n\t\t\t\n\t\t\tvar selector = content.substring(pos, endPos);\n\n\t\t\t// trim whitespace from matched selector\n\t\t\tvar m = selector.replace(reSpace, ' ').match(reSpaceTrim);\n\t\t\tif (m) {\n\t\t\t\tpos += m[1].length;\n\t\t\t\tendPos -= m[2].length;\n\t\t\t}\n\n\t\t\treturn range.create2(pos, endPos);\n\t\t},\n\n\t\t/**\n\t\t * Search for nearest CSS rule/section that contains\n\t\t * given position\n\t\t * @param  {String} content CSS content or matched CSS rules (array of ranges)\n\t\t * @param  {Number} pos     Search position\n\t\t * @return {Range}\n\t\t */\n\t\tmatchEnclosingRule: function(content, pos) {\n\t\t\tif (typeof content === 'string') {\n\t\t\t\tcontent = this.findAllRules(content);\n\t\t\t}\n\n\t\t\tvar rules = content.filter(function(r) {\n\t\t\t\treturn r.inside(pos);\n\t\t\t});\n\n\t\t\treturn utils.last(rules);\n\t\t},\n\n\t\t/**\n\t\t * Locates CSS rule next or before given position\n\t\t * @param  {String}  content    CSS content\n\t\t * @param  {Number}  pos        Search start position\n\t\t * @param  {Boolean} isBackward Search backward (find previous rule insteaf of next one)\n\t\t * @return {Range}\n\t\t */\n\t\tlocateRule: function(content, pos, isBackward) {\n\t\t\t// possible case: editor reported that current syntax is\n\t\t\t// CSS, but it’s actually a HTML document (either `style` tag or attribute)\n\t\t\tvar offset = 0;\n\t\t\tvar subrange = this.styleTagRange(content, pos);\n\t\t\tif (subrange) {\n\t\t\t\toffset = subrange.start;\n\t\t\t\tpos -= subrange.start;\n\t\t\t\tcontent = subrange.substring(content);\n\t\t\t}\n\n\t\t\tvar rules = this.findAllRules(content);\n\t\t\tvar ctxRule = this.matchEnclosingRule(rules, pos);\n\n\t\t\tif (ctxRule) {\n\t\t\t\treturn ctxRule.shift(offset);\n\t\t\t}\n\n\t\t\tfor (var i = 0, il = rules.length; i < il; i++) {\n\t\t\t\tif (rules[i].start > pos) {\n\t\t\t\t\treturn rules[isBackward && i > 0 ? i - 1 : i].shift(offset);\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\n\t\t/**\n\t\t * Sanitizes given CSS content: replaces content that may \n\t\t * interfere with parsing (comments, interpolations, etc.)\n\t\t * with spaces. Sanitized content MUST NOT be used for\n\t\t * editing or outputting, it just simplifies searching\n\t\t * @param  {String} content CSS content\n\t\t * @return {String}\n\t\t */\n\t\tsanitize: function(content) {\n\t\t\tcontent = commentsUtils.strip(content);\n\n\t\t\t// remove preprocessor string interpolations like #{var}\n\t\t\tvar stream = stringStream(content);\n\t\t\tvar replaceRanges = [];\n\t\t\tvar ch, ch2;\n\n\t\t\twhile ((ch = stream.next())) {\n\t\t\t\tif (isQuote(ch)) {\n\t\t\t\t\t// skip string\n\t\t\t\t\tstream.skipString(ch)\n\t\t\t\t\tcontinue;\n\t\t\t\t} else if (ch === '#' || ch === '@') {\n\t\t\t\t\tch2 = stream.peek();\n\t\t\t\t\tif (ch2 === '{') { // string interpolation\n\t\t\t\t\t\tstream.start = stream.pos - 1;\n\n\t\t\t\t\t\tif (stream.skipTo('}')) {\n\t\t\t\t\t\t\tstream.pos += 1;\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tthrow 'Invalid string interpolation at ' + stream.start;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\treplaceRanges.push([stream.start, stream.pos]);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn utils.replaceWith(content, replaceRanges, 'a');\n\t\t},\n\n\t\t/**\n\t\t * Parses and returns all sections in given CSS\n\t\t * as tree-like structure, e.g. provides nesting\n\t\t * info\n\t\t * @param  {String} content CSS content\n\t\t * @return {CSSSection}\n\t\t */\n\t\tsectionTree: function(content) {\n\t\t\tvar root = new CSSSection(null, content);\n\t\t\tvar rules = this.findAllRules(content);\n\n\t\t\t// rules are sorted in order they appear in CSS source\n\t\t\t// so we can optimize their nesting routine\n\t\t\tvar insert = function(range, ctx) {\n\t\t\t\twhile (ctx && ctx.range) {\n\t\t\t\t\tif (ctx.range.contains(range)) {\n\t\t\t\t\t\treturn ctx.addChild(range);\n\t\t\t\t\t}\n\n\t\t\t\t\tctx = ctx.parent;\n\t\t\t\t}\n\n\t\t\t\t// if we are here then given range is a top-level section\n\t\t\t\treturn root.addChild(range);\n\t\t\t};\n\n\t\t\tvar ctx = root;\n\t\t\trules.forEach(function(r) {\n\t\t\t\tctx = insert(r, ctx);\n\t\t\t});\n\n\t\t\treturn root;\n\t\t},\n\n\t\t/**\n\t\t * Returns ranges for all nested sections, available in\n\t\t * given CSS rule\n\t\t * @param  {CSSEditContainer} rule\n\t\t * @return {Array}\n\t\t */\n\t\tnestedSectionsInRule: function(rule) {\n\t\t\tvar offset = rule.valueRange(true).start;\n\t\t\tvar nestedSections = this.findAllRules(rule.valueRange().substring(rule.source));\n\t\t\tnestedSections.forEach(function(section) {\n\t\t\t\tsection.start += offset;\n\t\t\t\tsection.end += offset;\n\t\t\t\tsection._selectorEnd += offset;\n\t\t\t\tsection._contentStart += offset;\n\t\t\t});\n\t\t\treturn nestedSections;\n\t\t},\n\n\t\tstyleTagRange: function(content, pos) {\n\t\t\tvar tag = htmlMatcher.tag(content, pos);\n\t\t\treturn tag && tag.open.name.toLowerCase() == 'style' \n\t\t\t\t&& tag.innerRange.cmp(pos, 'lte', 'gte')\n\t\t\t\t&& tag.innerRange;\n\t\t},\n\n\t\tstyleAttrRange: function(content, pos) {\n\t\t\tvar tree = xmlEditTree.parseFromPosition(content, pos, true);\n\t\t\tif (tree) {\n\t\t\t\tvar attr = tree.itemFromPosition(pos, true);\n\t\t\t\treturn attr && attr.name().toLowerCase() == 'style' \n\t\t\t\t\t&& attr.valueRange(true).cmp(pos, 'lte', 'gte')\n\t\t\t\t\t&& attr.valueRange(true);\n\t\t\t}\n\t\t},\n\n\t\tCSSSection: CSSSection\n\t};\n});\n},{\"../assets/htmlMatcher\":\"assets\\\\htmlMatcher.js\",\"../assets/range\":\"assets\\\\range.js\",\"../assets/stringStream\":\"assets\\\\stringStream.js\",\"../editTree/xml\":\"editTree\\\\xml.js\",\"../parser/css\":\"parser\\\\css.js\",\"./comments\":\"utils\\\\comments.js\",\"./common\":\"utils\\\\common.js\"}],\"utils\\\\editor.js\":[function(require,module,exports){\n/**\n * Utility module used to prepare text for pasting into back-end editor\n * @author Sergey Chikuyonok (serge.che@gmail.com) <http://chikuyonok.ru>\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar utils = require('./common');\n\tvar resources = require('../assets/resources');\n\n\treturn  {\n\t\t/**\n\t\t * Check if cursor is placed inside XHTML tag\n\t\t * @param {String} html Contents of the document\n\t\t * @param {Number} caretPos Current caret position inside tag\n\t\t * @return {Boolean}\n\t\t */\n\t\tisInsideTag: function(html, caretPos) {\n\t\t\tvar reTag = /^<\\/?\\w[\\w\\:\\-]*.*?>/;\n\t\t\t\n\t\t\t// search left to find opening brace\n\t\t\tvar pos = caretPos;\n\t\t\twhile (pos > -1) {\n\t\t\t\tif (html.charAt(pos) == '<') \n\t\t\t\t\tbreak;\n\t\t\t\tpos--;\n\t\t\t}\n\t\t\t\n\t\t\tif (pos != -1) {\n\t\t\t\tvar m = reTag.exec(html.substring(pos));\n\t\t\t\tif (m && caretPos > pos && caretPos < pos + m[0].length)\n\t\t\t\t\treturn true;\n\t\t\t}\n\t\t\t\n\t\t\treturn false;\n\t\t},\n\t\t\n\t\t/**\n\t\t * Sanitizes incoming editor data and provides default values for\n\t\t * output-specific info\n\t\t * @param {IEmmetEditor} editor\n\t\t * @param {String} syntax\n\t\t * @param {String} profile\n\t\t */\n\t\toutputInfo: function(editor, syntax, profile) {\n\t\t\t// most of this code makes sense for Java/Rhino environment\n\t\t\t// because string that comes from Java are not actually JS string\n\t\t\t// but Java String object so the have to be explicitly converted\n\t\t\t// to native string\n\t\t\tprofile = profile || editor.getProfileName();\n\t\t\treturn  {\n\t\t\t\t/** @memberOf outputInfo */\n\t\t\t\tsyntax: String(syntax || editor.getSyntax()),\n\t\t\t\tprofile: profile || null,\n\t\t\t\tcontent: String(editor.getContent())\n\t\t\t};\n\t\t},\n\t\t\n\t\t/**\n\t\t * Unindent content, thus preparing text for tag wrapping\n\t\t * @param {IEmmetEditor} editor Editor instance\n\t\t * @param {String} text\n\t\t * @return {String}\n\t\t */\n\t\tunindent: function(editor, text) {\n\t\t\treturn utils.unindentString(text, this.getCurrentLinePadding(editor));\n\t\t},\n\t\t\n\t\t/**\n\t\t * Returns padding of current editor's line\n\t\t * @param {IEmmetEditor} Editor instance\n\t\t * @return {String}\n\t\t */\n\t\tgetCurrentLinePadding: function(editor) {\n\t\t\treturn utils.getLinePadding(editor.getCurrentLine());\n\t\t},\n\n\t\t/**\n\t\t * Normalizes content according to given preferences, e.g.\n\t\t * replaces newlines and indentation with ones defined in\n\t\t * `options`. If options are not provided or incomplete, \n\t\t * values will be taken from current user environment\n\t\t * @param {String} text\n\t\t * @param {Object} options\n\t\t * @return {String}\n\t\t */\n\t\tnormalize: function(text, options) {\n\t\t\toptions = utils.extend({\n\t\t\t\tnewline: resources.getNewline(),\n\t\t\t\tindentation: resources.getVariable('indentation')\n\t\t\t}, options);\n\n\t\t\tvar indent = function(tabs) {\n\t\t\t\treturn utils.repeatString(options.indentation, tabs.length);\n\t\t\t};\n\n\t\t\tvar lines = utils.splitByLines(text);\n\n\t\t\t// normailze indentation if it’s not tabs\n\t\t\tif (options.indentation !== '\\t') {\n\t\t\t\tlines = lines.map(function(line) {\n\t\t\t\t\treturn line.replace(/^\\s+/, function(space) {\n\t\t\t\t\t\treturn space.replace(/\\t/g, indent);\n\t\t\t\t\t});\n\t\t\t\t});\n\t\t\t}\n\n\t\t\t// normalize newlines\n\t\t\treturn lines.join(options.newline);\n\t\t}\n\t};\n});\n\n},{\"../assets/resources\":\"assets\\\\resources.js\",\"./common\":\"utils\\\\common.js\"}],\"utils\\\\math.js\":[function(require,module,exports){\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\t/*\n\t Source: https://github.com/silentmatt/js-expression-eval\n\n\t Based on ndef.parser, by Raphael Graf(r@undefined.ch)\n\t http://www.undefined.ch/mparser/index.html\n\n\t Ported to JavaScript and modified by Matthew Crumley (email@matthewcrumley.com, http://silentmatt.com/)\n\n\t You are free to use and modify this code in anyway you find useful. Please leave this comment in the code\n\t to acknowledge its original source. If you feel like it, I enjoy hearing about projects that use my code,\n\t but don't feel like you have to let me know or ask permission.\n\t*/\n\n\tfunction object(o) {\n\t\tfunction F() {}\n\t\tF.prototype = o;\n\t\treturn new F();\n\t}\n\n\tvar TNUMBER = 0;\n\tvar TOP1 = 1;\n\tvar TOP2 = 2;\n\tvar TVAR = 3;\n\tvar TFUNCALL = 4;\n\n\tfunction Token(type_, index_, prio_, number_) {\n\t\tthis.type_ = type_;\n\t\tthis.index_ = index_ || 0;\n\t\tthis.prio_ = prio_ || 0;\n\t\tthis.number_ = (number_ !== undefined && number_ !== null) ? number_ : 0;\n\t\tthis.toString = function () {\n\t\t\tswitch (this.type_) {\n\t\t\tcase TNUMBER:\n\t\t\t\treturn this.number_;\n\t\t\tcase TOP1:\n\t\t\tcase TOP2:\n\t\t\tcase TVAR:\n\t\t\t\treturn this.index_;\n\t\t\tcase TFUNCALL:\n\t\t\t\treturn \"CALL\";\n\t\t\tdefault:\n\t\t\t\treturn \"Invalid Token\";\n\t\t\t}\n\t\t};\n\t}\n\n\tfunction Expression(tokens, ops1, ops2, functions) {\n\t\tthis.tokens = tokens;\n\t\tthis.ops1 = ops1;\n\t\tthis.ops2 = ops2;\n\t\tthis.functions = functions;\n\t}\n\n\t// Based on http://www.json.org/json2.js\n    var cx = /[\\u0000\\u00ad\\u0600-\\u0604\\u070f\\u17b4\\u17b5\\u200c-\\u200f\\u2028-\\u202f\\u2060-\\u206f\\ufeff\\ufff0-\\uffff]/g,\n        escapable = /[\\\\\\'\\x00-\\x1f\\x7f-\\x9f\\u00ad\\u0600-\\u0604\\u070f\\u17b4\\u17b5\\u200c-\\u200f\\u2028-\\u202f\\u2060-\\u206f\\ufeff\\ufff0-\\uffff]/g,\n        meta = {    // table of character substitutions\n            '\\b': '\\\\b',\n            '\\t': '\\\\t',\n            '\\n': '\\\\n',\n            '\\f': '\\\\f',\n            '\\r': '\\\\r',\n            \"'\" : \"\\\\'\",\n            '\\\\': '\\\\\\\\'\n        };\n\n\tfunction escapeValue(v) {\n\t\tif (typeof v === \"string\") {\n\t\t\tescapable.lastIndex = 0;\n\t        return escapable.test(v) ?\n\t            \"'\" + v.replace(escapable, function (a) {\n\t                var c = meta[a];\n\t                return typeof c === 'string' ? c :\n\t                    '\\\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);\n\t            }) + \"'\" :\n\t            \"'\" + v + \"'\";\n\t\t}\n\t\treturn v;\n\t}\n\n\tExpression.prototype = {\n\t\tsimplify: function (values) {\n\t\t\tvalues = values || {};\n\t\t\tvar nstack = [];\n\t\t\tvar newexpression = [];\n\t\t\tvar n1;\n\t\t\tvar n2;\n\t\t\tvar f;\n\t\t\tvar L = this.tokens.length;\n\t\t\tvar item;\n\t\t\tvar i = 0;\n\t\t\tfor (i = 0; i < L; i++) {\n\t\t\t\titem = this.tokens[i];\n\t\t\t\tvar type_ = item.type_;\n\t\t\t\tif (type_ === TNUMBER) {\n\t\t\t\t\tnstack.push(item);\n\t\t\t\t}\n\t\t\t\telse if (type_ === TVAR && (item.index_ in values)) {\n\t\t\t\t\titem = new Token(TNUMBER, 0, 0, values[item.index_]);\n\t\t\t\t\tnstack.push(item);\n\t\t\t\t}\n\t\t\t\telse if (type_ === TOP2 && nstack.length > 1) {\n\t\t\t\t\tn2 = nstack.pop();\n\t\t\t\t\tn1 = nstack.pop();\n\t\t\t\t\tf = this.ops2[item.index_];\n\t\t\t\t\titem = new Token(TNUMBER, 0, 0, f(n1.number_, n2.number_));\n\t\t\t\t\tnstack.push(item);\n\t\t\t\t}\n\t\t\t\telse if (type_ === TOP1 && nstack.length > 0) {\n\t\t\t\t\tn1 = nstack.pop();\n\t\t\t\t\tf = this.ops1[item.index_];\n\t\t\t\t\titem = new Token(TNUMBER, 0, 0, f(n1.number_));\n\t\t\t\t\tnstack.push(item);\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\twhile (nstack.length > 0) {\n\t\t\t\t\t\tnewexpression.push(nstack.shift());\n\t\t\t\t\t}\n\t\t\t\t\tnewexpression.push(item);\n\t\t\t\t}\n\t\t\t}\n\t\t\twhile (nstack.length > 0) {\n\t\t\t\tnewexpression.push(nstack.shift());\n\t\t\t}\n\n\t\t\treturn new Expression(newexpression, object(this.ops1), object(this.ops2), object(this.functions));\n\t\t},\n\n\t\tsubstitute: function (variable, expr) {\n\t\t\tif (!(expr instanceof Expression)) {\n\t\t\t\texpr = new Parser().parse(String(expr));\n\t\t\t}\n\t\t\tvar newexpression = [];\n\t\t\tvar L = this.tokens.length;\n\t\t\tvar item;\n\t\t\tvar i = 0;\n\t\t\tfor (i = 0; i < L; i++) {\n\t\t\t\titem = this.tokens[i];\n\t\t\t\tvar type_ = item.type_;\n\t\t\t\tif (type_ === TVAR && item.index_ === variable) {\n\t\t\t\t\tfor (var j = 0; j < expr.tokens.length; j++) {\n\t\t\t\t\t\tvar expritem = expr.tokens[j];\n\t\t\t\t\t\tvar replitem = new Token(expritem.type_, expritem.index_, expritem.prio_, expritem.number_);\n\t\t\t\t\t\tnewexpression.push(replitem);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tnewexpression.push(item);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tvar ret = new Expression(newexpression, object(this.ops1), object(this.ops2), object(this.functions));\n\t\t\treturn ret;\n\t\t},\n\n\t\tevaluate: function (values) {\n\t\t\tvalues = values || {};\n\t\t\tvar nstack = [];\n\t\t\tvar n1;\n\t\t\tvar n2;\n\t\t\tvar f;\n\t\t\tvar L = this.tokens.length;\n\t\t\tvar item;\n\t\t\tvar i = 0;\n\t\t\tfor (i = 0; i < L; i++) {\n\t\t\t\titem = this.tokens[i];\n\t\t\t\tvar type_ = item.type_;\n\t\t\t\tif (type_ === TNUMBER) {\n\t\t\t\t\tnstack.push(item.number_);\n\t\t\t\t}\n\t\t\t\telse if (type_ === TOP2) {\n\t\t\t\t\tn2 = nstack.pop();\n\t\t\t\t\tn1 = nstack.pop();\n\t\t\t\t\tf = this.ops2[item.index_];\n\t\t\t\t\tnstack.push(f(n1, n2));\n\t\t\t\t}\n\t\t\t\telse if (type_ === TVAR) {\n\t\t\t\t\tif (item.index_ in values) {\n\t\t\t\t\t\tnstack.push(values[item.index_]);\n\t\t\t\t\t}\n\t\t\t\t\telse if (item.index_ in this.functions) {\n\t\t\t\t\t\tnstack.push(this.functions[item.index_]);\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\tthrow new Error(\"undefined variable: \" + item.index_);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\telse if (type_ === TOP1) {\n\t\t\t\t\tn1 = nstack.pop();\n\t\t\t\t\tf = this.ops1[item.index_];\n\t\t\t\t\tnstack.push(f(n1));\n\t\t\t\t}\n\t\t\t\telse if (type_ === TFUNCALL) {\n\t\t\t\t\tn1 = nstack.pop();\n\t\t\t\t\tf = nstack.pop();\n\t\t\t\t\tif (f.apply && f.call) {\n\t\t\t\t\t\tif (Object.prototype.toString.call(n1) == \"[object Array]\") {\n\t\t\t\t\t\t\tnstack.push(f.apply(undefined, n1));\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse {\n\t\t\t\t\t\t\tnstack.push(f.call(undefined, n1));\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\tthrow new Error(f + \" is not a function\");\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tthrow new Error(\"invalid Expression\");\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (nstack.length > 1) {\n\t\t\t\tthrow new Error(\"invalid Expression (parity)\");\n\t\t\t}\n\t\t\treturn nstack[0];\n\t\t},\n\n\t\ttoString: function (toJS) {\n\t\t\tvar nstack = [];\n\t\t\tvar n1;\n\t\t\tvar n2;\n\t\t\tvar f;\n\t\t\tvar L = this.tokens.length;\n\t\t\tvar item;\n\t\t\tvar i = 0;\n\t\t\tfor (i = 0; i < L; i++) {\n\t\t\t\titem = this.tokens[i];\n\t\t\t\tvar type_ = item.type_;\n\t\t\t\tif (type_ === TNUMBER) {\n\t\t\t\t\tnstack.push(escapeValue(item.number_));\n\t\t\t\t}\n\t\t\t\telse if (type_ === TOP2) {\n\t\t\t\t\tn2 = nstack.pop();\n\t\t\t\t\tn1 = nstack.pop();\n\t\t\t\t\tf = item.index_;\n\t\t\t\t\tif (toJS && f == \"^\") {\n\t\t\t\t\t\tnstack.push(\"Math.pow(\" + n1 + \",\" + n2 + \")\");\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\tnstack.push(\"(\" + n1 + f + n2 + \")\");\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\telse if (type_ === TVAR) {\n\t\t\t\t\tnstack.push(item.index_);\n\t\t\t\t}\n\t\t\t\telse if (type_ === TOP1) {\n\t\t\t\t\tn1 = nstack.pop();\n\t\t\t\t\tf = item.index_;\n\t\t\t\t\tif (f === \"-\") {\n\t\t\t\t\t\tnstack.push(\"(\" + f + n1 + \")\");\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\tnstack.push(f + \"(\" + n1 + \")\");\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\telse if (type_ === TFUNCALL) {\n\t\t\t\t\tn1 = nstack.pop();\n\t\t\t\t\tf = nstack.pop();\n\t\t\t\t\tnstack.push(f + \"(\" + n1 + \")\");\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tthrow new Error(\"invalid Expression\");\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (nstack.length > 1) {\n\t\t\t\tthrow new Error(\"invalid Expression (parity)\");\n\t\t\t}\n\t\t\treturn nstack[0];\n\t\t},\n\n\t\tvariables: function () {\n\t\t\tvar L = this.tokens.length;\n\t\t\tvar vars = [];\n\t\t\tfor (var i = 0; i < L; i++) {\n\t\t\t\tvar item = this.tokens[i];\n\t\t\t\tif (item.type_ === TVAR && (vars.indexOf(item.index_) == -1)) {\n\t\t\t\t\tvars.push(item.index_);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn vars;\n\t\t},\n\n\t\ttoJSFunction: function (param, variables) {\n\t\t\tvar f = new Function(param, \"with(Parser.values) { return \" + this.simplify(variables).toString(true) + \"; }\");\n\t\t\treturn f;\n\t\t}\n\t};\n\n\tfunction add(a, b) {\n\t\treturn Number(a) + Number(b);\n\t}\n\tfunction sub(a, b) {\n\t\treturn a - b; \n\t}\n\tfunction mul(a, b) {\n\t\treturn a * b;\n\t}\n\tfunction div(a, b) {\n\t\treturn a / b;\n\t}\n\tfunction mod(a, b) {\n\t\treturn a % b;\n\t}\n\tfunction concat(a, b) {\n\t\treturn \"\" + a + b;\n\t}\n\n\tfunction neg(a) {\n\t\treturn -a;\n\t}\n\n\tfunction random(a) {\n\t\treturn Math.random() * (a || 1);\n\t}\n\tfunction fac(a) { //a!\n\t\ta = Math.floor(a);\n\t\tvar b = a;\n\t\twhile (a > 1) {\n\t\t\tb = b * (--a);\n\t\t}\n\t\treturn b;\n\t}\n\n\t// TODO: use hypot that doesn't overflow\n\tfunction pyt(a, b) {\n\t\treturn Math.sqrt(a * a + b * b);\n\t}\n\n\tfunction append(a, b) {\n\t\tif (Object.prototype.toString.call(a) != \"[object Array]\") {\n\t\t\treturn [a, b];\n\t\t}\n\t\ta = a.slice();\n\t\ta.push(b);\n\t\treturn a;\n\t}\n\n\tfunction Parser() {\n\t\tthis.success = false;\n\t\tthis.errormsg = \"\";\n\t\tthis.expression = \"\";\n\n\t\tthis.pos = 0;\n\n\t\tthis.tokennumber = 0;\n\t\tthis.tokenprio = 0;\n\t\tthis.tokenindex = 0;\n\t\tthis.tmpprio = 0;\n\n\t\tthis.ops1 = {\n\t\t\t\"sin\": Math.sin,\n\t\t\t\"cos\": Math.cos,\n\t\t\t\"tan\": Math.tan,\n\t\t\t\"asin\": Math.asin,\n\t\t\t\"acos\": Math.acos,\n\t\t\t\"atan\": Math.atan,\n\t\t\t\"sqrt\": Math.sqrt,\n\t\t\t\"log\": Math.log,\n\t\t\t\"abs\": Math.abs,\n\t\t\t\"ceil\": Math.ceil,\n\t\t\t\"floor\": Math.floor,\n\t\t\t\"round\": Math.round,\n\t\t\t\"-\": neg,\n\t\t\t\"exp\": Math.exp\n\t\t};\n\n\t\tthis.ops2 = {\n\t\t\t\"+\": add,\n\t\t\t\"-\": sub,\n\t\t\t\"*\": mul,\n\t\t\t\"/\": div,\n\t\t\t\"%\": mod,\n\t\t\t\"^\": Math.pow,\n\t\t\t\",\": append,\n\t\t\t\"||\": concat\n\t\t};\n\n\t\tthis.functions = {\n\t\t\t\"random\": random,\n\t\t\t\"fac\": fac,\n\t\t\t\"min\": Math.min,\n\t\t\t\"max\": Math.max,\n\t\t\t\"pyt\": pyt,\n\t\t\t\"pow\": Math.pow,\n\t\t\t\"atan2\": Math.atan2\n\t\t};\n\n\t\tthis.consts = {\n\t\t\t\"E\": Math.E,\n\t\t\t\"PI\": Math.PI\n\t\t};\n\t}\n\n\tParser.parse = function (expr) {\n\t\treturn new Parser().parse(expr);\n\t};\n\n\tParser.evaluate = function (expr, variables) {\n\t\treturn Parser.parse(expr).evaluate(variables);\n\t};\n\n\tParser.Expression = Expression;\n\n\tParser.values = {\n\t\tsin: Math.sin,\n\t\tcos: Math.cos,\n\t\ttan: Math.tan,\n\t\tasin: Math.asin,\n\t\tacos: Math.acos,\n\t\tatan: Math.atan,\n\t\tsqrt: Math.sqrt,\n\t\tlog: Math.log,\n\t\tabs: Math.abs,\n\t\tceil: Math.ceil,\n\t\tfloor: Math.floor,\n\t\tround: Math.round,\n\t\trandom: random,\n\t\tfac: fac,\n\t\texp: Math.exp,\n\t\tmin: Math.min,\n\t\tmax: Math.max,\n\t\tpyt: pyt,\n\t\tpow: Math.pow,\n\t\tatan2: Math.atan2,\n\t\tE: Math.E,\n\t\tPI: Math.PI\n\t};\n\n\tvar PRIMARY      = 1 << 0;\n\tvar OPERATOR     = 1 << 1;\n\tvar FUNCTION     = 1 << 2;\n\tvar LPAREN       = 1 << 3;\n\tvar RPAREN       = 1 << 4;\n\tvar COMMA        = 1 << 5;\n\tvar SIGN         = 1 << 6;\n\tvar CALL         = 1 << 7;\n\tvar NULLARY_CALL = 1 << 8;\n\n\tParser.prototype = {\n\t\tparse: function (expr) {\n\t\t\tthis.errormsg = \"\";\n\t\t\tthis.success = true;\n\t\t\tvar operstack = [];\n\t\t\tvar tokenstack = [];\n\t\t\tthis.tmpprio = 0;\n\t\t\tvar expected = (PRIMARY | LPAREN | FUNCTION | SIGN);\n\t\t\tvar noperators = 0;\n\t\t\tthis.expression = expr;\n\t\t\tthis.pos = 0;\n\n\t\t\twhile (this.pos < this.expression.length) {\n\t\t\t\tif (this.isOperator()) {\n\t\t\t\t\tif (this.isSign() && (expected & SIGN)) {\n\t\t\t\t\t\tif (this.isNegativeSign()) {\n\t\t\t\t\t\t\tthis.tokenprio = 2;\n\t\t\t\t\t\t\tthis.tokenindex = \"-\";\n\t\t\t\t\t\t\tnoperators++;\n\t\t\t\t\t\t\tthis.addfunc(tokenstack, operstack, TOP1);\n\t\t\t\t\t\t}\n\t\t\t\t\t\texpected = (PRIMARY | LPAREN | FUNCTION | SIGN);\n\t\t\t\t\t}\n\t\t\t\t\telse if (this.isComment()) {\n\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\tif ((expected & OPERATOR) === 0) {\n\t\t\t\t\t\t\tthis.error_parsing(this.pos, \"unexpected operator\");\n\t\t\t\t\t\t}\n\t\t\t\t\t\tnoperators += 2;\n\t\t\t\t\t\tthis.addfunc(tokenstack, operstack, TOP2);\n\t\t\t\t\t\texpected = (PRIMARY | LPAREN | FUNCTION | SIGN);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\telse if (this.isNumber()) {\n\t\t\t\t\tif ((expected & PRIMARY) === 0) {\n\t\t\t\t\t\tthis.error_parsing(this.pos, \"unexpected number\");\n\t\t\t\t\t}\n\t\t\t\t\tvar token = new Token(TNUMBER, 0, 0, this.tokennumber);\n\t\t\t\t\ttokenstack.push(token);\n\n\t\t\t\t\texpected = (OPERATOR | RPAREN | COMMA);\n\t\t\t\t}\n\t\t\t\telse if (this.isString()) {\n\t\t\t\t\tif ((expected & PRIMARY) === 0) {\n\t\t\t\t\t\tthis.error_parsing(this.pos, \"unexpected string\");\n\t\t\t\t\t}\n\t\t\t\t\tvar token = new Token(TNUMBER, 0, 0, this.tokennumber);\n\t\t\t\t\ttokenstack.push(token);\n\n\t\t\t\t\texpected = (OPERATOR | RPAREN | COMMA);\n\t\t\t\t}\n\t\t\t\telse if (this.isLeftParenth()) {\n\t\t\t\t\tif ((expected & LPAREN) === 0) {\n\t\t\t\t\t\tthis.error_parsing(this.pos, \"unexpected \\\"(\\\"\");\n\t\t\t\t\t}\n\n\t\t\t\t\tif (expected & CALL) {\n\t\t\t\t\t\tnoperators += 2;\n\t\t\t\t\t\tthis.tokenprio = -2;\n\t\t\t\t\t\tthis.tokenindex = -1;\n\t\t\t\t\t\tthis.addfunc(tokenstack, operstack, TFUNCALL);\n\t\t\t\t\t}\n\n\t\t\t\t\texpected = (PRIMARY | LPAREN | FUNCTION | SIGN | NULLARY_CALL);\n\t\t\t\t}\n\t\t\t\telse if (this.isRightParenth()) {\n\t\t\t\t    if (expected & NULLARY_CALL) {\n\t\t\t\t\t\tvar token = new Token(TNUMBER, 0, 0, []);\n\t\t\t\t\t\ttokenstack.push(token);\n\t\t\t\t\t}\n\t\t\t\t\telse if ((expected & RPAREN) === 0) {\n\t\t\t\t\t\tthis.error_parsing(this.pos, \"unexpected \\\")\\\"\");\n\t\t\t\t\t}\n\n\t\t\t\t\texpected = (OPERATOR | RPAREN | COMMA | LPAREN | CALL);\n\t\t\t\t}\n\t\t\t\telse if (this.isComma()) {\n\t\t\t\t\tif ((expected & COMMA) === 0) {\n\t\t\t\t\t\tthis.error_parsing(this.pos, \"unexpected \\\",\\\"\");\n\t\t\t\t\t}\n\t\t\t\t\tthis.addfunc(tokenstack, operstack, TOP2);\n\t\t\t\t\tnoperators += 2;\n\t\t\t\t\texpected = (PRIMARY | LPAREN | FUNCTION | SIGN);\n\t\t\t\t}\n\t\t\t\telse if (this.isConst()) {\n\t\t\t\t\tif ((expected & PRIMARY) === 0) {\n\t\t\t\t\t\tthis.error_parsing(this.pos, \"unexpected constant\");\n\t\t\t\t\t}\n\t\t\t\t\tvar consttoken = new Token(TNUMBER, 0, 0, this.tokennumber);\n\t\t\t\t\ttokenstack.push(consttoken);\n\t\t\t\t\texpected = (OPERATOR | RPAREN | COMMA);\n\t\t\t\t}\n\t\t\t\telse if (this.isOp2()) {\n\t\t\t\t\tif ((expected & FUNCTION) === 0) {\n\t\t\t\t\t\tthis.error_parsing(this.pos, \"unexpected function\");\n\t\t\t\t\t}\n\t\t\t\t\tthis.addfunc(tokenstack, operstack, TOP2);\n\t\t\t\t\tnoperators += 2;\n\t\t\t\t\texpected = (LPAREN);\n\t\t\t\t}\n\t\t\t\telse if (this.isOp1()) {\n\t\t\t\t\tif ((expected & FUNCTION) === 0) {\n\t\t\t\t\t\tthis.error_parsing(this.pos, \"unexpected function\");\n\t\t\t\t\t}\n\t\t\t\t\tthis.addfunc(tokenstack, operstack, TOP1);\n\t\t\t\t\tnoperators++;\n\t\t\t\t\texpected = (LPAREN);\n\t\t\t\t}\n\t\t\t\telse if (this.isVar()) {\n\t\t\t\t\tif ((expected & PRIMARY) === 0) {\n\t\t\t\t\t\tthis.error_parsing(this.pos, \"unexpected variable\");\n\t\t\t\t\t}\n\t\t\t\t\tvar vartoken = new Token(TVAR, this.tokenindex, 0, 0);\n\t\t\t\t\ttokenstack.push(vartoken);\n\n\t\t\t\t\texpected = (OPERATOR | RPAREN | COMMA | LPAREN | CALL);\n\t\t\t\t}\n\t\t\t\telse if (this.isWhite()) {\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tif (this.errormsg === \"\") {\n\t\t\t\t\t\tthis.error_parsing(this.pos, \"unknown character\");\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\tthis.error_parsing(this.pos, this.errormsg);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (this.tmpprio < 0 || this.tmpprio >= 10) {\n\t\t\t\tthis.error_parsing(this.pos, \"unmatched \\\"()\\\"\");\n\t\t\t}\n\t\t\twhile (operstack.length > 0) {\n\t\t\t\tvar tmp = operstack.pop();\n\t\t\t\ttokenstack.push(tmp);\n\t\t\t}\n\t\t\tif (noperators + 1 !== tokenstack.length) {\n\t\t\t\t//print(noperators + 1);\n\t\t\t\t//print(tokenstack);\n\t\t\t\tthis.error_parsing(this.pos, \"parity\");\n\t\t\t}\n\n\t\t\treturn new Expression(tokenstack, object(this.ops1), object(this.ops2), object(this.functions));\n\t\t},\n\n\t\tevaluate: function (expr, variables) {\n\t\t\treturn this.parse(expr).evaluate(variables);\n\t\t},\n\n\t\terror_parsing: function (column, msg) {\n\t\t\tthis.success = false;\n\t\t\tthis.errormsg = \"parse error [column \" + (column) + \"]: \" + msg;\n\t\t\tthrow new Error(this.errormsg);\n\t\t},\n\n//\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\/\\\n\n\t\taddfunc: function (tokenstack, operstack, type_) {\n\t\t\tvar operator = new Token(type_, this.tokenindex, this.tokenprio + this.tmpprio, 0);\n\t\t\twhile (operstack.length > 0) {\n\t\t\t\tif (operator.prio_ <= operstack[operstack.length - 1].prio_) {\n\t\t\t\t\ttokenstack.push(operstack.pop());\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\toperstack.push(operator);\n\t\t},\n\n\t\tisNumber: function () {\n\t\t\tvar r = false;\n\t\t\tvar str = \"\";\n\t\t\twhile (this.pos < this.expression.length) {\n\t\t\t\tvar code = this.expression.charCodeAt(this.pos);\n\t\t\t\tif ((code >= 48 && code <= 57) || code === 46) {\n\t\t\t\t\tstr += this.expression.charAt(this.pos);\n\t\t\t\t\tthis.pos++;\n\t\t\t\t\tthis.tokennumber = parseFloat(str);\n\t\t\t\t\tr = true;\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn r;\n\t\t},\n\n\t\t// Ported from the yajjl JSON parser at http://code.google.com/p/yajjl/\n\t\tunescape: function(v, pos) {\n\t\t\tvar buffer = [];\n\t\t\tvar escaping = false;\n\n\t\t\tfor (var i = 0; i < v.length; i++) {\n\t\t\t\tvar c = v.charAt(i);\n\t\n\t\t\t\tif (escaping) {\n\t\t\t\t\tswitch (c) {\n\t\t\t\t\tcase \"'\":\n\t\t\t\t\t\tbuffer.push(\"'\");\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase '\\\\':\n\t\t\t\t\t\tbuffer.push('\\\\');\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase '/':\n\t\t\t\t\t\tbuffer.push('/');\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase 'b':\n\t\t\t\t\t\tbuffer.push('\\b');\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase 'f':\n\t\t\t\t\t\tbuffer.push('\\f');\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase 'n':\n\t\t\t\t\t\tbuffer.push('\\n');\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase 'r':\n\t\t\t\t\t\tbuffer.push('\\r');\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase 't':\n\t\t\t\t\t\tbuffer.push('\\t');\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase 'u':\n\t\t\t\t\t\t// interpret the following 4 characters as the hex of the unicode code point\n\t\t\t\t\t\tvar codePoint = parseInt(v.substring(i + 1, i + 5), 16);\n\t\t\t\t\t\tbuffer.push(String.fromCharCode(codePoint));\n\t\t\t\t\t\ti += 4;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tdefault:\n\t\t\t\t\t\tthrow this.error_parsing(pos + i, \"Illegal escape sequence: '\\\\\" + c + \"'\");\n\t\t\t\t\t}\n\t\t\t\t\tescaping = false;\n\t\t\t\t} else {\n\t\t\t\t\tif (c == '\\\\') {\n\t\t\t\t\t\tescaping = true;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tbuffer.push(c);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\n\t\t\treturn buffer.join('');\n\t\t},\n\n\t\tisString: function () {\n\t\t\tvar r = false;\n\t\t\tvar str = \"\";\n\t\t\tvar startpos = this.pos;\n\t\t\tif (this.pos < this.expression.length && this.expression.charAt(this.pos) == \"'\") {\n\t\t\t\tthis.pos++;\n\t\t\t\twhile (this.pos < this.expression.length) {\n\t\t\t\t\tvar code = this.expression.charAt(this.pos);\n\t\t\t\t\tif (code != \"'\" || str.slice(-1) == \"\\\\\") {\n\t\t\t\t\t\tstr += this.expression.charAt(this.pos);\n\t\t\t\t\t\tthis.pos++;\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\tthis.pos++;\n\t\t\t\t\t\tthis.tokennumber = this.unescape(str, startpos);\n\t\t\t\t\t\tr = true;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn r;\n\t\t},\n\n\t\tisConst: function () {\n\t\t\tvar str;\n\t\t\tfor (var i in this.consts) {\n\t\t\t\tif (true) {\n\t\t\t\t\tvar L = i.length;\n\t\t\t\t\tstr = this.expression.substr(this.pos, L);\n\t\t\t\t\tif (i === str) {\n\t\t\t\t\t\tthis.tokennumber = this.consts[i];\n\t\t\t\t\t\tthis.pos += L;\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn false;\n\t\t},\n\n\t\tisOperator: function () {\n\t\t\tvar code = this.expression.charCodeAt(this.pos);\n\t\t\tif (code === 43) { // +\n\t\t\t\tthis.tokenprio = 0;\n\t\t\t\tthis.tokenindex = \"+\";\n\t\t\t}\n\t\t\telse if (code === 45) { // -\n\t\t\t\tthis.tokenprio = 0;\n\t\t\t\tthis.tokenindex = \"-\";\n\t\t\t}\n\t\t\telse if (code === 124) { // |\n\t\t\t\tif (this.expression.charCodeAt(this.pos + 1) === 124) {\n\t\t\t\t\tthis.pos++;\n\t\t\t\t\tthis.tokenprio = 0;\n\t\t\t\t\tthis.tokenindex = \"||\";\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t\telse if (code === 42) { // *\n\t\t\t\tthis.tokenprio = 1;\n\t\t\t\tthis.tokenindex = \"*\";\n\t\t\t}\n\t\t\telse if (code === 47) { // /\n\t\t\t\tthis.tokenprio = 2;\n\t\t\t\tthis.tokenindex = \"/\";\n\t\t\t}\n\t\t\telse if (code === 37) { // %\n\t\t\t\tthis.tokenprio = 2;\n\t\t\t\tthis.tokenindex = \"%\";\n\t\t\t}\n\t\t\telse if (code === 94) { // ^\n\t\t\t\tthis.tokenprio = 3;\n\t\t\t\tthis.tokenindex = \"^\";\n\t\t\t}\n\t\t\telse {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t\tthis.pos++;\n\t\t\treturn true;\n\t\t},\n\n\t\tisSign: function () {\n\t\t\tvar code = this.expression.charCodeAt(this.pos - 1);\n\t\t\tif (code === 45 || code === 43) { // -\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\treturn false;\n\t\t},\n\n\t\tisPositiveSign: function () {\n\t\t\tvar code = this.expression.charCodeAt(this.pos - 1);\n\t\t\tif (code === 43) { // -\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\treturn false;\n\t\t},\n\n\t\tisNegativeSign: function () {\n\t\t\tvar code = this.expression.charCodeAt(this.pos - 1);\n\t\t\tif (code === 45) { // -\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\treturn false;\n\t\t},\n\n\t\tisLeftParenth: function () {\n\t\t\tvar code = this.expression.charCodeAt(this.pos);\n\t\t\tif (code === 40) { // (\n\t\t\t\tthis.pos++;\n\t\t\t\tthis.tmpprio += 10;\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\treturn false;\n\t\t},\n\n\t\tisRightParenth: function () {\n\t\t\tvar code = this.expression.charCodeAt(this.pos);\n\t\t\tif (code === 41) { // )\n\t\t\t\tthis.pos++;\n\t\t\t\tthis.tmpprio -= 10;\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\treturn false;\n\t\t},\n\n\t\tisComma: function () {\n\t\t\tvar code = this.expression.charCodeAt(this.pos);\n\t\t\tif (code === 44) { // ,\n\t\t\t\tthis.pos++;\n\t\t\t\tthis.tokenprio = -1;\n\t\t\t\tthis.tokenindex = \",\";\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\treturn false;\n\t\t},\n\n\t\tisWhite: function () {\n\t\t\tvar code = this.expression.charCodeAt(this.pos);\n\t\t\tif (code === 32 || code === 9 || code === 10 || code === 13) {\n\t\t\t\tthis.pos++;\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\treturn false;\n\t\t},\n\n\t\tisOp1: function () {\n\t\t\tvar str = \"\";\n\t\t\tfor (var i = this.pos; i < this.expression.length; i++) {\n\t\t\t\tvar c = this.expression.charAt(i);\n\t\t\t\tif (c.toUpperCase() === c.toLowerCase()) {\n\t\t\t\t\tif (i === this.pos || (c != '_' && (c < '0' || c > '9'))) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tstr += c;\n\t\t\t}\n\t\t\tif (str.length > 0 && (str in this.ops1)) {\n\t\t\t\tthis.tokenindex = str;\n\t\t\t\tthis.tokenprio = 5;\n\t\t\t\tthis.pos += str.length;\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\treturn false;\n\t\t},\n\n\t\tisOp2: function () {\n\t\t\tvar str = \"\";\n\t\t\tfor (var i = this.pos; i < this.expression.length; i++) {\n\t\t\t\tvar c = this.expression.charAt(i);\n\t\t\t\tif (c.toUpperCase() === c.toLowerCase()) {\n\t\t\t\t\tif (i === this.pos || (c != '_' && (c < '0' || c > '9'))) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tstr += c;\n\t\t\t}\n\t\t\tif (str.length > 0 && (str in this.ops2)) {\n\t\t\t\tthis.tokenindex = str;\n\t\t\t\tthis.tokenprio = 5;\n\t\t\t\tthis.pos += str.length;\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\treturn false;\n\t\t},\n\n\t\tisVar: function () {\n\t\t\tvar str = \"\";\n\t\t\tfor (var i = this.pos; i < this.expression.length; i++) {\n\t\t\t\tvar c = this.expression.charAt(i);\n\t\t\t\tif (c.toUpperCase() === c.toLowerCase()) {\n\t\t\t\t\tif (i === this.pos || (c != '_' && (c < '0' || c > '9'))) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tstr += c;\n\t\t\t}\n\t\t\tif (str.length > 0) {\n\t\t\t\tthis.tokenindex = str;\n\t\t\t\tthis.tokenprio = 4;\n\t\t\t\tthis.pos += str.length;\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\treturn false;\n\t\t},\n\n\t\tisComment: function () {\n\t\t\tvar code = this.expression.charCodeAt(this.pos - 1);\n\t\t\tif (code === 47 && this.expression.charCodeAt(this.pos) === 42) {\n\t\t\t\tthis.pos = this.expression.indexOf(\"*/\", this.pos) + 2;\n\t\t\t\tif (this.pos === 1) {\n\t\t\t\t\tthis.pos = this.expression.length;\n\t\t\t\t}\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\treturn false;\n\t\t}\n\t};\n\n\treturn Parser;\n});\n},{}],\"utils\\\\template.js\":[function(require,module,exports){\n/**\n * A very simple, ERB-style templating. Basically, just as string substitution.\n * The reason to not use default Lo-dash’es `_.template()` implementation\n * is because it fails to run in CSP-enabled environments (Chrome extension, Atom)\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar stringStream = require('../assets/stringStream');\n\tvar utils = require('./common');\n\n\tfunction parseArgs(str) {\n\t\tvar args = [];\n\t\tvar stream = stringStream(str);\n\n\t\twhile (!stream.eol()) {\n\t\t\tif (stream.peek() == ',') {\n\t\t\t\targs.push(utils.trim(stream.current()));\n\t\t\t\tstream.next();\n\t\t\t\tstream.start = stream.pos;\n\t\t\t}\n\t\t\tstream.next();\n\t\t}\n\n\t\targs.push(utils.trim(stream.current()));\n\t\treturn args.filter(function(a) {\n\t\t\treturn !!a;\n\t\t});\n\t}\n\n\tfunction parseFunctionCall(str) {\n\t\tvar fnName = null, args;\n\t\tvar stream = stringStream(str);\n\t\twhile (!stream.eol()) {\n\t\t\tif (stream.peek() == '(') {\n\t\t\t\tfnName = stream.current();\n\t\t\t\tstream.start = stream.pos;\n\t\t\t\tstream.skipToPair('(', ')', true);\n\t\t\t\targs = stream.current();\n\t\t\t\targs = parseArgs(args.substring(1, args.length - 1));\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tstream.next();\n\t\t}\n\n\t\treturn fnName && {\n\t\t\tname: fnName,\n\t\t\targs: args\n\t\t};\n\t}\n\n\tfunction evalArg(arg, context) {\n\t\tif (/^['\"]/.test(arg)) {\n\t\t\t// plain string\n\t\t\treturn arg.replace(/^(['\"])(.+?)\\1$/, '$2');\n\t\t}\n\n\t\tif (!isNaN(+arg)) {\n\t\t\t// a number\n\t\t\treturn +arg;\n\t\t}\n\n\t\t// otherwise, treat argument as a property name\n\t\tif (arg) {\n\t\t\tvar parts = arg.split('.');\n\t\t\tvar prop = context;\n\t\t\twhile (parts.length) {\n\t\t\t\tprop = prop[parts.shift()];\n\t\t\t}\n\n\t\t\treturn prop;\n\t\t}\n\t}\n\n\tfunction process(template, context) {\n\t\treturn template.replace(/<%[=\\-](.+?)%>/g, function(str, match) {\n\t\t\tmatch = utils.trim(match);\n\t\t\tvar fn = parseFunctionCall(match);\n\t\t\tif (fn) {\n\t\t\t\tvar fnArgs = fn.args.map(function(arg) {\n\t\t\t\t\treturn evalArg(arg, context);\n\t\t\t\t});\n\t\t\t\treturn context[fn.name].apply(context, fnArgs);\n\t\t\t}\n\n\t\t\treturn evalArg(match, context);\n\t\t});\n\t}\n\n\treturn function(template, context) {\n\t\treturn context ? process(template, context) : function(context) {\n\t\t\treturn process(template, context);\n\t\t};\n\t};\n});\n},{\"../assets/stringStream\":\"assets\\\\stringStream.js\",\"./common\":\"utils\\\\common.js\"}],\"vendor\\\\klass.js\":[function(require,module,exports){\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\tvar utils = require('../utils/common');\n\n\t/**\n\t * Shared empty constructor function to aid in prototype-chain creation.\n\t */\n\tvar ctor = function(){};\n\n\t/**\n\t * Helper function to correctly set up the prototype chain, for subclasses.\n\t * Similar to `goog.inherits`, but uses a hash of prototype properties and\n\t * class properties to be extended.\n\t * Took it from Backbone.\n\t * @param {Object} parent\n\t * @param {Object} protoProps\n\t * @param {Object} staticProps\n\t * @returns {Object}\n\t */\n\tfunction inherits(parent, protoProps, staticProps) {\n\t\tvar child;\n\n\t\t// The constructor function for the new subclass is either defined by\n\t\t// you (the \"constructor\" property in your `extend` definition), or\n\t\t// defaulted by us to simply call the parent's constructor.\n\t\tif (protoProps && protoProps.hasOwnProperty('constructor')) {\n\t\t\tchild = protoProps.constructor;\n\t\t} else {\n\t\t\tchild = function() {\n\t\t\t\tparent.apply(this, arguments);\n\t\t\t};\n\t\t}\n\n\t\t// Inherit class (static) properties from parent.\n\t\tutils.extend(child, parent);\n\n\t\t// Set the prototype chain to inherit from `parent`, without calling\n\t\t// `parent`'s constructor function.\n\t\tctor.prototype = parent.prototype;\n\t\tchild.prototype = new ctor();\n\n\t\t// Add prototype properties (instance properties) to the subclass,\n\t\t// if supplied.\n\t\tif (protoProps)\n\t\t\tutils.extend(child.prototype, protoProps);\n\n\t\t// Add static properties to the constructor function, if supplied.\n\t\tif (staticProps)\n\t\t\tutils.extend(child, staticProps);\n\n\t\t// Correctly set child's `prototype.constructor`.\n\t\tchild.prototype.constructor = child;\n\n\t\t// Set a convenience property in case the parent's prototype is needed\n\t\t// later.\n\t\tchild.__super__ = parent.prototype;\n\n\t\treturn child;\n\t}\n\n\treturn {\n\t\t/**\n\t\t * The self-propagating extend function for classes.\n\t\t * Took it from Backbone \n\t\t * @param {Object} protoProps\n\t\t * @param {Object} classProps\n\t\t * @returns {Object}\n\t\t */\n\t\textend: function(protoProps, classProps) {\n\t\t\tvar child = inherits(this, protoProps, classProps);\n\t\t\tchild.extend = this.extend;\n\t\t\t// a hack required to WSH inherit `toString` method\n\t\t\tif (protoProps.hasOwnProperty('toString'))\n\t\t\t\tchild.prototype.toString = protoProps.toString;\n\t\t\treturn child;\n\t\t}\n\t};\n});\n},{\"../utils/common\":\"utils\\\\common.js\"}],\"vendor\\\\stringScore.js\":[function(require,module,exports){\n/*!\n * string_score.js: String Scoring Algorithm 0.1.10 \n *\n * http://joshaven.com/string_score\n * https://github.com/joshaven/string_score\n *\n * Copyright (C) 2009-2011 Joshaven Potter <yourtech@gmail.com>\n * Special thanks to all of the contributors listed here https://github.com/joshaven/string_score\n * MIT license: http://www.opensource.org/licenses/mit-license.php\n *\n * Date: Tue Mar 1 2011\n*/\n\n/**\n * Scores a string against another string.\n *  'Hello World'.score('he');     //=> 0.5931818181818181\n *  'Hello World'.score('Hello');  //=> 0.7318181818181818\n */\nif (typeof module === 'object' && typeof define !== 'function') {\n\tvar define = function (factory) {\n\t\tmodule.exports = factory(require, exports, module);\n\t};\n}\n\ndefine(function(require, exports, module) {\n\treturn {\n\t\tscore: function(string, abbreviation, fuzziness) {\n\t\t\t// If the string is equal to the abbreviation, perfect match.\n\t\t\t  if (string == abbreviation) {return 1;}\n\t\t\t  //if it's not a perfect match and is empty return 0\n\t\t\t  if(abbreviation == \"\") {return 0;}\n\n\t\t\t  var total_character_score = 0,\n\t\t\t      abbreviation_length = abbreviation.length,\n\t\t\t      string_length = string.length,\n\t\t\t      start_of_string_bonus,\n\t\t\t      abbreviation_score,\n\t\t\t      fuzzies=1,\n\t\t\t      final_score;\n\t\t\t  \n\t\t\t  // Walk through abbreviation and add up scores.\n\t\t\t  for (var i = 0,\n\t\t\t         character_score/* = 0*/,\n\t\t\t         index_in_string/* = 0*/,\n\t\t\t         c/* = ''*/,\n\t\t\t         index_c_lowercase/* = 0*/,\n\t\t\t         index_c_uppercase/* = 0*/,\n\t\t\t         min_index/* = 0*/;\n\t\t\t     i < abbreviation_length;\n\t\t\t     ++i) {\n\t\t\t    \n\t\t\t    // Find the first case-insensitive match of a character.\n\t\t\t    c = abbreviation.charAt(i);\n\t\t\t    \n\t\t\t    index_c_lowercase = string.indexOf(c.toLowerCase());\n\t\t\t    index_c_uppercase = string.indexOf(c.toUpperCase());\n\t\t\t    min_index = Math.min(index_c_lowercase, index_c_uppercase);\n\t\t\t    index_in_string = (min_index > -1) ? min_index : Math.max(index_c_lowercase, index_c_uppercase);\n\t\t\t    \n\t\t\t    if (index_in_string === -1) { \n\t\t\t      if (fuzziness) {\n\t\t\t        fuzzies += 1-fuzziness;\n\t\t\t        continue;\n\t\t\t      } else {\n\t\t\t        return 0;\n\t\t\t      }\n\t\t\t    } else {\n\t\t\t      character_score = 0.1;\n\t\t\t    }\n\t\t\t    \n\t\t\t    // Set base score for matching 'c'.\n\t\t\t    \n\t\t\t    // Same case bonus.\n\t\t\t    if (string[index_in_string] === c) { \n\t\t\t      character_score += 0.1; \n\t\t\t    }\n\t\t\t    \n\t\t\t    // Consecutive letter & start-of-string Bonus\n\t\t\t    if (index_in_string === 0) {\n\t\t\t      // Increase the score when matching first character of the remainder of the string\n\t\t\t      character_score += 0.6;\n\t\t\t      if (i === 0) {\n\t\t\t        // If match is the first character of the string\n\t\t\t        // & the first character of abbreviation, add a\n\t\t\t        // start-of-string match bonus.\n\t\t\t        start_of_string_bonus = 1; //true;\n\t\t\t      }\n\t\t\t    }\n\t\t\t    else {\n\t\t\t  // Acronym Bonus\n\t\t\t  // Weighing Logic: Typing the first character of an acronym is as if you\n\t\t\t  // preceded it with two perfect character matches.\n\t\t\t  if (string.charAt(index_in_string - 1) === ' ') {\n\t\t\t    character_score += 0.8; // * Math.min(index_in_string, 5); // Cap bonus at 0.4 * 5\n\t\t\t  }\n\t\t\t    }\n\t\t\t    \n\t\t\t    // Left trim the already matched part of the string\n\t\t\t    // (forces sequential matching).\n\t\t\t    string = string.substring(index_in_string + 1, string_length);\n\t\t\t    \n\t\t\t    total_character_score += character_score;\n\t\t\t  } // end of for loop\n\t\t\t  \n\t\t\t  // Uncomment to weigh smaller words higher.\n\t\t\t  // return total_character_score / string_length;\n\t\t\t  \n\t\t\t  abbreviation_score = total_character_score / abbreviation_length;\n\t\t\t  //percentage_of_matched_string = abbreviation_length / string_length;\n\t\t\t  //word_score = abbreviation_score * percentage_of_matched_string;\n\t\t\t  \n\t\t\t  // Reduce penalty for longer strings.\n\t\t\t  //final_score = (word_score + abbreviation_score) / 2;\n\t\t\t  final_score = ((abbreviation_score * (abbreviation_length / string_length)) + abbreviation_score) / 2;\n\t\t\t  \n\t\t\t  final_score = final_score / fuzzies;\n\t\t\t  \n\t\t\t  if (start_of_string_bonus && (final_score + 0.15 < 1)) {\n\t\t\t    final_score += 0.15;\n\t\t\t  }\n\t\t\t  \n\t\t\t  return final_score;\n\t\t}\n\t};\n});\n},{}]},{},[\"./lib/emmet.js\",\"./bundles/snippets.js\"])(\"./lib/emmet.js\")\n});","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n"],"sourceRoot":""}