Spaces:
Runtime error
Runtime error
| import { commonjsGlobal, getDefaultExportFromCjs } from './index-f3183a9a.js'; | |
| import require$$0__default__default from 'fs'; | |
| import postcss$1 from './postcss-db2e39ff.js'; | |
| import require$$0$4 from 'path'; | |
| import require$$3$1 from 'crypto'; | |
| import require$$0$6 from 'util'; | |
| import { lib } from './dep-c423598f-00db75d5.js'; | |
| import { fileURLToPath } from 'node:url'; | |
| import { dirname } from 'node:path'; | |
| import { createRequire } from 'node:module'; | |
| import 'node:child_process'; | |
| import 'net'; | |
| import 'node:fs'; | |
| import 'node:fs/promises'; | |
| import 'node:util'; | |
| import 'node:perf_hooks'; | |
| import 'tty'; | |
| import 'esbuild-wasm'; | |
| import 'events'; | |
| import 'assert'; | |
| import 'url'; | |
| import 'http'; | |
| import 'stream'; | |
| import 'os'; | |
| import 'child_process'; | |
| import 'node:os'; | |
| import 'node:crypto'; | |
| import 'node:dns'; | |
| import 'node:buffer'; | |
| import 'module'; | |
| import 'node:assert'; | |
| import 'node:process'; | |
| import 'node:v8'; | |
| import 'worker_threads'; | |
| import 'zlib'; | |
| import 'buffer'; | |
| import 'https'; | |
| import 'tls'; | |
| import 'node:http'; | |
| import 'node:https'; | |
| import 'querystring'; | |
| import 'node:readline'; | |
| import 'node:zlib'; | |
| import '../compiler.js'; | |
| import 'fs/promises'; | |
| const __filename = fileURLToPath(import.meta.url); | |
| dirname(__filename); | |
| const require = createRequire(import.meta.url); | |
| function _mergeNamespaces(n, m) { | |
| for (var i = 0; i < m.length; i++) { | |
| var e = m[i]; | |
| if (typeof e !== 'string' && !Array.isArray(e)) { for (var k in e) { | |
| if (k !== 'default' && !(k in n)) { | |
| n[k] = e[k]; | |
| } | |
| } } | |
| } | |
| return n; | |
| } | |
| var build = {exports: {}}; | |
| var fs = {}; | |
| Object.defineProperty(fs, "__esModule", { | |
| value: true | |
| }); | |
| fs.getFileSystem = getFileSystem; | |
| fs.setFileSystem = setFileSystem; | |
| let fileSystem = { | |
| readFile: () => { | |
| throw Error("readFile not implemented"); | |
| }, | |
| writeFile: () => { | |
| throw Error("writeFile not implemented"); | |
| } | |
| }; | |
| function setFileSystem(fs) { | |
| fileSystem.readFile = fs.readFile; | |
| fileSystem.writeFile = fs.writeFile; | |
| } | |
| function getFileSystem() { | |
| return fileSystem; | |
| } | |
| var pluginFactory = {}; | |
| var unquote$1 = {}; | |
| Object.defineProperty(unquote$1, "__esModule", { | |
| value: true | |
| }); | |
| unquote$1.default = unquote; | |
| // copied from https://github.com/lakenen/node-unquote | |
| const 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 = {}; | |
| 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$4 = { | |
| replaceValueSymbols, | |
| replaceSymbols, | |
| extractICSS: extractICSS$1, | |
| createICSSRules, | |
| }; | |
| Object.defineProperty(Parser$1, "__esModule", { | |
| value: true | |
| }); | |
| Parser$1.default = void 0; | |
| var _icssUtils = src$4; | |
| // Initially 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", | |
| async OnceExit(css) { | |
| await Promise.all(parser.fetchAllImports(css)); | |
| parser.linkImportedSymbols(css); | |
| return 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, _icssUtils.replaceSymbols)(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(); | |
| } | |
| async fetchImport(importNode, relativeTo, depNr) { | |
| const file = importNode.selector.match(importRegexp)[1]; | |
| const depTrace = this.trace + String.fromCharCode(depNr); | |
| const exports = await this.pathFetcher(file, relativeTo, depTrace); | |
| try { | |
| importNode.each(decl => { | |
| if (decl.type == "decl") { | |
| this.translations[decl.prop] = exports[decl.value]; | |
| } | |
| }); | |
| importNode.remove(); | |
| } catch (err) { | |
| console.log(err); | |
| } | |
| } | |
| } | |
| Parser$1.default = Parser; | |
| var saveJSON$1 = {}; | |
| Object.defineProperty(saveJSON$1, "__esModule", { | |
| value: true | |
| }); | |
| saveJSON$1.default = saveJSON; | |
| var _fs$2 = fs; | |
| function saveJSON(cssFile, json) { | |
| return new Promise((resolve, reject) => { | |
| const { | |
| writeFile | |
| } = (0, _fs$2.getFileSystem)(); | |
| writeFile(`${cssFile}.json`, JSON.stringify(json), e => e ? reject(e) : resolve(json)); | |
| }); | |
| } | |
| var localsConvention = {}; | |
| /** | |
| * 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 commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && 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; | |
| Object.defineProperty(localsConvention, "__esModule", { | |
| value: true | |
| }); | |
| localsConvention.makeLocalsConventionReducer = makeLocalsConventionReducer; | |
| var _lodash = _interopRequireDefault$5(lodash_camelcase); | |
| function _interopRequireDefault$5(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| function dashesCamelCase(string) { | |
| return string.replace(/-+(\w)/g, (_, firstLetter) => firstLetter.toUpperCase()); | |
| } | |
| function makeLocalsConventionReducer(localsConvention, inputFile) { | |
| const isFunc = typeof localsConvention === "function"; | |
| return (tokens, [className, value]) => { | |
| if (isFunc) { | |
| const convention = localsConvention(className, value, inputFile); | |
| tokens[convention] = value; | |
| return tokens; | |
| } | |
| switch (localsConvention) { | |
| case "camelCase": | |
| tokens[className] = value; | |
| tokens[(0, _lodash.default)(className)] = value; | |
| break; | |
| case "camelCaseOnly": | |
| tokens[(0, _lodash.default)(className)] = value; | |
| break; | |
| case "dashes": | |
| tokens[className] = value; | |
| tokens[dashesCamelCase(className)] = value; | |
| break; | |
| case "dashesOnly": | |
| tokens[dashesCamelCase(className)] = value; | |
| break; | |
| } | |
| return tokens; | |
| }; | |
| } | |
| var FileSystemLoader$1 = {}; | |
| Object.defineProperty(FileSystemLoader$1, "__esModule", { | |
| value: true | |
| }); | |
| FileSystemLoader$1.default = void 0; | |
| var _postcss$1 = _interopRequireDefault$4(postcss$1); | |
| var _path = _interopRequireDefault$4(require$$0$4); | |
| var _Parser$1 = _interopRequireDefault$4(Parser$1); | |
| var _fs$1 = fs; | |
| function _interopRequireDefault$4(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| // Initially copied from https://github.com/css-modules/css-modules-loader-core | |
| class Core { | |
| constructor(plugins) { | |
| this.plugins = plugins || Core.defaultPlugins; | |
| } | |
| async load(sourceString, sourcePath, trace, pathFetcher) { | |
| const parser = new _Parser$1.default(pathFetcher, trace); | |
| const plugins = this.plugins.concat([parser.plugin()]); | |
| const result = await (0, _postcss$1.default)(plugins).process(sourceString, { | |
| from: sourcePath | |
| }); | |
| 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; | |
| } | |
| if (a.length > b.length) { | |
| return a.substring(0, b.length) <= b ? -1 : 1; | |
| } | |
| return a < b ? -1 : 1; | |
| }; | |
| class FileSystemLoader { | |
| constructor(root, plugins, fileResolve) { | |
| if (root === "/" && process.platform === "win32") { | |
| const cwdDrive = process.cwd().slice(0, 3); | |
| if (!/^[A-Za-z]:\\$/.test(cwdDrive)) { | |
| throw new Error(`Failed to obtain root from "${process.cwd()}".`); | |
| } | |
| root = cwdDrive; | |
| } | |
| this.root = root; | |
| this.fileResolve = fileResolve; | |
| this.sources = {}; | |
| this.traces = {}; | |
| this.importNr = 0; | |
| this.core = new Core(plugins); | |
| this.tokensByFile = {}; | |
| this.fs = (0, _fs$1.getFileSystem)(); | |
| } | |
| async fetch(_newPath, relativeTo, _trace) { | |
| const newPath = _newPath.replace(/^["']|["']$/g, ""); | |
| const trace = _trace || String.fromCharCode(this.importNr++); | |
| const useFileResolve = typeof this.fileResolve === "function"; | |
| const fileResolvedPath = useFileResolve ? await this.fileResolve(newPath, relativeTo) : await Promise.resolve(); | |
| if (fileResolvedPath && !_path.default.isAbsolute(fileResolvedPath)) { | |
| throw new Error('The returned path from the "fileResolve" option must be absolute.'); | |
| } | |
| const relativeDir = _path.default.dirname(relativeTo); | |
| const rootRelativePath = fileResolvedPath || _path.default.resolve(relativeDir, newPath); | |
| let fileRelativePath = fileResolvedPath || _path.default.resolve(_path.default.resolve(this.root, relativeDir), newPath); // if the path is not relative or absolute, try to resolve it in node_modules | |
| if (!useFileResolve && newPath[0] !== "." && !_path.default.isAbsolute(newPath)) { | |
| try { | |
| fileRelativePath = require.resolve(newPath); | |
| } catch (e) {// noop | |
| } | |
| } | |
| const tokens = this.tokensByFile[fileRelativePath]; | |
| if (tokens) return tokens; | |
| return new Promise((resolve, reject) => { | |
| this.fs.readFile(fileRelativePath, "utf-8", async (err, source) => { | |
| if (err) reject(err); | |
| const { | |
| injectableSource, | |
| exportTokens | |
| } = await this.core.load(source, rootRelativePath, trace, this.fetch.bind(this)); | |
| this.sources[fileRelativePath] = injectableSource; | |
| this.traces[trace] = fileRelativePath; | |
| this.tokensByFile[fileRelativePath] = exportTokens; | |
| resolve(exportTokens); | |
| }); | |
| }); | |
| } | |
| 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(""); | |
| } | |
| } | |
| FileSystemLoader$1.default = FileSystemLoader; | |
| var scoping = {}; | |
| var src$3 = {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$3.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$3.exports.postcss = true; | |
| var srcExports$2 = src$3.exports; | |
| var wasmHash = {exports: {}}; | |
| /* | |
| MIT License http://www.opensource.org/licenses/mit-license.php | |
| Author Tobias Koppers @sokra | |
| */ | |
| var hasRequiredWasmHash; | |
| function requireWasmHash () { | |
| if (hasRequiredWasmHash) return wasmHash.exports; | |
| hasRequiredWasmHash = 1; | |
| // 65536 is the size of a wasm memory page | |
| // 64 is the maximum chunk size for every possible wasm hash implementation | |
| // 4 is the maximum number of bytes per char for string encoding (max is utf-8) | |
| // ~3 makes sure that it's always a block of 4 chars, so avoid partially encoded bytes for base64 | |
| const MAX_SHORT_STRING = Math.floor((65536 - 64) / 4) & ~3; | |
| class WasmHash { | |
| /** | |
| * @param {WebAssembly.Instance} instance wasm instance | |
| * @param {WebAssembly.Instance[]} instancesPool pool of instances | |
| * @param {number} chunkSize size of data chunks passed to wasm | |
| * @param {number} digestSize size of digest returned by wasm | |
| */ | |
| constructor(instance, instancesPool, chunkSize, digestSize) { | |
| const exports = /** @type {any} */ (instance.exports); | |
| exports.init(); | |
| this.exports = exports; | |
| this.mem = Buffer.from(exports.memory.buffer, 0, 65536); | |
| this.buffered = 0; | |
| this.instancesPool = instancesPool; | |
| this.chunkSize = chunkSize; | |
| this.digestSize = digestSize; | |
| } | |
| reset() { | |
| this.buffered = 0; | |
| this.exports.init(); | |
| } | |
| /** | |
| * @param {Buffer | string} data data | |
| * @param {BufferEncoding=} encoding encoding | |
| * @returns {this} itself | |
| */ | |
| update(data, encoding) { | |
| if (typeof data === "string") { | |
| while (data.length > MAX_SHORT_STRING) { | |
| this._updateWithShortString(data.slice(0, MAX_SHORT_STRING), encoding); | |
| data = data.slice(MAX_SHORT_STRING); | |
| } | |
| this._updateWithShortString(data, encoding); | |
| return this; | |
| } | |
| this._updateWithBuffer(data); | |
| return this; | |
| } | |
| /** | |
| * @param {string} data data | |
| * @param {BufferEncoding=} encoding encoding | |
| * @returns {void} | |
| */ | |
| _updateWithShortString(data, encoding) { | |
| const { exports, buffered, mem, chunkSize } = this; | |
| let endPos; | |
| if (data.length < 70) { | |
| if (!encoding || encoding === "utf-8" || encoding === "utf8") { | |
| endPos = buffered; | |
| for (let i = 0; i < data.length; i++) { | |
| const cc = data.charCodeAt(i); | |
| if (cc < 0x80) { | |
| mem[endPos++] = cc; | |
| } else if (cc < 0x800) { | |
| mem[endPos] = (cc >> 6) | 0xc0; | |
| mem[endPos + 1] = (cc & 0x3f) | 0x80; | |
| endPos += 2; | |
| } else { | |
| // bail-out for weird chars | |
| endPos += mem.write(data.slice(i), endPos, encoding); | |
| break; | |
| } | |
| } | |
| } else if (encoding === "latin1") { | |
| endPos = buffered; | |
| for (let i = 0; i < data.length; i++) { | |
| const cc = data.charCodeAt(i); | |
| mem[endPos++] = cc; | |
| } | |
| } else { | |
| endPos = buffered + mem.write(data, buffered, encoding); | |
| } | |
| } else { | |
| endPos = buffered + mem.write(data, buffered, encoding); | |
| } | |
| if (endPos < chunkSize) { | |
| this.buffered = endPos; | |
| } else { | |
| const l = endPos & ~(this.chunkSize - 1); | |
| exports.update(l); | |
| const newBuffered = endPos - l; | |
| this.buffered = newBuffered; | |
| if (newBuffered > 0) { | |
| mem.copyWithin(0, l, endPos); | |
| } | |
| } | |
| } | |
| /** | |
| * @param {Buffer} data data | |
| * @returns {void} | |
| */ | |
| _updateWithBuffer(data) { | |
| const { exports, buffered, mem } = this; | |
| const length = data.length; | |
| if (buffered + length < this.chunkSize) { | |
| data.copy(mem, buffered, 0, length); | |
| this.buffered += length; | |
| } else { | |
| const l = (buffered + length) & ~(this.chunkSize - 1); | |
| if (l > 65536) { | |
| let i = 65536 - buffered; | |
| data.copy(mem, buffered, 0, i); | |
| exports.update(65536); | |
| const stop = l - buffered - 65536; | |
| while (i < stop) { | |
| data.copy(mem, 0, i, i + 65536); | |
| exports.update(65536); | |
| i += 65536; | |
| } | |
| data.copy(mem, 0, i, l - buffered); | |
| exports.update(l - buffered - i); | |
| } else { | |
| data.copy(mem, buffered, 0, l - buffered); | |
| exports.update(l); | |
| } | |
| const newBuffered = length + buffered - l; | |
| this.buffered = newBuffered; | |
| if (newBuffered > 0) { | |
| data.copy(mem, 0, length - newBuffered, length); | |
| } | |
| } | |
| } | |
| digest(type) { | |
| const { exports, buffered, mem, digestSize } = this; | |
| exports.final(buffered); | |
| this.instancesPool.push(this); | |
| const hex = mem.toString("latin1", 0, digestSize); | |
| if (type === "hex") { | |
| return hex; | |
| } | |
| if (type === "binary" || !type) { | |
| return Buffer.from(hex, "hex"); | |
| } | |
| return Buffer.from(hex, "hex").toString(type); | |
| } | |
| } | |
| const create = (wasmModule, instancesPool, chunkSize, digestSize) => { | |
| if (instancesPool.length > 0) { | |
| const old = instancesPool.pop(); | |
| old.reset(); | |
| return old; | |
| } else { | |
| return new WasmHash( | |
| new WebAssembly.Instance(wasmModule), | |
| instancesPool, | |
| chunkSize, | |
| digestSize | |
| ); | |
| } | |
| }; | |
| wasmHash.exports = create; | |
| wasmHash.exports.MAX_SHORT_STRING = MAX_SHORT_STRING; | |
| return wasmHash.exports; | |
| } | |
| /* | |
| MIT License http://www.opensource.org/licenses/mit-license.php | |
| Author Tobias Koppers @sokra | |
| */ | |
| var xxhash64_1; | |
| var hasRequiredXxhash64; | |
| function requireXxhash64 () { | |
| if (hasRequiredXxhash64) return xxhash64_1; | |
| hasRequiredXxhash64 = 1; | |
| const create = requireWasmHash(); | |
| //#region wasm code: xxhash64 (../../../assembly/hash/xxhash64.asm.ts) --initialMemory 1 | |
| const xxhash64 = new WebAssembly.Module( | |
| Buffer.from( | |
| // 1173 bytes | |
| "AGFzbQEAAAABCAJgAX8AYAAAAwQDAQAABQMBAAEGGgV+AUIAC34BQgALfgFCAAt+AUIAC34BQgALByIEBGluaXQAAAZ1cGRhdGUAAQVmaW5hbAACBm1lbW9yeQIACrUIAzAAQtbrgu7q/Yn14AAkAELP1tO+0ser2UIkAUIAJAJC+erQ0OfJoeThACQDQgAkBAvUAQIBfwR+IABFBEAPCyMEIACtfCQEIwAhAiMBIQMjAiEEIwMhBQNAIAIgASkDAELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiECIAMgASkDCELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEDIAQgASkDEELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEEIAUgASkDGELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEFIAAgAUEgaiIBSw0ACyACJAAgAyQBIAQkAiAFJAMLqwYCAX8EfiMEQgBSBH4jACICQgGJIwEiA0IHiXwjAiIEQgyJfCMDIgVCEol8IAJCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0gA0LP1tO+0ser2UJ+Qh+JQoeVr6+Ytt6bnn9+hUKHla+vmLbem55/fkKdo7Xqg7GNivoAfSAEQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IAVCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0FQsXP2bLx5brqJwsjBCAArXx8IQIDQCABQQhqIABNBEAgAiABKQMAQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQhuJQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IQIgAUEIaiEBDAELCyABQQRqIABNBEACfyACIAE1AgBCh5Wvr5i23puef36FQheJQs/W077Sx6vZQn5C+fPd8Zn2masWfCECIAFBBGoLIQELA0AgACABRwRAIAIgATEAAELFz9my8eW66id+hUILiUKHla+vmLbem55/fiECIAFBAWohAQwBCwtBACACIAJCIYiFQs/W077Sx6vZQn4iAiACQh2IhUL5893xmfaZqxZ+IgIgAkIgiIUiAkIgiCIDQv//A4NCIIYgA0KAgPz/D4NCEIiEIgNC/4GAgPAfg0IQhiADQoD+g4CA4D+DQgiIhCIDQo+AvIDwgcAHg0IIhiADQvCBwIeAnoD4AINCBIiEIgNChoyYsODAgYMGfEIEiEKBgoSIkKDAgAGDQid+IANCsODAgYOGjJgwhHw3AwBBCCACQv////8PgyICQv//A4NCIIYgAkKAgPz/D4NCEIiEIgJC/4GAgPAfg0IQhiACQoD+g4CA4D+DQgiIhCICQo+AvIDwgcAHg0IIhiACQvCBwIeAnoD4AINCBIiEIgJChoyYsODAgYMGfEIEiEKBgoSIkKDAgAGDQid+IAJCsODAgYOGjJgwhHw3AwAL", | |
| "base64" | |
| ) | |
| ); | |
| //#endregion | |
| xxhash64_1 = create.bind(null, xxhash64, [], 32, 16); | |
| return xxhash64_1; | |
| } | |
| var BatchedHash_1; | |
| var hasRequiredBatchedHash; | |
| function requireBatchedHash () { | |
| if (hasRequiredBatchedHash) return BatchedHash_1; | |
| hasRequiredBatchedHash = 1; | |
| const MAX_SHORT_STRING = requireWasmHash().MAX_SHORT_STRING; | |
| class BatchedHash { | |
| constructor(hash) { | |
| this.string = undefined; | |
| this.encoding = undefined; | |
| this.hash = hash; | |
| } | |
| /** | |
| * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding} | |
| * @param {string|Buffer} data data | |
| * @param {string=} inputEncoding data encoding | |
| * @returns {this} updated hash | |
| */ | |
| update(data, inputEncoding) { | |
| if (this.string !== undefined) { | |
| if ( | |
| typeof data === "string" && | |
| inputEncoding === this.encoding && | |
| this.string.length + data.length < MAX_SHORT_STRING | |
| ) { | |
| this.string += data; | |
| return this; | |
| } | |
| this.hash.update(this.string, this.encoding); | |
| this.string = undefined; | |
| } | |
| if (typeof data === "string") { | |
| if ( | |
| data.length < MAX_SHORT_STRING && | |
| // base64 encoding is not valid since it may contain padding chars | |
| (!inputEncoding || !inputEncoding.startsWith("ba")) | |
| ) { | |
| this.string = data; | |
| this.encoding = inputEncoding; | |
| } else { | |
| this.hash.update(data, inputEncoding); | |
| } | |
| } else { | |
| this.hash.update(data); | |
| } | |
| return this; | |
| } | |
| /** | |
| * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding} | |
| * @param {string=} encoding encoding of the return value | |
| * @returns {string|Buffer} digest | |
| */ | |
| digest(encoding) { | |
| if (this.string !== undefined) { | |
| this.hash.update(this.string, this.encoding); | |
| } | |
| return this.hash.digest(encoding); | |
| } | |
| } | |
| BatchedHash_1 = BatchedHash; | |
| return BatchedHash_1; | |
| } | |
| /* | |
| MIT License http://www.opensource.org/licenses/mit-license.php | |
| Author Tobias Koppers @sokra | |
| */ | |
| var md4_1; | |
| var hasRequiredMd4; | |
| function requireMd4 () { | |
| if (hasRequiredMd4) return md4_1; | |
| hasRequiredMd4 = 1; | |
| const create = requireWasmHash(); | |
| //#region wasm code: md4 (../../../assembly/hash/md4.asm.ts) --initialMemory 1 | |
| const md4 = new WebAssembly.Module( | |
| Buffer.from( | |
| // 2150 bytes | |
| "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", | |
| "base64" | |
| ) | |
| ); | |
| //#endregion | |
| md4_1 = create.bind(null, md4, [], 64, 32); | |
| return md4_1; | |
| } | |
| var BulkUpdateDecorator_1; | |
| var hasRequiredBulkUpdateDecorator; | |
| function requireBulkUpdateDecorator () { | |
| if (hasRequiredBulkUpdateDecorator) return BulkUpdateDecorator_1; | |
| hasRequiredBulkUpdateDecorator = 1; | |
| const BULK_SIZE = 2000; | |
| // We are using an object instead of a Map as this will stay static during the runtime | |
| // so access to it can be optimized by v8 | |
| const digestCaches = {}; | |
| class BulkUpdateDecorator { | |
| /** | |
| * @param {Hash | function(): Hash} hashOrFactory function to create a hash | |
| * @param {string=} hashKey key for caching | |
| */ | |
| constructor(hashOrFactory, hashKey) { | |
| this.hashKey = hashKey; | |
| if (typeof hashOrFactory === "function") { | |
| this.hashFactory = hashOrFactory; | |
| this.hash = undefined; | |
| } else { | |
| this.hashFactory = undefined; | |
| this.hash = hashOrFactory; | |
| } | |
| this.buffer = ""; | |
| } | |
| /** | |
| * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding} | |
| * @param {string|Buffer} data data | |
| * @param {string=} inputEncoding data encoding | |
| * @returns {this} updated hash | |
| */ | |
| update(data, inputEncoding) { | |
| if ( | |
| inputEncoding !== undefined || | |
| typeof data !== "string" || | |
| data.length > BULK_SIZE | |
| ) { | |
| if (this.hash === undefined) { | |
| this.hash = this.hashFactory(); | |
| } | |
| if (this.buffer.length > 0) { | |
| this.hash.update(this.buffer); | |
| this.buffer = ""; | |
| } | |
| this.hash.update(data, inputEncoding); | |
| } else { | |
| this.buffer += data; | |
| if (this.buffer.length > BULK_SIZE) { | |
| if (this.hash === undefined) { | |
| this.hash = this.hashFactory(); | |
| } | |
| this.hash.update(this.buffer); | |
| this.buffer = ""; | |
| } | |
| } | |
| return this; | |
| } | |
| /** | |
| * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding} | |
| * @param {string=} encoding encoding of the return value | |
| * @returns {string|Buffer} digest | |
| */ | |
| digest(encoding) { | |
| let digestCache; | |
| const buffer = this.buffer; | |
| if (this.hash === undefined) { | |
| // short data for hash, we can use caching | |
| const cacheKey = `${this.hashKey}-${encoding}`; | |
| digestCache = digestCaches[cacheKey]; | |
| if (digestCache === undefined) { | |
| digestCache = digestCaches[cacheKey] = new Map(); | |
| } | |
| const cacheEntry = digestCache.get(buffer); | |
| if (cacheEntry !== undefined) { | |
| return cacheEntry; | |
| } | |
| this.hash = this.hashFactory(); | |
| } | |
| if (buffer.length > 0) { | |
| this.hash.update(buffer); | |
| } | |
| const digestResult = this.hash.digest(encoding); | |
| if (digestCache !== undefined) { | |
| digestCache.set(buffer, digestResult); | |
| } | |
| return digestResult; | |
| } | |
| } | |
| BulkUpdateDecorator_1 = BulkUpdateDecorator; | |
| return BulkUpdateDecorator_1; | |
| } | |
| const baseEncodeTables = { | |
| 26: "abcdefghijklmnopqrstuvwxyz", | |
| 32: "123456789abcdefghjkmnpqrstuvwxyz", // no 0lio | |
| 36: "0123456789abcdefghijklmnopqrstuvwxyz", | |
| 49: "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ", // no lIO | |
| 52: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", | |
| 58: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ", // no 0lIO | |
| 62: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", | |
| 64: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_", | |
| }; | |
| /** | |
| * @param {Uint32Array} uint32Array Treated as a long base-0x100000000 number, little endian | |
| * @param {number} divisor The divisor | |
| * @return {number} Modulo (remainder) of the division | |
| */ | |
| function divmod32(uint32Array, divisor) { | |
| let carry = 0; | |
| for (let i = uint32Array.length - 1; i >= 0; i--) { | |
| const value = carry * 0x100000000 + uint32Array[i]; | |
| carry = value % divisor; | |
| uint32Array[i] = Math.floor(value / divisor); | |
| } | |
| return carry; | |
| } | |
| function encodeBufferToBase(buffer, base, length) { | |
| const encodeTable = baseEncodeTables[base]; | |
| if (!encodeTable) { | |
| throw new Error("Unknown encoding base" + base); | |
| } | |
| // Input bits are only enough to generate this many characters | |
| const limit = Math.ceil((buffer.length * 8) / Math.log2(base)); | |
| length = Math.min(length, limit); | |
| // Most of the crypto digests (if not all) has length a multiple of 4 bytes. | |
| // Fewer numbers in the array means faster math. | |
| const uint32Array = new Uint32Array(Math.ceil(buffer.length / 4)); | |
| // Make sure the input buffer data is copied and is not mutated by reference. | |
| // divmod32() would corrupt the BulkUpdateDecorator cache otherwise. | |
| buffer.copy(Buffer.from(uint32Array.buffer)); | |
| let output = ""; | |
| for (let i = 0; i < length; i++) { | |
| output = encodeTable[divmod32(uint32Array, base)] + output; | |
| } | |
| return output; | |
| } | |
| let crypto = undefined; | |
| let createXXHash64 = undefined; | |
| let createMd4 = undefined; | |
| let BatchedHash = undefined; | |
| let BulkUpdateDecorator = undefined; | |
| function getHashDigest$1(buffer, algorithm, digestType, maxLength) { | |
| algorithm = algorithm || "xxhash64"; | |
| maxLength = maxLength || 9999; | |
| let hash; | |
| if (algorithm === "xxhash64") { | |
| if (createXXHash64 === undefined) { | |
| createXXHash64 = requireXxhash64(); | |
| if (BatchedHash === undefined) { | |
| BatchedHash = requireBatchedHash(); | |
| } | |
| } | |
| hash = new BatchedHash(createXXHash64()); | |
| } else if (algorithm === "md4") { | |
| if (createMd4 === undefined) { | |
| createMd4 = requireMd4(); | |
| if (BatchedHash === undefined) { | |
| BatchedHash = requireBatchedHash(); | |
| } | |
| } | |
| hash = new BatchedHash(createMd4()); | |
| } else if (algorithm === "native-md4") { | |
| if (typeof crypto === "undefined") { | |
| crypto = require$$3$1; | |
| if (BulkUpdateDecorator === undefined) { | |
| BulkUpdateDecorator = requireBulkUpdateDecorator(); | |
| } | |
| } | |
| hash = new BulkUpdateDecorator(() => crypto.createHash("md4"), "md4"); | |
| } else { | |
| if (typeof crypto === "undefined") { | |
| crypto = require$$3$1; | |
| if (BulkUpdateDecorator === undefined) { | |
| BulkUpdateDecorator = requireBulkUpdateDecorator(); | |
| } | |
| } | |
| hash = new BulkUpdateDecorator( | |
| () => crypto.createHash(algorithm), | |
| algorithm | |
| ); | |
| } | |
| hash.update(buffer); | |
| if ( | |
| digestType === "base26" || | |
| digestType === "base32" || | |
| digestType === "base36" || | |
| digestType === "base49" || | |
| digestType === "base52" || | |
| digestType === "base58" || | |
| digestType === "base62" | |
| ) { | |
| return encodeBufferToBase(hash.digest(), digestType.substr(4), maxLength); | |
| } else { | |
| return hash.digest(digestType || "hex").substr(0, maxLength); | |
| } | |
| } | |
| var getHashDigest_1 = getHashDigest$1; | |
| const path$1 = require$$0$4; | |
| const getHashDigest = getHashDigest_1; | |
| function interpolateName$1(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(content, hashType, digestType, parseInt(maxLength, 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$1; | |
| var interpolateName = interpolateName_1; | |
| var path = require$$0$4; | |
| /** | |
| * @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, "/") + | |
| "\x00" + | |
| 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 src$2 = {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 unescExports = 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 getPropExports = 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 ensureObjectExports = 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)); | |
| var stripCommentsExports = stripComments.exports; | |
| util.__esModule = true; | |
| util.stripComments = util.ensureObject = util.getProp = util.unesc = void 0; | |
| var _unesc = _interopRequireDefault$3(unescExports); | |
| util.unesc = _unesc["default"]; | |
| var _getProp = _interopRequireDefault$3(getPropExports); | |
| util.getProp = _getProp["default"]; | |
| var _ensureObject = _interopRequireDefault$3(ensureObjectExports); | |
| util.ensureObject = _ensureObject["default"]; | |
| var _stripComments = _interopRequireDefault$3(stripCommentsExports); | |
| 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 nodeExports = 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(nodeExports); | |
| 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)); | |
| var containerExports = container.exports; | |
| (function (module, exports) { | |
| exports.__esModule = true; | |
| exports["default"] = void 0; | |
| var _container = _interopRequireDefault(containerExports); | |
| 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 rootExports = root$1.exports; | |
| var selector$1 = {exports: {}}; | |
| (function (module, exports) { | |
| exports.__esModule = true; | |
| exports["default"] = void 0; | |
| var _container = _interopRequireDefault(containerExports); | |
| 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 selectorExports = 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(nodeExports); | |
| 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 classNameExports = className$1.exports; | |
| var comment$2 = {exports: {}}; | |
| (function (module, exports) { | |
| exports.__esModule = true; | |
| exports["default"] = void 0; | |
| var _node = _interopRequireDefault(nodeExports); | |
| 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 commentExports = comment$2.exports; | |
| var id$1 = {exports: {}}; | |
| (function (module, exports) { | |
| exports.__esModule = true; | |
| exports["default"] = void 0; | |
| var _node = _interopRequireDefault(nodeExports); | |
| 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 idExports = 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(nodeExports); | |
| 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)); | |
| var namespaceExports = namespace.exports; | |
| (function (module, exports) { | |
| exports.__esModule = true; | |
| exports["default"] = void 0; | |
| var _namespace = _interopRequireDefault(namespaceExports); | |
| 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 tagExports = tag$1.exports; | |
| var string$1 = {exports: {}}; | |
| (function (module, exports) { | |
| exports.__esModule = true; | |
| exports["default"] = void 0; | |
| var _node = _interopRequireDefault(nodeExports); | |
| 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 stringExports = string$1.exports; | |
| var pseudo$1 = {exports: {}}; | |
| (function (module, exports) { | |
| exports.__esModule = true; | |
| exports["default"] = void 0; | |
| var _container = _interopRequireDefault(containerExports); | |
| 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 pseudoExports = pseudo$1.exports; | |
| var attribute$1 = {}; | |
| /** | |
| * For Node.js, simply re-export the core `util.deprecate` function. | |
| */ | |
| var node = require$$0$6.deprecate; | |
| (function (exports) { | |
| exports.__esModule = true; | |
| exports.unescapeValue = unescapeValue; | |
| exports["default"] = void 0; | |
| var _cssesc = _interopRequireDefault(cssesc_1); | |
| var _unesc = _interopRequireDefault(unescExports); | |
| var _namespace = _interopRequireDefault(namespaceExports); | |
| 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(namespaceExports); | |
| 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 universalExports = universal$1.exports; | |
| var combinator$2 = {exports: {}}; | |
| (function (module, exports) { | |
| exports.__esModule = true; | |
| exports["default"] = void 0; | |
| var _node = _interopRequireDefault(nodeExports); | |
| 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 combinatorExports = combinator$2.exports; | |
| var nesting$1 = {exports: {}}; | |
| (function (module, exports) { | |
| exports.__esModule = true; | |
| exports["default"] = void 0; | |
| var _node = _interopRequireDefault(nodeExports); | |
| 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 nestingExports = 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 sortAscendingExports = 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(rootExports); | |
| var _selector = _interopRequireDefault(selectorExports); | |
| var _className = _interopRequireDefault(classNameExports); | |
| var _comment = _interopRequireDefault(commentExports); | |
| var _id = _interopRequireDefault(idExports); | |
| var _tag = _interopRequireDefault(tagExports); | |
| var _string = _interopRequireDefault(stringExports); | |
| var _pseudo = _interopRequireDefault(pseudoExports); | |
| var _attribute = _interopRequireWildcard(attribute$1); | |
| var _universal = _interopRequireDefault(universalExports); | |
| var _combinator = _interopRequireDefault(combinatorExports); | |
| var _nesting = _interopRequireDefault(nestingExports); | |
| var _sortAscending = _interopRequireDefault(sortAscendingExports); | |
| 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) { | |
| // Allow escaped dot within class name | |
| var escapedDot = word[i - 1] === '\\'; // Allow decimal numbers percent in @keyframes | |
| var isKeyframesPercent = /^\d+\.\d+%$/.test(word); | |
| return !escapedDot && !isKeyframesPercent; | |
| }); | |
| 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)); | |
| var parserExports = parser.exports; | |
| (function (module, exports) { | |
| exports.__esModule = true; | |
| exports["default"] = void 0; | |
| var _parser = _interopRequireDefault(parserExports); | |
| 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 processorExports = 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(classNameExports); | |
| var _combinator = _interopRequireDefault$2(combinatorExports); | |
| var _comment = _interopRequireDefault$2(commentExports); | |
| var _id = _interopRequireDefault$2(idExports); | |
| var _nesting = _interopRequireDefault$2(nestingExports); | |
| var _pseudo = _interopRequireDefault$2(pseudoExports); | |
| var _root = _interopRequireDefault$2(rootExports); | |
| var _selector = _interopRequireDefault$2(selectorExports); | |
| var _string = _interopRequireDefault$2(stringExports); | |
| var _tag = _interopRequireDefault$2(tagExports); | |
| var _universal = _interopRequireDefault$2(universalExports); | |
| 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" || node.value.toLowerCase() === ":first-letter" || node.value.toLowerCase() === ":first-line"); | |
| } | |
| 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(processorExports); | |
| 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)); | |
| var distExports = dist.exports; | |
| const selectorParser$1 = distExports; | |
| const valueParser = lib; | |
| const { extractICSS } = src$4; | |
| 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$2.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$2.exports.postcss = true; | |
| var srcExports$1 = src$2.exports; | |
| const selectorParser = distExports; | |
| 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; | |
| 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; | |
| var src = {exports: {}}; | |
| const ICSSUtils = src$4; | |
| 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; | |
| var srcExports = src.exports; | |
| Object.defineProperty(scoping, "__esModule", { | |
| value: true | |
| }); | |
| scoping.behaviours = void 0; | |
| scoping.getDefaultPlugins = getDefaultPlugins; | |
| scoping.getDefaultScopeBehaviour = getDefaultScopeBehaviour; | |
| scoping.getScopedNameGenerator = getScopedNameGenerator; | |
| var _postcssModulesExtractImports = _interopRequireDefault$1(srcExports$2); | |
| var _genericNames = _interopRequireDefault$1(genericNames); | |
| var _postcssModulesLocalByDefault = _interopRequireDefault$1(srcExports$1); | |
| var _postcssModulesScope = _interopRequireDefault$1(src$1); | |
| var _stringHash = _interopRequireDefault$1(stringHash); | |
| var _postcssModulesValues = _interopRequireDefault$1(srcExports); | |
| function _interopRequireDefault$1(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| const behaviours = { | |
| LOCAL: "local", | |
| GLOBAL: "global" | |
| }; | |
| scoping.behaviours = behaviours; | |
| function getDefaultPlugins({ | |
| behaviour, | |
| generateScopedName, | |
| exportGlobals | |
| }) { | |
| const scope = (0, _postcssModulesScope.default)({ | |
| generateScopedName, | |
| exportGlobals | |
| }); | |
| const plugins = { | |
| [behaviours.LOCAL]: [_postcssModulesValues.default, (0, _postcssModulesLocalByDefault.default)({ | |
| mode: "local" | |
| }), _postcssModulesExtractImports.default, scope], | |
| [behaviours.GLOBAL]: [_postcssModulesValues.default, (0, _postcssModulesLocalByDefault.default)({ | |
| mode: "global" | |
| }), _postcssModulesExtractImports.default, scope] | |
| }; | |
| return plugins[behaviour]; | |
| } | |
| function isValidBehaviour(behaviour) { | |
| return Object.keys(behaviours).map(key => behaviours[key]).indexOf(behaviour) > -1; | |
| } | |
| function getDefaultScopeBehaviour(scopeBehaviour) { | |
| return scopeBehaviour && isValidBehaviour(scopeBehaviour) ? scopeBehaviour : behaviours.LOCAL; | |
| } | |
| function generateScopedNameDefault(name, filename, css) { | |
| const i = css.indexOf(`.${name}`); | |
| const lineNumber = css.substr(0, i).split(/[\r\n]/).length; | |
| const hash = (0, _stringHash.default)(css).toString(36).substr(0, 5); | |
| return `_${name}_${hash}_${lineNumber}`; | |
| } | |
| function getScopedNameGenerator(generateScopedName, hashPrefix) { | |
| const scopedNameGenerator = generateScopedName || generateScopedNameDefault; | |
| if (typeof scopedNameGenerator === "function") { | |
| return scopedNameGenerator; | |
| } | |
| return (0, _genericNames.default)(scopedNameGenerator, { | |
| context: process.cwd(), | |
| hashPrefix: hashPrefix | |
| }); | |
| } | |
| Object.defineProperty(pluginFactory, "__esModule", { | |
| value: true | |
| }); | |
| pluginFactory.makePlugin = makePlugin; | |
| var _postcss = _interopRequireDefault(postcss$1); | |
| var _unquote = _interopRequireDefault(unquote$1); | |
| var _Parser = _interopRequireDefault(Parser$1); | |
| var _saveJSON = _interopRequireDefault(saveJSON$1); | |
| var _localsConvention = localsConvention; | |
| var _FileSystemLoader = _interopRequireDefault(FileSystemLoader$1); | |
| var _scoping = scoping; | |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | |
| const PLUGIN_NAME = "postcss-modules"; | |
| 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 = (0, _scoping.getDefaultScopeBehaviour)(opts.scopeBehaviour); | |
| const generateScopedName = (0, _scoping.getScopedNameGenerator)(opts.generateScopedName, opts.hashPrefix); | |
| if (globalModulesList && isGlobalModule(globalModulesList, inputFile)) { | |
| return (0, _scoping.getDefaultPlugins)({ | |
| behaviour: _scoping.behaviours.GLOBAL, | |
| generateScopedName, | |
| exportGlobals | |
| }); | |
| } | |
| return (0, _scoping.getDefaultPlugins)({ | |
| behaviour: defaultBehaviour, | |
| generateScopedName, | |
| exportGlobals | |
| }); | |
| } | |
| function getLoader(opts, plugins) { | |
| const root = typeof opts.root === "undefined" ? "/" : opts.root; | |
| return typeof opts.Loader === "function" ? new opts.Loader(root, plugins, opts.resolve) : new _FileSystemLoader.default(root, plugins, opts.resolve); | |
| } | |
| function isOurPlugin(plugin) { | |
| return plugin.postcssPlugin === PLUGIN_NAME; | |
| } | |
| function makePlugin(opts) { | |
| return { | |
| postcssPlugin: PLUGIN_NAME, | |
| async OnceExit(css, { | |
| result | |
| }) { | |
| const getJSON = opts.getJSON || _saveJSON.default; | |
| const inputFile = css.source.input.file; | |
| const pluginList = getDefaultPluginsList(opts, inputFile); | |
| const resultPluginIndex = result.processor.plugins.findIndex(plugin => 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 = async (file, relativeTo, depTrace) => { | |
| const unquoteFile = (0, _unquote.default)(file); | |
| return loader.fetch.call(loader, unquoteFile, relativeTo, depTrace); | |
| }; | |
| const parser = new _Parser.default(fetcher); | |
| await (0, _postcss.default)([...pluginList, parser.plugin()]).process(css, { | |
| from: inputFile | |
| }); | |
| const out = loader.finalSource; | |
| if (out) css.prepend(out); | |
| if (opts.localsConvention) { | |
| const reducer = (0, _localsConvention.makeLocalsConventionReducer)(opts.localsConvention, inputFile); | |
| parser.exportTokens = Object.entries(parser.exportTokens).reduce(reducer, {}); | |
| } | |
| 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 _fs = require$$0__default__default; | |
| var _fs2 = fs; | |
| var _pluginFactory = pluginFactory; | |
| (0, _fs2.setFileSystem)({ | |
| readFile: _fs.readFile, | |
| writeFile: _fs.writeFile | |
| }); | |
| build.exports = (opts = {}) => (0, _pluginFactory.makePlugin)(opts); | |
| var postcss = build.exports.postcss = true; | |
| var buildExports = build.exports; | |
| var index = /*@__PURE__*/getDefaultExportFromCjs(buildExports); | |
| var index$1 = /*#__PURE__*/_mergeNamespaces({ | |
| __proto__: null, | |
| default: index, | |
| postcss: postcss | |
| }, [buildExports]); | |
| export { index$1 as i }; | |