e860485ec8
svg2pptx.py: - 修复image opacity不生效（通过OOXML alphaModFix） - 修复环形图stroke渐变url(#id)引用不支持（fallback第一个stop颜色） - 修复viewBox内缩放不传递（g组scale累积到所有子元素） - 修复text baseline偏移（区分text-after-edge和auto） - 修复text-anchor:middle/end的x坐标偏移 - 添加--html-dir参数支持 html2svg.py: - 修复图片相对路径解析（以HTML文件所在目录为基准） - 新增3种CSS兜底预处理（background-clip:text、text-fill-color、mask-image） 新增 references/pipeline-compat.md: - HTML->SVG->PPTX管线兼容性规则文档 - CSS禁止清单、防偏移写法指南、防偏移checklist - 已整合到SKILL.md和prompts.md中引用 prompts.md: - 新增内联SVG防偏移约束（禁SVG text、用HTML叠加） 示例产物: - ppt-output/ 包含SU7示例的完整HTML/SVG/PPTX产物
6252 lines
224 KiB
JavaScript
6252 lines
224 KiB
JavaScript
(() => {
|
|
var __create = Object.create;
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __getProtoOf = Object.getPrototypeOf;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __commonJS = (cb, mod) => function __require() {
|
|
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
|
|
};
|
|
var __copyProps = (to, from, except, desc) => {
|
|
if (from && typeof from === "object" || typeof from === "function") {
|
|
for (let key of __getOwnPropNames(from))
|
|
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
}
|
|
return to;
|
|
};
|
|
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
|
// If the importer is in node compatibility mode or this is not an ESM
|
|
// file that has been converted to a CommonJS file using a Babel-
|
|
// compatible transform (i.e. "__esModule" has not been set), then set
|
|
// "default" to the CommonJS "module.exports" for node compatibility.
|
|
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
|
mod
|
|
));
|
|
|
|
// 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, blackBright: x, redBright: x, greenBright: x, yellowBright: x, blueBright: x, magentaBright: x, cyanBright: x, whiteBright: x, bgBlackBright: x, bgRedBright: x, bgGreenBright: x, bgYellowBright: x, bgBlueBright: x, bgMagentaBright: x, bgCyanBright: x, bgWhiteBright: 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;
|
|
let aside = (text) => text;
|
|
let mark = (text) => text;
|
|
let highlight = (text) => text;
|
|
if (color) {
|
|
let { bold, gray, red } = pico.createColors(true);
|
|
mark = (text) => bold(red(text));
|
|
aside = (text) => gray(text);
|
|
if (terminalHighlight) {
|
|
highlight = (text) => terminalHighlight(text);
|
|
}
|
|
}
|
|
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;
|
|
return lines.slice(start, end).map((line, index) => {
|
|
let number = start + 1 + index;
|
|
let gutter = " " + (" " + number).slice(-maxWidth) + " | ";
|
|
if (number === this.line) {
|
|
if (line.length > 160) {
|
|
let padding = 20;
|
|
let subLineStart = Math.max(0, this.column - padding);
|
|
let subLineEnd = Math.max(
|
|
this.column + padding,
|
|
this.endColumn + padding
|
|
);
|
|
let subLine = line.slice(subLineStart, subLineEnd);
|
|
let spacing2 = aside(gutter.replace(/\d/g, " ")) + line.slice(0, Math.min(this.column - 1, padding - 1)).replace(/[^\t]/g, " ");
|
|
return mark(">") + aside(gutter) + highlight(subLine) + "\n " + spacing2 + mark("^");
|
|
}
|
|
let spacing = aside(gutter.replace(/\d/g, " ")) + line.slice(0, this.column - 1).replace(/[^\t]/g, " ");
|
|
return mark(">") + aside(gutter) + highlight(line) + "\n " + spacing + mark("^");
|
|
}
|
|
return " " + aside(gutter) + highlight(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/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 stringify3(node, builder) {
|
|
let str = new Stringifier(builder);
|
|
str.stringify(node);
|
|
}
|
|
module.exports = stringify3;
|
|
stringify3.default = stringify3;
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/symbols.js
|
|
var require_symbols = __commonJS({
|
|
"node_modules/postcss/lib/symbols.js"(exports, module) {
|
|
"use strict";
|
|
module.exports.isClean = /* @__PURE__ */ Symbol("isClean");
|
|
module.exports.my = /* @__PURE__ */ Symbol("my");
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/node.js
|
|
var require_node = __commonJS({
|
|
"node_modules/postcss/lib/node.js"(exports, module) {
|
|
"use strict";
|
|
var CssSyntaxError2 = require_css_syntax_error();
|
|
var Stringifier = require_stringifier();
|
|
var stringify3 = require_stringify();
|
|
var { isClean, my } = require_symbols();
|
|
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;
|
|
}
|
|
function sourceOffset(inputCSS, position) {
|
|
if (position && typeof position.offset !== "undefined") {
|
|
return position.offset;
|
|
}
|
|
let column = 1;
|
|
let line = 1;
|
|
let offset = 0;
|
|
for (let i = 0; i < inputCSS.length; i++) {
|
|
if (line === position.line && column === position.column) {
|
|
offset = i;
|
|
break;
|
|
}
|
|
if (inputCSS[i] === "\n") {
|
|
column = 1;
|
|
line += 1;
|
|
} else {
|
|
column += 1;
|
|
}
|
|
}
|
|
return offset;
|
|
}
|
|
var Node3 = class {
|
|
get proxyOf() {
|
|
return this;
|
|
}
|
|
constructor(defaults2 = {}) {
|
|
this.raws = {};
|
|
this[isClean] = false;
|
|
this[my] = true;
|
|
for (let name in defaults2) {
|
|
if (name === "nodes") {
|
|
this.nodes = [];
|
|
for (let node of defaults2[name]) {
|
|
if (typeof node.clone === "function") {
|
|
this.append(node.clone());
|
|
} else {
|
|
this.append(node);
|
|
}
|
|
}
|
|
} else {
|
|
this[name] = defaults2[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;
|
|
}
|
|
};
|
|
}
|
|
/* c8 ignore next 3 */
|
|
markClean() {
|
|
this[isClean] = 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 = {}) {
|
|
let pos = this.source.start;
|
|
if (opts.index) {
|
|
pos = this.positionInside(opts.index);
|
|
} else if (opts.word) {
|
|
let inputString = "document" in this.source.input ? this.source.input.document : this.source.input.css;
|
|
let stringRepresentation = inputString.slice(
|
|
sourceOffset(inputString, this.source.start),
|
|
sourceOffset(inputString, this.source.end)
|
|
);
|
|
let index = stringRepresentation.indexOf(opts.word);
|
|
if (index !== -1) pos = this.positionInside(index);
|
|
}
|
|
return pos;
|
|
}
|
|
positionInside(index) {
|
|
let column = this.source.start.column;
|
|
let line = this.source.start.line;
|
|
let inputString = "document" in this.source.input ? this.source.input.document : this.source.input.css;
|
|
let offset = sourceOffset(inputString, this.source.start);
|
|
let end = offset + index;
|
|
for (let i = offset; i < end; i++) {
|
|
if (inputString[i] === "\n") {
|
|
column = 1;
|
|
line += 1;
|
|
} else {
|
|
column += 1;
|
|
}
|
|
}
|
|
return { column, line, offset: end };
|
|
}
|
|
prev() {
|
|
if (!this.parent) return void 0;
|
|
let index = this.parent.index(this);
|
|
return this.parent.nodes[index - 1];
|
|
}
|
|
rangeBy(opts = {}) {
|
|
let inputString = "document" in this.source.input ? this.source.input.document : this.source.input.css;
|
|
let start = {
|
|
column: this.source.start.column,
|
|
line: this.source.start.line,
|
|
offset: sourceOffset(inputString, this.source.start)
|
|
};
|
|
let end = this.source.end ? {
|
|
column: this.source.end.column + 1,
|
|
line: this.source.end.line,
|
|
offset: typeof this.source.end.offset === "number" ? (
|
|
// `source.end.offset` is exclusive, so we don't need to add 1
|
|
this.source.end.offset
|
|
) : (
|
|
// Since line/column in this.source.end is inclusive,
|
|
// the `sourceOffset(... , this.source.end)` returns an inclusive offset.
|
|
// So, we add 1 to convert it to exclusive.
|
|
sourceOffset(inputString, this.source.end) + 1
|
|
)
|
|
} : {
|
|
column: start.column + 1,
|
|
line: start.line,
|
|
offset: start.offset + 1
|
|
};
|
|
if (opts.word) {
|
|
let stringRepresentation = inputString.slice(
|
|
sourceOffset(inputString, this.source.start),
|
|
sourceOffset(inputString, this.source.end)
|
|
);
|
|
let index = stringRepresentation.indexOf(opts.word);
|
|
if (index !== -1) {
|
|
start = this.positionInside(index);
|
|
end = this.positionInside(index + opts.word.length);
|
|
}
|
|
} else {
|
|
if (opts.start) {
|
|
start = {
|
|
column: opts.start.column,
|
|
line: opts.start.line,
|
|
offset: sourceOffset(inputString, opts.start)
|
|
};
|
|
} else if (opts.index) {
|
|
start = this.positionInside(opts.index);
|
|
}
|
|
if (opts.end) {
|
|
end = {
|
|
column: opts.end.column,
|
|
line: opts.end.line,
|
|
offset: sourceOffset(inputString, opts.end)
|
|
};
|
|
} 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,
|
|
offset: start.offset + 1
|
|
};
|
|
}
|
|
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") {
|
|
if (value == null) continue;
|
|
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 = stringify3) {
|
|
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);
|
|
}
|
|
};
|
|
module.exports = Node3;
|
|
Node3.default = Node3;
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/comment.js
|
|
var require_comment = __commonJS({
|
|
"node_modules/postcss/lib/comment.js"(exports, module) {
|
|
"use strict";
|
|
var Node3 = require_node();
|
|
var Comment2 = class extends Node3 {
|
|
constructor(defaults2) {
|
|
super(defaults2);
|
|
this.type = "comment";
|
|
}
|
|
};
|
|
module.exports = Comment2;
|
|
Comment2.default = Comment2;
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/declaration.js
|
|
var require_declaration = __commonJS({
|
|
"node_modules/postcss/lib/declaration.js"(exports, module) {
|
|
"use strict";
|
|
var Node3 = require_node();
|
|
var Declaration2 = class extends Node3 {
|
|
get variable() {
|
|
return this.prop.startsWith("--") || this.prop[0] === "$";
|
|
}
|
|
constructor(defaults2) {
|
|
if (defaults2 && typeof defaults2.value !== "undefined" && typeof defaults2.value !== "string") {
|
|
defaults2 = { ...defaults2, value: String(defaults2.value) };
|
|
}
|
|
super(defaults2);
|
|
this.type = "decl";
|
|
}
|
|
};
|
|
module.exports = Declaration2;
|
|
Declaration2.default = Declaration2;
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/container.js
|
|
var require_container = __commonJS({
|
|
"node_modules/postcss/lib/container.js"(exports, module) {
|
|
"use strict";
|
|
var Comment2 = require_comment();
|
|
var Declaration2 = require_declaration();
|
|
var Node3 = require_node();
|
|
var { isClean, my } = require_symbols();
|
|
var AtRule2;
|
|
var parse3;
|
|
var Root2;
|
|
var Rule2;
|
|
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 Node3 {
|
|
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];
|
|
}
|
|
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(parse3(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.selectors) {
|
|
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 (!i.raws) i.raws = {};
|
|
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);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
Container2.registerParse = (dependant) => {
|
|
parse3 = 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/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(defaults2) {
|
|
super(defaults2);
|
|
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/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(defaults2) {
|
|
super({ type: "document", ...defaults2 });
|
|
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/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 | 0;
|
|
while (i--) {
|
|
id += alphabet[Math.random() * alphabet.length | 0];
|
|
}
|
|
return id;
|
|
};
|
|
};
|
|
var nanoid = (size = 21) => {
|
|
let id = "";
|
|
let i = size | 0;
|
|
while (i--) {
|
|
id += urlAlphabet[Math.random() * 64 | 0];
|
|
}
|
|
return id;
|
|
};
|
|
module.exports = { nanoid, customAlphabet };
|
|
}
|
|
});
|
|
|
|
// (disabled):path
|
|
var require_path = __commonJS({
|
|
"(disabled):path"() {
|
|
}
|
|
});
|
|
|
|
// (disabled):node_modules/source-map-js/source-map.js
|
|
var require_source_map = __commonJS({
|
|
"(disabled):node_modules/source-map-js/source-map.js"() {
|
|
}
|
|
});
|
|
|
|
// (disabled):url
|
|
var require_url = __commonJS({
|
|
"(disabled):url"() {
|
|
}
|
|
});
|
|
|
|
// (disabled):fs
|
|
var require_fs = __commonJS({
|
|
"(disabled):fs"() {
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/previous-map.js
|
|
var require_previous_map = __commonJS({
|
|
"node_modules/postcss/lib/previous-map.js"(exports, module) {
|
|
"use strict";
|
|
var { existsSync, readFileSync } = require_fs();
|
|
var { dirname, join } = require_path();
|
|
var { SourceMapConsumer, SourceMapGenerator } = require_source_map();
|
|
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,/;
|
|
let uriMatch = text.match(charsetUri) || text.match(uri);
|
|
if (uriMatch) {
|
|
return decodeURIComponent(text.substr(uriMatch[0].length));
|
|
}
|
|
let baseUriMatch = text.match(baseCharsetUri) || text.match(baseUri);
|
|
if (baseUriMatch) {
|
|
return fromBase64(text.substr(baseUriMatch[0].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=/g);
|
|
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 { nanoid } = require_non_secure();
|
|
var { isAbsolute, resolve } = require_path();
|
|
var { SourceMapConsumer, SourceMapGenerator } = require_source_map();
|
|
var { fileURLToPath, pathToFileURL } = require_url();
|
|
var CssSyntaxError2 = require_css_syntax_error();
|
|
var PreviousMap = require_previous_map();
|
|
var terminalHighlight = require_terminal_highlight();
|
|
var lineToIndexCache = /* @__PURE__ */ Symbol("lineToIndexCache");
|
|
var sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator);
|
|
var pathAvailable = Boolean(resolve && isAbsolute);
|
|
function getLineToIndex(input) {
|
|
if (input[lineToIndexCache]) return input[lineToIndexCache];
|
|
let lines = input.css.split("\n");
|
|
let 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;
|
|
}
|
|
input[lineToIndexCache] = lineToIndex;
|
|
return lineToIndex;
|
|
}
|
|
var Input2 = class {
|
|
get from() {
|
|
return this.file || this.id;
|
|
}
|
|
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] === "\uFFFE") {
|
|
this.hasBOM = true;
|
|
this.css = this.css.slice(1);
|
|
} else {
|
|
this.hasBOM = false;
|
|
}
|
|
this.document = this.css;
|
|
if (opts.document) this.document = opts.document.toString();
|
|
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 endColumn, endLine, endOffset, offset, result;
|
|
if (line && typeof line === "object") {
|
|
let start = line;
|
|
let end = column;
|
|
if (typeof start.offset === "number") {
|
|
offset = start.offset;
|
|
let pos = this.fromOffset(offset);
|
|
line = pos.line;
|
|
column = pos.col;
|
|
} else {
|
|
line = start.line;
|
|
column = start.column;
|
|
offset = this.fromLineAndColumn(line, column);
|
|
}
|
|
if (typeof end.offset === "number") {
|
|
endOffset = end.offset;
|
|
let pos = this.fromOffset(endOffset);
|
|
endLine = pos.line;
|
|
endColumn = pos.col;
|
|
} else {
|
|
endLine = end.line;
|
|
endColumn = end.column;
|
|
endOffset = this.fromLineAndColumn(end.line, end.column);
|
|
}
|
|
} else if (!column) {
|
|
offset = line;
|
|
let pos = this.fromOffset(offset);
|
|
line = pos.line;
|
|
column = pos.col;
|
|
} else {
|
|
offset = this.fromLineAndColumn(line, column);
|
|
}
|
|
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, endOffset, line, offset, source: this.css };
|
|
if (this.file) {
|
|
if (pathToFileURL) {
|
|
result.input.url = pathToFileURL(this.file).toString();
|
|
}
|
|
result.input.file = this.file;
|
|
}
|
|
return result;
|
|
}
|
|
fromLineAndColumn(line, column) {
|
|
let lineToIndex = getLineToIndex(this);
|
|
let index = lineToIndex[line - 1];
|
|
return index + column - 1;
|
|
}
|
|
fromOffset(offset) {
|
|
let lineToIndex = getLineToIndex(this);
|
|
let 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;
|
|
}
|
|
};
|
|
module.exports = Input2;
|
|
Input2.default = Input2;
|
|
if (terminalHighlight && terminalHighlight.registerInput) {
|
|
terminalHighlight.registerInput(Input2);
|
|
}
|
|
}
|
|
});
|
|
|
|
// 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(defaults2) {
|
|
super(defaults2);
|
|
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 {
|
|
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);
|
|
}
|
|
constructor(defaults2) {
|
|
super(defaults2);
|
|
this.type = "rule";
|
|
if (!this.nodes) this.nodes = [];
|
|
}
|
|
};
|
|
module.exports = Rule2;
|
|
Rule2.default = Rule2;
|
|
Container2.registerRule(Rule2);
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/fromJSON.js
|
|
var require_fromJSON = __commonJS({
|
|
"node_modules/postcss/lib/fromJSON.js"(exports, module) {
|
|
"use strict";
|
|
var AtRule2 = require_at_rule();
|
|
var Comment2 = require_comment();
|
|
var Declaration2 = require_declaration();
|
|
var Input2 = require_input();
|
|
var PreviousMap = require_previous_map();
|
|
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, ...defaults2 } = 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 (defaults2.nodes) {
|
|
defaults2.nodes = json.nodes.map((n) => fromJSON2(n, inputs));
|
|
}
|
|
if (defaults2.source) {
|
|
let { inputId, ...source } = defaults2.source;
|
|
defaults2.source = source;
|
|
if (inputId != null) {
|
|
defaults2.source.input = inputs[inputId];
|
|
}
|
|
}
|
|
if (defaults2.type === "root") {
|
|
return new Root2(defaults2);
|
|
} else if (defaults2.type === "decl") {
|
|
return new Declaration2(defaults2);
|
|
} else if (defaults2.type === "rule") {
|
|
return new Rule2(defaults2);
|
|
} else if (defaults2.type === "comment") {
|
|
return new Comment2(defaults2);
|
|
} else if (defaults2.type === "atrule") {
|
|
return new AtRule2(defaults2);
|
|
} else {
|
|
throw new Error("Unknown node type: " + json.type);
|
|
}
|
|
}
|
|
module.exports = fromJSON2;
|
|
fromJSON2.default = fromJSON2;
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/map-generator.js
|
|
var require_map_generator = __commonJS({
|
|
"node_modules/postcss/lib/map-generator.js"(exports, module) {
|
|
"use strict";
|
|
var { dirname, relative, resolve, sep } = require_path();
|
|
var { SourceMapConsumer, SourceMapGenerator } = require_source_map();
|
|
var { pathToFileURL } = require_url();
|
|
var Input2 = require_input();
|
|
var sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator);
|
|
var pathAvailable = Boolean(dirname && resolve && relative && sep);
|
|
var MapGenerator = class {
|
|
constructor(stringify3, root2, opts, cssString) {
|
|
this.stringify = stringify3;
|
|
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.startsWith("# sourceMappingURL=")) {
|
|
this.root.removeChild(i);
|
|
}
|
|
}
|
|
} else if (this.css) {
|
|
let startIndex;
|
|
while ((startIndex = this.css.lastIndexOf("/*#")) !== -1) {
|
|
let endIndex = this.css.indexOf("*/", startIndex + 3);
|
|
if (endIndex === -1) break;
|
|
while (startIndex > 0 && this.css[startIndex - 1] === "\n") {
|
|
startIndex--;
|
|
}
|
|
this.css = this.css.slice(0, startIndex) + this.css.slice(endIndex + 2);
|
|
}
|
|
}
|
|
}
|
|
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 last, lines;
|
|
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/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, content, escape, next, quote;
|
|
let currentToken, escaped, escapePos, n, prev;
|
|
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/parser.js
|
|
var require_parser = __commonJS({
|
|
"node_modules/postcss/lib/parser.js"(exports, module) {
|
|
"use strict";
|
|
var AtRule2 = require_at_rule();
|
|
var Comment2 = require_comment();
|
|
var Declaration2 = require_declaration();
|
|
var Root2 = require_root();
|
|
var Rule2 = require_rule();
|
|
var tokenizer = require_tokenize();
|
|
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 prev, token, type;
|
|
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 (!text.trim()) {
|
|
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().startsWith("!") && type !== "space") {
|
|
break;
|
|
}
|
|
str = cache.pop()[1] + str;
|
|
}
|
|
if (str.trim().startsWith("!")) {
|
|
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 = "";
|
|
prev.source.end = this.getPosition(token[2]);
|
|
prev.source.end.offset += prev.raws.ownSemicolon.length;
|
|
}
|
|
}
|
|
}
|
|
// 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 " + tokens[0][1],
|
|
{ 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 Input2 = require_input();
|
|
var Parser = require_parser();
|
|
function parse3(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 = parse3;
|
|
parse3.default = parse3;
|
|
Container2.registerParse(parse3);
|
|
}
|
|
});
|
|
|
|
// 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 {
|
|
get content() {
|
|
return this.css;
|
|
}
|
|
constructor(processor, root2, opts) {
|
|
this.processor = processor;
|
|
this.messages = [];
|
|
this.root = root2;
|
|
this.opts = opts;
|
|
this.css = "";
|
|
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");
|
|
}
|
|
};
|
|
module.exports = Result2;
|
|
Result2.default = Result2;
|
|
}
|
|
});
|
|
|
|
// 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/lazy-result.js
|
|
var require_lazy_result = __commonJS({
|
|
"node_modules/postcss/lib/lazy-result.js"(exports, module) {
|
|
"use strict";
|
|
var Container2 = require_container();
|
|
var Document2 = require_document();
|
|
var MapGenerator = require_map_generator();
|
|
var parse3 = require_parse();
|
|
var Result2 = require_result();
|
|
var Root2 = require_root();
|
|
var stringify3 = require_stringify();
|
|
var { isClean, my } = require_symbols();
|
|
var warnOnce = require_warn_once();
|
|
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 {
|
|
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";
|
|
}
|
|
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 = parse3;
|
|
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 = stringify3;
|
|
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();
|
|
}
|
|
};
|
|
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 parse3 = require_parse();
|
|
var Result2 = require_result();
|
|
var stringify3 = require_stringify();
|
|
var warnOnce = require_warn_once();
|
|
var NoWorkResult = class {
|
|
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 = parse3;
|
|
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";
|
|
}
|
|
constructor(processor, css, opts) {
|
|
css = css.toString();
|
|
this.stringified = false;
|
|
this._processor = processor;
|
|
this._css = css;
|
|
this._opts = opts;
|
|
this._map = void 0;
|
|
let str = stringify3;
|
|
this.result = new Result2(this._processor, void 0, this._opts);
|
|
this.result.css = css;
|
|
let self = this;
|
|
Object.defineProperty(this.result, "root", {
|
|
get() {
|
|
return self.root;
|
|
}
|
|
});
|
|
let map = new MapGenerator(str, void 0, 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 [];
|
|
}
|
|
};
|
|
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 Document2 = require_document();
|
|
var LazyResult = require_lazy_result();
|
|
var NoWorkResult = require_no_work_result();
|
|
var Root2 = require_root();
|
|
var Processor2 = class {
|
|
constructor(plugins = []) {
|
|
this.version = "8.5.8";
|
|
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/postcss.js
|
|
var require_postcss = __commonJS({
|
|
"node_modules/postcss/lib/postcss.js"(exports, module) {
|
|
"use strict";
|
|
var AtRule2 = require_at_rule();
|
|
var Comment2 = require_comment();
|
|
var Container2 = require_container();
|
|
var CssSyntaxError2 = require_css_syntax_error();
|
|
var Declaration2 = require_declaration();
|
|
var Document2 = require_document();
|
|
var fromJSON2 = require_fromJSON();
|
|
var Input2 = require_input();
|
|
var LazyResult = require_lazy_result();
|
|
var list2 = require_list();
|
|
var Node3 = require_node();
|
|
var parse3 = require_parse();
|
|
var Processor2 = require_processor();
|
|
var Result2 = require_result();
|
|
var Root2 = require_root();
|
|
var Rule2 = require_rule();
|
|
var stringify3 = require_stringify();
|
|
var Warning2 = require_warning();
|
|
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 + ": \u91CC\u9762 postcss.plugin \u88AB\u5F03\u7528. \u8FC1\u79FB\u6307\u5357:\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 = stringify3;
|
|
postcss2.parse = parse3;
|
|
postcss2.fromJSON = fromJSON2;
|
|
postcss2.list = list2;
|
|
postcss2.comment = (defaults2) => new Comment2(defaults2);
|
|
postcss2.atRule = (defaults2) => new AtRule2(defaults2);
|
|
postcss2.decl = (defaults2) => new Declaration2(defaults2);
|
|
postcss2.rule = (defaults2) => new Rule2(defaults2);
|
|
postcss2.root = (defaults2) => new Root2(defaults2);
|
|
postcss2.document = (defaults2) => new Document2(defaults2);
|
|
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 = Node3;
|
|
LazyResult.registerPostcss(postcss2);
|
|
module.exports = postcss2;
|
|
postcss2.default = postcss2;
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss-value-parser/lib/parse.js
|
|
var require_parse2 = __commonJS({
|
|
"node_modules/postcss-value-parser/lib/parse.js"(exports, module) {
|
|
var openParentheses = "(".charCodeAt(0);
|
|
var closeParentheses = ")".charCodeAt(0);
|
|
var singleQuote = "'".charCodeAt(0);
|
|
var doubleQuote = '"'.charCodeAt(0);
|
|
var backslash = "\\".charCodeAt(0);
|
|
var slash = "/".charCodeAt(0);
|
|
var comma = ",".charCodeAt(0);
|
|
var colon = ":".charCodeAt(0);
|
|
var star = "*".charCodeAt(0);
|
|
var uLower = "u".charCodeAt(0);
|
|
var uUpper = "U".charCodeAt(0);
|
|
var plus = "+".charCodeAt(0);
|
|
var isUnicodeRange = /^[a-f0-9?-]+$/i;
|
|
module.exports = function(input) {
|
|
var tokens = [];
|
|
var value = input;
|
|
var next, quote, prev, token, escape, escapePos, whitespacePos, parenthesesOpenPos;
|
|
var pos = 0;
|
|
var code = value.charCodeAt(pos);
|
|
var max = value.length;
|
|
var stack = [{ nodes: tokens }];
|
|
var balanced = 0;
|
|
var parent;
|
|
var name = "";
|
|
var before = "";
|
|
var after = "";
|
|
while (pos < max) {
|
|
if (code <= 32) {
|
|
next = pos;
|
|
do {
|
|
next += 1;
|
|
code = value.charCodeAt(next);
|
|
} while (code <= 32);
|
|
token = value.slice(pos, next);
|
|
prev = tokens[tokens.length - 1];
|
|
if (code === closeParentheses && balanced) {
|
|
after = token;
|
|
} else if (prev && prev.type === "div") {
|
|
prev.after = token;
|
|
prev.sourceEndIndex += token.length;
|
|
} else if (code === comma || code === colon || code === slash && value.charCodeAt(next + 1) !== star && (!parent || parent && parent.type === "function" && parent.value !== "calc")) {
|
|
before = token;
|
|
} else {
|
|
tokens.push({
|
|
type: "space",
|
|
sourceIndex: pos,
|
|
sourceEndIndex: next,
|
|
value: token
|
|
});
|
|
}
|
|
pos = next;
|
|
} else if (code === singleQuote || code === doubleQuote) {
|
|
next = pos;
|
|
quote = code === singleQuote ? "'" : '"';
|
|
token = {
|
|
type: "string",
|
|
sourceIndex: pos,
|
|
quote
|
|
};
|
|
do {
|
|
escape = false;
|
|
next = value.indexOf(quote, next + 1);
|
|
if (~next) {
|
|
escapePos = next;
|
|
while (value.charCodeAt(escapePos - 1) === backslash) {
|
|
escapePos -= 1;
|
|
escape = !escape;
|
|
}
|
|
} else {
|
|
value += quote;
|
|
next = value.length - 1;
|
|
token.unclosed = true;
|
|
}
|
|
} while (escape);
|
|
token.value = value.slice(pos + 1, next);
|
|
token.sourceEndIndex = token.unclosed ? next : next + 1;
|
|
tokens.push(token);
|
|
pos = next + 1;
|
|
code = value.charCodeAt(pos);
|
|
} else if (code === slash && value.charCodeAt(pos + 1) === star) {
|
|
next = value.indexOf("*/", pos);
|
|
token = {
|
|
type: "comment",
|
|
sourceIndex: pos,
|
|
sourceEndIndex: next + 2
|
|
};
|
|
if (next === -1) {
|
|
token.unclosed = true;
|
|
next = value.length;
|
|
token.sourceEndIndex = next;
|
|
}
|
|
token.value = value.slice(pos + 2, next);
|
|
tokens.push(token);
|
|
pos = next + 2;
|
|
code = value.charCodeAt(pos);
|
|
} else if ((code === slash || code === star) && parent && parent.type === "function" && parent.value === "calc") {
|
|
token = value[pos];
|
|
tokens.push({
|
|
type: "word",
|
|
sourceIndex: pos - before.length,
|
|
sourceEndIndex: pos + token.length,
|
|
value: token
|
|
});
|
|
pos += 1;
|
|
code = value.charCodeAt(pos);
|
|
} else if (code === slash || code === comma || code === colon) {
|
|
token = value[pos];
|
|
tokens.push({
|
|
type: "div",
|
|
sourceIndex: pos - before.length,
|
|
sourceEndIndex: pos + token.length,
|
|
value: token,
|
|
before,
|
|
after: ""
|
|
});
|
|
before = "";
|
|
pos += 1;
|
|
code = value.charCodeAt(pos);
|
|
} else if (openParentheses === code) {
|
|
next = pos;
|
|
do {
|
|
next += 1;
|
|
code = value.charCodeAt(next);
|
|
} while (code <= 32);
|
|
parenthesesOpenPos = pos;
|
|
token = {
|
|
type: "function",
|
|
sourceIndex: pos - name.length,
|
|
value: name,
|
|
before: value.slice(parenthesesOpenPos + 1, next)
|
|
};
|
|
pos = next;
|
|
if (name === "url" && code !== singleQuote && code !== doubleQuote) {
|
|
next -= 1;
|
|
do {
|
|
escape = false;
|
|
next = value.indexOf(")", next + 1);
|
|
if (~next) {
|
|
escapePos = next;
|
|
while (value.charCodeAt(escapePos - 1) === backslash) {
|
|
escapePos -= 1;
|
|
escape = !escape;
|
|
}
|
|
} else {
|
|
value += ")";
|
|
next = value.length - 1;
|
|
token.unclosed = true;
|
|
}
|
|
} while (escape);
|
|
whitespacePos = next;
|
|
do {
|
|
whitespacePos -= 1;
|
|
code = value.charCodeAt(whitespacePos);
|
|
} while (code <= 32);
|
|
if (parenthesesOpenPos < whitespacePos) {
|
|
if (pos !== whitespacePos + 1) {
|
|
token.nodes = [
|
|
{
|
|
type: "word",
|
|
sourceIndex: pos,
|
|
sourceEndIndex: whitespacePos + 1,
|
|
value: value.slice(pos, whitespacePos + 1)
|
|
}
|
|
];
|
|
} else {
|
|
token.nodes = [];
|
|
}
|
|
if (token.unclosed && whitespacePos + 1 !== next) {
|
|
token.after = "";
|
|
token.nodes.push({
|
|
type: "space",
|
|
sourceIndex: whitespacePos + 1,
|
|
sourceEndIndex: next,
|
|
value: value.slice(whitespacePos + 1, next)
|
|
});
|
|
} else {
|
|
token.after = value.slice(whitespacePos + 1, next);
|
|
token.sourceEndIndex = next;
|
|
}
|
|
} else {
|
|
token.after = "";
|
|
token.nodes = [];
|
|
}
|
|
pos = next + 1;
|
|
token.sourceEndIndex = token.unclosed ? next : pos;
|
|
code = value.charCodeAt(pos);
|
|
tokens.push(token);
|
|
} else {
|
|
balanced += 1;
|
|
token.after = "";
|
|
token.sourceEndIndex = pos + 1;
|
|
tokens.push(token);
|
|
stack.push(token);
|
|
tokens = token.nodes = [];
|
|
parent = token;
|
|
}
|
|
name = "";
|
|
} else if (closeParentheses === code && balanced) {
|
|
pos += 1;
|
|
code = value.charCodeAt(pos);
|
|
parent.after = after;
|
|
parent.sourceEndIndex += after.length;
|
|
after = "";
|
|
balanced -= 1;
|
|
stack[stack.length - 1].sourceEndIndex = pos;
|
|
stack.pop();
|
|
parent = stack[balanced];
|
|
tokens = parent.nodes;
|
|
} else {
|
|
next = pos;
|
|
do {
|
|
if (code === backslash) {
|
|
next += 1;
|
|
}
|
|
next += 1;
|
|
code = value.charCodeAt(next);
|
|
} while (next < max && !(code <= 32 || code === singleQuote || code === doubleQuote || code === comma || code === colon || code === slash || code === openParentheses || code === star && parent && parent.type === "function" && parent.value === "calc" || code === slash && parent.type === "function" && parent.value === "calc" || code === closeParentheses && balanced));
|
|
token = value.slice(pos, next);
|
|
if (openParentheses === code) {
|
|
name = token;
|
|
} else if ((uLower === token.charCodeAt(0) || uUpper === token.charCodeAt(0)) && plus === token.charCodeAt(1) && isUnicodeRange.test(token.slice(2))) {
|
|
tokens.push({
|
|
type: "unicode-range",
|
|
sourceIndex: pos,
|
|
sourceEndIndex: next,
|
|
value: token
|
|
});
|
|
} else {
|
|
tokens.push({
|
|
type: "word",
|
|
sourceIndex: pos,
|
|
sourceEndIndex: next,
|
|
value: token
|
|
});
|
|
}
|
|
pos = next;
|
|
}
|
|
}
|
|
for (pos = stack.length - 1; pos; pos -= 1) {
|
|
stack[pos].unclosed = true;
|
|
stack[pos].sourceEndIndex = value.length;
|
|
}
|
|
return stack[0].nodes;
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss-value-parser/lib/walk.js
|
|
var require_walk = __commonJS({
|
|
"node_modules/postcss-value-parser/lib/walk.js"(exports, module) {
|
|
module.exports = function walk(nodes, cb, bubble) {
|
|
var i, max, node, result;
|
|
for (i = 0, max = nodes.length; i < max; i += 1) {
|
|
node = nodes[i];
|
|
if (!bubble) {
|
|
result = cb(node, i, nodes);
|
|
}
|
|
if (result !== false && node.type === "function" && Array.isArray(node.nodes)) {
|
|
walk(node.nodes, cb, bubble);
|
|
}
|
|
if (bubble) {
|
|
cb(node, i, nodes);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss-value-parser/lib/stringify.js
|
|
var require_stringify2 = __commonJS({
|
|
"node_modules/postcss-value-parser/lib/stringify.js"(exports, module) {
|
|
function stringifyNode(node, custom) {
|
|
var type = node.type;
|
|
var value = node.value;
|
|
var buf;
|
|
var customResult;
|
|
if (custom && (customResult = custom(node)) !== void 0) {
|
|
return customResult;
|
|
} else if (type === "word" || type === "space") {
|
|
return value;
|
|
} else if (type === "string") {
|
|
buf = node.quote || "";
|
|
return buf + value + (node.unclosed ? "" : buf);
|
|
} else if (type === "comment") {
|
|
return "/*" + value + (node.unclosed ? "" : "*/");
|
|
} else if (type === "div") {
|
|
return (node.before || "") + value + (node.after || "");
|
|
} else if (Array.isArray(node.nodes)) {
|
|
buf = stringify3(node.nodes, custom);
|
|
if (type !== "function") {
|
|
return buf;
|
|
}
|
|
return value + "(" + (node.before || "") + buf + (node.after || "") + (node.unclosed ? "" : ")");
|
|
}
|
|
return value;
|
|
}
|
|
function stringify3(nodes, custom) {
|
|
var result, i;
|
|
if (Array.isArray(nodes)) {
|
|
result = "";
|
|
for (i = nodes.length - 1; ~i; i -= 1) {
|
|
result = stringifyNode(nodes[i], custom) + result;
|
|
}
|
|
return result;
|
|
}
|
|
return stringifyNode(nodes, custom);
|
|
}
|
|
module.exports = stringify3;
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss-value-parser/lib/unit.js
|
|
var require_unit = __commonJS({
|
|
"node_modules/postcss-value-parser/lib/unit.js"(exports, module) {
|
|
var minus = "-".charCodeAt(0);
|
|
var plus = "+".charCodeAt(0);
|
|
var dot = ".".charCodeAt(0);
|
|
var exp = "e".charCodeAt(0);
|
|
var EXP = "E".charCodeAt(0);
|
|
function likeNumber(value) {
|
|
var code = value.charCodeAt(0);
|
|
var nextCode;
|
|
if (code === plus || code === minus) {
|
|
nextCode = value.charCodeAt(1);
|
|
if (nextCode >= 48 && nextCode <= 57) {
|
|
return true;
|
|
}
|
|
var nextNextCode = value.charCodeAt(2);
|
|
if (nextCode === dot && nextNextCode >= 48 && nextNextCode <= 57) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
if (code === dot) {
|
|
nextCode = value.charCodeAt(1);
|
|
if (nextCode >= 48 && nextCode <= 57) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
if (code >= 48 && code <= 57) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
module.exports = function(value) {
|
|
var pos = 0;
|
|
var length = value.length;
|
|
var code;
|
|
var nextCode;
|
|
var nextNextCode;
|
|
if (length === 0 || !likeNumber(value)) {
|
|
return false;
|
|
}
|
|
code = value.charCodeAt(pos);
|
|
if (code === plus || code === minus) {
|
|
pos++;
|
|
}
|
|
while (pos < length) {
|
|
code = value.charCodeAt(pos);
|
|
if (code < 48 || code > 57) {
|
|
break;
|
|
}
|
|
pos += 1;
|
|
}
|
|
code = value.charCodeAt(pos);
|
|
nextCode = value.charCodeAt(pos + 1);
|
|
if (code === dot && nextCode >= 48 && nextCode <= 57) {
|
|
pos += 2;
|
|
while (pos < length) {
|
|
code = value.charCodeAt(pos);
|
|
if (code < 48 || code > 57) {
|
|
break;
|
|
}
|
|
pos += 1;
|
|
}
|
|
}
|
|
code = value.charCodeAt(pos);
|
|
nextCode = value.charCodeAt(pos + 1);
|
|
nextNextCode = value.charCodeAt(pos + 2);
|
|
if ((code === exp || code === EXP) && (nextCode >= 48 && nextCode <= 57 || (nextCode === plus || nextCode === minus) && nextNextCode >= 48 && nextNextCode <= 57)) {
|
|
pos += nextCode === plus || nextCode === minus ? 3 : 2;
|
|
while (pos < length) {
|
|
code = value.charCodeAt(pos);
|
|
if (code < 48 || code > 57) {
|
|
break;
|
|
}
|
|
pos += 1;
|
|
}
|
|
}
|
|
return {
|
|
number: value.slice(0, pos),
|
|
unit: value.slice(pos)
|
|
};
|
|
};
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss-value-parser/lib/index.js
|
|
var require_lib = __commonJS({
|
|
"node_modules/postcss-value-parser/lib/index.js"(exports, module) {
|
|
var parse3 = require_parse2();
|
|
var walk = require_walk();
|
|
var stringify3 = require_stringify2();
|
|
function ValueParser(value) {
|
|
if (this instanceof ValueParser) {
|
|
this.nodes = parse3(value);
|
|
return this;
|
|
}
|
|
return new ValueParser(value);
|
|
}
|
|
ValueParser.prototype.toString = function() {
|
|
return Array.isArray(this.nodes) ? stringify3(this.nodes) : "";
|
|
};
|
|
ValueParser.prototype.walk = function(cb, bubble) {
|
|
walk(this.nodes, cb, bubble);
|
|
return this;
|
|
};
|
|
ValueParser.unit = require_unit();
|
|
ValueParser.walk = walk;
|
|
ValueParser.stringify = stringify3;
|
|
module.exports = ValueParser;
|
|
}
|
|
});
|
|
|
|
// node_modules/postcss/lib/postcss.mjs
|
|
var import_postcss = __toESM(require_postcss(), 1);
|
|
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 Node2 = import_postcss.default.Node;
|
|
|
|
// node_modules/dom-to-svg/lib/index.js
|
|
var import_postcss_value_parser4 = __toESM(require_lib(), 1);
|
|
|
|
// node_modules/dom-to-svg/lib/css.js
|
|
var isCSSFontFaceRule = (rule2) => rule2.type === CSSRule.FONT_FACE_RULE;
|
|
var isInline = (styles) => styles.displayOutside === "inline" || styles.display.startsWith("inline-");
|
|
var isPositioned = (styles) => styles.position !== "static";
|
|
var isInFlow = (styles) => styles.float !== "none" && styles.position !== "absolute" && styles.position !== "fixed";
|
|
var isTransparent = (color) => color === "transparent" || color === "rgba(0, 0, 0, 0)";
|
|
var hasUniformBorder = (styles) => parseFloat(styles.borderTopWidth) !== 0 && styles.borderTopStyle !== "none" && styles.borderTopStyle !== "inset" && styles.borderTopStyle !== "outset" && !isTransparent(styles.borderTopColor) && // Cannot use border property directly as in Firefox those are empty strings.
|
|
// Need to get the specific border properties from the specific sides.
|
|
// https://stackoverflow.com/questions/41696063/getcomputedstyle-returns-empty-strings-on-ff-when-instead-crome-returns-a-comp
|
|
styles.borderTopWidth === styles.borderLeftWidth && styles.borderTopWidth === styles.borderRightWidth && styles.borderTopWidth === styles.borderBottomWidth && styles.borderTopColor === styles.borderLeftColor && styles.borderTopColor === styles.borderRightColor && styles.borderTopColor === styles.borderBottomColor && styles.borderTopStyle === styles.borderLeftStyle && styles.borderTopStyle === styles.borderRightStyle && styles.borderTopStyle === styles.borderBottomStyle;
|
|
var SIDES = ["top", "bottom", "right", "left"];
|
|
var isHorizontal = (side) => side === "bottom" || side === "top";
|
|
var CORNERS = {
|
|
top: ["left", "right"],
|
|
bottom: ["left", "right"],
|
|
left: ["top", "bottom"],
|
|
right: ["top", "bottom"]
|
|
};
|
|
function getBorderRadiiForSide(side, styles, bounds) {
|
|
var _a, _b, _c, _d;
|
|
const [horizontalStyle1, verticalStyle1] = styles.getPropertyValue(isHorizontal(side) ? `border-${side}-${CORNERS[side][0]}-radius` : `border-${CORNERS[side][0]}-${side}-radius`).split(" ");
|
|
const [horizontalStyle2, verticalStyle2] = styles.getPropertyValue(isHorizontal(side) ? `border-${side}-${CORNERS[side][1]}-radius` : `border-${CORNERS[side][1]}-${side}-radius`).split(" ");
|
|
if (isHorizontal(side)) {
|
|
return [
|
|
(_a = parseCSSLength(horizontalStyle1 || "0px", bounds.width)) !== null && _a !== void 0 ? _a : 0,
|
|
(_b = parseCSSLength(horizontalStyle2 || "0px", bounds.width)) !== null && _b !== void 0 ? _b : 0
|
|
];
|
|
}
|
|
return [
|
|
(_c = parseCSSLength(verticalStyle1 || horizontalStyle1 || "0px", bounds.height)) !== null && _c !== void 0 ? _c : 0,
|
|
(_d = parseCSSLength(verticalStyle2 || horizontalStyle2 || "0px", bounds.height)) !== null && _d !== void 0 ? _d : 0
|
|
];
|
|
}
|
|
var calculateOverlappingCurvesFactor = (styles, bounds) => Math.min(...SIDES.map((side) => {
|
|
const length = isHorizontal(side) ? bounds.width : bounds.height;
|
|
const radiiSum = getBorderRadiiForSide(side, styles, bounds).reduce((sum, radius) => sum + radius, 0);
|
|
return length / radiiSum;
|
|
}), 1);
|
|
var isVisible = (styles) => styles.displayOutside !== "none" && styles.display !== "none" && styles.visibility !== "hidden" && styles.opacity !== "0";
|
|
function parseCSSLength(length, containerLength) {
|
|
if (length.endsWith("px")) {
|
|
return parseFloat(length);
|
|
}
|
|
if (length.endsWith("%")) {
|
|
return parseFloat(length) / 100 * containerLength;
|
|
}
|
|
return void 0;
|
|
}
|
|
var unescapeStringValue = (value) => value.replace(/\\([\da-f]{1,2})/gi, (substring, codePoint) => String.fromCodePoint(parseInt(codePoint, 16))).replace(/\\(.)/g, "$1");
|
|
function copyCssStyles(from, to) {
|
|
for (const property of from) {
|
|
to.setProperty(property, from.getPropertyValue(property), from.getPropertyPriority(property));
|
|
}
|
|
}
|
|
|
|
// node_modules/dom-to-svg/lib/dom.js
|
|
var svgNamespace = "http://www.w3.org/2000/svg";
|
|
var xlinkNamespace = "http://www.w3.org/1999/xlink";
|
|
var xhtmlNamespace = "http://www.w3.org/1999/xhtml";
|
|
var isElement = (node) => node.nodeType === Node.ELEMENT_NODE;
|
|
var isTextNode = (node) => node.nodeType === Node.TEXT_NODE;
|
|
var isSVGElement = (element) => element.namespaceURI === svgNamespace;
|
|
var isSVGSVGElement = (element) => isSVGElement(element) && element.tagName === "svg";
|
|
var isSVGGraphicsElement = (element) => isSVGElement(element) && "getCTM" in element && "getScreenCTM" in element;
|
|
var isSVGAnchorElement = (element) => isSVGElement(element) && element.tagName === "a";
|
|
var isSVGTextContentElement = (element) => isSVGElement(element) && "textLength" in element;
|
|
var isSVGImageElement = (element) => element.tagName === "image" && isSVGElement(element);
|
|
var isSVGStyleElement = (element) => element.tagName === "style" && isSVGElement(element);
|
|
var isHTMLElement = (element) => element.namespaceURI === xhtmlNamespace;
|
|
var isHTMLAnchorElement = (element) => element.tagName === "A" && isHTMLElement(element);
|
|
var isHTMLImageElement = (element) => element.tagName === "IMG" && isHTMLElement(element);
|
|
var isHTMLInputElement = (element) => element.tagName === "INPUT" && isHTMLElement(element);
|
|
var hasLabels = (element) => "labels" in element;
|
|
|
|
// node_modules/dom-to-svg/lib/stacking.js
|
|
var stackingContextEstablishingProperties = /* @__PURE__ */ new Set([
|
|
"clipPath",
|
|
"contain",
|
|
"filter",
|
|
"isolation",
|
|
"mask",
|
|
"maskBorder",
|
|
"maskImage",
|
|
"mixBlendMode",
|
|
"opacity",
|
|
"perspective",
|
|
"position",
|
|
"transform",
|
|
"webkitOverflowScrolling",
|
|
"zIndex"
|
|
]);
|
|
function establishesStackingContext(styles, parentStyles) {
|
|
return !!((styles.position === "absolute" || styles.position === "relative") && styles.zIndex !== "auto" || styles.position === "fixed" || styles.position === "sticky" || parentStyles && (parentStyles.display === "flex" || parentStyles.display === "grid") && styles.zIndex !== "auto" || parseFloat(styles.opacity) !== 1 || styles.mixBlendMode !== "normal" || styles.transform !== "none" || styles.filter !== "none" || styles.perspective !== "none" || styles.clipPath !== "none" || styles.mask !== "none" || styles.maskImage !== "none" || styles.maskBorder !== "none" || styles.isolation === "isolate" || styles.webkitOverflowScrolling === "touch" || styles.contain === "layout" || styles.contain === "paint" || styles.contain === "strict" || styles.contain === "content" || styles.willChange.split(",").some((property) => stackingContextEstablishingProperties.has(property.trim())));
|
|
}
|
|
var STACKING_LAYER_NAMES = [
|
|
"rootBackgroundAndBorders",
|
|
"childStackingContextsWithNegativeStackLevels",
|
|
"inFlowNonInlineNonPositionedDescendants",
|
|
"nonPositionedFloats",
|
|
"inFlowInlineLevelNonPositionedDescendants",
|
|
"childStackingContextsWithStackLevelZeroAndPositionedDescendantsWithStackLevelZero",
|
|
"childStackingContextsWithPositiveStackLevels"
|
|
];
|
|
function createStackingLayer(parent, layerName) {
|
|
const layer = parent.ownerDocument.createElementNS(svgNamespace, "g");
|
|
layer.dataset.stackingLayer = layerName;
|
|
parent.append(layer);
|
|
return layer;
|
|
}
|
|
function createStackingLayers(container) {
|
|
container.dataset.stackingContext = "true";
|
|
return {
|
|
rootBackgroundAndBorders: createStackingLayer(container, "rootBackgroundAndBorders"),
|
|
childStackingContextsWithNegativeStackLevels: createStackingLayer(container, "childStackingContextsWithNegativeStackLevels"),
|
|
inFlowNonInlineNonPositionedDescendants: createStackingLayer(container, "inFlowNonInlineNonPositionedDescendants"),
|
|
nonPositionedFloats: createStackingLayer(container, "nonPositionedFloats"),
|
|
inFlowInlineLevelNonPositionedDescendants: createStackingLayer(container, "inFlowInlineLevelNonPositionedDescendants"),
|
|
childStackingContextsWithStackLevelZeroAndPositionedDescendantsWithStackLevelZero: createStackingLayer(container, "childStackingContextsWithStackLevelZeroAndPositionedDescendantsWithStackLevelZero"),
|
|
childStackingContextsWithPositiveStackLevels: createStackingLayer(container, "childStackingContextsWithPositiveStackLevels")
|
|
};
|
|
}
|
|
function determineStackingLayer(styles, parentStyles) {
|
|
const zIndex = styles.zIndex !== "auto" ? parseInt(styles.zIndex, 10) : void 0;
|
|
if (zIndex !== void 0 && zIndex < 0 && establishesStackingContext(styles, parentStyles)) {
|
|
return "childStackingContextsWithNegativeStackLevels";
|
|
}
|
|
if (isInFlow(styles) && !isInline(styles) && !isPositioned(styles)) {
|
|
return "inFlowNonInlineNonPositionedDescendants";
|
|
}
|
|
if (!isPositioned(styles) && styles.float !== "none") {
|
|
return "nonPositionedFloats";
|
|
}
|
|
if (isInFlow(styles) && isInline(styles) && !isPositioned(styles)) {
|
|
return "inFlowInlineLevelNonPositionedDescendants";
|
|
}
|
|
if (zIndex === 0 && (isPositioned(styles) || establishesStackingContext(styles, parentStyles))) {
|
|
return "childStackingContextsWithStackLevelZeroAndPositionedDescendantsWithStackLevelZero";
|
|
}
|
|
if (zIndex !== void 0 && zIndex > 0 && establishesStackingContext(styles, parentStyles)) {
|
|
return "childStackingContextsWithPositiveStackLevels";
|
|
}
|
|
return void 0;
|
|
}
|
|
function sortChildrenByZIndex(parent) {
|
|
const sorted = [...parent.children].sort((a, b) => {
|
|
const zIndexA = a.dataset.zIndex;
|
|
const zIndexB = b.dataset.zIndex;
|
|
if (!zIndexA || !zIndexB) {
|
|
return 0;
|
|
}
|
|
return parseInt(zIndexA, 10) - parseInt(zIndexB, 10);
|
|
});
|
|
for (const child of sorted) {
|
|
parent.append(child);
|
|
}
|
|
}
|
|
function sortStackingLayerChildren(stackingLayers) {
|
|
sortChildrenByZIndex(stackingLayers.childStackingContextsWithNegativeStackLevels);
|
|
sortChildrenByZIndex(stackingLayers.childStackingContextsWithPositiveStackLevels);
|
|
}
|
|
function cleanupStackingLayerChildren(stackingLayers) {
|
|
for (const name of STACKING_LAYER_NAMES) {
|
|
const layer = stackingLayers[name];
|
|
if (!layer.hasChildNodes()) {
|
|
layer.remove();
|
|
}
|
|
}
|
|
}
|
|
|
|
// node_modules/dom-to-svg/lib/element.js
|
|
var import_postcss_value_parser2 = __toESM(require_lib(), 1);
|
|
|
|
// node_modules/dom-to-svg/lib/accessibility.js
|
|
var isStandaloneFooter = (element) => !element.closest('article, aside, main, nav, section, [role="article"], [role="complementary"], [role="main"], [role="navigation"], [role="region"]');
|
|
function getAccessibilityAttributes(element, { labels, getUniqueId }) {
|
|
var _a, _b, _c;
|
|
const attributes = /* @__PURE__ */ new Map();
|
|
switch (element.tagName) {
|
|
case "A":
|
|
attributes.set("role", "link");
|
|
break;
|
|
case "ARTICLE":
|
|
attributes.set("role", "article");
|
|
break;
|
|
case "ASIDE":
|
|
attributes.set("role", "complementary");
|
|
break;
|
|
case "BODY":
|
|
attributes.set("role", "document");
|
|
break;
|
|
case "BUTTON":
|
|
case "SUMMARY":
|
|
attributes.set("role", "button");
|
|
break;
|
|
case "DD":
|
|
attributes.set("role", "definition");
|
|
break;
|
|
case "DETAILS":
|
|
attributes.set("role", "group");
|
|
break;
|
|
case "DFN":
|
|
attributes.set("role", "term");
|
|
break;
|
|
case "DIALOG":
|
|
attributes.set("role", "dialog");
|
|
break;
|
|
case "DT":
|
|
attributes.set("role", "term");
|
|
break;
|
|
case "FIELDSET":
|
|
attributes.set("role", "group");
|
|
break;
|
|
case "FIGURE":
|
|
attributes.set("role", "figure");
|
|
break;
|
|
case "FOOTER":
|
|
if (isStandaloneFooter(element)) {
|
|
attributes.set("role", "contentinfo");
|
|
}
|
|
break;
|
|
case "FORM":
|
|
attributes.set("role", "form");
|
|
break;
|
|
case "H1":
|
|
case "H2":
|
|
case "H3":
|
|
case "H4":
|
|
case "H5":
|
|
case "H6":
|
|
attributes.set("role", "heading");
|
|
attributes.set("aria-level", element.tagName.slice(1));
|
|
break;
|
|
case "HEADER":
|
|
if (isStandaloneFooter(element)) {
|
|
attributes.set("role", "banner");
|
|
}
|
|
break;
|
|
case "HR":
|
|
attributes.set("role", "separator");
|
|
break;
|
|
case "IMG": {
|
|
const alt = element.getAttribute("alt");
|
|
if (alt === null || alt !== "") {
|
|
attributes.set("role", "img");
|
|
if (alt) {
|
|
attributes.set("aria-label", alt);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case "INPUT":
|
|
switch (element.type) {
|
|
case "button":
|
|
case "image":
|
|
case "reset":
|
|
case "submit":
|
|
attributes.set("role", "button");
|
|
break;
|
|
case "number":
|
|
attributes.set("role", "spinbutton");
|
|
break;
|
|
case "range":
|
|
attributes.set("role", "slider");
|
|
break;
|
|
case "checkbox":
|
|
attributes.set("role", "checkbox");
|
|
break;
|
|
case "radio":
|
|
attributes.set("role", "radio");
|
|
break;
|
|
case "email":
|
|
case "tel":
|
|
if (!element.hasAttribute("list")) {
|
|
attributes.set("role", "textbox");
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
case "LI":
|
|
if (((_a = element.parentElement) === null || _a === void 0 ? void 0 : _a.tagName) === "OL" || ((_b = element.parentElement) === null || _b === void 0 ? void 0 : _b.tagName) === "UL" || ((_c = element.parentElement) === null || _c === void 0 ? void 0 : _c.tagName) === "MENU") {
|
|
attributes.set("role", "listitem");
|
|
}
|
|
break;
|
|
case "LINK":
|
|
if (element.href) {
|
|
attributes.set("role", "link");
|
|
}
|
|
break;
|
|
case "MAIN":
|
|
attributes.set("role", "main");
|
|
break;
|
|
case "MATH":
|
|
attributes.set("role", "math");
|
|
break;
|
|
case "OL":
|
|
case "UL":
|
|
case "MENU":
|
|
attributes.set("role", "list");
|
|
break;
|
|
case "NAV":
|
|
attributes.set("role", "navigation");
|
|
break;
|
|
case "OPTION":
|
|
attributes.set("role", "option");
|
|
break;
|
|
case "PROGRESS":
|
|
attributes.set("role", "progressbar");
|
|
break;
|
|
case "SECTION":
|
|
attributes.set("role", "region");
|
|
break;
|
|
case "SELECT":
|
|
attributes.set("role", !element.hasAttribute("multiple") && element.size <= 1 ? "combobox" : "listbox");
|
|
break;
|
|
case "TABLE":
|
|
attributes.set("role", "table");
|
|
break;
|
|
case "THEAD":
|
|
case "TBODY":
|
|
case "TFOOT":
|
|
attributes.set("role", "rowgroup");
|
|
break;
|
|
case "TEXTAREA":
|
|
attributes.set("role", "textbox");
|
|
break;
|
|
case "TD":
|
|
attributes.set("role", "cell");
|
|
break;
|
|
case "TH":
|
|
attributes.set("role", element.closest("thead") ? "columnheader" : "rowheader");
|
|
break;
|
|
case "TR":
|
|
attributes.set("role", "tablerow");
|
|
break;
|
|
}
|
|
if (element.hasAttribute("disabled")) {
|
|
attributes.set("aria-disabled", "true");
|
|
}
|
|
if (element.hasAttribute("placeholder")) {
|
|
attributes.set("aria-placeholder", element.getAttribute("placeholder") || "");
|
|
}
|
|
const tabIndex = element.getAttribute("tabindex");
|
|
if (tabIndex) {
|
|
attributes.set("tabindex", tabIndex);
|
|
}
|
|
if (isHTMLElement(element) && hasLabels(element) && element.labels) {
|
|
attributes.set("aria-labelledby", [...element.labels].map((label) => {
|
|
let labelId = label.id || labels.get(label);
|
|
if (!labelId) {
|
|
labelId = getUniqueId("label");
|
|
labels.set(label, labelId);
|
|
}
|
|
return labelId;
|
|
}).join(" "));
|
|
}
|
|
for (const attribute of element.attributes) {
|
|
if (attribute.name.startsWith("aria-")) {
|
|
attributes.set(attribute.name, attribute.value);
|
|
}
|
|
}
|
|
const customRole = element.getAttribute("role");
|
|
if (customRole) {
|
|
attributes.set("role", customRole);
|
|
}
|
|
return attributes;
|
|
}
|
|
|
|
// node_modules/gradient-parser/build/esm.mjs
|
|
var GradientParser = GradientParser || {};
|
|
GradientParser.stringify = /* @__PURE__ */ (function() {
|
|
var visitor = {
|
|
"visit_linear-gradient": function(node) {
|
|
return visitor.visit_gradient(node);
|
|
},
|
|
"visit_repeating-linear-gradient": function(node) {
|
|
return visitor.visit_gradient(node);
|
|
},
|
|
"visit_radial-gradient": function(node) {
|
|
return visitor.visit_gradient(node);
|
|
},
|
|
"visit_repeating-radial-gradient": function(node) {
|
|
return visitor.visit_gradient(node);
|
|
},
|
|
"visit_conic-gradient": function(node) {
|
|
return visitor.visit_gradient(node);
|
|
},
|
|
"visit_repeating-conic-gradient": function(node) {
|
|
return visitor.visit_gradient(node);
|
|
},
|
|
"visit_gradient": function(node) {
|
|
var orientation = visitor.visit(node.orientation);
|
|
if (orientation) {
|
|
orientation += ", ";
|
|
}
|
|
return node.type + "(" + orientation + visitor.visit(node.colorStops) + ")";
|
|
},
|
|
"visit_shape": function(node) {
|
|
var result = node.value, at = visitor.visit(node.at), style = visitor.visit(node.style);
|
|
if (style) {
|
|
result += " " + style;
|
|
}
|
|
if (at) {
|
|
result += " at " + at;
|
|
}
|
|
return result;
|
|
},
|
|
"visit_default-radial": function(node) {
|
|
var result = "", at = visitor.visit(node.at);
|
|
if (at) {
|
|
if (node.hasAtKeyword) {
|
|
result += "at " + at;
|
|
} else {
|
|
result += at;
|
|
}
|
|
}
|
|
return result;
|
|
},
|
|
"visit_extent-keyword": function(node) {
|
|
var result = node.value, at = visitor.visit(node.at);
|
|
if (at) {
|
|
result += " at " + at;
|
|
}
|
|
return result;
|
|
},
|
|
"visit_position-keyword": function(node) {
|
|
return node.value;
|
|
},
|
|
"visit_position": function(node) {
|
|
return visitor.visit(node.value.x) + " " + visitor.visit(node.value.y);
|
|
},
|
|
"visit_%": function(node) {
|
|
return node.value + "%";
|
|
},
|
|
"visit_em": function(node) {
|
|
return node.value + "em";
|
|
},
|
|
"visit_px": function(node) {
|
|
return node.value + "px";
|
|
},
|
|
"visit_rem": function(node) {
|
|
return node.value + "rem";
|
|
},
|
|
"visit_vw": function(node) {
|
|
return node.value + "vw";
|
|
},
|
|
"visit_vh": function(node) {
|
|
return node.value + "vh";
|
|
},
|
|
"visit_vmin": function(node) {
|
|
return node.value + "vmin";
|
|
},
|
|
"visit_vmax": function(node) {
|
|
return node.value + "vmax";
|
|
},
|
|
"visit_ch": function(node) {
|
|
return node.value + "ch";
|
|
},
|
|
"visit_ex": function(node) {
|
|
return node.value + "ex";
|
|
},
|
|
"visit_calc": function(node) {
|
|
return "calc(" + node.value + ")";
|
|
},
|
|
"visit_literal": function(node) {
|
|
return visitor.visit_color(node.value, node);
|
|
},
|
|
"visit_hex": function(node) {
|
|
return visitor.visit_color("#" + node.value, node);
|
|
},
|
|
"visit_rgb": function(node) {
|
|
return visitor.visit_color("rgb(" + node.value.join(", ") + ")", node);
|
|
},
|
|
"visit_rgba": function(node) {
|
|
return visitor.visit_color("rgba(" + node.value.join(", ") + ")", node);
|
|
},
|
|
"visit_hsl": function(node) {
|
|
return visitor.visit_color("hsl(" + node.value[0] + ", " + node.value[1] + "%, " + node.value[2] + "%)", node);
|
|
},
|
|
"visit_hsla": function(node) {
|
|
return visitor.visit_color("hsla(" + node.value[0] + ", " + node.value[1] + "%, " + node.value[2] + "%, " + node.value[3] + ")", node);
|
|
},
|
|
"visit_var": function(node) {
|
|
return visitor.visit_color("var(" + node.value + ")", node);
|
|
},
|
|
"visit_color": function(resultColor, node) {
|
|
var result = resultColor, length = visitor.visit(node.length);
|
|
if (length) {
|
|
result += " " + length;
|
|
}
|
|
var length2 = visitor.visit(node.length2);
|
|
if (length2) {
|
|
result += " " + length2;
|
|
}
|
|
return result;
|
|
},
|
|
"visit_angular": function(node) {
|
|
return node.value + (node.unit || "deg");
|
|
},
|
|
"visit_directional": function(node) {
|
|
return "to " + node.value;
|
|
},
|
|
"visit_conic": function(node) {
|
|
var result = "";
|
|
if (node.angle) {
|
|
result += "from " + visitor.visit(node.angle);
|
|
}
|
|
if (node.at) {
|
|
if (result) {
|
|
result += " ";
|
|
}
|
|
result += "at " + visitor.visit(node.at);
|
|
}
|
|
return result;
|
|
},
|
|
"visit_array": function(elements) {
|
|
var result = "", size = elements.length;
|
|
elements.forEach(function(element, i) {
|
|
result += visitor.visit(element);
|
|
if (i < size - 1) {
|
|
result += ", ";
|
|
}
|
|
});
|
|
return result;
|
|
},
|
|
"visit_object": function(obj) {
|
|
if (obj.width && obj.height) {
|
|
return visitor.visit(obj.width) + " " + visitor.visit(obj.height);
|
|
}
|
|
return "";
|
|
},
|
|
"visit": function(element) {
|
|
if (!element) {
|
|
return "";
|
|
}
|
|
var result = "";
|
|
if (element instanceof Array) {
|
|
return visitor.visit_array(element);
|
|
} else if (typeof element === "object" && !element.type) {
|
|
return visitor.visit_object(element);
|
|
} else if (element.type) {
|
|
var nodeVisitor = visitor["visit_" + element.type];
|
|
if (nodeVisitor) {
|
|
return nodeVisitor(element);
|
|
} else {
|
|
throw Error("Missing visitor visit_" + element.type);
|
|
}
|
|
} else {
|
|
throw Error("Invalid node.");
|
|
}
|
|
}
|
|
};
|
|
return function(root2) {
|
|
return visitor.visit(root2);
|
|
};
|
|
})();
|
|
var GradientParser = GradientParser || {};
|
|
GradientParser.parse = /* @__PURE__ */ (function() {
|
|
var tokens = {
|
|
linearGradient: /^(\-(webkit|o|ms|moz)\-)?(linear\-gradient)/i,
|
|
repeatingLinearGradient: /^(\-(webkit|o|ms|moz)\-)?(repeating\-linear\-gradient)/i,
|
|
radialGradient: /^(\-(webkit|o|ms|moz)\-)?(radial\-gradient)/i,
|
|
repeatingRadialGradient: /^(\-(webkit|o|ms|moz)\-)?(repeating\-radial\-gradient)/i,
|
|
conicGradient: /^(\-(webkit|o|ms|moz)\-)?(conic\-gradient)/i,
|
|
repeatingConicGradient: /^(\-(webkit|o|ms|moz)\-)?(repeating\-conic\-gradient)/i,
|
|
sideOrCorner: /^to (left (top|bottom)|right (top|bottom)|top (left|right)|bottom (left|right)|left|right|top|bottom)/i,
|
|
extentKeywords: /^(closest\-side|closest\-corner|farthest\-side|farthest\-corner|contain|cover)/,
|
|
positionKeywords: /^(left|center|right|top|bottom)/i,
|
|
pixelValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))px/,
|
|
percentageValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))\%/,
|
|
emValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))em/,
|
|
remValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))rem/,
|
|
vwValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))vw/,
|
|
vhValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))vh/,
|
|
vminValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))vmin/,
|
|
vmaxValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))vmax/,
|
|
chValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))ch/,
|
|
exValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))ex/,
|
|
angleValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))deg/,
|
|
radianValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))rad/,
|
|
gradianValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))grad/,
|
|
turnValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))turn/,
|
|
startCall: /^\(/,
|
|
endCall: /^\)/,
|
|
comma: /^,/,
|
|
slash: /^\//,
|
|
hexColor: /^\#([0-9a-fA-F]{8}|[0-9a-fA-F]{6}|[0-9a-fA-F]{4}|[0-9a-fA-F]{3})(?![0-9a-fA-F])/,
|
|
literalColor: /^([a-zA-Z]+)/,
|
|
rgbColor: /^rgb/i,
|
|
rgbaColor: /^rgba/i,
|
|
varColor: /^var/i,
|
|
calcValue: /^calc/i,
|
|
variableName: /^(--[a-zA-Z0-9-,\s\#]+)/,
|
|
number: /^(([0-9]*\.[0-9]+)|([0-9]+\.?))/,
|
|
hslColor: /^hsl/i,
|
|
hslaColor: /^hsla/i
|
|
};
|
|
var input = "";
|
|
function error(msg) {
|
|
var err = new Error(input + ": " + msg);
|
|
err.source = input;
|
|
throw err;
|
|
}
|
|
function getAST() {
|
|
var ast = matchListDefinitions();
|
|
if (input.length > 0) {
|
|
error("Invalid input not EOF");
|
|
}
|
|
return ast;
|
|
}
|
|
function matchListDefinitions() {
|
|
return matchListing(matchDefinition);
|
|
}
|
|
function matchDefinition() {
|
|
return matchGradient(
|
|
"linear-gradient",
|
|
tokens.linearGradient,
|
|
matchLinearOrientation
|
|
) || matchGradient(
|
|
"repeating-linear-gradient",
|
|
tokens.repeatingLinearGradient,
|
|
matchLinearOrientation
|
|
) || matchGradient(
|
|
"radial-gradient",
|
|
tokens.radialGradient,
|
|
matchListRadialOrientations
|
|
) || matchGradient(
|
|
"repeating-radial-gradient",
|
|
tokens.repeatingRadialGradient,
|
|
matchListRadialOrientations
|
|
) || matchGradient(
|
|
"conic-gradient",
|
|
tokens.conicGradient,
|
|
matchConicOrientation
|
|
) || matchGradient(
|
|
"repeating-conic-gradient",
|
|
tokens.repeatingConicGradient,
|
|
matchConicOrientation
|
|
);
|
|
}
|
|
function matchGradient(gradientType, pattern, orientationMatcher) {
|
|
return matchCall(pattern, function(captures) {
|
|
var orientation = orientationMatcher();
|
|
if (orientation) {
|
|
if (!scan(tokens.comma)) {
|
|
error("Missing comma before color stops");
|
|
}
|
|
}
|
|
return {
|
|
type: gradientType,
|
|
orientation,
|
|
colorStops: matchListing(matchColorStop)
|
|
};
|
|
});
|
|
}
|
|
function matchCall(pattern, callback) {
|
|
var captures = scan(pattern);
|
|
if (captures) {
|
|
if (!scan(tokens.startCall)) {
|
|
error("Missing (");
|
|
}
|
|
var result = callback(captures);
|
|
if (!scan(tokens.endCall)) {
|
|
error("Missing )");
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
function matchLinearOrientation() {
|
|
var sideOrCorner = matchSideOrCorner();
|
|
if (sideOrCorner) {
|
|
return sideOrCorner;
|
|
}
|
|
var legacyDirection = match("position-keyword", tokens.positionKeywords, 1);
|
|
if (legacyDirection) {
|
|
return {
|
|
type: "directional",
|
|
value: legacyDirection.value
|
|
};
|
|
}
|
|
return matchAngle();
|
|
}
|
|
function matchConicOrientation() {
|
|
var angle = matchFrom();
|
|
var atPosition = matchAtPosition();
|
|
if (angle || atPosition) {
|
|
return {
|
|
type: "conic",
|
|
angle: angle || void 0,
|
|
at: atPosition || void 0
|
|
};
|
|
}
|
|
}
|
|
function matchFrom() {
|
|
if (match("from", /^from/, 0)) {
|
|
var angle = matchAngle();
|
|
if (!angle) {
|
|
error('Missing angle after "from" in conic-gradient');
|
|
}
|
|
return angle;
|
|
}
|
|
}
|
|
function matchSideOrCorner() {
|
|
return match("directional", tokens.sideOrCorner, 1);
|
|
}
|
|
function matchAngle() {
|
|
return matchAngularWithUnit("deg", tokens.angleValue) || matchAngularWithUnit("rad", tokens.radianValue) || matchAngularWithUnit("grad", tokens.gradianValue) || matchAngularWithUnit("turn", tokens.turnValue);
|
|
}
|
|
function matchAngularWithUnit(unit, pattern) {
|
|
var captures = scan(pattern);
|
|
if (captures) {
|
|
return {
|
|
type: "angular",
|
|
value: captures[1],
|
|
unit
|
|
};
|
|
}
|
|
}
|
|
function matchListRadialOrientations() {
|
|
var radialOrientations, radialOrientation = matchRadialOrientation(), lookaheadCache;
|
|
if (radialOrientation) {
|
|
radialOrientations = [];
|
|
radialOrientations.push(radialOrientation);
|
|
lookaheadCache = input;
|
|
if (scan(tokens.comma)) {
|
|
radialOrientation = matchRadialOrientation();
|
|
if (radialOrientation) {
|
|
radialOrientations.push(radialOrientation);
|
|
} else {
|
|
input = lookaheadCache;
|
|
}
|
|
}
|
|
}
|
|
return radialOrientations;
|
|
}
|
|
function matchRadialOrientation() {
|
|
var radialType = matchCircle() || matchEllipse();
|
|
if (radialType) {
|
|
radialType.at = matchAtPosition();
|
|
} else {
|
|
var extent = matchExtentKeyword();
|
|
if (extent) {
|
|
radialType = extent;
|
|
var positionAt = matchAtPosition();
|
|
if (positionAt) {
|
|
radialType.at = positionAt;
|
|
}
|
|
} else {
|
|
var atPosition = matchAtPosition();
|
|
if (atPosition) {
|
|
radialType = {
|
|
type: "default-radial",
|
|
at: atPosition,
|
|
hasAtKeyword: true
|
|
};
|
|
} else {
|
|
var defaultPosition = matchPositioning();
|
|
if (defaultPosition) {
|
|
radialType = {
|
|
type: "default-radial",
|
|
at: defaultPosition
|
|
};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return radialType;
|
|
}
|
|
function matchCircle() {
|
|
var circle = match("shape", /^(circle)/i, 0);
|
|
if (circle) {
|
|
circle.style = matchLength() || matchExtentKeyword();
|
|
}
|
|
return circle;
|
|
}
|
|
function matchEllipse() {
|
|
var ellipse = match("shape", /^(ellipse)/i, 0);
|
|
if (ellipse) {
|
|
ellipse.style = matchPositioning() || matchDistance() || matchExtentKeyword();
|
|
}
|
|
return ellipse;
|
|
}
|
|
function matchExtentKeyword() {
|
|
return match("extent-keyword", tokens.extentKeywords, 1);
|
|
}
|
|
function matchAtPosition() {
|
|
if (match("position", /^at/, 0)) {
|
|
var positioning = matchPositioning();
|
|
if (!positioning) {
|
|
error("Missing positioning value");
|
|
}
|
|
return positioning;
|
|
}
|
|
}
|
|
function matchPositioning() {
|
|
var location = matchCoordinates();
|
|
if (location.x || location.y) {
|
|
return {
|
|
type: "position",
|
|
value: location
|
|
};
|
|
}
|
|
}
|
|
function matchCoordinates() {
|
|
return {
|
|
x: matchDistance(),
|
|
y: matchDistance()
|
|
};
|
|
}
|
|
function matchListing(matcher) {
|
|
var captures = matcher(), result = [];
|
|
if (captures) {
|
|
result.push(captures);
|
|
while (scan(tokens.comma)) {
|
|
captures = matcher();
|
|
if (captures) {
|
|
result.push(captures);
|
|
} else {
|
|
error("One extra comma");
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function matchColorStop() {
|
|
var color = matchColor();
|
|
if (!color) {
|
|
error("Expected color definition");
|
|
}
|
|
color.length = matchDistance();
|
|
if (color.length) {
|
|
color.length2 = matchDistance();
|
|
}
|
|
return color;
|
|
}
|
|
function matchColor() {
|
|
return matchHexColor() || matchHSLAColor() || matchHSLColor() || matchRGBAColor() || matchRGBColor() || matchVarColor() || matchLiteralColor();
|
|
}
|
|
function matchLiteralColor() {
|
|
return match("literal", tokens.literalColor, 0);
|
|
}
|
|
function matchHexColor() {
|
|
return match("hex", tokens.hexColor, 1);
|
|
}
|
|
function matchRGBColor() {
|
|
return matchCall(tokens.rgbColor, function() {
|
|
return matchRGBValues("rgb");
|
|
});
|
|
}
|
|
function matchRGBAColor() {
|
|
return matchCall(tokens.rgbaColor, function() {
|
|
return matchRGBValues("rgba");
|
|
});
|
|
}
|
|
function matchRGBValues(baseType) {
|
|
var r = matchNumber();
|
|
if (scan(tokens.comma)) {
|
|
var g = matchNumber();
|
|
scan(tokens.comma);
|
|
var b = matchNumber();
|
|
var values = [r, g, b];
|
|
if (scan(tokens.comma)) {
|
|
values.push(matchNumber());
|
|
return { type: "rgba", value: values };
|
|
}
|
|
return { type: baseType, value: values };
|
|
} else {
|
|
var g = matchNumber();
|
|
var b = matchNumber();
|
|
var values = [r, g, b];
|
|
if (scan(tokens.slash)) {
|
|
values.push(matchNumber());
|
|
return { type: "rgba", value: values };
|
|
}
|
|
return { type: baseType, value: values };
|
|
}
|
|
}
|
|
function matchVarColor() {
|
|
return matchCall(tokens.varColor, function() {
|
|
return {
|
|
type: "var",
|
|
value: matchVariableName()
|
|
};
|
|
});
|
|
}
|
|
function matchHSLColor() {
|
|
return matchCall(tokens.hslColor, function() {
|
|
return matchHSLValues("hsl");
|
|
});
|
|
}
|
|
function matchHSLAColor() {
|
|
return matchCall(tokens.hslaColor, function() {
|
|
return matchHSLValues("hsla");
|
|
});
|
|
}
|
|
function matchHSLValues(baseType) {
|
|
var lookahead = scan(tokens.percentageValue);
|
|
if (lookahead) {
|
|
error("HSL hue value must be a number in degrees (0-360) or normalized (-360 to 360), not a percentage");
|
|
}
|
|
var hue = matchNumber();
|
|
if (scan(tokens.comma)) {
|
|
var captures = scan(tokens.percentageValue);
|
|
var sat = captures ? captures[1] : null;
|
|
scan(tokens.comma);
|
|
captures = scan(tokens.percentageValue);
|
|
var light = captures ? captures[1] : null;
|
|
if (!sat || !light) {
|
|
error("Expected percentage value for saturation and lightness in HSL");
|
|
}
|
|
if (scan(tokens.comma)) {
|
|
var alpha = matchNumber();
|
|
return { type: "hsla", value: [hue, sat, light, alpha] };
|
|
}
|
|
return { type: baseType, value: [hue, sat, light] };
|
|
} else {
|
|
var captures = scan(tokens.percentageValue);
|
|
var sat = captures ? captures[1] : null;
|
|
captures = scan(tokens.percentageValue);
|
|
var light = captures ? captures[1] : null;
|
|
if (!sat || !light) {
|
|
error("Expected percentage value for saturation and lightness in HSL");
|
|
}
|
|
if (scan(tokens.slash)) {
|
|
var alpha = matchNumber();
|
|
return { type: "hsla", value: [hue, sat, light, alpha] };
|
|
}
|
|
return { type: baseType, value: [hue, sat, light] };
|
|
}
|
|
}
|
|
function matchPercentage() {
|
|
var captures = scan(tokens.percentageValue);
|
|
return captures ? captures[1] : null;
|
|
}
|
|
function matchVariableName() {
|
|
return scan(tokens.variableName)[1];
|
|
}
|
|
function matchNumber() {
|
|
return scan(tokens.number)[1];
|
|
}
|
|
function matchDistance() {
|
|
return match("%", tokens.percentageValue, 1) || matchPositionKeyword() || matchCalc() || matchLength();
|
|
}
|
|
function matchPositionKeyword() {
|
|
return match("position-keyword", tokens.positionKeywords, 1);
|
|
}
|
|
function matchCalc() {
|
|
return matchCall(tokens.calcValue, function() {
|
|
var openParenCount = 1;
|
|
var i = 0;
|
|
while (openParenCount > 0 && i < input.length) {
|
|
var char = input.charAt(i);
|
|
if (char === "(") {
|
|
openParenCount++;
|
|
} else if (char === ")") {
|
|
openParenCount--;
|
|
}
|
|
i++;
|
|
}
|
|
if (openParenCount > 0) {
|
|
error("Missing closing parenthesis in calc() expression");
|
|
}
|
|
var calcContent = input.substring(0, i - 1);
|
|
consume(i - 1);
|
|
return {
|
|
type: "calc",
|
|
value: calcContent
|
|
};
|
|
});
|
|
}
|
|
function matchLength() {
|
|
return match("px", tokens.pixelValue, 1) || match("em", tokens.emValue, 1) || match("rem", tokens.remValue, 1) || match("vw", tokens.vwValue, 1) || match("vh", tokens.vhValue, 1) || match("vmin", tokens.vminValue, 1) || match("vmax", tokens.vmaxValue, 1) || match("ch", tokens.chValue, 1) || match("ex", tokens.exValue, 1);
|
|
}
|
|
function match(type, pattern, captureIndex) {
|
|
var captures = scan(pattern);
|
|
if (captures) {
|
|
return {
|
|
type,
|
|
value: captures[captureIndex]
|
|
};
|
|
}
|
|
}
|
|
function scan(regexp) {
|
|
var captures, blankCaptures;
|
|
blankCaptures = /^[\n\r\t\s]+/.exec(input);
|
|
if (blankCaptures) {
|
|
consume(blankCaptures[0].length);
|
|
}
|
|
captures = regexp.exec(input);
|
|
if (captures) {
|
|
consume(captures[0].length);
|
|
}
|
|
return captures;
|
|
}
|
|
function consume(size) {
|
|
input = input.substring(size);
|
|
}
|
|
return function(code) {
|
|
input = code.toString().trim();
|
|
if (input.endsWith(";")) {
|
|
input = input.slice(0, -1);
|
|
}
|
|
return getAST();
|
|
};
|
|
})();
|
|
var parse2 = GradientParser.parse;
|
|
var stringify2 = GradientParser.stringify;
|
|
var esm_default = { parse: GradientParser.parse, stringify: GradientParser.stringify };
|
|
|
|
// node_modules/dom-to-svg/lib/gradients.js
|
|
var positionsForOrientation = (orientation) => {
|
|
const positions = {
|
|
x1: "0%",
|
|
x2: "0%",
|
|
y1: "0%",
|
|
y2: "0%"
|
|
};
|
|
if ((orientation === null || orientation === void 0 ? void 0 : orientation.type) === "angular") {
|
|
const anglePI = orientation.value * (Math.PI / 180);
|
|
positions.x1 = `${Math.round(50 + Math.sin(anglePI + Math.PI) * 50)}%`;
|
|
positions.y1 = `${Math.round(50 + Math.cos(anglePI) * 50)}%`;
|
|
positions.x2 = `${Math.round(50 + Math.sin(anglePI) * 50)}%`;
|
|
positions.y2 = `${Math.round(50 + Math.cos(anglePI + Math.PI) * 50)}%`;
|
|
} else if ((orientation === null || orientation === void 0 ? void 0 : orientation.type) === "directional") {
|
|
switch (orientation.value) {
|
|
case "left":
|
|
positions.x1 = "100%";
|
|
break;
|
|
case "top":
|
|
positions.y1 = "100%";
|
|
break;
|
|
case "right":
|
|
positions.x2 = "100%";
|
|
break;
|
|
case "bottom":
|
|
positions.y2 = "100%";
|
|
break;
|
|
}
|
|
}
|
|
return positions;
|
|
};
|
|
function convertLinearGradient(css, { svgDocument }) {
|
|
const { orientation, colorStops } = parse2(css)[0];
|
|
const { x1, x2, y1, y2 } = positionsForOrientation(orientation);
|
|
const getColorStops = (colorStop, index) => {
|
|
const offset = `${index / (colorStops.length - 1) * 100}%`;
|
|
let stopColor = "rgb(0,0,0)";
|
|
let stopOpacity = 1;
|
|
switch (colorStop.type) {
|
|
case "rgb": {
|
|
const [red, green, blue] = colorStop.value;
|
|
stopColor = `rgb(${red},${green},${blue})`;
|
|
break;
|
|
}
|
|
case "rgba": {
|
|
const [red, green, blue, alpha] = colorStop.value;
|
|
stopColor = `rgb(${red},${green},${blue})`;
|
|
stopOpacity = alpha;
|
|
break;
|
|
}
|
|
case "hex": {
|
|
stopColor = `#${colorStop.value}`;
|
|
break;
|
|
}
|
|
case "literal": {
|
|
stopColor = colorStop.value;
|
|
break;
|
|
}
|
|
}
|
|
const stop = svgDocument.createElementNS(svgNamespace, "stop");
|
|
stop.setAttribute("offset", offset);
|
|
stop.setAttribute("stop-color", stopColor);
|
|
stop.setAttribute("stop-opacity", stopOpacity.toString());
|
|
return stop;
|
|
};
|
|
const linearGradient = svgDocument.createElementNS(svgNamespace, "linearGradient");
|
|
linearGradient.setAttribute("x1", x1);
|
|
linearGradient.setAttribute("y1", y1);
|
|
linearGradient.setAttribute("x2", x2);
|
|
linearGradient.setAttribute("y2", y2);
|
|
linearGradient.append(...colorStops.map(getColorStops));
|
|
return linearGradient;
|
|
}
|
|
|
|
// node_modules/dom-to-svg/lib/svg.js
|
|
var import_postcss_value_parser = __toESM(require_lib(), 1);
|
|
|
|
// node_modules/dom-to-svg/lib/util.js
|
|
var createIdGenerator = () => {
|
|
const nextCounts = /* @__PURE__ */ new Map();
|
|
return (prefix) => {
|
|
var _a;
|
|
const count = (_a = nextCounts.get(prefix)) !== null && _a !== void 0 ? _a : 1;
|
|
nextCounts.set(prefix, count + 1);
|
|
return `${prefix}${count}`;
|
|
};
|
|
};
|
|
var doRectanglesIntersect = (a, b) => !(a.bottom < b.top || // A is above B
|
|
a.top > b.bottom || // A is below B
|
|
a.right < b.left || // A is left of B
|
|
// A is right of B
|
|
a.left > b.right);
|
|
function diagonale(box) {
|
|
return Math.sqrt(box.width ** 2 + box.height ** 2);
|
|
}
|
|
function withTimeout(timeout, message, func) {
|
|
return Promise.race([
|
|
func(),
|
|
new Promise((resolve, reject) => setTimeout(() => reject(new Error(message)), timeout))
|
|
]);
|
|
}
|
|
var isTaggedUnionMember = (key, value) => (object) => object[key] === value;
|
|
function assert(condition, message) {
|
|
if (!condition) {
|
|
throw new Error(message);
|
|
}
|
|
}
|
|
|
|
// node_modules/dom-to-svg/lib/text.js
|
|
function handleTextNode(textNode, context) {
|
|
if (!textNode.ownerDocument.defaultView) {
|
|
throw new Error("Element's ownerDocument has no defaultView");
|
|
}
|
|
const window2 = textNode.ownerDocument.defaultView;
|
|
const parentElement = textNode.parentElement;
|
|
const styles = window2.getComputedStyle(parentElement);
|
|
if (!isVisible(styles)) {
|
|
return;
|
|
}
|
|
const selection = window2.getSelection();
|
|
assert(selection, "Could not obtain selection from window. Selection is needed for detecting whitespace collapsing in text.");
|
|
const svgTextElement = context.svgDocument.createElementNS(svgNamespace, "text");
|
|
copyTextStyles(styles, svgTextElement);
|
|
const tabSize = parseInt(styles.tabSize, 10);
|
|
svgTextElement.setAttribute("dominant-baseline", "text-after-edge");
|
|
const lineRange = textNode.ownerDocument.createRange();
|
|
lineRange.setStart(textNode, 0);
|
|
lineRange.setEnd(textNode, 0);
|
|
while (true) {
|
|
const addTextSpanForLineRange = () => {
|
|
if (lineRange.collapsed) {
|
|
return;
|
|
}
|
|
const lineRectangle = lineRange.getClientRects()[0];
|
|
if (!doRectanglesIntersect(lineRectangle, context.options.captureArea)) {
|
|
return;
|
|
}
|
|
const textSpan = context.svgDocument.createElementNS(svgNamespace, "tspan");
|
|
textSpan.setAttribute("xml:space", "preserve");
|
|
const previousUserSelect = parentElement.style.userSelect;
|
|
parentElement.style.userSelect = "all";
|
|
try {
|
|
selection.removeAllRanges();
|
|
selection.addRange(lineRange);
|
|
textSpan.textContent = selection.toString().replace(/\t/g, " ".repeat(tabSize));
|
|
} finally {
|
|
parentElement.style.userSelect = previousUserSelect;
|
|
selection.removeAllRanges();
|
|
}
|
|
textSpan.setAttribute("x", lineRectangle.x.toString());
|
|
textSpan.setAttribute("y", lineRectangle.bottom.toString());
|
|
textSpan.setAttribute("textLength", lineRectangle.width.toString());
|
|
textSpan.setAttribute("lengthAdjust", "spacingAndGlyphs");
|
|
svgTextElement.append(textSpan);
|
|
};
|
|
try {
|
|
lineRange.setEnd(textNode, lineRange.endOffset + 1);
|
|
} catch (error) {
|
|
if (error.code === DOMException.INDEX_SIZE_ERR) {
|
|
addTextSpanForLineRange();
|
|
break;
|
|
}
|
|
throw error;
|
|
}
|
|
const lineRectangles = lineRange.getClientRects();
|
|
if (!lineRectangles[0]) {
|
|
return;
|
|
}
|
|
if (lineRectangles[1] && lineRectangles[0].top !== lineRectangles[1].top) {
|
|
lineRange.setEnd(textNode, lineRange.endOffset - 1);
|
|
addTextSpanForLineRange();
|
|
lineRange.setStart(textNode, lineRange.endOffset);
|
|
}
|
|
}
|
|
context.currentSvgParent.append(svgTextElement);
|
|
}
|
|
var textAttributes = /* @__PURE__ */ new Set([
|
|
"color",
|
|
"dominant-baseline",
|
|
"font-family",
|
|
"font-size",
|
|
"font-size-adjust",
|
|
"font-stretch",
|
|
"font-style",
|
|
"font-variant",
|
|
"font-weight",
|
|
"direction",
|
|
"letter-spacing",
|
|
"text-decoration",
|
|
"text-anchor",
|
|
"text-decoration",
|
|
"text-rendering",
|
|
"unicode-bidi",
|
|
"word-spacing",
|
|
"writing-mode",
|
|
"user-select"
|
|
]);
|
|
function copyTextStyles(styles, svgElement) {
|
|
for (const textProperty of textAttributes) {
|
|
const value = styles.getPropertyValue(textProperty);
|
|
if (value) {
|
|
svgElement.setAttribute(textProperty, value);
|
|
}
|
|
}
|
|
svgElement.setAttribute("fill", styles.color);
|
|
}
|
|
|
|
// node_modules/dom-to-svg/lib/svg.js
|
|
function handleSvgNode(node, context) {
|
|
if (isElement(node)) {
|
|
if (!isSVGElement(node)) {
|
|
return;
|
|
}
|
|
handleSvgElement(node, context);
|
|
} else if (isTextNode(node)) {
|
|
const clonedTextNode = node.cloneNode(true);
|
|
context.currentSvgParent.append(clonedTextNode);
|
|
}
|
|
}
|
|
var ignoredElements = /* @__PURE__ */ new Set(["script", "style", "foreignElement"]);
|
|
var URL_ID_REFERENCE_REGEX = /\burl\(["']?#/;
|
|
function handleSvgElement(element, context) {
|
|
var _a, _b, _c, _d;
|
|
if (ignoredElements.has(element.tagName)) {
|
|
return;
|
|
}
|
|
let elementToAppend;
|
|
if (isSVGSVGElement(element)) {
|
|
const contentContainer = context.svgDocument.createElementNS(svgNamespace, "g");
|
|
elementToAppend = contentContainer;
|
|
contentContainer.classList.add("svg-content", ...element.classList);
|
|
contentContainer.dataset.viewBox = (_a = element.getAttribute("viewBox")) !== null && _a !== void 0 ? _a : "";
|
|
contentContainer.dataset.width = (_b = element.getAttribute("width")) !== null && _b !== void 0 ? _b : "";
|
|
contentContainer.dataset.height = (_c = element.getAttribute("height")) !== null && _c !== void 0 ? _c : "";
|
|
for (const child of element.children) {
|
|
if (!isSVGGraphicsElement(child)) {
|
|
continue;
|
|
}
|
|
let viewBoxTransformMatrix = (
|
|
// When this function is called on an inline <svg> element in the original DOM, we want
|
|
// getScreenCTM() to map it to the DOM coordinate system. When this function is called from
|
|
// inlineResources() the <svg> is already embedded into the output <svg>. In that case the output
|
|
// SVG already has a viewBox, and the coordinate system of the SVG is not equal to the coordinate
|
|
// system of the screen, therefor we need to use getCTM() to map it into the output SVG's
|
|
// coordinate system.
|
|
child.ownerDocument !== context.svgDocument && // When we inline an SVG, we put a transform on it for the getScreenCTM(). When that SVG also
|
|
// contains another SVG, the inner SVG should just get transformed relative to the outer SVG, not
|
|
// relative to the screen, because the transforms will stack in the output SVG.
|
|
!((_d = element.parentElement) === null || _d === void 0 ? void 0 : _d.closest("svg")) ? child.getScreenCTM() : child.getCTM()
|
|
);
|
|
if (!viewBoxTransformMatrix) {
|
|
break;
|
|
}
|
|
if (child.transform.baseVal.numberOfItems > 0) {
|
|
child.transform.baseVal.consolidate();
|
|
const existingTransform = child.transform.baseVal.getItem(0).matrix;
|
|
viewBoxTransformMatrix = viewBoxTransformMatrix.multiply(existingTransform.inverse());
|
|
}
|
|
contentContainer.transform.baseVal.appendItem(contentContainer.transform.baseVal.createSVGTransformFromMatrix(viewBoxTransformMatrix));
|
|
break;
|
|
}
|
|
} else {
|
|
if (isSVGAnchorElement(element) && !context.options.keepLinks) {
|
|
elementToAppend = context.svgDocument.createElementNS(svgNamespace, "g");
|
|
} else {
|
|
elementToAppend = element.cloneNode(false);
|
|
}
|
|
for (const attribute of elementToAppend.attributes) {
|
|
if (attribute.localName.startsWith("on")) {
|
|
elementToAppend.attributes.removeNamedItemNS(attribute.namespaceURI, attribute.localName);
|
|
} else if (attribute.localName === "href" && attribute.value.startsWith("javascript:")) {
|
|
elementToAppend.attributes.removeNamedItemNS(attribute.namespaceURI, attribute.localName);
|
|
}
|
|
}
|
|
const window2 = element.ownerDocument.defaultView;
|
|
assert(window2, "Element's ownerDocument has no defaultView");
|
|
const svgViewportElement = element.ownerSVGElement;
|
|
assert(svgViewportElement, "Expected element to have ownerSVGElement");
|
|
const styles = window2.getComputedStyle(element);
|
|
if (isSVGGraphicsElement(element)) {
|
|
copyGraphicalPresentationAttributes(styles, elementToAppend, svgViewportElement.viewBox.animVal);
|
|
if (isSVGTextContentElement(element)) {
|
|
copyTextStyles(styles, elementToAppend);
|
|
}
|
|
}
|
|
for (const attribute of elementToAppend.attributes) {
|
|
if (attribute.localName === "href") {
|
|
if (attribute.value.startsWith("#")) {
|
|
attribute.value = attribute.value.replace("#", `#${context.idPrefix}`);
|
|
}
|
|
} else if (URL_ID_REFERENCE_REGEX.test(attribute.value)) {
|
|
attribute.value = rewriteUrlIdReferences(attribute.value, context);
|
|
}
|
|
}
|
|
for (const property of elementToAppend.style) {
|
|
const value = elementToAppend.style.getPropertyValue(property);
|
|
if (URL_ID_REFERENCE_REGEX.test(value)) {
|
|
elementToAppend.style.setProperty(property, rewriteUrlIdReferences(value, context), elementToAppend.style.getPropertyPriority(property));
|
|
}
|
|
}
|
|
}
|
|
if (elementToAppend.id) {
|
|
elementToAppend.id = context.idPrefix + elementToAppend.id;
|
|
}
|
|
context.currentSvgParent.append(elementToAppend);
|
|
for (const child of element.childNodes) {
|
|
handleSvgNode(child, { ...context, currentSvgParent: elementToAppend });
|
|
}
|
|
}
|
|
var graphicalPresentationAttributes = [
|
|
"alignment-baseline",
|
|
"baseline-shift",
|
|
// 'clip',
|
|
"clip-path",
|
|
"clip-rule",
|
|
"color",
|
|
"color-interpolation",
|
|
"color-interpolation-filters",
|
|
// 'color-profile',
|
|
"color-rendering",
|
|
// 'cursor',
|
|
"direction",
|
|
// 'display',
|
|
// 'enable-background',
|
|
"fill",
|
|
"fill-opacity",
|
|
"fill-rule",
|
|
"filter",
|
|
"flood-color",
|
|
"flood-opacity",
|
|
"image-rendering",
|
|
"lighting-color",
|
|
"marker-end",
|
|
"marker-mid",
|
|
"marker-start",
|
|
"mask",
|
|
"opacity",
|
|
// 'overflow',
|
|
"pointer-events",
|
|
"shape-rendering",
|
|
// 'solid-color',
|
|
// 'solid-opacity',
|
|
"stop-color",
|
|
"stop-opacity",
|
|
"stroke",
|
|
"stroke-dasharray",
|
|
"stroke-dashoffset",
|
|
"stroke-linecap",
|
|
"stroke-linejoin",
|
|
"stroke-miterlimit",
|
|
"stroke-opacity",
|
|
"stroke-width",
|
|
"transform",
|
|
"vector-effect",
|
|
"visibility"
|
|
];
|
|
var defaults = {
|
|
"alignment-baseline": "auto",
|
|
"baseline-shift": "0px",
|
|
"clip-path": "none",
|
|
"clip-rule": "nonzero",
|
|
"color-interpolation-filters": "linearrgb",
|
|
"color-interpolation": "srgb",
|
|
"color-rendering": "auto",
|
|
"fill-opacity": "1",
|
|
"fill-rule": "nonzero",
|
|
"flood-color": "rgb(0, 0, 0)",
|
|
"flood-opacity": "1",
|
|
"image-rendering": "auto",
|
|
"lighting-color": "rgb(255, 255, 255)",
|
|
"marker-end": "none",
|
|
"marker-mid": "none",
|
|
"marker-start": "none",
|
|
"pointer-events": "auto",
|
|
"shape-rendering": "auto",
|
|
"stop-color": "rgb(0, 0, 0)",
|
|
"stop-opacity": "1",
|
|
"stroke-dasharray": "none",
|
|
"stroke-dashoffset": "0px",
|
|
"stroke-linecap": "butt",
|
|
"stroke-linejoin": "miter",
|
|
"stroke-miterlimit": "4",
|
|
"stroke-opacity": "1",
|
|
"stroke-width": "1px",
|
|
"vector-effect": "none",
|
|
color: "",
|
|
direction: "ltr",
|
|
fill: "",
|
|
filter: "none",
|
|
mask: "none",
|
|
opacity: "1",
|
|
stroke: "",
|
|
transform: "none",
|
|
visibility: "visible"
|
|
};
|
|
function rewriteUrlIdReferences(value, { idPrefix }) {
|
|
const parsedValue = (0, import_postcss_value_parser.default)(value);
|
|
parsedValue.walk((node) => {
|
|
if (node.type !== "function" || node.value !== "url") {
|
|
return;
|
|
}
|
|
const urlArgument = node.nodes[0];
|
|
if (!urlArgument) {
|
|
return;
|
|
}
|
|
urlArgument.value = urlArgument.value.replace("#", `#${idPrefix}`);
|
|
});
|
|
return import_postcss_value_parser.default.stringify(parsedValue.nodes);
|
|
}
|
|
function copyGraphicalPresentationAttributes(styles, target, viewBox) {
|
|
var _a;
|
|
for (const attribute of graphicalPresentationAttributes) {
|
|
let value = styles.getPropertyValue(attribute);
|
|
if (value && value !== defaults[attribute]) {
|
|
if (value.endsWith("%")) {
|
|
value = (_a = parseCSSLength(value, diagonale(viewBox))) !== null && _a !== void 0 ? _a : 0;
|
|
}
|
|
target.setAttribute(attribute, value.toString());
|
|
}
|
|
}
|
|
}
|
|
|
|
// node_modules/dom-to-svg/lib/element.js
|
|
function handleElement(element, context) {
|
|
var _a, _b, _c, _d, _e, _f, _g;
|
|
const cleanupFunctions = [];
|
|
try {
|
|
const window2 = element.ownerDocument.defaultView;
|
|
if (!window2) {
|
|
throw new Error("Element's ownerDocument has no defaultView");
|
|
}
|
|
const bounds = element.getBoundingClientRect();
|
|
const rectanglesIntersect = doRectanglesIntersect(bounds, context.options.captureArea);
|
|
const styles = window2.getComputedStyle(element);
|
|
const parentStyles = element.parentElement && window2.getComputedStyle(element.parentElement);
|
|
const svgContainer = isHTMLAnchorElement(element) && context.options.keepLinks ? createSvgAnchor(element, context) : context.svgDocument.createElementNS(svgNamespace, "g");
|
|
svgContainer.dataset.tag = element.tagName.toLowerCase();
|
|
const id = element.id || context.getUniqueId(element.classList[0] || element.tagName.toLowerCase());
|
|
svgContainer.id = id;
|
|
const className = element.getAttribute("class");
|
|
if (className) {
|
|
svgContainer.setAttribute("class", className);
|
|
}
|
|
if (isHTMLElement(element) && element.title) {
|
|
const svgTitle = context.svgDocument.createElementNS(svgNamespace, "title");
|
|
svgTitle.textContent = element.title;
|
|
svgContainer.prepend(svgTitle);
|
|
}
|
|
const stackingLayerName = determineStackingLayer(styles, parentStyles);
|
|
const stackingLayer = stackingLayerName ? context.stackingLayers[stackingLayerName] : context.parentStackingLayer;
|
|
if (stackingLayer) {
|
|
context.currentSvgParent.setAttribute("aria-owns", [context.currentSvgParent.getAttribute("aria-owns"), svgContainer.id].filter(Boolean).join(" "));
|
|
}
|
|
const elementToAppendTo = context.parentStackingLayer === stackingLayer ? context.currentSvgParent : stackingLayer;
|
|
svgContainer.dataset.zIndex = styles.zIndex;
|
|
elementToAppendTo.append(svgContainer);
|
|
let childContext;
|
|
let backgroundContainer;
|
|
let ownStackingLayers;
|
|
if (establishesStackingContext(styles, parentStyles)) {
|
|
ownStackingLayers = createStackingLayers(svgContainer);
|
|
backgroundContainer = ownStackingLayers.rootBackgroundAndBorders;
|
|
childContext = {
|
|
...context,
|
|
currentSvgParent: svgContainer,
|
|
stackingLayers: ownStackingLayers,
|
|
parentStackingLayer: stackingLayer
|
|
};
|
|
} else {
|
|
backgroundContainer = svgContainer;
|
|
childContext = {
|
|
...context,
|
|
currentSvgParent: svgContainer,
|
|
parentStackingLayer: stackingLayer
|
|
};
|
|
}
|
|
if (styles.opacity !== "1") {
|
|
svgContainer.setAttribute("opacity", styles.opacity);
|
|
}
|
|
for (const [name, value] of getAccessibilityAttributes(element, context)) {
|
|
svgContainer.setAttribute(name, value);
|
|
}
|
|
if (isHTMLElement(element) && !element.dataset.pseudoElement) {
|
|
const handlePseudoElement = (pseudoSelector, position) => {
|
|
const pseudoElementStyles = window2.getComputedStyle(element, pseudoSelector);
|
|
const content = (0, import_postcss_value_parser2.default)(pseudoElementStyles.content).nodes.find(isTaggedUnionMember("type", "string"));
|
|
if (!content) {
|
|
return;
|
|
}
|
|
const span = element.ownerDocument.createElement("span");
|
|
span.dataset.pseudoElement = pseudoSelector;
|
|
copyCssStyles(pseudoElementStyles, span.style);
|
|
span.textContent = unescapeStringValue(content.value);
|
|
element.dataset.pseudoElementOwner = id;
|
|
cleanupFunctions.push(() => element.removeAttribute("data-pseudo-element-owner"));
|
|
const style = element.ownerDocument.createElement("style");
|
|
style.textContent = `[data-pseudo-element-owner="${id}"]${pseudoSelector} { display: none !important; }`;
|
|
element.before(style);
|
|
cleanupFunctions.push(() => style.remove());
|
|
element[position](span);
|
|
cleanupFunctions.push(() => span.remove());
|
|
};
|
|
handlePseudoElement("::before", "prepend");
|
|
handlePseudoElement("::after", "append");
|
|
}
|
|
if (rectanglesIntersect) {
|
|
addBackgroundAndBorders(styles, bounds, backgroundContainer, window2, context);
|
|
}
|
|
if (styles.overflow !== "visible") {
|
|
const mask = context.svgDocument.createElementNS(svgNamespace, "mask");
|
|
mask.id = context.getUniqueId("mask-for-" + id);
|
|
const visibleRectangle = createBox(bounds, context);
|
|
visibleRectangle.setAttribute("fill", "#ffffff");
|
|
mask.append(visibleRectangle);
|
|
svgContainer.append(mask);
|
|
svgContainer.setAttribute("mask", `url(#${mask.id})`);
|
|
childContext = {
|
|
...childContext,
|
|
ancestorMasks: [{ mask, forElement: element }, ...childContext.ancestorMasks]
|
|
};
|
|
}
|
|
if (isHTMLElement(element) && (styles.position === "absolute" || styles.position === "fixed") && context.ancestorMasks.length > 0 && element.offsetParent) {
|
|
for (const { mask, forElement } of context.ancestorMasks) {
|
|
if (element.offsetParent.contains(forElement) || element.offsetParent === forElement) {
|
|
const visibleRectangle = createBox(bounds, context);
|
|
visibleRectangle.setAttribute("fill", "#ffffff");
|
|
mask.append(visibleRectangle);
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (rectanglesIntersect && isHTMLImageElement(element) && // Make sure the element has a src/srcset attribute (the relative URL). `element.src` is absolute and always defined.
|
|
(element.getAttribute("src") || element.getAttribute("srcset"))) {
|
|
const svgImage = context.svgDocument.createElementNS(svgNamespace, "image");
|
|
svgImage.id = `${id}-image`;
|
|
svgImage.setAttribute("xlink:href", element.currentSrc || element.src);
|
|
const paddingLeft = (_a = parseCSSLength(styles.paddingLeft, bounds.width)) !== null && _a !== void 0 ? _a : 0;
|
|
const paddingRight = (_b = parseCSSLength(styles.paddingRight, bounds.width)) !== null && _b !== void 0 ? _b : 0;
|
|
const paddingTop = (_c = parseCSSLength(styles.paddingTop, bounds.height)) !== null && _c !== void 0 ? _c : 0;
|
|
const paddingBottom = (_d = parseCSSLength(styles.paddingBottom, bounds.height)) !== null && _d !== void 0 ? _d : 0;
|
|
svgImage.setAttribute("x", (bounds.x + paddingLeft).toString());
|
|
svgImage.setAttribute("y", (bounds.y + paddingTop).toString());
|
|
svgImage.setAttribute("width", (bounds.width - paddingLeft - paddingRight).toString());
|
|
svgImage.setAttribute("height", (bounds.height - paddingTop - paddingBottom).toString());
|
|
if (element.alt) {
|
|
svgImage.setAttribute("aria-label", element.alt);
|
|
}
|
|
svgContainer.append(svgImage);
|
|
} else if (rectanglesIntersect && isHTMLInputElement(element) && bounds.width > 0 && bounds.height > 0) {
|
|
if (element.value) {
|
|
const svgTextElement = context.svgDocument.createElementNS(svgNamespace, "text");
|
|
copyTextStyles(styles, svgTextElement);
|
|
svgTextElement.setAttribute("dominant-baseline", "central");
|
|
svgTextElement.setAttribute("xml:space", "preserve");
|
|
svgTextElement.setAttribute("x", (bounds.x + ((_e = parseCSSLength(styles.paddingLeft, bounds.width)) !== null && _e !== void 0 ? _e : 0)).toString());
|
|
const top = bounds.top + ((_f = parseCSSLength(styles.paddingTop, bounds.height)) !== null && _f !== void 0 ? _f : 0);
|
|
const bottom = bounds.bottom + ((_g = parseCSSLength(styles.paddingBottom, bounds.height)) !== null && _g !== void 0 ? _g : 0);
|
|
const middle = (top + bottom) / 2;
|
|
svgTextElement.setAttribute("y", middle.toString());
|
|
svgTextElement.textContent = element.value;
|
|
childContext.stackingLayers.inFlowInlineLevelNonPositionedDescendants.append(svgTextElement);
|
|
}
|
|
} else if (rectanglesIntersect && isSVGSVGElement(element) && isVisible(styles)) {
|
|
handleSvgNode(element, { ...childContext, idPrefix: `${id}-` });
|
|
} else {
|
|
for (const child of element.childNodes) {
|
|
walkNode(child, childContext);
|
|
}
|
|
if (ownStackingLayers) {
|
|
sortStackingLayerChildren(ownStackingLayers);
|
|
cleanupStackingLayerChildren(ownStackingLayers);
|
|
}
|
|
}
|
|
} finally {
|
|
for (const cleanup of cleanupFunctions) {
|
|
cleanup();
|
|
}
|
|
}
|
|
}
|
|
function addBackgroundAndBorders(styles, bounds, backgroundAndBordersContainer, window2, context) {
|
|
var _a, _b, _c, _d;
|
|
if (isVisible(styles)) {
|
|
if (bounds.width > 0 && bounds.height > 0 && (!isTransparent(styles.backgroundColor) || hasUniformBorder(styles) || styles.backgroundImage !== "none")) {
|
|
const box = createBackgroundAndBorderBox(bounds, styles, context);
|
|
backgroundAndBordersContainer.append(box);
|
|
if (styles.backgroundImage !== "none") {
|
|
const backgrounds = (0, import_postcss_value_parser2.default)(styles.backgroundImage).nodes.filter(isTaggedUnionMember("type", "function")).reverse();
|
|
const xBackgroundPositions = styles.backgroundPositionX.split(/\s*,\s*/g);
|
|
const yBackgroundPositions = styles.backgroundPositionY.split(/\s*,\s*/g);
|
|
const backgroundRepeats = styles.backgroundRepeat.split(/\s*,\s*/g);
|
|
for (const [index, backgroundNode] of backgrounds.entries()) {
|
|
const backgroundPositionX = (_a = parseCSSLength(xBackgroundPositions[index], bounds.width)) !== null && _a !== void 0 ? _a : 0;
|
|
const backgroundPositionY = (_b = parseCSSLength(yBackgroundPositions[index], bounds.height)) !== null && _b !== void 0 ? _b : 0;
|
|
const backgroundRepeat = backgroundRepeats[index];
|
|
if (backgroundNode.value === "url" && backgroundNode.nodes[0]) {
|
|
const urlArgument = backgroundNode.nodes[0];
|
|
const image = context.svgDocument.createElementNS(svgNamespace, "image");
|
|
image.id = context.getUniqueId("background-image");
|
|
const [cssWidth = "auto", cssHeight = "auto"] = styles.backgroundSize.split(" ");
|
|
const backgroundWidth = (_c = parseCSSLength(cssWidth, bounds.width)) !== null && _c !== void 0 ? _c : bounds.width;
|
|
const backgroundHeight = (_d = parseCSSLength(cssHeight, bounds.height)) !== null && _d !== void 0 ? _d : bounds.height;
|
|
image.setAttribute("width", backgroundWidth.toString());
|
|
image.setAttribute("height", backgroundHeight.toString());
|
|
if (cssWidth !== "auto" && cssHeight !== "auto") {
|
|
image.setAttribute("preserveAspectRatio", "none");
|
|
} else if (styles.backgroundSize === "contain") {
|
|
image.setAttribute("preserveAspectRatio", "xMidYMid meet");
|
|
} else if (styles.backgroundSize === "cover") {
|
|
image.setAttribute("preserveAspectRatio", "xMidYMid slice");
|
|
}
|
|
const url = new URL(unescapeStringValue(urlArgument.value), window2.location.href);
|
|
image.setAttribute("xlink:href", url.href);
|
|
if (backgroundRepeat === "no-repeat" || backgroundPositionX === 0 && backgroundPositionY === 0 && backgroundWidth === bounds.width && backgroundHeight === bounds.height) {
|
|
image.setAttribute("x", bounds.x.toString());
|
|
image.setAttribute("y", bounds.y.toString());
|
|
backgroundAndBordersContainer.append(image);
|
|
} else {
|
|
image.setAttribute("x", "0");
|
|
image.setAttribute("y", "0");
|
|
const pattern = context.svgDocument.createElementNS(svgNamespace, "pattern");
|
|
pattern.setAttribute("patternUnits", "userSpaceOnUse");
|
|
pattern.setAttribute("patternContentUnits", "userSpaceOnUse");
|
|
pattern.setAttribute("x", (bounds.x + backgroundPositionX).toString());
|
|
pattern.setAttribute("y", (bounds.y + backgroundPositionY).toString());
|
|
pattern.setAttribute("width", (backgroundRepeat === "repeat" || backgroundRepeat === "repeat-x" ? backgroundWidth : (
|
|
// If background shouldn't repeat on this axis, make the tile as big as the element so the repetition is cut off.
|
|
backgroundWidth + bounds.x + backgroundPositionX
|
|
)).toString());
|
|
pattern.setAttribute("height", (backgroundRepeat === "repeat" || backgroundRepeat === "repeat-y" ? backgroundHeight : (
|
|
// If background shouldn't repeat on this axis, make the tile as big as the element so the repetition is cut off.
|
|
backgroundHeight + bounds.y + backgroundPositionY
|
|
)).toString());
|
|
pattern.id = context.getUniqueId("pattern");
|
|
pattern.append(image);
|
|
box.before(pattern);
|
|
box.setAttribute("fill", `url(#${pattern.id})`);
|
|
}
|
|
} else if (/^(-webkit-)?linear-gradient$/.test(backgroundNode.value)) {
|
|
const linearGradientCss = import_postcss_value_parser2.default.stringify(backgroundNode);
|
|
const svgLinearGradient = convertLinearGradient(linearGradientCss, context);
|
|
if (backgroundPositionX !== 0 || backgroundPositionY !== 0) {
|
|
svgLinearGradient.setAttribute("gradientTransform", `translate(${backgroundPositionX}, ${backgroundPositionY})`);
|
|
}
|
|
svgLinearGradient.id = context.getUniqueId("linear-gradient");
|
|
box.before(svgLinearGradient);
|
|
box.setAttribute("fill", `url(#${svgLinearGradient.id})`);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!hasUniformBorder(styles)) {
|
|
for (const borderLine of createBorders(styles, bounds, context)) {
|
|
backgroundAndBordersContainer.append(borderLine);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function createBox(bounds, context) {
|
|
const box = context.svgDocument.createElementNS(svgNamespace, "rect");
|
|
box.setAttribute("width", bounds.width.toString());
|
|
box.setAttribute("height", bounds.height.toString());
|
|
box.setAttribute("x", bounds.x.toString());
|
|
box.setAttribute("y", bounds.y.toString());
|
|
return box;
|
|
}
|
|
function createBackgroundAndBorderBox(bounds, styles, context) {
|
|
const background = createBox(bounds, context);
|
|
if (styles.backgroundColor) {
|
|
background.setAttribute("fill", styles.backgroundColor);
|
|
}
|
|
if (hasUniformBorder(styles)) {
|
|
background.setAttribute("stroke", styles.borderTopColor);
|
|
background.setAttribute("stroke-width", styles.borderTopWidth);
|
|
if (styles.borderTopStyle === "dashed") {
|
|
background.setAttribute("stroke-dasharray", "1");
|
|
}
|
|
}
|
|
const overlappingCurvesFactor = calculateOverlappingCurvesFactor(styles, bounds);
|
|
const radiusX = getBorderRadiiForSide("top", styles, bounds)[0] * overlappingCurvesFactor;
|
|
const radiusY = getBorderRadiiForSide("left", styles, bounds)[0] * overlappingCurvesFactor;
|
|
if (radiusX !== 0) {
|
|
background.setAttribute("rx", radiusX.toString());
|
|
}
|
|
if (radiusY !== 0) {
|
|
background.setAttribute("ry", radiusY.toString());
|
|
}
|
|
return background;
|
|
}
|
|
function* createBorders(styles, bounds, context) {
|
|
for (const side of ["top", "bottom", "right", "left"]) {
|
|
if (hasBorder(styles, side)) {
|
|
yield createBorder(styles, bounds, side, context);
|
|
}
|
|
}
|
|
}
|
|
function hasBorder(styles, side) {
|
|
return !!styles.getPropertyValue(`border-${side}-color`) && !isTransparent(styles.getPropertyValue(`border-${side}-color`)) && styles.getPropertyValue(`border-${side}-width`) !== "0px";
|
|
}
|
|
function createBorder(styles, bounds, side, context) {
|
|
const border = context.svgDocument.createElementNS(svgNamespace, "line");
|
|
border.setAttribute("stroke-linecap", "square");
|
|
const color = styles.getPropertyValue(`border-${side}-color`);
|
|
border.setAttribute("stroke", color);
|
|
border.setAttribute("stroke-width", styles.getPropertyValue(`border-${side}-width`));
|
|
const borderStyle = styles.getPropertyValue(`border-${side}-style`);
|
|
if (borderStyle === "inset" && (side === "top" || side === "left") || borderStyle === "outset" && (side === "right" || side === "bottom")) {
|
|
const match = color.match(/rgba?\((\d+), (\d+), (\d+)(?:, ([\d.]+))?\)/);
|
|
if (!match) {
|
|
throw new Error(`Unexpected color: ${color}`);
|
|
}
|
|
const components = match.slice(1, 4).map((value) => parseInt(value, 10) * 0.3);
|
|
if (match[4]) {
|
|
components.push(parseFloat(match[4]));
|
|
}
|
|
border.setAttribute("stroke", `rgba(${components.join(", ")})`);
|
|
}
|
|
if (side === "top") {
|
|
border.setAttribute("x1", bounds.left.toString());
|
|
border.setAttribute("x2", bounds.right.toString());
|
|
border.setAttribute("y1", bounds.top.toString());
|
|
border.setAttribute("y2", bounds.top.toString());
|
|
} else if (side === "left") {
|
|
border.setAttribute("x1", bounds.left.toString());
|
|
border.setAttribute("x2", bounds.left.toString());
|
|
border.setAttribute("y1", bounds.top.toString());
|
|
border.setAttribute("y2", bounds.bottom.toString());
|
|
} else if (side === "right") {
|
|
border.setAttribute("x1", bounds.right.toString());
|
|
border.setAttribute("x2", bounds.right.toString());
|
|
border.setAttribute("y1", bounds.top.toString());
|
|
border.setAttribute("y2", bounds.bottom.toString());
|
|
} else if (side === "bottom") {
|
|
border.setAttribute("x1", bounds.left.toString());
|
|
border.setAttribute("x2", bounds.right.toString());
|
|
border.setAttribute("y1", bounds.bottom.toString());
|
|
border.setAttribute("y2", bounds.bottom.toString());
|
|
}
|
|
return border;
|
|
}
|
|
function createSvgAnchor(element, context) {
|
|
const svgAnchor = context.svgDocument.createElementNS(svgNamespace, "a");
|
|
if (element.href && !element.href.startsWith("javascript:")) {
|
|
svgAnchor.setAttribute("href", element.href);
|
|
}
|
|
if (element.rel) {
|
|
svgAnchor.setAttribute("rel", element.rel);
|
|
}
|
|
if (element.target) {
|
|
svgAnchor.setAttribute("target", element.target);
|
|
}
|
|
if (element.download) {
|
|
svgAnchor.setAttribute("download", element.download);
|
|
}
|
|
return svgAnchor;
|
|
}
|
|
|
|
// node_modules/dom-to-svg/lib/traversal.js
|
|
function walkNode(node, context) {
|
|
if (isElement(node)) {
|
|
handleElement(node, context);
|
|
} else if (isTextNode(node)) {
|
|
handleTextNode(node, context);
|
|
}
|
|
}
|
|
|
|
// node_modules/dom-to-svg/lib/inline.js
|
|
var import_postcss_value_parser3 = __toESM(require_lib(), 1);
|
|
async function inlineResources(element) {
|
|
await Promise.all([
|
|
...[...element.children].map(inlineResources),
|
|
(async () => {
|
|
var _a;
|
|
if (isSVGImageElement(element)) {
|
|
const blob = await withTimeout(1e4, `Timeout fetching ${element.href.baseVal}`, () => fetchResource(element.href.baseVal));
|
|
if (blob.type === "image/svg+xml") {
|
|
assert(element.ownerDocument, "Expected <image> element to have ownerDocument");
|
|
const embeddedSvgDocument = new DOMParser().parseFromString(await blob.text(), "image/svg+xml");
|
|
const svgRoot = embeddedSvgDocument.documentElement;
|
|
svgRoot.setAttribute("x", element.getAttribute("x"));
|
|
svgRoot.setAttribute("y", element.getAttribute("y"));
|
|
svgRoot.setAttribute("width", element.getAttribute("width"));
|
|
svgRoot.setAttribute("height", element.getAttribute("height"));
|
|
svgRoot.remove();
|
|
element.replaceWith(svgRoot);
|
|
try {
|
|
const svgDocument = element.ownerDocument;
|
|
const mount = svgDocument.createElementNS(svgNamespace, "g");
|
|
assert(element.id, "<image> element must have ID");
|
|
handleSvgNode(svgRoot, {
|
|
currentSvgParent: mount,
|
|
svgDocument,
|
|
idPrefix: `${element.id}-`,
|
|
options: {
|
|
// SVGs embedded through <img> are never interactive.
|
|
keepLinks: false,
|
|
captureArea: svgRoot.viewBox.baseVal
|
|
}
|
|
});
|
|
mount.dataset.tag = "img";
|
|
mount.setAttribute("role", "img");
|
|
svgRoot.replaceWith(mount);
|
|
} finally {
|
|
svgRoot.remove();
|
|
}
|
|
} else {
|
|
const dataUrl = await blobToDataURL(blob);
|
|
element.dataset.src = element.href.baseVal;
|
|
element.setAttribute("xlink:href", dataUrl.href);
|
|
}
|
|
} else if (isSVGStyleElement(element)) {
|
|
try {
|
|
const promises = [];
|
|
const parsedSheet = parse((_a = element.textContent) !== null && _a !== void 0 ? _a : "");
|
|
parsedSheet.walkAtRules("font-face", (fontFaceRule) => {
|
|
fontFaceRule.walkDecls("src", (sourceDeclaration) => {
|
|
const parsedSourceValue = (0, import_postcss_value_parser3.default)(sourceDeclaration.value);
|
|
parsedSourceValue.walk((node) => {
|
|
if (node.type === "function" && node.value === "url" && node.nodes[0]) {
|
|
const urlArgumentNode = node.nodes[0];
|
|
if (urlArgumentNode.type === "string" || urlArgumentNode.type === "word") {
|
|
promises.push(inlineCssFontUrlArgumentNode(urlArgumentNode));
|
|
}
|
|
}
|
|
});
|
|
sourceDeclaration.value = import_postcss_value_parser3.default.stringify(parsedSourceValue.nodes);
|
|
});
|
|
});
|
|
await Promise.all(promises);
|
|
element.textContent = parsedSheet.toString();
|
|
} catch (error) {
|
|
console.error("Error inlining stylesheet", element.sheet, error);
|
|
}
|
|
}
|
|
})().catch((error) => {
|
|
console.error("Error inlining resource for element", element, error);
|
|
})
|
|
]);
|
|
}
|
|
async function inlineCssFontUrlArgumentNode(urlArgumentNode) {
|
|
try {
|
|
const url = new URL(unescapeStringValue(urlArgumentNode.value));
|
|
const blob = await withTimeout(1e4, `Timeout fetching ${url.href}`, () => fetchResource(url.href));
|
|
if (!blob.type.startsWith("font/") && !blob.type.startsWith("application/font-") && !blob.type.startsWith("application/x-font-") && !blob.type.startsWith("image/svg+xml") && !blob.type.startsWith("application/vnd.ms-fontobject")) {
|
|
throw new Error(`Invalid response MIME type inlining font at ${url.href}: Expected font MIME type, got ${blob.type}`);
|
|
}
|
|
const dataUrl = await blobToDataURL(blob);
|
|
urlArgumentNode.value = dataUrl.href;
|
|
} catch (error) {
|
|
console.error(`Error inlining ${urlArgumentNode.value}`, error);
|
|
}
|
|
}
|
|
async function fetchResource(url) {
|
|
assert(url, "No URL passed");
|
|
const headers = new Headers();
|
|
const response = await fetch(url, { headers });
|
|
if (!response.ok) {
|
|
throw new Error(response.statusText);
|
|
}
|
|
const blob = await response.blob();
|
|
return blob;
|
|
}
|
|
async function blobToDataURL(blob) {
|
|
const reader = new FileReader();
|
|
await new Promise((resolve, reject) => {
|
|
reader.addEventListener("error", () => reject(new Error("Error loading resource with FileLoader")));
|
|
reader.addEventListener("load", () => resolve());
|
|
reader.readAsDataURL(blob);
|
|
});
|
|
return new URL(reader.result);
|
|
}
|
|
|
|
// node_modules/dom-to-svg/lib/index.js
|
|
function documentToSVG(document2, options) {
|
|
return elementToSVG(document2.documentElement, options);
|
|
}
|
|
function elementToSVG(element, options) {
|
|
var _a, _b, _c, _d;
|
|
const svgDocument = element.ownerDocument.implementation.createDocument(svgNamespace, "svg", null);
|
|
const svgElement = svgDocument.documentElement;
|
|
svgElement.setAttribute("xmlns", svgNamespace);
|
|
svgElement.setAttribute("xmlns:xlink", xlinkNamespace);
|
|
svgElement.append(svgDocument.createComment(
|
|
// "--" is invalid in comments, percent-encode.
|
|
` Generated by dom-to-svg from ${element.ownerDocument.location.href.replace(/--/g, "%2D%2D")} `
|
|
));
|
|
const styleElement = svgDocument.createElementNS(svgNamespace, "style");
|
|
for (const styleSheet of element.ownerDocument.styleSheets) {
|
|
try {
|
|
for (const rule2 of (_a = styleSheet.rules) !== null && _a !== void 0 ? _a : []) {
|
|
if (!isCSSFontFaceRule(rule2)) {
|
|
continue;
|
|
}
|
|
const styleSheetHref = (_b = rule2.parentStyleSheet) === null || _b === void 0 ? void 0 : _b.href;
|
|
if (styleSheetHref) {
|
|
const parsedSourceValue = (0, import_postcss_value_parser4.default)(rule2.style.getPropertyValue("src"));
|
|
parsedSourceValue.walk((node) => {
|
|
if (node.type === "function" && node.value === "url" && node.nodes[0]) {
|
|
const urlArgumentNode = node.nodes[0];
|
|
if (urlArgumentNode.type === "string" || urlArgumentNode.type === "word") {
|
|
urlArgumentNode.value = new URL(unescapeStringValue(urlArgumentNode.value), styleSheetHref).href;
|
|
}
|
|
}
|
|
});
|
|
const updatedFontFaceRule = parse(rule2.cssText);
|
|
updatedFontFaceRule.walkDecls("src", (declaration) => {
|
|
declaration.value = import_postcss_value_parser4.default.stringify(parsedSourceValue.nodes);
|
|
});
|
|
styleElement.append(updatedFontFaceRule.toString() + "\n");
|
|
}
|
|
}
|
|
} catch (error) {
|
|
console.error("Error resolving @font-face src URLs for styleSheet, skipping", styleSheet, error);
|
|
}
|
|
}
|
|
svgElement.append(styleElement);
|
|
walkNode(element, {
|
|
svgDocument,
|
|
currentSvgParent: svgElement,
|
|
stackingLayers: createStackingLayers(svgElement),
|
|
parentStackingLayer: svgElement,
|
|
getUniqueId: createIdGenerator(),
|
|
labels: /* @__PURE__ */ new Map(),
|
|
ancestorMasks: [],
|
|
options: {
|
|
captureArea: (_c = options === null || options === void 0 ? void 0 : options.captureArea) !== null && _c !== void 0 ? _c : element.getBoundingClientRect(),
|
|
keepLinks: (options === null || options === void 0 ? void 0 : options.keepLinks) !== false
|
|
}
|
|
});
|
|
const bounds = (_d = options === null || options === void 0 ? void 0 : options.captureArea) !== null && _d !== void 0 ? _d : element.getBoundingClientRect();
|
|
svgElement.setAttribute("width", bounds.width.toString());
|
|
svgElement.setAttribute("height", bounds.height.toString());
|
|
svgElement.setAttribute("viewBox", `${bounds.x} ${bounds.y} ${bounds.width} ${bounds.height}`);
|
|
return svgDocument;
|
|
}
|
|
|
|
// .bundle_entry.js
|
|
window.__domToSvg = { documentToSVG, elementToSVG, inlineResources };
|
|
})();
|