psoejy7f5
/
Mieriki_test
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'fbcabf01d3'
${ noResults }
Mieriki_test/node_modules/vite/dist/node/chunks/dep-afe9ad01.js

11392 lines
311 KiB
Raw Normal View History Unescape

项目初始化
8 months ago
'use strict';
var require$$0 = require('postcss');
var build$2 = require('./dep-1be34a63.js');
var path$4 = require('path');
var require$$1 = require('crypto');
var fs = require('fs');
var require$$0$1 = require('util');
var index$1 = require('./dep-e36486f6.js');
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e['default'] : e; }
var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0);
var path__default = /*#__PURE__*/_interopDefaultLegacy(path$4);
var require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1);
var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
var require$$0__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$0$1);
var build$1 = {exports: {}};
/**
* lodash (Custom Build) <https://lodash.com/>
* Build: `lodash modularize exports="npm" -o ./`
* Copyright jQuery Foundation and other contributors <https://jquery.org/>
* Released under MIT license <https://lodash.com/license>
* Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
* Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
*/
/** Used as references for various `Number` constants. */
var INFINITY = 1 / 0;
/** `Object#toString` result references. */
var symbolTag = '[object Symbol]';
/** Used to match words composed of alphanumeric characters. */
var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
/** Used to match Latin Unicode letters (excluding mathematical operators). */
var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
/** Used to compose unicode character classes. */
var rsAstralRange = '\\ud800-\\udfff',
rsComboMarksRange = '\\u0300-\\u036f\\ufe20-\\ufe23',
rsComboSymbolsRange = '\\u20d0-\\u20f0',
rsDingbatRange = '\\u2700-\\u27bf',
rsLowerRange = 'a-z\\xdf-\\xf6\\xf8-\\xff',
rsMathOpRange = '\\xac\\xb1\\xd7\\xf7',
rsNonCharRange = '\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf',
rsPunctuationRange = '\\u2000-\\u206f',
rsSpaceRange = ' \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000',
rsUpperRange = 'A-Z\\xc0-\\xd6\\xd8-\\xde',
rsVarRange = '\\ufe0e\\ufe0f',
rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;
/** Used to compose unicode capture groups. */
var rsApos = "['\u2019]",
rsAstral = '[' + rsAstralRange + ']',
rsBreak = '[' + rsBreakRange + ']',
rsCombo = '[' + rsComboMarksRange + rsComboSymbolsRange + ']',
rsDigits = '\\d+',
rsDingbat = '[' + rsDingbatRange + ']',
rsLower = '[' + rsLowerRange + ']',
rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']',
rsFitz = '\\ud83c[\\udffb-\\udfff]',
rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',
rsNonAstral = '[^' + rsAstralRange + ']',
rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}',
rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]',
rsUpper = '[' + rsUpperRange + ']',
rsZWJ = '\\u200d';
/** Used to compose unicode regexes. */
var rsLowerMisc = '(?:' + rsLower + '|' + rsMisc + ')',
rsUpperMisc = '(?:' + rsUpper + '|' + rsMisc + ')',
rsOptLowerContr = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?',
rsOptUpperContr = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?',
reOptMod = rsModifier + '?',
rsOptVar = '[' + rsVarRange + ']?',
rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',
rsSeq = rsOptVar + reOptMod + rsOptJoin,
rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq,
rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';
/** Used to match apostrophes. */
var reApos = RegExp(rsApos, 'g');
/**
* Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and
* [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).
*/
var reComboMark = RegExp(rsCombo, 'g');
/** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */
var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');
/** Used to match complex or compound words. */
var reUnicodeWord = RegExp([
rsUpper + '?' + rsLower + '+' + rsOptLowerContr + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')',
rsUpperMisc + '+' + rsOptUpperContr + '(?=' + [rsBreak, rsUpper + rsLowerMisc, '$'].join('|') + ')',
rsUpper + '?' + rsLowerMisc + '+' + rsOptLowerContr,
rsUpper + '+' + rsOptUpperContr,
rsDigits,
rsEmoji
].join('|'), 'g');
/** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */
var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange + rsComboMarksRange + rsComboSymbolsRange + rsVarRange + ']');
/** Used to detect strings that need a more robust regexp to match words. */
var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2,}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;
/** Used to map Latin Unicode letters to basic Latin letters. */
var deburredLetters = {
// Latin-1 Supplement block.
'\xc0': 'A', '\xc1': 'A', '\xc2': 'A', '\xc3': 'A', '\xc4': 'A', '\xc5': 'A',
'\xe0': 'a', '\xe1': 'a', '\xe2': 'a', '\xe3': 'a', '\xe4': 'a', '\xe5': 'a',
'\xc7': 'C', '\xe7': 'c',
'\xd0': 'D', '\xf0': 'd',
'\xc8': 'E', '\xc9': 'E', '\xca': 'E', '\xcb': 'E',
'\xe8': 'e', '\xe9': 'e', '\xea': 'e', '\xeb': 'e',
'\xcc': 'I', '\xcd': 'I', '\xce': 'I', '\xcf': 'I',
'\xec': 'i', '\xed': 'i', '\xee': 'i', '\xef': 'i',
'\xd1': 'N', '\xf1': 'n',
'\xd2': 'O', '\xd3': 'O', '\xd4': 'O', '\xd5': 'O', '\xd6': 'O', '\xd8': 'O',
'\xf2': 'o', '\xf3': 'o', '\xf4': 'o', '\xf5': 'o', '\xf6': 'o', '\xf8': 'o',
'\xd9': 'U', '\xda': 'U', '\xdb': 'U', '\xdc': 'U',
'\xf9': 'u', '\xfa': 'u', '\xfb': 'u', '\xfc': 'u',
'\xdd': 'Y', '\xfd': 'y', '\xff': 'y',
'\xc6': 'Ae', '\xe6': 'ae',
'\xde': 'Th', '\xfe': 'th',
'\xdf': 'ss',
// Latin Extended-A block.
'\u0100': 'A', '\u0102': 'A', '\u0104': 'A',
'\u0101': 'a', '\u0103': 'a', '\u0105': 'a',
'\u0106': 'C', '\u0108': 'C', '\u010a': 'C', '\u010c': 'C',
'\u0107': 'c', '\u0109': 'c', '\u010b': 'c', '\u010d': 'c',
'\u010e': 'D', '\u0110': 'D', '\u010f': 'd', '\u0111': 'd',
'\u0112': 'E', '\u0114': 'E', '\u0116': 'E', '\u0118': 'E', '\u011a': 'E',
'\u0113': 'e', '\u0115': 'e', '\u0117': 'e', '\u0119': 'e', '\u011b': 'e',
'\u011c': 'G', '\u011e': 'G', '\u0120': 'G', '\u0122': 'G',
'\u011d': 'g', '\u011f': 'g', '\u0121': 'g', '\u0123': 'g',
'\u0124': 'H', '\u0126': 'H', '\u0125': 'h', '\u0127': 'h',
'\u0128': 'I', '\u012a': 'I', '\u012c': 'I', '\u012e': 'I', '\u0130': 'I',
'\u0129': 'i', '\u012b': 'i', '\u012d': 'i', '\u012f': 'i', '\u0131': 'i',
'\u0134': 'J', '\u0135': 'j',
'\u0136': 'K', '\u0137': 'k', '\u0138': 'k',
'\u0139': 'L', '\u013b': 'L', '\u013d': 'L', '\u013f': 'L', '\u0141': 'L',
'\u013a': 'l', '\u013c': 'l', '\u013e': 'l', '\u0140': 'l', '\u0142': 'l',
'\u0143': 'N', '\u0145': 'N', '\u0147': 'N', '\u014a': 'N',
'\u0144': 'n', '\u0146': 'n', '\u0148': 'n', '\u014b': 'n',
'\u014c': 'O', '\u014e': 'O', '\u0150': 'O',
'\u014d': 'o', '\u014f': 'o', '\u0151': 'o',
'\u0154': 'R', '\u0156': 'R', '\u0158': 'R',
'\u0155': 'r', '\u0157': 'r', '\u0159': 'r',
'\u015a': 'S', '\u015c': 'S', '\u015e': 'S', '\u0160': 'S',
'\u015b': 's', '\u015d': 's', '\u015f': 's', '\u0161': 's',
'\u0162': 'T', '\u0164': 'T', '\u0166': 'T',
'\u0163': 't', '\u0165': 't', '\u0167': 't',
'\u0168': 'U', '\u016a': 'U', '\u016c': 'U', '\u016e': 'U', '\u0170': 'U', '\u0172': 'U',
'\u0169': 'u', '\u016b': 'u', '\u016d': 'u', '\u016f': 'u', '\u0171': 'u', '\u0173': 'u',
'\u0174': 'W', '\u0175': 'w',
'\u0176': 'Y', '\u0177': 'y', '\u0178': 'Y',
'\u0179': 'Z', '\u017b': 'Z', '\u017d': 'Z',
'\u017a': 'z', '\u017c': 'z', '\u017e': 'z',
'\u0132': 'IJ', '\u0133': 'ij',
'\u0152': 'Oe', '\u0153': 'oe',
'\u0149': "'n", '\u017f': 'ss'
};
/** Detect free variable `global` from Node.js. */
var freeGlobal = typeof build$2.commonjsGlobal == 'object' && build$2.commonjsGlobal && build$2.commonjsGlobal.Object === Object && build$2.commonjsGlobal;
/** Detect free variable `self`. */
var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
/** Used as a reference to the global object. */
var root$2 = freeGlobal || freeSelf || Function('return this')();
/**
* A specialized version of `_.reduce` for arrays without support for
* iteratee shorthands.
*
* @private
* @param {Array} [array] The array to iterate over.
* @param {Function} iteratee The function invoked per iteration.
* @param {*} [accumulator] The initial value.
* @param {boolean} [initAccum] Specify using the first element of `array` as
* the initial value.
* @returns {*} Returns the accumulated value.
*/
function arrayReduce(array, iteratee, accumulator, initAccum) {
var index = -1,
length = array ? array.length : 0;
if (initAccum && length) {
accumulator = array[++index];
}
while (++index < length) {
accumulator = iteratee(accumulator, array[index], index, array);
}
return accumulator;
}
/**
* Converts an ASCII `string` to an array.
*
* @private
* @param {string} string The string to convert.
* @returns {Array} Returns the converted array.
*/
function asciiToArray(string) {
return string.split('');
}
/**
* Splits an ASCII `string` into an array of its words.
*
* @private
* @param {string} The string to inspect.
* @returns {Array} Returns the words of `string`.
*/
function asciiWords(string) {
return string.match(reAsciiWord) || [];
}
/**
* The base implementation of `_.propertyOf` without support for deep paths.
*
* @private
* @param {Object} object The object to query.
* @returns {Function} Returns the new accessor function.
*/
function basePropertyOf(object) {
return function(key) {
return object == null ? undefined : object[key];
};
}
/**
* Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A
* letters to basic Latin letters.
*
* @private
* @param {string} letter The matched letter to deburr.
* @returns {string} Returns the deburred letter.
*/
var deburrLetter = basePropertyOf(deburredLetters);
/**
* Checks if `string` contains Unicode symbols.
*
* @private
* @param {string} string The string to inspect.
* @returns {boolean} Returns `true` if a symbol is found, else `false`.
*/
function hasUnicode(string) {
return reHasUnicode.test(string);
}
/**
* Checks if `string` contains a word composed of Unicode symbols.
*
* @private
* @param {string} string The string to inspect.
* @returns {boolean} Returns `true` if a word is found, else `false`.
*/
function hasUnicodeWord(string) {
return reHasUnicodeWord.test(string);
}
/**
* Converts `string` to an array.
*
* @private
* @param {string} string The string to convert.
* @returns {Array} Returns the converted array.
*/
function stringToArray(string) {
return hasUnicode(string)
? unicodeToArray(string)
: asciiToArray(string);
}
/**
* Converts a Unicode `string` to an array.
*
* @private
* @param {string} string The string to convert.
* @returns {Array} Returns the converted array.
*/
function unicodeToArray(string) {
return string.match(reUnicode) || [];
}
/**
* Splits a Unicode `string` into an array of its words.
*
* @private
* @param {string} The string to inspect.
* @returns {Array} Returns the words of `string`.
*/
function unicodeWords(string) {
return string.match(reUnicodeWord) || [];
}
/** Used for built-in method references. */
var objectProto = Object.prototype;
/**
* Used to resolve the
* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
* of values.
*/
var objectToString = objectProto.toString;
/** Built-in value references. */
var Symbol$1 = root$2.Symbol;
/** Used to convert symbols to primitives and strings. */
var symbolProto = Symbol$1 ? Symbol$1.prototype : undefined,
symbolToString = symbolProto ? symbolProto.toString : undefined;
/**
* The base implementation of `_.slice` without an iteratee call guard.
*
* @private
* @param {Array} array The array to slice.
* @param {number} [start=0] The start position.
* @param {number} [end=array.length] The end position.
* @returns {Array} Returns the slice of `array`.
*/
function baseSlice(array, start, end) {
var index = -1,
length = array.length;
if (start < 0) {
start = -start > length ? 0 : (length + start);
}
end = end > length ? length : end;
if (end < 0) {
end += length;
}
length = start > end ? 0 : ((end - start) >>> 0);
start >>>= 0;
var result = Array(length);
while (++index < length) {
result[index] = array[index + start];
}
return result;
}
/**
* The base implementation of `_.toString` which doesn't convert nullish
* values to empty strings.
*
* @private
* @param {*} value The value to process.
* @returns {string} Returns the string.
*/
function baseToString(value) {
// Exit early for strings to avoid a performance hit in some environments.
if (typeof value == 'string') {
return value;
}
if (isSymbol(value)) {
return symbolToString ? symbolToString.call(value) : '';
}
var result = (value + '');
return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
}
/**
* Casts `array` to a slice if it's needed.
*
* @private
* @param {Array} array The array to inspect.
* @param {number} start The start position.
* @param {number} [end=array.length] The end position.
* @returns {Array} Returns the cast slice.
*/
function castSlice(array, start, end) {
var length = array.length;
end = end === undefined ? length : end;
return (!start && end >= length) ? array : baseSlice(array, start, end);
}
/**
* Creates a function like `_.lowerFirst`.
*
* @private
* @param {string} methodName The name of the `String` case method to use.
* @returns {Function} Returns the new case function.
*/
function createCaseFirst(methodName) {
return function(string) {
string = toString(string);
var strSymbols = hasUnicode(string)
? stringToArray(string)
: undefined;
var chr = strSymbols
? strSymbols[0]
: string.charAt(0);
var trailing = strSymbols
? castSlice(strSymbols, 1).join('')
: string.slice(1);
return chr[methodName]() + trailing;
};
}
/**
* Creates a function like `_.camelCase`.
*
* @private
* @param {Function} callback The function to combine each word.
* @returns {Function} Returns the new compounder function.
*/
function createCompounder(callback) {
return function(string) {
return arrayReduce(words(deburr(string).replace(reApos, '')), callback, '');
};
}
/**
* Checks if `value` is object-like. A value is object-like if it's not `null`
* and has a `typeof` result of "object".
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is object-like, else `false`.
* @example
*
* _.isObjectLike({});
* // => true
*
* _.isObjectLike([1, 2, 3]);
* // => true
*
* _.isObjectLike(_.noop);
* // => false
*
* _.isObjectLike(null);
* // => false
*/
function isObjectLike(value) {
return !!value && typeof value == 'object';
}
/**
* Checks if `value` is classified as a `Symbol` primitive or object.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
* @example
*
* _.isSymbol(Symbol.iterator);
* // => true
*
* _.isSymbol('abc');
* // => false
*/
function isSymbol(value) {
return typeof value == 'symbol' ||
(isObjectLike(value) && objectToString.call(value) == symbolTag);
}
/**
* Converts `value` to a string. An empty string is returned for `null`
* and `undefined` values. The sign of `-0` is preserved.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to process.
* @returns {string} Returns the string.
* @example
*
* _.toString(null);
* // => ''
*
* _.toString(-0);
* // => '-0'
*
* _.toString([1, 2, 3]);
* // => '1,2,3'
*/
function toString(value) {
return value == null ? '' : baseToString(value);
}
/**
* Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase).
*
* @static
* @memberOf _
* @since 3.0.0
* @category String
* @param {string} [string=''] The string to convert.
* @returns {string} Returns the camel cased string.
* @example
*
* _.camelCase('Foo Bar');
* // => 'fooBar'
*
* _.camelCase('--foo-bar--');
* // => 'fooBar'
*
* _.camelCase('__FOO_BAR__');
* // => 'fooBar'
*/
var camelCase = createCompounder(function(result, word, index) {
word = word.toLowerCase();
return result + (index ? capitalize(word) : word);
});
/**
* Converts the first character of `string` to upper case and the remaining
* to lower case.
*
* @static
* @memberOf _
* @since 3.0.0
* @category String
* @param {string} [string=''] The string to capitalize.
* @returns {string} Returns the capitalized string.
* @example
*
* _.capitalize('FRED');
* // => 'Fred'
*/
function capitalize(string) {
return upperFirst(toString(string).toLowerCase());
}
/**
* Deburrs `string` by converting
* [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)
* and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)
* letters to basic Latin letters and removing
* [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).
*
* @static
* @memberOf _
* @since 3.0.0
* @category String
* @param {string} [string=''] The string to deburr.
* @returns {string} Returns the deburred string.
* @example
*
* _.deburr('déjà vu');
* // => 'deja vu'
*/
function deburr(string) {
string = toString(string);
return string && string.replace(reLatin, deburrLetter).replace(reComboMark, '');
}
/**
* Converts the first character of `string` to upper case.
*
* @static
* @memberOf _
* @since 4.0.0
* @category String
* @param {string} [string=''] The string to convert.
* @returns {string} Returns the converted string.
* @example
*
* _.upperFirst('fred');
* // => 'Fred'
*
* _.upperFirst('FRED');
* // => 'FRED'
*/
var upperFirst = createCaseFirst('toUpperCase');
/**
* Splits `string` into an array of its words.
*
* @static
* @memberOf _
* @since 3.0.0
* @category String
* @param {string} [string=''] The string to inspect.
* @param {RegExp|string} [pattern] The pattern to match words.
* @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
* @returns {Array} Returns the words of `string`.
* @example
*
* _.words('fred, barney, & pebbles');
* // => ['fred', 'barney', 'pebbles']
*
* _.words('fred, barney, & pebbles', /[^, ]+/g);
* // => ['fred', 'barney', '&', 'pebbles']
*/
function words(string, pattern, guard) {
string = toString(string);
pattern = guard ? undefined : pattern;
if (pattern === undefined) {
return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);
}
return string.match(pattern) || [];
}
var lodash_camelcase = camelCase;
var lib$2 = {};
var lib$1 = {exports: {}};
var parse = {exports: {}};
var util$1 = {};
var unicode$1 = {};
Object.defineProperty(unicode$1,"__esModule",{value:true});unicode$1.Space_Separator=/[\u1680\u2000-\u200A\u202F\u205F\u3000]/;unicode$1.ID_Start=/[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B4\u08B6-\u08BD\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FD5\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\
Object.defineProperty(util$1,'__esModule',{value:true});util$1.isSpaceSeparator=isSpaceSeparator;util$1.isIdStartChar=isIdStartChar;util$1.isIdContinueChar=isIdContinueChar;util$1.isDigit=isDigit;util$1.isHexDigit=isHexDigit;var _unicode=unicode$1;var unicode=_interopRequireWildcard(_unicode);function _interopRequireWildcard(obj){if(obj&&obj.__esModule){return obj}else {var newObj={};if(obj!=null){for(var key in obj){if(Object.prototype.hasOwnProperty.call(obj,key))newObj[key]=obj[key];}}newObj.default=obj;return newObj}}function isSpaceSeparator(c){return unicode.Space_Separator.test(c)}function isIdStartChar(c){return c>='a'&&c<='z'||c>='A'&&c<='Z'||c==='$'||c==='_'||unicode.ID_Start.test(c)}function isIdContinueChar(c){return c>='a'&&c<='z'||c>='A'&&c<='Z'||c>='0'&&c<='9'||c==='$'||c==='_'||c==='\u200C'||c==='\u200D'||unicode.ID_Continue.test(c)}function isDigit(c){return /[0-9]/.test(c)}function isHexDigit(c){return /[0-9A-Fa-f]/.test(c)}
(function (module, exports) {
Object.defineProperty(exports,'__esModule',{value:true});var _typeof=typeof Symbol==='function'&&typeof Symbol.iterator==='symbol'?function(obj){return typeof obj}:function(obj){return obj&&typeof Symbol==='function'&&obj.constructor===Symbol&&obj!==Symbol.prototype?'symbol':typeof obj};exports.default=parse;var _util=util$1;var util=_interopRequireWildcard(_util);function _interopRequireWildcard(obj){if(obj&&obj.__esModule){return obj}else {var newObj={};if(obj!=null){for(var key in obj){if(Object.prototype.hasOwnProperty.call(obj,key))newObj[key]=obj[key];}}newObj.default=obj;return newObj}}var source=void 0;var parseState=void 0;var stack=void 0;var pos=void 0;var line=void 0;var column=void 0;var token=void 0;var key=void 0;var root=void 0;function parse(text,reviver){source=String(text);parseState='start';stack=[];pos=0;line=1;column=0;token=undefined;key=undefined;root=undefined;do{token=lex();parseStates[parseState]();}while(token.type!=='eof');if(typeof reviver==='function'){return internalize({'':root},'',reviver)}return root}function internalize(holder,name,reviver){var value=holder[name];if(value!=null&&(typeof value==='undefined'?'undefined':_typeof(value))==='object'){for(var _key in value){var replacement=internalize(value,_key,reviver);if(replacement===undefined){delete value[_key];}else {value[_key]=replacement;}}}return reviver.call(holder,name,value)}var lexState=void 0;var buffer=void 0;var doubleQuote=void 0;var _sign=void 0;var c=void 0;function lex(){lexState='default';buffer='';doubleQuote=false;_sign=1;for(;;){c=peek();var _token=lexStates[lexState]();if(_token){return _token}}}function peek(){if(source[pos]){return String.fromCodePoint(source.codePointAt(pos))}}function read(){var c=peek();if(c==='\n'){line++;column=0;}else if(c){column+=c.length;}else {column++;}if(c){pos+=c.length;}return c}var lexStates={default:function _default(){switch(c){case'\t':case'\x0B':case'\f':case' ':case'\xA0':case'\uFEFF':case'\n':case'\r':case'\u2028':case'\u2029':read();return;case'/':read();lexState='comment';return;case undefined:read();return newToken('eof');}if(util.isSpaceSeparator(c)){read();return}return lexStates[parseState]()},comment:function comment(){switch(c){case'*':read();lexState='multiLineComment';return;case'/':read();lexState='singleLineComment';return;}throw invalidChar(read())},multiLineComment:function multiLineComment(){switch(c){case'*':read();lexState='multiLineCommentAsterisk';return;case undefined:throw invalidChar(read());}read();},multiLineCommentAsterisk:function multiLineCommentAsterisk(){switch(c){case'*':read();return;case'/':read();lexState='default';return;case undefined:throw invalidChar(read());}read();lexState='multiLineComment';},singleLineComment:function singleLineComment(){switch(c){case'\n':case'\r':case'\u2028':case'\u2029':read();lexState='default';return;case undefined:read();return newToken('eof');}read();},value:function value(){switch(c){case'{':case'[':return newToken('punctuator',read());case'n':read();literal('ull');return newToken('null',null);case't':read();literal('rue');return newToken('boolean',true);case'f':read();literal('alse');return newToken('boolean',false);case'-':case'+':if(read()==='-'){_sign=-1;}lexState='sign';return;case'.':buffer=read();lexState='decimalPointLeading';return;case'0':buffer=read();lexState='zero';return;case'1':case'2':case'3':case'4':case'5':case'6':case'7':case'8':case'9':buffer=read();lexState='decimalInteger';return;case'I':read();literal('nfinity');return newToken('numeric',Infinity);case'N':read();literal('aN');return newToken('numeric',NaN);case'"':case'\'':doubleQuote=read()==='"';buffer='';lexState='string';return;}throw invalidChar(read())},identifierNameStartEscape:function identifierNameStartEscape(){if(c!=='u'){throw invalidChar(read())}read();var u=unicodeEscape();switch(u){case'$':case'_':break;default:if(!util.isIdStartChar(u)){throw invalidIdentifier()}break;}buffer+=u;lexState='identifierName';},identifierName:function identifierName(){switch(c){case'$':case'_':case'\u200C':case'\u200D':buffer+=read();return;c
}(parse, parse.exports));
var stringify = {exports: {}};
(function (module, exports) {
Object.defineProperty(exports,'__esModule',{value:true});var _typeof=typeof Symbol==='function'&&typeof Symbol.iterator==='symbol'?function(obj){return typeof obj}:function(obj){return obj&&typeof Symbol==='function'&&obj.constructor===Symbol&&obj!==Symbol.prototype?'symbol':typeof obj};exports.default=stringify;var _util=util$1;var util=_interopRequireWildcard(_util);function _interopRequireWildcard(obj){if(obj&&obj.__esModule){return obj}else {var newObj={};if(obj!=null){for(var key in obj){if(Object.prototype.hasOwnProperty.call(obj,key))newObj[key]=obj[key];}}newObj.default=obj;return newObj}}function stringify(value,replacer,space){var stack=[];var indent='';var propertyList=void 0;var replacerFunc=void 0;var gap='';var quote=void 0;if(replacer!=null&&(typeof replacer==='undefined'?'undefined':_typeof(replacer))==='object'&&!Array.isArray(replacer)){space=replacer.space;quote=replacer.quote;replacer=replacer.replacer;}if(typeof replacer==='function'){replacerFunc=replacer;}else if(Array.isArray(replacer)){propertyList=[];var _iteratorNormalCompletion=true;var _didIteratorError=false;var _iteratorError=undefined;try{for(var _iterator=replacer[Symbol.iterator](),_step;!(_iteratorNormalCompletion=(_step=_iterator.next()).done);_iteratorNormalCompletion=true){var v=_step.value;var item=void 0;if(typeof v==='string'){item=v;}else if(typeof v==='number'||v instanceof String||v instanceof Number){item=String(v);}if(item!==undefined&&propertyList.indexOf(item)<0){propertyList.push(item);}}}catch(err){_didIteratorError=true;_iteratorError=err;}finally{try{if(!_iteratorNormalCompletion&&_iterator.return){_iterator.return();}}finally{if(_didIteratorError){throw _iteratorError}}}}if(space instanceof Number){space=Number(space);}else if(space instanceof String){space=String(space);}if(typeof space==='number'){if(space>0){space=Math.min(10,Math.floor(space));gap=' '.substr(0,space);}}else if(typeof space==='string'){gap=space.substr(0,10);}return serializeProperty('',{'':value});function serializeProperty(key,holder){var value=holder[key];if(value!=null){if(typeof value.toJSON5==='function'){value=value.toJSON5(key);}else if(typeof value.toJSON==='function'){value=value.toJSON(key);}}if(replacerFunc){value=replacerFunc.call(holder,key,value);}if(value instanceof Number){value=Number(value);}else if(value instanceof String){value=String(value);}else if(value instanceof Boolean){value=value.valueOf();}switch(value){case null:return 'null';case true:return 'true';case false:return 'false';}if(typeof value==='string'){return quoteString(value)}if(typeof value==='number'){return String(value)}if((typeof value==='undefined'?'undefined':_typeof(value))==='object'){return Array.isArray(value)?serializeArray(value):serializeObject(value)}return undefined}function quoteString(value){var quotes={'\'':0.1,'"':0.2};var replacements={'\'':'\\\'','"':'\\"','\\':'\\\\','\b':'\\b','\f':'\\f','\n':'\\n','\r':'\\r','\t':'\\t','\x0B':'\\v','\0':'\\0','\u2028':'\\u2028','\u2029':'\\u2029'};var product='';var _iteratorNormalCompletion2=true;var _didIteratorError2=false;var _iteratorError2=undefined;try{for(var _iterator2=value[Symbol.iterator](),_step2;!(_iteratorNormalCompletion2=(_step2=_iterator2.next()).done);_iteratorNormalCompletion2=true){var c=_step2.value;switch(c){case'\'':case'"':quotes[c]++;product+=c;continue;}if(replacements[c]){product+=replacements[c];continue}if(c<' '){var hexString=c.charCodeAt(0).toString(16);product+='\\x'+('00'+hexString).substring(hexString.length);continue}product+=c;}}catch(err){_didIteratorError2=true;_iteratorError2=err;}finally{try{if(!_iteratorNormalCompletion2&&_iterator2.return){_iterator2.return();}}finally{if(_didIteratorError2){throw _iteratorError2}}}var quoteChar=quote||Object.keys(quotes).reduce(function(a,b){return quotes[a]<quotes[b]?a:b});product=product.replace(new RegExp(quoteChar,'g'),replacements[quoteChar]);return quoteChar+product+quoteChar}function serializeObject(value){if(stack.indexOf(value)>=0){throw TypeError('Converting circular structure to JSON5')}stack.push(value);var st
}(stringify, stringify.exports));
(function (module, exports) {
Object.defineProperty(exports,'__esModule',{value:true});var _parse=parse.exports;var _parse2=_interopRequireDefault(_parse);var _stringify=stringify.exports;var _stringify2=_interopRequireDefault(_stringify);function _interopRequireDefault(obj){return obj&&obj.__esModule?obj:{default:obj}}exports.default={parse:_parse2.default,stringify:_stringify2.default};module.exports=exports['default'];
}(lib$1, lib$1.exports));
const JSON5 = lib$1.exports;
const specialValues = {
null: null,
true: true,
false: false,
};
function parseQuery$2(query) {
if (query.substr(0, 1) !== '?') {
throw new Error(
"A valid query string passed to parseQuery should begin with '?'"
);
}
query = query.substr(1);
if (!query) {
return {};
}
if (query.substr(0, 1) === '{' && query.substr(-1) === '}') {
return JSON5.parse(query);
}
const queryArgs = query.split(/[,&]/g);
const result = {};
queryArgs.forEach((arg) => {
const idx = arg.indexOf('=');
if (idx >= 0) {
let name = arg.substr(0, idx);
let value = decodeURIComponent(arg.substr(idx + 1));
if (specialValues.hasOwnProperty(value)) {
value = specialValues[value];
}
if (name.substr(-2) === '[]') {
name = decodeURIComponent(name.substr(0, name.length - 2));
if (!Array.isArray(result[name])) {
result[name] = [];
}
result[name].push(value);
} else {
name = decodeURIComponent(name);
result[name] = value;
}
} else {
if (arg.substr(0, 1) === '-') {
result[decodeURIComponent(arg.substr(1))] = false;
} else if (arg.substr(0, 1) === '+') {
result[decodeURIComponent(arg.substr(1))] = true;
} else {
result[decodeURIComponent(arg)] = true;
}
}
});
return result;
}
var parseQuery_1 = parseQuery$2;
const parseQuery$1 = parseQuery_1;
function getOptions$1(loaderContext) {
const query = loaderContext.query;
if (typeof query === 'string' && query !== '') {
return parseQuery$1(loaderContext.query);
}
if (!query || typeof query !== 'object') {
// Not object-like queries are not supported.
return null;
}
return query;
}
var getOptions_1 = getOptions$1;
const path$3 = path__default;
const matchRelativePath = /^\.\.?[/\\]/;
function isAbsolutePath(str) {
return path$3.posix.isAbsolute(str) || path$3.win32.isAbsolute(str);
}
function isRelativePath(str) {
return matchRelativePath.test(str);
}
function stringifyRequest$1(loaderContext, request) {
const splitted = request.split('!');
const context =
loaderContext.context ||
(loaderContext.options && loaderContext.options.context);
return JSON.stringify(
splitted
.map((part) => {
// First, separate singlePath from query, because the query might contain paths again
const splittedPart = part.match(/^(.*?)(\?.*)/);
const query = splittedPart ? splittedPart[2] : '';
let singlePath = splittedPart ? splittedPart[1] : part;
if (isAbsolutePath(singlePath) && context) {
singlePath = path$3.relative(context, singlePath);
if (isAbsolutePath(singlePath)) {
// If singlePath still matches an absolute path, singlePath was on a different drive than context.
// In this case, we leave the path platform-specific without replacing any separators.
// @see https://github.com/webpack/loader-utils/pull/14
return singlePath + query;
}
if (isRelativePath(singlePath) === false) {
// Ensure that the relative path starts at least with ./ otherwise it would be a request into the modules directory (like node_modules).
singlePath = './' + singlePath;
}
}
return singlePath.replace(/\\/g, '/') + query;
})
.join('!')
);
}
var stringifyRequest_1 = stringifyRequest$1;
function getRemainingRequest$1(loaderContext) {
if (loaderContext.remainingRequest) {
return loaderContext.remainingRequest;
}
const request = loaderContext.loaders
.slice(loaderContext.loaderIndex + 1)
.map((obj) => obj.request)
.concat([loaderContext.resource]);
return request.join('!');
}
var getRemainingRequest_1 = getRemainingRequest$1;
function getCurrentRequest$1(loaderContext) {
if (loaderContext.currentRequest) {
return loaderContext.currentRequest;
}
const request = loaderContext.loaders
.slice(loaderContext.loaderIndex)
.map((obj) => obj.request)
.concat([loaderContext.resource]);
return request.join('!');
}
var getCurrentRequest_1 = getCurrentRequest$1;
const path$2 = path__default;
function isUrlRequest$1(url, root) {
// An URL is not an request if
// 1. It's an absolute url and it is not `windows` path like `C:\dir\file`
if (/^[a-z][a-z0-9+.-]*:/i.test(url) && !path$2.win32.isAbsolute(url)) {
return false;
}
// 2. It's a protocol-relative
if (/^\/\//.test(url)) {
return false;
}
// 3. It's some kind of url for a template
if (/^[{}[\]#*;,'§$%&(=?`´^°<>]/.test(url)) {
return false;
}
// 4. It's also not an request if root isn't set and it's a root-relative url
if ((root === undefined || root === false) && /^\//.test(url)) {
return false;
}
return true;
}
var isUrlRequest_1 = isUrlRequest$1;
// we can't use path.win32.isAbsolute because it also matches paths starting with a forward slash
const matchNativeWin32Path = /^[A-Z]:[/\\]|^\\\\/i;
function urlToRequest$1(url, root) {
// Do not rewrite an empty url
if (url === '') {
return '';
}
const moduleRequestRegex = /^[^?]*~/;
let request;
if (matchNativeWin32Path.test(url)) {
// absolute windows path, keep it
request = url;
} else if (root !== undefined && root !== false && /^\//.test(url)) {
// if root is set and the url is root-relative
switch (typeof root) {
// 1. root is a string: root is prefixed to the url
case 'string':
// special case: `~` roots convert to module request
if (moduleRequestRegex.test(root)) {
request = root.replace(/([^~/])$/, '$1/') + url.slice(1);
} else {
request = root + url;
}
break;
// 2. root is `true`: absolute paths are allowed
// *nix only, windows-style absolute paths are always allowed as they doesn't start with a `/`
case 'boolean':
request = url;
break;
default:
throw new Error(
"Unexpected parameters to loader-utils 'urlToRequest': url = " +
url +
', root = ' +
root +
'.'
);
}
} else if (/^\.\.?\//.test(url)) {
// A relative url stays
request = url;
} else {
// every other url is threaded like a relative url
request = './' + url;
}
// A `~` makes the url an module
if (moduleRequestRegex.test(request)) {
request = request.replace(moduleRequestRegex, '');
}
return request;
}
var urlToRequest_1 = urlToRequest$1;
function parseString$1(str) {
try {
if (str[0] === '"') {
return JSON.parse(str);
}
if (str[0] === "'" && str.substr(str.length - 1) === "'") {
return parseString$1(
str
.replace(/\\.|"/g, (x) => (x === '"' ? '\\"' : x))
.replace(/^'|'$/g, '"')
);
}
return JSON.parse('"' + str + '"');
} catch (e) {
return str;
}
}
var parseString_1 = parseString$1;
var big = {exports: {}};
/*
* big.js v5.2.2
* A small, fast, easy-to-use library for arbitrary-precision decimal arithmetic.
* Copyright (c) 2018 Michael Mclaughlin <M8ch88l@gmail.com>
* https://github.com/MikeMcl/big.js/LICENCE
*/
(function (module) {
(function (GLOBAL) {
var Big,
/************************************** EDITABLE DEFAULTS *****************************************/
// The default values below must be integers within the stated ranges.
/*
* The maximum number of decimal places (DP) of the results of operations involving division:
* div and sqrt, and pow with negative exponents.
*/
DP = 20, // 0 to MAX_DP
/*
* The rounding mode (RM) used when rounding to the above decimal places.
*
* 0 Towards zero (i.e. truncate, no rounding). (ROUND_DOWN)
* 1 To nearest neighbour. If equidistant, round up. (ROUND_HALF_UP)
* 2 To nearest neighbour. If equidistant, to even. (ROUND_HALF_EVEN)
* 3 Away from zero. (ROUND_UP)
*/
RM = 1, // 0, 1, 2 or 3
// The maximum value of DP and Big.DP.
MAX_DP = 1E6, // 0 to 1000000
// The maximum magnitude of the exponent argument to the pow method.
MAX_POWER = 1E6, // 1 to 1000000
/*
* The negative exponent (NE) at and beneath which toString returns exponential notation.
* (JavaScript numbers: -7)
* -1000000 is the minimum recommended exponent value of a Big.
*/
NE = -7, // 0 to -1000000
/*
* The positive exponent (PE) at and above which toString returns exponential notation.
* (JavaScript numbers: 21)
* 1000000 is the maximum recommended exponent value of a Big.
* (This limit is not enforced or checked.)
*/
PE = 21, // 0 to 1000000
/**************************************************************************************************/
// Error messages.
NAME = '[big.js] ',
INVALID = NAME + 'Invalid ',
INVALID_DP = INVALID + 'decimal places',
INVALID_RM = INVALID + 'rounding mode',
DIV_BY_ZERO = NAME + 'Division by zero',
// The shared prototype object.
P = {},
UNDEFINED = void 0,
NUMERIC = /^-?(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i;
/*
* Create and return a Big constructor.
*
*/
function _Big_() {
/*
* The Big constructor and exported function.
* Create and return a new instance of a Big number object.
*
* n {number|string|Big} A numeric value.
*/
function Big(n) {
var x = this;
// Enable constructor usage without new.
if (!(x instanceof Big)) return n === UNDEFINED ? _Big_() : new Big(n);
// Duplicate.
if (n instanceof Big) {
x.s = n.s;
x.e = n.e;
x.c = n.c.slice();
} else {
parse(x, n);
}
/*
* Retain a reference to this Big constructor, and shadow Big.prototype.constructor which
* points to Object.
*/
x.constructor = Big;
}
Big.prototype = P;
Big.DP = DP;
Big.RM = RM;
Big.NE = NE;
Big.PE = PE;
Big.version = '5.2.2';
return Big;
}
/*
* Parse the number or string value passed to a Big constructor.
*
* x {Big} A Big number instance.
* n {number|string} A numeric value.
*/
function parse(x, n) {
var e, i, nl;
// Minus zero?
if (n === 0 && 1 / n < 0) n = '-0';
else if (!NUMERIC.test(n += '')) throw Error(INVALID + 'number');
// Determine sign.
x.s = n.charAt(0) == '-' ? (n = n.slice(1), -1) : 1;
// Decimal point?
if ((e = n.indexOf('.')) > -1) n = n.replace('.', '');
// Exponential form?
if ((i = n.search(/e/i)) > 0) {
// Determine exponent.
if (e < 0) e = i;
e += +n.slice(i + 1);
n = n.substring(0, i);
} else if (e < 0) {
// Integer.
e = n.length;
}
nl = n.length;
// Determine leading zeros.
for (i = 0; i < nl && n.charAt(i) == '0';) ++i;
if (i == nl) {
// Zero.
x.c = [x.e = 0];
} else {
// Determine trailing zeros.
for (; nl > 0 && n.charAt(--nl) == '0';);
x.e = e - i - 1;
x.c = [];
// Convert string to array of digits without leading/trailing zeros.
for (e = 0; i <= nl;) x.c[e++] = +n.charAt(i++);
}
return x;
}
/*
* Round Big x to a maximum of dp decimal places using rounding mode rm.
* Called by stringify, P.div, P.round and P.sqrt.
*
* x {Big} The Big to round.
* dp {number} Integer, 0 to MAX_DP inclusive.
* rm {number} 0, 1, 2 or 3 (DOWN, HALF_UP, HALF_EVEN, UP)
* [more] {boolean} Whether the result of division was truncated.
*/
function round(x, dp, rm, more) {
var xc = x.c,
i = x.e + dp + 1;
if (i < xc.length) {
if (rm === 1) {
// xc[i] is the digit after the digit that may be rounded up.
more = xc[i] >= 5;
} else if (rm === 2) {
more = xc[i] > 5 || xc[i] == 5 &&
(more || i < 0 || xc[i + 1] !== UNDEFINED || xc[i - 1] & 1);
} else if (rm === 3) {
more = more || !!xc[0];
} else {
more = false;
if (rm !== 0) throw Error(INVALID_RM);
}
if (i < 1) {
xc.length = 1;
if (more) {
// 1, 0.1, 0.01, 0.001, 0.0001 etc.
x.e = -dp;
xc[0] = 1;
} else {
// Zero.
xc[0] = x.e = 0;
}
} else {
// Remove any digits after the required decimal places.
xc.length = i--;
// Round up?
if (more) {
// Rounding up may mean the previous digit has to be rounded up.
for (; ++xc[i] > 9;) {
xc[i] = 0;
if (!i--) {
++x.e;
xc.unshift(1);
}
}
}
// Remove trailing zeros.
for (i = xc.length; !xc[--i];) xc.pop();
}
} else if (rm < 0 || rm > 3 || rm !== ~~rm) {
throw Error(INVALID_RM);
}
return x;
}
/*
* Return a string representing the value of Big x in normal or exponential notation.
* Handles P.toExponential, P.toFixed, P.toJSON, P.toPrecision, P.toString and P.valueOf.
*
* x {Big}
* id? {number} Caller id.
* 1 toExponential
* 2 toFixed
* 3 toPrecision
* 4 valueOf
* n? {number|undefined} Caller's argument.
* k? {number|undefined}
*/
function stringify(x, id, n, k) {
var e, s,
Big = x.constructor,
z = !x.c[0];
if (n !== UNDEFINED) {
if (n !== ~~n || n < (id == 3) || n > MAX_DP) {
throw Error(id == 3 ? INVALID + 'precision' : INVALID_DP);
}
x = new Big(x);
// The index of the digit that may be rounded up.
n = k - x.e;
// Round?
if (x.c.length > ++k) round(x, n, Big.RM);
// toFixed: recalculate k as x.e may have changed if value rounded up.
if (id == 2) k = x.e + n + 1;
// Append zeros?
for (; x.c.length < k;) x.c.push(0);
}
e = x.e;
s = x.c.join('');
n = s.length;
// Exponential notation?
if (id != 2 && (id == 1 || id == 3 && k <= e || e <= Big.NE || e >= Big.PE)) {
s = s.charAt(0) + (n > 1 ? '.' + s.slice(1) : '') + (e < 0 ? 'e' : 'e+') + e;
// Normal notation.
} else if (e < 0) {
for (; ++e;) s = '0' + s;
s = '0.' + s;
} else if (e > 0) {
if (++e > n) for (e -= n; e--;) s += '0';
else if (e < n) s = s.slice(0, e) + '.' + s.slice(e);
} else if (n > 1) {
s = s.charAt(0) + '.' + s.slice(1);
}
return x.s < 0 && (!z || id == 4) ? '-' + s : s;
}
// Prototype/instance methods
/*
* Return a new Big whose value is the absolute value of this Big.
*/
P.abs = function () {
var x = new this.constructor(this);
x.s = 1;
return x;
};
/*
* Return 1 if the value of this Big is greater than the value of Big y,
* -1 if the value of this Big is less than the value of Big y, or
* 0 if they have the same value.
*/
P.cmp = function (y) {
var isneg,
x = this,
xc = x.c,
yc = (y = new x.constructor(y)).c,
i = x.s,
j = y.s,
k = x.e,
l = y.e;
// Either zero?
if (!xc[0] || !yc[0]) return !xc[0] ? !yc[0] ? 0 : -j : i;
// Signs differ?
if (i != j) return i;
isneg = i < 0;
// Compare exponents.
if (k != l) return k > l ^ isneg ? 1 : -1;
j = (k = xc.length) < (l = yc.length) ? k : l;
// Compare digit by digit.
for (i = -1; ++i < j;) {
if (xc[i] != yc[i]) return xc[i] > yc[i] ^ isneg ? 1 : -1;
}
// Compare lengths.
return k == l ? 0 : k > l ^ isneg ? 1 : -1;
};
/*
* Return a new Big whose value is the value of this Big divided by the value of Big y, rounded,
* if necessary, to a maximum of Big.DP decimal places using rounding mode Big.RM.
*/
P.div = function (y) {
var x = this,
Big = x.constructor,
a = x.c, // dividend
b = (y = new Big(y)).c, // divisor
k = x.s == y.s ? 1 : -1,
dp = Big.DP;
if (dp !== ~~dp || dp < 0 || dp > MAX_DP) throw Error(INVALID_DP);
// Divisor is zero?
if (!b[0]) throw Error(DIV_BY_ZERO);
// Dividend is 0? Return +-0.
if (!a[0]) return new Big(k * 0);
var bl, bt, n, cmp, ri,
bz = b.slice(),
ai = bl = b.length,
al = a.length,
r = a.slice(0, bl), // remainder
rl = r.length,
q = y, // quotient
qc = q.c = [],
qi = 0,
d = dp + (q.e = x.e - y.e) + 1; // number of digits of the result
q.s = k;
k = d < 0 ? 0 : d;
// Create version of divisor with leading zero.
bz.unshift(0);
// Add zeros to make remainder as long as divisor.
for (; rl++ < bl;) r.push(0);
do {
// n is how many times the divisor goes into current remainder.
for (n = 0; n < 10; n++) {
// Compare divisor and remainder.
if (bl != (rl = r.length)) {
cmp = bl > rl ? 1 : -1;
} else {
for (ri = -1, cmp = 0; ++ri < bl;) {
if (b[ri] != r[ri]) {
cmp = b[ri] > r[ri] ? 1 : -1;
break;
}
}
}
// If divisor < remainder, subtract divisor from remainder.
if (cmp < 0) {
// Remainder can't be more than 1 digit longer than divisor.
// Equalise lengths using divisor with extra leading zero?
for (bt = rl == bl ? b : bz; rl;) {
if (r[--rl] < bt[rl]) {
ri = rl;
for (; ri && !r[--ri];) r[ri] = 9;
--r[ri];
r[rl] += 10;
}
r[rl] -= bt[rl];
}
for (; !r[0];) r.shift();
} else {
break;
}
}
// Add the digit n to the result array.
qc[qi++] = cmp ? n : ++n;
// Update the remainder.
if (r[0] && cmp) r[rl] = a[ai] || 0;
else r = [a[ai]];
} while ((ai++ < al || r[0] !== UNDEFINED) && k--);
// Leading zero? Do not remove if result is simply zero (qi == 1).
if (!qc[0] && qi != 1) {
// There can't be more than one zero.
qc.shift();
q.e--;
}
// Round?
if (qi > d) round(q, dp, Big.RM, r[0] !== UNDEFINED);
return q;
};
/*
* Return true if the value of this Big is equal to the value of Big y, otherwise return false.
*/
P.eq = function (y) {
return !this.cmp(y);
};
/*
* Return true if the value of this Big is greater than the value of Big y, otherwise return
* false.
*/
P.gt = function (y) {
return this.cmp(y) > 0;
};
/*
* Return true if the value of this Big is greater than or equal to the value of Big y, otherwise
* return false.
*/
P.gte = function (y) {
return this.cmp(y) > -1;
};
/*
* Return true if the value of this Big is less than the value of Big y, otherwise return false.
*/
P.lt = function (y) {
return this.cmp(y) < 0;
};
/*
* Return true if the value of this Big is less than or equal to the value of Big y, otherwise
* return false.
*/
P.lte = function (y) {
return this.cmp(y) < 1;
};
/*
* Return a new Big whose value is the value of this Big minus the value of Big y.
*/
P.minus = P.sub = function (y) {
var i, j, t, xlty,
x = this,
Big = x.constructor,
a = x.s,
b = (y = new Big(y)).s;
// Signs differ?
if (a != b) {
y.s = -b;
return x.plus(y);
}
var xc = x.c.slice(),
xe = x.e,
yc = y.c,
ye = y.e;
// Either zero?
if (!xc[0] || !yc[0]) {
// y is non-zero? x is non-zero? Or both are zero.
return yc[0] ? (y.s = -b, y) : new Big(xc[0] ? x : 0);
}
// Determine which is the bigger number. Prepend zeros to equalise exponents.
if (a = xe - ye) {
if (xlty = a < 0) {
a = -a;
t = xc;
} else {
ye = xe;
t = yc;
}
t.reverse();
for (b = a; b--;) t.push(0);
t.reverse();
} else {
// Exponents equal. Check digit by digit.
j = ((xlty = xc.length < yc.length) ? xc : yc).length;
for (a = b = 0; b < j; b++) {
if (xc[b] != yc[b]) {
xlty = xc[b] < yc[b];
break;
}
}
}
// x < y? Point xc to the array of the bigger number.
if (xlty) {
t = xc;
xc = yc;
yc = t;
y.s = -y.s;
}
/*
* Append zeros to xc if shorter. No need to add zeros to yc if shorter as subtraction only
* needs to start at yc.length.
*/
if ((b = (j = yc.length) - (i = xc.length)) > 0) for (; b--;) xc[i++] = 0;
// Subtract yc from xc.
for (b = i; j > a;) {
if (xc[--j] < yc[j]) {
for (i = j; i && !xc[--i];) xc[i] = 9;
--xc[i];
xc[j] += 10;
}
xc[j] -= yc[j];
}
// Remove trailing zeros.
for (; xc[--b] === 0;) xc.pop();
// Remove leading zeros and adjust exponent accordingly.
for (; xc[0] === 0;) {
xc.shift();
--ye;
}
if (!xc[0]) {
// n - n = +0
y.s = 1;
// Result must be zero.
xc = [ye = 0];
}
y.c = xc;
y.e = ye;
return y;
};
/*
* Return a new Big whose value is the value of this Big modulo the value of Big y.
*/
P.mod = function (y) {
var ygtx,
x = this,
Big = x.constructor,
a = x.s,
b = (y = new Big(y)).s;
if (!y.c[0]) throw Error(DIV_BY_ZERO);
x.s = y.s = 1;
ygtx = y.cmp(x) == 1;
x.s = a;
y.s = b;
if (ygtx) return new Big(x);
a = Big.DP;
b = Big.RM;
Big.DP = Big.RM = 0;
x = x.div(y);
Big.DP = a;
Big.RM = b;
return this.minus(x.times(y));
};
/*
* Return a new Big whose value is the value of this Big plus the value of Big y.
*/
P.plus = P.add = function (y) {
var t,
x = this,
Big = x.constructor,
a = x.s,
b = (y = new Big(y)).s;
// Signs differ?
if (a != b) {
y.s = -b;
return x.minus(y);
}
var xe = x.e,
xc = x.c,
ye = y.e,
yc = y.c;
// Either zero? y is non-zero? x is non-zero? Or both are zero.
if (!xc[0] || !yc[0]) return yc[0] ? y : new Big(xc[0] ? x : a * 0);
xc = xc.slice();
// Prepend zeros to equalise exponents.
// Note: reverse faster than unshifts.
if (a = xe - ye) {
if (a > 0) {
ye = xe;
t = yc;
} else {
a = -a;
t = xc;
}
t.reverse();
for (; a--;) t.push(0);
t.reverse();
}
// Point xc to the longer array.
if (xc.length - yc.length < 0) {
t = yc;
yc = xc;
xc = t;
}
a = yc.length;
// Only start adding at yc.length - 1 as the further digits of xc can be left as they are.
for (b = 0; a; xc[a] %= 10) b = (xc[--a] = xc[a] + yc[a] + b) / 10 | 0;
// No need to check for zero, as +x + +y != 0 && -x + -y != 0
if (b) {
xc.unshift(b);
++ye;
}
// Remove trailing zeros.
for (a = xc.length; xc[--a] === 0;) xc.pop();
y.c = xc;
y.e = ye;
return y;
};
/*
* Return a Big whose value is the value of this Big raised to the power n.
* If n is negative, round to a maximum of Big.DP decimal places using rounding
* mode Big.RM.
*
* n {number} Integer, -MAX_POWER to MAX_POWER inclusive.
*/
P.pow = function (n) {
var x = this,
one = new x.constructor(1),
y = one,
isneg = n < 0;
if (n !== ~~n || n < -MAX_POWER || n > MAX_POWER) throw Error(INVALID + 'exponent');
if (isneg) n = -n;
for (;;) {
if (n & 1) y = y.times(x);
n >>= 1;
if (!n) break;
x = x.times(x);
}
return isneg ? one.div(y) : y;
};
/*
* Return a new Big whose value is the value of this Big rounded using rounding mode rm
* to a maximum of dp decimal places, or, if dp is negative, to an integer which is a
* multiple of 10**-dp.
* If dp is not specified, round to 0 decimal places.
* If rm is not specified, use Big.RM.
*
* dp? {number} Integer, -MAX_DP to MAX_DP inclusive.
* rm? 0, 1, 2 or 3 (ROUND_DOWN, ROUND_HALF_UP, ROUND_HALF_EVEN, ROUND_UP)
*/
P.round = function (dp, rm) {
var Big = this.constructor;
if (dp === UNDEFINED) dp = 0;
else if (dp !== ~~dp || dp < -MAX_DP || dp > MAX_DP) throw Error(INVALID_DP);
return round(new Big(this), dp, rm === UNDEFINED ? Big.RM : rm);
};
/*
* Return a new Big whose value is the square root of the value of this Big, rounded, if
* necessary, to a maximum of Big.DP decimal places using rounding mode Big.RM.
*/
P.sqrt = function () {
var r, c, t,
x = this,
Big = x.constructor,
s = x.s,
e = x.e,
half = new Big(0.5);
// Zero?
if (!x.c[0]) return new Big(x);
// Negative?
if (s < 0) throw Error(NAME + 'No square root');
// Estimate.
s = Math.sqrt(x + '');
// Math.sqrt underflow/overflow?
// Re-estimate: pass x coefficient to Math.sqrt as integer, then adjust the result exponent.
if (s === 0 || s === 1 / 0) {
c = x.c.join('');
if (!(c.length + e & 1)) c += '0';
s = Math.sqrt(c);
e = ((e + 1) / 2 | 0) - (e < 0 || e & 1);
r = new Big((s == 1 / 0 ? '1e' : (s = s.toExponential()).slice(0, s.indexOf('e') + 1)) + e);
} else {
r = new Big(s);
}
e = r.e + (Big.DP += 4);
// Newton-Raphson iteration.
do {
t = r;
r = half.times(t.plus(x.div(t)));
} while (t.c.slice(0, e).join('') !== r.c.slice(0, e).join(''));
return round(r, Big.DP -= 4, Big.RM);
};
/*
* Return a new Big whose value is the value of this Big times the value of Big y.
*/
P.times = P.mul = function (y) {
var c,
x = this,
Big = x.constructor,
xc = x.c,
yc = (y = new Big(y)).c,
a = xc.length,
b = yc.length,
i = x.e,
j = y.e;
// Determine sign of result.
y.s = x.s == y.s ? 1 : -1;
// Return signed 0 if either 0.
if (!xc[0] || !yc[0]) return new Big(y.s * 0);
// Initialise exponent of result as x.e + y.e.
y.e = i + j;
// If array xc has fewer digits than yc, swap xc and yc, and lengths.
if (a < b) {
c = xc;
xc = yc;
yc = c;
j = a;
a = b;
b = j;
}
// Initialise coefficient array of result with zeros.
for (c = new Array(j = a + b); j--;) c[j] = 0;
// Multiply.
// i is initially xc.length.
for (i = b; i--;) {
b = 0;
// a is yc.length.
for (j = a + i; j > i;) {
// Current sum of products at this digit position, plus carry.
b = c[j] + yc[i] * xc[j - i - 1] + b;
c[j--] = b % 10;
// carry
b = b / 10 | 0;
}
c[j] = (c[j] + b) % 10;
}
// Increment result exponent if there is a final carry, otherwise remove leading zero.
if (b) ++y.e;
else c.shift();
// Remove trailing zeros.
for (i = c.length; !c[--i];) c.pop();
y.c = c;
return y;
};
/*
* Return a string representing the value of this Big in exponential notation to dp fixed decimal
* places and rounded using Big.RM.
*
* dp? {number} Integer, 0 to MAX_DP inclusive.
*/
P.toExponential = function (dp) {
return stringify(this, 1, dp, dp);
};
/*
* Return a string representing the value of this Big in normal notation to dp fixed decimal
* places and rounded using Big.RM.
*
* dp? {number} Integer, 0 to MAX_DP inclusive.
*
* (-0).toFixed(0) is '0', but (-0.1).toFixed(0) is '-0'.
* (-0).toFixed(1) is '0.0', but (-0.01).toFixed(1) is '-0.0'.
*/
P.toFixed = function (dp) {
return stringify(this, 2, dp, this.e + dp);
};
/*
* Return a string representing the value of this Big rounded to sd significant digits using
* Big.RM. Use exponential notation if sd is less than the number of digits necessary to represent
* the integer part of the value in normal notation.
*
* sd {number} Integer, 1 to MAX_DP inclusive.
*/
P.toPrecision = function (sd) {
return stringify(this, 3, sd, sd - 1);
};
/*
* Return a string representing the value of this Big.
* Return exponential notation if this Big has a positive exponent equal to or greater than
* Big.PE, or a negative exponent equal to or less than Big.NE.
* Omit the sign for negative zero.
*/
P.toString = function () {
return stringify(this);
};
/*
* Return a string representing the value of this Big.
* Return exponential notation if this Big has a positive exponent equal to or greater than
* Big.PE, or a negative exponent equal to or less than Big.NE.
* Include the sign for negative zero.
*/
P.valueOf = P.toJSON = function () {
return stringify(this, 4);
};
// Export
Big = _Big_();
Big['default'] = Big.Big = Big;
//AMD.
if (module.exports) {
module.exports = Big;
//Browser.
} else {
GLOBAL.Big = Big;
}
})(build$2.commonjsGlobal);
}(big));
const baseEncodeTables = {
26: 'abcdefghijklmnopqrstuvwxyz',
32: '123456789abcdefghjkmnpqrstuvwxyz', // no 0lio
36: '0123456789abcdefghijklmnopqrstuvwxyz',
49: 'abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ', // no lIO
52: 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
58: '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ', // no 0lIO
62: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
64: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_',
};
function encodeBufferToBase(buffer, base) {
const encodeTable = baseEncodeTables[base];
if (!encodeTable) {
throw new Error('Unknown encoding base' + base);
}
const readLength = buffer.length;
const Big = big.exports;
Big.RM = Big.DP = 0;
let b = new Big(0);
for (let i = readLength - 1; i >= 0; i--) {
b = b.times(256).plus(buffer[i]);
}
let output = '';
while (b.gt(0)) {
output = encodeTable[b.mod(base)] + output;
b = b.div(base);
}
Big.DP = 20;
Big.RM = 1;
return output;
}
function getHashDigest$2(buffer, hashType, digestType, maxLength) {
hashType = hashType || 'md5';
maxLength = maxLength || 9999;
const hash = require$$1__default.createHash(hashType);
hash.update(buffer);
if (
digestType === 'base26' ||
digestType === 'base32' ||
digestType === 'base36' ||
digestType === 'base49' ||
digestType === 'base52' ||
digestType === 'base58' ||
digestType === 'base62' ||
digestType === 'base64'
) {
return encodeBufferToBase(hash.digest(), digestType.substr(4)).substr(
0,
maxLength
);
} else {
return hash.digest(digestType || 'hex').substr(0, maxLength);
}
}
var getHashDigest_1 = getHashDigest$2;
var emojisList$1 = [
"🀄️",
"🃏",
"🅰️",
"🅱️",
"🅾️",
"🅿️",
"🆎",
"🆑",
"🆒",
"🆓",
"🆔",
"🆕",
"🆖",
"🆗",
"🆘",
"🆙",
"🆚",
"🇦🇨",
"🇦🇩",
"🇦🇪",
"🇦🇫",
"🇦🇬",
"🇦🇮",
"🇦🇱",
"🇦🇲",
"🇦🇴",
"🇦🇶",
"🇦🇷",
"🇦🇸",
"🇦🇹",
"🇦🇺",
"🇦🇼",
"🇦🇽",
"🇦🇿",
"🇦",
"🇧🇦",
"🇧🇧",
"🇧🇩",
"🇧🇪",
"🇧🇫",
"🇧🇬",
"🇧🇭",
"🇧🇮",
"🇧🇯",
"🇧🇱",
"🇧🇲",
"🇧🇳",
"🇧🇴",
"🇧🇶",
"🇧🇷",
"🇧🇸",
"🇧🇹",
"🇧🇻",
"🇧🇼",
"🇧🇾",
"🇧🇿",
"🇧",
"🇨🇦",
"🇨🇨",
"🇨🇩",
"🇨🇫",
"🇨🇬",
"🇨🇭",
"🇨🇮",
"🇨🇰",
"🇨🇱",
"🇨🇲",
"🇨🇳",
"🇨🇴",
"🇨🇵",
"🇨🇷",
"🇨🇺",
"🇨🇻",
"🇨🇼",
"🇨🇽",
"🇨🇾",
"🇨🇿",
"🇨",
"🇩🇪",
"🇩🇬",
"🇩🇯",
"🇩🇰",
"🇩🇲",
"🇩🇴",
"🇩🇿",
"🇩",
"🇪🇦",
"🇪🇨",
"🇪🇪",
"🇪🇬",
"🇪🇭",
"🇪🇷",
"🇪🇸",
"🇪🇹",
"🇪🇺",
"🇪",
"🇫🇮",
"🇫🇯",
"🇫🇰",
"🇫🇲",
"🇫🇴",
"🇫🇷",
"🇫",
"🇬🇦",
"🇬🇧",
"🇬🇩",
"🇬🇪",
"🇬🇫",
"🇬🇬",
"🇬🇭",
"🇬🇮",
"🇬🇱",
"🇬🇲",
"🇬🇳",
"🇬🇵",
"🇬🇶",
"🇬🇷",
"🇬🇸",
"🇬🇹",
"🇬🇺",
"🇬🇼",
"🇬🇾",
"🇬",
"🇭🇰",
"🇭🇲",
"🇭🇳",
"🇭🇷",
"🇭🇹",
"🇭🇺",
"🇭",
"🇮🇨",
"🇮🇩",
"🇮🇪",
"🇮🇱",
"🇮🇲",
"🇮🇳",
"🇮🇴",
"🇮🇶",
"🇮🇷",
"🇮🇸",
"🇮🇹",
"🇮",
"🇯🇪",
"🇯🇲",
"🇯🇴",
"🇯🇵",
"🇯",
"🇰🇪",
"🇰🇬",
"🇰🇭",
"🇰🇮",
"🇰🇲",
"🇰🇳",
"🇰🇵",
"🇰🇷",
"🇰🇼",
"🇰🇾",
"🇰🇿",
"🇰",
"🇱🇦",
"🇱🇧",
"🇱🇨",
"🇱🇮",
"🇱🇰",
"🇱🇷",
"🇱🇸",
"🇱🇹",
"🇱🇺",
"🇱🇻",
"🇱🇾",
"🇱",
"🇲🇦",
"🇲🇨",
"🇲🇩",
"🇲🇪",
"🇲🇫",
"🇲🇬",
"🇲🇭",
"🇲🇰",
"🇲🇱",
"🇲🇲",
"🇲🇳",
"🇲🇴",
"🇲🇵",
"🇲🇶",
"🇲🇷",
"🇲🇸",
"🇲🇹",
"🇲🇺",
"🇲🇻",
"🇲🇼",
"🇲🇽",
"🇲🇾",
"🇲🇿",
"🇲",
"🇳🇦",
"🇳🇨",
"🇳🇪",
"🇳🇫",
"🇳🇬",
"🇳🇮",
"🇳🇱",
"🇳🇴",
"🇳🇵",
"🇳🇷",
"🇳🇺",
"🇳🇿",
"🇳",
"🇴🇲",
"🇴",
"🇵🇦",
"🇵🇪",
"🇵🇫",
"🇵🇬",
"🇵🇭",
"🇵🇰",
"🇵🇱",
"🇵🇲",
"🇵🇳",
"🇵🇷",
"🇵🇸",
"🇵🇹",
"🇵🇼",
"🇵🇾",
"🇵",
"🇶🇦",
"🇶",
"🇷🇪",
"🇷🇴",
"🇷🇸",
"🇷🇺",
"🇷🇼",
"🇷",
"🇸🇦",
"🇸🇧",
"🇸🇨",
"🇸🇩",
"🇸🇪",
"🇸🇬",
"🇸🇭",
"🇸🇮",
"🇸🇯",
"🇸🇰",
"🇸🇱",
"🇸🇲",
"🇸🇳",
"🇸🇴",
"🇸🇷",
"🇸🇸",
"🇸🇹",
"🇸🇻",
"🇸🇽",
"🇸🇾",
"🇸🇿",
"🇸",
"🇹🇦",
"🇹🇨",
"🇹🇩",
"🇹🇫",
"🇹🇬",
"🇹🇭",
"🇹🇯",
"🇹🇰",
"🇹🇱",
"🇹🇲",
"🇹🇳",
"🇹🇴",
"🇹🇷",
"🇹🇹",
"🇹🇻",
"🇹🇼",
"🇹🇿",
"🇹",
"🇺🇦",
"🇺🇬",
"🇺🇲",
"🇺🇳",
"🇺🇸",
"🇺🇾",
"🇺🇿",
"🇺",
"🇻🇦",
"🇻🇨",
"🇻🇪",
"🇻🇬",
"🇻🇮",
"🇻🇳",
"🇻🇺",
"🇻",
"🇼🇫",
"🇼🇸",
"🇼",
"🇽🇰",
"🇽",
"🇾🇪",
"🇾🇹",
"🇾",
"🇿🇦",
"🇿🇲",
"🇿🇼",
"🇿",
"🈁",
"🈂️",
"🈚️",
"🈯️",
"🈲",
"🈳",
"🈴",
"🈵",
"🈶",
"🈷️",
"🈸",
"🈹",
"🈺",
"🉐",
"🉑",
"🌀",
"🌁",
"🌂",
"🌃",
"🌄",
"🌅",
"🌆",
"🌇",
"🌈",
"🌉",
"🌊",
"🌋",
"🌌",
"🌍",
"🌎",
"🌏",
"🌐",
"🌑",
"🌒",
"🌓",
"🌔",
"🌕",
"🌖",
"🌗",
"🌘",
"🌙",
"🌚",
"🌛",
"🌜",
"🌝",
"🌞",
"🌟",
"🌠",
"🌡️",
"🌤️",
"🌥️",
"🌦️",
"🌧️",
"🌨️",
"🌩️",
"🌪️",
"🌫️",
"🌬️",
"🌭",
"🌮",
"🌯",
"🌰",
"🌱",
"🌲",
"🌳",
"🌴",
"🌵",
"🌶️",
"🌷",
"🌸",
"🌹",
"🌺",
"🌻",
"🌼",
"🌽",
"🌾",
"🌿",
"🍀",
"🍁",
"🍂",
"🍃",
"🍄",
"🍅",
"🍆",
"🍇",
"🍈",
"🍉",
"🍊",
"🍋",
"🍌",
"🍍",
"🍎",
"🍏",
"🍐",
"🍑",
"🍒",
"🍓",
"🍔",
"🍕",
"🍖",
"🍗",
"🍘",
"🍙",
"🍚",
"🍛",
"🍜",
"🍝",
"🍞",
"🍟",
"🍠",
"🍡",
"🍢",
"🍣",
"🍤",
"🍥",
"🍦",
"🍧",
"🍨",
"🍩",
"🍪",
"🍫",
"🍬",
"🍭",
"🍮",
"🍯",
"🍰",
"🍱",
"🍲",
"🍳",
"🍴",
"🍵",
"🍶",
"🍷",
"🍸",
"🍹",
"🍺",
"🍻",
"🍼",
"🍽️",
"🍾",
"🍿",
"🎀",
"🎁",
"🎂",
"🎃",
"🎄",
"🎅🏻",
"🎅🏼",
"🎅🏽",
"🎅🏾",
"🎅🏿",
"🎅",
"🎆",
"🎇",
"🎈",
"🎉",
"🎊",
"🎋",
"🎌",
"🎍",
"🎎",
"🎏",
"🎐",
"🎑",
"🎒",
"🎓",
"🎖️",
"🎗️",
"🎙️",
"🎚️",
"🎛️",
"🎞️",
"🎟️",
"🎠",
"🎡",
"🎢",
"🎣",
"🎤",
"🎥",
"🎦",
"🎧",
"🎨",
"🎩",
"🎪",
"🎫",
"🎬",
"🎭",
"🎮",
"🎯",
"🎰",
"🎱",
"🎲",
"🎳",
"🎴",
"🎵",
"🎶",
"🎷",
"🎸",
"🎹",
"🎺",
"🎻",
"🎼",
"🎽",
"🎾",
"🎿",
"🏀",
"🏁",
"🏂🏻",
"🏂🏼",
"🏂🏽",
"🏂🏾",
"🏂🏿",
"🏂",
"🏃🏻‍♀️",
"🏃🏻‍♂️",
"🏃🏻",
"🏃🏼‍♀️",
"🏃🏼‍♂️",
"🏃🏼",
"🏃🏽‍♀️",
"🏃🏽‍♂️",
"🏃🏽",
"🏃🏾‍♀️",
"🏃🏾‍♂️",
"🏃🏾",
"🏃🏿‍♀️",
"🏃🏿‍♂️",
"🏃🏿",
"🏃‍♀️",
"🏃‍♂️",
"🏃",
"🏄🏻‍♀️",
"🏄🏻‍♂️",
"🏄🏻",
"🏄🏼‍♀️",
"🏄🏼‍♂️",
"🏄🏼",
"🏄🏽‍♀️",
"🏄🏽‍♂️",
"🏄🏽",
"🏄🏾‍♀️",
"🏄🏾‍♂️",
"🏄🏾",
"🏄🏿‍♀️",
"🏄🏿‍♂️",
"🏄🏿",
"🏄‍♀️",
"🏄‍♂️",
"🏄",
"🏅",
"🏆",
"🏇🏻",
"🏇🏼",
"🏇🏽",
"🏇🏾",
"🏇🏿",
"🏇",
"🏈",
"🏉",
"🏊🏻‍♀️",
"🏊🏻‍♂️",
"🏊🏻",
"🏊🏼‍♀️",
"🏊🏼‍♂️",
"🏊🏼",
"🏊🏽‍♀️",
"🏊🏽‍♂️",
"🏊🏽",
"🏊🏾‍♀️",
"🏊🏾‍♂️",
"🏊🏾",
"🏊🏿‍♀️",
"🏊🏿‍♂️",
"🏊🏿",
"🏊‍♀️",
"🏊‍♂️",
"🏊",
"🏋🏻‍♀️",
"🏋🏻‍♂️",
"🏋🏻",
"🏋🏼‍♀️",
"🏋🏼‍♂️",
"🏋🏼",
"🏋🏽‍♀️",
"🏋🏽‍♂️",
"🏋🏽",
"🏋🏾‍♀️",
"🏋🏾‍♂️",
"🏋🏾",
"🏋🏿‍♀️",
"🏋🏿‍♂️",
"🏋🏿",
"🏋️‍♀️",
"🏋️‍♂️",
"🏋️",
"🏌🏻‍♀️",
"🏌🏻‍♂️",
"🏌🏻",
"🏌🏼‍♀️",
"🏌🏼‍♂️",
"🏌🏼",
"🏌🏽‍♀️",
"🏌🏽‍♂️",
"🏌🏽",
"🏌🏾‍♀️",
"🏌🏾‍♂️",
"🏌🏾",
"🏌🏿‍♀️",
"🏌🏿‍♂️",
"🏌🏿",
"🏌️‍♀️",
"🏌️‍♂️",
"🏌️",
"🏍️",
"🏎️",
"🏏",
"🏐",
"🏑",
"🏒",
"🏓",
"🏔️",
"🏕️",
"🏖️",
"🏗️",
"🏘️",
"🏙️",
"🏚️",
"🏛️",
"🏜️",
"🏝️",
"🏞️",
"🏟️",
"🏠",
"🏡",
"🏢",
"🏣",
"🏤",
"🏥",
"🏦",
"🏧",
"🏨",
"🏩",
"🏪",
"🏫",
"🏬",
"🏭",
"🏮",
"🏯",
"🏰",
"🏳️‍🌈",
"🏳️",
"🏴‍☠️",
"🏴󠁧󠁢󠁥󠁮󠁧󠁿",
"🏴󠁧󠁢󠁳󠁣󠁴󠁿",
"🏴󠁧󠁢󠁷󠁬󠁳󠁿",
"🏴",
"🏵️",
"🏷️",
"🏸",
"🏹",
"🏺",
"🏻",
"🏼",
"🏽",
"🏾",
"🏿",
"🐀",
"🐁",
"🐂",
"🐃",
"🐄",
"🐅",
"🐆",
"🐇",
"🐈",
"🐉",
"🐊",
"🐋",
"🐌",
"🐍",
"🐎",
"🐏",
"🐐",
"🐑",
"🐒",
"🐓",
"🐔",
"🐕‍🦺",
"🐕",
"🐖",
"🐗",
"🐘",
"🐙",
"🐚",
"🐛",
"🐜",
"🐝",
"🐞",
"🐟",
"🐠",
"🐡",
"🐢",
"🐣",
"🐤",
"🐥",
"🐦",
"🐧",
"🐨",
"🐩",
"🐪",
"🐫",
"🐬",
"🐭",
"🐮",
"🐯",
"🐰",
"🐱",
"🐲",
"🐳",
"🐴",
"🐵",
"🐶",
"🐷",
"🐸",
"🐹",
"🐺",
"🐻",
"🐼",
"🐽",
"🐾",
"🐿️",
"👀",
"👁‍🗨",
"👁️",
"👂🏻",
"👂🏼",
"👂🏽",
"👂🏾",
"👂🏿",
"👂",
"👃🏻",
"👃🏼",
"👃🏽",
"👃🏾",
"👃🏿",
"👃",
"👄",
"👅",
"👆🏻",
"👆🏼",
"👆🏽",
"👆🏾",
"👆🏿",
"👆",
"👇🏻",
"👇🏼",
"👇🏽",
"👇🏾",
"👇🏿",
"👇",
"👈🏻",
"👈🏼",
"👈🏽",
"👈🏾",
"👈🏿",
"👈",
"👉🏻",
"👉🏼",
"👉🏽",
"👉🏾",
"👉🏿",
"👉",
"👊🏻",
"👊🏼",
"👊🏽",
"👊🏾",
"👊🏿",
"👊",
"👋🏻",
"👋🏼",
"👋🏽",
"👋🏾",
"👋🏿",
"👋",
"👌🏻",
"👌🏼",
"👌🏽",
"👌🏾",
"👌🏿",
"👌",
"👍🏻",
"👍🏼",
"👍🏽",
"👍🏾",
"👍🏿",
"👍",
"👎🏻",
"👎🏼",
"👎🏽",
"👎🏾",
"👎🏿",
"👎",
"👏🏻",
"👏🏼",
"👏🏽",
"👏🏾",
"👏🏿",
"👏",
"👐🏻",
"👐🏼",
"👐🏽",
"👐🏾",
"👐🏿",
"👐",
"👑",
"👒",
"👓",
"👔",
"👕",
"👖",
"👗",
"👘",
"👙",
"👚",
"👛",
"👜",
"👝",
"👞",
"👟",
"👠",
"👡",
"👢",
"👣",
"👤",
"👥",
"👦🏻",
"👦🏼",
"👦🏽",
"👦🏾",
"👦🏿",
"👦",
"👧🏻",
"👧🏼",
"👧🏽",
"👧🏾",
"👧🏿",
"👧",
"👨🏻‍🌾",
"👨🏻‍🍳",
"👨🏻‍🎓",
"👨🏻‍🎤",
"👨🏻‍🎨",
"👨🏻‍🏫",
"👨🏻‍🏭",
"👨🏻‍💻",
"👨🏻‍💼",
"👨🏻‍🔧",
"👨🏻‍🔬",
"👨🏻‍🚀",
"👨🏻‍🚒",
"👨🏻‍🦯",
"👨🏻‍🦰",
"👨🏻‍🦱",
"👨🏻‍🦲",
"👨🏻‍🦳",
"👨🏻‍🦼",
"👨🏻‍🦽",
"👨🏻‍⚕️",
"👨🏻‍⚖️",
"👨🏻‍✈️",
"👨🏻",
"👨🏼‍🌾",
"👨🏼‍🍳",
"👨🏼‍🎓",
"👨🏼‍🎤",
"👨🏼‍🎨",
"👨🏼‍🏫",
"👨🏼‍🏭",
"👨🏼‍💻",
"👨🏼‍💼",
"👨🏼‍🔧",
"👨🏼‍🔬",
"👨🏼‍🚀",
"👨🏼‍🚒",
"👨🏼‍🤝‍👨🏻",
"👨🏼‍🦯",
"👨🏼‍🦰",
"👨🏼‍🦱",
"👨🏼‍🦲",
"👨🏼‍🦳",
"👨🏼‍🦼",
"👨🏼‍🦽",
"👨🏼‍⚕️",
"👨🏼‍⚖️",
"👨🏼‍✈️",
"👨🏼",
"👨🏽‍🌾",
"👨🏽‍🍳",
"👨🏽‍🎓",
"👨🏽‍🎤",
"👨🏽‍🎨",
"👨🏽‍🏫",
"👨🏽‍🏭",
"👨🏽‍💻",
"👨🏽‍💼",
"👨🏽‍🔧",
"👨🏽‍🔬",
"👨🏽‍🚀",
"👨🏽‍🚒",
"👨🏽‍🤝‍👨🏻",
"👨🏽‍🤝‍👨🏼",
"👨🏽‍🦯",
"👨🏽‍🦰",
"👨🏽‍🦱",
"👨🏽‍🦲",
"👨🏽‍🦳",
"👨🏽‍🦼",
"👨🏽‍🦽",
"👨🏽‍⚕️",
"👨🏽‍⚖️",
"👨🏽‍✈️",
"👨🏽",
"👨🏾‍🌾",
"👨🏾‍🍳",
"👨🏾‍🎓",
"👨🏾‍🎤",
"👨🏾‍🎨",
"👨🏾‍🏫",
"👨🏾‍🏭",
"👨🏾‍💻",
"👨🏾‍💼",
"👨🏾‍🔧",
"👨🏾‍🔬",
"👨🏾‍🚀",
"👨🏾‍🚒",
"👨🏾‍🤝‍👨🏻",
"👨🏾‍🤝‍👨🏼",
"👨🏾‍🤝‍👨🏽",
"👨🏾‍🦯",
"👨🏾‍🦰",
"👨🏾‍🦱",
"👨🏾‍🦲",
"👨🏾‍🦳",
"👨🏾‍🦼",
"👨🏾‍🦽",
"👨🏾‍⚕️",
"👨🏾‍⚖️",
"👨🏾‍✈️",
"👨🏾",
"👨🏿‍🌾",
"👨🏿‍🍳",
"👨🏿‍🎓",
"👨🏿‍🎤",
"👨🏿‍🎨",
"👨🏿‍🏫",
"👨🏿‍🏭",
"👨🏿‍💻",
"👨🏿‍💼",
"👨🏿‍🔧",
"👨🏿‍🔬",
"👨🏿‍🚀",
"👨🏿‍🚒",
"👨🏿‍🤝‍👨🏻",
"👨🏿‍🤝‍👨🏼",
"👨🏿‍🤝‍👨🏽",
"👨🏿‍🤝‍👨🏾",
"👨🏿‍🦯",
"👨🏿‍🦰",
"👨🏿‍🦱",
"👨🏿‍🦲",
"👨🏿‍🦳",
"👨🏿‍🦼",
"👨🏿‍🦽",
"👨🏿‍⚕️",
"👨🏿‍⚖️",
"👨🏿‍✈️",
"👨🏿",
"👨‍🌾",
"👨‍🍳",
"👨‍🎓",
"👨‍🎤",
"👨‍🎨",
"👨‍🏫",
"👨‍🏭",
"👨‍👦‍👦",
"👨‍👦",
"👨‍👧‍👦",
"👨‍👧‍👧",
"👨‍👧",
"👨‍👨‍👦‍👦",
"👨‍👨‍👦",
"👨‍👨‍👧‍👦",
"👨‍👨‍👧‍👧",
"👨‍👨‍👧",
"👨‍👩‍👦‍👦",
"👨‍👩‍👦",
"👨‍👩‍👧‍👦",
"👨‍👩‍👧‍👧",
"👨‍👩‍👧",
"👨‍💻",
"👨‍💼",
"👨‍🔧",
"👨‍🔬",
"👨‍🚀",
"👨‍🚒",
"👨‍🦯",
"👨‍🦰",
"👨‍🦱",
"👨‍🦲",
"👨‍🦳",
"👨‍🦼",
"👨‍🦽",
"👨‍⚕️",
"👨‍⚖️",
"👨‍✈️",
"👨‍❤️‍👨",
"👨‍❤️‍💋‍👨",
"👨",
"👩🏻‍🌾",
"👩🏻‍🍳",
"👩🏻‍🎓",
"👩🏻‍🎤",
"👩🏻‍🎨",
"👩🏻‍🏫",
"👩🏻‍🏭",
"👩🏻‍💻",
"👩🏻‍💼",
"👩🏻‍🔧",
"👩🏻‍🔬",
"👩🏻‍🚀",
"👩🏻‍🚒",
"👩🏻‍🤝‍👨🏼",
"👩🏻‍🤝‍👨🏽",
"👩🏻‍🤝‍👨🏾",
"👩🏻‍🤝‍👨🏿",
"👩🏻‍🦯",
"👩🏻‍🦰",
"👩🏻‍🦱",
"👩🏻‍🦲",
"👩🏻‍🦳",
"👩🏻‍🦼",
"👩🏻‍🦽",
"👩🏻‍⚕️",
"👩🏻‍⚖️",
"👩🏻‍✈️",
"👩🏻",
"👩🏼‍🌾",
"👩🏼‍🍳",
"👩🏼‍🎓",
"👩🏼‍🎤",
"👩🏼‍🎨",
"👩🏼‍🏫",
"👩🏼‍🏭",
"👩🏼‍💻",
"👩🏼‍💼",
"👩🏼‍🔧",
"👩🏼‍🔬",
"👩🏼‍🚀",
"👩🏼‍🚒",
"👩🏼‍🤝‍👨🏻",
"👩🏼‍🤝‍👨🏽",
"👩🏼‍🤝‍👨🏾",
"👩🏼‍🤝‍👨🏿",
"👩🏼‍🤝‍👩🏻",
"👩🏼‍🦯",
"👩🏼‍🦰",
"👩🏼‍🦱",
"👩🏼‍🦲",
"👩🏼‍🦳",
"👩🏼‍🦼",
"👩🏼‍🦽",
"👩🏼‍⚕️",
"👩🏼‍⚖️",
"👩🏼‍✈️",
"👩🏼",
"👩🏽‍🌾",
"👩🏽‍🍳",
"👩🏽‍🎓",
"👩🏽‍🎤",
"👩🏽‍🎨",
"👩🏽‍🏫",
"👩🏽‍🏭",
"👩🏽‍💻",
"👩🏽‍💼",
"👩🏽‍🔧",
"👩🏽‍🔬",
"👩🏽‍🚀",
"👩🏽‍🚒",
"👩🏽‍🤝‍👨🏻",
"👩🏽‍🤝‍👨🏼",
"👩🏽‍🤝‍👨🏾",
"👩🏽‍🤝‍👨🏿",
"👩🏽‍🤝‍👩🏻",
"👩🏽‍🤝‍👩🏼",
"👩🏽‍🦯",
"👩🏽‍🦰",
"👩🏽‍🦱",
"👩🏽‍🦲",
"👩🏽‍🦳",
"👩🏽‍🦼",
"👩🏽‍🦽",
"👩🏽‍⚕️",
"👩🏽‍⚖️",
"👩🏽‍✈️",
"👩🏽",
"👩🏾‍🌾",
"👩🏾‍🍳",
"👩🏾‍🎓",
"👩🏾‍🎤",
"👩🏾‍🎨",
"👩🏾‍🏫",
"👩🏾‍🏭",
"👩🏾‍💻",
"👩🏾‍💼",
"👩🏾‍🔧",
"👩🏾‍🔬",
"👩🏾‍🚀",
"👩🏾‍🚒",
"👩🏾‍🤝‍👨🏻",
"👩🏾‍🤝‍👨🏼",
"👩🏾‍🤝‍👨🏽",
"👩🏾‍🤝‍👨🏿",
"👩🏾‍🤝‍👩🏻",
"👩🏾‍🤝‍👩🏼",
"👩🏾‍🤝‍👩🏽",
"👩🏾‍🦯",
"👩🏾‍🦰",
"👩🏾‍🦱",
"👩🏾‍🦲",
"👩🏾‍🦳",
"👩🏾‍🦼",
"👩🏾‍🦽",
"👩🏾‍⚕️",
"👩🏾‍⚖️",
"👩🏾‍✈️",
"👩🏾",
"👩🏿‍🌾",
"👩🏿‍🍳",
"👩🏿‍🎓",
"👩🏿‍🎤",
"👩🏿‍🎨",
"👩🏿‍🏫",
"👩🏿‍🏭",
"👩🏿‍💻",
"👩🏿‍💼",
"👩🏿‍🔧",
"👩🏿‍🔬",
"👩🏿‍🚀",
"👩🏿‍🚒",
"👩🏿‍🤝‍👨🏻",
"👩🏿‍🤝‍👨🏼",
"👩🏿‍🤝‍👨🏽",
"👩🏿‍🤝‍👨🏾",
"👩🏿‍🤝‍👩🏻",
"👩🏿‍🤝‍👩🏼",
"👩🏿‍🤝‍👩🏽",
"👩🏿‍🤝‍👩🏾",
"👩🏿‍🦯",
"👩🏿‍🦰",
"👩🏿‍🦱",
"👩🏿‍🦲",
"👩🏿‍🦳",
"👩🏿‍🦼",
"👩🏿‍🦽",
"👩🏿‍⚕️",
"👩🏿‍⚖️",
"👩🏿‍✈️",
"👩🏿",
"👩‍🌾",
"👩‍🍳",
"👩‍🎓",
"👩‍🎤",
"👩‍🎨",
"👩‍🏫",
"👩‍🏭",
"👩‍👦‍👦",
"👩‍👦",
"👩‍👧‍👦",
"👩‍👧‍👧",
"👩‍👧",
"👩‍👩‍👦‍👦",
"👩‍👩‍👦",
"👩‍👩‍👧‍👦",
"👩‍👩‍👧‍👧",
"👩‍👩‍👧",
"👩‍💻",
"👩‍💼",
"👩‍🔧",
"👩‍🔬",
"👩‍🚀",
"👩‍🚒",
"👩‍🦯",
"👩‍🦰",
"👩‍🦱",
"👩‍🦲",
"👩‍🦳",
"👩‍🦼",
"👩‍🦽",
"👩‍⚕️",
"👩‍⚖️",
"👩‍✈️",
"👩‍❤️‍👨",
"👩‍❤️‍👩",
"👩‍❤️‍💋‍👨",
"👩‍❤️‍💋‍👩",
"👩",
"👪",
"👫🏻",
"👫🏼",
"👫🏽",
"👫🏾",
"👫🏿",
"👫",
"👬🏻",
"👬🏼",
"👬🏽",
"👬🏾",
"👬🏿",
"👬",
"👭🏻",
"👭🏼",
"👭🏽",
"👭🏾",
"👭🏿",
"👭",
"👮🏻‍♀️",
"👮🏻‍♂️",
"👮🏻",
"👮🏼‍♀️",
"👮🏼‍♂️",
"👮🏼",
"👮🏽‍♀️",
"👮🏽‍♂️",
"👮🏽",
"👮🏾‍♀️",
"👮🏾‍♂️",
"👮🏾",
"👮🏿‍♀️",
"👮🏿‍♂️",
"👮🏿",
"👮‍♀️",
"👮‍♂️",
"👮",
"👯‍♀️",
"👯‍♂️",
"👯",
"👰🏻",
"👰🏼",
"👰🏽",
"👰🏾",
"👰🏿",
"👰",
"👱🏻‍♀️",
"👱🏻‍♂️",
"👱🏻",
"👱🏼‍♀️",
"👱🏼‍♂️",
"👱🏼",
"👱🏽‍♀️",
"👱🏽‍♂️",
"👱🏽",
"👱🏾‍♀️",
"👱🏾‍♂️",
"👱🏾",
"👱🏿‍♀️",
"👱🏿‍♂️",
"👱🏿",
"👱‍♀️",
"👱‍♂️",
"👱",
"👲🏻",
"👲🏼",
"👲🏽",
"👲🏾",
"👲🏿",
"👲",
"👳🏻‍♀️",
"👳🏻‍♂️",
"👳🏻",
"👳🏼‍♀️",
"👳🏼‍♂️",
"👳🏼",
"👳🏽‍♀️",
"👳🏽‍♂️",
"👳🏽",
"👳🏾‍♀️",
"👳🏾‍♂️",
"👳🏾",
"👳🏿‍♀️",
"👳🏿‍♂️",
"👳🏿",
"👳‍♀️",
"👳‍♂️",
"👳",
"👴🏻",
"👴🏼",
"👴🏽",
"👴🏾",
"👴🏿",
"👴",
"👵🏻",
"👵🏼",
"👵🏽",
"👵🏾",
"👵🏿",
"👵",
"👶🏻",
"👶🏼",
"👶🏽",
"👶🏾",
"👶🏿",
"👶",
"👷🏻‍♀️",
"👷🏻‍♂️",
"👷🏻",
"👷🏼‍♀️",
"👷🏼‍♂️",
"👷🏼",
"👷🏽‍♀️",
"👷🏽‍♂️",
"👷🏽",
"👷🏾‍♀️",
"👷🏾‍♂️",
"👷🏾",
"👷🏿‍♀️",
"👷🏿‍♂️",
"👷🏿",
"👷‍♀️",
"👷‍♂️",
"👷",
"👸🏻",
"👸🏼",
"👸🏽",
"👸🏾",
"👸🏿",
"👸",
"👹",
"👺",
"👻",
"👼🏻",
"👼🏼",
"👼🏽",
"👼🏾",
"👼🏿",
"👼",
"👽",
"👾",
"👿",
"💀",
"💁🏻‍♀️",
"💁🏻‍♂️",
"💁🏻",
"💁🏼‍♀️",
"💁🏼‍♂️",
"💁🏼",
"💁🏽‍♀️",
"💁🏽‍♂️",
"💁🏽",
"💁🏾‍♀️",
"💁🏾‍♂️",
"💁🏾",
"💁🏿‍♀️",
"💁🏿‍♂️",
"💁🏿",
"💁‍♀️",
"💁‍♂️",
"💁",
"💂🏻‍♀️",
"💂🏻‍♂️",
"💂🏻",
"💂🏼‍♀️",
"💂🏼‍♂️",
"💂🏼",
"💂🏽‍♀️",
"💂🏽‍♂️",
"💂🏽",
"💂🏾‍♀️",
"💂🏾‍♂️",
"💂🏾",
"💂🏿‍♀️",
"💂🏿‍♂️",
"💂🏿",
"💂‍♀️",
"💂‍♂️",
"💂",
"💃🏻",
"💃🏼",
"💃🏽",
"💃🏾",
"💃🏿",
"💃",
"💄",
"💅🏻",
"💅🏼",
"💅🏽",
"💅🏾",
"💅🏿",
"💅",
"💆🏻‍♀️",
"💆🏻‍♂️",
"💆🏻",
"💆🏼‍♀️",
"💆🏼‍♂️",
"💆🏼",
"💆🏽‍♀️",
"💆🏽‍♂️",
"💆🏽",
"💆🏾‍♀️",
"💆🏾‍♂️",
"💆🏾",
"💆🏿‍♀️",
"💆🏿‍♂️",
"💆🏿",
"💆‍♀️",
"💆‍♂️",
"💆",
"💇🏻‍♀️",
"💇🏻‍♂️",
"💇🏻",
"💇🏼‍♀️",
"💇🏼‍♂️",
"💇🏼",
"💇🏽‍♀️",
"💇🏽‍♂️",
"💇🏽",
"💇🏾‍♀️",
"💇🏾‍♂️",
"💇🏾",
"💇🏿‍♀️",
"💇🏿‍♂️",
"💇🏿",
"💇‍♀️",
"💇‍♂️",
"💇",
"💈",
"💉",
"💊",
"💋",
"💌",
"💍",
"💎",
"💏",
"💐",
"💑",
"💒",
"💓",
"💔",
"💕",
"💖",
"💗",
"💘",
"💙",
"💚",
"💛",
"💜",
"💝",
"💞",
"💟",
"💠",
"💡",
"💢",
"💣",
"💤",
"💥",
"💦",
"💧",
"💨",
"💩",
"💪🏻",
"💪🏼",
"💪🏽",
"💪🏾",
"💪🏿",
"💪",
"💫",
"💬",
"💭",
"💮",
"💯",
"💰",
"💱",
"💲",
"💳",
"💴",
"💵",
"💶",
"💷",
"💸",
"💹",
"💺",
"💻",
"💼",
"💽",
"💾",
"💿",
"📀",
"📁",
"📂",
"📃",
"📄",
"📅",
"📆",
"📇",
"📈",
"📉",
"📊",
"📋",
"📌",
"📍",
"📎",
"📏",
"📐",
"📑",
"📒",
"📓",
"📔",
"📕",
"📖",
"📗",
"📘",
"📙",
"📚",
"📛",
"📜",
"📝",
"📞",
"📟",
"📠",
"📡",
"📢",
"📣",
"📤",
"📥",
"📦",
"📧",
"📨",
"📩",
"📪",
"📫",
"📬",
"📭",
"📮",
"📯",
"📰",
"📱",
"📲",
"📳",
"📴",
"📵",
"📶",
"📷",
"📸",
"📹",
"📺",
"📻",
"📼",
"📽️",
"📿",
"🔀",
"🔁",
"🔂",
"🔃",
"🔄",
"🔅",
"🔆",
"🔇",
"🔈",
"🔉",
"🔊",
"🔋",
"🔌",
"🔍",
"🔎",
"🔏",
"🔐",
"🔑",
"🔒",
"🔓",
"🔔",
"🔕",
"🔖",
"🔗",
"🔘",
"🔙",
"🔚",
"🔛",
"🔜",
"🔝",
"🔞",
"🔟",
"🔠",
"🔡",
"🔢",
"🔣",
"🔤",
"🔥",
"🔦",
"🔧",
"🔨",
"🔩",
"🔪",
"🔫",
"🔬",
"🔭",
"🔮",
"🔯",
"🔰",
"🔱",
"🔲",
"🔳",
"🔴",
"🔵",
"🔶",
"🔷",
"🔸",
"🔹",
"🔺",
"🔻",
"🔼",
"🔽",
"🕉️",
"🕊️",
"🕋",
"🕌",
"🕍",
"🕎",
"🕐",
"🕑",
"🕒",
"🕓",
"🕔",
"🕕",
"🕖",
"🕗",
"🕘",
"🕙",
"🕚",
"🕛",
"🕜",
"🕝",
"🕞",
"🕟",
"🕠",
"🕡",
"🕢",
"🕣",
"🕤",
"🕥",
"🕦",
"🕧",
"🕯️",
"🕰️",
"🕳️",
"🕴🏻‍♀️",
"🕴🏻‍♂️",
"🕴🏻",
"🕴🏼‍♀️",
"🕴🏼‍♂️",
"🕴🏼",
"🕴🏽‍♀️",
"🕴🏽‍♂️",
"🕴🏽",
"🕴🏾‍♀️",
"🕴🏾‍♂️",
"🕴🏾",
"🕴🏿‍♀️",
"🕴🏿‍♂️",
"🕴🏿",
"🕴️‍♀️",
"🕴️‍♂️",
"🕴️",
"🕵🏻‍♀️",
"🕵🏻‍♂️",
"🕵🏻",
"🕵🏼‍♀️",
"🕵🏼‍♂️",
"🕵🏼",
"🕵🏽‍♀️",
"🕵🏽‍♂️",
"🕵🏽",
"🕵🏾‍♀️",
"🕵🏾‍♂️",
"🕵🏾",
"🕵🏿‍♀️",
"🕵🏿‍♂️",
"🕵🏿",
"🕵️‍♀️",
"🕵️‍♂️",
"🕵️",
"🕶️",
"🕷️",
"🕸️",
"🕹️",
"🕺🏻",
"🕺🏼",
"🕺🏽",
"🕺🏾",
"🕺🏿",
"🕺",
"🖇️",
"🖊️",
"🖋️",
"🖌️",
"🖍️",
"🖐🏻",
"🖐🏼",
"🖐🏽",
"🖐🏾",
"🖐🏿",
"🖐️",
"🖕🏻",
"🖕🏼",
"🖕🏽",
"🖕🏾",
"🖕🏿",
"🖕",
"🖖🏻",
"🖖🏼",
"🖖🏽",
"🖖🏾",
"🖖🏿",
"🖖",
"🖤",
"🖥️",
"🖨️",
"🖱️",
"🖲️",
"🖼️",
"🗂️",
"🗃️",
"🗄️",
"🗑️",
"🗒️",
"🗓️",
"🗜️",
"🗝️",
"🗞️",
"🗡️",
"🗣️",
"🗨️",
"🗯️",
"🗳️",
"🗺️",
"🗻",
"🗼",
"🗽",
"🗾",
"🗿",
"😀",
"😁",
"😂",
"😃",
"😄",
"😅",
"😆",
"😇",
"😈",
"😉",
"😊",
"😋",
"😌",
"😍",
"😎",
"😏",
"😐",
"😑",
"😒",
"😓",
"😔",
"😕",
"😖",
"😗",
"😘",
"😙",
"😚",
"😛",
"😜",
"😝",
"😞",
"😟",
"😠",
"😡",
"😢",
"😣",
"😤",
"😥",
"😦",
"😧",
"😨",
"😩",
"😪",
"😫",
"😬",
"😭",
"😮",
"😯",
"😰",
"😱",
"😲",
"😳",
"😴",
"😵",
"😶",
"😷",
"😸",
"😹",
"😺",
"😻",
"😼",
"😽",
"😾",
"😿",
"🙀",
"🙁",
"🙂",
"🙃",
"🙄",
"🙅🏻‍♀️",
"🙅🏻‍♂️",
"🙅🏻",
"🙅🏼‍♀️",
"🙅🏼‍♂️",
"🙅🏼",
"🙅🏽‍♀️",
"🙅🏽‍♂️",
"🙅🏽",
"🙅🏾‍♀️",
"🙅🏾‍♂️",
"🙅🏾",
"🙅🏿‍♀️",
"🙅🏿‍♂️",
"🙅🏿",
"🙅‍♀️",
"🙅‍♂️",
"🙅",
"🙆🏻‍♀️",
"🙆🏻‍♂️",
"🙆🏻",
"🙆🏼‍♀️",
"🙆🏼‍♂️",
"🙆🏼",
"🙆🏽‍♀️",
"🙆🏽‍♂️",
"🙆🏽",
"🙆🏾‍♀️",
"🙆🏾‍♂️",
"🙆🏾",
"🙆🏿‍♀️",
"🙆🏿‍♂️",
"🙆🏿",
"🙆‍♀️",
"🙆‍♂️",
"🙆",
"🙇🏻‍♀️",
"🙇🏻‍♂️",
"🙇🏻",
"🙇🏼‍♀️",
"🙇🏼‍♂️",
"🙇🏼",
"🙇🏽‍♀️",
"🙇🏽‍♂️",
"🙇🏽",
"🙇🏾‍♀️",
"🙇🏾‍♂️",
"🙇🏾",
"🙇🏿‍♀️",
"🙇🏿‍♂️",
"🙇🏿",
"🙇‍♀️",
"🙇‍♂️",
"🙇",
"🙈",
"🙉",
"🙊",
"🙋🏻‍♀️",
"🙋🏻‍♂️",
"🙋🏻",
"🙋🏼‍♀️",
"🙋🏼‍♂️",
"🙋🏼",
"🙋🏽‍♀️",
"🙋🏽‍♂️",
"🙋🏽",
"🙋🏾‍♀️",
"🙋🏾‍♂️",
"🙋🏾",
"🙋🏿‍♀️",
"🙋🏿‍♂️",
"🙋🏿",
"🙋‍♀️",
"🙋‍♂️",
"🙋",
"🙌🏻",
"🙌🏼",
"🙌🏽",
"🙌🏾",
"🙌🏿",
"🙌",
"🙍🏻‍♀️",
"🙍🏻‍♂️",
"🙍🏻",
"🙍🏼‍♀️",
"🙍🏼‍♂️",
"🙍🏼",
"🙍🏽‍♀️",
"🙍🏽‍♂️",
"🙍🏽",
"🙍🏾‍♀️",
"🙍🏾‍♂️",
"🙍🏾",
"🙍🏿‍♀️",
"🙍🏿‍♂️",
"🙍🏿",
"🙍‍♀️",
"🙍‍♂️",
"🙍",
"🙎🏻‍♀️",
"🙎🏻‍♂️",
"🙎🏻",
"🙎🏼‍♀️",
"🙎🏼‍♂️",
"🙎🏼",
"🙎🏽‍♀️",
"🙎🏽‍♂️",
"🙎🏽",
"🙎🏾‍♀️",
"🙎🏾‍♂️",
"🙎🏾",
"🙎🏿‍♀️",
"🙎🏿‍♂️",
"🙎🏿",
"🙎‍♀️",
"🙎‍♂️",
"🙎",
"🙏🏻",
"🙏🏼",
"🙏🏽",
"🙏🏾",
"🙏🏿",
"🙏",
"🚀",
"🚁",
"🚂",
"🚃",
"🚄",
"🚅",
"🚆",
"🚇",
"🚈",
"🚉",
"🚊",
"🚋",
"🚌",
"🚍",
"🚎",
"🚏",
"🚐",
"🚑",
"🚒",
"🚓",
"🚔",
"🚕",
"🚖",
"🚗",
"🚘",
"🚙",
"🚚",
"🚛",
"🚜",
"🚝",
"🚞",
"🚟",
"🚠",
"🚡",
"🚢",
"🚣🏻‍♀️",
"🚣🏻‍♂️",
"🚣🏻",
"🚣🏼‍♀️",
"🚣🏼‍♂️",
"🚣🏼",
"🚣🏽‍♀️",
"🚣🏽‍♂️",
"🚣🏽",
"🚣🏾‍♀️",
"🚣🏾‍♂️",
"🚣🏾",
"🚣🏿‍♀️",
"🚣🏿‍♂️",
"🚣🏿",
"🚣‍♀️",
"🚣‍♂️",
"🚣",
"🚤",
"🚥",
"🚦",
"🚧",
"🚨",
"🚩",
"🚪",
"🚫",
"🚬",
"🚭",
"🚮",
"🚯",
"🚰",
"🚱",
"🚲",
"🚳",
"🚴🏻‍♀️",
"🚴🏻‍♂️",
"🚴🏻",
"🚴🏼‍♀️",
"🚴🏼‍♂️",
"🚴🏼",
"🚴🏽‍♀️",
"🚴🏽‍♂️",
"🚴🏽",
"🚴🏾‍♀️",
"🚴🏾‍♂️",
"🚴🏾",
"🚴🏿‍♀️",
"🚴🏿‍♂️",
"🚴🏿",
"🚴‍♀️",
"🚴‍♂️",
"🚴",
"🚵🏻‍♀️",
"🚵🏻‍♂️",
"🚵🏻",
"🚵🏼‍♀️",
"🚵🏼‍♂️",
"🚵🏼",
"🚵🏽‍♀️",
"🚵🏽‍♂️",
"🚵🏽",
"🚵🏾‍♀️",
"🚵🏾‍♂️",
"🚵🏾",
"🚵🏿‍♀️",
"🚵🏿‍♂️",
"🚵🏿",
"🚵‍♀️",
"🚵‍♂️",
"🚵",
"🚶🏻‍♀️",
"🚶🏻‍♂️",
"🚶🏻",
"🚶🏼‍♀️",
"🚶🏼‍♂️",
"🚶🏼",
"🚶🏽‍♀️",
"🚶🏽‍♂️",
"🚶🏽",
"🚶🏾‍♀️",
"🚶🏾‍♂️",
"🚶🏾",
"🚶🏿‍♀️",
"🚶🏿‍♂️",
"🚶🏿",
"🚶‍♀️",
"🚶‍♂️",
"🚶",
"🚷",
"🚸",
"🚹",
"🚺",
"🚻",
"🚼",
"🚽",
"🚾",
"🚿",
"🛀🏻",
"🛀🏼",
"🛀🏽",
"🛀🏾",
"🛀🏿",
"🛀",
"🛁",
"🛂",
"🛃",
"🛄",
"🛅",
"🛋️",
"🛌🏻",
"🛌🏼",
"🛌🏽",
"🛌🏾",
"🛌🏿",
"🛌",
"🛍️",
"🛎️",
"🛏️",
"🛐",
"🛑",
"🛒",
"🛕",
"🛠️",
"🛡️",
"🛢️",
"🛣️",
"🛤️",
"🛥️",
"🛩️",
"🛫",
"🛬",
"🛰️",
"🛳️",
"🛴",
"🛵",
"🛶",
"🛷",
"🛸",
"🛹",
"🛺",
"🟠",
"🟡",
"🟢",
"🟣",
"🟤",
"🟥",
"🟦",
"🟧",
"🟨",
"🟩",
"🟪",
"🟫",
"🤍",
"🤎",
"🤏🏻",
"🤏🏼",
"🤏🏽",
"🤏🏾",
"🤏🏿",
"🤏",
"🤐",
"🤑",
"🤒",
"🤓",
"🤔",
"🤕",
"🤖",
"🤗",
"🤘🏻",
"🤘🏼",
"🤘🏽",
"🤘🏾",
"🤘🏿",
"🤘",
"🤙🏻",
"🤙🏼",
"🤙🏽",
"🤙🏾",
"🤙🏿",
"🤙",
"🤚🏻",
"🤚🏼",
"🤚🏽",
"🤚🏾",
"🤚🏿",
"🤚",
"🤛🏻",
"🤛🏼",
"🤛🏽",
"🤛🏾",
"🤛🏿",
"🤛",
"🤜🏻",
"🤜🏼",
"🤜🏽",
"🤜🏾",
"🤜🏿",
"🤜",
"🤝",
"🤞🏻",
"🤞🏼",
"🤞🏽",
"🤞🏾",
"🤞🏿",
"🤞",
"🤟🏻",
"🤟🏼",
"🤟🏽",
"🤟🏾",
"🤟🏿",
"🤟",
"🤠",
"🤡",
"🤢",
"🤣",
"🤤",
"🤥",
"🤦🏻‍♀️",
"🤦🏻‍♂️",
"🤦🏻",
"🤦🏼‍♀️",
"🤦🏼‍♂️",
"🤦🏼",
"🤦🏽‍♀️",
"🤦🏽‍♂️",
"🤦🏽",
"🤦🏾‍♀️",
"🤦🏾‍♂️",
"🤦🏾",
"🤦🏿‍♀️",
"🤦🏿‍♂️",
"🤦🏿",
"🤦‍♀️",
"🤦‍♂️",
"🤦",
"🤧",
"🤨",
"🤩",
"🤪",
"🤫",
"🤬",
"🤭",
"🤮",
"🤯",
"🤰🏻",
"🤰🏼",
"🤰🏽",
"🤰🏾",
"🤰🏿",
"🤰",
"🤱🏻",
"🤱🏼",
"🤱🏽",
"🤱🏾",
"🤱🏿",
"🤱",
"🤲🏻",
"🤲🏼",
"🤲🏽",
"🤲🏾",
"🤲🏿",
"🤲",
"🤳🏻",
"🤳🏼",
"🤳🏽",
"🤳🏾",
"🤳🏿",
"🤳",
"🤴🏻",
"🤴🏼",
"🤴🏽",
"🤴🏾",
"🤴🏿",
"🤴",
"🤵🏻‍♀️",
"🤵🏻‍♂️",
"🤵🏻",
"🤵🏼‍♀️",
"🤵🏼‍♂️",
"🤵🏼",
"🤵🏽‍♀️",
"🤵🏽‍♂️",
"🤵🏽",
"🤵🏾‍♀️",
"🤵🏾‍♂️",
"🤵🏾",
"🤵🏿‍♀️",
"🤵🏿‍♂️",
"🤵🏿",
"🤵‍♀️",
"🤵‍♂️",
"🤵",
"🤶🏻",
"🤶🏼",
"🤶🏽",
"🤶🏾",
"🤶🏿",
"🤶",
"🤷🏻‍♀️",
"🤷🏻‍♂️",
"🤷🏻",
"🤷🏼‍♀️",
"🤷🏼‍♂️",
"🤷🏼",
"🤷🏽‍♀️",
"🤷🏽‍♂️",
"🤷🏽",
"🤷🏾‍♀️",
"🤷🏾‍♂️",
"🤷🏾",
"🤷🏿‍♀️",
"🤷🏿‍♂️",
"🤷🏿",
"🤷‍♀️",
"🤷‍♂️",
"🤷",
"🤸🏻‍♀️",
"🤸🏻‍♂️",
"🤸🏻",
"🤸🏼‍♀️",
"🤸🏼‍♂️",
"🤸🏼",
"🤸🏽‍♀️",
"🤸🏽‍♂️",
"🤸🏽",
"🤸🏾‍♀️",
"🤸🏾‍♂️",
"🤸🏾",
"🤸🏿‍♀️",
"🤸🏿‍♂️",
"🤸🏿",
"🤸‍♀️",
"🤸‍♂️",
"🤸",
"🤹🏻‍♀️",
"🤹🏻‍♂️",
"🤹🏻",
"🤹🏼‍♀️",
"🤹🏼‍♂️",
"🤹🏼",
"🤹🏽‍♀️",
"🤹🏽‍♂️",
"🤹🏽",
"🤹🏾‍♀️",
"🤹🏾‍♂️",
"🤹🏾",
"🤹🏿‍♀️",
"🤹🏿‍♂️",
"🤹🏿",
"🤹‍♀️",
"🤹‍♂️",
"🤹",
"🤺",
"🤼‍♀️",
"🤼‍♂️",
"🤼",
"🤽🏻‍♀️",
"🤽🏻‍♂️",
"🤽🏻",
"🤽🏼‍♀️",
"🤽🏼‍♂️",
"🤽🏼",
"🤽🏽‍♀️",
"🤽🏽‍♂️",
"🤽🏽",
"🤽🏾‍♀️",
"🤽🏾‍♂️",
"🤽🏾",
"🤽🏿‍♀️",
"🤽🏿‍♂️",
"🤽🏿",
"🤽‍♀️",
"🤽‍♂️",
"🤽",
"🤾🏻‍♀️",
"🤾🏻‍♂️",
"🤾🏻",
"🤾🏼‍♀️",
"🤾🏼‍♂️",
"🤾🏼",
"🤾🏽‍♀️",
"🤾🏽‍♂️",
"🤾🏽",
"🤾🏾‍♀️",
"🤾🏾‍♂️",
"🤾🏾",
"🤾🏿‍♀️",
"🤾🏿‍♂️",
"🤾🏿",
"🤾‍♀️",
"🤾‍♂️",
"🤾",
"🤿",
"🥀",
"🥁",
"🥂",
"🥃",
"🥄",
"🥅",
"🥇",
"🥈",
"🥉",
"🥊",
"🥋",
"🥌",
"🥍",
"🥎",
"🥏",
"🥐",
"🥑",
"🥒",
"🥓",
"🥔",
"🥕",
"🥖",
"🥗",
"🥘",
"🥙",
"🥚",
"🥛",
"🥜",
"🥝",
"🥞",
"🥟",
"🥠",
"🥡",
"🥢",
"🥣",
"🥤",
"🥥",
"🥦",
"🥧",
"🥨",
"🥩",
"🥪",
"🥫",
"🥬",
"🥭",
"🥮",
"🥯",
"🥰",
"🥱",
"🥳",
"🥴",
"🥵",
"🥶",
"🥺",
"🥻",
"🥼",
"🥽",
"🥾",
"🥿",
"🦀",
"🦁",
"🦂",
"🦃",
"🦄",
"🦅",
"🦆",
"🦇",
"🦈",
"🦉",
"🦊",
"🦋",
"🦌",
"🦍",
"🦎",
"🦏",
"🦐",
"🦑",
"🦒",
"🦓",
"🦔",
"🦕",
"🦖",
"🦗",
"🦘",
"🦙",
"🦚",
"🦛",
"🦜",
"🦝",
"🦞",
"🦟",
"🦠",
"🦡",
"🦢",
"🦥",
"🦦",
"🦧",
"🦨",
"🦩",
"🦪",
"🦮",
"🦯",
"🦰",
"🦱",
"🦲",
"🦳",
"🦴",
"🦵🏻",
"🦵🏼",
"🦵🏽",
"🦵🏾",
"🦵🏿",
"🦵",
"🦶🏻",
"🦶🏼",
"🦶🏽",
"🦶🏾",
"🦶🏿",
"🦶",
"🦷",
"🦸🏻‍♀️",
"🦸🏻‍♂️",
"🦸🏻",
"🦸🏼‍♀️",
"🦸🏼‍♂️",
"🦸🏼",
"🦸🏽‍♀️",
"🦸🏽‍♂️",
"🦸🏽",
"🦸🏾‍♀️",
"🦸🏾‍♂️",
"🦸🏾",
"🦸🏿‍♀️",
"🦸🏿‍♂️",
"🦸🏿",
"🦸‍♀️",
"🦸‍♂️",
"🦸",
"🦹🏻‍♀️",
"🦹🏻‍♂️",
"🦹🏻",
"🦹🏼‍♀️",
"🦹🏼‍♂️",
"🦹🏼",
"🦹🏽‍♀️",
"🦹🏽‍♂️",
"🦹🏽",
"🦹🏾‍♀️",
"🦹🏾‍♂️",
"🦹🏾",
"🦹🏿‍♀️",
"🦹🏿‍♂️",
"🦹🏿",
"🦹‍♀️",
"🦹‍♂️",
"🦹",
"🦺",
"🦻🏻",
"🦻🏼",
"🦻🏽",
"🦻🏾",
"🦻🏿",
"🦻",
"🦼",
"🦽",
"🦾",
"🦿",
"🧀",
"🧁",
"🧂",
"🧃",
"🧄",
"🧅",
"🧆",
"🧇",
"🧈",
"🧉",
"🧊",
"🧍🏻‍♀️",
"🧍🏻‍♂️",
"🧍🏻",
"🧍🏼‍♀️",
"🧍🏼‍♂️",
"🧍🏼",
"🧍🏽‍♀️",
"🧍🏽‍♂️",
"🧍🏽",
"🧍🏾‍♀️",
"🧍🏾‍♂️",
"🧍🏾",
"🧍🏿‍♀️",
"🧍🏿‍♂️",
"🧍🏿",
"🧍‍♀️",
"🧍‍♂️",
"🧍",
"🧎🏻‍♀️",
"🧎🏻‍♂️",
"🧎🏻",
"🧎🏼‍♀️",
"🧎🏼‍♂️",
"🧎🏼",
"🧎🏽‍♀️",
"🧎🏽‍♂️",
"🧎🏽",
"🧎🏾‍♀️",
"🧎🏾‍♂️",
"🧎🏾",
"🧎🏿‍♀️",
"🧎🏿‍♂️",
"🧎🏿",
"🧎‍♀️",
"🧎‍♂️",
"🧎",
"🧏🏻‍♀️",
"🧏🏻‍♂️",
"🧏🏻",
"🧏🏼‍♀️",
"🧏🏼‍♂️",
"🧏🏼",
"🧏🏽‍♀️",
"🧏🏽‍♂️",
"🧏🏽",
"🧏🏾‍♀️",
"🧏🏾‍♂️",
"🧏🏾",
"🧏🏿‍♀️",
"🧏🏿‍♂️",
"🧏🏿",
"🧏‍♀️",
"🧏‍♂️",
"🧏",
"🧐",
"🧑🏻‍🤝‍🧑🏻",
"🧑🏻",
"🧑🏼‍🤝‍🧑🏻",
"🧑🏼‍🤝‍🧑🏼",
"🧑🏼",
"🧑🏽‍🤝‍🧑🏻",
"🧑🏽‍🤝‍🧑🏼",
"🧑🏽‍🤝‍🧑🏽",
"🧑🏽",
"🧑🏾‍🤝‍🧑🏻",
"🧑🏾‍🤝‍🧑🏼",
"🧑🏾‍🤝‍🧑🏽",
"🧑🏾‍🤝‍🧑🏾",
"🧑🏾",
"🧑🏿‍🤝‍🧑🏻",
"🧑🏿‍🤝‍🧑🏼",
"🧑🏿‍🤝‍🧑🏽",
"🧑🏿‍🤝‍🧑🏾",
"🧑🏿‍🤝‍🧑🏿",
"🧑🏿",
"🧑‍🤝‍🧑",
"🧑",
"🧒🏻",
"🧒🏼",
"🧒🏽",
"🧒🏾",
"🧒🏿",
"🧒",
"🧓🏻",
"🧓🏼",
"🧓🏽",
"🧓🏾",
"🧓🏿",
"🧓",
"🧔🏻",
"🧔🏼",
"🧔🏽",
"🧔🏾",
"🧔🏿",
"🧔",
"🧕🏻",
"🧕🏼",
"🧕🏽",
"🧕🏾",
"🧕🏿",
"🧕",
"🧖🏻‍♀️",
"🧖🏻‍♂️",
"🧖🏻",
"🧖🏼‍♀️",
"🧖🏼‍♂️",
"🧖🏼",
"🧖🏽‍♀️",
"🧖🏽‍♂️",
"🧖🏽",
"🧖🏾‍♀️",
"🧖🏾‍♂️",
"🧖🏾",
"🧖🏿‍♀️",
"🧖🏿‍♂️",
"🧖🏿",
"🧖‍♀️",
"🧖‍♂️",
"🧖",
"🧗🏻‍♀️",
"🧗🏻‍♂️",
"🧗🏻",
"🧗🏼‍♀️",
"🧗🏼‍♂️",
"🧗🏼",
"🧗🏽‍♀️",
"🧗🏽‍♂️",
"🧗🏽",
"🧗🏾‍♀️",
"🧗🏾‍♂️",
"🧗🏾",
"🧗🏿‍♀️",
"🧗🏿‍♂️",
"🧗🏿",
"🧗‍♀️",
"🧗‍♂️",
"🧗",
"🧘🏻‍♀️",
"🧘🏻‍♂️",
"🧘🏻",
"🧘🏼‍♀️",
"🧘🏼‍♂️",
"🧘🏼",
"🧘🏽‍♀️",
"🧘🏽‍♂️",
"🧘🏽",
"🧘🏾‍♀️",
"🧘🏾‍♂️",
"🧘🏾",
"🧘🏿‍♀️",
"🧘🏿‍♂️",
"🧘🏿",
"🧘‍♀️",
"🧘‍♂️",
"🧘",
"🧙🏻‍♀️",
"🧙🏻‍♂️",
"🧙🏻",
"🧙🏼‍♀️",
"🧙🏼‍♂️",
"🧙🏼",
"🧙🏽‍♀️",
"🧙🏽‍♂️",
"🧙🏽",
"🧙🏾‍♀️",
"🧙🏾‍♂️",
"🧙🏾",
"🧙🏿‍♀️",
"🧙🏿‍♂️",
"🧙🏿",
"🧙‍♀️",
"🧙‍♂️",
"🧙",
"🧚🏻‍♀️",
"🧚🏻‍♂️",
"🧚🏻",
"🧚🏼‍♀️",
"🧚🏼‍♂️",
"🧚🏼",
"🧚🏽‍♀️",
"🧚🏽‍♂️",
"🧚🏽",
"🧚🏾‍♀️",
"🧚🏾‍♂️",
"🧚🏾",
"🧚🏿‍♀️",
"🧚🏿‍♂️",
"🧚🏿",
"🧚‍♀️",
"🧚‍♂️",
"🧚",
"🧛🏻‍♀️",
"🧛🏻‍♂️",
"🧛🏻",
"🧛🏼‍♀️",
"🧛🏼‍♂️",
"🧛🏼",
"🧛🏽‍♀️",
"🧛🏽‍♂️",
"🧛🏽",
"🧛🏾‍♀️",
"🧛🏾‍♂️",
"🧛🏾",
"🧛🏿‍♀️",
"🧛🏿‍♂️",
"🧛🏿",
"🧛‍♀️",
"🧛‍♂️",
"🧛",
"🧜🏻‍♀️",
"🧜🏻‍♂️",
"🧜🏻",
"🧜🏼‍♀️",
"🧜🏼‍♂️",
"🧜🏼",
"🧜🏽‍♀️",
"🧜🏽‍♂️",
"🧜🏽",
"🧜🏾‍♀️",
"🧜🏾‍♂️",
"🧜🏾",
"🧜🏿‍♀️",
"🧜🏿‍♂️",
"🧜🏿",
"🧜‍♀️",
"🧜‍♂️",
"🧜",
"🧝🏻‍♀️",
"🧝🏻‍♂️",
"🧝🏻",
"🧝🏼‍♀️",
"🧝🏼‍♂️",
"🧝🏼",
"🧝🏽‍♀️",
"🧝🏽‍♂️",
"🧝🏽",
"🧝🏾‍♀️",
"🧝🏾‍♂️",
"🧝🏾",
"🧝🏿‍♀️",
"🧝🏿‍♂️",
"🧝🏿",
"🧝‍♀️",
"🧝‍♂️",
"🧝",
"🧞‍♀️",
"🧞‍♂️",
"🧞",
"🧟‍♀️",
"🧟‍♂️",
"🧟",
"🧠",
"🧡",
"🧢",
"🧣",
"🧤",
"🧥",
"🧦",
"🧧",
"🧨",
"🧩",
"🧪",
"🧫",
"🧬",
"🧭",
"🧮",
"🧯",
"🧰",
"🧱",
"🧲",
"🧳",
"🧴",
"🧵",
"🧶",
"🧷",
"🧸",
"🧹",
"🧺",
"🧻",
"🧼",
"🧽",
"🧾",
"🧿",
"🩰",
"🩱",
"🩲",
"🩳",
"🩸",
"🩹",
"🩺",
"🪀",
"🪁",
"🪂",
"🪐",
"🪑",
"🪒",
"🪓",
"🪔",
"🪕",
"‼️",
"⁉️",
"™️",
"ℹ️",
"↔️",
"↕️",
"↖️",
"↗️",
"↘️",
"↙️",
"↩️",
"↪️",
"#⃣",
"⌚️",
"⌛️",
"⌨️",
"⏏️",
"⏩",
"⏪",
"⏫",
"⏬",
"⏭️",
"⏮️",
"⏯️",
"⏰",
"⏱️",
"⏲️",
"⏳",
"⏸️",
"⏹️",
"⏺️",
"Ⓜ️",
"▪️",
"▫️",
"▶️",
"◀️",
"◻️",
"◼️",
"◽️",
"◾️",
"☀️",
"☁️",
"☂️",
"☃️",
"☄️",
"☎️",
"☑️",
"☔️",
"☕️",
"☘️",
"☝🏻",
"☝🏼",
"☝🏽",
"☝🏾",
"☝🏿",
"☝️",
"☠️",
"☢️",
"☣️",
"☦️",
"☪️",
"☮️",
"☯️",
"☸️",
"☹️",
"☺️",
"♀️",
"♂️",
"♈️",
"♉️",
"♊️",
"♋️",
"♌️",
"♍️",
"♎️",
"♏️",
"♐️",
"♑️",
"♒️",
"♓️",
"♟️",
"♠️",
"♣️",
"♥️",
"♦️",
"♨️",
"♻️",
"♾",
"♿️",
"⚒️",
"⚓️",
"⚔️",
"⚕️",
"⚖️",
"⚗️",
"⚙️",
"⚛️",
"⚜️",
"⚠️",
"⚡️",
"⚪️",
"⚫️",
"⚰️",
"⚱️",
"⚽️",
"⚾️",
"⛄️",
"⛅️",
"⛈️",
"⛎",
"⛏️",
"⛑️",
"⛓️",
"⛔️",
"⛩️",
"⛪️",
"⛰️",
"⛱️",
"⛲️",
"⛳️",
"⛴️",
"⛵️",
"⛷🏻",
"⛷🏼",
"⛷🏽",
"⛷🏾",
"⛷🏿",
"⛷️",
"⛸️",
"⛹🏻‍♀️",
"⛹🏻‍♂️",
"⛹🏻",
"⛹🏼‍♀️",
"⛹🏼‍♂️",
"⛹🏼",
"⛹🏽‍♀️",
"⛹🏽‍♂️",
"⛹🏽",
"⛹🏾‍♀️",
"⛹🏾‍♂️",
"⛹🏾",
"⛹🏿‍♀️",
"⛹🏿‍♂️",
"⛹🏿",
"⛹️‍♀️",
"⛹️‍♂️",
"⛹️",
"⛺️",
"⛽️",
"✂️",
"✅",
"✈️",
"✉️",
"✊🏻",
"✊🏼",
"✊🏽",
"✊🏾",
"✊🏿",
"✊",
"✋🏻",
"✋🏼",
"✋🏽",
"✋🏾",
"✋🏿",
"✋",
"✌🏻",
"✌🏼",
"✌🏽",
"✌🏾",
"✌🏿",
"✌️",
"✍🏻",
"✍🏼",
"✍🏽",
"✍🏾",
"✍🏿",
"✍️",
"✏️",
"✒️",
"✔️",
"✖️",
"✝️",
"✡️",
"✨",
"✳️",
"✴️",
"❄️",
"❇️",
"❌",
"❎",
"❓",
"❔",
"❕",
"❗️",
"❣️",
"❤️",
"➕",
"➖",
"➗",
"➡️",
"➰",
"➿",
"⤴️",
"⤵️",
"*⃣",
"⬅️",
"⬆️",
"⬇️",
"⬛️",
"⬜️",
"⭐️",
"⭕️",
"0⃣",
"〰️",
"〽️",
"1⃣",
"2⃣",
"㊗️",
"㊙️",
"3⃣",
"4⃣",
"5⃣",
"6⃣",
"7⃣",
"8⃣",
"9⃣",
"©️",
"®️",
""
];
const path$1 = path__default;
const emojisList = emojisList$1;
const getHashDigest$1 = getHashDigest_1;
const emojiRegex = /[\uD800-\uDFFF]./;
const emojiList = emojisList.filter((emoji) => emojiRegex.test(emoji));
const emojiCache = {};
function encodeStringToEmoji(content, length) {
if (emojiCache[content]) {
return emojiCache[content];
}
length = length || 1;
const emojis = [];
do {
if (!emojiList.length) {
throw new Error('Ran out of emoji');
}
const index = Math.floor(Math.random() * emojiList.length);
emojis.push(emojiList[index]);
emojiList.splice(index, 1);
} while (--length > 0);
const emojiEncoding = emojis.join('');
emojiCache[content] = emojiEncoding;
return emojiEncoding;
}
function interpolateName$2(loaderContext, name, options) {
let filename;
const hasQuery =
loaderContext.resourceQuery && loaderContext.resourceQuery.length > 1;
if (typeof name === 'function') {
filename = name(
loaderContext.resourcePath,
hasQuery ? loaderContext.resourceQuery : undefined
);
} else {
filename = name || '[hash].[ext]';
}
const context = options.context;
const content = options.content;
const regExp = options.regExp;
let ext = 'bin';
let basename = 'file';
let directory = '';
let folder = '';
let query = '';
if (loaderContext.resourcePath) {
const parsed = path$1.parse(loaderContext.resourcePath);
let resourcePath = loaderContext.resourcePath;
if (parsed.ext) {
ext = parsed.ext.substr(1);
}
if (parsed.dir) {
basename = parsed.name;
resourcePath = parsed.dir + path$1.sep;
}
if (typeof context !== 'undefined') {
directory = path$1
.relative(context, resourcePath + '_')
.replace(/\\/g, '/')
.replace(/\.\.(\/)?/g, '_$1');
directory = directory.substr(0, directory.length - 1);
} else {
directory = resourcePath.replace(/\\/g, '/').replace(/\.\.(\/)?/g, '_$1');
}
if (directory.length === 1) {
directory = '';
} else if (directory.length > 1) {
folder = path$1.basename(directory);
}
}
if (loaderContext.resourceQuery && loaderContext.resourceQuery.length > 1) {
query = loaderContext.resourceQuery;
const hashIdx = query.indexOf('#');
if (hashIdx >= 0) {
query = query.substr(0, hashIdx);
}
}
let url = filename;
if (content) {
// Match hash template
url = url
// `hash` and `contenthash` are same in `loader-utils` context
// let's keep `hash` for backward compatibility
.replace(
/\[(?:([^:\]]+):)?(?:hash|contenthash)(?::([a-z]+\d*))?(?::(\d+))?\]/gi,
(all, hashType, digestType, maxLength) =>
getHashDigest$1(content, hashType, digestType, parseInt(maxLength, 10))
)
.replace(/\[emoji(?::(\d+))?\]/gi, (all, length) =>
encodeStringToEmoji(content, parseInt(length, 10))
);
}
url = url
.replace(/\[ext\]/gi, () => ext)
.replace(/\[name\]/gi, () => basename)
.replace(/\[path\]/gi, () => directory)
.replace(/\[folder\]/gi, () => folder)
.replace(/\[query\]/gi, () => query);
if (regExp && loaderContext.resourcePath) {
const match = loaderContext.resourcePath.match(new RegExp(regExp));
match &&
match.forEach((matched, i) => {
url = url.replace(new RegExp('\\[' + i + '\\]', 'ig'), matched);
});
}
if (
typeof loaderContext.options === 'object' &&
typeof loaderContext.options.customInterpolateName === 'function'
) {
url = loaderContext.options.customInterpolateName.call(
loaderContext,
url,
name,
options
);
}
return url;
}
var interpolateName_1 = interpolateName$2;
const getOptions = getOptions_1;
const parseQuery = parseQuery_1;
const stringifyRequest = stringifyRequest_1;
const getRemainingRequest = getRemainingRequest_1;
const getCurrentRequest = getCurrentRequest_1;
const isUrlRequest = isUrlRequest_1;
const urlToRequest = urlToRequest_1;
const parseString = parseString_1;
const getHashDigest = getHashDigest_1;
const interpolateName$1 = interpolateName_1;
lib$2.getOptions = getOptions;
lib$2.parseQuery = parseQuery;
lib$2.stringifyRequest = stringifyRequest;
lib$2.getRemainingRequest = getRemainingRequest;
lib$2.getCurrentRequest = getCurrentRequest;
lib$2.isUrlRequest = isUrlRequest;
lib$2.urlToRequest = urlToRequest;
lib$2.parseString = parseString;
lib$2.getHashDigest = getHashDigest;
lib$2.interpolateName = interpolateName$1;
var interpolateName = lib$2.interpolateName;
var path = path__default;
/**
* @param {string} pattern
* @param {object} options
* @param {string} options.context
* @param {string} options.hashPrefix
* @return {function}
*/
var genericNames = function createGenerator(pattern, options) {
options = options || {};
var context =
options && typeof options.context === "string"
? options.context
: process.cwd();
var hashPrefix =
options && typeof options.hashPrefix === "string" ? options.hashPrefix : "";
/**
* @param {string} localName Usually a class name
* @param {string} filepath Absolute path
* @return {string}
*/
return function generate(localName, filepath) {
var name = pattern.replace(/\[local\]/gi, localName);
var loaderContext = {
resourcePath: filepath
};
var loaderOptions = {
content:
hashPrefix +
path.relative(context, filepath).replace(/\\/g, "/") +
"+" +
localName,
context: context
};
var genericName = interpolateName(loaderContext, name, loaderOptions);
return genericName
.replace(new RegExp("[^a-zA-Z0-9\\-_\u00A0-\uFFFF]", "g"), "-")
.replace(/^((-?[0-9])|--)/, "_$1");
};
};
var unquote$1 = {};
Object.defineProperty(unquote$1, "__esModule", {
value: true
});
unquote$1.default = unquote;
// copied from https://github.com/lakenen/node-unquote
var reg = /['"]/;
function unquote(str) {
if (!str) {
return "";
}
if (reg.test(str.charAt(0))) {
str = str.substr(1);
}
if (reg.test(str.charAt(str.length - 1))) {
str = str.substr(0, str.length - 1);
}
return str;
}
var parser$1 = {};
var lib = {};
Object.defineProperty(lib, "__esModule", {
value: true
});
lib.replaceAll = replaceAll;
var matchConstName = /[$#]?[\w-\.]+/g;
function replaceAll(replacements, text) {
var matches = void 0;
while (matches = matchConstName.exec(text)) {
var replacement = replacements[matches[0]];
if (replacement) {
text = text.slice(0, matches.index) + replacement + text.slice(matchConstName.lastIndex);
matchConstName.lastIndex -= matches[0].length - replacement.length;
}
}
return text;
}
lib.default = function (css, translations) {
css.walkDecls(function (decl) {
return decl.value = replaceAll(translations, decl.value);
});
css.walkAtRules('media', function (atRule) {
return atRule.params = replaceAll(translations, atRule.params);
});
};
Object.defineProperty(parser$1, "__esModule", {
value: true
});
var _icssReplaceSymbols = lib;
var _icssReplaceSymbols2 = _interopRequireDefault$6(_icssReplaceSymbols);
function _interopRequireDefault$6(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
// Copied from https://github.com/css-modules/css-modules-loader-core
const importRegexp = /^:import\((.+)\)$/;
class Parser {
constructor(pathFetcher, trace) {
this.pathFetcher = pathFetcher;
this.plugin = this.plugin.bind(this);
this.exportTokens = {};
this.translations = {};
this.trace = trace;
}
plugin() {
const parser = this;
return {
postcssPlugin: "css-modules-parser",
OnceExit(css) {
return Promise.all(parser.fetchAllImports(css)).then(() => parser.linkImportedSymbols(css)).then(() => parser.extractExports(css));
}
};
}
fetchAllImports(css) {
let imports = [];
css.each(node => {
if (node.type == "rule" && node.selector.match(importRegexp)) {
imports.push(this.fetchImport(node, css.source.input.from, imports.length));
}
});
return imports;
}
linkImportedSymbols(css) {
(0, _icssReplaceSymbols2.default)(css, this.translations);
}
extractExports(css) {
css.each(node => {
if (node.type == "rule" && node.selector == ":export") this.handleExport(node);
});
}
handleExport(exportNode) {
exportNode.each(decl => {
if (decl.type == "decl") {
Object.keys(this.translations).forEach(translation => {
decl.value = decl.value.replace(translation, this.translations[translation]);
});
this.exportTokens[decl.prop] = decl.value;
}
});
exportNode.remove();
}
fetchImport(importNode, relativeTo, depNr) {
let file = importNode.selector.match(importRegexp)[1],
depTrace = this.trace + String.fromCharCode(depNr);
return this.pathFetcher(file, relativeTo, depTrace).then(exports => {
importNode.each(decl => {
if (decl.type == "decl") {
this.translations[decl.prop] = exports[decl.value];
}
});
importNode.remove();
}, err => console.log(err));
}
}
parser$1.default = Parser;
var loader = {};
Object.defineProperty(loader, "__esModule", {
value: true
});
var _postcss$1 = require$$0__default;
var _postcss2$1 = _interopRequireDefault$5(_postcss$1);
var _fs$1 = fs__default;
var _fs2 = _interopRequireDefault$5(_fs$1);
var _path = path__default;
var _path2 = _interopRequireDefault$5(_path);
var _parser$1 = parser$1;
var _parser2$1 = _interopRequireDefault$5(_parser$1);
function _interopRequireDefault$5(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
// Copied from https://github.com/css-modules/css-modules-loader-core
class Core {
constructor(plugins) {
this.plugins = plugins || Core.defaultPlugins;
}
load(sourceString, sourcePath, trace, pathFetcher) {
let parser = new _parser2$1.default(pathFetcher, trace);
return (0, _postcss2$1.default)(this.plugins.concat([parser.plugin()])).process(sourceString, { from: "/" + sourcePath }).then(result => {
return {
injectableSource: result.css,
exportTokens: parser.exportTokens
};
});
}
}
// Sorts dependencies in the following way:
// AAA comes before AA and A
// AB comes after AA and before A
// All Bs come after all As
// This ensures that the files are always returned in the following order:
// - In the order they were required, except
// - After all their dependencies
const traceKeySorter = (a, b) => {
if (a.length < b.length) {
return a < b.substring(0, a.length) ? -1 : 1;
} else if (a.length > b.length) {
return a.substring(0, b.length) <= b ? -1 : 1;
} else {
return a < b ? -1 : 1;
}
};
class FileSystemLoader {
constructor(root, plugins) {
this.root = root;
this.sources = {};
this.traces = {};
this.importNr = 0;
this.core = new Core(plugins);
this.tokensByFile = {};
}
fetch(_newPath, relativeTo, _trace) {
let newPath = _newPath.replace(/^["']|["']$/g, ""),
trace = _trace || String.fromCharCode(this.importNr++);
return new Promise((resolve, reject) => {
let relativeDir = _path2.default.dirname(relativeTo),
rootRelativePath = _path2.default.resolve(relativeDir, newPath),
fileRelativePath = _path2.default.resolve(_path2.default.join(this.root, relativeDir), newPath);
// if the path is not relative or absolute, try to resolve it in node_modules
if (newPath[0] !== "." && newPath[0] !== "/") {
try {
fileRelativePath = require.resolve(newPath);
} catch (e) {
// noop
}
}
const tokens = this.tokensByFile[fileRelativePath];
if (tokens) {
return resolve(tokens);
}
_fs2.default.readFile(fileRelativePath, "utf-8", (err, source) => {
if (err) reject(err);
this.core.load(source, rootRelativePath, trace, this.fetch.bind(this)).then(({ injectableSource, exportTokens }) => {
this.sources[fileRelativePath] = injectableSource;
this.traces[trace] = fileRelativePath;
this.tokensByFile[fileRelativePath] = exportTokens;
resolve(exportTokens);
}, reject);
});
});
}
get finalSource() {
const traces = this.traces;
const sources = this.sources;
let written = new Set();
return Object.keys(traces).sort(traceKeySorter).map(key => {
const filename = traces[key];
if (written.has(filename)) {
return null;
}
written.add(filename);
return sources[filename];
}).join("");
}
}
loader.default = FileSystemLoader;
var generateScopedName$1 = {};
function hash(str) {
var hash = 5381,
i = str.length;
while(i) {
hash = (hash * 33) ^ str.charCodeAt(--i);
}
/* JavaScript does bitwise operations (like XOR, above) on 32-bit signed
* integers. Since we want the results to be always positive, convert the
* signed int to an unsigned by doing an unsigned bitshift. */
return hash >>> 0;
}
var stringHash = hash;
Object.defineProperty(generateScopedName$1, "__esModule", {
value: true
});
generateScopedName$1.default = generateScopedName;
var _stringHash = stringHash;
var _stringHash2 = _interopRequireDefault$4(_stringHash);
function _interopRequireDefault$4(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function generateScopedName(name, filename, css) {
const i = css.indexOf(`.${name}`);
const lineNumber = css.substr(0, i).split(/[\r\n]/).length;
const hash = (0, _stringHash2.default)(css).toString(36).substr(0, 5);
return `_${name}_${hash}_${lineNumber}`;
}
var saveJSON$1 = {};
Object.defineProperty(saveJSON$1, "__esModule", {
value: true
});
saveJSON$1.default = saveJSON;
var _fs = fs__default;
function saveJSON(cssFile, json) {
return new Promise((resolve, reject) => {
(0, _fs.writeFile)(`${cssFile}.json`, JSON.stringify(json), e => e ? reject(e) : resolve(json));
});
}
var behaviours$1 = {};
var src$4 = {exports: {}};
var dist = {exports: {}};
var processor = {exports: {}};
var parser = {exports: {}};
var root$1 = {exports: {}};
var container = {exports: {}};
var node$1 = {exports: {}};
var util = {};
var unesc = {exports: {}};
(function (module, exports) {
exports.__esModule = true;
exports["default"] = unesc;
// Many thanks for this post which made this migration much easier.
// https://mathiasbynens.be/notes/css-escapes
/**
*
* @param {string} str
* @returns {[string, number]|undefined}
*/
function gobbleHex(str) {
var lower = str.toLowerCase();
var hex = '';
var spaceTerminated = false;
for (var i = 0; i < 6 && lower[i] !== undefined; i++) {
var code = lower.charCodeAt(i); // check to see if we are dealing with a valid hex char [a-f|0-9]
var valid = code >= 97 && code <= 102 || code >= 48 && code <= 57; // https://drafts.csswg.org/css-syntax/#consume-escaped-code-point
spaceTerminated = code === 32;
if (!valid) {
break;
}
hex += lower[i];
}
if (hex.length === 0) {
return undefined;
}
var codePoint = parseInt(hex, 16);
var isSurrogate = codePoint >= 0xD800 && codePoint <= 0xDFFF; // Add special case for
// "If this number is zero, or is for a surrogate, or is greater than the maximum allowed code point"
// https://drafts.csswg.org/css-syntax/#maximum-allowed-code-point
if (isSurrogate || codePoint === 0x0000 || codePoint > 0x10FFFF) {
return ["\uFFFD", hex.length + (spaceTerminated ? 1 : 0)];
}
return [String.fromCodePoint(codePoint), hex.length + (spaceTerminated ? 1 : 0)];
}
var CONTAINS_ESCAPE = /\\/;
function unesc(str) {
var needToProcess = CONTAINS_ESCAPE.test(str);
if (!needToProcess) {
return str;
}
var ret = "";
for (var i = 0; i < str.length; i++) {
if (str[i] === "\\") {
var gobbled = gobbleHex(str.slice(i + 1, i + 7));
if (gobbled !== undefined) {
ret += gobbled[0];
i += gobbled[1];
continue;
} // Retain a pair of \\ if double escaped `\\\\`
// https://github.com/postcss/postcss-selector-parser/commit/268c9a7656fb53f543dc620aa5b73a30ec3ff20e
if (str[i + 1] === "\\") {
ret += "\\";
i++;
continue;
} // if \\ is at the end of the string retain it
// https://github.com/postcss/postcss-selector-parser/commit/01a6b346e3612ce1ab20219acc26abdc259ccefb
if (str.length === i + 1) {
ret += str[i];
}
continue;
}
ret += str[i];
}
return ret;
}
module.exports = exports.default;
}(unesc, unesc.exports));
var getProp = {exports: {}};
(function (module, exports) {
exports.__esModule = true;
exports["default"] = getProp;
function getProp(obj) {
for (var _len = arguments.length, props = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
props[_key - 1] = arguments[_key];
}
while (props.length > 0) {
var prop = props.shift();
if (!obj[prop]) {
return undefined;
}
obj = obj[prop];
}
return obj;
}
module.exports = exports.default;
}(getProp, getProp.exports));
var ensureObject = {exports: {}};
(function (module, exports) {
exports.__esModule = true;
exports["default"] = ensureObject;
function ensureObject(obj) {
for (var _len = arguments.length, props = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
props[_key - 1] = arguments[_key];
}
while (props.length > 0) {
var prop = props.shift();
if (!obj[prop]) {
obj[prop] = {};
}
obj = obj[prop];
}
}
module.exports = exports.default;
}(ensureObject, ensureObject.exports));
var stripComments = {exports: {}};
(function (module, exports) {
exports.__esModule = true;
exports["default"] = stripComments;
function stripComments(str) {
var s = "";
var commentStart = str.indexOf("/*");
var lastEnd = 0;
while (commentStart >= 0) {
s = s + str.slice(lastEnd, commentStart);
var commentEnd = str.indexOf("*/", commentStart + 2);
if (commentEnd < 0) {
return s;
}
lastEnd = commentEnd + 2;
commentStart = str.indexOf("/*", lastEnd);
}
s = s + str.slice(lastEnd);
return s;
}
module.exports = exports.default;
}(stripComments, stripComments.exports));
util.__esModule = true;
util.stripComments = util.ensureObject = util.getProp = util.unesc = void 0;
var _unesc = _interopRequireDefault$3(unesc.exports);
util.unesc = _unesc["default"];
var _getProp = _interopRequireDefault$3(getProp.exports);
util.getProp = _getProp["default"];
var _ensureObject = _interopRequireDefault$3(ensureObject.exports);
util.ensureObject = _ensureObject["default"];
var _stripComments = _interopRequireDefault$3(stripComments.exports);
util.stripComments = _stripComments["default"];
function _interopRequireDefault$3(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
(function (module, exports) {
exports.__esModule = true;
exports["default"] = void 0;
var _util = util;
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
var cloneNode = function cloneNode(obj, parent) {
if (typeof obj !== 'object' || obj === null) {
return obj;
}
var cloned = new obj.constructor();
for (var i in obj) {
if (!obj.hasOwnProperty(i)) {
continue;
}
var value = obj[i];
var type = typeof value;
if (i === 'parent' && type === 'object') {
if (parent) {
cloned[i] = parent;
}
} else if (value instanceof Array) {
cloned[i] = value.map(function (j) {
return cloneNode(j, cloned);
});
} else {
cloned[i] = cloneNode(value, cloned);
}
}
return cloned;
};
var Node = /*#__PURE__*/function () {
function Node(opts) {
if (opts === void 0) {
opts = {};
}
Object.assign(this, opts);
this.spaces = this.spaces || {};
this.spaces.before = this.spaces.before || '';
this.spaces.after = this.spaces.after || '';
}
var _proto = Node.prototype;
_proto.remove = function remove() {
if (this.parent) {
this.parent.removeChild(this);
}
this.parent = undefined;
return this;
};
_proto.replaceWith = function replaceWith() {
if (this.parent) {
for (var index in arguments) {
this.parent.insertBefore(this, arguments[index]);
}
this.remove();
}
return this;
};
_proto.next = function next() {
return this.parent.at(this.parent.index(this) + 1);
};
_proto.prev = function prev() {
return this.parent.at(this.parent.index(this) - 1);
};
_proto.clone = function clone(overrides) {
if (overrides === void 0) {
overrides = {};
}
var cloned = cloneNode(this);
for (var name in overrides) {
cloned[name] = overrides[name];
}
return cloned;
}
/**
* Some non-standard syntax doesn't follow normal escaping rules for css.
* This allows non standard syntax to be appended to an existing property
* by specifying the escaped value. By specifying the escaped value,
* illegal characters are allowed to be directly inserted into css output.
* @param {string} name the property to set
* @param {any} value the unescaped value of the property
* @param {string} valueEscaped optional. the escaped value of the property.
*/
;
_proto.appendToPropertyAndEscape = function appendToPropertyAndEscape(name, value, valueEscaped) {
if (!this.raws) {
this.raws = {};
}
var originalValue = this[name];
var originalEscaped = this.raws[name];
this[name] = originalValue + value; // this may trigger a setter that updates raws, so it has to be set first.
if (originalEscaped || valueEscaped !== value) {
this.raws[name] = (originalEscaped || originalValue) + valueEscaped;
} else {
delete this.raws[name]; // delete any escaped value that was created by the setter.
}
}
/**
* Some non-standard syntax doesn't follow normal escaping rules for css.
* This allows the escaped value to be specified directly, allowing illegal
* characters to be directly inserted into css output.
* @param {string} name the property to set
* @param {any} value the unescaped value of the property
* @param {string} valueEscaped the escaped value of the property.
*/
;
_proto.setPropertyAndEscape = function setPropertyAndEscape(name, value, valueEscaped) {
if (!this.raws) {
this.raws = {};
}
this[name] = value; // this may trigger a setter that updates raws, so it has to be set first.
this.raws[name] = valueEscaped;
}
/**
* When you want a value to passed through to CSS directly. This method
* deletes the corresponding raw value causing the stringifier to fallback
* to the unescaped value.
* @param {string} name the property to set.
* @param {any} value The value that is both escaped and unescaped.
*/
;
_proto.setPropertyWithoutEscape = function setPropertyWithoutEscape(name, value) {
this[name] = value; // this may trigger a setter that updates raws, so it has to be set first.
if (this.raws) {
delete this.raws[name];
}
}
/**
*
* @param {number} line The number (starting with 1)
* @param {number} column The column number (starting with 1)
*/
;
_proto.isAtPosition = function isAtPosition(line, column) {
if (this.source && this.source.start && this.source.end) {
if (this.source.start.line > line) {
return false;
}
if (this.source.end.line < line) {
return false;
}
if (this.source.start.line === line && this.source.start.column > column) {
return false;
}
if (this.source.end.line === line && this.source.end.column < column) {
return false;
}
return true;
}
return undefined;
};
_proto.stringifyProperty = function stringifyProperty(name) {
return this.raws && this.raws[name] || this[name];
};
_proto.valueToString = function valueToString() {
return String(this.stringifyProperty("value"));
};
_proto.toString = function toString() {
return [this.rawSpaceBefore, this.valueToString(), this.rawSpaceAfter].join('');
};
_createClass(Node, [{
key: "rawSpaceBefore",
get: function get() {
var rawSpace = this.raws && this.raws.spaces && this.raws.spaces.before;
if (rawSpace === undefined) {
rawSpace = this.spaces && this.spaces.before;
}
return rawSpace || "";
},
set: function set(raw) {
(0, _util.ensureObject)(this, "raws", "spaces");
this.raws.spaces.before = raw;
}
}, {
key: "rawSpaceAfter",
get: function get() {
var rawSpace = this.raws && this.raws.spaces && this.raws.spaces.after;
if (rawSpace === undefined) {
rawSpace = this.spaces.after;
}
return rawSpace || "";
},
set: function set(raw) {
(0, _util.ensureObject)(this, "raws", "spaces");
this.raws.spaces.after = raw;
}
}]);
return Node;
}();
exports["default"] = Node;
module.exports = exports.default;
}(node$1, node$1.exports));
var types = {};
types.__esModule = true;
types.UNIVERSAL = types.ATTRIBUTE = types.CLASS = types.COMBINATOR = types.COMMENT = types.ID = types.NESTING = types.PSEUDO = types.ROOT = types.SELECTOR = types.STRING = types.TAG = void 0;
var TAG = 'tag';
types.TAG = TAG;
var STRING = 'string';
types.STRING = STRING;
var SELECTOR = 'selector';
types.SELECTOR = SELECTOR;
var ROOT = 'root';
types.ROOT = ROOT;
var PSEUDO = 'pseudo';
types.PSEUDO = PSEUDO;
var NESTING = 'nesting';
types.NESTING = NESTING;
var ID = 'id';
types.ID = ID;
var COMMENT = 'comment';
types.COMMENT = COMMENT;
var COMBINATOR = 'combinator';
types.COMBINATOR = COMBINATOR;
var CLASS = 'class';
types.CLASS = CLASS;
var ATTRIBUTE = 'attribute';
types.ATTRIBUTE = ATTRIBUTE;
var UNIVERSAL = 'universal';
types.UNIVERSAL = UNIVERSAL;
(function (module, exports) {
exports.__esModule = true;
exports["default"] = void 0;
var _node = _interopRequireDefault(node$1.exports);
var types$1 = _interopRequireWildcard(types);
function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } it = o[Symbol.iterator](); return it.next.bind(it); }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
var Container = /*#__PURE__*/function (_Node) {
_inheritsLoose(Container, _Node);
function Container(opts) {
var _this;
_this = _Node.call(this, opts) || this;
if (!_this.nodes) {
_this.nodes = [];
}
return _this;
}
var _proto = Container.prototype;
_proto.append = function append(selector) {
selector.parent = this;
this.nodes.push(selector);
return this;
};
_proto.prepend = function prepend(selector) {
selector.parent = this;
this.nodes.unshift(selector);
return this;
};
_proto.at = function at(index) {
return this.nodes[index];
};
_proto.index = function index(child) {
if (typeof child === 'number') {
return child;
}
return this.nodes.indexOf(child);
};
_proto.removeChild = function removeChild(child) {
child = this.index(child);
this.at(child).parent = undefined;
this.nodes.splice(child, 1);
var index;
for (var id in this.indexes) {
index = this.indexes[id];
if (index >= child) {
this.indexes[id] = index - 1;
}
}
return this;
};
_proto.removeAll = function removeAll() {
for (var _iterator = _createForOfIteratorHelperLoose(this.nodes), _step; !(_step = _iterator()).done;) {
var node = _step.value;
node.parent = undefined;
}
this.nodes = [];
return this;
};
_proto.empty = function empty() {
return this.removeAll();
};
_proto.insertAfter = function insertAfter(oldNode, newNode) {
newNode.parent = this;
var oldIndex = this.index(oldNode);
this.nodes.splice(oldIndex + 1, 0, newNode);
newNode.parent = this;
var index;
for (var id in this.indexes) {
index = this.indexes[id];
if (oldIndex <= index) {
this.indexes[id] = index + 1;
}
}
return this;
};
_proto.insertBefore = function insertBefore(oldNode, newNode) {
newNode.parent = this;
var oldIndex = this.index(oldNode);
this.nodes.splice(oldIndex, 0, newNode);
newNode.parent = this;
var index;
for (var id in this.indexes) {
index = this.indexes[id];
if (index <= oldIndex) {
this.indexes[id] = index + 1;
}
}
return this;
};
_proto._findChildAtPosition = function _findChildAtPosition(line, col) {
var found = undefined;
this.each(function (node) {
if (node.atPosition) {
var foundChild = node.atPosition(line, col);
if (foundChild) {
found = foundChild;
return false;
}
} else if (node.isAtPosition(line, col)) {
found = node;
return false;
}
});
return found;
}
/**
* Return the most specific node at the line and column number given.
* The source location is based on the original parsed location, locations aren't
* updated as selector nodes are mutated.
*
* Note that this location is relative to the location of the first character
* of the selector, and not the location of the selector in the overall document
* when used in conjunction with postcss.
*
* If not found, returns undefined.
* @param {number} line The line number of the node to find. (1-based index)
* @param {number} col The column number of the node to find. (1-based index)
*/
;
_proto.atPosition = function atPosition(line, col) {
if (this.isAtPosition(line, col)) {
return this._findChildAtPosition(line, col) || this;
} else {
return undefined;
}
};
_proto._inferEndPosition = function _inferEndPosition() {
if (this.last && this.last.source && this.last.source.end) {
this.source = this.source || {};
this.source.end = this.source.end || {};
Object.assign(this.source.end, this.last.source.end);
}
};
_proto.each = function each(callback) {
if (!this.lastEach) {
this.lastEach = 0;
}
if (!this.indexes) {
this.indexes = {};
}
this.lastEach++;
var id = this.lastEach;
this.indexes[id] = 0;
if (!this.length) {
return undefined;
}
var index, result;
while (this.indexes[id] < this.length) {
index = this.indexes[id];
result = callback(this.at(index), index);
if (result === false) {
break;
}
this.indexes[id] += 1;
}
delete this.indexes[id];
if (result === false) {
return false;
}
};
_proto.walk = function walk(callback) {
return this.each(function (node, i) {
var result = callback(node, i);
if (result !== false && node.length) {
result = node.walk(callback);
}
if (result === false) {
return false;
}
});
};
_proto.walkAttributes = function walkAttributes(callback) {
var _this2 = this;
return this.walk(function (selector) {
if (selector.type === types$1.ATTRIBUTE) {
return callback.call(_this2, selector);
}
});
};
_proto.walkClasses = function walkClasses(callback) {
var _this3 = this;
return this.walk(function (selector) {
if (selector.type === types$1.CLASS) {
return callback.call(_this3, selector);
}
});
};
_proto.walkCombinators = function walkCombinators(callback) {
var _this4 = this;
return this.walk(function (selector) {
if (selector.type === types$1.COMBINATOR) {
return callback.call(_this4, selector);
}
});
};
_proto.walkComments = function walkComments(callback) {
var _this5 = this;
return this.walk(function (selector) {
if (selector.type === types$1.COMMENT) {
return callback.call(_this5, selector);
}
});
};
_proto.walkIds = function walkIds(callback) {
var _this6 = this;
return this.walk(function (selector) {
if (selector.type === types$1.ID) {
return callback.call(_this6, selector);
}
});
};
_proto.walkNesting = function walkNesting(callback) {
var _this7 = this;
return this.walk(function (selector) {
if (selector.type === types$1.NESTING) {
return callback.call(_this7, selector);
}
});
};
_proto.walkPseudos = function walkPseudos(callback) {
var _this8 = this;
return this.walk(function (selector) {
if (selector.type === types$1.PSEUDO) {
return callback.call(_this8, selector);
}
});
};
_proto.walkTags = function walkTags(callback) {
var _this9 = this;
return this.walk(function (selector) {
if (selector.type === types$1.TAG) {
return callback.call(_this9, selector);
}
});
};
_proto.walkUniversals = function walkUniversals(callback) {
var _this10 = this;
return this.walk(function (selector) {
if (selector.type === types$1.UNIVERSAL) {
return callback.call(_this10, selector);
}
});
};
_proto.split = function split(callback) {
var _this11 = this;
var current = [];
return this.reduce(function (memo, node, index) {
var split = callback.call(_this11, node);
current.push(node);
if (split) {
memo.push(current);
current = [];
} else if (index === _this11.length - 1) {
memo.push(current);
}
return memo;
}, []);
};
_proto.map = function map(callback) {
return this.nodes.map(callback);
};
_proto.reduce = function reduce(callback, memo) {
return this.nodes.reduce(callback, memo);
};
_proto.every = function every(callback) {
return this.nodes.every(callback);
};
_proto.some = function some(callback) {
return this.nodes.some(callback);
};
_proto.filter = function filter(callback) {
return this.nodes.filter(callback);
};
_proto.sort = function sort(callback) {
return this.nodes.sort(callback);
};
_proto.toString = function toString() {
return this.map(String).join('');
};
_createClass(Container, [{
key: "first",
get: function get() {
return this.at(0);
}
}, {
key: "last",
get: function get() {
return this.at(this.length - 1);
}
}, {
key: "length",
get: function get() {
return this.nodes.length;
}
}]);
return Container;
}(_node["default"]);
exports["default"] = Container;
module.exports = exports.default;
}(container, container.exports));
(function (module, exports) {
exports.__esModule = true;
exports["default"] = void 0;
var _container = _interopRequireDefault(container.exports);
var _types = types;
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
var Root = /*#__PURE__*/function (_Container) {
_inheritsLoose(Root, _Container);
function Root(opts) {
var _this;
_this = _Container.call(this, opts) || this;
_this.type = _types.ROOT;
return _this;
}
var _proto = Root.prototype;
_proto.toString = function toString() {
var str = this.reduce(function (memo, selector) {
memo.push(String(selector));
return memo;
}, []).join(',');
return this.trailingComma ? str + ',' : str;
};
_proto.error = function error(message, options) {
if (this._error) {
return this._error(message, options);
} else {
return new Error(message);
}
};
_createClass(Root, [{
key: "errorGenerator",
set: function set(handler) {
this._error = handler;
}
}]);
return Root;
}(_container["default"]);
exports["default"] = Root;
module.exports = exports.default;
}(root$1, root$1.exports));
var selector$1 = {exports: {}};
(function (module, exports) {
exports.__esModule = true;
exports["default"] = void 0;
var _container = _interopRequireDefault(container.exports);
var _types = types;
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
var Selector = /*#__PURE__*/function (_Container) {
_inheritsLoose(Selector, _Container);
function Selector(opts) {
var _this;
_this = _Container.call(this, opts) || this;
_this.type = _types.SELECTOR;
return _this;
}
return Selector;
}(_container["default"]);
exports["default"] = Selector;
module.exports = exports.default;
}(selector$1, selector$1.exports));
var className$1 = {exports: {}};
/*! https://mths.be/cssesc v3.0.0 by @mathias */
var object = {};
var hasOwnProperty$1 = object.hasOwnProperty;
var merge = function merge(options, defaults) {
if (!options) {
return defaults;
}
var result = {};
for (var key in defaults) {
// `if (defaults.hasOwnProperty(key) { … }` is not needed here, since
// only recognized option names are used.
result[key] = hasOwnProperty$1.call(options, key) ? options[key] : defaults[key];
}
return result;
};
var regexAnySingleEscape = /[ -,\.\/:-@\[-\^`\{-~]/;
var regexSingleEscape = /[ -,\.\/:-@\[\]\^`\{-~]/;
var regexExcessiveSpaces = /(^|\\+)?(\\[A-F0-9]{1,6})\x20(?![a-fA-F0-9\x20])/g;
// https://mathiasbynens.be/notes/css-escapes#css
var cssesc = function cssesc(string, options) {
options = merge(options, cssesc.options);
if (options.quotes != 'single' && options.quotes != 'double') {
options.quotes = 'single';
}
var quote = options.quotes == 'double' ? '"' : '\'';
var isIdentifier = options.isIdentifier;
var firstChar = string.charAt(0);
var output = '';
var counter = 0;
var length = string.length;
while (counter < length) {
var character = string.charAt(counter++);
var codePoint = character.charCodeAt();
var value = void 0;
// If it’s not a printable ASCII character…
if (codePoint < 0x20 || codePoint > 0x7E) {
if (codePoint >= 0xD800 && codePoint <= 0xDBFF && counter < length) {
// It’s a high surrogate, and there is a next character.
var extra = string.charCodeAt(counter++);
if ((extra & 0xFC00) == 0xDC00) {
// next character is low surrogate
codePoint = ((codePoint & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000;
} else {
// It’s an unmatched surrogate; only append this code unit, in case
// the next code unit is the high surrogate of a surrogate pair.
counter--;
}
}
value = '\\' + codePoint.toString(16).toUpperCase() + ' ';
} else {
if (options.escapeEverything) {
if (regexAnySingleEscape.test(character)) {
value = '\\' + character;
} else {
value = '\\' + codePoint.toString(16).toUpperCase() + ' ';
}
} else if (/[\t\n\f\r\x0B]/.test(character)) {
value = '\\' + codePoint.toString(16).toUpperCase() + ' ';
} else if (character == '\\' || !isIdentifier && (character == '"' && quote == character || character == '\'' && quote == character) || isIdentifier && regexSingleEscape.test(character)) {
value = '\\' + character;
} else {
value = character;
}
}
output += value;
}
if (isIdentifier) {
if (/^-[-\d]/.test(output)) {
output = '\\-' + output.slice(1);
} else if (/\d/.test(firstChar)) {
output = '\\3' + firstChar + ' ' + output.slice(1);
}
}
// Remove spaces after `\HEX` escapes that are not followed by a hex digit,
// since they’re redundant. Note that this is only possible if the escape
// sequence isn’t preceded by an odd number of backslashes.
output = output.replace(regexExcessiveSpaces, function ($0, $1, $2) {
if ($1 && $1.length % 2) {
// It’s not safe to remove the space, so don’t.
return $0;
}
// Strip the space.
return ($1 || '') + $2;
});
if (!isIdentifier && options.wrap) {
return quote + output + quote;
}
return output;
};
// Expose default options (so they can be overridden globally).
cssesc.options = {
'escapeEverything': false,
'isIdentifier': false,
'quotes': 'single',
'wrap': false
};
cssesc.version = '3.0.0';
var cssesc_1 = cssesc;
(function (module, exports) {
exports.__esModule = true;
exports["default"] = void 0;
var _cssesc = _interopRequireDefault(cssesc_1);
var _util = util;
var _node = _interopRequireDefault(node$1.exports);
var _types = types;
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
var ClassName = /*#__PURE__*/function (_Node) {
_inheritsLoose(ClassName, _Node);
function ClassName(opts) {
var _this;
_this = _Node.call(this, opts) || this;
_this.type = _types.CLASS;
_this._constructed = true;
return _this;
}
var _proto = ClassName.prototype;
_proto.valueToString = function valueToString() {
return '.' + _Node.prototype.valueToString.call(this);
};
_createClass(ClassName, [{
key: "value",
get: function get() {
return this._value;
},
set: function set(v) {
if (this._constructed) {
var escaped = (0, _cssesc["default"])(v, {
isIdentifier: true
});
if (escaped !== v) {
(0, _util.ensureObject)(this, "raws");
this.raws.value = escaped;
} else if (this.raws) {
delete this.raws.value;
}
}
this._value = v;
}
}]);
return ClassName;
}(_node["default"]);
exports["default"] = ClassName;
module.exports = exports.default;
}(className$1, className$1.exports));
var comment$2 = {exports: {}};
(function (module, exports) {
exports.__esModule = true;
exports["default"] = void 0;
var _node = _interopRequireDefault(node$1.exports);
var _types = types;
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
var Comment = /*#__PURE__*/function (_Node) {
_inheritsLoose(Comment, _Node);
function Comment(opts) {
var _this;
_this = _Node.call(this, opts) || this;
_this.type = _types.COMMENT;
return _this;
}
return Comment;
}(_node["default"]);
exports["default"] = Comment;
module.exports = exports.default;
}(comment$2, comment$2.exports));
var id$1 = {exports: {}};
(function (module, exports) {
exports.__esModule = true;
exports["default"] = void 0;
var _node = _interopRequireDefault(node$1.exports);
var _types = types;
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
var ID = /*#__PURE__*/function (_Node) {
_inheritsLoose(ID, _Node);
function ID(opts) {
var _this;
_this = _Node.call(this, opts) || this;
_this.type = _types.ID;
return _this;
}
var _proto = ID.prototype;
_proto.valueToString = function valueToString() {
return '#' + _Node.prototype.valueToString.call(this);
};
return ID;
}(_node["default"]);
exports["default"] = ID;
module.exports = exports.default;
}(id$1, id$1.exports));
var tag$1 = {exports: {}};
var namespace = {exports: {}};
(function (module, exports) {
exports.__esModule = true;
exports["default"] = void 0;
var _cssesc = _interopRequireDefault(cssesc_1);
var _util = util;
var _node = _interopRequireDefault(node$1.exports);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
var Namespace = /*#__PURE__*/function (_Node) {
_inheritsLoose(Namespace, _Node);
function Namespace() {
return _Node.apply(this, arguments) || this;
}
var _proto = Namespace.prototype;
_proto.qualifiedName = function qualifiedName(value) {
if (this.namespace) {
return this.namespaceString + "|" + value;
} else {
return value;
}
};
_proto.valueToString = function valueToString() {
return this.qualifiedName(_Node.prototype.valueToString.call(this));
};
_createClass(Namespace, [{
key: "namespace",
get: function get() {
return this._namespace;
},
set: function set(namespace) {
if (namespace === true || namespace === "*" || namespace === "&") {
this._namespace = namespace;
if (this.raws) {
delete this.raws.namespace;
}
return;
}
var escaped = (0, _cssesc["default"])(namespace, {
isIdentifier: true
});
this._namespace = namespace;
if (escaped !== namespace) {
(0, _util.ensureObject)(this, "raws");
this.raws.namespace = escaped;
} else if (this.raws) {
delete this.raws.namespace;
}
}
}, {
key: "ns",
get: function get() {
return this._namespace;
},
set: function set(namespace) {
this.namespace = namespace;
}
}, {
key: "namespaceString",
get: function get() {
if (this.namespace) {
var ns = this.stringifyProperty("namespace");
if (ns === true) {
return '';
} else {
return ns;
}
} else {
return '';
}
}
}]);
return Namespace;
}(_node["default"]);
exports["default"] = Namespace;
module.exports = exports.default;
}(namespace, namespace.exports));
(function (module, exports) {
exports.__esModule = true;
exports["default"] = void 0;
var _namespace = _interopRequireDefault(namespace.exports);
var _types = types;
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
var Tag = /*#__PURE__*/function (_Namespace) {
_inheritsLoose(Tag, _Namespace);
function Tag(opts) {
var _this;
_this = _Namespace.call(this, opts) || this;
_this.type = _types.TAG;
return _this;
}
return Tag;
}(_namespace["default"]);
exports["default"] = Tag;
module.exports = exports.default;
}(tag$1, tag$1.exports));
var string$1 = {exports: {}};
(function (module, exports) {
exports.__esModule = true;
exports["default"] = void 0;
var _node = _interopRequireDefault(node$1.exports);
var _types = types;
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
var String = /*#__PURE__*/function (_Node) {
_inheritsLoose(String, _Node);
function String(opts) {
var _this;
_this = _Node.call(this, opts) || this;
_this.type = _types.STRING;
return _this;
}
return String;
}(_node["default"]);
exports["default"] = String;
module.exports = exports.default;
}(string$1, string$1.exports));
var pseudo$1 = {exports: {}};
(function (module, exports) {
exports.__esModule = true;
exports["default"] = void 0;
var _container = _interopRequireDefault(container.exports);
var _types = types;
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
var Pseudo = /*#__PURE__*/function (_Container) {
_inheritsLoose(Pseudo, _Container);
function Pseudo(opts) {
var _this;
_this = _Container.call(this, opts) || this;
_this.type = _types.PSEUDO;
return _this;
}
var _proto = Pseudo.prototype;
_proto.toString = function toString() {
var params = this.length ? '(' + this.map(String).join(',') + ')' : '';
return [this.rawSpaceBefore, this.stringifyProperty("value"), params, this.rawSpaceAfter].join('');
};
return Pseudo;
}(_container["default"]);
exports["default"] = Pseudo;
module.exports = exports.default;
}(pseudo$1, pseudo$1.exports));
var attribute$1 = {};
/**
* For Node.js, simply re-export the core `util.deprecate` function.
*/
var node = require$$0__default$1.deprecate;
(function (exports) {
exports.__esModule = true;
exports.unescapeValue = unescapeValue;
exports["default"] = void 0;
var _cssesc = _interopRequireDefault(cssesc_1);
var _unesc = _interopRequireDefault(unesc.exports);
var _namespace = _interopRequireDefault(namespace.exports);
var _types = types;
var _CSSESC_QUOTE_OPTIONS;
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
var deprecate = node;
var WRAPPED_IN_QUOTES = /^('|")([^]*)\1$/;
var warnOfDeprecatedValueAssignment = deprecate(function () {}, "Assigning an attribute a value containing characters that might need to be escaped is deprecated. " + "Call attribute.setValue() instead.");
var warnOfDeprecatedQuotedAssignment = deprecate(function () {}, "Assigning attr.quoted is deprecated and has no effect. Assign to attr.quoteMark instead.");
var warnOfDeprecatedConstructor = deprecate(function () {}, "Constructing an Attribute selector with a value without specifying quoteMark is deprecated. Note: The value should be unescaped now.");
function unescapeValue(value) {
var deprecatedUsage = false;
var quoteMark = null;
var unescaped = value;
var m = unescaped.match(WRAPPED_IN_QUOTES);
if (m) {
quoteMark = m[1];
unescaped = m[2];
}
unescaped = (0, _unesc["default"])(unescaped);
if (unescaped !== value) {
deprecatedUsage = true;
}
return {
deprecatedUsage: deprecatedUsage,
unescaped: unescaped,
quoteMark: quoteMark
};
}
function handleDeprecatedContructorOpts(opts) {
if (opts.quoteMark !== undefined) {
return opts;
}
if (opts.value === undefined) {
return opts;
}
warnOfDeprecatedConstructor();
var _unescapeValue = unescapeValue(opts.value),
quoteMark = _unescapeValue.quoteMark,
unescaped = _unescapeValue.unescaped;
if (!opts.raws) {
opts.raws = {};
}
if (opts.raws.value === undefined) {
opts.raws.value = opts.value;
}
opts.value = unescaped;
opts.quoteMark = quoteMark;
return opts;
}
var Attribute = /*#__PURE__*/function (_Namespace) {
_inheritsLoose(Attribute, _Namespace);
function Attribute(opts) {
var _this;
if (opts === void 0) {
opts = {};
}
_this = _Namespace.call(this, handleDeprecatedContructorOpts(opts)) || this;
_this.type = _types.ATTRIBUTE;
_this.raws = _this.raws || {};
Object.defineProperty(_this.raws, 'unquoted', {
get: deprecate(function () {
return _this.value;
}, "attr.raws.unquoted is deprecated. Call attr.value instead."),
set: deprecate(function () {
return _this.value;
}, "Setting attr.raws.unquoted is deprecated and has no effect. attr.value is unescaped by default now.")
});
_this._constructed = true;
return _this;
}
/**
* Returns the Attribute's value quoted such that it would be legal to use
* in the value of a css file. The original value's quotation setting
* used for stringification is left unchanged. See `setValue(value, options)`
* if you want to control the quote settings of a new value for the attribute.
*
* You can also change the quotation used for the current value by setting quoteMark.
*
* Options:
* * quoteMark {'"' | "'" | null} - Use this value to quote the value. If this
* option is not set, the original value for quoteMark will be used. If
* indeterminate, a double quote is used. The legal values are:
* * `null` - the value will be unquoted and characters will be escaped as necessary.
* * `'` - the value will be quoted with a single quote and single quotes are escaped.
* * `"` - the value will be quoted with a double quote and double quotes are escaped.
* * preferCurrentQuoteMark {boolean} - if true, prefer the source quote mark
* over the quoteMark option value.
* * smart {boolean} - if true, will select a quote mark based on the value
* and the other options specified here. See the `smartQuoteMark()`
* method.
**/
var _proto = Attribute.prototype;
_proto.getQuotedValue = function getQuotedValue(options) {
if (options === void 0) {
options = {};
}
var quoteMark = this._determineQuoteMark(options);
var cssescopts = CSSESC_QUOTE_OPTIONS[quoteMark];
var escaped = (0, _cssesc["default"])(this._value, cssescopts);
return escaped;
};
_proto._determineQuoteMark = function _determineQuoteMark(options) {
return options.smart ? this.smartQuoteMark(options) : this.preferredQuoteMark(options);
}
/**
* Set the unescaped value with the specified quotation options. The value
* provided must not include any wrapping quote marks -- those quotes will
* be interpreted as part of the value and escaped accordingly.
*/
;
_proto.setValue = function setValue(value, options) {
if (options === void 0) {
options = {};
}
this._value = value;
this._quoteMark = this._determineQuoteMark(options);
this._syncRawValue();
}
/**
* Intelligently select a quoteMark value based on the value's contents. If
* the value is a legal CSS ident, it will not be quoted. Otherwise a quote
* mark will be picked that minimizes the number of escapes.
*
* If there's no clear winner, the quote mark from these options is used,
* then the source quote mark (this is inverted if `preferCurrentQuoteMark` is
* true). If the quoteMark is unspecified, a double quote is used.
*
* @param options This takes the quoteMark and preferCurrentQuoteMark options
* from the quoteValue method.
*/
;
_proto.smartQuoteMark = function smartQuoteMark(options) {
var v = this.value;
var numSingleQuotes = v.replace(/[^']/g, '').length;
var numDoubleQuotes = v.replace(/[^"]/g, '').length;
if (numSingleQuotes + numDoubleQuotes === 0) {
var escaped = (0, _cssesc["default"])(v, {
isIdentifier: true
});
if (escaped === v) {
return Attribute.NO_QUOTE;
} else {
var pref = this.preferredQuoteMark(options);
if (pref === Attribute.NO_QUOTE) {
// pick a quote mark that isn't none and see if it's smaller
var quote = this.quoteMark || options.quoteMark || Attribute.DOUBLE_QUOTE;
var opts = CSSESC_QUOTE_OPTIONS[quote];
var quoteValue = (0, _cssesc["default"])(v, opts);
if (quoteValue.length < escaped.length) {
return quote;
}
}
return pref;
}
} else if (numDoubleQuotes === numSingleQuotes) {
return this.preferredQuoteMark(options);
} else if (numDoubleQuotes < numSingleQuotes) {
return Attribute.DOUBLE_QUOTE;
} else {
return Attribute.SINGLE_QUOTE;
}
}
/**
* Selects the preferred quote mark based on the options and the current quote mark value.
* If you want the quote mark to depend on the attribute value, call `smartQuoteMark(opts)`
* instead.
*/
;
_proto.preferredQuoteMark = function preferredQuoteMark(options) {
var quoteMark = options.preferCurrentQuoteMark ? this.quoteMark : options.quoteMark;
if (quoteMark === undefined) {
quoteMark = options.preferCurrentQuoteMark ? options.quoteMark : this.quoteMark;
}
if (quoteMark === undefined) {
quoteMark = Attribute.DOUBLE_QUOTE;
}
return quoteMark;
};
_proto._syncRawValue = function _syncRawValue() {
var rawValue = (0, _cssesc["default"])(this._value, CSSESC_QUOTE_OPTIONS[this.quoteMark]);
if (rawValue === this._value) {
if (this.raws) {
delete this.raws.value;
}
} else {
this.raws.value = rawValue;
}
};
_proto._handleEscapes = function _handleEscapes(prop, value) {
if (this._constructed) {
var escaped = (0, _cssesc["default"])(value, {
isIdentifier: true
});
if (escaped !== value) {
this.raws[prop] = escaped;
} else {
delete this.raws[prop];
}
}
};
_proto._spacesFor = function _spacesFor(name) {
var attrSpaces = {
before: '',
after: ''
};
var spaces = this.spaces[name] || {};
var rawSpaces = this.raws.spaces && this.raws.spaces[name] || {};
return Object.assign(attrSpaces, spaces, rawSpaces);
};
_proto._stringFor = function _stringFor(name, spaceName, concat) {
if (spaceName === void 0) {
spaceName = name;
}
if (concat === void 0) {
concat = defaultAttrConcat;
}
var attrSpaces = this._spacesFor(spaceName);
return concat(this.stringifyProperty(name), attrSpaces);
}
/**
* returns the offset of the attribute part specified relative to the
* start of the node of the output string.
*
* * "ns" - alias for "namespace"
* * "namespace" - the namespace if it exists.
* * "attribute" - the attribute name
* * "attributeNS" - the start of the attribute or its namespace
* * "operator" - the match operator of the attribute
* * "value" - The value (string or identifier)
* * "insensitive" - the case insensitivity flag;
* @param part One of the possible values inside an attribute.
* @returns -1 if the name is invalid or the value doesn't exist in this attribute.
*/
;
_proto.offsetOf = function offsetOf(name) {
var count = 1;
var attributeSpaces = this._spacesFor("attribute");
count += attributeSpaces.before.length;
if (name === "namespace" || name === "ns") {
return this.namespace ? count : -1;
}
if (name === "attributeNS") {
return count;
}
count += this.namespaceString.length;
if (this.namespace) {
count += 1;
}
if (name === "attribute") {
return count;
}
count += this.stringifyProperty("attribute").length;
count += attributeSpaces.after.length;
var operatorSpaces = this._spacesFor("operator");
count += operatorSpaces.before.length;
var operator = this.stringifyProperty("operator");
if (name === "operator") {
return operator ? count : -1;
}
count += operator.length;
count += operatorSpaces.after.length;
var valueSpaces = this._spacesFor("value");
count += valueSpaces.before.length;
var value = this.stringifyProperty("value");
if (name === "value") {
return value ? count : -1;
}
count += value.length;
count += valueSpaces.after.length;
var insensitiveSpaces = this._spacesFor("insensitive");
count += insensitiveSpaces.before.length;
if (name === "insensitive") {
return this.insensitive ? count : -1;
}
return -1;
};
_proto.toString = function toString() {
var _this2 = this;
var selector = [this.rawSpaceBefore, '['];
selector.push(this._stringFor('qualifiedAttribute', 'attribute'));
if (this.operator && (this.value || this.value === '')) {
selector.push(this._stringFor('operator'));
selector.push(this._stringFor('value'));
selector.push(this._stringFor('insensitiveFlag', 'insensitive', function (attrValue, attrSpaces) {
if (attrValue.length > 0 && !_this2.quoted && attrSpaces.before.length === 0 && !(_this2.spaces.value && _this2.spaces.value.after)) {
attrSpaces.before = " ";
}
return defaultAttrConcat(attrValue, attrSpaces);
}));
}
selector.push(']');
selector.push(this.rawSpaceAfter);
return selector.join('');
};
_createClass(Attribute, [{
key: "quoted",
get: function get() {
var qm = this.quoteMark;
return qm === "'" || qm === '"';
},
set: function set(value) {
warnOfDeprecatedQuotedAssignment();
}
/**
* returns a single (`'`) or double (`"`) quote character if the value is quoted.
* returns `null` if the value is not quoted.
* returns `undefined` if the quotation state is unknown (this can happen when
* the attribute is constructed without specifying a quote mark.)
*/
}, {
key: "quoteMark",
get: function get() {
return this._quoteMark;
}
/**
* Set the quote mark to be used by this attribute's value.
* If the quote mark changes, the raw (escaped) value at `attr.raws.value` of the attribute
* value is updated accordingly.
*
* @param {"'" | '"' | null} quoteMark The quote mark or `null` if the value should be unquoted.
*/
,
set: function set(quoteMark) {
if (!this._constructed) {
this._quoteMark = quoteMark;
return;
}
if (this._quoteMark !== quoteMark) {
this._quoteMark = quoteMark;
this._syncRawValue();
}
}
}, {
key: "qualifiedAttribute",
get: function get() {
return this.qualifiedName(this.raws.attribute || this.attribute);
}
}, {
key: "insensitiveFlag",
get: function get() {
return this.insensitive ? 'i' : '';
}
}, {
key: "value",
get: function get() {
return this._value;
}
/**
* Before 3.0, the value had to be set to an escaped value including any wrapped
* quote marks. In 3.0, the semantics of `Attribute.value` changed so that the value
* is unescaped during parsing and any quote marks are removed.
*
* Because the ambiguity of this semantic change, if you set `attr.value = newValue`,
* a deprecation warning is raised when the new value contains any characters that would
* require escaping (including if it contains wrapped quotes).
*
* Instead, you should call `attr.setValue(newValue, opts)` and pass options that describe
* how the new value is quoted.
*/
,
set: function set(v) {
if (this._constructed) {
var _unescapeValue2 = unescapeValue(v),
deprecatedUsage = _unescapeValue2.deprecatedUsage,
unescaped = _unescapeValue2.unescaped,
quoteMark = _unescapeValue2.quoteMark;
if (deprecatedUsage) {
warnOfDeprecatedValueAssignment();
}
if (unescaped === this._value && quoteMark === this._quoteMark) {
return;
}
this._value = unescaped;
this._quoteMark = quoteMark;
this._syncRawValue();
} else {
this._value = v;
}
}
}, {
key: "attribute",
get: function get() {
return this._attribute;
},
set: function set(name) {
this._handleEscapes("attribute", name);
this._attribute = name;
}
}]);
return Attribute;
}(_namespace["default"]);
exports["default"] = Attribute;
Attribute.NO_QUOTE = null;
Attribute.SINGLE_QUOTE = "'";
Attribute.DOUBLE_QUOTE = '"';
var CSSESC_QUOTE_OPTIONS = (_CSSESC_QUOTE_OPTIONS = {
"'": {
quotes: 'single',
wrap: true
},
'"': {
quotes: 'double',
wrap: true
}
}, _CSSESC_QUOTE_OPTIONS[null] = {
isIdentifier: true
}, _CSSESC_QUOTE_OPTIONS);
function defaultAttrConcat(attrValue, attrSpaces) {
return "" + attrSpaces.before + attrValue + attrSpaces.after;
}
}(attribute$1));
var universal$1 = {exports: {}};
(function (module, exports) {
exports.__esModule = true;
exports["default"] = void 0;
var _namespace = _interopRequireDefault(namespace.exports);
var _types = types;
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
var Universal = /*#__PURE__*/function (_Namespace) {
_inheritsLoose(Universal, _Namespace);
function Universal(opts) {
var _this;
_this = _Namespace.call(this, opts) || this;
_this.type = _types.UNIVERSAL;
_this.value = '*';
return _this;
}
return Universal;
}(_namespace["default"]);
exports["default"] = Universal;
module.exports = exports.default;
}(universal$1, universal$1.exports));
var combinator$2 = {exports: {}};
(function (module, exports) {
exports.__esModule = true;
exports["default"] = void 0;
var _node = _interopRequireDefault(node$1.exports);
var _types = types;
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
var Combinator = /*#__PURE__*/function (_Node) {
_inheritsLoose(Combinator, _Node);
function Combinator(opts) {
var _this;
_this = _Node.call(this, opts) || this;
_this.type = _types.COMBINATOR;
return _this;
}
return Combinator;
}(_node["default"]);
exports["default"] = Combinator;
module.exports = exports.default;
}(combinator$2, combinator$2.exports));
var nesting$1 = {exports: {}};
(function (module, exports) {
exports.__esModule = true;
exports["default"] = void 0;
var _node = _interopRequireDefault(node$1.exports);
var _types = types;
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
var Nesting = /*#__PURE__*/function (_Node) {
_inheritsLoose(Nesting, _Node);
function Nesting(opts) {
var _this;
_this = _Node.call(this, opts) || this;
_this.type = _types.NESTING;
_this.value = '&';
return _this;
}
return Nesting;
}(_node["default"]);
exports["default"] = Nesting;
module.exports = exports.default;
}(nesting$1, nesting$1.exports));
var sortAscending = {exports: {}};
(function (module, exports) {
exports.__esModule = true;
exports["default"] = sortAscending;
function sortAscending(list) {
return list.sort(function (a, b) {
return a - b;
});
}
module.exports = exports.default;
}(sortAscending, sortAscending.exports));
var tokenize = {};
var tokenTypes = {};
tokenTypes.__esModule = true;
tokenTypes.combinator = tokenTypes.word = tokenTypes.comment = tokenTypes.str = tokenTypes.tab = tokenTypes.newline = tokenTypes.feed = tokenTypes.cr = tokenTypes.backslash = tokenTypes.bang = tokenTypes.slash = tokenTypes.doubleQuote = tokenTypes.singleQuote = tokenTypes.space = tokenTypes.greaterThan = tokenTypes.pipe = tokenTypes.equals = tokenTypes.plus = tokenTypes.caret = tokenTypes.tilde = tokenTypes.dollar = tokenTypes.closeSquare = tokenTypes.openSquare = tokenTypes.closeParenthesis = tokenTypes.openParenthesis = tokenTypes.semicolon = tokenTypes.colon = tokenTypes.comma = tokenTypes.at = tokenTypes.asterisk = tokenTypes.ampersand = void 0;
var ampersand = 38; // `&`.charCodeAt(0);
tokenTypes.ampersand = ampersand;
var asterisk = 42; // `*`.charCodeAt(0);
tokenTypes.asterisk = asterisk;
var at = 64; // `@`.charCodeAt(0);
tokenTypes.at = at;
var comma = 44; // `,`.charCodeAt(0);
tokenTypes.comma = comma;
var colon = 58; // `:`.charCodeAt(0);
tokenTypes.colon = colon;
var semicolon = 59; // `;`.charCodeAt(0);
tokenTypes.semicolon = semicolon;
var openParenthesis = 40; // `(`.charCodeAt(0);
tokenTypes.openParenthesis = openParenthesis;
var closeParenthesis = 41; // `)`.charCodeAt(0);
tokenTypes.closeParenthesis = closeParenthesis;
var openSquare = 91; // `[`.charCodeAt(0);
tokenTypes.openSquare = openSquare;
var closeSquare = 93; // `]`.charCodeAt(0);
tokenTypes.closeSquare = closeSquare;
var dollar = 36; // `$`.charCodeAt(0);
tokenTypes.dollar = dollar;
var tilde = 126; // `~`.charCodeAt(0);
tokenTypes.tilde = tilde;
var caret = 94; // `^`.charCodeAt(0);
tokenTypes.caret = caret;
var plus = 43; // `+`.charCodeAt(0);
tokenTypes.plus = plus;
var equals = 61; // `=`.charCodeAt(0);
tokenTypes.equals = equals;
var pipe = 124; // `|`.charCodeAt(0);
tokenTypes.pipe = pipe;
var greaterThan = 62; // `>`.charCodeAt(0);
tokenTypes.greaterThan = greaterThan;
var space = 32; // ` `.charCodeAt(0);
tokenTypes.space = space;
var singleQuote = 39; // `'`.charCodeAt(0);
tokenTypes.singleQuote = singleQuote;
var doubleQuote = 34; // `"`.charCodeAt(0);
tokenTypes.doubleQuote = doubleQuote;
var slash = 47; // `/`.charCodeAt(0);
tokenTypes.slash = slash;
var bang = 33; // `!`.charCodeAt(0);
tokenTypes.bang = bang;
var backslash = 92; // '\\'.charCodeAt(0);
tokenTypes.backslash = backslash;
var cr = 13; // '\r'.charCodeAt(0);
tokenTypes.cr = cr;
var feed = 12; // '\f'.charCodeAt(0);
tokenTypes.feed = feed;
var newline = 10; // '\n'.charCodeAt(0);
tokenTypes.newline = newline;
var tab = 9; // '\t'.charCodeAt(0);
// Expose aliases primarily for readability.
tokenTypes.tab = tab;
var str = singleQuote; // No good single character representation!
tokenTypes.str = str;
var comment$1 = -1;
tokenTypes.comment = comment$1;
var word = -2;
tokenTypes.word = word;
var combinator$1 = -3;
tokenTypes.combinator = combinator$1;
(function (exports) {
exports.__esModule = true;
exports["default"] = tokenize;
exports.FIELDS = void 0;
var t = _interopRequireWildcard(tokenTypes);
var _unescapable, _wordDelimiters;
function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
var unescapable = (_unescapable = {}, _unescapable[t.tab] = true, _unescapable[t.newline] = true, _unescapable[t.cr] = true, _unescapable[t.feed] = true, _unescapable);
var wordDelimiters = (_wordDelimiters = {}, _wordDelimiters[t.space] = true, _wordDelimiters[t.tab] = true, _wordDelimiters[t.newline] = true, _wordDelimiters[t.cr] = true, _wordDelimiters[t.feed] = true, _wordDelimiters[t.ampersand] = true, _wordDelimiters[t.asterisk] = true, _wordDelimiters[t.bang] = true, _wordDelimiters[t.comma] = true, _wordDelimiters[t.colon] = true, _wordDelimiters[t.semicolon] = true, _wordDelimiters[t.openParenthesis] = true, _wordDelimiters[t.closeParenthesis] = true, _wordDelimiters[t.openSquare] = true, _wordDelimiters[t.closeSquare] = true, _wordDelimiters[t.singleQuote] = true, _wordDelimiters[t.doubleQuote] = true, _wordDelimiters[t.plus] = true, _wordDelimiters[t.pipe] = true, _wordDelimiters[t.tilde] = true, _wordDelimiters[t.greaterThan] = true, _wordDelimiters[t.equals] = true, _wordDelimiters[t.dollar] = true, _wordDelimiters[t.caret] = true, _wordDelimiters[t.slash] = true, _wordDelimiters);
var hex = {};
var hexChars = "0123456789abcdefABCDEF";
for (var i = 0; i < hexChars.length; i++) {
hex[hexChars.charCodeAt(i)] = true;
}
/**
* Returns the last index of the bar css word
* @param {string} css The string in which the word begins
* @param {number} start The index into the string where word's first letter occurs
*/
function consumeWord(css, start) {
var next = start;
var code;
do {
code = css.charCodeAt(next);
if (wordDelimiters[code]) {
return next - 1;
} else if (code === t.backslash) {
next = consumeEscape(css, next) + 1;
} else {
// All other characters are part of the word
next++;
}
} while (next < css.length);
return next - 1;
}
/**
* Returns the last index of the escape sequence
* @param {string} css The string in which the sequence begins
* @param {number} start The index into the string where escape character (`\`) occurs.
*/
function consumeEscape(css, start) {
var next = start;
var code = css.charCodeAt(next + 1);
if (unescapable[code]) ; else if (hex[code]) {
var hexDigits = 0; // consume up to 6 hex chars
do {
next++;
hexDigits++;
code = css.charCodeAt(next + 1);
} while (hex[code] && hexDigits < 6); // if fewer than 6 hex chars, a trailing space ends the escape
if (hexDigits < 6 && code === t.space) {
next++;
}
} else {
// the next char is part of the current word
next++;
}
return next;
}
var FIELDS = {
TYPE: 0,
START_LINE: 1,
START_COL: 2,
END_LINE: 3,
END_COL: 4,
START_POS: 5,
END_POS: 6
};
exports.FIELDS = FIELDS;
function tokenize(input) {
var tokens = [];
var css = input.css.valueOf();
var _css = css,
length = _css.length;
var offset = -1;
var line = 1;
var start = 0;
var end = 0;
var code, content, endColumn, endLine, escaped, escapePos, last, lines, next, nextLine, nextOffset, quote, tokenType;
function unclosed(what, fix) {
if (input.safe) {
// fyi: this is never set to true.
css += fix;
next = css.length - 1;
} else {
throw input.error('Unclosed ' + what, line, start - offset, start);
}
}
while (start < length) {
code = css.charCodeAt(start);
if (code === t.newline) {
offset = start;
line += 1;
}
switch (code) {
case t.space:
case t.tab:
case t.newline:
case t.cr:
case t.feed:
next = start;
do {
next += 1;
code = css.charCodeAt(next);
if (code === t.newline) {
offset = next;
line += 1;
}
} while (code === t.space || code === t.newline || code === t.tab || code === t.cr || code === t.feed);
tokenType = t.space;
endLine = line;
endColumn = next - offset - 1;
end = next;
break;
case t.plus:
case t.greaterThan:
case t.tilde:
case t.pipe:
next = start;
do {
next += 1;
code = css.charCodeAt(next);
} while (code === t.plus || code === t.greaterThan || code === t.tilde || code === t.pipe);
tokenType = t.combinator;
endLine = line;
endColumn = start - offset;
end = next;
break;
// Consume these characters as single tokens.
case t.asterisk:
case t.ampersand:
case t.bang:
case t.comma:
case t.equals:
case t.dollar:
case t.caret:
case t.openSquare:
case t.closeSquare:
case t.colon:
case t.semicolon:
case t.openParenthesis:
case t.closeParenthesis:
next = start;
tokenType = code;
endLine = line;
endColumn = start - offset;
end = next + 1;
break;
case t.singleQuote:
case t.doubleQuote:
quote = code === t.singleQuote ? "'" : '"';
next = start;
do {
escaped = false;
next = css.indexOf(quote, next + 1);
if (next === -1) {
unclosed('quote', quote);
}
escapePos = next;
while (css.charCodeAt(escapePos - 1) === t.backslash) {
escapePos -= 1;
escaped = !escaped;
}
} while (escaped);
tokenType = t.str;
endLine = line;
endColumn = start - offset;
end = next + 1;
break;
default:
if (code === t.slash && css.charCodeAt(start + 1) === t.asterisk) {
next = css.indexOf('*/', start + 2) + 1;
if (next === 0) {
unclosed('comment', '*/');
}
content = css.slice(start, next + 1);
lines = content.split('\n');
last = lines.length - 1;
if (last > 0) {
nextLine = line + last;
nextOffset = next - lines[last].length;
} else {
nextLine = line;
nextOffset = offset;
}
tokenType = t.comment;
line = nextLine;
endLine = nextLine;
endColumn = next - nextOffset;
} else if (code === t.slash) {
next = start;
tokenType = code;
endLine = line;
endColumn = start - offset;
end = next + 1;
} else {
next = consumeWord(css, start);
tokenType = t.word;
endLine = line;
endColumn = next - offset;
}
end = next + 1;
break;
} // Ensure that the token structure remains consistent
tokens.push([tokenType, // [0] Token type
line, // [1] Starting line
start - offset, // [2] Starting column
endLine, // [3] Ending line
endColumn, // [4] Ending column
start, // [5] Start position / Source index
end // [6] End position
]); // Reset offset for the next token
if (nextOffset) {
offset = nextOffset;
nextOffset = null;
}
start = end;
}
return tokens;
}
}(tokenize));
(function (module, exports) {
exports.__esModule = true;
exports["default"] = void 0;
var _root = _interopRequireDefault(root$1.exports);
var _selector = _interopRequireDefault(selector$1.exports);
var _className = _interopRequireDefault(className$1.exports);
var _comment = _interopRequireDefault(comment$2.exports);
var _id = _interopRequireDefault(id$1.exports);
var _tag = _interopRequireDefault(tag$1.exports);
var _string = _interopRequireDefault(string$1.exports);
var _pseudo = _interopRequireDefault(pseudo$1.exports);
var _attribute = _interopRequireWildcard(attribute$1);
var _universal = _interopRequireDefault(universal$1.exports);
var _combinator = _interopRequireDefault(combinator$2.exports);
var _nesting = _interopRequireDefault(nesting$1.exports);
var _sortAscending = _interopRequireDefault(sortAscending.exports);
var _tokenize = _interopRequireWildcard(tokenize);
var tokens = _interopRequireWildcard(tokenTypes);
var types$1 = _interopRequireWildcard(types);
var _util = util;
var _WHITESPACE_TOKENS, _Object$assign;
function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
var WHITESPACE_TOKENS = (_WHITESPACE_TOKENS = {}, _WHITESPACE_TOKENS[tokens.space] = true, _WHITESPACE_TOKENS[tokens.cr] = true, _WHITESPACE_TOKENS[tokens.feed] = true, _WHITESPACE_TOKENS[tokens.newline] = true, _WHITESPACE_TOKENS[tokens.tab] = true, _WHITESPACE_TOKENS);
var WHITESPACE_EQUIV_TOKENS = Object.assign({}, WHITESPACE_TOKENS, (_Object$assign = {}, _Object$assign[tokens.comment] = true, _Object$assign));
function tokenStart(token) {
return {
line: token[_tokenize.FIELDS.START_LINE],
column: token[_tokenize.FIELDS.START_COL]
};
}
function tokenEnd(token) {
return {
line: token[_tokenize.FIELDS.END_LINE],
column: token[_tokenize.FIELDS.END_COL]
};
}
function getSource(startLine, startColumn, endLine, endColumn) {
return {
start: {
line: startLine,
column: startColumn
},
end: {
line: endLine,
column: endColumn
}
};
}
function getTokenSource(token) {
return getSource(token[_tokenize.FIELDS.START_LINE], token[_tokenize.FIELDS.START_COL], token[_tokenize.FIELDS.END_LINE], token[_tokenize.FIELDS.END_COL]);
}
function getTokenSourceSpan(startToken, endToken) {
if (!startToken) {
return undefined;
}
return getSource(startToken[_tokenize.FIELDS.START_LINE], startToken[_tokenize.FIELDS.START_COL], endToken[_tokenize.FIELDS.END_LINE], endToken[_tokenize.FIELDS.END_COL]);
}
function unescapeProp(node, prop) {
var value = node[prop];
if (typeof value !== "string") {
return;
}
if (value.indexOf("\\") !== -1) {
(0, _util.ensureObject)(node, 'raws');
node[prop] = (0, _util.unesc)(value);
if (node.raws[prop] === undefined) {
node.raws[prop] = value;
}
}
return node;
}
function indexesOf(array, item) {
var i = -1;
var indexes = [];
while ((i = array.indexOf(item, i + 1)) !== -1) {
indexes.push(i);
}
return indexes;
}
function uniqs() {
var list = Array.prototype.concat.apply([], arguments);
return list.filter(function (item, i) {
return i === list.indexOf(item);
});
}
var Parser = /*#__PURE__*/function () {
function Parser(rule, options) {
if (options === void 0) {
options = {};
}
this.rule = rule;
this.options = Object.assign({
lossy: false,
safe: false
}, options);
this.position = 0;
this.css = typeof this.rule === 'string' ? this.rule : this.rule.selector;
this.tokens = (0, _tokenize["default"])({
css: this.css,
error: this._errorGenerator(),
safe: this.options.safe
});
var rootSource = getTokenSourceSpan(this.tokens[0], this.tokens[this.tokens.length - 1]);
this.root = new _root["default"]({
source: rootSource
});
this.root.errorGenerator = this._errorGenerator();
var selector = new _selector["default"]({
source: {
start: {
line: 1,
column: 1
}
}
});
this.root.append(selector);
this.current = selector;
this.loop();
}
var _proto = Parser.prototype;
_proto._errorGenerator = function _errorGenerator() {
var _this = this;
return function (message, errorOptions) {
if (typeof _this.rule === 'string') {
return new Error(message);
}
return _this.rule.error(message, errorOptions);
};
};
_proto.attribute = function attribute() {
var attr = [];
var startingToken = this.currToken;
this.position++;
while (this.position < this.tokens.length && this.currToken[_tokenize.FIELDS.TYPE] !== tokens.closeSquare) {
attr.push(this.currToken);
this.position++;
}
if (this.currToken[_tokenize.FIELDS.TYPE] !== tokens.closeSquare) {
return this.expected('closing square bracket', this.currToken[_tokenize.FIELDS.START_POS]);
}
var len = attr.length;
var node = {
source: getSource(startingToken[1], startingToken[2], this.currToken[3], this.currToken[4]),
sourceIndex: startingToken[_tokenize.FIELDS.START_POS]
};
if (len === 1 && !~[tokens.word].indexOf(attr[0][_tokenize.FIELDS.TYPE])) {
return this.expected('attribute', attr[0][_tokenize.FIELDS.START_POS]);
}
var pos = 0;
var spaceBefore = '';
var commentBefore = '';
var lastAdded = null;
var spaceAfterMeaningfulToken = false;
while (pos < len) {
var token = attr[pos];
var content = this.content(token);
var next = attr[pos + 1];
switch (token[_tokenize.FIELDS.TYPE]) {
case tokens.space:
// if (
// len === 1 ||
// pos === 0 && this.content(next) === '|'
// ) {
// return this.expected('attribute', token[TOKEN.START_POS], content);
// }
spaceAfterMeaningfulToken = true;
if (this.options.lossy) {
break;
}
if (lastAdded) {
(0, _util.ensureObject)(node, 'spaces', lastAdded);
var prevContent = node.spaces[lastAdded].after || '';
node.spaces[lastAdded].after = prevContent + content;
var existingComment = (0, _util.getProp)(node, 'raws', 'spaces', lastAdded, 'after') || null;
if (existingComment) {
node.raws.spaces[lastAdded].after = existingComment + content;
}
} else {
spaceBefore = spaceBefore + content;
commentBefore = commentBefore + content;
}
break;
case tokens.asterisk:
if (next[_tokenize.FIELDS.TYPE] === tokens.equals) {
node.operator = content;
lastAdded = 'operator';
} else if ((!node.namespace || lastAdded === "namespace" && !spaceAfterMeaningfulToken) && next) {
if (spaceBefore) {
(0, _util.ensureObject)(node, 'spaces', 'attribute');
node.spaces.attribute.before = spaceBefore;
spaceBefore = '';
}
if (commentBefore) {
(0, _util.ensureObject)(node, 'raws', 'spaces', 'attribute');
node.raws.spaces.attribute.before = spaceBefore;
commentBefore = '';
}
node.namespace = (node.namespace || "") + content;
var rawValue = (0, _util.getProp)(node, 'raws', 'namespace') || null;
if (rawValue) {
node.raws.namespace += content;
}
lastAdded = 'namespace';
}
spaceAfterMeaningfulToken = false;
break;
case tokens.dollar:
if (lastAdded === "value") {
var oldRawValue = (0, _util.getProp)(node, 'raws', 'value');
node.value += "$";
if (oldRawValue) {
node.raws.value = oldRawValue + "$";
}
break;
}
// Falls through
case tokens.caret:
if (next[_tokenize.FIELDS.TYPE] === tokens.equals) {
node.operator = content;
lastAdded = 'operator';
}
spaceAfterMeaningfulToken = false;
break;
case tokens.combinator:
if (content === '~' && next[_tokenize.FIELDS.TYPE] === tokens.equals) {
node.operator = content;
lastAdded = 'operator';
}
if (content !== '|') {
spaceAfterMeaningfulToken = false;
break;
}
if (next[_tokenize.FIELDS.TYPE] === tokens.equals) {
node.operator = content;
lastAdded = 'operator';
} else if (!node.namespace && !node.attribute) {
node.namespace = true;
}
spaceAfterMeaningfulToken = false;
break;
case tokens.word:
if (next && this.content(next) === '|' && attr[pos + 2] && attr[pos + 2][_tokenize.FIELDS.TYPE] !== tokens.equals && // this look-ahead probably fails with comment nodes involved.
!node.operator && !node.namespace) {
node.namespace = content;
lastAdded = 'namespace';
} else if (!node.attribute || lastAdded === "attribute" && !spaceAfterMeaningfulToken) {
if (spaceBefore) {
(0, _util.ensureObject)(node, 'spaces', 'attribute');
node.spaces.attribute.before = spaceBefore;
spaceBefore = '';
}
if (commentBefore) {
(0, _util.ensureObject)(node, 'raws', 'spaces', 'attribute');
node.raws.spaces.attribute.before = commentBefore;
commentBefore = '';
}
node.attribute = (node.attribute || "") + content;
var _rawValue = (0, _util.getProp)(node, 'raws', 'attribute') || null;
if (_rawValue) {
node.raws.attribute += content;
}
lastAdded = 'attribute';
} else if (!node.value && node.value !== "" || lastAdded === "value" && !spaceAfterMeaningfulToken) {
var _unescaped = (0, _util.unesc)(content);
var _oldRawValue = (0, _util.getProp)(node, 'raws', 'value') || '';
var oldValue = node.value || '';
node.value = oldValue + _unescaped;
node.quoteMark = null;
if (_unescaped !== content || _oldRawValue) {
(0, _util.ensureObject)(node, 'raws');
node.raws.value = (_oldRawValue || oldValue) + content;
}
lastAdded = 'value';
} else {
var insensitive = content === 'i' || content === "I";
if ((node.value || node.value === '') && (node.quoteMark || spaceAfterMeaningfulToken)) {
node.insensitive = insensitive;
if (!insensitive || content === "I") {
(0, _util.ensureObject)(node, 'raws');
node.raws.insensitiveFlag = content;
}
lastAdded = 'insensitive';
if (spaceBefore) {
(0, _util.ensureObject)(node, 'spaces', 'insensitive');
node.spaces.insensitive.before = spaceBefore;
spaceBefore = '';
}
if (commentBefore) {
(0, _util.ensureObject)(node, 'raws', 'spaces', 'insensitive');
node.raws.spaces.insensitive.before = commentBefore;
commentBefore = '';
}
} else if (node.value || node.value === '') {
lastAdded = 'value';
node.value += content;
if (node.raws.value) {
node.raws.value += content;
}
}
}
spaceAfterMeaningfulToken = false;
break;
case tokens.str:
if (!node.attribute || !node.operator) {
return this.error("Expected an attribute followed by an operator preceding the string.", {
index: token[_tokenize.FIELDS.START_POS]
});
}
var _unescapeValue = (0, _attribute.unescapeValue)(content),
unescaped = _unescapeValue.unescaped,
quoteMark = _unescapeValue.quoteMark;
node.value = unescaped;
node.quoteMark = quoteMark;
lastAdded = 'value';
(0, _util.ensureObject)(node, 'raws');
node.raws.value = content;
spaceAfterMeaningfulToken = false;
break;
case tokens.equals:
if (!node.attribute) {
return this.expected('attribute', token[_tokenize.FIELDS.START_POS], content);
}
if (node.value) {
return this.error('Unexpected "=" found; an operator was already defined.', {
index: token[_tokenize.FIELDS.START_POS]
});
}
node.operator = node.operator ? node.operator + content : content;
lastAdded = 'operator';
spaceAfterMeaningfulToken = false;
break;
case tokens.comment:
if (lastAdded) {
if (spaceAfterMeaningfulToken || next && next[_tokenize.FIELDS.TYPE] === tokens.space || lastAdded === 'insensitive') {
var lastComment = (0, _util.getProp)(node, 'spaces', lastAdded, 'after') || '';
var rawLastComment = (0, _util.getProp)(node, 'raws', 'spaces', lastAdded, 'after') || lastComment;
(0, _util.ensureObject)(node, 'raws', 'spaces', lastAdded);
node.raws.spaces[lastAdded].after = rawLastComment + content;
} else {
var lastValue = node[lastAdded] || '';
var rawLastValue = (0, _util.getProp)(node, 'raws', lastAdded) || lastValue;
(0, _util.ensureObject)(node, 'raws');
node.raws[lastAdded] = rawLastValue + content;
}
} else {
commentBefore = commentBefore + content;
}
break;
default:
return this.error("Unexpected \"" + content + "\" found.", {
index: token[_tokenize.FIELDS.START_POS]
});
}
pos++;
}
unescapeProp(node, "attribute");
unescapeProp(node, "namespace");
this.newNode(new _attribute["default"](node));
this.position++;
}
/**
* return a node containing meaningless garbage up to (but not including) the specified token position.
* if the token position is negative, all remaining tokens are consumed.
*
* This returns an array containing a single string node if all whitespace,
* otherwise an array of comment nodes with space before and after.
*
* These tokens are not added to the current selector, the caller can add them or use them to amend
* a previous node's space metadata.
*
* In lossy mode, this returns only comments.
*/
;
_proto.parseWhitespaceEquivalentTokens = function parseWhitespaceEquivalentTokens(stopPosition) {
if (stopPosition < 0) {
stopPosition = this.tokens.length;
}
var startPosition = this.position;
var nodes = [];
var space = "";
var lastComment = undefined;
do {
if (WHITESPACE_TOKENS[this.currToken[_tokenize.FIELDS.TYPE]]) {
if (!this.options.lossy) {
space += this.content();
}
} else if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.comment) {
var spaces = {};
if (space) {
spaces.before = space;
space = "";
}
lastComment = new _comment["default"]({
value: this.content(),
source: getTokenSource(this.currToken),
sourceIndex: this.currToken[_tokenize.FIELDS.START_POS],
spaces: spaces
});
nodes.push(lastComment);
}
} while (++this.position < stopPosition);
if (space) {
if (lastComment) {
lastComment.spaces.after = space;
} else if (!this.options.lossy) {
var firstToken = this.tokens[startPosition];
var lastToken = this.tokens[this.position - 1];
nodes.push(new _string["default"]({
value: '',
source: getSource(firstToken[_tokenize.FIELDS.START_LINE], firstToken[_tokenize.FIELDS.START_COL], lastToken[_tokenize.FIELDS.END_LINE], lastToken[_tokenize.FIELDS.END_COL]),
sourceIndex: firstToken[_tokenize.FIELDS.START_POS],
spaces: {
before: space,
after: ''
}
}));
}
}
return nodes;
}
/**
*
* @param {*} nodes
*/
;
_proto.convertWhitespaceNodesToSpace = function convertWhitespaceNodesToSpace(nodes, requiredSpace) {
var _this2 = this;
if (requiredSpace === void 0) {
requiredSpace = false;
}
var space = "";
var rawSpace = "";
nodes.forEach(function (n) {
var spaceBefore = _this2.lossySpace(n.spaces.before, requiredSpace);
var rawSpaceBefore = _this2.lossySpace(n.rawSpaceBefore, requiredSpace);
space += spaceBefore + _this2.lossySpace(n.spaces.after, requiredSpace && spaceBefore.length === 0);
rawSpace += spaceBefore + n.value + _this2.lossySpace(n.rawSpaceAfter, requiredSpace && rawSpaceBefore.length === 0);
});
if (rawSpace === space) {
rawSpace = undefined;
}
var result = {
space: space,
rawSpace: rawSpace
};
return result;
};
_proto.isNamedCombinator = function isNamedCombinator(position) {
if (position === void 0) {
position = this.position;
}
return this.tokens[position + 0] && this.tokens[position + 0][_tokenize.FIELDS.TYPE] === tokens.slash && this.tokens[position + 1] && this.tokens[position + 1][_tokenize.FIELDS.TYPE] === tokens.word && this.tokens[position + 2] && this.tokens[position + 2][_tokenize.FIELDS.TYPE] === tokens.slash;
};
_proto.namedCombinator = function namedCombinator() {
if (this.isNamedCombinator()) {
var nameRaw = this.content(this.tokens[this.position + 1]);
var name = (0, _util.unesc)(nameRaw).toLowerCase();
var raws = {};
if (name !== nameRaw) {
raws.value = "/" + nameRaw + "/";
}
var node = new _combinator["default"]({
value: "/" + name + "/",
source: getSource(this.currToken[_tokenize.FIELDS.START_LINE], this.currToken[_tokenize.FIELDS.START_COL], this.tokens[this.position + 2][_tokenize.FIELDS.END_LINE], this.tokens[this.position + 2][_tokenize.FIELDS.END_COL]),
sourceIndex: this.currToken[_tokenize.FIELDS.START_POS],
raws: raws
});
this.position = this.position + 3;
return node;
} else {
this.unexpected();
}
};
_proto.combinator = function combinator() {
var _this3 = this;
if (this.content() === '|') {
return this.namespace();
} // We need to decide between a space that's a descendant combinator and meaningless whitespace at the end of a selector.
var nextSigTokenPos = this.locateNextMeaningfulToken(this.position);
if (nextSigTokenPos < 0 || this.tokens[nextSigTokenPos][_tokenize.FIELDS.TYPE] === tokens.comma) {
var nodes = this.parseWhitespaceEquivalentTokens(nextSigTokenPos);
if (nodes.length > 0) {
var last = this.current.last;
if (last) {
var _this$convertWhitespa = this.convertWhitespaceNodesToSpace(nodes),
space = _this$convertWhitespa.space,
rawSpace = _this$convertWhitespa.rawSpace;
if (rawSpace !== undefined) {
last.rawSpaceAfter += rawSpace;
}
last.spaces.after += space;
} else {
nodes.forEach(function (n) {
return _this3.newNode(n);
});
}
}
return;
}
var firstToken = this.currToken;
var spaceOrDescendantSelectorNodes = undefined;
if (nextSigTokenPos > this.position) {
spaceOrDescendantSelectorNodes = this.parseWhitespaceEquivalentTokens(nextSigTokenPos);
}
var node;
if (this.isNamedCombinator()) {
node = this.namedCombinator();
} else if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.combinator) {
node = new _combinator["default"]({
value: this.content(),
source: getTokenSource(this.currToken),
sourceIndex: this.currToken[_tokenize.FIELDS.START_POS]
});
this.position++;
} else if (WHITESPACE_TOKENS[this.currToken[_tokenize.FIELDS.TYPE]]) ; else if (!spaceOrDescendantSelectorNodes) {
this.unexpected();
}
if (node) {
if (spaceOrDescendantSelectorNodes) {
var _this$convertWhitespa2 = this.convertWhitespaceNodesToSpace(spaceOrDescendantSelectorNodes),
_space = _this$convertWhitespa2.space,
_rawSpace = _this$convertWhitespa2.rawSpace;
node.spaces.before = _space;
node.rawSpaceBefore = _rawSpace;
}
} else {
// descendant combinator
var _this$convertWhitespa3 = this.convertWhitespaceNodesToSpace(spaceOrDescendantSelectorNodes, true),
_space2 = _this$convertWhitespa3.space,
_rawSpace2 = _this$convertWhitespa3.rawSpace;
if (!_rawSpace2) {
_rawSpace2 = _space2;
}
var spaces = {};
var raws = {
spaces: {}
};
if (_space2.endsWith(' ') && _rawSpace2.endsWith(' ')) {
spaces.before = _space2.slice(0, _space2.length - 1);
raws.spaces.before = _rawSpace2.slice(0, _rawSpace2.length - 1);
} else if (_space2.startsWith(' ') && _rawSpace2.startsWith(' ')) {
spaces.after = _space2.slice(1);
raws.spaces.after = _rawSpace2.slice(1);
} else {
raws.value = _rawSpace2;
}
node = new _combinator["default"]({
value: ' ',
source: getTokenSourceSpan(firstToken, this.tokens[this.position - 1]),
sourceIndex: firstToken[_tokenize.FIELDS.START_POS],
spaces: spaces,
raws: raws
});
}
if (this.currToken && this.currToken[_tokenize.FIELDS.TYPE] === tokens.space) {
node.spaces.after = this.optionalSpace(this.content());
this.position++;
}
return this.newNode(node);
};
_proto.comma = function comma() {
if (this.position === this.tokens.length - 1) {
this.root.trailingComma = true;
this.position++;
return;
}
this.current._inferEndPosition();
var selector = new _selector["default"]({
source: {
start: tokenStart(this.tokens[this.position + 1])
}
});
this.current.parent.append(selector);
this.current = selector;
this.position++;
};
_proto.comment = function comment() {
var current = this.currToken;
this.newNode(new _comment["default"]({
value: this.content(),
source: getTokenSource(current),
sourceIndex: current[_tokenize.FIELDS.START_POS]
}));
this.position++;
};
_proto.error = function error(message, opts) {
throw this.root.error(message, opts);
};
_proto.missingBackslash = function missingBackslash() {
return this.error('Expected a backslash preceding the semicolon.', {
index: this.currToken[_tokenize.FIELDS.START_POS]
});
};
_proto.missingParenthesis = function missingParenthesis() {
return this.expected('opening parenthesis', this.currToken[_tokenize.FIELDS.START_POS]);
};
_proto.missingSquareBracket = function missingSquareBracket() {
return this.expected('opening square bracket', this.currToken[_tokenize.FIELDS.START_POS]);
};
_proto.unexpected = function unexpected() {
return this.error("Unexpected '" + this.content() + "'. Escaping special characters with \\ may help.", this.currToken[_tokenize.FIELDS.START_POS]);
};
_proto.namespace = function namespace() {
var before = this.prevToken && this.content(this.prevToken) || true;
if (this.nextToken[_tokenize.FIELDS.TYPE] === tokens.word) {
this.position++;
return this.word(before);
} else if (this.nextToken[_tokenize.FIELDS.TYPE] === tokens.asterisk) {
this.position++;
return this.universal(before);
}
};
_proto.nesting = function nesting() {
if (this.nextToken) {
var nextContent = this.content(this.nextToken);
if (nextContent === "|") {
this.position++;
return;
}
}
var current = this.currToken;
this.newNode(new _nesting["default"]({
value: this.content(),
source: getTokenSource(current),
sourceIndex: current[_tokenize.FIELDS.START_POS]
}));
this.position++;
};
_proto.parentheses = function parentheses() {
var last = this.current.last;
var unbalanced = 1;
this.position++;
if (last && last.type === types$1.PSEUDO) {
var selector = new _selector["default"]({
source: {
start: tokenStart(this.tokens[this.position - 1])
}
});
var cache = this.current;
last.append(selector);
this.current = selector;
while (this.position < this.tokens.length && unbalanced) {
if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) {
unbalanced++;
}
if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) {
unbalanced--;
}
if (unbalanced) {
this.parse();
} else {
this.current.source.end = tokenEnd(this.currToken);
this.current.parent.source.end = tokenEnd(this.currToken);
this.position++;
}
}
this.current = cache;
} else {
// I think this case should be an error. It's used to implement a basic parse of media queries
// but I don't think it's a good idea.
var parenStart = this.currToken;
var parenValue = "(";
var parenEnd;
while (this.position < this.tokens.length && unbalanced) {
if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) {
unbalanced++;
}
if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) {
unbalanced--;
}
parenEnd = this.currToken;
parenValue += this.parseParenthesisToken(this.currToken);
this.position++;
}
if (last) {
last.appendToPropertyAndEscape("value", parenValue, parenValue);
} else {
this.newNode(new _string["default"]({
value: parenValue,
source: getSource(parenStart[_tokenize.FIELDS.START_LINE], parenStart[_tokenize.FIELDS.START_COL], parenEnd[_tokenize.FIELDS.END_LINE], parenEnd[_tokenize.FIELDS.END_COL]),
sourceIndex: parenStart[_tokenize.FIELDS.START_POS]
}));
}
}
if (unbalanced) {
return this.expected('closing parenthesis', this.currToken[_tokenize.FIELDS.START_POS]);
}
};
_proto.pseudo = function pseudo() {
var _this4 = this;
var pseudoStr = '';
var startingToken = this.currToken;
while (this.currToken && this.currToken[_tokenize.FIELDS.TYPE] === tokens.colon) {
pseudoStr += this.content();
this.position++;
}
if (!this.currToken) {
return this.expected(['pseudo-class', 'pseudo-element'], this.position - 1);
}
if (this.currToken[_tokenize.FIELDS.TYPE] === tokens.word) {
this.splitWord(false, function (first, length) {
pseudoStr += first;
_this4.newNode(new _pseudo["default"]({
value: pseudoStr,
source: getTokenSourceSpan(startingToken, _this4.currToken),
sourceIndex: startingToken[_tokenize.FIELDS.START_POS]
}));
if (length > 1 && _this4.nextToken && _this4.nextToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis) {
_this4.error('Misplaced parenthesis.', {
index: _this4.nextToken[_tokenize.FIELDS.START_POS]
});
}
});
} else {
return this.expected(['pseudo-class', 'pseudo-element'], this.currToken[_tokenize.FIELDS.START_POS]);
}
};
_proto.space = function space() {
var content = this.content(); // Handle space before and after the selector
if (this.position === 0 || this.prevToken[_tokenize.FIELDS.TYPE] === tokens.comma || this.prevToken[_tokenize.FIELDS.TYPE] === tokens.openParenthesis || this.current.nodes.every(function (node) {
return node.type === 'comment';
})) {
this.spaces = this.optionalSpace(content);
this.position++;
} else if (this.position === this.tokens.length - 1 || this.nextToken[_tokenize.FIELDS.TYPE] === tokens.comma || this.nextToken[_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) {
this.current.last.spaces.after = this.optionalSpace(content);
this.position++;
} else {
this.combinator();
}
};
_proto.string = function string() {
var current = this.currToken;
this.newNode(new _string["default"]({
value: this.content(),
source: getTokenSource(current),
sourceIndex: current[_tokenize.FIELDS.START_POS]
}));
this.position++;
};
_proto.universal = function universal(namespace) {
var nextToken = this.nextToken;
if (nextToken && this.content(nextToken) === '|') {
this.position++;
return this.namespace();
}
var current = this.currToken;
this.newNode(new _universal["default"]({
value: this.content(),
source: getTokenSource(current),
sourceIndex: current[_tokenize.FIELDS.START_POS]
}), namespace);
this.position++;
};
_proto.splitWord = function splitWord(namespace, firstCallback) {
var _this5 = this;
var nextToken = this.nextToken;
var word = this.content();
while (nextToken && ~[tokens.dollar, tokens.caret, tokens.equals, tokens.word].indexOf(nextToken[_tokenize.FIELDS.TYPE])) {
this.position++;
var current = this.content();
word += current;
if (current.lastIndexOf('\\') === current.length - 1) {
var next = this.nextToken;
if (next && next[_tokenize.FIELDS.TYPE] === tokens.space) {
word += this.requiredSpace(this.content(next));
this.position++;
}
}
nextToken = this.nextToken;
}
var hasClass = indexesOf(word, '.').filter(function (i) {
return word[i - 1] !== '\\';
});
var hasId = indexesOf(word, '#').filter(function (i) {
return word[i - 1] !== '\\';
}); // Eliminate Sass interpolations from the list of id indexes
var interpolations = indexesOf(word, '#{');
if (interpolations.length) {
hasId = hasId.filter(function (hashIndex) {
return !~interpolations.indexOf(hashIndex);
});
}
var indices = (0, _sortAscending["default"])(uniqs([0].concat(hasClass, hasId)));
indices.forEach(function (ind, i) {
var index = indices[i + 1] || word.length;
var value = word.slice(ind, index);
if (i === 0 && firstCallback) {
return firstCallback.call(_this5, value, indices.length);
}
var node;
var current = _this5.currToken;
var sourceIndex = current[_tokenize.FIELDS.START_POS] + indices[i];
var source = getSource(current[1], current[2] + ind, current[3], current[2] + (index - 1));
if (~hasClass.indexOf(ind)) {
var classNameOpts = {
value: value.slice(1),
source: source,
sourceIndex: sourceIndex
};
node = new _className["default"](unescapeProp(classNameOpts, "value"));
} else if (~hasId.indexOf(ind)) {
var idOpts = {
value: value.slice(1),
source: source,
sourceIndex: sourceIndex
};
node = new _id["default"](unescapeProp(idOpts, "value"));
} else {
var tagOpts = {
value: value,
source: source,
sourceIndex: sourceIndex
};
unescapeProp(tagOpts, "value");
node = new _tag["default"](tagOpts);
}
_this5.newNode(node, namespace); // Ensure that the namespace is used only once
namespace = null;
});
this.position++;
};
_proto.word = function word(namespace) {
var nextToken = this.nextToken;
if (nextToken && this.content(nextToken) === '|') {
this.position++;
return this.namespace();
}
return this.splitWord(namespace);
};
_proto.loop = function loop() {
while (this.position < this.tokens.length) {
this.parse(true);
}
this.current._inferEndPosition();
return this.root;
};
_proto.parse = function parse(throwOnParenthesis) {
switch (this.currToken[_tokenize.FIELDS.TYPE]) {
case tokens.space:
this.space();
break;
case tokens.comment:
this.comment();
break;
case tokens.openParenthesis:
this.parentheses();
break;
case tokens.closeParenthesis:
if (throwOnParenthesis) {
this.missingParenthesis();
}
break;
case tokens.openSquare:
this.attribute();
break;
case tokens.dollar:
case tokens.caret:
case tokens.equals:
case tokens.word:
this.word();
break;
case tokens.colon:
this.pseudo();
break;
case tokens.comma:
this.comma();
break;
case tokens.asterisk:
this.universal();
break;
case tokens.ampersand:
this.nesting();
break;
case tokens.slash:
case tokens.combinator:
this.combinator();
break;
case tokens.str:
this.string();
break;
// These cases throw; no break needed.
case tokens.closeSquare:
this.missingSquareBracket();
case tokens.semicolon:
this.missingBackslash();
default:
this.unexpected();
}
}
/**
* Helpers
*/
;
_proto.expected = function expected(description, index, found) {
if (Array.isArray(description)) {
var last = description.pop();
description = description.join(', ') + " or " + last;
}
var an = /^[aeiou]/.test(description[0]) ? 'an' : 'a';
if (!found) {
return this.error("Expected " + an + " " + description + ".", {
index: index
});
}
return this.error("Expected " + an + " " + description + ", found \"" + found + "\" instead.", {
index: index
});
};
_proto.requiredSpace = function requiredSpace(space) {
return this.options.lossy ? ' ' : space;
};
_proto.optionalSpace = function optionalSpace(space) {
return this.options.lossy ? '' : space;
};
_proto.lossySpace = function lossySpace(space, required) {
if (this.options.lossy) {
return required ? ' ' : '';
} else {
return space;
}
};
_proto.parseParenthesisToken = function parseParenthesisToken(token) {
var content = this.content(token);
if (token[_tokenize.FIELDS.TYPE] === tokens.space) {
return this.requiredSpace(content);
} else {
return content;
}
};
_proto.newNode = function newNode(node, namespace) {
if (namespace) {
if (/^ +$/.test(namespace)) {
if (!this.options.lossy) {
this.spaces = (this.spaces || '') + namespace;
}
namespace = true;
}
node.namespace = namespace;
unescapeProp(node, "namespace");
}
if (this.spaces) {
node.spaces.before = this.spaces;
this.spaces = '';
}
return this.current.append(node);
};
_proto.content = function content(token) {
if (token === void 0) {
token = this.currToken;
}
return this.css.slice(token[_tokenize.FIELDS.START_POS], token[_tokenize.FIELDS.END_POS]);
};
/**
* returns the index of the next non-whitespace, non-comment token.
* returns -1 if no meaningful token is found.
*/
_proto.locateNextMeaningfulToken = function locateNextMeaningfulToken(startPosition) {
if (startPosition === void 0) {
startPosition = this.position + 1;
}
var searchPosition = startPosition;
while (searchPosition < this.tokens.length) {
if (WHITESPACE_EQUIV_TOKENS[this.tokens[searchPosition][_tokenize.FIELDS.TYPE]]) {
searchPosition++;
continue;
} else {
return searchPosition;
}
}
return -1;
};
_createClass(Parser, [{
key: "currToken",
get: function get() {
return this.tokens[this.position];
}
}, {
key: "nextToken",
get: function get() {
return this.tokens[this.position + 1];
}
}, {
key: "prevToken",
get: function get() {
return this.tokens[this.position - 1];
}
}]);
return Parser;
}();
exports["default"] = Parser;
module.exports = exports.default;
}(parser, parser.exports));
(function (module, exports) {
exports.__esModule = true;
exports["default"] = void 0;
var _parser = _interopRequireDefault(parser.exports);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
var Processor = /*#__PURE__*/function () {
function Processor(func, options) {
this.func = func || function noop() {};
this.funcRes = null;
this.options = options;
}
var _proto = Processor.prototype;
_proto._shouldUpdateSelector = function _shouldUpdateSelector(rule, options) {
if (options === void 0) {
options = {};
}
var merged = Object.assign({}, this.options, options);
if (merged.updateSelector === false) {
return false;
} else {
return typeof rule !== "string";
}
};
_proto._isLossy = function _isLossy(options) {
if (options === void 0) {
options = {};
}
var merged = Object.assign({}, this.options, options);
if (merged.lossless === false) {
return true;
} else {
return false;
}
};
_proto._root = function _root(rule, options) {
if (options === void 0) {
options = {};
}
var parser = new _parser["default"](rule, this._parseOptions(options));
return parser.root;
};
_proto._parseOptions = function _parseOptions(options) {
return {
lossy: this._isLossy(options)
};
};
_proto._run = function _run(rule, options) {
var _this = this;
if (options === void 0) {
options = {};
}
return new Promise(function (resolve, reject) {
try {
var root = _this._root(rule, options);
Promise.resolve(_this.func(root)).then(function (transform) {
var string = undefined;
if (_this._shouldUpdateSelector(rule, options)) {
string = root.toString();
rule.selector = string;
}
return {
transform: transform,
root: root,
string: string
};
}).then(resolve, reject);
} catch (e) {
reject(e);
return;
}
});
};
_proto._runSync = function _runSync(rule, options) {
if (options === void 0) {
options = {};
}
var root = this._root(rule, options);
var transform = this.func(root);
if (transform && typeof transform.then === "function") {
throw new Error("Selector processor returned a promise to a synchronous call.");
}
var string = undefined;
if (options.updateSelector && typeof rule !== "string") {
string = root.toString();
rule.selector = string;
}
return {
transform: transform,
root: root,
string: string
};
}
/**
* Process rule into a selector AST.
*
* @param rule {postcss.Rule | string} The css selector to be processed
* @param options The options for processing
* @returns {Promise<parser.Root>} The AST of the selector after processing it.
*/
;
_proto.ast = function ast(rule, options) {
return this._run(rule, options).then(function (result) {
return result.root;
});
}
/**
* Process rule into a selector AST synchronously.
*
* @param rule {postcss.Rule | string} The css selector to be processed
* @param options The options for processing
* @returns {parser.Root} The AST of the selector after processing it.
*/
;
_proto.astSync = function astSync(rule, options) {
return this._runSync(rule, options).root;
}
/**
* Process a selector into a transformed value asynchronously
*
* @param rule {postcss.Rule | string} The css selector to be processed
* @param options The options for processing
* @returns {Promise<any>} The value returned by the processor.
*/
;
_proto.transform = function transform(rule, options) {
return this._run(rule, options).then(function (result) {
return result.transform;
});
}
/**
* Process a selector into a transformed value synchronously.
*
* @param rule {postcss.Rule | string} The css selector to be processed
* @param options The options for processing
* @returns {any} The value returned by the processor.
*/
;
_proto.transformSync = function transformSync(rule, options) {
return this._runSync(rule, options).transform;
}
/**
* Process a selector into a new selector string asynchronously.
*
* @param rule {postcss.Rule | string} The css selector to be processed
* @param options The options for processing
* @returns {string} the selector after processing.
*/
;
_proto.process = function process(rule, options) {
return this._run(rule, options).then(function (result) {
return result.string || result.root.toString();
});
}
/**
* Process a selector into a new selector string synchronously.
*
* @param rule {postcss.Rule | string} The css selector to be processed
* @param options The options for processing
* @returns {string} the selector after processing.
*/
;
_proto.processSync = function processSync(rule, options) {
var result = this._runSync(rule, options);
return result.string || result.root.toString();
};
return Processor;
}();
exports["default"] = Processor;
module.exports = exports.default;
}(processor, processor.exports));
var selectors = {};
var constructors = {};
constructors.__esModule = true;
constructors.universal = constructors.tag = constructors.string = constructors.selector = constructors.root = constructors.pseudo = constructors.nesting = constructors.id = constructors.comment = constructors.combinator = constructors.className = constructors.attribute = void 0;
var _attribute = _interopRequireDefault$2(attribute$1);
var _className = _interopRequireDefault$2(className$1.exports);
var _combinator = _interopRequireDefault$2(combinator$2.exports);
var _comment = _interopRequireDefault$2(comment$2.exports);
var _id = _interopRequireDefault$2(id$1.exports);
var _nesting = _interopRequireDefault$2(nesting$1.exports);
var _pseudo = _interopRequireDefault$2(pseudo$1.exports);
var _root = _interopRequireDefault$2(root$1.exports);
var _selector = _interopRequireDefault$2(selector$1.exports);
var _string = _interopRequireDefault$2(string$1.exports);
var _tag = _interopRequireDefault$2(tag$1.exports);
var _universal = _interopRequireDefault$2(universal$1.exports);
function _interopRequireDefault$2(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
var attribute = function attribute(opts) {
return new _attribute["default"](opts);
};
constructors.attribute = attribute;
var className = function className(opts) {
return new _className["default"](opts);
};
constructors.className = className;
var combinator = function combinator(opts) {
return new _combinator["default"](opts);
};
constructors.combinator = combinator;
var comment = function comment(opts) {
return new _comment["default"](opts);
};
constructors.comment = comment;
var id = function id(opts) {
return new _id["default"](opts);
};
constructors.id = id;
var nesting = function nesting(opts) {
return new _nesting["default"](opts);
};
constructors.nesting = nesting;
var pseudo = function pseudo(opts) {
return new _pseudo["default"](opts);
};
constructors.pseudo = pseudo;
var root = function root(opts) {
return new _root["default"](opts);
};
constructors.root = root;
var selector = function selector(opts) {
return new _selector["default"](opts);
};
constructors.selector = selector;
var string = function string(opts) {
return new _string["default"](opts);
};
constructors.string = string;
var tag = function tag(opts) {
return new _tag["default"](opts);
};
constructors.tag = tag;
var universal = function universal(opts) {
return new _universal["default"](opts);
};
constructors.universal = universal;
var guards = {};
guards.__esModule = true;
guards.isNode = isNode;
guards.isPseudoElement = isPseudoElement;
guards.isPseudoClass = isPseudoClass;
guards.isContainer = isContainer;
guards.isNamespace = isNamespace;
guards.isUniversal = guards.isTag = guards.isString = guards.isSelector = guards.isRoot = guards.isPseudo = guards.isNesting = guards.isIdentifier = guards.isComment = guards.isCombinator = guards.isClassName = guards.isAttribute = void 0;
var _types = types;
var _IS_TYPE;
var IS_TYPE = (_IS_TYPE = {}, _IS_TYPE[_types.ATTRIBUTE] = true, _IS_TYPE[_types.CLASS] = true, _IS_TYPE[_types.COMBINATOR] = true, _IS_TYPE[_types.COMMENT] = true, _IS_TYPE[_types.ID] = true, _IS_TYPE[_types.NESTING] = true, _IS_TYPE[_types.PSEUDO] = true, _IS_TYPE[_types.ROOT] = true, _IS_TYPE[_types.SELECTOR] = true, _IS_TYPE[_types.STRING] = true, _IS_TYPE[_types.TAG] = true, _IS_TYPE[_types.UNIVERSAL] = true, _IS_TYPE);
function isNode(node) {
return typeof node === "object" && IS_TYPE[node.type];
}
function isNodeType(type, node) {
return isNode(node) && node.type === type;
}
var isAttribute = isNodeType.bind(null, _types.ATTRIBUTE);
guards.isAttribute = isAttribute;
var isClassName = isNodeType.bind(null, _types.CLASS);
guards.isClassName = isClassName;
var isCombinator = isNodeType.bind(null, _types.COMBINATOR);
guards.isCombinator = isCombinator;
var isComment = isNodeType.bind(null, _types.COMMENT);
guards.isComment = isComment;
var isIdentifier = isNodeType.bind(null, _types.ID);
guards.isIdentifier = isIdentifier;
var isNesting = isNodeType.bind(null, _types.NESTING);
guards.isNesting = isNesting;
var isPseudo = isNodeType.bind(null, _types.PSEUDO);
guards.isPseudo = isPseudo;
var isRoot = isNodeType.bind(null, _types.ROOT);
guards.isRoot = isRoot;
var isSelector = isNodeType.bind(null, _types.SELECTOR);
guards.isSelector = isSelector;
var isString = isNodeType.bind(null, _types.STRING);
guards.isString = isString;
var isTag = isNodeType.bind(null, _types.TAG);
guards.isTag = isTag;
var isUniversal = isNodeType.bind(null, _types.UNIVERSAL);
guards.isUniversal = isUniversal;
function isPseudoElement(node) {
return isPseudo(node) && node.value && (node.value.startsWith("::") || node.value.toLowerCase() === ":before" || node.value.toLowerCase() === ":after");
}
function isPseudoClass(node) {
return isPseudo(node) && !isPseudoElement(node);
}
function isContainer(node) {
return !!(isNode(node) && node.walk);
}
function isNamespace(node) {
return isAttribute(node) || isTag(node);
}
(function (exports) {
exports.__esModule = true;
var _types = types;
Object.keys(_types).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (key in exports && exports[key] === _types[key]) return;
exports[key] = _types[key];
});
var _constructors = constructors;
Object.keys(_constructors).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (key in exports && exports[key] === _constructors[key]) return;
exports[key] = _constructors[key];
});
var _guards = guards;
Object.keys(_guards).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (key in exports && exports[key] === _guards[key]) return;
exports[key] = _guards[key];
});
}(selectors));
(function (module, exports) {
exports.__esModule = true;
exports["default"] = void 0;
var _processor = _interopRequireDefault(processor.exports);
var selectors$1 = _interopRequireWildcard(selectors);
function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
var parser = function parser(processor) {
return new _processor["default"](processor);
};
Object.assign(parser, selectors$1);
delete parser.__esModule;
var _default = parser;
exports["default"] = _default;
module.exports = exports.default;
}(dist, dist.exports));
const matchValueName = /[$]?[\w-]+/g;
const replaceValueSymbols$2 = (value, replacements) => {
let matches;
while ((matches = matchValueName.exec(value))) {
const replacement = replacements[matches[0]];
if (replacement) {
value =
value.slice(0, matches.index) +
replacement +
value.slice(matchValueName.lastIndex);
matchValueName.lastIndex -= matches[0].length - replacement.length;
}
}
return value;
};
var replaceValueSymbols_1 = replaceValueSymbols$2;
const replaceValueSymbols$1 = replaceValueSymbols_1;
const replaceSymbols$1 = (css, replacements) => {
css.walk((node) => {
if (node.type === "decl" && node.value) {
node.value = replaceValueSymbols$1(node.value.toString(), replacements);
} else if (node.type === "rule" && node.selector) {
node.selector = replaceValueSymbols$1(
node.selector.toString(),
replacements
);
} else if (node.type === "atrule" && node.params) {
node.params = replaceValueSymbols$1(node.params.toString(), replacements);
}
});
};
var replaceSymbols_1 = replaceSymbols$1;
const importPattern = /^:import\(("[^"]*"|'[^']*'|[^"']+)\)$/;
const balancedQuotes = /^("[^"]*"|'[^']*'|[^"']+)$/;
const getDeclsObject = (rule) => {
const object = {};
rule.walkDecls((decl) => {
const before = decl.raws.before ? decl.raws.before.trim() : "";
object[before + decl.prop] = decl.value;
});
return object;
};
/**
*
* @param {string} css
* @param {boolean} removeRules
* @param {'auto' | 'rule' | 'at-rule'} mode
*/
const extractICSS$2 = (css, removeRules = true, mode = "auto") => {
const icssImports = {};
const icssExports = {};
function addImports(node, path) {
const unquoted = path.replace(/'|"/g, "");
icssImports[unquoted] = Object.assign(
icssImports[unquoted] || {},
getDeclsObject(node)
);
if (removeRules) {
node.remove();
}
}
function addExports(node) {
Object.assign(icssExports, getDeclsObject(node));
if (removeRules) {
node.remove();
}
}
css.each((node) => {
if (node.type === "rule" && mode !== "at-rule") {
if (node.selector.slice(0, 7) === ":import") {
const matches = importPattern.exec(node.selector);
if (matches) {
addImports(node, matches[1]);
}
}
if (node.selector === ":export") {
addExports(node);
}
}
if (node.type === "atrule" && mode !== "rule") {
if (node.name === "icss-import") {
const matches = balancedQuotes.exec(node.params);
if (matches) {
addImports(node, matches[1]);
}
}
if (node.name === "icss-export") {
addExports(node);
}
}
});
return { icssImports, icssExports };
};
var extractICSS_1 = extractICSS$2;
const createImports = (imports, postcss, mode = "rule") => {
return Object.keys(imports).map((path) => {
const aliases = imports[path];
const declarations = Object.keys(aliases).map((key) =>
postcss.decl({
prop: key,
value: aliases[key],
raws: { before: "\n " },
})
);
const hasDeclarations = declarations.length > 0;
const rule =
mode === "rule"
? postcss.rule({
selector: `:import('${path}')`,
raws: { after: hasDeclarations ? "\n" : "" },
})
: postcss.atRule({
name: "icss-import",
params: `'${path}'`,
raws: { after: hasDeclarations ? "\n" : "" },
});
if (hasDeclarations) {
rule.append(declarations);
}
return rule;
});
};
const createExports = (exports, postcss, mode = "rule") => {
const declarations = Object.keys(exports).map((key) =>
postcss.decl({
prop: key,
value: exports[key],
raws: { before: "\n " },
})
);
if (declarations.length === 0) {
return [];
}
const rule =
mode === "rule"
? postcss.rule({
selector: `:export`,
raws: { after: "\n" },
})
: postcss.atRule({
name: "icss-export",
raws: { after: "\n" },
});
rule.append(declarations);
return [rule];
};
const createICSSRules$1 = (imports, exports, postcss, mode) => [
...createImports(imports, postcss, mode),
...createExports(exports, postcss, mode),
];
var createICSSRules_1 = createICSSRules$1;
const replaceValueSymbols = replaceValueSymbols_1;
const replaceSymbols = replaceSymbols_1;
const extractICSS$1 = extractICSS_1;
const createICSSRules = createICSSRules_1;
var src$3 = {
replaceValueSymbols,
replaceSymbols,
extractICSS: extractICSS$1,
createICSSRules,
};
const selectorParser$1 = dist.exports;
const valueParser = index$1.lib;
const { extractICSS } = src$3;
const isSpacing = (node) => node.type === "combinator" && node.value === " ";
function normalizeNodeArray(nodes) {
const array = [];
nodes.forEach((x) => {
if (Array.isArray(x)) {
normalizeNodeArray(x).forEach((item) => {
array.push(item);
});
} else if (x) {
array.push(x);
}
});
if (array.length > 0 && isSpacing(array[array.length - 1])) {
array.pop();
}
return array;
}
function localizeNode(rule, mode, localAliasMap) {
const transform = (node, context) => {
if (context.ignoreNextSpacing && !isSpacing(node)) {
throw new Error("Missing whitespace after " + context.ignoreNextSpacing);
}
if (context.enforceNoSpacing && isSpacing(node)) {
throw new Error("Missing whitespace before " + context.enforceNoSpacing);
}
let newNodes;
switch (node.type) {
case "root": {
let resultingGlobal;
context.hasPureGlobals = false;
newNodes = node.nodes.map((n) => {
const nContext = {
global: context.global,
lastWasSpacing: true,
hasLocals: false,
explicit: false,
};
n = transform(n, nContext);
if (typeof resultingGlobal === "undefined") {
resultingGlobal = nContext.global;
} else if (resultingGlobal !== nContext.global) {
throw new Error(
'Inconsistent rule global/local result in rule "' +
node +
'" (multiple selectors must result in the same mode for the rule)'
);
}
if (!nContext.hasLocals) {
context.hasPureGlobals = true;
}
return n;
});
context.global = resultingGlobal;
node.nodes = normalizeNodeArray(newNodes);
break;
}
case "selector": {
newNodes = node.map((childNode) => transform(childNode, context));
node = node.clone();
node.nodes = normalizeNodeArray(newNodes);
break;
}
case "combinator": {
if (isSpacing(node)) {
if (context.ignoreNextSpacing) {
context.ignoreNextSpacing = false;
context.lastWasSpacing = false;
context.enforceNoSpacing = false;
return null;
}
context.lastWasSpacing = true;
return node;
}
break;
}
case "pseudo": {
let childContext;
const isNested = !!node.length;
const isScoped = node.value === ":local" || node.value === ":global";
const isImportExport =
node.value === ":import" || node.value === ":export";
if (isImportExport) {
context.hasLocals = true;
// :local(.foo)
} else if (isNested) {
if (isScoped) {
if (node.nodes.length === 0) {
throw new Error(`${node.value}() can't be empty`);
}
if (context.inside) {
throw new Error(
`A ${node.value} is not allowed inside of a ${context.inside}(...)`
);
}
childContext = {
global: node.value === ":global",
inside: node.value,
hasLocals: false,
explicit: true,
};
newNodes = node
.map((childNode) => transform(childNode, childContext))
.reduce((acc, next) => acc.concat(next.nodes), []);
if (newNodes.length) {
const { before, after } = node.spaces;
const first = newNodes[0];
const last = newNodes[newNodes.length - 1];
first.spaces = { before, after: first.spaces.after };
last.spaces = { before: last.spaces.before, after };
}
node = newNodes;
break;
} else {
childContext = {
global: context.global,
inside: context.inside,
lastWasSpacing: true,
hasLocals: false,
explicit: context.explicit,
};
newNodes = node.map((childNode) =>
transform(childNode, childContext)
);
node = node.clone();
node.nodes = normalizeNodeArray(newNodes);
if (childContext.hasLocals) {
context.hasLocals = true;
}
}
break;
//:local .foo .bar
} else if (isScoped) {
if (context.inside) {
throw new Error(
`A ${node.value} is not allowed inside of a ${context.inside}(...)`
);
}
const addBackSpacing = !!node.spaces.before;
context.ignoreNextSpacing = context.lastWasSpacing
? node.value
: false;
context.enforceNoSpacing = context.lastWasSpacing
? false
: node.value;
context.global = node.value === ":global";
context.explicit = true;
// because this node has spacing that is lost when we remove it
// we make up for it by adding an extra combinator in since adding
// spacing on the parent selector doesn't work
return addBackSpacing
? selectorParser$1.combinator({ value: " " })
: null;
}
break;
}
case "id":
case "class": {
if (!node.value) {
throw new Error("Invalid class or id selector syntax");
}
if (context.global) {
break;
}
const isImportedValue = localAliasMap.has(node.value);
const isImportedWithExplicitScope = isImportedValue && context.explicit;
if (!isImportedValue || isImportedWithExplicitScope) {
const innerNode = node.clone();
innerNode.spaces = { before: "", after: "" };
node = selectorParser$1.pseudo({
value: ":local",
nodes: [innerNode],
spaces: node.spaces,
});
context.hasLocals = true;
}
break;
}
}
context.lastWasSpacing = false;
context.ignoreNextSpacing = false;
context.enforceNoSpacing = false;
return node;
};
const rootContext = {
global: mode === "global",
hasPureGlobals: false,
};
rootContext.selector = selectorParser$1((root) => {
transform(root, rootContext);
}).processSync(rule, { updateSelector: false, lossless: true });
return rootContext;
}
function localizeDeclNode(node, context) {
switch (node.type) {
case "word":
if (context.localizeNextItem) {
if (!context.localAliasMap.has(node.value)) {
node.value = ":local(" + node.value + ")";
context.localizeNextItem = false;
}
}
break;
case "function":
if (
context.options &&
context.options.rewriteUrl &&
node.value.toLowerCase() === "url"
) {
node.nodes.map((nestedNode) => {
if (nestedNode.type !== "string" && nestedNode.type !== "word") {
return;
}
let newUrl = context.options.rewriteUrl(
context.global,
nestedNode.value
);
switch (nestedNode.type) {
case "string":
if (nestedNode.quote === "'") {
newUrl = newUrl.replace(/(\\)/g, "\\$1").replace(/'/g, "\\'");
}
if (nestedNode.quote === '"') {
newUrl = newUrl.replace(/(\\)/g, "\\$1").replace(/"/g, '\\"');
}
break;
case "word":
newUrl = newUrl.replace(/("|'|\)|\\)/g, "\\$1");
break;
}
nestedNode.value = newUrl;
});
}
break;
}
return node;
}
function isWordAFunctionArgument(wordNode, functionNode) {
return functionNode
? functionNode.nodes.some(
(functionNodeChild) =>
functionNodeChild.sourceIndex === wordNode.sourceIndex
)
: false;
}
function localizeDeclarationValues(localize, declaration, context) {
const valueNodes = valueParser(declaration.value);
valueNodes.walk((node, index, nodes) => {
const subContext = {
options: context.options,
global: context.global,
localizeNextItem: localize && !context.global,
localAliasMap: context.localAliasMap,
};
nodes[index] = localizeDeclNode(node, subContext);
});
declaration.value = valueNodes.toString();
}
function localizeDeclaration(declaration, context) {
const isAnimation = /animation$/i.test(declaration.prop);
if (isAnimation) {
const validIdent = /^-?[_a-z][_a-z0-9-]*$/i;
/*
The spec defines some keywords that you can use to describe properties such as the timing
function. These are still valid animation names, so as long as there is a property that accepts
a keyword, it is given priority. Only when all the properties that can take a keyword are
exhausted can the animation name be set to the keyword. I.e.
animation: infinite infinite;
The animation will repeat an infinite number of times from the first argument, and will have an
animation name of infinite from the second.
*/
const animationKeywords = {
$alternate: 1,
"$alternate-reverse": 1,
$backwards: 1,
$both: 1,
$ease: 1,
"$ease-in": 1,
"$ease-in-out": 1,
"$ease-out": 1,
$forwards: 1,
$infinite: 1,
$linear: 1,
$none: Infinity, // No matter how many times you write none, it will never be an animation name
$normal: 1,
$paused: 1,
$reverse: 1,
$running: 1,
"$step-end": 1,
"$step-start": 1,
$initial: Infinity,
$inherit: Infinity,
$unset: Infinity,
};
let parsedAnimationKeywords = {};
let stepsFunctionNode = null;
const valueNodes = valueParser(declaration.value).walk((node) => {
/* If div-token appeared (represents as comma ','), a possibility of an animation-keywords should be reflesh. */
if (node.type === "div") {
parsedAnimationKeywords = {};
}
if (node.type === "function" && node.value.toLowerCase() === "steps") {
stepsFunctionNode = node;
}
const value =
node.type === "word" &&
!isWordAFunctionArgument(node, stepsFunctionNode)
? node.value.toLowerCase()
: null;
let shouldParseAnimationName = false;
if (value && validIdent.test(value)) {
if ("$" + value in animationKeywords) {
parsedAnimationKeywords["$" + value] =
"$" + value in parsedAnimationKeywords
? parsedAnimationKeywords["$" + value] + 1
: 0;
shouldParseAnimationName =
parsedAnimationKeywords["$" + value] >=
animationKeywords["$" + value];
} else {
shouldParseAnimationName = true;
}
}
const subContext = {
options: context.options,
global: context.global,
localizeNextItem: shouldParseAnimationName && !context.global,
localAliasMap: context.localAliasMap,
};
return localizeDeclNode(node, subContext);
});
declaration.value = valueNodes.toString();
return;
}
const isAnimationName = /animation(-name)?$/i.test(declaration.prop);
if (isAnimationName) {
return localizeDeclarationValues(true, declaration, context);
}
const hasUrl = /url\(/i.test(declaration.value);
if (hasUrl) {
return localizeDeclarationValues(false, declaration, context);
}
}
src$4.exports = (options = {}) => {
if (
options &&
options.mode &&
options.mode !== "global" &&
options.mode !== "local" &&
options.mode !== "pure"
) {
throw new Error(
'options.mode must be either "global", "local" or "pure" (default "local")'
);
}
const pureMode = options && options.mode === "pure";
const globalMode = options && options.mode === "global";
return {
postcssPlugin: "postcss-modules-local-by-default",
prepare() {
const localAliasMap = new Map();
return {
Once(root) {
const { icssImports } = extractICSS(root, false);
Object.keys(icssImports).forEach((key) => {
Object.keys(icssImports[key]).forEach((prop) => {
localAliasMap.set(prop, icssImports[key][prop]);
});
});
root.walkAtRules((atRule) => {
if (/keyframes$/i.test(atRule.name)) {
const globalMatch = /^\s*:global\s*\((.+)\)\s*$/.exec(
atRule.params
);
const localMatch = /^\s*:local\s*\((.+)\)\s*$/.exec(
atRule.params
);
let globalKeyframes = globalMode;
if (globalMatch) {
if (pureMode) {
throw atRule.error(
"@keyframes :global(...) is not allowed in pure mode"
);
}
atRule.params = globalMatch[1];
globalKeyframes = true;
} else if (localMatch) {
atRule.params = localMatch[0];
globalKeyframes = false;
} else if (!globalMode) {
if (atRule.params && !localAliasMap.has(atRule.params)) {
atRule.params = ":local(" + atRule.params + ")";
}
}
atRule.walkDecls((declaration) => {
localizeDeclaration(declaration, {
localAliasMap,
options: options,
global: globalKeyframes,
});
});
} else if (atRule.nodes) {
atRule.nodes.forEach((declaration) => {
if (declaration.type === "decl") {
localizeDeclaration(declaration, {
localAliasMap,
options: options,
global: globalMode,
});
}
});
}
});
root.walkRules((rule) => {
if (
rule.parent &&
rule.parent.type === "atrule" &&
/keyframes$/i.test(rule.parent.name)
) {
// ignore keyframe rules
return;
}
const context = localizeNode(rule, options.mode, localAliasMap);
context.options = options;
context.localAliasMap = localAliasMap;
if (pureMode && context.hasPureGlobals) {
throw rule.error(
'Selector "' +
rule.selector +
'" is not pure ' +
"(pure selectors must contain at least one local class or id)"
);
}
rule.selector = context.selector;
// Less-syntax mixins parse as rules with no nodes
if (rule.nodes) {
rule.nodes.forEach((declaration) =>
localizeDeclaration(declaration, context)
);
}
});
},
};
},
};
};
src$4.exports.postcss = true;
var src$2 = {exports: {}};
const PERMANENT_MARKER = 2;
const TEMPORARY_MARKER = 1;
function createError(node, graph) {
const er = new Error("Nondeterministic import's order");
const related = graph[node];
const relatedNode = related.find(
(relatedNode) => graph[relatedNode].indexOf(node) > -1
);
er.nodes = [node, relatedNode];
return er;
}
function walkGraph(node, graph, state, result, strict) {
if (state[node] === PERMANENT_MARKER) {
return;
}
if (state[node] === TEMPORARY_MARKER) {
if (strict) {
return createError(node, graph);
}
return;
}
state[node] = TEMPORARY_MARKER;
const children = graph[node];
const length = children.length;
for (let i = 0; i < length; ++i) {
const error = walkGraph(children[i], graph, state, result, strict);
if (error instanceof Error) {
return error;
}
}
state[node] = PERMANENT_MARKER;
result.push(node);
}
function topologicalSort$1(graph, strict) {
const result = [];
const state = {};
const nodes = Object.keys(graph);
const length = nodes.length;
for (let i = 0; i < length; ++i) {
const er = walkGraph(nodes[i], graph, state, result, strict);
if (er instanceof Error) {
return er;
}
}
return result;
}
var topologicalSort_1 = topologicalSort$1;
const topologicalSort = topologicalSort_1;
const matchImports$1 = /^(.+?)\s+from\s+(?:"([^"]+)"|'([^']+)'|(global))$/;
const icssImport = /^:import\((?:"([^"]+)"|'([^']+)')\)/;
const VISITED_MARKER = 1;
/**
* :import('G') {}
*
* Rule
* composes: ... from 'A'
* composes: ... from 'B'
* Rule
* composes: ... from 'A'
* composes: ... from 'A'
* composes: ... from 'C'
*
* Results in:
*
* graph: {
* G: [],
* A: [],
* B: ['A'],
* C: ['A'],
* }
*/
function addImportToGraph(importId, parentId, graph, visited) {
const siblingsId = parentId + "_" + "siblings";
const visitedId = parentId + "_" + importId;
if (visited[visitedId] !== VISITED_MARKER) {
if (!Array.isArray(visited[siblingsId])) {
visited[siblingsId] = [];
}
const siblings = visited[siblingsId];
if (Array.isArray(graph[importId])) {
graph[importId] = graph[importId].concat(siblings);
} else {
graph[importId] = siblings.slice();
}
visited[visitedId] = VISITED_MARKER;
siblings.push(importId);
}
}
src$2.exports = (options = {}) => {
let importIndex = 0;
const createImportedName =
typeof options.createImportedName !== "function"
? (importName /*, path*/) =>
`i__imported_${importName.replace(/\W/g, "_")}_${importIndex++}`
: options.createImportedName;
const failOnWrongOrder = options.failOnWrongOrder;
return {
postcssPlugin: "postcss-modules-extract-imports",
prepare() {
const graph = {};
const visited = {};
const existingImports = {};
const importDecls = {};
const imports = {};
return {
Once(root, postcss) {
// Check the existing imports order and save refs
root.walkRules((rule) => {
const matches = icssImport.exec(rule.selector);
if (matches) {
const [, /*match*/ doubleQuotePath, singleQuotePath] = matches;
const importPath = doubleQuotePath || singleQuotePath;
addImportToGraph(importPath, "root", graph, visited);
existingImports[importPath] = rule;
}
});
root.walkDecls(/^composes$/, (declaration) => {
const matches = declaration.value.match(matchImports$1);
if (!matches) {
return;
}
let tmpSymbols;
let [
,
/*match*/ symbols,
doubleQuotePath,
singleQuotePath,
global,
] = matches;
if (global) {
// Composing globals simply means changing these classes to wrap them in global(name)
tmpSymbols = symbols.split(/\s+/).map((s) => `global(${s})`);
} else {
const importPath = doubleQuotePath || singleQuotePath;
let parent = declaration.parent;
let parentIndexes = "";
while (parent.type !== "root") {
parentIndexes =
parent.parent.index(parent) + "_" + parentIndexes;
parent = parent.parent;
}
const { selector } = declaration.parent;
const parentRule = `_${parentIndexes}${selector}`;
addImportToGraph(importPath, parentRule, graph, visited);
importDecls[importPath] = declaration;
imports[importPath] = imports[importPath] || {};
tmpSymbols = symbols.split(/\s+/).map((s) => {
if (!imports[importPath][s]) {
imports[importPath][s] = createImportedName(s, importPath);
}
return imports[importPath][s];
});
}
declaration.value = tmpSymbols.join(" ");
});
const importsOrder = topologicalSort(graph, failOnWrongOrder);
if (importsOrder instanceof Error) {
const importPath = importsOrder.nodes.find((importPath) =>
// eslint-disable-next-line no-prototype-builtins
importDecls.hasOwnProperty(importPath)
);
const decl = importDecls[importPath];
throw decl.error(
"Failed to resolve order of composed modules " +
importsOrder.nodes
.map((importPath) => "`" + importPath + "`")
.join(", ") +
".",
{
plugin: "postcss-modules-extract-imports",
word: "composes",
}
);
}
let lastImportRule;
importsOrder.forEach((path) => {
const importedSymbols = imports[path];
let rule = existingImports[path];
if (!rule && importedSymbols) {
rule = postcss.rule({
selector: `:import("${path}")`,
raws: { after: "\n" },
});
if (lastImportRule) {
root.insertAfter(lastImportRule, rule);
} else {
root.prepend(rule);
}
}
lastImportRule = rule;
if (!importedSymbols) {
return;
}
Object.keys(importedSymbols).forEach((importedSymbol) => {
rule.append(
postcss.decl({
value: importedSymbol,
prop: importedSymbols[importedSymbol],
raws: { before: "\n " },
})
);
});
});
},
};
},
};
};
src$2.exports.postcss = true;
const selectorParser = dist.exports;
const hasOwnProperty = Object.prototype.hasOwnProperty;
function getSingleLocalNamesForComposes(root) {
return root.nodes.map((node) => {
if (node.type !== "selector" || node.nodes.length !== 1) {
throw new Error(
`composition is only allowed when selector is single :local class name not in "${root}"`
);
}
node = node.nodes[0];
if (
node.type !== "pseudo" ||
node.value !== ":local" ||
node.nodes.length !== 1
) {
throw new Error(
'composition is only allowed when selector is single :local class name not in "' +
root +
'", "' +
node +
'" is weird'
);
}
node = node.first;
if (node.type !== "selector" || node.length !== 1) {
throw new Error(
'composition is only allowed when selector is single :local class name not in "' +
root +
'", "' +
node +
'" is weird'
);
}
node = node.first;
if (node.type !== "class") {
// 'id' is not possible, because you can't compose ids
throw new Error(
'composition is only allowed when selector is single :local class name not in "' +
root +
'", "' +
node +
'" is weird'
);
}
return node.value;
});
}
const whitespace = "[\\x20\\t\\r\\n\\f]";
const unescapeRegExp = new RegExp(
"\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)",
"ig"
);
function unescape(str) {
return str.replace(unescapeRegExp, (_, escaped, escapedWhitespace) => {
const high = "0x" + escaped - 0x10000;
// NaN means non-codepoint
// Workaround erroneous numeric interpretation of +"0x"
return high !== high || escapedWhitespace
? escaped
: high < 0
? // BMP codepoint
String.fromCharCode(high + 0x10000)
: // Supplemental Plane codepoint (surrogate pair)
String.fromCharCode((high >> 10) | 0xd800, (high & 0x3ff) | 0xdc00);
});
}
const plugin = (options = {}) => {
const generateScopedName =
(options && options.generateScopedName) || plugin.generateScopedName;
const generateExportEntry =
(options && options.generateExportEntry) || plugin.generateExportEntry;
const exportGlobals = options && options.exportGlobals;
return {
postcssPlugin: "postcss-modules-scope",
Once(root, { rule }) {
const exports = Object.create(null);
function exportScopedName(name, rawName) {
const scopedName = generateScopedName(
rawName ? rawName : name,
root.source.input.from,
root.source.input.css
);
const exportEntry = generateExportEntry(
rawName ? rawName : name,
scopedName,
root.source.input.from,
root.source.input.css
);
const { key, value } = exportEntry;
exports[key] = exports[key] || [];
if (exports[key].indexOf(value) < 0) {
exports[key].push(value);
}
return scopedName;
}
function localizeNode(node) {
switch (node.type) {
case "selector":
node.nodes = node.map(localizeNode);
return node;
case "class":
return selectorParser.className({
value: exportScopedName(
node.value,
node.raws && node.raws.value ? node.raws.value : null
),
});
case "id": {
return selectorParser.id({
value: exportScopedName(
node.value,
node.raws && node.raws.value ? node.raws.value : null
),
});
}
}
throw new Error(
`${node.type} ("${node}") is not allowed in a :local block`
);
}
function traverseNode(node) {
switch (node.type) {
case "pseudo":
if (node.value === ":local") {
if (node.nodes.length !== 1) {
throw new Error('Unexpected comma (",") in :local block');
}
const selector = localizeNode(node.first);
// move the spaces that were around the psuedo selector to the first
// non-container node
selector.first.spaces = node.spaces;
const nextNode = node.next();
if (
nextNode &&
nextNode.type === "combinator" &&
nextNode.value === " " &&
/\\[A-F0-9]{1,6}$/.test(selector.last.value)
) {
selector.last.spaces.after = " ";
}
node.replaceWith(selector);
return;
}
/* falls through */
case "root":
case "selector": {
node.each(traverseNode);
break;
}
case "id":
case "class":
if (exportGlobals) {
exports[node.value] = [node.value];
}
break;
}
return node;
}
// Find any :import and remember imported names
const importedNames = {};
root.walkRules(/^:import\(.+\)$/, (rule) => {
rule.walkDecls((decl) => {
importedNames[decl.prop] = true;
});
});
// Find any :local selectors
root.walkRules((rule) => {
let parsedSelector = selectorParser().astSync(rule);
rule.selector = traverseNode(parsedSelector.clone()).toString();
rule.walkDecls(/composes|compose-with/i, (decl) => {
const localNames = getSingleLocalNamesForComposes(parsedSelector);
const classes = decl.value.split(/\s+/);
classes.forEach((className) => {
const global = /^global\(([^)]+)\)$/.exec(className);
if (global) {
localNames.forEach((exportedName) => {
exports[exportedName].push(global[1]);
});
} else if (hasOwnProperty.call(importedNames, className)) {
localNames.forEach((exportedName) => {
exports[exportedName].push(className);
});
} else if (hasOwnProperty.call(exports, className)) {
localNames.forEach((exportedName) => {
exports[className].forEach((item) => {
exports[exportedName].push(item);
});
});
} else {
throw decl.error(
`referenced class name "${className}" in ${decl.prop} not found`
);
}
});
decl.remove();
});
// Find any :local values
rule.walkDecls((decl) => {
if (!/:local\s*\((.+?)\)/.test(decl.value)) {
return;
}
let tokens = decl.value.split(/(,|'[^']*'|"[^"]*")/);
tokens = tokens.map((token, idx) => {
if (idx === 0 || tokens[idx - 1] === ",") {
let result = token;
const localMatch = /:local\s*\((.+?)\)/.exec(token);
if (localMatch) {
const input = localMatch.input;
const matchPattern = localMatch[0];
const matchVal = localMatch[1];
const newVal = exportScopedName(matchVal);
result = input.replace(matchPattern, newVal);
} else {
return token;
}
return result;
} else {
return token;
}
});
decl.value = tokens.join("");
});
});
// Find any :local keyframes
root.walkAtRules(/keyframes$/i, (atRule) => {
const localMatch = /^\s*:local\s*\((.+?)\)\s*$/.exec(atRule.params);
if (!localMatch) {
return;
}
atRule.params = exportScopedName(localMatch[1]);
});
// If we found any :locals, insert an :export rule
const exportedNames = Object.keys(exports);
if (exportedNames.length > 0) {
const exportRule = rule({ selector: ":export" });
exportedNames.forEach((exportedName) =>
exportRule.append({
prop: exportedName,
value: exports[exportedName].join(" "),
raws: { before: "\n " },
})
);
root.append(exportRule);
}
},
};
};
plugin.postcss = true;
plugin.generateScopedName = function (name, path) {
const sanitisedPath = path
.replace(/\.[^./\\]+$/, "")
.replace(/[\W_]+/g, "_")
.replace(/^_|_$/g, "");
return `_${sanitisedPath}__${name}`.trim();
};
plugin.generateExportEntry = function (name, scopedName) {
return {
key: unescape(name),
value: unescape(scopedName),
};
};
var src$1 = plugin;
var src = {exports: {}};
const ICSSUtils = src$3;
const matchImports = /^(.+?|\([\s\S]+?\))\s+from\s+("[^"]*"|'[^']*'|[\w-]+)$/;
const matchValueDefinition = /(?:\s+|^)([\w-]+):?(.*?)$/;
const matchImport = /^([\w-]+)(?:\s+as\s+([\w-]+))?/;
src.exports = (options) => {
let importIndex = 0;
const createImportedName =
(options && options.createImportedName) ||
((importName /*, path*/) =>
`i__const_${importName.replace(/\W/g, "_")}_${importIndex++}`);
return {
postcssPlugin: "postcss-modules-values",
prepare(result) {
const importAliases = [];
const definitions = {};
return {
Once(root, postcss) {
root.walkAtRules(/value/i, (atRule) => {
const matches = atRule.params.match(matchImports);
if (matches) {
let [, /*match*/ aliases, path] = matches;
// We can use constants for path names
if (definitions[path]) {
path = definitions[path];
}
const imports = aliases
.replace(/^\(\s*([\s\S]+)\s*\)$/, "$1")
.split(/\s*,\s*/)
.map((alias) => {
const tokens = matchImport.exec(alias);
if (tokens) {
const [, /*match*/ theirName, myName = theirName] = tokens;
const importedName = createImportedName(myName);
definitions[myName] = importedName;
return { theirName, importedName };
} else {
throw new Error(`@import statement "${alias}" is invalid!`);
}
});
importAliases.push({ path, imports });
atRule.remove();
return;
}
if (atRule.params.indexOf("@value") !== -1) {
result.warn("Invalid value definition: " + atRule.params);
}
let [, key, value] = `${atRule.params}${atRule.raws.between}`.match(
matchValueDefinition
);
const normalizedValue = value.replace(/\/\*((?!\*\/).*?)\*\//g, "");
if (normalizedValue.length === 0) {
result.warn("Invalid value definition: " + atRule.params);
atRule.remove();
return;
}
let isOnlySpace = /^\s+$/.test(normalizedValue);
if (!isOnlySpace) {
value = value.trim();
}
// Add to the definitions, knowing that values can refer to each other
definitions[key] = ICSSUtils.replaceValueSymbols(
value,
definitions
);
atRule.remove();
});
/* If we have no definitions, don't continue */
if (!Object.keys(definitions).length) {
return;
}
/* Perform replacements */
ICSSUtils.replaceSymbols(root, definitions);
/* We want to export anything defined by now, but don't add it to the CSS yet or it well get picked up by the replacement stuff */
const exportDeclarations = Object.keys(definitions).map((key) =>
postcss.decl({
value: definitions[key],
prop: key,
raws: { before: "\n " },
})
);
/* Add export rules if any */
if (exportDeclarations.length > 0) {
const exportRule = postcss.rule({
selector: ":export",
raws: { after: "\n" },
});
exportRule.append(exportDeclarations);
root.prepend(exportRule);
}
/* Add import rules */
importAliases.reverse().forEach(({ path, imports }) => {
const importRule = postcss.rule({
selector: `:import(${path})`,
raws: { after: "\n" },
});
imports.forEach(({ theirName, importedName }) => {
importRule.append({
value: theirName,
prop: importedName,
raws: { before: "\n " },
});
});
root.prepend(importRule);
});
},
};
},
};
};
src.exports.postcss = true;
Object.defineProperty(behaviours$1, "__esModule", {
value: true
});
behaviours$1.behaviours = undefined;
behaviours$1.getDefaultPlugins = getDefaultPlugins;
behaviours$1.isValidBehaviour = isValidBehaviour;
var _postcssModulesLocalByDefault = src$4.exports;
var _postcssModulesLocalByDefault2 = _interopRequireDefault$1(_postcssModulesLocalByDefault);
var _postcssModulesExtractImports = src$2.exports;
var _postcssModulesExtractImports2 = _interopRequireDefault$1(_postcssModulesExtractImports);
var _postcssModulesScope = src$1;
var _postcssModulesScope2 = _interopRequireDefault$1(_postcssModulesScope);
var _postcssModulesValues = src.exports;
var _postcssModulesValues2 = _interopRequireDefault$1(_postcssModulesValues);
function _interopRequireDefault$1(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
const behaviours = behaviours$1.behaviours = {
LOCAL: "local",
GLOBAL: "global"
};
function getDefaultPlugins({
behaviour,
generateScopedName,
exportGlobals
}) {
const scope = (0, _postcssModulesScope2.default)({ generateScopedName, exportGlobals });
const plugins = {
[behaviours.LOCAL]: [_postcssModulesValues2.default, _postcssModulesLocalByDefault2.default, _postcssModulesExtractImports2.default, scope],
[behaviours.GLOBAL]: [_postcssModulesValues2.default, _postcssModulesExtractImports2.default, scope]
};
return plugins[behaviour];
}
function isValidBehaviour(behaviour) {
return Object.keys(behaviours).map(key => behaviours[key]).indexOf(behaviour) > -1;
}
var _postcss = require$$0__default;
var _postcss2 = _interopRequireDefault(_postcss);
var _lodash = lodash_camelcase;
var _lodash2 = _interopRequireDefault(_lodash);
var _genericNames = genericNames;
var _genericNames2 = _interopRequireDefault(_genericNames);
var _unquote = unquote$1;
var _unquote2 = _interopRequireDefault(_unquote);
var _parser = parser$1;
var _parser2 = _interopRequireDefault(_parser);
var _loader = loader;
var _loader2 = _interopRequireDefault(_loader);
var _generateScopedName = generateScopedName$1;
var _generateScopedName2 = _interopRequireDefault(_generateScopedName);
var _saveJSON = saveJSON$1;
var _saveJSON2 = _interopRequireDefault(_saveJSON);
var _behaviours = behaviours$1;
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
const PLUGIN_NAME = "postcss-modules";
function getDefaultScopeBehaviour(opts) {
if (opts.scopeBehaviour && (0, _behaviours.isValidBehaviour)(opts.scopeBehaviour)) {
return opts.scopeBehaviour;
}
return _behaviours.behaviours.LOCAL;
}
function getScopedNameGenerator(opts) {
const scopedNameGenerator = opts.generateScopedName || _generateScopedName2.default;
if (typeof scopedNameGenerator === "function") return scopedNameGenerator;
return (0, _genericNames2.default)(scopedNameGenerator, {
context: process.cwd(),
hashPrefix: opts.hashPrefix
});
}
function getLoader(opts, plugins) {
const root = typeof opts.root === "undefined" ? "/" : opts.root;
return typeof opts.Loader === "function" ? new opts.Loader(root, plugins) : new _loader2.default(root, plugins);
}
function isGlobalModule(globalModules, inputFile) {
return globalModules.some(regex => inputFile.match(regex));
}
function getDefaultPluginsList(opts, inputFile) {
const globalModulesList = opts.globalModulePaths || null;
const exportGlobals = opts.exportGlobals || false;
const defaultBehaviour = getDefaultScopeBehaviour(opts);
const generateScopedName = getScopedNameGenerator(opts);
if (globalModulesList && isGlobalModule(globalModulesList, inputFile)) {
return (0, _behaviours.getDefaultPlugins)({
behaviour: _behaviours.behaviours.GLOBAL,
generateScopedName,
exportGlobals
});
}
return (0, _behaviours.getDefaultPlugins)({
behaviour: defaultBehaviour,
generateScopedName,
exportGlobals
});
}
function isOurPlugin(plugin) {
return plugin.postcssPlugin === PLUGIN_NAME;
}
function dashesCamelCase(string) {
return string.replace(/-+(\w)/g, (_, firstLetter) => firstLetter.toUpperCase());
}
build$1.exports = (opts = {}) => {
return {
postcssPlugin: PLUGIN_NAME,
OnceExit(css, { result }) {
return _asyncToGenerator(function* () {
const getJSON = opts.getJSON || _saveJSON2.default;
const inputFile = css.source.input.file;
const pluginList = getDefaultPluginsList(opts, inputFile);
const resultPluginIndex = result.processor.plugins.findIndex(function (plugin) {
return isOurPlugin(plugin);
});
if (resultPluginIndex === -1) {
throw new Error('Plugin missing from options.');
}
const earlierPlugins = result.processor.plugins.slice(0, resultPluginIndex);
const loaderPlugins = [...earlierPlugins, ...pluginList];
const loader = getLoader(opts, loaderPlugins);
const fetcher = function fetcher(file, relativeTo, depTrace) {
const unquoteFile = (0, _unquote2.default)(file);
const resolvedResult = typeof opts.resolve === 'function' && opts.resolve(unquoteFile);
const resolvedFile = resolvedResult instanceof Promise ? resolvedResult : Promise.resolve(resolvedResult);
return resolvedFile.then(function (f) {
return loader.fetch.call(loader, `"${f || unquoteFile}"`, relativeTo, depTrace);
});
};
const parser = new _parser2.default(fetcher);
yield (0, _postcss2.default)([...pluginList, parser.plugin()]).process(css, {
from: inputFile
});
const out = loader.finalSource;
if (out) css.prepend(out);
if (opts.localsConvention) {
const isFunc = typeof opts.localsConvention === "function";
parser.exportTokens = Object.entries(parser.exportTokens).reduce(function (tokens, [className, value]) {
if (isFunc) {
tokens[opts.localsConvention(className, value, inputFile)] = value;
return tokens;
}
switch (opts.localsConvention) {
case "camelCase":
tokens[className] = value;
tokens[(0, _lodash2.default)(className)] = value;
break;
case "camelCaseOnly":
tokens[(0, _lodash2.default)(className)] = value;
break;
case "dashes":
tokens[className] = value;
tokens[dashesCamelCase(className)] = value;
break;
case "dashesOnly":
tokens[dashesCamelCase(className)] = value;
break;
}
return tokens;
}, {});
}
result.messages.push({
type: "export",
plugin: "postcss-modules",
exportTokens: parser.exportTokens
});
// getJSON may return a promise
return getJSON(css.source.input.file, parser.exportTokens, result.opts.to);
})();
}
};
};
var postcss = build$1.exports.postcss = true;
var build = build$1.exports;
var index = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(null), build$1.exports, {
'default': build,
postcss: postcss
});
exports.index = index;
//# sourceMappingURL=dep-afe9ad01.js.map