1697 lines
40 KiB
JavaScript
1697 lines
40 KiB
JavaScript
/*
|
|
* __ ___
|
|
* _____/ /___ __/ (_)____
|
|
* / ___/ __/ / / / / / ___/
|
|
* (__ ) /_/ /_/ / / (__ )
|
|
* /____/\__/\__, /_/_/____/
|
|
* /____/
|
|
*
|
|
* light - weight css preprocessor @licence MIT
|
|
*/
|
|
(function (factory) {/* eslint-disable */
|
|
typeof exports === 'object' && typeof module !== 'undefined' ? (module['exports'] = factory(null)) :
|
|
typeof define === 'function' && define['amd'] ? define(factory(null)) :
|
|
(window['stylis'] = factory(null))
|
|
}(/** @param {*=} options */function factory (options) {/* eslint-disable */
|
|
|
|
'use strict'
|
|
|
|
/**
|
|
* Notes
|
|
*
|
|
* The ['<method name>'] pattern is used to support closure compiler
|
|
* the jsdoc signatures are also used to the same effect
|
|
*
|
|
* ----
|
|
*
|
|
* int + int + int === n4 [faster]
|
|
*
|
|
* vs
|
|
*
|
|
* int === n1 && int === n2 && int === n3
|
|
*
|
|
* ----
|
|
*
|
|
* switch (int) { case ints...} [faster]
|
|
*
|
|
* vs
|
|
*
|
|
* if (int == 1 && int === 2 ...)
|
|
*
|
|
* ----
|
|
*
|
|
* The (first*n1 + second*n2 + third*n3) format used in the property parser
|
|
* is a simple way to hash the sequence of characters
|
|
* taking into account the index they occur in
|
|
* since any number of 3 character sequences could produce duplicates.
|
|
*
|
|
* On the other hand sequences that are directly tied to the index of the character
|
|
* resolve a far more accurate measure, it's also faster
|
|
* to evaluate one condition in a switch statement
|
|
* than three in an if statement regardless of the added math.
|
|
*
|
|
* This allows the vendor prefixer to be both small and fast.
|
|
*/
|
|
|
|
var nullptn = /^\0+/g /* matches leading null characters */
|
|
var formatptn = /[\0\r\f]/g /* matches new line, null and formfeed characters */
|
|
var colonptn = /: */g /* splits animation rules */
|
|
var cursorptn = /zoo|gra/ /* assert cursor varient */
|
|
var transformptn = /([,: ])(transform)/g /* vendor prefix transform, older webkit */
|
|
var animationptn = /,+\s*(?![^(]*[)])/g /* splits multiple shorthand notation animations */
|
|
var propertiesptn = / +\s*(?![^(]*[)])/g /* animation properties */
|
|
var elementptn = / *[\0] */g /* selector elements */
|
|
var selectorptn = /,\r+?/g /* splits selectors */
|
|
var andptn = /([\t\r\n ])*\f?&/g /* match & */
|
|
var escapeptn = /:global\(((?:[^\(\)\[\]]*|\[.*\]|\([^\(\)]*\))*)\)/g /* matches :global(.*) */
|
|
var invalidptn = /\W+/g /* removes invalid characters from keyframes */
|
|
var keyframeptn = /@(k\w+)\s*(\S*)\s*/ /* matches @keyframes $1 */
|
|
var plcholdrptn = /::(place)/g /* match ::placeholder varient */
|
|
var readonlyptn = /:(read-only)/g /* match :read-only varient */
|
|
var beforeptn = /\s+(?=[{\];=:>])/g /* matches \s before ] ; = : */
|
|
var afterptn = /([[}=:>])\s+/g /* matches \s after characters [ } = : */
|
|
var tailptn = /(\{[^{]+?);(?=\})/g /* matches tail semi-colons ;} */
|
|
var whiteptn = /\s{2,}/g /* matches repeating whitespace */
|
|
var pseudoptn = /([^\(])(:+) */g /* pseudo element */
|
|
var writingptn = /[svh]\w+-[tblr]{2}/ /* match writing mode property values */
|
|
var gradientptn = /([\w-]+t\()/g /* match *gradient property */
|
|
var supportsptn = /\(\s*(.*)\s*\)/g /* match supports (groups) */
|
|
var propertyptn = /([\s\S]*?);/g /* match properties leading semicolon */
|
|
var selfptn = /-self|flex-/g /* match flex- and -self in align-self: flex-*; */
|
|
var pseudofmt = /[^]*?(:[rp][el]a[\w-]+)[^]*/ /* extrats :readonly or :placholder from selector */
|
|
var trimptn = /[ \t]+$/ /* match tail whitspace */
|
|
var dimensionptn = /stretch|:\s*\w+\-(?:conte|avail)/ /* match max/min/fit-content, fill-available */
|
|
var imgsrcptn = /([^-])(image-set\()/
|
|
|
|
/* vendors */
|
|
var webkit = '-webkit-'
|
|
var moz = '-moz-'
|
|
var ms = '-ms-'
|
|
|
|
/* character codes */
|
|
var SEMICOLON = 59 /* ; */
|
|
var CLOSEBRACES = 125 /* } */
|
|
var OPENBRACES = 123 /* { */
|
|
var OPENPARENTHESES = 40 /* ( */
|
|
var CLOSEPARENTHESES = 41 /* ) */
|
|
var OPENBRACKET = 91 /* [ */
|
|
var CLOSEBRACKET = 93 /* ] */
|
|
var NEWLINE = 10 /* \n */
|
|
var CARRIAGE = 13 /* \r */
|
|
var TAB = 9 /* \t */
|
|
var AT = 64 /* @ */
|
|
var SPACE = 32 /* */
|
|
var AND = 38 /* & */
|
|
var DASH = 45 /* - */
|
|
var UNDERSCORE = 95 /* _ */
|
|
var STAR = 42 /* * */
|
|
var COMMA = 44 /* , */
|
|
var COLON = 58 /* : */
|
|
var SINGLEQUOTE = 39 /* ' */
|
|
var DOUBLEQUOTE = 34 /* " */
|
|
var FOWARDSLASH = 47 /* / */
|
|
var GREATERTHAN = 62 /* > */
|
|
var PLUS = 43 /* + */
|
|
var TILDE = 126 /* ~ */
|
|
var NULL = 0 /* \0 */
|
|
var FORMFEED = 12 /* \f */
|
|
var VERTICALTAB = 11 /* \v */
|
|
|
|
/* special identifiers */
|
|
var KEYFRAME = 107 /* k */
|
|
var MEDIA = 109 /* m */
|
|
var SUPPORTS = 115 /* s */
|
|
var PLACEHOLDER = 112 /* p */
|
|
var READONLY = 111 /* o */
|
|
var IMPORT = 105 /* <at>i */
|
|
var CHARSET = 99 /* <at>c */
|
|
var DOCUMENT = 100 /* <at>d */
|
|
var PAGE = 112 /* <at>p */
|
|
|
|
var column = 1 /* current column */
|
|
var line = 1 /* current line numebr */
|
|
var pattern = 0 /* :pattern */
|
|
|
|
var cascade = 1 /* #id h1 h2 vs h1#id h2#id */
|
|
var prefix = 1 /* vendor prefix */
|
|
var escape = 1 /* escape :global() pattern */
|
|
var compress = 0 /* compress output */
|
|
var semicolon = 0 /* no/semicolon option */
|
|
var preserve = 0 /* preserve empty selectors */
|
|
|
|
/* empty reference */
|
|
var array = []
|
|
|
|
/* plugins */
|
|
var plugins = []
|
|
var plugged = 0
|
|
var should = null
|
|
|
|
/* plugin context */
|
|
var POSTS = -2
|
|
var PREPS = -1
|
|
var UNKWN = 0
|
|
var PROPS = 1
|
|
var BLCKS = 2
|
|
var ATRUL = 3
|
|
|
|
/* plugin newline context */
|
|
var unkwn = 0
|
|
|
|
/* keyframe animation */
|
|
var keyed = 1
|
|
var key = ''
|
|
|
|
/* selector namespace */
|
|
var nscopealt = ''
|
|
var nscope = ''
|
|
|
|
/**
|
|
* Compile
|
|
*
|
|
* @param {Array<string>} parent
|
|
* @param {Array<string>} current
|
|
* @param {string} body
|
|
* @param {number} id
|
|
* @param {number} depth
|
|
* @return {string}
|
|
*/
|
|
function compile (parent, current, body, id, depth) {
|
|
var bracket = 0 /* brackets [] */
|
|
var comment = 0 /* comments /* // or /* */
|
|
var parentheses = 0 /* functions () */
|
|
var quote = 0 /* quotes '', "" */
|
|
|
|
var first = 0 /* first character code */
|
|
var second = 0 /* second character code */
|
|
var code = 0 /* current character code */
|
|
var tail = 0 /* previous character code */
|
|
var trail = 0 /* character before previous code */
|
|
var peak = 0 /* previous non-whitespace code */
|
|
|
|
var counter = 0 /* count sequence termination */
|
|
var context = 0 /* track current context */
|
|
var atrule = 0 /* track @at-rule context */
|
|
var pseudo = 0 /* track pseudo token index */
|
|
var caret = 0 /* current character index */
|
|
var format = 0 /* control character formating context */
|
|
var insert = 0 /* auto semicolon insertion */
|
|
var invert = 0 /* inverted selector pattern */
|
|
var length = 0 /* generic length address */
|
|
var eof = body.length /* end of file(length) */
|
|
var eol = eof - 1 /* end of file(characters) */
|
|
|
|
var char = '' /* current character */
|
|
var chars = '' /* current buffer of characters */
|
|
var child = '' /* next buffer of characters */
|
|
var out = '' /* compiled body */
|
|
var children = '' /* compiled children */
|
|
var flat = '' /* compiled leafs */
|
|
var selector /* generic selector address */
|
|
var result /* generic address */
|
|
|
|
// ...build body
|
|
while (caret < eof) {
|
|
code = body.charCodeAt(caret)
|
|
|
|
// eof varient
|
|
if (caret === eol) {
|
|
// last character + noop context, add synthetic padding for noop context to terminate
|
|
if (comment + quote + parentheses + bracket !== 0) {
|
|
if (comment !== 0) {
|
|
code = comment === FOWARDSLASH ? NEWLINE : FOWARDSLASH
|
|
}
|
|
|
|
quote = parentheses = bracket = 0
|
|
eof++
|
|
eol++
|
|
}
|
|
}
|
|
|
|
if (comment + quote + parentheses + bracket === 0) {
|
|
// eof varient
|
|
if (caret === eol) {
|
|
if (format > 0) {
|
|
chars = chars.replace(formatptn, '')
|
|
}
|
|
|
|
if (chars.trim().length > 0) {
|
|
switch (code) {
|
|
case SPACE:
|
|
case TAB:
|
|
case SEMICOLON:
|
|
case CARRIAGE:
|
|
case NEWLINE: {
|
|
break
|
|
}
|
|
default: {
|
|
chars += body.charAt(caret)
|
|
}
|
|
}
|
|
|
|
code = SEMICOLON
|
|
}
|
|
}
|
|
|
|
// auto semicolon insertion
|
|
if (insert === 1) {
|
|
switch (code) {
|
|
// false flags
|
|
case OPENBRACES:
|
|
case CLOSEBRACES:
|
|
case SEMICOLON:
|
|
case DOUBLEQUOTE:
|
|
case SINGLEQUOTE:
|
|
case OPENPARENTHESES:
|
|
case CLOSEPARENTHESES:
|
|
case COMMA: {
|
|
insert = 0
|
|
}
|
|
// ignore
|
|
case TAB:
|
|
case CARRIAGE:
|
|
case NEWLINE:
|
|
case SPACE: {
|
|
break
|
|
}
|
|
// valid
|
|
default: {
|
|
insert = 0
|
|
length = caret
|
|
first = code
|
|
caret--
|
|
code = SEMICOLON
|
|
|
|
while (length < eof) {
|
|
switch (body.charCodeAt(length++)) {
|
|
case NEWLINE:
|
|
case CARRIAGE:
|
|
case SEMICOLON: {
|
|
++caret
|
|
code = first
|
|
length = eof
|
|
break
|
|
}
|
|
case COLON: {
|
|
if (format > 0) {
|
|
++caret
|
|
code = first
|
|
}
|
|
}
|
|
case OPENBRACES: {
|
|
length = eof
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// token varient
|
|
switch (code) {
|
|
case OPENBRACES: {
|
|
chars = chars.trim()
|
|
first = chars.charCodeAt(0)
|
|
counter = 1
|
|
length = ++caret
|
|
|
|
while (caret < eof) {
|
|
switch (code = body.charCodeAt(caret)) {
|
|
case OPENBRACES: {
|
|
counter++
|
|
break
|
|
}
|
|
case CLOSEBRACES: {
|
|
counter--
|
|
break
|
|
}
|
|
case FOWARDSLASH: {
|
|
switch (second = body.charCodeAt(caret + 1)) {
|
|
// /*, //
|
|
case STAR:
|
|
case FOWARDSLASH: {
|
|
caret = delimited(second, caret, eol, body)
|
|
}
|
|
}
|
|
break
|
|
}
|
|
// given "[" === 91 & "]" === 93 hence forth 91 + 1 + 1 === 93
|
|
case OPENBRACKET: {
|
|
code++
|
|
}
|
|
// given "(" === 40 & ")" === 41 hence forth 40 + 1 === 41
|
|
case OPENPARENTHESES: {
|
|
code++
|
|
}
|
|
// quote tail delimiter is identical to the head delimiter hence noop,
|
|
// fallthrough clauses have been shifted to the correct tail delimiter
|
|
case DOUBLEQUOTE:
|
|
case SINGLEQUOTE: {
|
|
while (caret++ < eol) {
|
|
if (body.charCodeAt(caret) === code) {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (counter === 0) {
|
|
break
|
|
}
|
|
|
|
caret++
|
|
}
|
|
|
|
child = body.substring(length, caret)
|
|
|
|
if (first === NULL) {
|
|
first = (chars = chars.replace(nullptn, '').trim()).charCodeAt(0)
|
|
}
|
|
|
|
switch (first) {
|
|
// @at-rule
|
|
case AT: {
|
|
if (format > 0) {
|
|
chars = chars.replace(formatptn, '')
|
|
}
|
|
|
|
second = chars.charCodeAt(1)
|
|
|
|
switch (second) {
|
|
case DOCUMENT:
|
|
case MEDIA:
|
|
case SUPPORTS:
|
|
case DASH: {
|
|
selector = current
|
|
break
|
|
}
|
|
default: {
|
|
selector = array
|
|
}
|
|
}
|
|
|
|
child = compile(current, selector, child, second, depth+1)
|
|
length = child.length
|
|
|
|
// preserve empty @at-rule
|
|
if (preserve > 0 && length === 0) {
|
|
length = chars.length
|
|
}
|
|
|
|
// execute plugins, @at-rule context
|
|
if (plugged > 0) {
|
|
selector = select(array, chars, invert)
|
|
result = proxy(ATRUL, child, selector, current, line, column, length, second, depth, id)
|
|
chars = selector.join('')
|
|
|
|
if (result !== void 0) {
|
|
if ((length = (child = result.trim()).length) === 0) {
|
|
second = 0
|
|
child = ''
|
|
}
|
|
}
|
|
}
|
|
|
|
if (length > 0) {
|
|
switch (second) {
|
|
case SUPPORTS: {
|
|
chars = chars.replace(supportsptn, supports)
|
|
}
|
|
case DOCUMENT:
|
|
case MEDIA:
|
|
case DASH: {
|
|
child = chars + '{' + child + '}'
|
|
break
|
|
}
|
|
case KEYFRAME: {
|
|
chars = chars.replace(keyframeptn, '$1 $2' + (keyed > 0 ? key : ''))
|
|
child = chars + '{' + child + '}'
|
|
|
|
if (prefix === 1 || (prefix === 2 && vendor('@'+child, 3))) {
|
|
child = '@' + webkit + child + '@' + child
|
|
} else {
|
|
child = '@' + child
|
|
}
|
|
break
|
|
}
|
|
default: {
|
|
child = chars + child
|
|
|
|
if (id === PAGE) {
|
|
child = (out += child, '')
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
child = ''
|
|
}
|
|
|
|
break
|
|
}
|
|
// selector
|
|
default: {
|
|
child = compile(current, select(current, chars, invert), child, id, depth+1)
|
|
}
|
|
}
|
|
|
|
children += child
|
|
|
|
// reset
|
|
context = 0
|
|
insert = 0
|
|
pseudo = 0
|
|
format = 0
|
|
invert = 0
|
|
atrule = 0
|
|
chars = ''
|
|
child = ''
|
|
code = body.charCodeAt(++caret)
|
|
break
|
|
}
|
|
case CLOSEBRACES:
|
|
case SEMICOLON: {
|
|
chars = (format > 0 ? chars.replace(formatptn, '') : chars).trim()
|
|
|
|
if ((length = chars.length) > 1) {
|
|
// monkey-patch missing colon
|
|
if (pseudo === 0) {
|
|
first = chars.charCodeAt(0)
|
|
|
|
// first character is a letter or dash, buffer has a space character
|
|
if ((first === DASH || first > 96 && first < 123)) {
|
|
length = (chars = chars.replace(' ', ':')).length
|
|
}
|
|
}
|
|
|
|
// execute plugins, property context
|
|
if (plugged > 0) {
|
|
if ((result = proxy(PROPS, chars, current, parent, line, column, out.length, id, depth, id)) !== void 0) {
|
|
if ((length = (chars = result.trim()).length) === 0) {
|
|
chars = '\0\0'
|
|
}
|
|
}
|
|
}
|
|
|
|
first = chars.charCodeAt(0)
|
|
second = chars.charCodeAt(1)
|
|
|
|
switch (first) {
|
|
case NULL: {
|
|
break
|
|
}
|
|
case AT: {
|
|
if (second === IMPORT || second === CHARSET) {
|
|
flat += chars + body.charAt(caret)
|
|
break
|
|
}
|
|
}
|
|
default: {
|
|
if (chars.charCodeAt(length-1) === COLON) {
|
|
break
|
|
}
|
|
|
|
out += property(chars, first, second, chars.charCodeAt(2))
|
|
}
|
|
}
|
|
}
|
|
|
|
// reset
|
|
context = 0
|
|
insert = 0
|
|
pseudo = 0
|
|
format = 0
|
|
invert = 0
|
|
chars = ''
|
|
code = body.charCodeAt(++caret)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// parse characters
|
|
switch (code) {
|
|
case CARRIAGE:
|
|
case NEWLINE: {
|
|
// auto insert semicolon
|
|
if (comment + quote + parentheses + bracket + semicolon === 0) {
|
|
// valid non-whitespace characters that
|
|
// may precede a newline
|
|
switch (peak) {
|
|
case CLOSEPARENTHESES:
|
|
case SINGLEQUOTE:
|
|
case DOUBLEQUOTE:
|
|
case AT:
|
|
case TILDE:
|
|
case GREATERTHAN:
|
|
case STAR:
|
|
case PLUS:
|
|
case FOWARDSLASH:
|
|
case DASH:
|
|
case COLON:
|
|
case COMMA:
|
|
case SEMICOLON:
|
|
case OPENBRACES:
|
|
case CLOSEBRACES: {
|
|
break
|
|
}
|
|
default: {
|
|
// current buffer has a colon
|
|
if (pseudo > 0) {
|
|
insert = 1
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// terminate line comment
|
|
if (comment === FOWARDSLASH) {
|
|
comment = 0
|
|
} else if (cascade + context === 0 && id !== KEYFRAME && chars.length > 0) {
|
|
format = 1
|
|
chars += '\0'
|
|
}
|
|
|
|
// execute plugins, newline context
|
|
if (plugged * unkwn > 0) {
|
|
proxy(UNKWN, chars, current, parent, line, column, out.length, id, depth, id)
|
|
}
|
|
|
|
// next line, reset column position
|
|
column = 1
|
|
line++
|
|
break
|
|
}
|
|
case SEMICOLON:
|
|
case CLOSEBRACES: {
|
|
if (comment + quote + parentheses + bracket === 0) {
|
|
column++
|
|
break
|
|
}
|
|
}
|
|
default: {
|
|
// increment column position
|
|
column++
|
|
|
|
// current character
|
|
char = body.charAt(caret)
|
|
|
|
// remove comments, escape functions, strings, attributes and prepare selectors
|
|
switch (code) {
|
|
case TAB:
|
|
case SPACE: {
|
|
if (quote + bracket + comment === 0) {
|
|
switch (tail) {
|
|
case COMMA:
|
|
case COLON:
|
|
case TAB:
|
|
case SPACE: {
|
|
char = ''
|
|
break
|
|
}
|
|
default: {
|
|
if (code !== SPACE) {
|
|
char = ' '
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break
|
|
}
|
|
// escape breaking control characters
|
|
case NULL: {
|
|
char = '\\0'
|
|
break
|
|
}
|
|
case FORMFEED: {
|
|
char = '\\f'
|
|
break
|
|
}
|
|
case VERTICALTAB: {
|
|
char = '\\v'
|
|
break
|
|
}
|
|
// &
|
|
case AND: {
|
|
// inverted selector pattern i.e html &
|
|
if (quote + comment + bracket === 0 && cascade > 0) {
|
|
invert = 1
|
|
format = 1
|
|
char = '\f' + char
|
|
}
|
|
break
|
|
}
|
|
// ::p<l>aceholder, l
|
|
// :read-on<l>y, l
|
|
case 108: {
|
|
if (quote + comment + bracket + pattern === 0 && pseudo > 0) {
|
|
switch (caret - pseudo) {
|
|
// ::placeholder
|
|
case 2: {
|
|
if (tail === PLACEHOLDER && body.charCodeAt(caret-3) === COLON) {
|
|
pattern = tail
|
|
}
|
|
}
|
|
// :read-only
|
|
case 8: {
|
|
if (trail === READONLY) {
|
|
pattern = trail
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break
|
|
}
|
|
// :<pattern>
|
|
case COLON: {
|
|
if (quote + comment + bracket === 0) {
|
|
pseudo = caret
|
|
}
|
|
break
|
|
}
|
|
// selectors
|
|
case COMMA: {
|
|
if (comment + parentheses + quote + bracket === 0) {
|
|
format = 1
|
|
char += '\r'
|
|
}
|
|
break
|
|
}
|
|
// quotes
|
|
case DOUBLEQUOTE:
|
|
case SINGLEQUOTE: {
|
|
if (comment === 0) {
|
|
quote = quote === code ? 0 : (quote === 0 ? code : quote)
|
|
}
|
|
break
|
|
}
|
|
// attributes
|
|
case OPENBRACKET: {
|
|
if (quote + comment + parentheses === 0) {
|
|
bracket++
|
|
}
|
|
break
|
|
}
|
|
case CLOSEBRACKET: {
|
|
if (quote + comment + parentheses === 0) {
|
|
bracket--
|
|
}
|
|
break
|
|
}
|
|
// functions
|
|
case CLOSEPARENTHESES: {
|
|
if (quote + comment + bracket === 0) {
|
|
parentheses--
|
|
}
|
|
break
|
|
}
|
|
case OPENPARENTHESES: {
|
|
if (quote + comment + bracket === 0) {
|
|
if (context === 0) {
|
|
switch (tail*2 + trail*3) {
|
|
// :matches
|
|
case 533: {
|
|
break
|
|
}
|
|
// :global, :not, :nth-child etc...
|
|
default: {
|
|
counter = 0
|
|
context = 1
|
|
}
|
|
}
|
|
}
|
|
|
|
parentheses++
|
|
}
|
|
break
|
|
}
|
|
case AT: {
|
|
if (comment + parentheses + quote + bracket + pseudo + atrule === 0) {
|
|
atrule = 1
|
|
}
|
|
break
|
|
}
|
|
// block/line comments
|
|
case STAR:
|
|
case FOWARDSLASH: {
|
|
if (quote + bracket + parentheses > 0) {
|
|
break
|
|
}
|
|
|
|
switch (comment) {
|
|
// initialize line/block comment context
|
|
case 0: {
|
|
switch (code*2 + body.charCodeAt(caret+1)*3) {
|
|
// //
|
|
case 235: {
|
|
comment = FOWARDSLASH
|
|
break
|
|
}
|
|
// /*
|
|
case 220: {
|
|
length = caret
|
|
comment = STAR
|
|
break
|
|
}
|
|
}
|
|
break
|
|
}
|
|
// end block comment context
|
|
case STAR: {
|
|
if (code === FOWARDSLASH && tail === STAR && length + 2 !== caret) {
|
|
// /*<!> ... */, !
|
|
if (body.charCodeAt(length+2) === 33) {
|
|
out += body.substring(length, caret+1)
|
|
}
|
|
char = ''
|
|
comment = 0
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// ignore comment blocks
|
|
if (comment === 0) {
|
|
// aggressive isolation mode, divide each individual selector
|
|
// including selectors in :not function but excluding selectors in :global function
|
|
if (cascade + quote + bracket + atrule === 0 && id !== KEYFRAME && code !== SEMICOLON) {
|
|
switch (code) {
|
|
case COMMA:
|
|
case TILDE:
|
|
case GREATERTHAN:
|
|
case PLUS:
|
|
case CLOSEPARENTHESES:
|
|
case OPENPARENTHESES: {
|
|
if (context === 0) {
|
|
// outside of an isolated context i.e nth-child(<...>)
|
|
switch (tail) {
|
|
case TAB:
|
|
case SPACE:
|
|
case NEWLINE:
|
|
case CARRIAGE: {
|
|
char = char + '\0'
|
|
break
|
|
}
|
|
default: {
|
|
char = '\0' + char + (code === COMMA ? '' : '\0')
|
|
}
|
|
}
|
|
format = 1
|
|
} else {
|
|
// within an isolated context, sleep untill it's terminated
|
|
switch (code) {
|
|
case OPENPARENTHESES: {
|
|
// :globa<l>(
|
|
if (pseudo + 7 === caret && tail === 108) {
|
|
pseudo = 0
|
|
}
|
|
context = ++counter
|
|
break
|
|
}
|
|
case CLOSEPARENTHESES: {
|
|
if ((context = --counter) === 0) {
|
|
format = 1
|
|
char += '\0'
|
|
}
|
|
break
|
|
}
|
|
}
|
|
}
|
|
break
|
|
}
|
|
case TAB:
|
|
case SPACE: {
|
|
switch (tail) {
|
|
case NULL:
|
|
case OPENBRACES:
|
|
case CLOSEBRACES:
|
|
case SEMICOLON:
|
|
case COMMA:
|
|
case FORMFEED:
|
|
case TAB:
|
|
case SPACE:
|
|
case NEWLINE:
|
|
case CARRIAGE: {
|
|
break
|
|
}
|
|
default: {
|
|
// ignore in isolated contexts
|
|
if (context === 0) {
|
|
format = 1
|
|
char += '\0'
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// concat buffer of characters
|
|
chars += char
|
|
|
|
// previous non-whitespace character code
|
|
if (code !== SPACE && code !== TAB) {
|
|
peak = code
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// tail character codes
|
|
trail = tail
|
|
tail = code
|
|
|
|
// visit every character
|
|
caret++
|
|
}
|
|
|
|
length = out.length
|
|
|
|
// preserve empty selector
|
|
if (preserve > 0) {
|
|
if (length === 0 && children.length === 0 && (current[0].length === 0) === false) {
|
|
if (id !== MEDIA || (current.length === 1 && (cascade > 0 ? nscopealt : nscope) === current[0])) {
|
|
length = current.join(',').length + 2
|
|
}
|
|
}
|
|
}
|
|
|
|
if (length > 0) {
|
|
// cascade isolation mode?
|
|
selector = cascade === 0 && id !== KEYFRAME ? isolate(current) : current
|
|
|
|
// execute plugins, block context
|
|
if (plugged > 0) {
|
|
result = proxy(BLCKS, out, selector, parent, line, column, length, id, depth, id)
|
|
|
|
if (result !== void 0 && (out = result).length === 0) {
|
|
return flat + out + children
|
|
}
|
|
}
|
|
|
|
out = selector.join(',') + '{' + out + '}'
|
|
|
|
if (prefix*pattern !== 0) {
|
|
if (prefix === 2 && !vendor(out, 2))
|
|
pattern = 0
|
|
|
|
switch (pattern) {
|
|
// ::read-only
|
|
case READONLY: {
|
|
out = out.replace(readonlyptn, ':'+moz+'$1')+out
|
|
break
|
|
}
|
|
// ::placeholder
|
|
case PLACEHOLDER: {
|
|
out = (
|
|
out.replace(plcholdrptn, '::' + webkit + 'input-$1') +
|
|
out.replace(plcholdrptn, '::' + moz + '$1') +
|
|
out.replace(plcholdrptn, ':' + ms + 'input-$1') + out
|
|
)
|
|
break
|
|
}
|
|
}
|
|
|
|
pattern = 0
|
|
}
|
|
}
|
|
|
|
return flat + out + children
|
|
}
|
|
|
|
/**
|
|
* Select
|
|
*
|
|
* @param {Array<string>} parent
|
|
* @param {string} current
|
|
* @param {number} invert
|
|
* @return {Array<string>}
|
|
*/
|
|
function select (parent, current, invert) {
|
|
var selectors = current.trim().split(selectorptn)
|
|
var out = selectors
|
|
|
|
var length = selectors.length
|
|
var l = parent.length
|
|
|
|
switch (l) {
|
|
// 0-1 parent selectors
|
|
case 0:
|
|
case 1: {
|
|
for (var i = 0, selector = l === 0 ? '' : parent[0] + ' '; i < length; ++i) {
|
|
out[i] = scope(selector, out[i], invert, l).trim()
|
|
}
|
|
break
|
|
}
|
|
// >2 parent selectors, nested
|
|
default: {
|
|
for (var i = 0, j = 0, out = []; i < length; ++i) {
|
|
for (var k = 0; k < l; ++k) {
|
|
out[j++] = scope(parent[k] + ' ', selectors[i], invert, l).trim()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return out
|
|
}
|
|
|
|
/**
|
|
* Scope
|
|
*
|
|
* @param {string} parent
|
|
* @param {string} current
|
|
* @param {number} invert
|
|
* @param {number} level
|
|
* @return {string}
|
|
*/
|
|
function scope (parent, current, invert, level) {
|
|
var selector = current
|
|
var code = selector.charCodeAt(0)
|
|
|
|
// trim leading whitespace
|
|
if (code < 33) {
|
|
code = (selector = selector.trim()).charCodeAt(0)
|
|
}
|
|
|
|
switch (code) {
|
|
// &
|
|
case AND: {
|
|
switch (cascade + level) {
|
|
case 0:
|
|
case 1: {
|
|
if (parent.trim().length === 0) {
|
|
break
|
|
}
|
|
}
|
|
default: {
|
|
return selector.replace(andptn, '$1'+parent.trim())
|
|
}
|
|
}
|
|
break
|
|
}
|
|
// :
|
|
case COLON: {
|
|
switch (selector.charCodeAt(1)) {
|
|
// g in :global
|
|
case 103: {
|
|
if (escape > 0 && cascade > 0) {
|
|
return selector.replace(escapeptn, '$1').replace(andptn, '$1'+nscope)
|
|
}
|
|
break
|
|
}
|
|
default: {
|
|
// :hover
|
|
return parent.trim() + selector.replace(andptn, '$1'+parent.trim())
|
|
}
|
|
}
|
|
}
|
|
default: {
|
|
// html &
|
|
if (invert*cascade > 0 && selector.indexOf('\f') > 0) {
|
|
return selector.replace(andptn, (parent.charCodeAt(0) === COLON ? '' : '$1')+parent.trim())
|
|
}
|
|
}
|
|
}
|
|
|
|
return parent + selector
|
|
}
|
|
|
|
/**
|
|
* Property
|
|
*
|
|
* @param {string} input
|
|
* @param {number} first
|
|
* @param {number} second
|
|
* @param {number} third
|
|
* @return {string}
|
|
*/
|
|
function property (input, first, second, third) {
|
|
var index = 0
|
|
var out = input + ';'
|
|
var hash = (first*2) + (second*3) + (third*4)
|
|
var cache
|
|
|
|
// animation: a, n, i characters
|
|
if (hash === 944) {
|
|
return animation(out)
|
|
} else if (prefix === 0 || (prefix === 2 && !vendor(out, 1))) {
|
|
return out
|
|
}
|
|
|
|
// vendor prefix
|
|
switch (hash) {
|
|
// text-decoration/text-size-adjust/text-shadow/text-align/text-transform: t, e, x
|
|
case 1015: {
|
|
// text-shadow/text-align/text-transform, a
|
|
return out.charCodeAt(10) === 97 ? webkit + out + out : out
|
|
}
|
|
// filter/fill f, i, l
|
|
case 951: {
|
|
// filter, t
|
|
return out.charCodeAt(3) === 116 ? webkit + out + out : out
|
|
}
|
|
// color/column, c, o, l
|
|
case 963: {
|
|
// column, n
|
|
return out.charCodeAt(5) === 110 ? webkit + out + out : out
|
|
}
|
|
// box-decoration-break, b, o, x
|
|
case 1009: {
|
|
if (out.charCodeAt(4) !== 100) {
|
|
break
|
|
}
|
|
}
|
|
// mask, m, a, s
|
|
// clip-path, c, l, i
|
|
case 969:
|
|
case 942: {
|
|
return webkit + out + out
|
|
}
|
|
// appearance: a, p, p
|
|
case 978: {
|
|
return webkit + out + moz + out + out
|
|
}
|
|
// hyphens: h, y, p
|
|
// user-select: u, s, e
|
|
case 1019:
|
|
case 983: {
|
|
return webkit + out + moz + out + ms + out + out
|
|
}
|
|
// background/backface-visibility, b, a, c
|
|
case 883: {
|
|
// backface-visibility, -
|
|
if (out.charCodeAt(8) === DASH) {
|
|
return webkit + out + out
|
|
}
|
|
|
|
// image-set(...)
|
|
if (out.indexOf('image-set(', 11) > 0) {
|
|
return out.replace(imgsrcptn, '$1'+webkit+'$2') + out
|
|
}
|
|
|
|
return out
|
|
}
|
|
// flex: f, l, e
|
|
case 932: {
|
|
if (out.charCodeAt(4) === DASH) {
|
|
switch (out.charCodeAt(5)) {
|
|
// flex-grow, g
|
|
case 103: {
|
|
return webkit + 'box-' + out.replace('-grow', '') + webkit + out + ms + out.replace('grow', 'positive') + out
|
|
}
|
|
// flex-shrink, s
|
|
case 115: {
|
|
return webkit + out + ms + out.replace('shrink', 'negative') + out
|
|
}
|
|
// flex-basis, b
|
|
case 98: {
|
|
return webkit + out + ms + out.replace('basis', 'preferred-size') + out
|
|
}
|
|
}
|
|
}
|
|
|
|
return webkit + out + ms + out + out
|
|
}
|
|
// order: o, r, d
|
|
case 964: {
|
|
return webkit + out + ms + 'flex' + '-' + out + out
|
|
}
|
|
// justify-items/justify-content, j, u, s
|
|
case 1023: {
|
|
// justify-content, c
|
|
if (out.charCodeAt(8) !== 99) {
|
|
break
|
|
}
|
|
|
|
cache = out.substring(out.indexOf(':', 15)).replace('flex-', '').replace('space-between', 'justify')
|
|
return webkit + 'box-pack' + cache + webkit + out + ms + 'flex-pack' + cache + out
|
|
}
|
|
// cursor, c, u, r
|
|
case 1005: {
|
|
return cursorptn.test(out) ? out.replace(colonptn, ':' + webkit) + out.replace(colonptn, ':' + moz) + out : out
|
|
}
|
|
// writing-mode, w, r, i
|
|
case 1000: {
|
|
cache = out.substring(13).trim()
|
|
index = cache.indexOf('-') + 1
|
|
|
|
switch (cache.charCodeAt(0)+cache.charCodeAt(index)) {
|
|
// vertical-lr
|
|
case 226: {
|
|
cache = out.replace(writingptn, 'tb')
|
|
break
|
|
}
|
|
// vertical-rl
|
|
case 232: {
|
|
cache = out.replace(writingptn, 'tb-rl')
|
|
break
|
|
}
|
|
// horizontal-tb
|
|
case 220: {
|
|
cache = out.replace(writingptn, 'lr')
|
|
break
|
|
}
|
|
default: {
|
|
return out
|
|
}
|
|
}
|
|
|
|
return webkit + out + ms + cache + out
|
|
}
|
|
// position: sticky
|
|
case 1017: {
|
|
if (out.indexOf('sticky', 9) === -1) {
|
|
return out
|
|
}
|
|
}
|
|
// display(flex/inline-flex/inline-box): d, i, s
|
|
case 975: {
|
|
index = (out = input).length - 10
|
|
cache = (out.charCodeAt(index) === 33 ? out.substring(0, index) : out).substring(input.indexOf(':', 7) + 1).trim()
|
|
|
|
switch (hash = cache.charCodeAt(0) + (cache.charCodeAt(7)|0)) {
|
|
// inline-
|
|
case 203: {
|
|
// inline-box
|
|
if (cache.charCodeAt(8) < 111) {
|
|
break
|
|
}
|
|
}
|
|
// inline-box/sticky
|
|
case 115: {
|
|
out = out.replace(cache, webkit+cache)+';'+out
|
|
break
|
|
}
|
|
// inline-flex
|
|
// flex
|
|
case 207:
|
|
case 102: {
|
|
out = (
|
|
out.replace(cache, webkit+(hash > 102 ? 'inline-' : '')+'box')+';'+
|
|
out.replace(cache, webkit+cache)+';'+
|
|
out.replace(cache, ms+cache+'box')+';'+
|
|
out
|
|
)
|
|
}
|
|
}
|
|
|
|
return out + ';'
|
|
}
|
|
// align-items, align-center, align-self: a, l, i, -
|
|
case 938: {
|
|
if (out.charCodeAt(5) === DASH) {
|
|
switch (out.charCodeAt(6)) {
|
|
// align-items, i
|
|
case 105: {
|
|
cache = out.replace('-items', '')
|
|
return webkit + out + webkit + 'box-' + cache + ms + 'flex-' + cache + out
|
|
}
|
|
// align-self, s
|
|
case 115: {
|
|
return webkit + out + ms + 'flex-item-' + out.replace(selfptn, '') + out
|
|
}
|
|
// align-content
|
|
default: {
|
|
return webkit + out + ms + 'flex-line-pack' + out.replace('align-content', '').replace(selfptn, '') + out
|
|
}
|
|
}
|
|
}
|
|
break
|
|
}
|
|
// min/max
|
|
case 973:
|
|
case 989: {
|
|
// min-/max- height/width/block-size/inline-size
|
|
if (out.charCodeAt(3) !== DASH || out.charCodeAt(4) === 122) {
|
|
break
|
|
}
|
|
}
|
|
// height/width: min-content / width: max-content
|
|
case 931:
|
|
case 953: {
|
|
if (dimensionptn.test(input) === true) {
|
|
// stretch
|
|
if ((cache = input.substring(input.indexOf(':') + 1)).charCodeAt(0) === 115)
|
|
return property(input.replace('stretch', 'fill-available'), first, second, third).replace(':fill-available', ':stretch')
|
|
else
|
|
return out.replace(cache, webkit + cache) + out.replace(cache, moz + cache.replace('fill-', '')) + out
|
|
}
|
|
break
|
|
}
|
|
// transform, transition: t, r, a
|
|
case 962: {
|
|
out = webkit + out + (out.charCodeAt(5) === 102 ? ms + out : '') + out
|
|
|
|
// transitions
|
|
if (second + third === 211 && out.charCodeAt(13) === 105 && out.indexOf('transform', 10) > 0) {
|
|
return out.substring(0, out.indexOf(';', 27) + 1).replace(transformptn, '$1' + webkit + '$2') + out
|
|
}
|
|
|
|
break
|
|
}
|
|
}
|
|
|
|
return out
|
|
}
|
|
|
|
/**
|
|
* Vendor
|
|
*
|
|
* @param {string} content
|
|
* @param {number} context
|
|
* @return {boolean}
|
|
*/
|
|
function vendor (content, context) {
|
|
var index = content.indexOf(context === 1 ? ':' : '{')
|
|
var key = content.substring(0, context !== 3 ? index : 10)
|
|
var value = content.substring(index + 1, content.length - 1)
|
|
|
|
return should(context !== 2 ? key : key.replace(pseudofmt, '$1'), value, context)
|
|
}
|
|
|
|
/**
|
|
* Supports
|
|
*
|
|
* @param {string} match
|
|
* @param {string} group
|
|
* @return {string}
|
|
*/
|
|
function supports (match, group) {
|
|
var out = property(group, group.charCodeAt(0), group.charCodeAt(1), group.charCodeAt(2))
|
|
|
|
return out !== group+';' ? out.replace(propertyptn, ' or ($1)').substring(4) : '('+group+')'
|
|
}
|
|
|
|
/**
|
|
* Animation
|
|
*
|
|
* @param {string} input
|
|
* @return {string}
|
|
*/
|
|
function animation (input) {
|
|
var length = input.length
|
|
var index = input.indexOf(':', 9) + 1
|
|
var declare = input.substring(0, index).trim()
|
|
var out = input.substring(index, length-1).trim()
|
|
|
|
switch (input.charCodeAt(9)*keyed) {
|
|
case 0: {
|
|
break
|
|
}
|
|
// animation-*, -
|
|
case DASH: {
|
|
// animation-name, n
|
|
if (input.charCodeAt(10) !== 110) {
|
|
break
|
|
}
|
|
}
|
|
// animation/animation-name
|
|
default: {
|
|
// split in case of multiple animations
|
|
var list = out.split((out = '', animationptn))
|
|
|
|
for (var i = 0, index = 0, length = list.length; i < length; index = 0, ++i) {
|
|
var value = list[i]
|
|
var items = value.split(propertiesptn)
|
|
|
|
while (value = items[index]) {
|
|
var peak = value.charCodeAt(0)
|
|
|
|
if (keyed === 1 && (
|
|
// letters
|
|
(peak > AT && peak < 90) || (peak > 96 && peak < 123) || peak === UNDERSCORE ||
|
|
// dash but not in sequence i.e --
|
|
(peak === DASH && value.charCodeAt(1) !== DASH)
|
|
)) {
|
|
// not a number/function
|
|
switch (isNaN(parseFloat(value)) + (value.indexOf('(') !== -1)) {
|
|
case 1: {
|
|
switch (value) {
|
|
// not a valid reserved keyword
|
|
case 'infinite': case 'alternate': case 'backwards': case 'running':
|
|
case 'normal': case 'forwards': case 'both': case 'none': case 'linear':
|
|
case 'ease': case 'ease-in': case 'ease-out': case 'ease-in-out':
|
|
case 'paused': case 'reverse': case 'alternate-reverse': case 'inherit':
|
|
case 'initial': case 'unset': case 'step-start': case 'step-end': {
|
|
break
|
|
}
|
|
default: {
|
|
value += key
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
items[index++] = value
|
|
}
|
|
|
|
out += (i === 0 ? '' : ',') + items.join(' ')
|
|
}
|
|
}
|
|
}
|
|
|
|
out = declare + out + ';'
|
|
|
|
if (prefix === 1 || (prefix === 2 && vendor(out, 1)))
|
|
return webkit + out + out
|
|
|
|
return out
|
|
}
|
|
|
|
/**
|
|
* Isolate
|
|
*
|
|
* @param {Array<string>} current
|
|
*/
|
|
function isolate (current) {
|
|
for (var i = 0, length = current.length, selector = Array(length), padding, element; i < length; ++i) {
|
|
// split individual elements in a selector i.e h1 h2 === [h1, h2]
|
|
var elements = current[i].split(elementptn)
|
|
var out = ''
|
|
|
|
for (var j = 0, size = 0, tail = 0, code = 0, l = elements.length; j < l; ++j) {
|
|
// empty element
|
|
if ((size = (element = elements[j]).length) === 0 && l > 1) {
|
|
continue
|
|
}
|
|
|
|
tail = out.charCodeAt(out.length-1)
|
|
code = element.charCodeAt(0)
|
|
padding = ''
|
|
|
|
if (j !== 0) {
|
|
// determine if we need padding
|
|
switch (tail) {
|
|
case STAR:
|
|
case TILDE:
|
|
case GREATERTHAN:
|
|
case PLUS:
|
|
case SPACE:
|
|
case OPENPARENTHESES: {
|
|
break
|
|
}
|
|
default: {
|
|
padding = ' '
|
|
}
|
|
}
|
|
}
|
|
|
|
switch (code) {
|
|
case AND: {
|
|
element = padding + nscopealt
|
|
}
|
|
case TILDE:
|
|
case GREATERTHAN:
|
|
case PLUS:
|
|
case SPACE:
|
|
case CLOSEPARENTHESES:
|
|
case OPENPARENTHESES: {
|
|
break
|
|
}
|
|
case OPENBRACKET: {
|
|
element = padding + element + nscopealt
|
|
break
|
|
}
|
|
case COLON: {
|
|
switch (element.charCodeAt(1)*2 + element.charCodeAt(2)*3) {
|
|
// :global
|
|
case 530: {
|
|
if (escape > 0) {
|
|
element = padding + element.substring(8, size - 1)
|
|
break
|
|
}
|
|
}
|
|
// :hover, :nth-child(), ...
|
|
default: {
|
|
if (j < 1 || elements[j-1].length < 1) {
|
|
element = padding + nscopealt + element
|
|
}
|
|
}
|
|
}
|
|
break
|
|
}
|
|
case COMMA: {
|
|
padding = ''
|
|
}
|
|
default: {
|
|
if (size > 1 && element.indexOf(':') > 0) {
|
|
element = padding + element.replace(pseudoptn, '$1' + nscopealt + '$2')
|
|
} else {
|
|
element = padding + element + nscopealt
|
|
}
|
|
}
|
|
}
|
|
|
|
out += element
|
|
}
|
|
|
|
selector[i] = out.replace(formatptn, '').trim()
|
|
}
|
|
|
|
return selector
|
|
}
|
|
|
|
/**
|
|
* Proxy
|
|
*
|
|
* @param {number} context
|
|
* @param {string} content
|
|
* @param {Array<string>} selectors
|
|
* @param {Array<string>} parents
|
|
* @param {number} line
|
|
* @param {number} column
|
|
* @param {number} length
|
|
* @param {number} id
|
|
* @param {number} depth
|
|
* @param {number} at
|
|
* @return {(string|void|*)}
|
|
*/
|
|
function proxy (context, content, selectors, parents, line, column, length, id, depth, at) {
|
|
for (var i = 0, out = content, next; i < plugged; ++i) {
|
|
switch (next = plugins[i].call(stylis, context, out, selectors, parents, line, column, length, id, depth, at)) {
|
|
case void 0:
|
|
case false:
|
|
case true:
|
|
case null: {
|
|
break
|
|
}
|
|
default: {
|
|
out = next
|
|
}
|
|
}
|
|
}
|
|
if (out !== content) {
|
|
return out
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {number} code
|
|
* @param {number} index
|
|
* @param {number} length
|
|
* @param {string} body
|
|
* @return {number}
|
|
*/
|
|
function delimited (code, index, length, body) {
|
|
for (var i = index + 1; i < length; ++i) {
|
|
switch (body.charCodeAt(i)) {
|
|
// /*
|
|
case FOWARDSLASH: {
|
|
if (code === STAR) {
|
|
if (body.charCodeAt(i - 1) === STAR && index + 2 !== i) {
|
|
return i + 1
|
|
}
|
|
}
|
|
break
|
|
}
|
|
// //
|
|
case NEWLINE: {
|
|
if (code === FOWARDSLASH) {
|
|
return i + 1
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return i
|
|
}
|
|
|
|
/**
|
|
* @param {number} type
|
|
* @param {number} index
|
|
* @param {number} length
|
|
* @param {number} find
|
|
* @param {string} body
|
|
* @return {number}
|
|
*/
|
|
function match (type, index, length, body) {
|
|
for (var i = index + 1; i < length; ++i) {
|
|
switch (body.charCodeAt(i)) {
|
|
case type: {
|
|
return i
|
|
}
|
|
}
|
|
}
|
|
|
|
return i
|
|
}
|
|
|
|
/**
|
|
* Minify
|
|
*
|
|
* @param {(string|*)} output
|
|
* @return {string}
|
|
*/
|
|
function minify (output) {
|
|
return output
|
|
.replace(formatptn, '')
|
|
.replace(beforeptn, '')
|
|
.replace(afterptn, '$1')
|
|
.replace(tailptn, '$1')
|
|
.replace(whiteptn, ' ')
|
|
}
|
|
|
|
/**
|
|
* Use
|
|
*
|
|
* @param {(Array<function(...?)>|function(...?)|number|void)?} plugin
|
|
*/
|
|
function use (plugin) {
|
|
switch (plugin) {
|
|
case void 0:
|
|
case null: {
|
|
plugged = plugins.length = 0
|
|
break
|
|
}
|
|
default: {
|
|
if (typeof plugin === 'function') {
|
|
plugins[plugged++] = plugin
|
|
} else if (typeof plugin === 'object') {
|
|
for (var i = 0, length = plugin.length; i < length; ++i) {
|
|
use(plugin[i])
|
|
}
|
|
} else {
|
|
unkwn = !!plugin|0
|
|
}
|
|
}
|
|
}
|
|
|
|
return use
|
|
}
|
|
|
|
/**
|
|
* Set
|
|
*
|
|
* @param {*} options
|
|
*/
|
|
function set (options) {
|
|
for (var name in options) {
|
|
var value = options[name]
|
|
switch (name) {
|
|
case 'keyframe': keyed = value|0; break
|
|
case 'global': escape = value|0; break
|
|
case 'cascade': cascade = value|0; break
|
|
case 'compress': compress = value|0; break
|
|
case 'semicolon': semicolon = value|0; break
|
|
case 'preserve': preserve = value|0; break
|
|
case 'prefix':
|
|
should = null
|
|
|
|
if (!value) {
|
|
prefix = 0
|
|
} else if (typeof value !== 'function') {
|
|
prefix = 1
|
|
} else {
|
|
prefix = 2
|
|
should = value
|
|
}
|
|
}
|
|
}
|
|
|
|
return set
|
|
}
|
|
|
|
/**
|
|
* Stylis
|
|
*
|
|
* @param {string} selector
|
|
* @param {string} input
|
|
* @return {*}
|
|
*/
|
|
function stylis (selector, input) {
|
|
if (this !== void 0 && this.constructor === stylis) {
|
|
return factory(selector)
|
|
}
|
|
|
|
// setup
|
|
var ns = selector
|
|
var code = ns.charCodeAt(0)
|
|
|
|
// trim leading whitespace
|
|
if (code < 33) {
|
|
code = (ns = ns.trim()).charCodeAt(0)
|
|
}
|
|
|
|
// keyframe/animation namespace
|
|
if (keyed > 0) {
|
|
key = ns.replace(invalidptn, code === OPENBRACKET ? '' : '-')
|
|
}
|
|
|
|
// reset, used to assert if a plugin is moneky-patching the return value
|
|
code = 1
|
|
|
|
// cascade/isolate
|
|
if (cascade === 1) {
|
|
nscope = ns
|
|
} else {
|
|
nscopealt = ns
|
|
}
|
|
|
|
var selectors = [nscope]
|
|
var result
|
|
|
|
// execute plugins, pre-process context
|
|
if (plugged > 0) {
|
|
result = proxy(PREPS, input, selectors, selectors, line, column, 0, 0, 0, 0)
|
|
|
|
if (result !== void 0 && typeof result === 'string') {
|
|
input = result
|
|
}
|
|
}
|
|
|
|
// build
|
|
var output = compile(array, selectors, input, 0, 0)
|
|
|
|
// execute plugins, post-process context
|
|
if (plugged > 0) {
|
|
result = proxy(POSTS, output, selectors, selectors, line, column, output.length, 0, 0, 0)
|
|
|
|
// bypass minification
|
|
if (result !== void 0 && typeof(output = result) !== 'string') {
|
|
code = 0
|
|
}
|
|
}
|
|
|
|
// reset
|
|
key = ''
|
|
nscope = ''
|
|
nscopealt = ''
|
|
pattern = 0
|
|
line = 1
|
|
column = 1
|
|
|
|
return compress*code === 0 ? output : minify(output)
|
|
}
|
|
|
|
stylis['use'] = use
|
|
stylis['set'] = set
|
|
|
|
if (options !== void 0) {
|
|
set(options)
|
|
}
|
|
|
|
return stylis
|
|
}));
|