3788 lines
119 KiB
JavaScript
3788 lines
119 KiB
JavaScript
import {
|
|
require_url
|
|
} from "./chunk-MPVQUUHK.js";
|
|
import {
|
|
require_fs
|
|
} from "./chunk-I5RSIQOR.js";
|
|
import {
|
|
require_path
|
|
} from "./chunk-4XRL7ZXG.js";
|
|
import {
|
|
__commonJS,
|
|
__toESM
|
|
} from "./chunk-ZSMWDLMK.js";
|
|
|
|
// node_modules/picocolors/picocolors.browser.js
|
|
var require_picocolors_browser = __commonJS({
|
|
"node_modules/picocolors/picocolors.browser.js"(exports, module) {
|
|
var x = String;
|
|
var create = function() {
|
|
return { isColorSupported: false, reset: x, bold: x, dim: x, italic: x, underline: x, inverse: x, hidden: x, strikethrough: x, black: x, red: x, green: x, yellow: x, blue: x, magenta: x, cyan: x, white: x, gray: x, bgBlack: x, bgRed: x, bgGreen: x, bgYellow: x, bgBlue: x, bgMagenta: x, bgCyan: x, bgWhite: x };
|
|
};
|
|
module.exports = create();
|
|
module.exports.createColors = create;
|
|
}
|
|
});
|
|
|
|
// (disabled):node_modules/postcss/lib/terminal-highlight
|
|
var require_terminal_highlight = __commonJS({
|
|
"(disabled):node_modules/postcss/lib/terminal-highlight"() {
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/css-syntax-error.js
|
|
var require_css_syntax_error = __commonJS({
|
|
"node_modules/postcss/lib/css-syntax-error.js"(exports, module) {
|
|
"use strict";
|
|
var pico = require_picocolors_browser();
|
|
var terminalHighlight = require_terminal_highlight();
|
|
var CssSyntaxError2 = class _CssSyntaxError extends Error {
|
|
constructor(message, line, column, source, file, plugin2) {
|
|
super(message);
|
|
this.name = "CssSyntaxError";
|
|
this.reason = message;
|
|
if (file) {
|
|
this.file = file;
|
|
}
|
|
if (source) {
|
|
this.source = source;
|
|
}
|
|
if (plugin2) {
|
|
this.plugin = plugin2;
|
|
}
|
|
if (typeof line !== "undefined" && typeof column !== "undefined") {
|
|
if (typeof line === "number") {
|
|
this.line = line;
|
|
this.column = column;
|
|
} else {
|
|
this.line = line.line;
|
|
this.column = line.column;
|
|
this.endLine = column.line;
|
|
this.endColumn = column.column;
|
|
}
|
|
}
|
|
this.setMessage();
|
|
if (Error.captureStackTrace) {
|
|
Error.captureStackTrace(this, _CssSyntaxError);
|
|
}
|
|
}
|
|
setMessage() {
|
|
this.message = this.plugin ? this.plugin + ": " : "";
|
|
this.message += this.file ? this.file : "<css input>";
|
|
if (typeof this.line !== "undefined") {
|
|
this.message += ":" + this.line + ":" + this.column;
|
|
}
|
|
this.message += ": " + this.reason;
|
|
}
|
|
showSourceCode(color) {
|
|
if (!this.source) return "";
|
|
let css = this.source;
|
|
if (color == null) color = pico.isColorSupported;
|
|
if (terminalHighlight) {
|
|
if (color) css = terminalHighlight(css);
|
|
}
|
|
let lines = css.split(/\r?\n/);
|
|
let start = Math.max(this.line - 3, 0);
|
|
let end = Math.min(this.line + 2, lines.length);
|
|
let maxWidth = String(end).length;
|
|
let mark, aside;
|
|
if (color) {
|
|
let { bold, gray, red } = pico.createColors(true);
|
|
mark = (text) => bold(red(text));
|
|
aside = (text) => gray(text);
|
|
} else {
|
|
mark = aside = (str) => str;
|
|
}
|
|
return lines.slice(start, end).map((line, index) => {
|
|
let number = start + 1 + index;
|
|
let gutter = " " + (" " + number).slice(-maxWidth) + " | ";
|
|
if (number === this.line) {
|
|
let spacing = aside(gutter.replace(/\d/g, " ")) + line.slice(0, this.column - 1).replace(/[^\t]/g, " ");
|
|
return mark(">") + aside(gutter) + line + "\n " + spacing + mark("^");
|
|
}
|
|
return " " + aside(gutter) + line;
|
|
}).join("\n");
|
|
}
|
|
toString() {
|
|
let code = this.showSourceCode();
|
|
if (code) {
|
|
code = "\n\n" + code + "\n";
|
|
}
|
|
return this.name + ": " + this.message + code;
|
|
}
|
|
};
|
|
module.exports = CssSyntaxError2;
|
|
CssSyntaxError2.default = CssSyntaxError2;
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/symbols.js
|
|
var require_symbols = __commonJS({
|
|
"node_modules/postcss/lib/symbols.js"(exports, module) {
|
|
"use strict";
|
|
module.exports.isClean = Symbol("isClean");
|
|
module.exports.my = Symbol("my");
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/stringifier.js
|
|
var require_stringifier = __commonJS({
|
|
"node_modules/postcss/lib/stringifier.js"(exports, module) {
|
|
"use strict";
|
|
var DEFAULT_RAW = {
|
|
after: "\n",
|
|
beforeClose: "\n",
|
|
beforeComment: "\n",
|
|
beforeDecl: "\n",
|
|
beforeOpen: " ",
|
|
beforeRule: "\n",
|
|
colon: ": ",
|
|
commentLeft: " ",
|
|
commentRight: " ",
|
|
emptyBody: "",
|
|
indent: " ",
|
|
semicolon: false
|
|
};
|
|
function capitalize(str) {
|
|
return str[0].toUpperCase() + str.slice(1);
|
|
}
|
|
var Stringifier = class {
|
|
constructor(builder) {
|
|
this.builder = builder;
|
|
}
|
|
atrule(node, semicolon) {
|
|
let name = "@" + node.name;
|
|
let params = node.params ? this.rawValue(node, "params") : "";
|
|
if (typeof node.raws.afterName !== "undefined") {
|
|
name += node.raws.afterName;
|
|
} else if (params) {
|
|
name += " ";
|
|
}
|
|
if (node.nodes) {
|
|
this.block(node, name + params);
|
|
} else {
|
|
let end = (node.raws.between || "") + (semicolon ? ";" : "");
|
|
this.builder(name + params + end, node);
|
|
}
|
|
}
|
|
beforeAfter(node, detect) {
|
|
let value;
|
|
if (node.type === "decl") {
|
|
value = this.raw(node, null, "beforeDecl");
|
|
} else if (node.type === "comment") {
|
|
value = this.raw(node, null, "beforeComment");
|
|
} else if (detect === "before") {
|
|
value = this.raw(node, null, "beforeRule");
|
|
} else {
|
|
value = this.raw(node, null, "beforeClose");
|
|
}
|
|
let buf = node.parent;
|
|
let depth = 0;
|
|
while (buf && buf.type !== "root") {
|
|
depth += 1;
|
|
buf = buf.parent;
|
|
}
|
|
if (value.includes("\n")) {
|
|
let indent = this.raw(node, null, "indent");
|
|
if (indent.length) {
|
|
for (let step = 0; step < depth; step++) value += indent;
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
block(node, start) {
|
|
let between = this.raw(node, "between", "beforeOpen");
|
|
this.builder(start + between + "{", node, "start");
|
|
let after;
|
|
if (node.nodes && node.nodes.length) {
|
|
this.body(node);
|
|
after = this.raw(node, "after");
|
|
} else {
|
|
after = this.raw(node, "after", "emptyBody");
|
|
}
|
|
if (after) this.builder(after);
|
|
this.builder("}", node, "end");
|
|
}
|
|
body(node) {
|
|
let last = node.nodes.length - 1;
|
|
while (last > 0) {
|
|
if (node.nodes[last].type !== "comment") break;
|
|
last -= 1;
|
|
}
|
|
let semicolon = this.raw(node, "semicolon");
|
|
for (let i = 0; i < node.nodes.length; i++) {
|
|
let child = node.nodes[i];
|
|
let before = this.raw(child, "before");
|
|
if (before) this.builder(before);
|
|
this.stringify(child, last !== i || semicolon);
|
|
}
|
|
}
|
|
comment(node) {
|
|
let left = this.raw(node, "left", "commentLeft");
|
|
let right = this.raw(node, "right", "commentRight");
|
|
this.builder("/*" + left + node.text + right + "*/", node);
|
|
}
|
|
decl(node, semicolon) {
|
|
let between = this.raw(node, "between", "colon");
|
|
let string = node.prop + between + this.rawValue(node, "value");
|
|
if (node.important) {
|
|
string += node.raws.important || " !important";
|
|
}
|
|
if (semicolon) string += ";";
|
|
this.builder(string, node);
|
|
}
|
|
document(node) {
|
|
this.body(node);
|
|
}
|
|
raw(node, own, detect) {
|
|
let value;
|
|
if (!detect) detect = own;
|
|
if (own) {
|
|
value = node.raws[own];
|
|
if (typeof value !== "undefined") return value;
|
|
}
|
|
let parent = node.parent;
|
|
if (detect === "before") {
|
|
if (!parent || parent.type === "root" && parent.first === node) {
|
|
return "";
|
|
}
|
|
if (parent && parent.type === "document") {
|
|
return "";
|
|
}
|
|
}
|
|
if (!parent) return DEFAULT_RAW[detect];
|
|
let root2 = node.root();
|
|
if (!root2.rawCache) root2.rawCache = {};
|
|
if (typeof root2.rawCache[detect] !== "undefined") {
|
|
return root2.rawCache[detect];
|
|
}
|
|
if (detect === "before" || detect === "after") {
|
|
return this.beforeAfter(node, detect);
|
|
} else {
|
|
let method = "raw" + capitalize(detect);
|
|
if (this[method]) {
|
|
value = this[method](root2, node);
|
|
} else {
|
|
root2.walk((i) => {
|
|
value = i.raws[own];
|
|
if (typeof value !== "undefined") return false;
|
|
});
|
|
}
|
|
}
|
|
if (typeof value === "undefined") value = DEFAULT_RAW[detect];
|
|
root2.rawCache[detect] = value;
|
|
return value;
|
|
}
|
|
rawBeforeClose(root2) {
|
|
let value;
|
|
root2.walk((i) => {
|
|
if (i.nodes && i.nodes.length > 0) {
|
|
if (typeof i.raws.after !== "undefined") {
|
|
value = i.raws.after;
|
|
if (value.includes("\n")) {
|
|
value = value.replace(/[^\n]+$/, "");
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
});
|
|
if (value) value = value.replace(/\S/g, "");
|
|
return value;
|
|
}
|
|
rawBeforeComment(root2, node) {
|
|
let value;
|
|
root2.walkComments((i) => {
|
|
if (typeof i.raws.before !== "undefined") {
|
|
value = i.raws.before;
|
|
if (value.includes("\n")) {
|
|
value = value.replace(/[^\n]+$/, "");
|
|
}
|
|
return false;
|
|
}
|
|
});
|
|
if (typeof value === "undefined") {
|
|
value = this.raw(node, null, "beforeDecl");
|
|
} else if (value) {
|
|
value = value.replace(/\S/g, "");
|
|
}
|
|
return value;
|
|
}
|
|
rawBeforeDecl(root2, node) {
|
|
let value;
|
|
root2.walkDecls((i) => {
|
|
if (typeof i.raws.before !== "undefined") {
|
|
value = i.raws.before;
|
|
if (value.includes("\n")) {
|
|
value = value.replace(/[^\n]+$/, "");
|
|
}
|
|
return false;
|
|
}
|
|
});
|
|
if (typeof value === "undefined") {
|
|
value = this.raw(node, null, "beforeRule");
|
|
} else if (value) {
|
|
value = value.replace(/\S/g, "");
|
|
}
|
|
return value;
|
|
}
|
|
rawBeforeOpen(root2) {
|
|
let value;
|
|
root2.walk((i) => {
|
|
if (i.type !== "decl") {
|
|
value = i.raws.between;
|
|
if (typeof value !== "undefined") return false;
|
|
}
|
|
});
|
|
return value;
|
|
}
|
|
rawBeforeRule(root2) {
|
|
let value;
|
|
root2.walk((i) => {
|
|
if (i.nodes && (i.parent !== root2 || root2.first !== i)) {
|
|
if (typeof i.raws.before !== "undefined") {
|
|
value = i.raws.before;
|
|
if (value.includes("\n")) {
|
|
value = value.replace(/[^\n]+$/, "");
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
});
|
|
if (value) value = value.replace(/\S/g, "");
|
|
return value;
|
|
}
|
|
rawColon(root2) {
|
|
let value;
|
|
root2.walkDecls((i) => {
|
|
if (typeof i.raws.between !== "undefined") {
|
|
value = i.raws.between.replace(/[^\s:]/g, "");
|
|
return false;
|
|
}
|
|
});
|
|
return value;
|
|
}
|
|
rawEmptyBody(root2) {
|
|
let value;
|
|
root2.walk((i) => {
|
|
if (i.nodes && i.nodes.length === 0) {
|
|
value = i.raws.after;
|
|
if (typeof value !== "undefined") return false;
|
|
}
|
|
});
|
|
return value;
|
|
}
|
|
rawIndent(root2) {
|
|
if (root2.raws.indent) return root2.raws.indent;
|
|
let value;
|
|
root2.walk((i) => {
|
|
let p = i.parent;
|
|
if (p && p !== root2 && p.parent && p.parent === root2) {
|
|
if (typeof i.raws.before !== "undefined") {
|
|
let parts = i.raws.before.split("\n");
|
|
value = parts[parts.length - 1];
|
|
value = value.replace(/\S/g, "");
|
|
return false;
|
|
}
|
|
}
|
|
});
|
|
return value;
|
|
}
|
|
rawSemicolon(root2) {
|
|
let value;
|
|
root2.walk((i) => {
|
|
if (i.nodes && i.nodes.length && i.last.type === "decl") {
|
|
value = i.raws.semicolon;
|
|
if (typeof value !== "undefined") return false;
|
|
}
|
|
});
|
|
return value;
|
|
}
|
|
rawValue(node, prop) {
|
|
let value = node[prop];
|
|
let raw = node.raws[prop];
|
|
if (raw && raw.value === value) {
|
|
return raw.raw;
|
|
}
|
|
return value;
|
|
}
|
|
root(node) {
|
|
this.body(node);
|
|
if (node.raws.after) this.builder(node.raws.after);
|
|
}
|
|
rule(node) {
|
|
this.block(node, this.rawValue(node, "selector"));
|
|
if (node.raws.ownSemicolon) {
|
|
this.builder(node.raws.ownSemicolon, node, "end");
|
|
}
|
|
}
|
|
stringify(node, semicolon) {
|
|
if (!this[node.type]) {
|
|
throw new Error(
|
|
"Unknown AST node type " + node.type + ". Maybe you need to change PostCSS stringifier."
|
|
);
|
|
}
|
|
this[node.type](node, semicolon);
|
|
}
|
|
};
|
|
module.exports = Stringifier;
|
|
Stringifier.default = Stringifier;
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/stringify.js
|
|
var require_stringify = __commonJS({
|
|
"node_modules/postcss/lib/stringify.js"(exports, module) {
|
|
"use strict";
|
|
var Stringifier = require_stringifier();
|
|
function stringify2(node, builder) {
|
|
let str = new Stringifier(builder);
|
|
str.stringify(node);
|
|
}
|
|
module.exports = stringify2;
|
|
stringify2.default = stringify2;
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/node.js
|
|
var require_node = __commonJS({
|
|
"node_modules/postcss/lib/node.js"(exports, module) {
|
|
"use strict";
|
|
var { isClean, my } = require_symbols();
|
|
var CssSyntaxError2 = require_css_syntax_error();
|
|
var Stringifier = require_stringifier();
|
|
var stringify2 = require_stringify();
|
|
function cloneNode(obj, parent) {
|
|
let cloned = new obj.constructor();
|
|
for (let i in obj) {
|
|
if (!Object.prototype.hasOwnProperty.call(obj, i)) {
|
|
continue;
|
|
}
|
|
if (i === "proxyCache") continue;
|
|
let value = obj[i];
|
|
let type = typeof value;
|
|
if (i === "parent" && type === "object") {
|
|
if (parent) cloned[i] = parent;
|
|
} else if (i === "source") {
|
|
cloned[i] = value;
|
|
} else if (Array.isArray(value)) {
|
|
cloned[i] = value.map((j) => cloneNode(j, cloned));
|
|
} else {
|
|
if (type === "object" && value !== null) value = cloneNode(value);
|
|
cloned[i] = value;
|
|
}
|
|
}
|
|
return cloned;
|
|
}
|
|
var Node2 = class {
|
|
constructor(defaults = {}) {
|
|
this.raws = {};
|
|
this[isClean] = false;
|
|
this[my] = true;
|
|
for (let name in defaults) {
|
|
if (name === "nodes") {
|
|
this.nodes = [];
|
|
for (let node of defaults[name]) {
|
|
if (typeof node.clone === "function") {
|
|
this.append(node.clone());
|
|
} else {
|
|
this.append(node);
|
|
}
|
|
}
|
|
} else {
|
|
this[name] = defaults[name];
|
|
}
|
|
}
|
|
}
|
|
addToError(error) {
|
|
error.postcssNode = this;
|
|
if (error.stack && this.source && /\n\s{4}at /.test(error.stack)) {
|
|
let s = this.source;
|
|
error.stack = error.stack.replace(
|
|
/\n\s{4}at /,
|
|
`$&${s.input.from}:${s.start.line}:${s.start.column}$&`
|
|
);
|
|
}
|
|
return error;
|
|
}
|
|
after(add) {
|
|
this.parent.insertAfter(this, add);
|
|
return this;
|
|
}
|
|
assign(overrides = {}) {
|
|
for (let name in overrides) {
|
|
this[name] = overrides[name];
|
|
}
|
|
return this;
|
|
}
|
|
before(add) {
|
|
this.parent.insertBefore(this, add);
|
|
return this;
|
|
}
|
|
cleanRaws(keepBetween) {
|
|
delete this.raws.before;
|
|
delete this.raws.after;
|
|
if (!keepBetween) delete this.raws.between;
|
|
}
|
|
clone(overrides = {}) {
|
|
let cloned = cloneNode(this);
|
|
for (let name in overrides) {
|
|
cloned[name] = overrides[name];
|
|
}
|
|
return cloned;
|
|
}
|
|
cloneAfter(overrides = {}) {
|
|
let cloned = this.clone(overrides);
|
|
this.parent.insertAfter(this, cloned);
|
|
return cloned;
|
|
}
|
|
cloneBefore(overrides = {}) {
|
|
let cloned = this.clone(overrides);
|
|
this.parent.insertBefore(this, cloned);
|
|
return cloned;
|
|
}
|
|
error(message, opts = {}) {
|
|
if (this.source) {
|
|
let { end, start } = this.rangeBy(opts);
|
|
return this.source.input.error(
|
|
message,
|
|
{ column: start.column, line: start.line },
|
|
{ column: end.column, line: end.line },
|
|
opts
|
|
);
|
|
}
|
|
return new CssSyntaxError2(message);
|
|
}
|
|
getProxyProcessor() {
|
|
return {
|
|
get(node, prop) {
|
|
if (prop === "proxyOf") {
|
|
return node;
|
|
} else if (prop === "root") {
|
|
return () => node.root().toProxy();
|
|
} else {
|
|
return node[prop];
|
|
}
|
|
},
|
|
set(node, prop, value) {
|
|
if (node[prop] === value) return true;
|
|
node[prop] = value;
|
|
if (prop === "prop" || prop === "value" || prop === "name" || prop === "params" || prop === "important" || /* c8 ignore next */
|
|
prop === "text") {
|
|
node.markDirty();
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
}
|
|
markDirty() {
|
|
if (this[isClean]) {
|
|
this[isClean] = false;
|
|
let next = this;
|
|
while (next = next.parent) {
|
|
next[isClean] = false;
|
|
}
|
|
}
|
|
}
|
|
next() {
|
|
if (!this.parent) return void 0;
|
|
let index = this.parent.index(this);
|
|
return this.parent.nodes[index + 1];
|
|
}
|
|
positionBy(opts, stringRepresentation) {
|
|
let pos = this.source.start;
|
|
if (opts.index) {
|
|
pos = this.positionInside(opts.index, stringRepresentation);
|
|
} else if (opts.word) {
|
|
stringRepresentation = this.toString();
|
|
let index = stringRepresentation.indexOf(opts.word);
|
|
if (index !== -1) pos = this.positionInside(index, stringRepresentation);
|
|
}
|
|
return pos;
|
|
}
|
|
positionInside(index, stringRepresentation) {
|
|
let string = stringRepresentation || this.toString();
|
|
let column = this.source.start.column;
|
|
let line = this.source.start.line;
|
|
for (let i = 0; i < index; i++) {
|
|
if (string[i] === "\n") {
|
|
column = 1;
|
|
line += 1;
|
|
} else {
|
|
column += 1;
|
|
}
|
|
}
|
|
return { column, line };
|
|
}
|
|
prev() {
|
|
if (!this.parent) return void 0;
|
|
let index = this.parent.index(this);
|
|
return this.parent.nodes[index - 1];
|
|
}
|
|
rangeBy(opts) {
|
|
let start = {
|
|
column: this.source.start.column,
|
|
line: this.source.start.line
|
|
};
|
|
let end = this.source.end ? {
|
|
column: this.source.end.column + 1,
|
|
line: this.source.end.line
|
|
} : {
|
|
column: start.column + 1,
|
|
line: start.line
|
|
};
|
|
if (opts.word) {
|
|
let stringRepresentation = this.toString();
|
|
let index = stringRepresentation.indexOf(opts.word);
|
|
if (index !== -1) {
|
|
start = this.positionInside(index, stringRepresentation);
|
|
end = this.positionInside(index + opts.word.length, stringRepresentation);
|
|
}
|
|
} else {
|
|
if (opts.start) {
|
|
start = {
|
|
column: opts.start.column,
|
|
line: opts.start.line
|
|
};
|
|
} else if (opts.index) {
|
|
start = this.positionInside(opts.index);
|
|
}
|
|
if (opts.end) {
|
|
end = {
|
|
column: opts.end.column,
|
|
line: opts.end.line
|
|
};
|
|
} else if (typeof opts.endIndex === "number") {
|
|
end = this.positionInside(opts.endIndex);
|
|
} else if (opts.index) {
|
|
end = this.positionInside(opts.index + 1);
|
|
}
|
|
}
|
|
if (end.line < start.line || end.line === start.line && end.column <= start.column) {
|
|
end = { column: start.column + 1, line: start.line };
|
|
}
|
|
return { end, start };
|
|
}
|
|
raw(prop, defaultType) {
|
|
let str = new Stringifier();
|
|
return str.raw(this, prop, defaultType);
|
|
}
|
|
remove() {
|
|
if (this.parent) {
|
|
this.parent.removeChild(this);
|
|
}
|
|
this.parent = void 0;
|
|
return this;
|
|
}
|
|
replaceWith(...nodes) {
|
|
if (this.parent) {
|
|
let bookmark = this;
|
|
let foundSelf = false;
|
|
for (let node of nodes) {
|
|
if (node === this) {
|
|
foundSelf = true;
|
|
} else if (foundSelf) {
|
|
this.parent.insertAfter(bookmark, node);
|
|
bookmark = node;
|
|
} else {
|
|
this.parent.insertBefore(bookmark, node);
|
|
}
|
|
}
|
|
if (!foundSelf) {
|
|
this.remove();
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
root() {
|
|
let result = this;
|
|
while (result.parent && result.parent.type !== "document") {
|
|
result = result.parent;
|
|
}
|
|
return result;
|
|
}
|
|
toJSON(_, inputs) {
|
|
let fixed = {};
|
|
let emitInputs = inputs == null;
|
|
inputs = inputs || /* @__PURE__ */ new Map();
|
|
let inputsNextIndex = 0;
|
|
for (let name in this) {
|
|
if (!Object.prototype.hasOwnProperty.call(this, name)) {
|
|
continue;
|
|
}
|
|
if (name === "parent" || name === "proxyCache") continue;
|
|
let value = this[name];
|
|
if (Array.isArray(value)) {
|
|
fixed[name] = value.map((i) => {
|
|
if (typeof i === "object" && i.toJSON) {
|
|
return i.toJSON(null, inputs);
|
|
} else {
|
|
return i;
|
|
}
|
|
});
|
|
} else if (typeof value === "object" && value.toJSON) {
|
|
fixed[name] = value.toJSON(null, inputs);
|
|
} else if (name === "source") {
|
|
let inputId = inputs.get(value.input);
|
|
if (inputId == null) {
|
|
inputId = inputsNextIndex;
|
|
inputs.set(value.input, inputsNextIndex);
|
|
inputsNextIndex++;
|
|
}
|
|
fixed[name] = {
|
|
end: value.end,
|
|
inputId,
|
|
start: value.start
|
|
};
|
|
} else {
|
|
fixed[name] = value;
|
|
}
|
|
}
|
|
if (emitInputs) {
|
|
fixed.inputs = [...inputs.keys()].map((input) => input.toJSON());
|
|
}
|
|
return fixed;
|
|
}
|
|
toProxy() {
|
|
if (!this.proxyCache) {
|
|
this.proxyCache = new Proxy(this, this.getProxyProcessor());
|
|
}
|
|
return this.proxyCache;
|
|
}
|
|
toString(stringifier = stringify2) {
|
|
if (stringifier.stringify) stringifier = stringifier.stringify;
|
|
let result = "";
|
|
stringifier(this, (i) => {
|
|
result += i;
|
|
});
|
|
return result;
|
|
}
|
|
warn(result, text, opts) {
|
|
let data = { node: this };
|
|
for (let i in opts) data[i] = opts[i];
|
|
return result.warn(text, data);
|
|
}
|
|
get proxyOf() {
|
|
return this;
|
|
}
|
|
};
|
|
module.exports = Node2;
|
|
Node2.default = Node2;
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/declaration.js
|
|
var require_declaration = __commonJS({
|
|
"node_modules/postcss/lib/declaration.js"(exports, module) {
|
|
"use strict";
|
|
var Node2 = require_node();
|
|
var Declaration2 = class extends Node2 {
|
|
constructor(defaults) {
|
|
if (defaults && typeof defaults.value !== "undefined" && typeof defaults.value !== "string") {
|
|
defaults = { ...defaults, value: String(defaults.value) };
|
|
}
|
|
super(defaults);
|
|
this.type = "decl";
|
|
}
|
|
get variable() {
|
|
return this.prop.startsWith("--") || this.prop[0] === "$";
|
|
}
|
|
};
|
|
module.exports = Declaration2;
|
|
Declaration2.default = Declaration2;
|
|
}
|
|
});
|
|
|
|
// browser-external:source-map-js
|
|
var require_source_map_js = __commonJS({
|
|
"browser-external:source-map-js"(exports, module) {
|
|
module.exports = Object.create(new Proxy({}, {
|
|
get(_, key) {
|
|
if (key !== "__esModule" && key !== "__proto__" && key !== "constructor" && key !== "splice") {
|
|
console.warn(`Module "source-map-js" has been externalized for browser compatibility. Cannot access "source-map-js.${key}" in client code. See https://vitejs.dev/guide/troubleshooting.html#module-externalized-for-browser-compatibility for more details.`);
|
|
}
|
|
}
|
|
}));
|
|
}
|
|
});
|
|
|
|
// node_modules/nanoid/non-secure/index.cjs
|
|
var require_non_secure = __commonJS({
|
|
"node_modules/nanoid/non-secure/index.cjs"(exports, module) {
|
|
var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
|
|
var customAlphabet = (alphabet, defaultSize = 21) => {
|
|
return (size = defaultSize) => {
|
|
let id = "";
|
|
let i = size;
|
|
while (i--) {
|
|
id += alphabet[Math.random() * alphabet.length | 0];
|
|
}
|
|
return id;
|
|
};
|
|
};
|
|
var nanoid = (size = 21) => {
|
|
let id = "";
|
|
let i = size;
|
|
while (i--) {
|
|
id += urlAlphabet[Math.random() * 64 | 0];
|
|
}
|
|
return id;
|
|
};
|
|
module.exports = { nanoid, customAlphabet };
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/previous-map.js
|
|
var require_previous_map = __commonJS({
|
|
"node_modules/postcss/lib/previous-map.js"(exports, module) {
|
|
"use strict";
|
|
var { SourceMapConsumer, SourceMapGenerator } = require_source_map_js();
|
|
var { existsSync, readFileSync } = require_fs();
|
|
var { dirname, join } = require_path();
|
|
function fromBase64(str) {
|
|
if (Buffer) {
|
|
return Buffer.from(str, "base64").toString();
|
|
} else {
|
|
return window.atob(str);
|
|
}
|
|
}
|
|
var PreviousMap = class {
|
|
constructor(css, opts) {
|
|
if (opts.map === false) return;
|
|
this.loadAnnotation(css);
|
|
this.inline = this.startWith(this.annotation, "data:");
|
|
let prev = opts.map ? opts.map.prev : void 0;
|
|
let text = this.loadMap(opts.from, prev);
|
|
if (!this.mapFile && opts.from) {
|
|
this.mapFile = opts.from;
|
|
}
|
|
if (this.mapFile) this.root = dirname(this.mapFile);
|
|
if (text) this.text = text;
|
|
}
|
|
consumer() {
|
|
if (!this.consumerCache) {
|
|
this.consumerCache = new SourceMapConsumer(this.text);
|
|
}
|
|
return this.consumerCache;
|
|
}
|
|
decodeInline(text) {
|
|
let baseCharsetUri = /^data:application\/json;charset=utf-?8;base64,/;
|
|
let baseUri = /^data:application\/json;base64,/;
|
|
let charsetUri = /^data:application\/json;charset=utf-?8,/;
|
|
let uri = /^data:application\/json,/;
|
|
if (charsetUri.test(text) || uri.test(text)) {
|
|
return decodeURIComponent(text.substr(RegExp.lastMatch.length));
|
|
}
|
|
if (baseCharsetUri.test(text) || baseUri.test(text)) {
|
|
return fromBase64(text.substr(RegExp.lastMatch.length));
|
|
}
|
|
let encoding = text.match(/data:application\/json;([^,]+),/)[1];
|
|
throw new Error("Unsupported source map encoding " + encoding);
|
|
}
|
|
getAnnotationURL(sourceMapString) {
|
|
return sourceMapString.replace(/^\/\*\s*# sourceMappingURL=/, "").trim();
|
|
}
|
|
isMap(map) {
|
|
if (typeof map !== "object") return false;
|
|
return typeof map.mappings === "string" || typeof map._mappings === "string" || Array.isArray(map.sections);
|
|
}
|
|
loadAnnotation(css) {
|
|
let comments = css.match(/\/\*\s*# sourceMappingURL=/gm);
|
|
if (!comments) return;
|
|
let start = css.lastIndexOf(comments.pop());
|
|
let end = css.indexOf("*/", start);
|
|
if (start > -1 && end > -1) {
|
|
this.annotation = this.getAnnotationURL(css.substring(start, end));
|
|
}
|
|
}
|
|
loadFile(path) {
|
|
this.root = dirname(path);
|
|
if (existsSync(path)) {
|
|
this.mapFile = path;
|
|
return readFileSync(path, "utf-8").toString().trim();
|
|
}
|
|
}
|
|
loadMap(file, prev) {
|
|
if (prev === false) return false;
|
|
if (prev) {
|
|
if (typeof prev === "string") {
|
|
return prev;
|
|
} else if (typeof prev === "function") {
|
|
let prevPath = prev(file);
|
|
if (prevPath) {
|
|
let map = this.loadFile(prevPath);
|
|
if (!map) {
|
|
throw new Error(
|
|
"Unable to load previous source map: " + prevPath.toString()
|
|
);
|
|
}
|
|
return map;
|
|
}
|
|
} else if (prev instanceof SourceMapConsumer) {
|
|
return SourceMapGenerator.fromSourceMap(prev).toString();
|
|
} else if (prev instanceof SourceMapGenerator) {
|
|
return prev.toString();
|
|
} else if (this.isMap(prev)) {
|
|
return JSON.stringify(prev);
|
|
} else {
|
|
throw new Error(
|
|
"Unsupported previous source map format: " + prev.toString()
|
|
);
|
|
}
|
|
} else if (this.inline) {
|
|
return this.decodeInline(this.annotation);
|
|
} else if (this.annotation) {
|
|
let map = this.annotation;
|
|
if (file) map = join(dirname(file), map);
|
|
return this.loadFile(map);
|
|
}
|
|
}
|
|
startWith(string, start) {
|
|
if (!string) return false;
|
|
return string.substr(0, start.length) === start;
|
|
}
|
|
withContent() {
|
|
return !!(this.consumer().sourcesContent && this.consumer().sourcesContent.length > 0);
|
|
}
|
|
};
|
|
module.exports = PreviousMap;
|
|
PreviousMap.default = PreviousMap;
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/input.js
|
|
var require_input = __commonJS({
|
|
"node_modules/postcss/lib/input.js"(exports, module) {
|
|
"use strict";
|
|
var { SourceMapConsumer, SourceMapGenerator } = require_source_map_js();
|
|
var { fileURLToPath, pathToFileURL } = require_url();
|
|
var { isAbsolute, resolve } = require_path();
|
|
var { nanoid } = require_non_secure();
|
|
var terminalHighlight = require_terminal_highlight();
|
|
var CssSyntaxError2 = require_css_syntax_error();
|
|
var PreviousMap = require_previous_map();
|
|
var fromOffsetCache = Symbol("fromOffsetCache");
|
|
var sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator);
|
|
var pathAvailable = Boolean(resolve && isAbsolute);
|
|
var Input2 = class {
|
|
constructor(css, opts = {}) {
|
|
if (css === null || typeof css === "undefined" || typeof css === "object" && !css.toString) {
|
|
throw new Error(`PostCSS received ${css} instead of CSS string`);
|
|
}
|
|
this.css = css.toString();
|
|
if (this.css[0] === "\uFEFF" || this.css[0] === "") {
|
|
this.hasBOM = true;
|
|
this.css = this.css.slice(1);
|
|
} else {
|
|
this.hasBOM = false;
|
|
}
|
|
if (opts.from) {
|
|
if (!pathAvailable || /^\w+:\/\//.test(opts.from) || isAbsolute(opts.from)) {
|
|
this.file = opts.from;
|
|
} else {
|
|
this.file = resolve(opts.from);
|
|
}
|
|
}
|
|
if (pathAvailable && sourceMapAvailable) {
|
|
let map = new PreviousMap(this.css, opts);
|
|
if (map.text) {
|
|
this.map = map;
|
|
let file = map.consumer().file;
|
|
if (!this.file && file) this.file = this.mapResolve(file);
|
|
}
|
|
}
|
|
if (!this.file) {
|
|
this.id = "<input css " + nanoid(6) + ">";
|
|
}
|
|
if (this.map) this.map.file = this.from;
|
|
}
|
|
error(message, line, column, opts = {}) {
|
|
let result, endLine, endColumn;
|
|
if (line && typeof line === "object") {
|
|
let start = line;
|
|
let end = column;
|
|
if (typeof start.offset === "number") {
|
|
let pos = this.fromOffset(start.offset);
|
|
line = pos.line;
|
|
column = pos.col;
|
|
} else {
|
|
line = start.line;
|
|
column = start.column;
|
|
}
|
|
if (typeof end.offset === "number") {
|
|
let pos = this.fromOffset(end.offset);
|
|
endLine = pos.line;
|
|
endColumn = pos.col;
|
|
} else {
|
|
endLine = end.line;
|
|
endColumn = end.column;
|
|
}
|
|
} else if (!column) {
|
|
let pos = this.fromOffset(line);
|
|
line = pos.line;
|
|
column = pos.col;
|
|
}
|
|
let origin = this.origin(line, column, endLine, endColumn);
|
|
if (origin) {
|
|
result = new CssSyntaxError2(
|
|
message,
|
|
origin.endLine === void 0 ? origin.line : { column: origin.column, line: origin.line },
|
|
origin.endLine === void 0 ? origin.column : { column: origin.endColumn, line: origin.endLine },
|
|
origin.source,
|
|
origin.file,
|
|
opts.plugin
|
|
);
|
|
} else {
|
|
result = new CssSyntaxError2(
|
|
message,
|
|
endLine === void 0 ? line : { column, line },
|
|
endLine === void 0 ? column : { column: endColumn, line: endLine },
|
|
this.css,
|
|
this.file,
|
|
opts.plugin
|
|
);
|
|
}
|
|
result.input = { column, endColumn, endLine, line, source: this.css };
|
|
if (this.file) {
|
|
if (pathToFileURL) {
|
|
result.input.url = pathToFileURL(this.file).toString();
|
|
}
|
|
result.input.file = this.file;
|
|
}
|
|
return result;
|
|
}
|
|
fromOffset(offset) {
|
|
let lastLine, lineToIndex;
|
|
if (!this[fromOffsetCache]) {
|
|
let lines = this.css.split("\n");
|
|
lineToIndex = new Array(lines.length);
|
|
let prevIndex = 0;
|
|
for (let i = 0, l = lines.length; i < l; i++) {
|
|
lineToIndex[i] = prevIndex;
|
|
prevIndex += lines[i].length + 1;
|
|
}
|
|
this[fromOffsetCache] = lineToIndex;
|
|
} else {
|
|
lineToIndex = this[fromOffsetCache];
|
|
}
|
|
lastLine = lineToIndex[lineToIndex.length - 1];
|
|
let min = 0;
|
|
if (offset >= lastLine) {
|
|
min = lineToIndex.length - 1;
|
|
} else {
|
|
let max = lineToIndex.length - 2;
|
|
let mid;
|
|
while (min < max) {
|
|
mid = min + (max - min >> 1);
|
|
if (offset < lineToIndex[mid]) {
|
|
max = mid - 1;
|
|
} else if (offset >= lineToIndex[mid + 1]) {
|
|
min = mid + 1;
|
|
} else {
|
|
min = mid;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return {
|
|
col: offset - lineToIndex[min] + 1,
|
|
line: min + 1
|
|
};
|
|
}
|
|
mapResolve(file) {
|
|
if (/^\w+:\/\//.test(file)) {
|
|
return file;
|
|
}
|
|
return resolve(this.map.consumer().sourceRoot || this.map.root || ".", file);
|
|
}
|
|
origin(line, column, endLine, endColumn) {
|
|
if (!this.map) return false;
|
|
let consumer = this.map.consumer();
|
|
let from = consumer.originalPositionFor({ column, line });
|
|
if (!from.source) return false;
|
|
let to;
|
|
if (typeof endLine === "number") {
|
|
to = consumer.originalPositionFor({ column: endColumn, line: endLine });
|
|
}
|
|
let fromUrl;
|
|
if (isAbsolute(from.source)) {
|
|
fromUrl = pathToFileURL(from.source);
|
|
} else {
|
|
fromUrl = new URL(
|
|
from.source,
|
|
this.map.consumer().sourceRoot || pathToFileURL(this.map.mapFile)
|
|
);
|
|
}
|
|
let result = {
|
|
column: from.column,
|
|
endColumn: to && to.column,
|
|
endLine: to && to.line,
|
|
line: from.line,
|
|
url: fromUrl.toString()
|
|
};
|
|
if (fromUrl.protocol === "file:") {
|
|
if (fileURLToPath) {
|
|
result.file = fileURLToPath(fromUrl);
|
|
} else {
|
|
throw new Error(`file: protocol is not available in this PostCSS build`);
|
|
}
|
|
}
|
|
let source = consumer.sourceContentFor(from.source);
|
|
if (source) result.source = source;
|
|
return result;
|
|
}
|
|
toJSON() {
|
|
let json = {};
|
|
for (let name of ["hasBOM", "css", "file", "id"]) {
|
|
if (this[name] != null) {
|
|
json[name] = this[name];
|
|
}
|
|
}
|
|
if (this.map) {
|
|
json.map = { ...this.map };
|
|
if (json.map.consumerCache) {
|
|
json.map.consumerCache = void 0;
|
|
}
|
|
}
|
|
return json;
|
|
}
|
|
get from() {
|
|
return this.file || this.id;
|
|
}
|
|
};
|
|
module.exports = Input2;
|
|
Input2.default = Input2;
|
|
if (terminalHighlight && terminalHighlight.registerInput) {
|
|
terminalHighlight.registerInput(Input2);
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/map-generator.js
|
|
var require_map_generator = __commonJS({
|
|
"node_modules/postcss/lib/map-generator.js"(exports, module) {
|
|
"use strict";
|
|
var { SourceMapConsumer, SourceMapGenerator } = require_source_map_js();
|
|
var { dirname, relative, resolve, sep } = require_path();
|
|
var { pathToFileURL } = require_url();
|
|
var Input2 = require_input();
|
|
var sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator);
|
|
var pathAvailable = Boolean(dirname && resolve && relative && sep);
|
|
var MapGenerator = class {
|
|
constructor(stringify2, root2, opts, cssString) {
|
|
this.stringify = stringify2;
|
|
this.mapOpts = opts.map || {};
|
|
this.root = root2;
|
|
this.opts = opts;
|
|
this.css = cssString;
|
|
this.originalCSS = cssString;
|
|
this.usesFileUrls = !this.mapOpts.from && this.mapOpts.absolute;
|
|
this.memoizedFileURLs = /* @__PURE__ */ new Map();
|
|
this.memoizedPaths = /* @__PURE__ */ new Map();
|
|
this.memoizedURLs = /* @__PURE__ */ new Map();
|
|
}
|
|
addAnnotation() {
|
|
let content;
|
|
if (this.isInline()) {
|
|
content = "data:application/json;base64," + this.toBase64(this.map.toString());
|
|
} else if (typeof this.mapOpts.annotation === "string") {
|
|
content = this.mapOpts.annotation;
|
|
} else if (typeof this.mapOpts.annotation === "function") {
|
|
content = this.mapOpts.annotation(this.opts.to, this.root);
|
|
} else {
|
|
content = this.outputFile() + ".map";
|
|
}
|
|
let eol = "\n";
|
|
if (this.css.includes("\r\n")) eol = "\r\n";
|
|
this.css += eol + "/*# sourceMappingURL=" + content + " */";
|
|
}
|
|
applyPrevMaps() {
|
|
for (let prev of this.previous()) {
|
|
let from = this.toUrl(this.path(prev.file));
|
|
let root2 = prev.root || dirname(prev.file);
|
|
let map;
|
|
if (this.mapOpts.sourcesContent === false) {
|
|
map = new SourceMapConsumer(prev.text);
|
|
if (map.sourcesContent) {
|
|
map.sourcesContent = null;
|
|
}
|
|
} else {
|
|
map = prev.consumer();
|
|
}
|
|
this.map.applySourceMap(map, from, this.toUrl(this.path(root2)));
|
|
}
|
|
}
|
|
clearAnnotation() {
|
|
if (this.mapOpts.annotation === false) return;
|
|
if (this.root) {
|
|
let node;
|
|
for (let i = this.root.nodes.length - 1; i >= 0; i--) {
|
|
node = this.root.nodes[i];
|
|
if (node.type !== "comment") continue;
|
|
if (node.text.indexOf("# sourceMappingURL=") === 0) {
|
|
this.root.removeChild(i);
|
|
}
|
|
}
|
|
} else if (this.css) {
|
|
this.css = this.css.replace(/\n*?\/\*#[\S\s]*?\*\/$/gm, "");
|
|
}
|
|
}
|
|
generate() {
|
|
this.clearAnnotation();
|
|
if (pathAvailable && sourceMapAvailable && this.isMap()) {
|
|
return this.generateMap();
|
|
} else {
|
|
let result = "";
|
|
this.stringify(this.root, (i) => {
|
|
result += i;
|
|
});
|
|
return [result];
|
|
}
|
|
}
|
|
generateMap() {
|
|
if (this.root) {
|
|
this.generateString();
|
|
} else if (this.previous().length === 1) {
|
|
let prev = this.previous()[0].consumer();
|
|
prev.file = this.outputFile();
|
|
this.map = SourceMapGenerator.fromSourceMap(prev, {
|
|
ignoreInvalidMapping: true
|
|
});
|
|
} else {
|
|
this.map = new SourceMapGenerator({
|
|
file: this.outputFile(),
|
|
ignoreInvalidMapping: true
|
|
});
|
|
this.map.addMapping({
|
|
generated: { column: 0, line: 1 },
|
|
original: { column: 0, line: 1 },
|
|
source: this.opts.from ? this.toUrl(this.path(this.opts.from)) : "<no source>"
|
|
});
|
|
}
|
|
if (this.isSourcesContent()) this.setSourcesContent();
|
|
if (this.root && this.previous().length > 0) this.applyPrevMaps();
|
|
if (this.isAnnotation()) this.addAnnotation();
|
|
if (this.isInline()) {
|
|
return [this.css];
|
|
} else {
|
|
return [this.css, this.map];
|
|
}
|
|
}
|
|
generateString() {
|
|
this.css = "";
|
|
this.map = new SourceMapGenerator({
|
|
file: this.outputFile(),
|
|
ignoreInvalidMapping: true
|
|
});
|
|
let line = 1;
|
|
let column = 1;
|
|
let noSource = "<no source>";
|
|
let mapping = {
|
|
generated: { column: 0, line: 0 },
|
|
original: { column: 0, line: 0 },
|
|
source: ""
|
|
};
|
|
let lines, last;
|
|
this.stringify(this.root, (str, node, type) => {
|
|
this.css += str;
|
|
if (node && type !== "end") {
|
|
mapping.generated.line = line;
|
|
mapping.generated.column = column - 1;
|
|
if (node.source && node.source.start) {
|
|
mapping.source = this.sourcePath(node);
|
|
mapping.original.line = node.source.start.line;
|
|
mapping.original.column = node.source.start.column - 1;
|
|
this.map.addMapping(mapping);
|
|
} else {
|
|
mapping.source = noSource;
|
|
mapping.original.line = 1;
|
|
mapping.original.column = 0;
|
|
this.map.addMapping(mapping);
|
|
}
|
|
}
|
|
lines = str.match(/\n/g);
|
|
if (lines) {
|
|
line += lines.length;
|
|
last = str.lastIndexOf("\n");
|
|
column = str.length - last;
|
|
} else {
|
|
column += str.length;
|
|
}
|
|
if (node && type !== "start") {
|
|
let p = node.parent || { raws: {} };
|
|
let childless = node.type === "decl" || node.type === "atrule" && !node.nodes;
|
|
if (!childless || node !== p.last || p.raws.semicolon) {
|
|
if (node.source && node.source.end) {
|
|
mapping.source = this.sourcePath(node);
|
|
mapping.original.line = node.source.end.line;
|
|
mapping.original.column = node.source.end.column - 1;
|
|
mapping.generated.line = line;
|
|
mapping.generated.column = column - 2;
|
|
this.map.addMapping(mapping);
|
|
} else {
|
|
mapping.source = noSource;
|
|
mapping.original.line = 1;
|
|
mapping.original.column = 0;
|
|
mapping.generated.line = line;
|
|
mapping.generated.column = column - 1;
|
|
this.map.addMapping(mapping);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
isAnnotation() {
|
|
if (this.isInline()) {
|
|
return true;
|
|
}
|
|
if (typeof this.mapOpts.annotation !== "undefined") {
|
|
return this.mapOpts.annotation;
|
|
}
|
|
if (this.previous().length) {
|
|
return this.previous().some((i) => i.annotation);
|
|
}
|
|
return true;
|
|
}
|
|
isInline() {
|
|
if (typeof this.mapOpts.inline !== "undefined") {
|
|
return this.mapOpts.inline;
|
|
}
|
|
let annotation = this.mapOpts.annotation;
|
|
if (typeof annotation !== "undefined" && annotation !== true) {
|
|
return false;
|
|
}
|
|
if (this.previous().length) {
|
|
return this.previous().some((i) => i.inline);
|
|
}
|
|
return true;
|
|
}
|
|
isMap() {
|
|
if (typeof this.opts.map !== "undefined") {
|
|
return !!this.opts.map;
|
|
}
|
|
return this.previous().length > 0;
|
|
}
|
|
isSourcesContent() {
|
|
if (typeof this.mapOpts.sourcesContent !== "undefined") {
|
|
return this.mapOpts.sourcesContent;
|
|
}
|
|
if (this.previous().length) {
|
|
return this.previous().some((i) => i.withContent());
|
|
}
|
|
return true;
|
|
}
|
|
outputFile() {
|
|
if (this.opts.to) {
|
|
return this.path(this.opts.to);
|
|
} else if (this.opts.from) {
|
|
return this.path(this.opts.from);
|
|
} else {
|
|
return "to.css";
|
|
}
|
|
}
|
|
path(file) {
|
|
if (this.mapOpts.absolute) return file;
|
|
if (file.charCodeAt(0) === 60) return file;
|
|
if (/^\w+:\/\//.test(file)) return file;
|
|
let cached = this.memoizedPaths.get(file);
|
|
if (cached) return cached;
|
|
let from = this.opts.to ? dirname(this.opts.to) : ".";
|
|
if (typeof this.mapOpts.annotation === "string") {
|
|
from = dirname(resolve(from, this.mapOpts.annotation));
|
|
}
|
|
let path = relative(from, file);
|
|
this.memoizedPaths.set(file, path);
|
|
return path;
|
|
}
|
|
previous() {
|
|
if (!this.previousMaps) {
|
|
this.previousMaps = [];
|
|
if (this.root) {
|
|
this.root.walk((node) => {
|
|
if (node.source && node.source.input.map) {
|
|
let map = node.source.input.map;
|
|
if (!this.previousMaps.includes(map)) {
|
|
this.previousMaps.push(map);
|
|
}
|
|
}
|
|
});
|
|
} else {
|
|
let input = new Input2(this.originalCSS, this.opts);
|
|
if (input.map) this.previousMaps.push(input.map);
|
|
}
|
|
}
|
|
return this.previousMaps;
|
|
}
|
|
setSourcesContent() {
|
|
let already = {};
|
|
if (this.root) {
|
|
this.root.walk((node) => {
|
|
if (node.source) {
|
|
let from = node.source.input.from;
|
|
if (from && !already[from]) {
|
|
already[from] = true;
|
|
let fromUrl = this.usesFileUrls ? this.toFileUrl(from) : this.toUrl(this.path(from));
|
|
this.map.setSourceContent(fromUrl, node.source.input.css);
|
|
}
|
|
}
|
|
});
|
|
} else if (this.css) {
|
|
let from = this.opts.from ? this.toUrl(this.path(this.opts.from)) : "<no source>";
|
|
this.map.setSourceContent(from, this.css);
|
|
}
|
|
}
|
|
sourcePath(node) {
|
|
if (this.mapOpts.from) {
|
|
return this.toUrl(this.mapOpts.from);
|
|
} else if (this.usesFileUrls) {
|
|
return this.toFileUrl(node.source.input.from);
|
|
} else {
|
|
return this.toUrl(this.path(node.source.input.from));
|
|
}
|
|
}
|
|
toBase64(str) {
|
|
if (Buffer) {
|
|
return Buffer.from(str).toString("base64");
|
|
} else {
|
|
return window.btoa(unescape(encodeURIComponent(str)));
|
|
}
|
|
}
|
|
toFileUrl(path) {
|
|
let cached = this.memoizedFileURLs.get(path);
|
|
if (cached) return cached;
|
|
if (pathToFileURL) {
|
|
let fileURL = pathToFileURL(path).toString();
|
|
this.memoizedFileURLs.set(path, fileURL);
|
|
return fileURL;
|
|
} else {
|
|
throw new Error(
|
|
"`map.absolute` option is not available in this PostCSS build"
|
|
);
|
|
}
|
|
}
|
|
toUrl(path) {
|
|
let cached = this.memoizedURLs.get(path);
|
|
if (cached) return cached;
|
|
if (sep === "\\") {
|
|
path = path.replace(/\\/g, "/");
|
|
}
|
|
let url = encodeURI(path).replace(/[#?]/g, encodeURIComponent);
|
|
this.memoizedURLs.set(path, url);
|
|
return url;
|
|
}
|
|
};
|
|
module.exports = MapGenerator;
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/comment.js
|
|
var require_comment = __commonJS({
|
|
"node_modules/postcss/lib/comment.js"(exports, module) {
|
|
"use strict";
|
|
var Node2 = require_node();
|
|
var Comment2 = class extends Node2 {
|
|
constructor(defaults) {
|
|
super(defaults);
|
|
this.type = "comment";
|
|
}
|
|
};
|
|
module.exports = Comment2;
|
|
Comment2.default = Comment2;
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/container.js
|
|
var require_container = __commonJS({
|
|
"node_modules/postcss/lib/container.js"(exports, module) {
|
|
"use strict";
|
|
var { isClean, my } = require_symbols();
|
|
var Declaration2 = require_declaration();
|
|
var Comment2 = require_comment();
|
|
var Node2 = require_node();
|
|
var parse2;
|
|
var Rule2;
|
|
var AtRule2;
|
|
var Root2;
|
|
function cleanSource(nodes) {
|
|
return nodes.map((i) => {
|
|
if (i.nodes) i.nodes = cleanSource(i.nodes);
|
|
delete i.source;
|
|
return i;
|
|
});
|
|
}
|
|
function markTreeDirty(node) {
|
|
node[isClean] = false;
|
|
if (node.proxyOf.nodes) {
|
|
for (let i of node.proxyOf.nodes) {
|
|
markTreeDirty(i);
|
|
}
|
|
}
|
|
}
|
|
var Container2 = class _Container extends Node2 {
|
|
append(...children) {
|
|
for (let child of children) {
|
|
let nodes = this.normalize(child, this.last);
|
|
for (let node of nodes) this.proxyOf.nodes.push(node);
|
|
}
|
|
this.markDirty();
|
|
return this;
|
|
}
|
|
cleanRaws(keepBetween) {
|
|
super.cleanRaws(keepBetween);
|
|
if (this.nodes) {
|
|
for (let node of this.nodes) node.cleanRaws(keepBetween);
|
|
}
|
|
}
|
|
each(callback) {
|
|
if (!this.proxyOf.nodes) return void 0;
|
|
let iterator = this.getIterator();
|
|
let index, result;
|
|
while (this.indexes[iterator] < this.proxyOf.nodes.length) {
|
|
index = this.indexes[iterator];
|
|
result = callback(this.proxyOf.nodes[index], index);
|
|
if (result === false) break;
|
|
this.indexes[iterator] += 1;
|
|
}
|
|
delete this.indexes[iterator];
|
|
return result;
|
|
}
|
|
every(condition) {
|
|
return this.nodes.every(condition);
|
|
}
|
|
getIterator() {
|
|
if (!this.lastEach) this.lastEach = 0;
|
|
if (!this.indexes) this.indexes = {};
|
|
this.lastEach += 1;
|
|
let iterator = this.lastEach;
|
|
this.indexes[iterator] = 0;
|
|
return iterator;
|
|
}
|
|
getProxyProcessor() {
|
|
return {
|
|
get(node, prop) {
|
|
if (prop === "proxyOf") {
|
|
return node;
|
|
} else if (!node[prop]) {
|
|
return node[prop];
|
|
} else if (prop === "each" || typeof prop === "string" && prop.startsWith("walk")) {
|
|
return (...args) => {
|
|
return node[prop](
|
|
...args.map((i) => {
|
|
if (typeof i === "function") {
|
|
return (child, index) => i(child.toProxy(), index);
|
|
} else {
|
|
return i;
|
|
}
|
|
})
|
|
);
|
|
};
|
|
} else if (prop === "every" || prop === "some") {
|
|
return (cb) => {
|
|
return node[prop](
|
|
(child, ...other) => cb(child.toProxy(), ...other)
|
|
);
|
|
};
|
|
} else if (prop === "root") {
|
|
return () => node.root().toProxy();
|
|
} else if (prop === "nodes") {
|
|
return node.nodes.map((i) => i.toProxy());
|
|
} else if (prop === "first" || prop === "last") {
|
|
return node[prop].toProxy();
|
|
} else {
|
|
return node[prop];
|
|
}
|
|
},
|
|
set(node, prop, value) {
|
|
if (node[prop] === value) return true;
|
|
node[prop] = value;
|
|
if (prop === "name" || prop === "params" || prop === "selector") {
|
|
node.markDirty();
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
}
|
|
index(child) {
|
|
if (typeof child === "number") return child;
|
|
if (child.proxyOf) child = child.proxyOf;
|
|
return this.proxyOf.nodes.indexOf(child);
|
|
}
|
|
insertAfter(exist, add) {
|
|
let existIndex = this.index(exist);
|
|
let nodes = this.normalize(add, this.proxyOf.nodes[existIndex]).reverse();
|
|
existIndex = this.index(exist);
|
|
for (let node of nodes) this.proxyOf.nodes.splice(existIndex + 1, 0, node);
|
|
let index;
|
|
for (let id in this.indexes) {
|
|
index = this.indexes[id];
|
|
if (existIndex < index) {
|
|
this.indexes[id] = index + nodes.length;
|
|
}
|
|
}
|
|
this.markDirty();
|
|
return this;
|
|
}
|
|
insertBefore(exist, add) {
|
|
let existIndex = this.index(exist);
|
|
let type = existIndex === 0 ? "prepend" : false;
|
|
let nodes = this.normalize(
|
|
add,
|
|
this.proxyOf.nodes[existIndex],
|
|
type
|
|
).reverse();
|
|
existIndex = this.index(exist);
|
|
for (let node of nodes) this.proxyOf.nodes.splice(existIndex, 0, node);
|
|
let index;
|
|
for (let id in this.indexes) {
|
|
index = this.indexes[id];
|
|
if (existIndex <= index) {
|
|
this.indexes[id] = index + nodes.length;
|
|
}
|
|
}
|
|
this.markDirty();
|
|
return this;
|
|
}
|
|
normalize(nodes, sample) {
|
|
if (typeof nodes === "string") {
|
|
nodes = cleanSource(parse2(nodes).nodes);
|
|
} else if (typeof nodes === "undefined") {
|
|
nodes = [];
|
|
} else if (Array.isArray(nodes)) {
|
|
nodes = nodes.slice(0);
|
|
for (let i of nodes) {
|
|
if (i.parent) i.parent.removeChild(i, "ignore");
|
|
}
|
|
} else if (nodes.type === "root" && this.type !== "document") {
|
|
nodes = nodes.nodes.slice(0);
|
|
for (let i of nodes) {
|
|
if (i.parent) i.parent.removeChild(i, "ignore");
|
|
}
|
|
} else if (nodes.type) {
|
|
nodes = [nodes];
|
|
} else if (nodes.prop) {
|
|
if (typeof nodes.value === "undefined") {
|
|
throw new Error("Value field is missed in node creation");
|
|
} else if (typeof nodes.value !== "string") {
|
|
nodes.value = String(nodes.value);
|
|
}
|
|
nodes = [new Declaration2(nodes)];
|
|
} else if (nodes.selector) {
|
|
nodes = [new Rule2(nodes)];
|
|
} else if (nodes.name) {
|
|
nodes = [new AtRule2(nodes)];
|
|
} else if (nodes.text) {
|
|
nodes = [new Comment2(nodes)];
|
|
} else {
|
|
throw new Error("Unknown node type in node creation");
|
|
}
|
|
let processed = nodes.map((i) => {
|
|
if (!i[my]) _Container.rebuild(i);
|
|
i = i.proxyOf;
|
|
if (i.parent) i.parent.removeChild(i);
|
|
if (i[isClean]) markTreeDirty(i);
|
|
if (typeof i.raws.before === "undefined") {
|
|
if (sample && typeof sample.raws.before !== "undefined") {
|
|
i.raws.before = sample.raws.before.replace(/\S/g, "");
|
|
}
|
|
}
|
|
i.parent = this.proxyOf;
|
|
return i;
|
|
});
|
|
return processed;
|
|
}
|
|
prepend(...children) {
|
|
children = children.reverse();
|
|
for (let child of children) {
|
|
let nodes = this.normalize(child, this.first, "prepend").reverse();
|
|
for (let node of nodes) this.proxyOf.nodes.unshift(node);
|
|
for (let id in this.indexes) {
|
|
this.indexes[id] = this.indexes[id] + nodes.length;
|
|
}
|
|
}
|
|
this.markDirty();
|
|
return this;
|
|
}
|
|
push(child) {
|
|
child.parent = this;
|
|
this.proxyOf.nodes.push(child);
|
|
return this;
|
|
}
|
|
removeAll() {
|
|
for (let node of this.proxyOf.nodes) node.parent = void 0;
|
|
this.proxyOf.nodes = [];
|
|
this.markDirty();
|
|
return this;
|
|
}
|
|
removeChild(child) {
|
|
child = this.index(child);
|
|
this.proxyOf.nodes[child].parent = void 0;
|
|
this.proxyOf.nodes.splice(child, 1);
|
|
let index;
|
|
for (let id in this.indexes) {
|
|
index = this.indexes[id];
|
|
if (index >= child) {
|
|
this.indexes[id] = index - 1;
|
|
}
|
|
}
|
|
this.markDirty();
|
|
return this;
|
|
}
|
|
replaceValues(pattern, opts, callback) {
|
|
if (!callback) {
|
|
callback = opts;
|
|
opts = {};
|
|
}
|
|
this.walkDecls((decl2) => {
|
|
if (opts.props && !opts.props.includes(decl2.prop)) return;
|
|
if (opts.fast && !decl2.value.includes(opts.fast)) return;
|
|
decl2.value = decl2.value.replace(pattern, callback);
|
|
});
|
|
this.markDirty();
|
|
return this;
|
|
}
|
|
some(condition) {
|
|
return this.nodes.some(condition);
|
|
}
|
|
walk(callback) {
|
|
return this.each((child, i) => {
|
|
let result;
|
|
try {
|
|
result = callback(child, i);
|
|
} catch (e) {
|
|
throw child.addToError(e);
|
|
}
|
|
if (result !== false && child.walk) {
|
|
result = child.walk(callback);
|
|
}
|
|
return result;
|
|
});
|
|
}
|
|
walkAtRules(name, callback) {
|
|
if (!callback) {
|
|
callback = name;
|
|
return this.walk((child, i) => {
|
|
if (child.type === "atrule") {
|
|
return callback(child, i);
|
|
}
|
|
});
|
|
}
|
|
if (name instanceof RegExp) {
|
|
return this.walk((child, i) => {
|
|
if (child.type === "atrule" && name.test(child.name)) {
|
|
return callback(child, i);
|
|
}
|
|
});
|
|
}
|
|
return this.walk((child, i) => {
|
|
if (child.type === "atrule" && child.name === name) {
|
|
return callback(child, i);
|
|
}
|
|
});
|
|
}
|
|
walkComments(callback) {
|
|
return this.walk((child, i) => {
|
|
if (child.type === "comment") {
|
|
return callback(child, i);
|
|
}
|
|
});
|
|
}
|
|
walkDecls(prop, callback) {
|
|
if (!callback) {
|
|
callback = prop;
|
|
return this.walk((child, i) => {
|
|
if (child.type === "decl") {
|
|
return callback(child, i);
|
|
}
|
|
});
|
|
}
|
|
if (prop instanceof RegExp) {
|
|
return this.walk((child, i) => {
|
|
if (child.type === "decl" && prop.test(child.prop)) {
|
|
return callback(child, i);
|
|
}
|
|
});
|
|
}
|
|
return this.walk((child, i) => {
|
|
if (child.type === "decl" && child.prop === prop) {
|
|
return callback(child, i);
|
|
}
|
|
});
|
|
}
|
|
walkRules(selector, callback) {
|
|
if (!callback) {
|
|
callback = selector;
|
|
return this.walk((child, i) => {
|
|
if (child.type === "rule") {
|
|
return callback(child, i);
|
|
}
|
|
});
|
|
}
|
|
if (selector instanceof RegExp) {
|
|
return this.walk((child, i) => {
|
|
if (child.type === "rule" && selector.test(child.selector)) {
|
|
return callback(child, i);
|
|
}
|
|
});
|
|
}
|
|
return this.walk((child, i) => {
|
|
if (child.type === "rule" && child.selector === selector) {
|
|
return callback(child, i);
|
|
}
|
|
});
|
|
}
|
|
get first() {
|
|
if (!this.proxyOf.nodes) return void 0;
|
|
return this.proxyOf.nodes[0];
|
|
}
|
|
get last() {
|
|
if (!this.proxyOf.nodes) return void 0;
|
|
return this.proxyOf.nodes[this.proxyOf.nodes.length - 1];
|
|
}
|
|
};
|
|
Container2.registerParse = (dependant) => {
|
|
parse2 = dependant;
|
|
};
|
|
Container2.registerRule = (dependant) => {
|
|
Rule2 = dependant;
|
|
};
|
|
Container2.registerAtRule = (dependant) => {
|
|
AtRule2 = dependant;
|
|
};
|
|
Container2.registerRoot = (dependant) => {
|
|
Root2 = dependant;
|
|
};
|
|
module.exports = Container2;
|
|
Container2.default = Container2;
|
|
Container2.rebuild = (node) => {
|
|
if (node.type === "atrule") {
|
|
Object.setPrototypeOf(node, AtRule2.prototype);
|
|
} else if (node.type === "rule") {
|
|
Object.setPrototypeOf(node, Rule2.prototype);
|
|
} else if (node.type === "decl") {
|
|
Object.setPrototypeOf(node, Declaration2.prototype);
|
|
} else if (node.type === "comment") {
|
|
Object.setPrototypeOf(node, Comment2.prototype);
|
|
} else if (node.type === "root") {
|
|
Object.setPrototypeOf(node, Root2.prototype);
|
|
}
|
|
node[my] = true;
|
|
if (node.nodes) {
|
|
node.nodes.forEach((child) => {
|
|
Container2.rebuild(child);
|
|
});
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/document.js
|
|
var require_document = __commonJS({
|
|
"node_modules/postcss/lib/document.js"(exports, module) {
|
|
"use strict";
|
|
var Container2 = require_container();
|
|
var LazyResult;
|
|
var Processor2;
|
|
var Document2 = class extends Container2 {
|
|
constructor(defaults) {
|
|
super({ type: "document", ...defaults });
|
|
if (!this.nodes) {
|
|
this.nodes = [];
|
|
}
|
|
}
|
|
toResult(opts = {}) {
|
|
let lazy = new LazyResult(new Processor2(), this, opts);
|
|
return lazy.stringify();
|
|
}
|
|
};
|
|
Document2.registerLazyResult = (dependant) => {
|
|
LazyResult = dependant;
|
|
};
|
|
Document2.registerProcessor = (dependant) => {
|
|
Processor2 = dependant;
|
|
};
|
|
module.exports = Document2;
|
|
Document2.default = Document2;
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/warn-once.js
|
|
var require_warn_once = __commonJS({
|
|
"node_modules/postcss/lib/warn-once.js"(exports, module) {
|
|
"use strict";
|
|
var printed = {};
|
|
module.exports = function warnOnce(message) {
|
|
if (printed[message]) return;
|
|
printed[message] = true;
|
|
if (typeof console !== "undefined" && console.warn) {
|
|
console.warn(message);
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/warning.js
|
|
var require_warning = __commonJS({
|
|
"node_modules/postcss/lib/warning.js"(exports, module) {
|
|
"use strict";
|
|
var Warning2 = class {
|
|
constructor(text, opts = {}) {
|
|
this.type = "warning";
|
|
this.text = text;
|
|
if (opts.node && opts.node.source) {
|
|
let range = opts.node.rangeBy(opts);
|
|
this.line = range.start.line;
|
|
this.column = range.start.column;
|
|
this.endLine = range.end.line;
|
|
this.endColumn = range.end.column;
|
|
}
|
|
for (let opt in opts) this[opt] = opts[opt];
|
|
}
|
|
toString() {
|
|
if (this.node) {
|
|
return this.node.error(this.text, {
|
|
index: this.index,
|
|
plugin: this.plugin,
|
|
word: this.word
|
|
}).message;
|
|
}
|
|
if (this.plugin) {
|
|
return this.plugin + ": " + this.text;
|
|
}
|
|
return this.text;
|
|
}
|
|
};
|
|
module.exports = Warning2;
|
|
Warning2.default = Warning2;
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/result.js
|
|
var require_result = __commonJS({
|
|
"node_modules/postcss/lib/result.js"(exports, module) {
|
|
"use strict";
|
|
var Warning2 = require_warning();
|
|
var Result2 = class {
|
|
constructor(processor, root2, opts) {
|
|
this.processor = processor;
|
|
this.messages = [];
|
|
this.root = root2;
|
|
this.opts = opts;
|
|
this.css = void 0;
|
|
this.map = void 0;
|
|
}
|
|
toString() {
|
|
return this.css;
|
|
}
|
|
warn(text, opts = {}) {
|
|
if (!opts.plugin) {
|
|
if (this.lastPlugin && this.lastPlugin.postcssPlugin) {
|
|
opts.plugin = this.lastPlugin.postcssPlugin;
|
|
}
|
|
}
|
|
let warning = new Warning2(text, opts);
|
|
this.messages.push(warning);
|
|
return warning;
|
|
}
|
|
warnings() {
|
|
return this.messages.filter((i) => i.type === "warning");
|
|
}
|
|
get content() {
|
|
return this.css;
|
|
}
|
|
};
|
|
module.exports = Result2;
|
|
Result2.default = Result2;
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/tokenize.js
|
|
var require_tokenize = __commonJS({
|
|
"node_modules/postcss/lib/tokenize.js"(exports, module) {
|
|
"use strict";
|
|
var SINGLE_QUOTE = "'".charCodeAt(0);
|
|
var DOUBLE_QUOTE = '"'.charCodeAt(0);
|
|
var BACKSLASH = "\\".charCodeAt(0);
|
|
var SLASH = "/".charCodeAt(0);
|
|
var NEWLINE = "\n".charCodeAt(0);
|
|
var SPACE = " ".charCodeAt(0);
|
|
var FEED = "\f".charCodeAt(0);
|
|
var TAB = " ".charCodeAt(0);
|
|
var CR = "\r".charCodeAt(0);
|
|
var OPEN_SQUARE = "[".charCodeAt(0);
|
|
var CLOSE_SQUARE = "]".charCodeAt(0);
|
|
var OPEN_PARENTHESES = "(".charCodeAt(0);
|
|
var CLOSE_PARENTHESES = ")".charCodeAt(0);
|
|
var OPEN_CURLY = "{".charCodeAt(0);
|
|
var CLOSE_CURLY = "}".charCodeAt(0);
|
|
var SEMICOLON = ";".charCodeAt(0);
|
|
var ASTERISK = "*".charCodeAt(0);
|
|
var COLON = ":".charCodeAt(0);
|
|
var AT = "@".charCodeAt(0);
|
|
var RE_AT_END = /[\t\n\f\r "#'()/;[\\\]{}]/g;
|
|
var RE_WORD_END = /[\t\n\f\r !"#'():;@[\\\]{}]|\/(?=\*)/g;
|
|
var RE_BAD_BRACKET = /.[\r\n"'(/\\]/;
|
|
var RE_HEX_ESCAPE = /[\da-f]/i;
|
|
module.exports = function tokenizer(input, options = {}) {
|
|
let css = input.css.valueOf();
|
|
let ignore = options.ignoreErrors;
|
|
let code, next, quote, content, escape;
|
|
let escaped, escapePos, prev, n, currentToken;
|
|
let length = css.length;
|
|
let pos = 0;
|
|
let buffer = [];
|
|
let returned = [];
|
|
function position() {
|
|
return pos;
|
|
}
|
|
function unclosed(what) {
|
|
throw input.error("Unclosed " + what, pos);
|
|
}
|
|
function endOfFile() {
|
|
return returned.length === 0 && pos >= length;
|
|
}
|
|
function nextToken(opts) {
|
|
if (returned.length) return returned.pop();
|
|
if (pos >= length) return;
|
|
let ignoreUnclosed = opts ? opts.ignoreUnclosed : false;
|
|
code = css.charCodeAt(pos);
|
|
switch (code) {
|
|
case NEWLINE:
|
|
case SPACE:
|
|
case TAB:
|
|
case CR:
|
|
case FEED: {
|
|
next = pos;
|
|
do {
|
|
next += 1;
|
|
code = css.charCodeAt(next);
|
|
} while (code === SPACE || code === NEWLINE || code === TAB || code === CR || code === FEED);
|
|
currentToken = ["space", css.slice(pos, next)];
|
|
pos = next - 1;
|
|
break;
|
|
}
|
|
case OPEN_SQUARE:
|
|
case CLOSE_SQUARE:
|
|
case OPEN_CURLY:
|
|
case CLOSE_CURLY:
|
|
case COLON:
|
|
case SEMICOLON:
|
|
case CLOSE_PARENTHESES: {
|
|
let controlChar = String.fromCharCode(code);
|
|
currentToken = [controlChar, controlChar, pos];
|
|
break;
|
|
}
|
|
case OPEN_PARENTHESES: {
|
|
prev = buffer.length ? buffer.pop()[1] : "";
|
|
n = css.charCodeAt(pos + 1);
|
|
if (prev === "url" && n !== SINGLE_QUOTE && n !== DOUBLE_QUOTE && n !== SPACE && n !== NEWLINE && n !== TAB && n !== FEED && n !== CR) {
|
|
next = pos;
|
|
do {
|
|
escaped = false;
|
|
next = css.indexOf(")", next + 1);
|
|
if (next === -1) {
|
|
if (ignore || ignoreUnclosed) {
|
|
next = pos;
|
|
break;
|
|
} else {
|
|
unclosed("bracket");
|
|
}
|
|
}
|
|
escapePos = next;
|
|
while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
|
|
escapePos -= 1;
|
|
escaped = !escaped;
|
|
}
|
|
} while (escaped);
|
|
currentToken = ["brackets", css.slice(pos, next + 1), pos, next];
|
|
pos = next;
|
|
} else {
|
|
next = css.indexOf(")", pos + 1);
|
|
content = css.slice(pos, next + 1);
|
|
if (next === -1 || RE_BAD_BRACKET.test(content)) {
|
|
currentToken = ["(", "(", pos];
|
|
} else {
|
|
currentToken = ["brackets", content, pos, next];
|
|
pos = next;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case SINGLE_QUOTE:
|
|
case DOUBLE_QUOTE: {
|
|
quote = code === SINGLE_QUOTE ? "'" : '"';
|
|
next = pos;
|
|
do {
|
|
escaped = false;
|
|
next = css.indexOf(quote, next + 1);
|
|
if (next === -1) {
|
|
if (ignore || ignoreUnclosed) {
|
|
next = pos + 1;
|
|
break;
|
|
} else {
|
|
unclosed("string");
|
|
}
|
|
}
|
|
escapePos = next;
|
|
while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
|
|
escapePos -= 1;
|
|
escaped = !escaped;
|
|
}
|
|
} while (escaped);
|
|
currentToken = ["string", css.slice(pos, next + 1), pos, next];
|
|
pos = next;
|
|
break;
|
|
}
|
|
case AT: {
|
|
RE_AT_END.lastIndex = pos + 1;
|
|
RE_AT_END.test(css);
|
|
if (RE_AT_END.lastIndex === 0) {
|
|
next = css.length - 1;
|
|
} else {
|
|
next = RE_AT_END.lastIndex - 2;
|
|
}
|
|
currentToken = ["at-word", css.slice(pos, next + 1), pos, next];
|
|
pos = next;
|
|
break;
|
|
}
|
|
case BACKSLASH: {
|
|
next = pos;
|
|
escape = true;
|
|
while (css.charCodeAt(next + 1) === BACKSLASH) {
|
|
next += 1;
|
|
escape = !escape;
|
|
}
|
|
code = css.charCodeAt(next + 1);
|
|
if (escape && code !== SLASH && code !== SPACE && code !== NEWLINE && code !== TAB && code !== CR && code !== FEED) {
|
|
next += 1;
|
|
if (RE_HEX_ESCAPE.test(css.charAt(next))) {
|
|
while (RE_HEX_ESCAPE.test(css.charAt(next + 1))) {
|
|
next += 1;
|
|
}
|
|
if (css.charCodeAt(next + 1) === SPACE) {
|
|
next += 1;
|
|
}
|
|
}
|
|
}
|
|
currentToken = ["word", css.slice(pos, next + 1), pos, next];
|
|
pos = next;
|
|
break;
|
|
}
|
|
default: {
|
|
if (code === SLASH && css.charCodeAt(pos + 1) === ASTERISK) {
|
|
next = css.indexOf("*/", pos + 2) + 1;
|
|
if (next === 0) {
|
|
if (ignore || ignoreUnclosed) {
|
|
next = css.length;
|
|
} else {
|
|
unclosed("comment");
|
|
}
|
|
}
|
|
currentToken = ["comment", css.slice(pos, next + 1), pos, next];
|
|
pos = next;
|
|
} else {
|
|
RE_WORD_END.lastIndex = pos + 1;
|
|
RE_WORD_END.test(css);
|
|
if (RE_WORD_END.lastIndex === 0) {
|
|
next = css.length - 1;
|
|
} else {
|
|
next = RE_WORD_END.lastIndex - 2;
|
|
}
|
|
currentToken = ["word", css.slice(pos, next + 1), pos, next];
|
|
buffer.push(currentToken);
|
|
pos = next;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
pos++;
|
|
return currentToken;
|
|
}
|
|
function back(token) {
|
|
returned.push(token);
|
|
}
|
|
return {
|
|
back,
|
|
endOfFile,
|
|
nextToken,
|
|
position
|
|
};
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/at-rule.js
|
|
var require_at_rule = __commonJS({
|
|
"node_modules/postcss/lib/at-rule.js"(exports, module) {
|
|
"use strict";
|
|
var Container2 = require_container();
|
|
var AtRule2 = class extends Container2 {
|
|
constructor(defaults) {
|
|
super(defaults);
|
|
this.type = "atrule";
|
|
}
|
|
append(...children) {
|
|
if (!this.proxyOf.nodes) this.nodes = [];
|
|
return super.append(...children);
|
|
}
|
|
prepend(...children) {
|
|
if (!this.proxyOf.nodes) this.nodes = [];
|
|
return super.prepend(...children);
|
|
}
|
|
};
|
|
module.exports = AtRule2;
|
|
AtRule2.default = AtRule2;
|
|
Container2.registerAtRule(AtRule2);
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/root.js
|
|
var require_root = __commonJS({
|
|
"node_modules/postcss/lib/root.js"(exports, module) {
|
|
"use strict";
|
|
var Container2 = require_container();
|
|
var LazyResult;
|
|
var Processor2;
|
|
var Root2 = class extends Container2 {
|
|
constructor(defaults) {
|
|
super(defaults);
|
|
this.type = "root";
|
|
if (!this.nodes) this.nodes = [];
|
|
}
|
|
normalize(child, sample, type) {
|
|
let nodes = super.normalize(child);
|
|
if (sample) {
|
|
if (type === "prepend") {
|
|
if (this.nodes.length > 1) {
|
|
sample.raws.before = this.nodes[1].raws.before;
|
|
} else {
|
|
delete sample.raws.before;
|
|
}
|
|
} else if (this.first !== sample) {
|
|
for (let node of nodes) {
|
|
node.raws.before = sample.raws.before;
|
|
}
|
|
}
|
|
}
|
|
return nodes;
|
|
}
|
|
removeChild(child, ignore) {
|
|
let index = this.index(child);
|
|
if (!ignore && index === 0 && this.nodes.length > 1) {
|
|
this.nodes[1].raws.before = this.nodes[index].raws.before;
|
|
}
|
|
return super.removeChild(child);
|
|
}
|
|
toResult(opts = {}) {
|
|
let lazy = new LazyResult(new Processor2(), this, opts);
|
|
return lazy.stringify();
|
|
}
|
|
};
|
|
Root2.registerLazyResult = (dependant) => {
|
|
LazyResult = dependant;
|
|
};
|
|
Root2.registerProcessor = (dependant) => {
|
|
Processor2 = dependant;
|
|
};
|
|
module.exports = Root2;
|
|
Root2.default = Root2;
|
|
Container2.registerRoot(Root2);
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/list.js
|
|
var require_list = __commonJS({
|
|
"node_modules/postcss/lib/list.js"(exports, module) {
|
|
"use strict";
|
|
var list2 = {
|
|
comma(string) {
|
|
return list2.split(string, [","], true);
|
|
},
|
|
space(string) {
|
|
let spaces = [" ", "\n", " "];
|
|
return list2.split(string, spaces);
|
|
},
|
|
split(string, separators, last) {
|
|
let array = [];
|
|
let current = "";
|
|
let split = false;
|
|
let func = 0;
|
|
let inQuote = false;
|
|
let prevQuote = "";
|
|
let escape = false;
|
|
for (let letter of string) {
|
|
if (escape) {
|
|
escape = false;
|
|
} else if (letter === "\\") {
|
|
escape = true;
|
|
} else if (inQuote) {
|
|
if (letter === prevQuote) {
|
|
inQuote = false;
|
|
}
|
|
} else if (letter === '"' || letter === "'") {
|
|
inQuote = true;
|
|
prevQuote = letter;
|
|
} else if (letter === "(") {
|
|
func += 1;
|
|
} else if (letter === ")") {
|
|
if (func > 0) func -= 1;
|
|
} else if (func === 0) {
|
|
if (separators.includes(letter)) split = true;
|
|
}
|
|
if (split) {
|
|
if (current !== "") array.push(current.trim());
|
|
current = "";
|
|
split = false;
|
|
} else {
|
|
current += letter;
|
|
}
|
|
}
|
|
if (last || current !== "") array.push(current.trim());
|
|
return array;
|
|
}
|
|
};
|
|
module.exports = list2;
|
|
list2.default = list2;
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/rule.js
|
|
var require_rule = __commonJS({
|
|
"node_modules/postcss/lib/rule.js"(exports, module) {
|
|
"use strict";
|
|
var Container2 = require_container();
|
|
var list2 = require_list();
|
|
var Rule2 = class extends Container2 {
|
|
constructor(defaults) {
|
|
super(defaults);
|
|
this.type = "rule";
|
|
if (!this.nodes) this.nodes = [];
|
|
}
|
|
get selectors() {
|
|
return list2.comma(this.selector);
|
|
}
|
|
set selectors(values) {
|
|
let match = this.selector ? this.selector.match(/,\s*/) : null;
|
|
let sep = match ? match[0] : "," + this.raw("between", "beforeOpen");
|
|
this.selector = values.join(sep);
|
|
}
|
|
};
|
|
module.exports = Rule2;
|
|
Rule2.default = Rule2;
|
|
Container2.registerRule(Rule2);
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/parser.js
|
|
var require_parser = __commonJS({
|
|
"node_modules/postcss/lib/parser.js"(exports, module) {
|
|
"use strict";
|
|
var Declaration2 = require_declaration();
|
|
var tokenizer = require_tokenize();
|
|
var Comment2 = require_comment();
|
|
var AtRule2 = require_at_rule();
|
|
var Root2 = require_root();
|
|
var Rule2 = require_rule();
|
|
var SAFE_COMMENT_NEIGHBOR = {
|
|
empty: true,
|
|
space: true
|
|
};
|
|
function findLastWithPosition(tokens) {
|
|
for (let i = tokens.length - 1; i >= 0; i--) {
|
|
let token = tokens[i];
|
|
let pos = token[3] || token[2];
|
|
if (pos) return pos;
|
|
}
|
|
}
|
|
var Parser = class {
|
|
constructor(input) {
|
|
this.input = input;
|
|
this.root = new Root2();
|
|
this.current = this.root;
|
|
this.spaces = "";
|
|
this.semicolon = false;
|
|
this.createTokenizer();
|
|
this.root.source = { input, start: { column: 1, line: 1, offset: 0 } };
|
|
}
|
|
atrule(token) {
|
|
let node = new AtRule2();
|
|
node.name = token[1].slice(1);
|
|
if (node.name === "") {
|
|
this.unnamedAtrule(node, token);
|
|
}
|
|
this.init(node, token[2]);
|
|
let type;
|
|
let prev;
|
|
let shift;
|
|
let last = false;
|
|
let open = false;
|
|
let params = [];
|
|
let brackets = [];
|
|
while (!this.tokenizer.endOfFile()) {
|
|
token = this.tokenizer.nextToken();
|
|
type = token[0];
|
|
if (type === "(" || type === "[") {
|
|
brackets.push(type === "(" ? ")" : "]");
|
|
} else if (type === "{" && brackets.length > 0) {
|
|
brackets.push("}");
|
|
} else if (type === brackets[brackets.length - 1]) {
|
|
brackets.pop();
|
|
}
|
|
if (brackets.length === 0) {
|
|
if (type === ";") {
|
|
node.source.end = this.getPosition(token[2]);
|
|
node.source.end.offset++;
|
|
this.semicolon = true;
|
|
break;
|
|
} else if (type === "{") {
|
|
open = true;
|
|
break;
|
|
} else if (type === "}") {
|
|
if (params.length > 0) {
|
|
shift = params.length - 1;
|
|
prev = params[shift];
|
|
while (prev && prev[0] === "space") {
|
|
prev = params[--shift];
|
|
}
|
|
if (prev) {
|
|
node.source.end = this.getPosition(prev[3] || prev[2]);
|
|
node.source.end.offset++;
|
|
}
|
|
}
|
|
this.end(token);
|
|
break;
|
|
} else {
|
|
params.push(token);
|
|
}
|
|
} else {
|
|
params.push(token);
|
|
}
|
|
if (this.tokenizer.endOfFile()) {
|
|
last = true;
|
|
break;
|
|
}
|
|
}
|
|
node.raws.between = this.spacesAndCommentsFromEnd(params);
|
|
if (params.length) {
|
|
node.raws.afterName = this.spacesAndCommentsFromStart(params);
|
|
this.raw(node, "params", params);
|
|
if (last) {
|
|
token = params[params.length - 1];
|
|
node.source.end = this.getPosition(token[3] || token[2]);
|
|
node.source.end.offset++;
|
|
this.spaces = node.raws.between;
|
|
node.raws.between = "";
|
|
}
|
|
} else {
|
|
node.raws.afterName = "";
|
|
node.params = "";
|
|
}
|
|
if (open) {
|
|
node.nodes = [];
|
|
this.current = node;
|
|
}
|
|
}
|
|
checkMissedSemicolon(tokens) {
|
|
let colon = this.colon(tokens);
|
|
if (colon === false) return;
|
|
let founded = 0;
|
|
let token;
|
|
for (let j = colon - 1; j >= 0; j--) {
|
|
token = tokens[j];
|
|
if (token[0] !== "space") {
|
|
founded += 1;
|
|
if (founded === 2) break;
|
|
}
|
|
}
|
|
throw this.input.error(
|
|
"Missed semicolon",
|
|
token[0] === "word" ? token[3] + 1 : token[2]
|
|
);
|
|
}
|
|
colon(tokens) {
|
|
let brackets = 0;
|
|
let token, type, prev;
|
|
for (let [i, element] of tokens.entries()) {
|
|
token = element;
|
|
type = token[0];
|
|
if (type === "(") {
|
|
brackets += 1;
|
|
}
|
|
if (type === ")") {
|
|
brackets -= 1;
|
|
}
|
|
if (brackets === 0 && type === ":") {
|
|
if (!prev) {
|
|
this.doubleColon(token);
|
|
} else if (prev[0] === "word" && prev[1] === "progid") {
|
|
continue;
|
|
} else {
|
|
return i;
|
|
}
|
|
}
|
|
prev = token;
|
|
}
|
|
return false;
|
|
}
|
|
comment(token) {
|
|
let node = new Comment2();
|
|
this.init(node, token[2]);
|
|
node.source.end = this.getPosition(token[3] || token[2]);
|
|
node.source.end.offset++;
|
|
let text = token[1].slice(2, -2);
|
|
if (/^\s*$/.test(text)) {
|
|
node.text = "";
|
|
node.raws.left = text;
|
|
node.raws.right = "";
|
|
} else {
|
|
let match = text.match(/^(\s*)([^]*\S)(\s*)$/);
|
|
node.text = match[2];
|
|
node.raws.left = match[1];
|
|
node.raws.right = match[3];
|
|
}
|
|
}
|
|
createTokenizer() {
|
|
this.tokenizer = tokenizer(this.input);
|
|
}
|
|
decl(tokens, customProperty) {
|
|
let node = new Declaration2();
|
|
this.init(node, tokens[0][2]);
|
|
let last = tokens[tokens.length - 1];
|
|
if (last[0] === ";") {
|
|
this.semicolon = true;
|
|
tokens.pop();
|
|
}
|
|
node.source.end = this.getPosition(
|
|
last[3] || last[2] || findLastWithPosition(tokens)
|
|
);
|
|
node.source.end.offset++;
|
|
while (tokens[0][0] !== "word") {
|
|
if (tokens.length === 1) this.unknownWord(tokens);
|
|
node.raws.before += tokens.shift()[1];
|
|
}
|
|
node.source.start = this.getPosition(tokens[0][2]);
|
|
node.prop = "";
|
|
while (tokens.length) {
|
|
let type = tokens[0][0];
|
|
if (type === ":" || type === "space" || type === "comment") {
|
|
break;
|
|
}
|
|
node.prop += tokens.shift()[1];
|
|
}
|
|
node.raws.between = "";
|
|
let token;
|
|
while (tokens.length) {
|
|
token = tokens.shift();
|
|
if (token[0] === ":") {
|
|
node.raws.between += token[1];
|
|
break;
|
|
} else {
|
|
if (token[0] === "word" && /\w/.test(token[1])) {
|
|
this.unknownWord([token]);
|
|
}
|
|
node.raws.between += token[1];
|
|
}
|
|
}
|
|
if (node.prop[0] === "_" || node.prop[0] === "*") {
|
|
node.raws.before += node.prop[0];
|
|
node.prop = node.prop.slice(1);
|
|
}
|
|
let firstSpaces = [];
|
|
let next;
|
|
while (tokens.length) {
|
|
next = tokens[0][0];
|
|
if (next !== "space" && next !== "comment") break;
|
|
firstSpaces.push(tokens.shift());
|
|
}
|
|
this.precheckMissedSemicolon(tokens);
|
|
for (let i = tokens.length - 1; i >= 0; i--) {
|
|
token = tokens[i];
|
|
if (token[1].toLowerCase() === "!important") {
|
|
node.important = true;
|
|
let string = this.stringFrom(tokens, i);
|
|
string = this.spacesFromEnd(tokens) + string;
|
|
if (string !== " !important") node.raws.important = string;
|
|
break;
|
|
} else if (token[1].toLowerCase() === "important") {
|
|
let cache = tokens.slice(0);
|
|
let str = "";
|
|
for (let j = i; j > 0; j--) {
|
|
let type = cache[j][0];
|
|
if (str.trim().indexOf("!") === 0 && type !== "space") {
|
|
break;
|
|
}
|
|
str = cache.pop()[1] + str;
|
|
}
|
|
if (str.trim().indexOf("!") === 0) {
|
|
node.important = true;
|
|
node.raws.important = str;
|
|
tokens = cache;
|
|
}
|
|
}
|
|
if (token[0] !== "space" && token[0] !== "comment") {
|
|
break;
|
|
}
|
|
}
|
|
let hasWord = tokens.some((i) => i[0] !== "space" && i[0] !== "comment");
|
|
if (hasWord) {
|
|
node.raws.between += firstSpaces.map((i) => i[1]).join("");
|
|
firstSpaces = [];
|
|
}
|
|
this.raw(node, "value", firstSpaces.concat(tokens), customProperty);
|
|
if (node.value.includes(":") && !customProperty) {
|
|
this.checkMissedSemicolon(tokens);
|
|
}
|
|
}
|
|
doubleColon(token) {
|
|
throw this.input.error(
|
|
"Double colon",
|
|
{ offset: token[2] },
|
|
{ offset: token[2] + token[1].length }
|
|
);
|
|
}
|
|
emptyRule(token) {
|
|
let node = new Rule2();
|
|
this.init(node, token[2]);
|
|
node.selector = "";
|
|
node.raws.between = "";
|
|
this.current = node;
|
|
}
|
|
end(token) {
|
|
if (this.current.nodes && this.current.nodes.length) {
|
|
this.current.raws.semicolon = this.semicolon;
|
|
}
|
|
this.semicolon = false;
|
|
this.current.raws.after = (this.current.raws.after || "") + this.spaces;
|
|
this.spaces = "";
|
|
if (this.current.parent) {
|
|
this.current.source.end = this.getPosition(token[2]);
|
|
this.current.source.end.offset++;
|
|
this.current = this.current.parent;
|
|
} else {
|
|
this.unexpectedClose(token);
|
|
}
|
|
}
|
|
endFile() {
|
|
if (this.current.parent) this.unclosedBlock();
|
|
if (this.current.nodes && this.current.nodes.length) {
|
|
this.current.raws.semicolon = this.semicolon;
|
|
}
|
|
this.current.raws.after = (this.current.raws.after || "") + this.spaces;
|
|
this.root.source.end = this.getPosition(this.tokenizer.position());
|
|
}
|
|
freeSemicolon(token) {
|
|
this.spaces += token[1];
|
|
if (this.current.nodes) {
|
|
let prev = this.current.nodes[this.current.nodes.length - 1];
|
|
if (prev && prev.type === "rule" && !prev.raws.ownSemicolon) {
|
|
prev.raws.ownSemicolon = this.spaces;
|
|
this.spaces = "";
|
|
}
|
|
}
|
|
}
|
|
// Helpers
|
|
getPosition(offset) {
|
|
let pos = this.input.fromOffset(offset);
|
|
return {
|
|
column: pos.col,
|
|
line: pos.line,
|
|
offset
|
|
};
|
|
}
|
|
init(node, offset) {
|
|
this.current.push(node);
|
|
node.source = {
|
|
input: this.input,
|
|
start: this.getPosition(offset)
|
|
};
|
|
node.raws.before = this.spaces;
|
|
this.spaces = "";
|
|
if (node.type !== "comment") this.semicolon = false;
|
|
}
|
|
other(start) {
|
|
let end = false;
|
|
let type = null;
|
|
let colon = false;
|
|
let bracket = null;
|
|
let brackets = [];
|
|
let customProperty = start[1].startsWith("--");
|
|
let tokens = [];
|
|
let token = start;
|
|
while (token) {
|
|
type = token[0];
|
|
tokens.push(token);
|
|
if (type === "(" || type === "[") {
|
|
if (!bracket) bracket = token;
|
|
brackets.push(type === "(" ? ")" : "]");
|
|
} else if (customProperty && colon && type === "{") {
|
|
if (!bracket) bracket = token;
|
|
brackets.push("}");
|
|
} else if (brackets.length === 0) {
|
|
if (type === ";") {
|
|
if (colon) {
|
|
this.decl(tokens, customProperty);
|
|
return;
|
|
} else {
|
|
break;
|
|
}
|
|
} else if (type === "{") {
|
|
this.rule(tokens);
|
|
return;
|
|
} else if (type === "}") {
|
|
this.tokenizer.back(tokens.pop());
|
|
end = true;
|
|
break;
|
|
} else if (type === ":") {
|
|
colon = true;
|
|
}
|
|
} else if (type === brackets[brackets.length - 1]) {
|
|
brackets.pop();
|
|
if (brackets.length === 0) bracket = null;
|
|
}
|
|
token = this.tokenizer.nextToken();
|
|
}
|
|
if (this.tokenizer.endOfFile()) end = true;
|
|
if (brackets.length > 0) this.unclosedBracket(bracket);
|
|
if (end && colon) {
|
|
if (!customProperty) {
|
|
while (tokens.length) {
|
|
token = tokens[tokens.length - 1][0];
|
|
if (token !== "space" && token !== "comment") break;
|
|
this.tokenizer.back(tokens.pop());
|
|
}
|
|
}
|
|
this.decl(tokens, customProperty);
|
|
} else {
|
|
this.unknownWord(tokens);
|
|
}
|
|
}
|
|
parse() {
|
|
let token;
|
|
while (!this.tokenizer.endOfFile()) {
|
|
token = this.tokenizer.nextToken();
|
|
switch (token[0]) {
|
|
case "space":
|
|
this.spaces += token[1];
|
|
break;
|
|
case ";":
|
|
this.freeSemicolon(token);
|
|
break;
|
|
case "}":
|
|
this.end(token);
|
|
break;
|
|
case "comment":
|
|
this.comment(token);
|
|
break;
|
|
case "at-word":
|
|
this.atrule(token);
|
|
break;
|
|
case "{":
|
|
this.emptyRule(token);
|
|
break;
|
|
default:
|
|
this.other(token);
|
|
break;
|
|
}
|
|
}
|
|
this.endFile();
|
|
}
|
|
precheckMissedSemicolon() {
|
|
}
|
|
raw(node, prop, tokens, customProperty) {
|
|
let token, type;
|
|
let length = tokens.length;
|
|
let value = "";
|
|
let clean = true;
|
|
let next, prev;
|
|
for (let i = 0; i < length; i += 1) {
|
|
token = tokens[i];
|
|
type = token[0];
|
|
if (type === "space" && i === length - 1 && !customProperty) {
|
|
clean = false;
|
|
} else if (type === "comment") {
|
|
prev = tokens[i - 1] ? tokens[i - 1][0] : "empty";
|
|
next = tokens[i + 1] ? tokens[i + 1][0] : "empty";
|
|
if (!SAFE_COMMENT_NEIGHBOR[prev] && !SAFE_COMMENT_NEIGHBOR[next]) {
|
|
if (value.slice(-1) === ",") {
|
|
clean = false;
|
|
} else {
|
|
value += token[1];
|
|
}
|
|
} else {
|
|
clean = false;
|
|
}
|
|
} else {
|
|
value += token[1];
|
|
}
|
|
}
|
|
if (!clean) {
|
|
let raw = tokens.reduce((all, i) => all + i[1], "");
|
|
node.raws[prop] = { raw, value };
|
|
}
|
|
node[prop] = value;
|
|
}
|
|
rule(tokens) {
|
|
tokens.pop();
|
|
let node = new Rule2();
|
|
this.init(node, tokens[0][2]);
|
|
node.raws.between = this.spacesAndCommentsFromEnd(tokens);
|
|
this.raw(node, "selector", tokens);
|
|
this.current = node;
|
|
}
|
|
spacesAndCommentsFromEnd(tokens) {
|
|
let lastTokenType;
|
|
let spaces = "";
|
|
while (tokens.length) {
|
|
lastTokenType = tokens[tokens.length - 1][0];
|
|
if (lastTokenType !== "space" && lastTokenType !== "comment") break;
|
|
spaces = tokens.pop()[1] + spaces;
|
|
}
|
|
return spaces;
|
|
}
|
|
// Errors
|
|
spacesAndCommentsFromStart(tokens) {
|
|
let next;
|
|
let spaces = "";
|
|
while (tokens.length) {
|
|
next = tokens[0][0];
|
|
if (next !== "space" && next !== "comment") break;
|
|
spaces += tokens.shift()[1];
|
|
}
|
|
return spaces;
|
|
}
|
|
spacesFromEnd(tokens) {
|
|
let lastTokenType;
|
|
let spaces = "";
|
|
while (tokens.length) {
|
|
lastTokenType = tokens[tokens.length - 1][0];
|
|
if (lastTokenType !== "space") break;
|
|
spaces = tokens.pop()[1] + spaces;
|
|
}
|
|
return spaces;
|
|
}
|
|
stringFrom(tokens, from) {
|
|
let result = "";
|
|
for (let i = from; i < tokens.length; i++) {
|
|
result += tokens[i][1];
|
|
}
|
|
tokens.splice(from, tokens.length - from);
|
|
return result;
|
|
}
|
|
unclosedBlock() {
|
|
let pos = this.current.source.start;
|
|
throw this.input.error("Unclosed block", pos.line, pos.column);
|
|
}
|
|
unclosedBracket(bracket) {
|
|
throw this.input.error(
|
|
"Unclosed bracket",
|
|
{ offset: bracket[2] },
|
|
{ offset: bracket[2] + 1 }
|
|
);
|
|
}
|
|
unexpectedClose(token) {
|
|
throw this.input.error(
|
|
"Unexpected }",
|
|
{ offset: token[2] },
|
|
{ offset: token[2] + 1 }
|
|
);
|
|
}
|
|
unknownWord(tokens) {
|
|
throw this.input.error(
|
|
"Unknown word",
|
|
{ offset: tokens[0][2] },
|
|
{ offset: tokens[0][2] + tokens[0][1].length }
|
|
);
|
|
}
|
|
unnamedAtrule(node, token) {
|
|
throw this.input.error(
|
|
"At-rule without name",
|
|
{ offset: token[2] },
|
|
{ offset: token[2] + token[1].length }
|
|
);
|
|
}
|
|
};
|
|
module.exports = Parser;
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/parse.js
|
|
var require_parse = __commonJS({
|
|
"node_modules/postcss/lib/parse.js"(exports, module) {
|
|
"use strict";
|
|
var Container2 = require_container();
|
|
var Parser = require_parser();
|
|
var Input2 = require_input();
|
|
function parse2(css, opts) {
|
|
let input = new Input2(css, opts);
|
|
let parser = new Parser(input);
|
|
try {
|
|
parser.parse();
|
|
} catch (e) {
|
|
if (true) {
|
|
if (e.name === "CssSyntaxError" && opts && opts.from) {
|
|
if (/\.scss$/i.test(opts.from)) {
|
|
e.message += "\nYou tried to parse SCSS with the standard CSS parser; try again with the postcss-scss parser";
|
|
} else if (/\.sass/i.test(opts.from)) {
|
|
e.message += "\nYou tried to parse Sass with the standard CSS parser; try again with the postcss-sass parser";
|
|
} else if (/\.less$/i.test(opts.from)) {
|
|
e.message += "\nYou tried to parse Less with the standard CSS parser; try again with the postcss-less parser";
|
|
}
|
|
}
|
|
}
|
|
throw e;
|
|
}
|
|
return parser.root;
|
|
}
|
|
module.exports = parse2;
|
|
parse2.default = parse2;
|
|
Container2.registerParse(parse2);
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/lazy-result.js
|
|
var require_lazy_result = __commonJS({
|
|
"node_modules/postcss/lib/lazy-result.js"(exports, module) {
|
|
"use strict";
|
|
var { isClean, my } = require_symbols();
|
|
var MapGenerator = require_map_generator();
|
|
var stringify2 = require_stringify();
|
|
var Container2 = require_container();
|
|
var Document2 = require_document();
|
|
var warnOnce = require_warn_once();
|
|
var Result2 = require_result();
|
|
var parse2 = require_parse();
|
|
var Root2 = require_root();
|
|
var TYPE_TO_CLASS_NAME = {
|
|
atrule: "AtRule",
|
|
comment: "Comment",
|
|
decl: "Declaration",
|
|
document: "Document",
|
|
root: "Root",
|
|
rule: "Rule"
|
|
};
|
|
var PLUGIN_PROPS = {
|
|
AtRule: true,
|
|
AtRuleExit: true,
|
|
Comment: true,
|
|
CommentExit: true,
|
|
Declaration: true,
|
|
DeclarationExit: true,
|
|
Document: true,
|
|
DocumentExit: true,
|
|
Once: true,
|
|
OnceExit: true,
|
|
postcssPlugin: true,
|
|
prepare: true,
|
|
Root: true,
|
|
RootExit: true,
|
|
Rule: true,
|
|
RuleExit: true
|
|
};
|
|
var NOT_VISITORS = {
|
|
Once: true,
|
|
postcssPlugin: true,
|
|
prepare: true
|
|
};
|
|
var CHILDREN = 0;
|
|
function isPromise(obj) {
|
|
return typeof obj === "object" && typeof obj.then === "function";
|
|
}
|
|
function getEvents(node) {
|
|
let key = false;
|
|
let type = TYPE_TO_CLASS_NAME[node.type];
|
|
if (node.type === "decl") {
|
|
key = node.prop.toLowerCase();
|
|
} else if (node.type === "atrule") {
|
|
key = node.name.toLowerCase();
|
|
}
|
|
if (key && node.append) {
|
|
return [
|
|
type,
|
|
type + "-" + key,
|
|
CHILDREN,
|
|
type + "Exit",
|
|
type + "Exit-" + key
|
|
];
|
|
} else if (key) {
|
|
return [type, type + "-" + key, type + "Exit", type + "Exit-" + key];
|
|
} else if (node.append) {
|
|
return [type, CHILDREN, type + "Exit"];
|
|
} else {
|
|
return [type, type + "Exit"];
|
|
}
|
|
}
|
|
function toStack(node) {
|
|
let events;
|
|
if (node.type === "document") {
|
|
events = ["Document", CHILDREN, "DocumentExit"];
|
|
} else if (node.type === "root") {
|
|
events = ["Root", CHILDREN, "RootExit"];
|
|
} else {
|
|
events = getEvents(node);
|
|
}
|
|
return {
|
|
eventIndex: 0,
|
|
events,
|
|
iterator: 0,
|
|
node,
|
|
visitorIndex: 0,
|
|
visitors: []
|
|
};
|
|
}
|
|
function cleanMarks(node) {
|
|
node[isClean] = false;
|
|
if (node.nodes) node.nodes.forEach((i) => cleanMarks(i));
|
|
return node;
|
|
}
|
|
var postcss2 = {};
|
|
var LazyResult = class _LazyResult {
|
|
constructor(processor, css, opts) {
|
|
this.stringified = false;
|
|
this.processed = false;
|
|
let root2;
|
|
if (typeof css === "object" && css !== null && (css.type === "root" || css.type === "document")) {
|
|
root2 = cleanMarks(css);
|
|
} else if (css instanceof _LazyResult || css instanceof Result2) {
|
|
root2 = cleanMarks(css.root);
|
|
if (css.map) {
|
|
if (typeof opts.map === "undefined") opts.map = {};
|
|
if (!opts.map.inline) opts.map.inline = false;
|
|
opts.map.prev = css.map;
|
|
}
|
|
} else {
|
|
let parser = parse2;
|
|
if (opts.syntax) parser = opts.syntax.parse;
|
|
if (opts.parser) parser = opts.parser;
|
|
if (parser.parse) parser = parser.parse;
|
|
try {
|
|
root2 = parser(css, opts);
|
|
} catch (error) {
|
|
this.processed = true;
|
|
this.error = error;
|
|
}
|
|
if (root2 && !root2[my]) {
|
|
Container2.rebuild(root2);
|
|
}
|
|
}
|
|
this.result = new Result2(processor, root2, opts);
|
|
this.helpers = { ...postcss2, postcss: postcss2, result: this.result };
|
|
this.plugins = this.processor.plugins.map((plugin2) => {
|
|
if (typeof plugin2 === "object" && plugin2.prepare) {
|
|
return { ...plugin2, ...plugin2.prepare(this.result) };
|
|
} else {
|
|
return plugin2;
|
|
}
|
|
});
|
|
}
|
|
async() {
|
|
if (this.error) return Promise.reject(this.error);
|
|
if (this.processed) return Promise.resolve(this.result);
|
|
if (!this.processing) {
|
|
this.processing = this.runAsync();
|
|
}
|
|
return this.processing;
|
|
}
|
|
catch(onRejected) {
|
|
return this.async().catch(onRejected);
|
|
}
|
|
finally(onFinally) {
|
|
return this.async().then(onFinally, onFinally);
|
|
}
|
|
getAsyncError() {
|
|
throw new Error("Use process(css).then(cb) to work with async plugins");
|
|
}
|
|
handleError(error, node) {
|
|
let plugin2 = this.result.lastPlugin;
|
|
try {
|
|
if (node) node.addToError(error);
|
|
this.error = error;
|
|
if (error.name === "CssSyntaxError" && !error.plugin) {
|
|
error.plugin = plugin2.postcssPlugin;
|
|
error.setMessage();
|
|
} else if (plugin2.postcssVersion) {
|
|
if (true) {
|
|
let pluginName = plugin2.postcssPlugin;
|
|
let pluginVer = plugin2.postcssVersion;
|
|
let runtimeVer = this.result.processor.version;
|
|
let a = pluginVer.split(".");
|
|
let b = runtimeVer.split(".");
|
|
if (a[0] !== b[0] || parseInt(a[1]) > parseInt(b[1])) {
|
|
console.error(
|
|
"Unknown error from PostCSS plugin. Your current PostCSS version is " + runtimeVer + ", but " + pluginName + " uses " + pluginVer + ". Perhaps this is the source of the error below."
|
|
);
|
|
}
|
|
}
|
|
}
|
|
} catch (err) {
|
|
if (console && console.error) console.error(err);
|
|
}
|
|
return error;
|
|
}
|
|
prepareVisitors() {
|
|
this.listeners = {};
|
|
let add = (plugin2, type, cb) => {
|
|
if (!this.listeners[type]) this.listeners[type] = [];
|
|
this.listeners[type].push([plugin2, cb]);
|
|
};
|
|
for (let plugin2 of this.plugins) {
|
|
if (typeof plugin2 === "object") {
|
|
for (let event in plugin2) {
|
|
if (!PLUGIN_PROPS[event] && /^[A-Z]/.test(event)) {
|
|
throw new Error(
|
|
`Unknown event ${event} in ${plugin2.postcssPlugin}. Try to update PostCSS (${this.processor.version} now).`
|
|
);
|
|
}
|
|
if (!NOT_VISITORS[event]) {
|
|
if (typeof plugin2[event] === "object") {
|
|
for (let filter in plugin2[event]) {
|
|
if (filter === "*") {
|
|
add(plugin2, event, plugin2[event][filter]);
|
|
} else {
|
|
add(
|
|
plugin2,
|
|
event + "-" + filter.toLowerCase(),
|
|
plugin2[event][filter]
|
|
);
|
|
}
|
|
}
|
|
} else if (typeof plugin2[event] === "function") {
|
|
add(plugin2, event, plugin2[event]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
this.hasListener = Object.keys(this.listeners).length > 0;
|
|
}
|
|
async runAsync() {
|
|
this.plugin = 0;
|
|
for (let i = 0; i < this.plugins.length; i++) {
|
|
let plugin2 = this.plugins[i];
|
|
let promise = this.runOnRoot(plugin2);
|
|
if (isPromise(promise)) {
|
|
try {
|
|
await promise;
|
|
} catch (error) {
|
|
throw this.handleError(error);
|
|
}
|
|
}
|
|
}
|
|
this.prepareVisitors();
|
|
if (this.hasListener) {
|
|
let root2 = this.result.root;
|
|
while (!root2[isClean]) {
|
|
root2[isClean] = true;
|
|
let stack = [toStack(root2)];
|
|
while (stack.length > 0) {
|
|
let promise = this.visitTick(stack);
|
|
if (isPromise(promise)) {
|
|
try {
|
|
await promise;
|
|
} catch (e) {
|
|
let node = stack[stack.length - 1].node;
|
|
throw this.handleError(e, node);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (this.listeners.OnceExit) {
|
|
for (let [plugin2, visitor] of this.listeners.OnceExit) {
|
|
this.result.lastPlugin = plugin2;
|
|
try {
|
|
if (root2.type === "document") {
|
|
let roots = root2.nodes.map(
|
|
(subRoot) => visitor(subRoot, this.helpers)
|
|
);
|
|
await Promise.all(roots);
|
|
} else {
|
|
await visitor(root2, this.helpers);
|
|
}
|
|
} catch (e) {
|
|
throw this.handleError(e);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
this.processed = true;
|
|
return this.stringify();
|
|
}
|
|
runOnRoot(plugin2) {
|
|
this.result.lastPlugin = plugin2;
|
|
try {
|
|
if (typeof plugin2 === "object" && plugin2.Once) {
|
|
if (this.result.root.type === "document") {
|
|
let roots = this.result.root.nodes.map(
|
|
(root2) => plugin2.Once(root2, this.helpers)
|
|
);
|
|
if (isPromise(roots[0])) {
|
|
return Promise.all(roots);
|
|
}
|
|
return roots;
|
|
}
|
|
return plugin2.Once(this.result.root, this.helpers);
|
|
} else if (typeof plugin2 === "function") {
|
|
return plugin2(this.result.root, this.result);
|
|
}
|
|
} catch (error) {
|
|
throw this.handleError(error);
|
|
}
|
|
}
|
|
stringify() {
|
|
if (this.error) throw this.error;
|
|
if (this.stringified) return this.result;
|
|
this.stringified = true;
|
|
this.sync();
|
|
let opts = this.result.opts;
|
|
let str = stringify2;
|
|
if (opts.syntax) str = opts.syntax.stringify;
|
|
if (opts.stringifier) str = opts.stringifier;
|
|
if (str.stringify) str = str.stringify;
|
|
let map = new MapGenerator(str, this.result.root, this.result.opts);
|
|
let data = map.generate();
|
|
this.result.css = data[0];
|
|
this.result.map = data[1];
|
|
return this.result;
|
|
}
|
|
sync() {
|
|
if (this.error) throw this.error;
|
|
if (this.processed) return this.result;
|
|
this.processed = true;
|
|
if (this.processing) {
|
|
throw this.getAsyncError();
|
|
}
|
|
for (let plugin2 of this.plugins) {
|
|
let promise = this.runOnRoot(plugin2);
|
|
if (isPromise(promise)) {
|
|
throw this.getAsyncError();
|
|
}
|
|
}
|
|
this.prepareVisitors();
|
|
if (this.hasListener) {
|
|
let root2 = this.result.root;
|
|
while (!root2[isClean]) {
|
|
root2[isClean] = true;
|
|
this.walkSync(root2);
|
|
}
|
|
if (this.listeners.OnceExit) {
|
|
if (root2.type === "document") {
|
|
for (let subRoot of root2.nodes) {
|
|
this.visitSync(this.listeners.OnceExit, subRoot);
|
|
}
|
|
} else {
|
|
this.visitSync(this.listeners.OnceExit, root2);
|
|
}
|
|
}
|
|
}
|
|
return this.result;
|
|
}
|
|
then(onFulfilled, onRejected) {
|
|
if (true) {
|
|
if (!("from" in this.opts)) {
|
|
warnOnce(
|
|
"Without `from` option PostCSS could generate wrong source map and will not find Browserslist config. Set it to CSS file path or to `undefined` to prevent this warning."
|
|
);
|
|
}
|
|
}
|
|
return this.async().then(onFulfilled, onRejected);
|
|
}
|
|
toString() {
|
|
return this.css;
|
|
}
|
|
visitSync(visitors, node) {
|
|
for (let [plugin2, visitor] of visitors) {
|
|
this.result.lastPlugin = plugin2;
|
|
let promise;
|
|
try {
|
|
promise = visitor(node, this.helpers);
|
|
} catch (e) {
|
|
throw this.handleError(e, node.proxyOf);
|
|
}
|
|
if (node.type !== "root" && node.type !== "document" && !node.parent) {
|
|
return true;
|
|
}
|
|
if (isPromise(promise)) {
|
|
throw this.getAsyncError();
|
|
}
|
|
}
|
|
}
|
|
visitTick(stack) {
|
|
let visit = stack[stack.length - 1];
|
|
let { node, visitors } = visit;
|
|
if (node.type !== "root" && node.type !== "document" && !node.parent) {
|
|
stack.pop();
|
|
return;
|
|
}
|
|
if (visitors.length > 0 && visit.visitorIndex < visitors.length) {
|
|
let [plugin2, visitor] = visitors[visit.visitorIndex];
|
|
visit.visitorIndex += 1;
|
|
if (visit.visitorIndex === visitors.length) {
|
|
visit.visitors = [];
|
|
visit.visitorIndex = 0;
|
|
}
|
|
this.result.lastPlugin = plugin2;
|
|
try {
|
|
return visitor(node.toProxy(), this.helpers);
|
|
} catch (e) {
|
|
throw this.handleError(e, node);
|
|
}
|
|
}
|
|
if (visit.iterator !== 0) {
|
|
let iterator = visit.iterator;
|
|
let child;
|
|
while (child = node.nodes[node.indexes[iterator]]) {
|
|
node.indexes[iterator] += 1;
|
|
if (!child[isClean]) {
|
|
child[isClean] = true;
|
|
stack.push(toStack(child));
|
|
return;
|
|
}
|
|
}
|
|
visit.iterator = 0;
|
|
delete node.indexes[iterator];
|
|
}
|
|
let events = visit.events;
|
|
while (visit.eventIndex < events.length) {
|
|
let event = events[visit.eventIndex];
|
|
visit.eventIndex += 1;
|
|
if (event === CHILDREN) {
|
|
if (node.nodes && node.nodes.length) {
|
|
node[isClean] = true;
|
|
visit.iterator = node.getIterator();
|
|
}
|
|
return;
|
|
} else if (this.listeners[event]) {
|
|
visit.visitors = this.listeners[event];
|
|
return;
|
|
}
|
|
}
|
|
stack.pop();
|
|
}
|
|
walkSync(node) {
|
|
node[isClean] = true;
|
|
let events = getEvents(node);
|
|
for (let event of events) {
|
|
if (event === CHILDREN) {
|
|
if (node.nodes) {
|
|
node.each((child) => {
|
|
if (!child[isClean]) this.walkSync(child);
|
|
});
|
|
}
|
|
} else {
|
|
let visitors = this.listeners[event];
|
|
if (visitors) {
|
|
if (this.visitSync(visitors, node.toProxy())) return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
warnings() {
|
|
return this.sync().warnings();
|
|
}
|
|
get content() {
|
|
return this.stringify().content;
|
|
}
|
|
get css() {
|
|
return this.stringify().css;
|
|
}
|
|
get map() {
|
|
return this.stringify().map;
|
|
}
|
|
get messages() {
|
|
return this.sync().messages;
|
|
}
|
|
get opts() {
|
|
return this.result.opts;
|
|
}
|
|
get processor() {
|
|
return this.result.processor;
|
|
}
|
|
get root() {
|
|
return this.sync().root;
|
|
}
|
|
get [Symbol.toStringTag]() {
|
|
return "LazyResult";
|
|
}
|
|
};
|
|
LazyResult.registerPostcss = (dependant) => {
|
|
postcss2 = dependant;
|
|
};
|
|
module.exports = LazyResult;
|
|
LazyResult.default = LazyResult;
|
|
Root2.registerLazyResult(LazyResult);
|
|
Document2.registerLazyResult(LazyResult);
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/no-work-result.js
|
|
var require_no_work_result = __commonJS({
|
|
"node_modules/postcss/lib/no-work-result.js"(exports, module) {
|
|
"use strict";
|
|
var MapGenerator = require_map_generator();
|
|
var stringify2 = require_stringify();
|
|
var warnOnce = require_warn_once();
|
|
var parse2 = require_parse();
|
|
var Result2 = require_result();
|
|
var NoWorkResult = class {
|
|
constructor(processor, css, opts) {
|
|
css = css.toString();
|
|
this.stringified = false;
|
|
this._processor = processor;
|
|
this._css = css;
|
|
this._opts = opts;
|
|
this._map = void 0;
|
|
let root2;
|
|
let str = stringify2;
|
|
this.result = new Result2(this._processor, root2, this._opts);
|
|
this.result.css = css;
|
|
let self = this;
|
|
Object.defineProperty(this.result, "root", {
|
|
get() {
|
|
return self.root;
|
|
}
|
|
});
|
|
let map = new MapGenerator(str, root2, this._opts, css);
|
|
if (map.isMap()) {
|
|
let [generatedCSS, generatedMap] = map.generate();
|
|
if (generatedCSS) {
|
|
this.result.css = generatedCSS;
|
|
}
|
|
if (generatedMap) {
|
|
this.result.map = generatedMap;
|
|
}
|
|
} else {
|
|
map.clearAnnotation();
|
|
this.result.css = map.css;
|
|
}
|
|
}
|
|
async() {
|
|
if (this.error) return Promise.reject(this.error);
|
|
return Promise.resolve(this.result);
|
|
}
|
|
catch(onRejected) {
|
|
return this.async().catch(onRejected);
|
|
}
|
|
finally(onFinally) {
|
|
return this.async().then(onFinally, onFinally);
|
|
}
|
|
sync() {
|
|
if (this.error) throw this.error;
|
|
return this.result;
|
|
}
|
|
then(onFulfilled, onRejected) {
|
|
if (true) {
|
|
if (!("from" in this._opts)) {
|
|
warnOnce(
|
|
"Without `from` option PostCSS could generate wrong source map and will not find Browserslist config. Set it to CSS file path or to `undefined` to prevent this warning."
|
|
);
|
|
}
|
|
}
|
|
return this.async().then(onFulfilled, onRejected);
|
|
}
|
|
toString() {
|
|
return this._css;
|
|
}
|
|
warnings() {
|
|
return [];
|
|
}
|
|
get content() {
|
|
return this.result.css;
|
|
}
|
|
get css() {
|
|
return this.result.css;
|
|
}
|
|
get map() {
|
|
return this.result.map;
|
|
}
|
|
get messages() {
|
|
return [];
|
|
}
|
|
get opts() {
|
|
return this.result.opts;
|
|
}
|
|
get processor() {
|
|
return this.result.processor;
|
|
}
|
|
get root() {
|
|
if (this._root) {
|
|
return this._root;
|
|
}
|
|
let root2;
|
|
let parser = parse2;
|
|
try {
|
|
root2 = parser(this._css, this._opts);
|
|
} catch (error) {
|
|
this.error = error;
|
|
}
|
|
if (this.error) {
|
|
throw this.error;
|
|
} else {
|
|
this._root = root2;
|
|
return root2;
|
|
}
|
|
}
|
|
get [Symbol.toStringTag]() {
|
|
return "NoWorkResult";
|
|
}
|
|
};
|
|
module.exports = NoWorkResult;
|
|
NoWorkResult.default = NoWorkResult;
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/processor.js
|
|
var require_processor = __commonJS({
|
|
"node_modules/postcss/lib/processor.js"(exports, module) {
|
|
"use strict";
|
|
var NoWorkResult = require_no_work_result();
|
|
var LazyResult = require_lazy_result();
|
|
var Document2 = require_document();
|
|
var Root2 = require_root();
|
|
var Processor2 = class {
|
|
constructor(plugins = []) {
|
|
this.version = "8.4.40";
|
|
this.plugins = this.normalize(plugins);
|
|
}
|
|
normalize(plugins) {
|
|
let normalized = [];
|
|
for (let i of plugins) {
|
|
if (i.postcss === true) {
|
|
i = i();
|
|
} else if (i.postcss) {
|
|
i = i.postcss;
|
|
}
|
|
if (typeof i === "object" && Array.isArray(i.plugins)) {
|
|
normalized = normalized.concat(i.plugins);
|
|
} else if (typeof i === "object" && i.postcssPlugin) {
|
|
normalized.push(i);
|
|
} else if (typeof i === "function") {
|
|
normalized.push(i);
|
|
} else if (typeof i === "object" && (i.parse || i.stringify)) {
|
|
if (true) {
|
|
throw new Error(
|
|
"PostCSS syntaxes cannot be used as plugins. Instead, please use one of the syntax/parser/stringifier options as outlined in your PostCSS runner documentation."
|
|
);
|
|
}
|
|
} else {
|
|
throw new Error(i + " is not a PostCSS plugin");
|
|
}
|
|
}
|
|
return normalized;
|
|
}
|
|
process(css, opts = {}) {
|
|
if (!this.plugins.length && !opts.parser && !opts.stringifier && !opts.syntax) {
|
|
return new NoWorkResult(this, css, opts);
|
|
} else {
|
|
return new LazyResult(this, css, opts);
|
|
}
|
|
}
|
|
use(plugin2) {
|
|
this.plugins = this.plugins.concat(this.normalize([plugin2]));
|
|
return this;
|
|
}
|
|
};
|
|
module.exports = Processor2;
|
|
Processor2.default = Processor2;
|
|
Root2.registerProcessor(Processor2);
|
|
Document2.registerProcessor(Processor2);
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/fromJSON.js
|
|
var require_fromJSON = __commonJS({
|
|
"node_modules/postcss/lib/fromJSON.js"(exports, module) {
|
|
"use strict";
|
|
var Declaration2 = require_declaration();
|
|
var PreviousMap = require_previous_map();
|
|
var Comment2 = require_comment();
|
|
var AtRule2 = require_at_rule();
|
|
var Input2 = require_input();
|
|
var Root2 = require_root();
|
|
var Rule2 = require_rule();
|
|
function fromJSON2(json, inputs) {
|
|
if (Array.isArray(json)) return json.map((n) => fromJSON2(n));
|
|
let { inputs: ownInputs, ...defaults } = json;
|
|
if (ownInputs) {
|
|
inputs = [];
|
|
for (let input of ownInputs) {
|
|
let inputHydrated = { ...input, __proto__: Input2.prototype };
|
|
if (inputHydrated.map) {
|
|
inputHydrated.map = {
|
|
...inputHydrated.map,
|
|
__proto__: PreviousMap.prototype
|
|
};
|
|
}
|
|
inputs.push(inputHydrated);
|
|
}
|
|
}
|
|
if (defaults.nodes) {
|
|
defaults.nodes = json.nodes.map((n) => fromJSON2(n, inputs));
|
|
}
|
|
if (defaults.source) {
|
|
let { inputId, ...source } = defaults.source;
|
|
defaults.source = source;
|
|
if (inputId != null) {
|
|
defaults.source.input = inputs[inputId];
|
|
}
|
|
}
|
|
if (defaults.type === "root") {
|
|
return new Root2(defaults);
|
|
} else if (defaults.type === "decl") {
|
|
return new Declaration2(defaults);
|
|
} else if (defaults.type === "rule") {
|
|
return new Rule2(defaults);
|
|
} else if (defaults.type === "comment") {
|
|
return new Comment2(defaults);
|
|
} else if (defaults.type === "atrule") {
|
|
return new AtRule2(defaults);
|
|
} else {
|
|
throw new Error("Unknown node type: " + json.type);
|
|
}
|
|
}
|
|
module.exports = fromJSON2;
|
|
fromJSON2.default = fromJSON2;
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/postcss.js
|
|
var require_postcss = __commonJS({
|
|
"node_modules/postcss/lib/postcss.js"(exports, module) {
|
|
"use strict";
|
|
var CssSyntaxError2 = require_css_syntax_error();
|
|
var Declaration2 = require_declaration();
|
|
var LazyResult = require_lazy_result();
|
|
var Container2 = require_container();
|
|
var Processor2 = require_processor();
|
|
var stringify2 = require_stringify();
|
|
var fromJSON2 = require_fromJSON();
|
|
var Document2 = require_document();
|
|
var Warning2 = require_warning();
|
|
var Comment2 = require_comment();
|
|
var AtRule2 = require_at_rule();
|
|
var Result2 = require_result();
|
|
var Input2 = require_input();
|
|
var parse2 = require_parse();
|
|
var list2 = require_list();
|
|
var Rule2 = require_rule();
|
|
var Root2 = require_root();
|
|
var Node2 = require_node();
|
|
function postcss2(...plugins) {
|
|
if (plugins.length === 1 && Array.isArray(plugins[0])) {
|
|
plugins = plugins[0];
|
|
}
|
|
return new Processor2(plugins);
|
|
}
|
|
postcss2.plugin = function plugin2(name, initializer) {
|
|
let warningPrinted = false;
|
|
function creator(...args) {
|
|
if (console && console.warn && !warningPrinted) {
|
|
warningPrinted = true;
|
|
console.warn(
|
|
name + ": postcss.plugin was deprecated. Migration guide:\nhttps://evilmartians.com/chronicles/postcss-8-plugin-migration"
|
|
);
|
|
if (process.env.LANG && process.env.LANG.startsWith("cn")) {
|
|
console.warn(
|
|
name + ": 里面 postcss.plugin 被弃用. 迁移指南:\nhttps://www.w3ctech.com/topic/2226"
|
|
);
|
|
}
|
|
}
|
|
let transformer = initializer(...args);
|
|
transformer.postcssPlugin = name;
|
|
transformer.postcssVersion = new Processor2().version;
|
|
return transformer;
|
|
}
|
|
let cache;
|
|
Object.defineProperty(creator, "postcss", {
|
|
get() {
|
|
if (!cache) cache = creator();
|
|
return cache;
|
|
}
|
|
});
|
|
creator.process = function(css, processOpts, pluginOpts) {
|
|
return postcss2([creator(pluginOpts)]).process(css, processOpts);
|
|
};
|
|
return creator;
|
|
};
|
|
postcss2.stringify = stringify2;
|
|
postcss2.parse = parse2;
|
|
postcss2.fromJSON = fromJSON2;
|
|
postcss2.list = list2;
|
|
postcss2.comment = (defaults) => new Comment2(defaults);
|
|
postcss2.atRule = (defaults) => new AtRule2(defaults);
|
|
postcss2.decl = (defaults) => new Declaration2(defaults);
|
|
postcss2.rule = (defaults) => new Rule2(defaults);
|
|
postcss2.root = (defaults) => new Root2(defaults);
|
|
postcss2.document = (defaults) => new Document2(defaults);
|
|
postcss2.CssSyntaxError = CssSyntaxError2;
|
|
postcss2.Declaration = Declaration2;
|
|
postcss2.Container = Container2;
|
|
postcss2.Processor = Processor2;
|
|
postcss2.Document = Document2;
|
|
postcss2.Comment = Comment2;
|
|
postcss2.Warning = Warning2;
|
|
postcss2.AtRule = AtRule2;
|
|
postcss2.Result = Result2;
|
|
postcss2.Input = Input2;
|
|
postcss2.Rule = Rule2;
|
|
postcss2.Root = Root2;
|
|
postcss2.Node = Node2;
|
|
LazyResult.registerPostcss(postcss2);
|
|
module.exports = postcss2;
|
|
postcss2.default = postcss2;
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/postcss.mjs
|
|
var import_postcss = __toESM(require_postcss(), 1);
|
|
var postcss_default = import_postcss.default;
|
|
var stringify = import_postcss.default.stringify;
|
|
var fromJSON = import_postcss.default.fromJSON;
|
|
var plugin = import_postcss.default.plugin;
|
|
var parse = import_postcss.default.parse;
|
|
var list = import_postcss.default.list;
|
|
var document = import_postcss.default.document;
|
|
var comment = import_postcss.default.comment;
|
|
var atRule = import_postcss.default.atRule;
|
|
var rule = import_postcss.default.rule;
|
|
var decl = import_postcss.default.decl;
|
|
var root = import_postcss.default.root;
|
|
var CssSyntaxError = import_postcss.default.CssSyntaxError;
|
|
var Declaration = import_postcss.default.Declaration;
|
|
var Container = import_postcss.default.Container;
|
|
var Processor = import_postcss.default.Processor;
|
|
var Document = import_postcss.default.Document;
|
|
var Comment = import_postcss.default.Comment;
|
|
var Warning = import_postcss.default.Warning;
|
|
var AtRule = import_postcss.default.AtRule;
|
|
var Result = import_postcss.default.Result;
|
|
var Input = import_postcss.default.Input;
|
|
var Rule = import_postcss.default.Rule;
|
|
var Root = import_postcss.default.Root;
|
|
var Node = import_postcss.default.Node;
|
|
|
|
export {
|
|
postcss_default,
|
|
stringify,
|
|
fromJSON,
|
|
plugin,
|
|
parse,
|
|
list,
|
|
document,
|
|
comment,
|
|
atRule,
|
|
rule,
|
|
decl,
|
|
root,
|
|
CssSyntaxError,
|
|
Declaration,
|
|
Container,
|
|
Processor,
|
|
Document,
|
|
Comment,
|
|
Warning,
|
|
AtRule,
|
|
Result,
|
|
Input,
|
|
Rule,
|
|
Root,
|
|
Node
|
|
};
|
|
//# sourceMappingURL=chunk-7522MNHT.js.map
|