mystmd 1.3.11__py3-none-any.whl → 1.3.12__py3-none-any.whl

mystmd_py/myst.cjs

@@ -42959,47 +42959,71 @@ var require_parse_srcset = __commonJS({
 // ../../node_modules/picocolors/picocolors.js
 var require_picocolors = __commonJS({
   "../../node_modules/picocolors/picocolors.js"(exports2, module2) {
-    var tty7 = require("tty");
-    var isColorSupported = !("NO_COLOR" in process.env || process.argv.includes("--no-color")) && ("FORCE_COLOR" in process.env || process.argv.includes("--color") || process.platform === "win32" || tty7.isatty(1) && process.env.TERM !== "dumb" || "CI" in process.env);
+    var argv = process.argv || [];
+    var env7 = process.env;
+    var isColorSupported = !("NO_COLOR" in env7 || argv.includes("--no-color")) && ("FORCE_COLOR" in env7 || argv.includes("--color") || process.platform === "win32" || require != null && require("tty").isatty(1) && env7.TERM !== "dumb" || "CI" in env7);
     var formatter = (open2, close2, replace = open2) => (input3) => {
       let string2 = "" + input3;
       let index4 = string2.indexOf(close2, open2.length);
       return ~index4 ? open2 + replaceClose(string2, close2, replace, index4) + close2 : open2 + string2 + close2;
     };
     var replaceClose = (string2, close2, replace, index4) => {
-      let start = string2.substring(0, index4) + replace;
-      let end = string2.substring(index4 + close2.length);
-      let nextIndex = end.indexOf(close2);
-      return ~nextIndex ? start + replaceClose(end, close2, replace, nextIndex) : start + end;
-    };
-    var createColors = (enabled = isColorSupported) => ({
-      isColorSupported: enabled,
-      reset: enabled ? (s5) => `\x1B[0m${s5}\x1B[0m` : String,
-      bold: enabled ? formatter("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m") : String,
-      dim: enabled ? formatter("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m") : String,
-      italic: enabled ? formatter("\x1B[3m", "\x1B[23m") : String,
-      underline: enabled ? formatter("\x1B[4m", "\x1B[24m") : String,
-      inverse: enabled ? formatter("\x1B[7m", "\x1B[27m") : String,
-      hidden: enabled ? formatter("\x1B[8m", "\x1B[28m") : String,
-      strikethrough: enabled ? formatter("\x1B[9m", "\x1B[29m") : String,
-      black: enabled ? formatter("\x1B[30m", "\x1B[39m") : String,
-      red: enabled ? formatter("\x1B[31m", "\x1B[39m") : String,
-      green: enabled ? formatter("\x1B[32m", "\x1B[39m") : String,
-      yellow: enabled ? formatter("\x1B[33m", "\x1B[39m") : String,
-      blue: enabled ? formatter("\x1B[34m", "\x1B[39m") : String,
-      magenta: enabled ? formatter("\x1B[35m", "\x1B[39m") : String,
-      cyan: enabled ? formatter("\x1B[36m", "\x1B[39m") : String,
-      white: enabled ? formatter("\x1B[37m", "\x1B[39m") : String,
-      gray: enabled ? formatter("\x1B[90m", "\x1B[39m") : String,
-      bgBlack: enabled ? formatter("\x1B[40m", "\x1B[49m") : String,
-      bgRed: enabled ? formatter("\x1B[41m", "\x1B[49m") : String,
-      bgGreen: enabled ? formatter("\x1B[42m", "\x1B[49m") : String,
-      bgYellow: enabled ? formatter("\x1B[43m", "\x1B[49m") : String,
-      bgBlue: enabled ? formatter("\x1B[44m", "\x1B[49m") : String,
-      bgMagenta: enabled ? formatter("\x1B[45m", "\x1B[49m") : String,
-      bgCyan: enabled ? formatter("\x1B[46m", "\x1B[49m") : String,
-      bgWhite: enabled ? formatter("\x1B[47m", "\x1B[49m") : String
-    });
+      let result = "";
+      let cursor = 0;
+      do {
+        result += string2.substring(cursor, index4) + replace;
+        cursor = index4 + close2.length;
+        index4 = string2.indexOf(close2, cursor);
+      } while (~index4);
+      return result + string2.substring(cursor);
+    };
+    var createColors = (enabled = isColorSupported) => {
+      let init4 = enabled ? formatter : () => String;
+      return {
+        isColorSupported: enabled,
+        reset: init4("\x1B[0m", "\x1B[0m"),
+        bold: init4("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+        dim: init4("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+        italic: init4("\x1B[3m", "\x1B[23m"),
+        underline: init4("\x1B[4m", "\x1B[24m"),
+        inverse: init4("\x1B[7m", "\x1B[27m"),
+        hidden: init4("\x1B[8m", "\x1B[28m"),
+        strikethrough: init4("\x1B[9m", "\x1B[29m"),
+        black: init4("\x1B[30m", "\x1B[39m"),
+        red: init4("\x1B[31m", "\x1B[39m"),
+        green: init4("\x1B[32m", "\x1B[39m"),
+        yellow: init4("\x1B[33m", "\x1B[39m"),
+        blue: init4("\x1B[34m", "\x1B[39m"),
+        magenta: init4("\x1B[35m", "\x1B[39m"),
+        cyan: init4("\x1B[36m", "\x1B[39m"),
+        white: init4("\x1B[37m", "\x1B[39m"),
+        gray: init4("\x1B[90m", "\x1B[39m"),
+        bgBlack: init4("\x1B[40m", "\x1B[49m"),
+        bgRed: init4("\x1B[41m", "\x1B[49m"),
+        bgGreen: init4("\x1B[42m", "\x1B[49m"),
+        bgYellow: init4("\x1B[43m", "\x1B[49m"),
+        bgBlue: init4("\x1B[44m", "\x1B[49m"),
+        bgMagenta: init4("\x1B[45m", "\x1B[49m"),
+        bgCyan: init4("\x1B[46m", "\x1B[49m"),
+        bgWhite: init4("\x1B[47m", "\x1B[49m"),
+        blackBright: init4("\x1B[90m", "\x1B[39m"),
+        redBright: init4("\x1B[91m", "\x1B[39m"),
+        greenBright: init4("\x1B[92m", "\x1B[39m"),
+        yellowBright: init4("\x1B[93m", "\x1B[39m"),
+        blueBright: init4("\x1B[94m", "\x1B[39m"),
+        magentaBright: init4("\x1B[95m", "\x1B[39m"),
+        cyanBright: init4("\x1B[96m", "\x1B[39m"),
+        whiteBright: init4("\x1B[97m", "\x1B[39m"),
+        bgBlackBright: init4("\x1B[100m", "\x1B[49m"),
+        bgRedBright: init4("\x1B[101m", "\x1B[49m"),
+        bgGreenBright: init4("\x1B[102m", "\x1B[49m"),
+        bgYellowBright: init4("\x1B[103m", "\x1B[49m"),
+        bgBlueBright: init4("\x1B[104m", "\x1B[49m"),
+        bgMagentaBright: init4("\x1B[105m", "\x1B[49m"),
+        bgCyanBright: init4("\x1B[106m", "\x1B[49m"),
+        bgWhiteBright: init4("\x1B[107m", "\x1B[49m")
+      };
+    };
     module2.exports = createColors();
     module2.exports.createColors = createColors;
   }
@@ -43035,8 +43059,8 @@ var require_tokenize = __commonJS({
     module2.exports = function tokenizer(input3, options = {}) {
       let css = input3.css.valueOf();
       let ignore3 = options.ignoreErrors;
-      let code7, next, quote, content3, escape5;
-      let escaped, escapePos, prev, n, currentToken;
+      let code7, content3, escape5, next, quote;
+      let currentToken, escaped, escapePos, n, prev;
       let length = css.length;
       let pos = 0;
       let buffer2 = [];
@@ -43335,30 +43359,40 @@ var require_css_syntax_error = __commonJS({
         let css = this.source;
         if (color2 == null)
           color2 = pico.isColorSupported;
-        if (terminalHighlight) {
-          if (color2)
-            css = terminalHighlight(css);
-        }
-        let lines = css.split(/\r?\n/);
-        let start = Math.max(this.line - 3, 0);
-        let end = Math.min(this.line + 2, lines.length);
-        let maxWidth = String(end).length;
-        let mark2, aside;
+        let aside = (text7) => text7;
+        let mark2 = (text7) => text7;
+        let highlight = (text7) => text7;
         if (color2) {
           let { bold, gray, red } = pico.createColors(true);
           mark2 = (text7) => bold(red(text7));
           aside = (text7) => gray(text7);
-        } else {
-          mark2 = aside = (str2) => str2;
+          if (terminalHighlight) {
+            highlight = (text7) => terminalHighlight(text7);
+          }
         }
+        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((line2, index4) => {
           let number2 = start + 1 + index4;
           let gutter = " " + (" " + number2).slice(-maxWidth) + " | ";
           if (number2 === this.line) {
+            if (line2.length > 160) {
+              let padding2 = 20;
+              let subLineStart = Math.max(0, this.column - padding2);
+              let subLineEnd = Math.max(
+                this.column + padding2,
+                this.endColumn + padding2
+              );
+              let subLine = line2.slice(subLineStart, subLineEnd);
+              let spacing3 = aside(gutter.replace(/\d/g, " ")) + line2.slice(0, Math.min(this.column - 1, padding2 - 1)).replace(/[^\t]/g, " ");
+              return mark2(">") + aside(gutter) + highlight(subLine) + "\n " + spacing3 + mark2("^");
+            }
             let spacing2 = aside(gutter.replace(/\d/g, " ")) + line2.slice(0, this.column - 1).replace(/[^\t]/g, " ");
-            return mark2(">") + aside(gutter) + line2 + "\n " + spacing2 + mark2("^");
+            return mark2(">") + aside(gutter) + highlight(line2) + "\n " + spacing2 + mark2("^");
           }
-          return " " + aside(gutter) + line2;
+          return " " + aside(gutter) + highlight(line2);
         }).join("\n");
       }
       toString() {
@@ -43374,15 +43408,6 @@ var require_css_syntax_error = __commonJS({
   }
 });
 
-// ../../node_modules/postcss/lib/symbols.js
-var require_symbols = __commonJS({
-  "../../node_modules/postcss/lib/symbols.js"(exports2, module2) {
-    "use strict";
-    module2.exports.isClean = Symbol("isClean");
-    module2.exports.my = Symbol("my");
-  }
-});
-
 // ../../node_modules/postcss/lib/stringifier.js
 var require_stringifier = __commonJS({
   "../../node_modules/postcss/lib/stringifier.js"(exports2, module2) {
@@ -43719,14 +43744,23 @@ var require_stringify2 = __commonJS({
   }
 });
 
+// ../../node_modules/postcss/lib/symbols.js
+var require_symbols = __commonJS({
+  "../../node_modules/postcss/lib/symbols.js"(exports2, module2) {
+    "use strict";
+    module2.exports.isClean = Symbol("isClean");
+    module2.exports.my = Symbol("my");
+  }
+});
+
 // ../../node_modules/postcss/lib/node.js
 var require_node2 = __commonJS({
   "../../node_modules/postcss/lib/node.js"(exports2, module2) {
     "use strict";
-    var { isClean, my } = require_symbols();
     var CssSyntaxError = require_css_syntax_error();
     var Stringifier = require_stringifier();
     var stringify4 = require_stringify2();
+    var { isClean, my } = require_symbols();
     function cloneNode(obj, parent2) {
       let cloned = new obj.constructor();
       for (let i2 in obj) {
@@ -43855,6 +43889,10 @@ var require_node2 = __commonJS({
           }
         };
       }
+      /* c8 ignore next 3 */
+      markClean() {
+        this[isClean] = true;
+      }
       markDirty() {
         if (this[isClean]) {
           this[isClean] = false;
@@ -43919,7 +43957,10 @@ var require_node2 = __commonJS({
           let index4 = stringRepresentation.indexOf(opts.word);
           if (index4 !== -1) {
             start = this.positionInside(index4, stringRepresentation);
-            end = this.positionInside(index4 + opts.word.length, stringRepresentation);
+            end = this.positionInside(
+              index4 + opts.word.length,
+              stringRepresentation
+            );
           }
         } else {
           if (opts.start) {
@@ -44057,6 +44098,22 @@ var require_node2 = __commonJS({
   }
 });
 
+// ../../node_modules/postcss/lib/comment.js
+var require_comment = __commonJS({
+  "../../node_modules/postcss/lib/comment.js"(exports2, module2) {
+    "use strict";
+    var Node = require_node2();
+    var Comment = class extends Node {
+      constructor(defaults4) {
+        super(defaults4);
+        this.type = "comment";
+      }
+    };
+    module2.exports = Comment;
+    Comment.default = Comment;
+  }
+});
+
 // ../../node_modules/postcss/lib/declaration.js
 var require_declaration = __commonJS({
   "../../node_modules/postcss/lib/declaration.js"(exports2, module2) {
@@ -44079,6 +44136,498 @@ var require_declaration = __commonJS({
   }
 });
 
+// ../../node_modules/postcss/lib/container.js
+var require_container = __commonJS({
+  "../../node_modules/postcss/lib/container.js"(exports2, module2) {
+    "use strict";
+    var Comment = require_comment();
+    var Declaration = require_declaration();
+    var Node = require_node2();
+    var { isClean, my } = require_symbols();
+    var AtRule;
+    var parse16;
+    var Root;
+    var Rule;
+    function cleanSource(nodes) {
+      return nodes.map((i2) => {
+        if (i2.nodes)
+          i2.nodes = cleanSource(i2.nodes);
+        delete i2.source;
+        return i2;
+      });
+    }
+    function markTreeDirty(node3) {
+      node3[isClean] = false;
+      if (node3.proxyOf.nodes) {
+        for (let i2 of node3.proxyOf.nodes) {
+          markTreeDirty(i2);
+        }
+      }
+    }
+    var Container = class extends Node {
+      append(...children) {
+        for (let child of children) {
+          let nodes = this.normalize(child, this.last);
+          for (let node3 of nodes)
+            this.proxyOf.nodes.push(node3);
+        }
+        this.markDirty();
+        return this;
+      }
+      cleanRaws(keepBetween) {
+        super.cleanRaws(keepBetween);
+        if (this.nodes) {
+          for (let node3 of this.nodes)
+            node3.cleanRaws(keepBetween);
+        }
+      }
+      each(callback) {
+        if (!this.proxyOf.nodes)
+          return void 0;
+        let iterator = this.getIterator();
+        let index4, result;
+        while (this.indexes[iterator] < this.proxyOf.nodes.length) {
+          index4 = this.indexes[iterator];
+          result = callback(this.proxyOf.nodes[index4], index4);
+          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(node3, prop) {
+            if (prop === "proxyOf") {
+              return node3;
+            } else if (!node3[prop]) {
+              return node3[prop];
+            } else if (prop === "each" || typeof prop === "string" && prop.startsWith("walk")) {
+              return (...args) => {
+                return node3[prop](
+                  ...args.map((i2) => {
+                    if (typeof i2 === "function") {
+                      return (child, index4) => i2(child.toProxy(), index4);
+                    } else {
+                      return i2;
+                    }
+                  })
+                );
+              };
+            } else if (prop === "every" || prop === "some") {
+              return (cb) => {
+                return node3[prop](
+                  (child, ...other) => cb(child.toProxy(), ...other)
+                );
+              };
+            } else if (prop === "root") {
+              return () => node3.root().toProxy();
+            } else if (prop === "nodes") {
+              return node3.nodes.map((i2) => i2.toProxy());
+            } else if (prop === "first" || prop === "last") {
+              return node3[prop].toProxy();
+            } else {
+              return node3[prop];
+            }
+          },
+          set(node3, prop, value) {
+            if (node3[prop] === value)
+              return true;
+            node3[prop] = value;
+            if (prop === "name" || prop === "params" || prop === "selector") {
+              node3.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, add2) {
+        let existIndex = this.index(exist);
+        let nodes = this.normalize(add2, this.proxyOf.nodes[existIndex]).reverse();
+        existIndex = this.index(exist);
+        for (let node3 of nodes)
+          this.proxyOf.nodes.splice(existIndex + 1, 0, node3);
+        let index4;
+        for (let id in this.indexes) {
+          index4 = this.indexes[id];
+          if (existIndex < index4) {
+            this.indexes[id] = index4 + nodes.length;
+          }
+        }
+        this.markDirty();
+        return this;
+      }
+      insertBefore(exist, add2) {
+        let existIndex = this.index(exist);
+        let type2 = existIndex === 0 ? "prepend" : false;
+        let nodes = this.normalize(
+          add2,
+          this.proxyOf.nodes[existIndex],
+          type2
+        ).reverse();
+        existIndex = this.index(exist);
+        for (let node3 of nodes)
+          this.proxyOf.nodes.splice(existIndex, 0, node3);
+        let index4;
+        for (let id in this.indexes) {
+          index4 = this.indexes[id];
+          if (existIndex <= index4) {
+            this.indexes[id] = index4 + nodes.length;
+          }
+        }
+        this.markDirty();
+        return this;
+      }
+      normalize(nodes, sample2) {
+        if (typeof nodes === "string") {
+          nodes = cleanSource(parse16(nodes).nodes);
+        } else if (typeof nodes === "undefined") {
+          nodes = [];
+        } else if (Array.isArray(nodes)) {
+          nodes = nodes.slice(0);
+          for (let i2 of nodes) {
+            if (i2.parent)
+              i2.parent.removeChild(i2, "ignore");
+          }
+        } else if (nodes.type === "root" && this.type !== "document") {
+          nodes = nodes.nodes.slice(0);
+          for (let i2 of nodes) {
+            if (i2.parent)
+              i2.parent.removeChild(i2, "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 Declaration(nodes)];
+        } else if (nodes.selector || nodes.selectors) {
+          nodes = [new Rule(nodes)];
+        } else if (nodes.name) {
+          nodes = [new AtRule(nodes)];
+        } else if (nodes.text) {
+          nodes = [new Comment(nodes)];
+        } else {
+          throw new Error("Unknown node type in node creation");
+        }
+        let processed = nodes.map((i2) => {
+          if (!i2[my])
+            Container.rebuild(i2);
+          i2 = i2.proxyOf;
+          if (i2.parent)
+            i2.parent.removeChild(i2);
+          if (i2[isClean])
+            markTreeDirty(i2);
+          if (!i2.raws)
+            i2.raws = {};
+          if (typeof i2.raws.before === "undefined") {
+            if (sample2 && typeof sample2.raws.before !== "undefined") {
+              i2.raws.before = sample2.raws.before.replace(/\S/g, "");
+            }
+          }
+          i2.parent = this.proxyOf;
+          return i2;
+        });
+        return processed;
+      }
+      prepend(...children) {
+        children = children.reverse();
+        for (let child of children) {
+          let nodes = this.normalize(child, this.first, "prepend").reverse();
+          for (let node3 of nodes)
+            this.proxyOf.nodes.unshift(node3);
+          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 node3 of this.proxyOf.nodes)
+          node3.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 index4;
+        for (let id in this.indexes) {
+          index4 = this.indexes[id];
+          if (index4 >= child) {
+            this.indexes[id] = index4 - 1;
+          }
+        }
+        this.markDirty();
+        return this;
+      }
+      replaceValues(pattern, opts, callback) {
+        if (!callback) {
+          callback = opts;
+          opts = {};
+        }
+        this.walkDecls((decl) => {
+          if (opts.props && !opts.props.includes(decl.prop))
+            return;
+          if (opts.fast && !decl.value.includes(opts.fast))
+            return;
+          decl.value = decl.value.replace(pattern, callback);
+        });
+        this.markDirty();
+        return this;
+      }
+      some(condition) {
+        return this.nodes.some(condition);
+      }
+      walk(callback) {
+        return this.each((child, i2) => {
+          let result;
+          try {
+            result = callback(child, i2);
+          } catch (e2) {
+            throw child.addToError(e2);
+          }
+          if (result !== false && child.walk) {
+            result = child.walk(callback);
+          }
+          return result;
+        });
+      }
+      walkAtRules(name3, callback) {
+        if (!callback) {
+          callback = name3;
+          return this.walk((child, i2) => {
+            if (child.type === "atrule") {
+              return callback(child, i2);
+            }
+          });
+        }
+        if (name3 instanceof RegExp) {
+          return this.walk((child, i2) => {
+            if (child.type === "atrule" && name3.test(child.name)) {
+              return callback(child, i2);
+            }
+          });
+        }
+        return this.walk((child, i2) => {
+          if (child.type === "atrule" && child.name === name3) {
+            return callback(child, i2);
+          }
+        });
+      }
+      walkComments(callback) {
+        return this.walk((child, i2) => {
+          if (child.type === "comment") {
+            return callback(child, i2);
+          }
+        });
+      }
+      walkDecls(prop, callback) {
+        if (!callback) {
+          callback = prop;
+          return this.walk((child, i2) => {
+            if (child.type === "decl") {
+              return callback(child, i2);
+            }
+          });
+        }
+        if (prop instanceof RegExp) {
+          return this.walk((child, i2) => {
+            if (child.type === "decl" && prop.test(child.prop)) {
+              return callback(child, i2);
+            }
+          });
+        }
+        return this.walk((child, i2) => {
+          if (child.type === "decl" && child.prop === prop) {
+            return callback(child, i2);
+          }
+        });
+      }
+      walkRules(selector, callback) {
+        if (!callback) {
+          callback = selector;
+          return this.walk((child, i2) => {
+            if (child.type === "rule") {
+              return callback(child, i2);
+            }
+          });
+        }
+        if (selector instanceof RegExp) {
+          return this.walk((child, i2) => {
+            if (child.type === "rule" && selector.test(child.selector)) {
+              return callback(child, i2);
+            }
+          });
+        }
+        return this.walk((child, i2) => {
+          if (child.type === "rule" && child.selector === selector) {
+            return callback(child, i2);
+          }
+        });
+      }
+      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];
+      }
+    };
+    Container.registerParse = (dependant) => {
+      parse16 = dependant;
+    };
+    Container.registerRule = (dependant) => {
+      Rule = dependant;
+    };
+    Container.registerAtRule = (dependant) => {
+      AtRule = dependant;
+    };
+    Container.registerRoot = (dependant) => {
+      Root = dependant;
+    };
+    module2.exports = Container;
+    Container.default = Container;
+    Container.rebuild = (node3) => {
+      if (node3.type === "atrule") {
+        Object.setPrototypeOf(node3, AtRule.prototype);
+      } else if (node3.type === "rule") {
+        Object.setPrototypeOf(node3, Rule.prototype);
+      } else if (node3.type === "decl") {
+        Object.setPrototypeOf(node3, Declaration.prototype);
+      } else if (node3.type === "comment") {
+        Object.setPrototypeOf(node3, Comment.prototype);
+      } else if (node3.type === "root") {
+        Object.setPrototypeOf(node3, Root.prototype);
+      }
+      node3[my] = true;
+      if (node3.nodes) {
+        node3.nodes.forEach((child) => {
+          Container.rebuild(child);
+        });
+      }
+    };
+  }
+});
+
+// ../../node_modules/postcss/lib/at-rule.js
+var require_at_rule = __commonJS({
+  "../../node_modules/postcss/lib/at-rule.js"(exports2, module2) {
+    "use strict";
+    var Container = require_container();
+    var AtRule = class extends Container {
+      constructor(defaults4) {
+        super(defaults4);
+        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);
+      }
+    };
+    module2.exports = AtRule;
+    AtRule.default = AtRule;
+    Container.registerAtRule(AtRule);
+  }
+});
+
+// ../../node_modules/postcss/lib/document.js
+var require_document = __commonJS({
+  "../../node_modules/postcss/lib/document.js"(exports2, module2) {
+    "use strict";
+    var Container = require_container();
+    var LazyResult;
+    var Processor2;
+    var Document2 = class extends Container {
+      constructor(defaults4) {
+        super({ type: "document", ...defaults4 });
+        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;
+    };
+    module2.exports = Document2;
+    Document2.default = Document2;
+  }
+});
+
+// ../../node_modules/postcss/node_modules/nanoid/non-secure/index.cjs
+var require_non_secure = __commonJS({
+  "../../node_modules/postcss/node_modules/nanoid/non-secure/index.cjs"(exports2, module2) {
+    var urlAlphabet3 = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+    var customAlphabet2 = (alphabet2, defaultSize = 21) => {
+      return (size = defaultSize) => {
+        let id = "";
+        let i2 = size;
+        while (i2--) {
+          id += alphabet2[Math.random() * alphabet2.length | 0];
+        }
+        return id;
+      };
+    };
+    var nanoid3 = (size = 21) => {
+      let id = "";
+      let i2 = size;
+      while (i2--) {
+        id += urlAlphabet3[Math.random() * 64 | 0];
+      }
+      return id;
+    };
+    module2.exports = { nanoid: nanoid3, customAlphabet: customAlphabet2 };
+  }
+});
+
 // ../../node_modules/source-map-js/lib/base64.js
 var require_base64 = __commonJS({
   "../../node_modules/source-map-js/lib/base64.js"(exports2) {
@@ -45135,7 +45684,9 @@ var require_source_map_consumer = __commonJS({
       for (var i2 = 0, n = mappings.length; i2 < n; i2++) {
         var mapping = mappings[i2];
         var source2 = mapping.source === null ? null : sources.at(mapping.source);
-        source2 = util4.computeSourceURL(sourceRoot, source2, sourceMapURL);
+        if (source2 !== null) {
+          source2 = util4.computeSourceURL(sourceRoot, source2, sourceMapURL);
+        }
         boundCallback({
           source: source2,
           generatedLine: mapping.generatedLine,
@@ -45674,7 +46225,9 @@ var require_source_map_consumer = __commonJS({
         for (var j = 0; j < sectionMappings.length; j++) {
           var mapping = sectionMappings[j];
           var source2 = section.consumer._sources.at(mapping.source);
-          source2 = util4.computeSourceURL(section.consumer.sourceRoot, source2, this._sourceMapURL);
+          if (source2 !== null) {
+            source2 = util4.computeSourceURL(section.consumer.sourceRoot, source2, this._sourceMapURL);
+          }
           this._sources.add(source2);
           source2 = this._sources.indexOf(source2);
           var name3 = null;
@@ -45979,39 +46532,13 @@ var require_source_map = __commonJS({
   }
 });
 
-// ../../node_modules/postcss/node_modules/nanoid/non-secure/index.cjs
-var require_non_secure = __commonJS({
-  "../../node_modules/postcss/node_modules/nanoid/non-secure/index.cjs"(exports2, module2) {
-    var urlAlphabet3 = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
-    var customAlphabet2 = (alphabet2, defaultSize = 21) => {
-      return (size = defaultSize) => {
-        let id = "";
-        let i2 = size;
-        while (i2--) {
-          id += alphabet2[Math.random() * alphabet2.length | 0];
-        }
-        return id;
-      };
-    };
-    var nanoid3 = (size = 21) => {
-      let id = "";
-      let i2 = size;
-      while (i2--) {
-        id += urlAlphabet3[Math.random() * 64 | 0];
-      }
-      return id;
-    };
-    module2.exports = { nanoid: nanoid3, customAlphabet: customAlphabet2 };
-  }
-});
-
 // ../../node_modules/postcss/lib/previous-map.js
 var require_previous_map = __commonJS({
   "../../node_modules/postcss/lib/previous-map.js"(exports2, module2) {
     "use strict";
-    var { SourceMapConsumer, SourceMapGenerator } = require_source_map();
     var { existsSync: existsSync2, readFileSync: readFileSync2 } = require("fs");
     var { dirname: dirname8, join: join20 } = require("path");
+    var { SourceMapConsumer, SourceMapGenerator } = require_source_map();
     function fromBase64(str2) {
       if (Buffer) {
         return Buffer.from(str2, "base64").toString();
@@ -46046,11 +46573,13 @@ var require_previous_map = __commonJS({
         let baseUri = /^data:application\/json;base64,/;
         let charsetUri = /^data:application\/json;charset=utf-?8,/;
         let uri = /^data:application\/json,/;
-        if (charsetUri.test(text7) || uri.test(text7)) {
-          return decodeURIComponent(text7.substr(RegExp.lastMatch.length));
+        let uriMatch = text7.match(charsetUri) || text7.match(uri);
+        if (uriMatch) {
+          return decodeURIComponent(text7.substr(uriMatch[0].length));
         }
-        if (baseCharsetUri.test(text7) || baseUri.test(text7)) {
-          return fromBase64(text7.substr(RegExp.lastMatch.length));
+        let baseUriMatch = text7.match(baseCharsetUri) || text7.match(baseUri);
+        if (baseUriMatch) {
+          return fromBase64(text7.substr(baseUriMatch[0].length));
         }
         let encoding = text7.match(/data:application\/json;([^,]+),/)[1];
         throw new Error("Unsupported source map encoding " + encoding);
@@ -46064,7 +46593,7 @@ var require_previous_map = __commonJS({
         return typeof map14.mappings === "string" || typeof map14._mappings === "string" || Array.isArray(map14.sections);
       }
       loadAnnotation(css) {
-        let comments = css.match(/\/\*\s*# sourceMappingURL=/gm);
+        let comments = css.match(/\/\*\s*# sourceMappingURL=/g);
         if (!comments)
           return;
         let start = css.lastIndexOf(comments.pop());
@@ -46135,13 +46664,13 @@ var require_previous_map = __commonJS({
 var require_input4 = __commonJS({
   "../../node_modules/postcss/lib/input.js"(exports2, module2) {
     "use strict";
+    var { nanoid: nanoid3 } = require_non_secure();
+    var { isAbsolute, resolve: resolve9 } = require("path");
     var { SourceMapConsumer, SourceMapGenerator } = require_source_map();
     var { fileURLToPath: fileURLToPath5, pathToFileURL } = require("url");
-    var { isAbsolute, resolve: resolve9 } = require("path");
-    var { nanoid: nanoid3 } = require_non_secure();
-    var terminalHighlight = require_terminal_highlight();
     var CssSyntaxError = require_css_syntax_error();
     var PreviousMap = require_previous_map();
+    var terminalHighlight = require_terminal_highlight();
     var fromOffsetCache = Symbol("fromOffsetCache");
     var sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator);
     var pathAvailable = Boolean(resolve9 && isAbsolute);
@@ -46180,7 +46709,7 @@ var require_input4 = __commonJS({
           this.map.file = this.from;
       }
       error(message, line2, column, opts = {}) {
-        let result, endLine, endColumn;
+        let endColumn, endLine, result;
         if (line2 && typeof line2 === "object") {
           let start = line2;
           let end = column;
@@ -46344,12 +46873,212 @@ var require_input4 = __commonJS({
   }
 });
 
+// ../../node_modules/postcss/lib/root.js
+var require_root = __commonJS({
+  "../../node_modules/postcss/lib/root.js"(exports2, module2) {
+    "use strict";
+    var Container = require_container();
+    var LazyResult;
+    var Processor2;
+    var Root = class extends Container {
+      constructor(defaults4) {
+        super(defaults4);
+        this.type = "root";
+        if (!this.nodes)
+          this.nodes = [];
+      }
+      normalize(child, sample2, type2) {
+        let nodes = super.normalize(child);
+        if (sample2) {
+          if (type2 === "prepend") {
+            if (this.nodes.length > 1) {
+              sample2.raws.before = this.nodes[1].raws.before;
+            } else {
+              delete sample2.raws.before;
+            }
+          } else if (this.first !== sample2) {
+            for (let node3 of nodes) {
+              node3.raws.before = sample2.raws.before;
+            }
+          }
+        }
+        return nodes;
+      }
+      removeChild(child, ignore3) {
+        let index4 = this.index(child);
+        if (!ignore3 && index4 === 0 && this.nodes.length > 1) {
+          this.nodes[1].raws.before = this.nodes[index4].raws.before;
+        }
+        return super.removeChild(child);
+      }
+      toResult(opts = {}) {
+        let lazy = new LazyResult(new Processor2(), this, opts);
+        return lazy.stringify();
+      }
+    };
+    Root.registerLazyResult = (dependant) => {
+      LazyResult = dependant;
+    };
+    Root.registerProcessor = (dependant) => {
+      Processor2 = dependant;
+    };
+    module2.exports = Root;
+    Root.default = Root;
+    Container.registerRoot(Root);
+  }
+});
+
+// ../../node_modules/postcss/lib/list.js
+var require_list = __commonJS({
+  "../../node_modules/postcss/lib/list.js"(exports2, module2) {
+    "use strict";
+    var list6 = {
+      comma(string2) {
+        return list6.split(string2, [","], true);
+      },
+      space(string2) {
+        let spaces = [" ", "\n", "	"];
+        return list6.split(string2, spaces);
+      },
+      split(string2, separators, last) {
+        let array = [];
+        let current2 = "";
+        let split2 = false;
+        let func = 0;
+        let inQuote = false;
+        let prevQuote = "";
+        let escape5 = false;
+        for (let letter of string2) {
+          if (escape5) {
+            escape5 = false;
+          } else if (letter === "\\") {
+            escape5 = 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))
+              split2 = true;
+          }
+          if (split2) {
+            if (current2 !== "")
+              array.push(current2.trim());
+            current2 = "";
+            split2 = false;
+          } else {
+            current2 += letter;
+          }
+        }
+        if (last || current2 !== "")
+          array.push(current2.trim());
+        return array;
+      }
+    };
+    module2.exports = list6;
+    list6.default = list6;
+  }
+});
+
+// ../../node_modules/postcss/lib/rule.js
+var require_rule = __commonJS({
+  "../../node_modules/postcss/lib/rule.js"(exports2, module2) {
+    "use strict";
+    var Container = require_container();
+    var list6 = require_list();
+    var Rule = class extends Container {
+      constructor(defaults4) {
+        super(defaults4);
+        this.type = "rule";
+        if (!this.nodes)
+          this.nodes = [];
+      }
+      get selectors() {
+        return list6.comma(this.selector);
+      }
+      set selectors(values) {
+        let match3 = this.selector ? this.selector.match(/,\s*/) : null;
+        let sep5 = match3 ? match3[0] : "," + this.raw("between", "beforeOpen");
+        this.selector = values.join(sep5);
+      }
+    };
+    module2.exports = Rule;
+    Rule.default = Rule;
+    Container.registerRule(Rule);
+  }
+});
+
+// ../../node_modules/postcss/lib/fromJSON.js
+var require_fromJSON = __commonJS({
+  "../../node_modules/postcss/lib/fromJSON.js"(exports2, module2) {
+    "use strict";
+    var AtRule = require_at_rule();
+    var Comment = require_comment();
+    var Declaration = require_declaration();
+    var Input = require_input4();
+    var PreviousMap = require_previous_map();
+    var Root = require_root();
+    var Rule = require_rule();
+    function fromJSON(json2, inputs) {
+      if (Array.isArray(json2))
+        return json2.map((n) => fromJSON(n));
+      let { inputs: ownInputs, ...defaults4 } = json2;
+      if (ownInputs) {
+        inputs = [];
+        for (let input3 of ownInputs) {
+          let inputHydrated = { ...input3, __proto__: Input.prototype };
+          if (inputHydrated.map) {
+            inputHydrated.map = {
+              ...inputHydrated.map,
+              __proto__: PreviousMap.prototype
+            };
+          }
+          inputs.push(inputHydrated);
+        }
+      }
+      if (defaults4.nodes) {
+        defaults4.nodes = json2.nodes.map((n) => fromJSON(n, inputs));
+      }
+      if (defaults4.source) {
+        let { inputId, ...source2 } = defaults4.source;
+        defaults4.source = source2;
+        if (inputId != null) {
+          defaults4.source.input = inputs[inputId];
+        }
+      }
+      if (defaults4.type === "root") {
+        return new Root(defaults4);
+      } else if (defaults4.type === "decl") {
+        return new Declaration(defaults4);
+      } else if (defaults4.type === "rule") {
+        return new Rule(defaults4);
+      } else if (defaults4.type === "comment") {
+        return new Comment(defaults4);
+      } else if (defaults4.type === "atrule") {
+        return new AtRule(defaults4);
+      } else {
+        throw new Error("Unknown node type: " + json2.type);
+      }
+    }
+    module2.exports = fromJSON;
+    fromJSON.default = fromJSON;
+  }
+});
+
 // ../../node_modules/postcss/lib/map-generator.js
 var require_map_generator = __commonJS({
   "../../node_modules/postcss/lib/map-generator.js"(exports2, module2) {
     "use strict";
-    var { SourceMapConsumer, SourceMapGenerator } = require_source_map();
     var { dirname: dirname8, relative: relative6, resolve: resolve9, sep: sep5 } = require("path");
+    var { SourceMapConsumer, SourceMapGenerator } = require_source_map();
     var { pathToFileURL } = require("url");
     var Input = require_input4();
     var sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator);
@@ -46408,12 +47137,12 @@ var require_map_generator = __commonJS({
             node3 = this.root.nodes[i2];
             if (node3.type !== "comment")
               continue;
-            if (node3.text.indexOf("# sourceMappingURL=") === 0) {
+            if (node3.text.startsWith("# sourceMappingURL=")) {
               this.root.removeChild(i2);
             }
           }
         } else if (this.css) {
-          this.css = this.css.replace(/\n*?\/\*#[\S\s]*?\*\/$/gm, "");
+          this.css = this.css.replace(/\n*\/\*#[\S\s]*?\*\/$/gm, "");
         }
       }
       generate() {
@@ -46474,7 +47203,7 @@ var require_map_generator = __commonJS({
           original: { column: 0, line: 0 },
           source: ""
         };
-        let lines, last;
+        let last, lines;
         this.stringify(this.root, (str2, node3, type2) => {
           this.css += str2;
           if (node3 && type2 !== "end") {
@@ -46674,727 +47403,16 @@ var require_map_generator = __commonJS({
   }
 });
 
-// ../../node_modules/postcss/lib/comment.js
-var require_comment = __commonJS({
-  "../../node_modules/postcss/lib/comment.js"(exports2, module2) {
-    "use strict";
-    var Node = require_node2();
-    var Comment = class extends Node {
-      constructor(defaults4) {
-        super(defaults4);
-        this.type = "comment";
-      }
-    };
-    module2.exports = Comment;
-    Comment.default = Comment;
-  }
-});
-
-// ../../node_modules/postcss/lib/container.js
-var require_container = __commonJS({
-  "../../node_modules/postcss/lib/container.js"(exports2, module2) {
-    "use strict";
-    var { isClean, my } = require_symbols();
-    var Declaration = require_declaration();
-    var Comment = require_comment();
-    var Node = require_node2();
-    var parse16;
-    var Rule;
-    var AtRule;
-    var Root;
-    function cleanSource(nodes) {
-      return nodes.map((i2) => {
-        if (i2.nodes)
-          i2.nodes = cleanSource(i2.nodes);
-        delete i2.source;
-        return i2;
-      });
-    }
-    function markDirtyUp(node3) {
-      node3[isClean] = false;
-      if (node3.proxyOf.nodes) {
-        for (let i2 of node3.proxyOf.nodes) {
-          markDirtyUp(i2);
-        }
-      }
-    }
-    var Container = class extends Node {
-      append(...children) {
-        for (let child of children) {
-          let nodes = this.normalize(child, this.last);
-          for (let node3 of nodes)
-            this.proxyOf.nodes.push(node3);
-        }
-        this.markDirty();
-        return this;
-      }
-      cleanRaws(keepBetween) {
-        super.cleanRaws(keepBetween);
-        if (this.nodes) {
-          for (let node3 of this.nodes)
-            node3.cleanRaws(keepBetween);
-        }
-      }
-      each(callback) {
-        if (!this.proxyOf.nodes)
-          return void 0;
-        let iterator = this.getIterator();
-        let index4, result;
-        while (this.indexes[iterator] < this.proxyOf.nodes.length) {
-          index4 = this.indexes[iterator];
-          result = callback(this.proxyOf.nodes[index4], index4);
-          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(node3, prop) {
-            if (prop === "proxyOf") {
-              return node3;
-            } else if (!node3[prop]) {
-              return node3[prop];
-            } else if (prop === "each" || typeof prop === "string" && prop.startsWith("walk")) {
-              return (...args) => {
-                return node3[prop](
-                  ...args.map((i2) => {
-                    if (typeof i2 === "function") {
-                      return (child, index4) => i2(child.toProxy(), index4);
-                    } else {
-                      return i2;
-                    }
-                  })
-                );
-              };
-            } else if (prop === "every" || prop === "some") {
-              return (cb) => {
-                return node3[prop](
-                  (child, ...other) => cb(child.toProxy(), ...other)
-                );
-              };
-            } else if (prop === "root") {
-              return () => node3.root().toProxy();
-            } else if (prop === "nodes") {
-              return node3.nodes.map((i2) => i2.toProxy());
-            } else if (prop === "first" || prop === "last") {
-              return node3[prop].toProxy();
-            } else {
-              return node3[prop];
-            }
-          },
-          set(node3, prop, value) {
-            if (node3[prop] === value)
-              return true;
-            node3[prop] = value;
-            if (prop === "name" || prop === "params" || prop === "selector") {
-              node3.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, add2) {
-        let existIndex = this.index(exist);
-        let nodes = this.normalize(add2, this.proxyOf.nodes[existIndex]).reverse();
-        existIndex = this.index(exist);
-        for (let node3 of nodes)
-          this.proxyOf.nodes.splice(existIndex + 1, 0, node3);
-        let index4;
-        for (let id in this.indexes) {
-          index4 = this.indexes[id];
-          if (existIndex < index4) {
-            this.indexes[id] = index4 + nodes.length;
-          }
-        }
-        this.markDirty();
-        return this;
-      }
-      insertBefore(exist, add2) {
-        let existIndex = this.index(exist);
-        let type2 = existIndex === 0 ? "prepend" : false;
-        let nodes = this.normalize(add2, this.proxyOf.nodes[existIndex], type2).reverse();
-        existIndex = this.index(exist);
-        for (let node3 of nodes)
-          this.proxyOf.nodes.splice(existIndex, 0, node3);
-        let index4;
-        for (let id in this.indexes) {
-          index4 = this.indexes[id];
-          if (existIndex <= index4) {
-            this.indexes[id] = index4 + nodes.length;
-          }
-        }
-        this.markDirty();
-        return this;
-      }
-      normalize(nodes, sample2) {
-        if (typeof nodes === "string") {
-          nodes = cleanSource(parse16(nodes).nodes);
-        } else if (typeof nodes === "undefined") {
-          nodes = [];
-        } else if (Array.isArray(nodes)) {
-          nodes = nodes.slice(0);
-          for (let i2 of nodes) {
-            if (i2.parent)
-              i2.parent.removeChild(i2, "ignore");
-          }
-        } else if (nodes.type === "root" && this.type !== "document") {
-          nodes = nodes.nodes.slice(0);
-          for (let i2 of nodes) {
-            if (i2.parent)
-              i2.parent.removeChild(i2, "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 Declaration(nodes)];
-        } else if (nodes.selector) {
-          nodes = [new Rule(nodes)];
-        } else if (nodes.name) {
-          nodes = [new AtRule(nodes)];
-        } else if (nodes.text) {
-          nodes = [new Comment(nodes)];
-        } else {
-          throw new Error("Unknown node type in node creation");
-        }
-        let processed = nodes.map((i2) => {
-          if (!i2[my])
-            Container.rebuild(i2);
-          i2 = i2.proxyOf;
-          if (i2.parent)
-            i2.parent.removeChild(i2);
-          if (i2[isClean])
-            markDirtyUp(i2);
-          if (typeof i2.raws.before === "undefined") {
-            if (sample2 && typeof sample2.raws.before !== "undefined") {
-              i2.raws.before = sample2.raws.before.replace(/\S/g, "");
-            }
-          }
-          i2.parent = this.proxyOf;
-          return i2;
-        });
-        return processed;
-      }
-      prepend(...children) {
-        children = children.reverse();
-        for (let child of children) {
-          let nodes = this.normalize(child, this.first, "prepend").reverse();
-          for (let node3 of nodes)
-            this.proxyOf.nodes.unshift(node3);
-          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 node3 of this.proxyOf.nodes)
-          node3.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 index4;
-        for (let id in this.indexes) {
-          index4 = this.indexes[id];
-          if (index4 >= child) {
-            this.indexes[id] = index4 - 1;
-          }
-        }
-        this.markDirty();
-        return this;
-      }
-      replaceValues(pattern, opts, callback) {
-        if (!callback) {
-          callback = opts;
-          opts = {};
-        }
-        this.walkDecls((decl) => {
-          if (opts.props && !opts.props.includes(decl.prop))
-            return;
-          if (opts.fast && !decl.value.includes(opts.fast))
-            return;
-          decl.value = decl.value.replace(pattern, callback);
-        });
-        this.markDirty();
-        return this;
-      }
-      some(condition) {
-        return this.nodes.some(condition);
-      }
-      walk(callback) {
-        return this.each((child, i2) => {
-          let result;
-          try {
-            result = callback(child, i2);
-          } catch (e2) {
-            throw child.addToError(e2);
-          }
-          if (result !== false && child.walk) {
-            result = child.walk(callback);
-          }
-          return result;
-        });
-      }
-      walkAtRules(name3, callback) {
-        if (!callback) {
-          callback = name3;
-          return this.walk((child, i2) => {
-            if (child.type === "atrule") {
-              return callback(child, i2);
-            }
-          });
-        }
-        if (name3 instanceof RegExp) {
-          return this.walk((child, i2) => {
-            if (child.type === "atrule" && name3.test(child.name)) {
-              return callback(child, i2);
-            }
-          });
-        }
-        return this.walk((child, i2) => {
-          if (child.type === "atrule" && child.name === name3) {
-            return callback(child, i2);
-          }
-        });
-      }
-      walkComments(callback) {
-        return this.walk((child, i2) => {
-          if (child.type === "comment") {
-            return callback(child, i2);
-          }
-        });
-      }
-      walkDecls(prop, callback) {
-        if (!callback) {
-          callback = prop;
-          return this.walk((child, i2) => {
-            if (child.type === "decl") {
-              return callback(child, i2);
-            }
-          });
-        }
-        if (prop instanceof RegExp) {
-          return this.walk((child, i2) => {
-            if (child.type === "decl" && prop.test(child.prop)) {
-              return callback(child, i2);
-            }
-          });
-        }
-        return this.walk((child, i2) => {
-          if (child.type === "decl" && child.prop === prop) {
-            return callback(child, i2);
-          }
-        });
-      }
-      walkRules(selector, callback) {
-        if (!callback) {
-          callback = selector;
-          return this.walk((child, i2) => {
-            if (child.type === "rule") {
-              return callback(child, i2);
-            }
-          });
-        }
-        if (selector instanceof RegExp) {
-          return this.walk((child, i2) => {
-            if (child.type === "rule" && selector.test(child.selector)) {
-              return callback(child, i2);
-            }
-          });
-        }
-        return this.walk((child, i2) => {
-          if (child.type === "rule" && child.selector === selector) {
-            return callback(child, i2);
-          }
-        });
-      }
-      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];
-      }
-    };
-    Container.registerParse = (dependant) => {
-      parse16 = dependant;
-    };
-    Container.registerRule = (dependant) => {
-      Rule = dependant;
-    };
-    Container.registerAtRule = (dependant) => {
-      AtRule = dependant;
-    };
-    Container.registerRoot = (dependant) => {
-      Root = dependant;
-    };
-    module2.exports = Container;
-    Container.default = Container;
-    Container.rebuild = (node3) => {
-      if (node3.type === "atrule") {
-        Object.setPrototypeOf(node3, AtRule.prototype);
-      } else if (node3.type === "rule") {
-        Object.setPrototypeOf(node3, Rule.prototype);
-      } else if (node3.type === "decl") {
-        Object.setPrototypeOf(node3, Declaration.prototype);
-      } else if (node3.type === "comment") {
-        Object.setPrototypeOf(node3, Comment.prototype);
-      } else if (node3.type === "root") {
-        Object.setPrototypeOf(node3, Root.prototype);
-      }
-      node3[my] = true;
-      if (node3.nodes) {
-        node3.nodes.forEach((child) => {
-          Container.rebuild(child);
-        });
-      }
-    };
-  }
-});
-
-// ../../node_modules/postcss/lib/document.js
-var require_document = __commonJS({
-  "../../node_modules/postcss/lib/document.js"(exports2, module2) {
-    "use strict";
-    var Container = require_container();
-    var LazyResult;
-    var Processor2;
-    var Document2 = class extends Container {
-      constructor(defaults4) {
-        super({ type: "document", ...defaults4 });
-        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;
-    };
-    module2.exports = Document2;
-    Document2.default = Document2;
-  }
-});
-
-// ../../node_modules/postcss/lib/warn-once.js
-var require_warn_once = __commonJS({
-  "../../node_modules/postcss/lib/warn-once.js"(exports2, module2) {
-    "use strict";
-    var printed = {};
-    module2.exports = function warnOnce(message) {
-      if (printed[message])
-        return;
-      printed[message] = true;
-      if (typeof console !== "undefined" && console.warn) {
-        console.warn(message);
-      }
-    };
-  }
-});
-
-// ../../node_modules/postcss/lib/warning.js
-var require_warning = __commonJS({
-  "../../node_modules/postcss/lib/warning.js"(exports2, module2) {
-    "use strict";
-    var Warning = class {
-      constructor(text7, opts = {}) {
-        this.type = "warning";
-        this.text = text7;
-        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;
-      }
-    };
-    module2.exports = Warning;
-    Warning.default = Warning;
-  }
-});
-
-// ../../node_modules/postcss/lib/result.js
-var require_result = __commonJS({
-  "../../node_modules/postcss/lib/result.js"(exports2, module2) {
-    "use strict";
-    var Warning = require_warning();
-    var Result = class {
-      constructor(processor2, root6, opts) {
-        this.processor = processor2;
-        this.messages = [];
-        this.root = root6;
-        this.opts = opts;
-        this.css = void 0;
-        this.map = void 0;
-      }
-      toString() {
-        return this.css;
-      }
-      warn(text7, opts = {}) {
-        if (!opts.plugin) {
-          if (this.lastPlugin && this.lastPlugin.postcssPlugin) {
-            opts.plugin = this.lastPlugin.postcssPlugin;
-          }
-        }
-        let warning2 = new Warning(text7, opts);
-        this.messages.push(warning2);
-        return warning2;
-      }
-      warnings() {
-        return this.messages.filter((i2) => i2.type === "warning");
-      }
-      get content() {
-        return this.css;
-      }
-    };
-    module2.exports = Result;
-    Result.default = Result;
-  }
-});
-
-// ../../node_modules/postcss/lib/at-rule.js
-var require_at_rule = __commonJS({
-  "../../node_modules/postcss/lib/at-rule.js"(exports2, module2) {
-    "use strict";
-    var Container = require_container();
-    var AtRule = class extends Container {
-      constructor(defaults4) {
-        super(defaults4);
-        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);
-      }
-    };
-    module2.exports = AtRule;
-    AtRule.default = AtRule;
-    Container.registerAtRule(AtRule);
-  }
-});
-
-// ../../node_modules/postcss/lib/root.js
-var require_root = __commonJS({
-  "../../node_modules/postcss/lib/root.js"(exports2, module2) {
-    "use strict";
-    var Container = require_container();
-    var LazyResult;
-    var Processor2;
-    var Root = class extends Container {
-      constructor(defaults4) {
-        super(defaults4);
-        this.type = "root";
-        if (!this.nodes)
-          this.nodes = [];
-      }
-      normalize(child, sample2, type2) {
-        let nodes = super.normalize(child);
-        if (sample2) {
-          if (type2 === "prepend") {
-            if (this.nodes.length > 1) {
-              sample2.raws.before = this.nodes[1].raws.before;
-            } else {
-              delete sample2.raws.before;
-            }
-          } else if (this.first !== sample2) {
-            for (let node3 of nodes) {
-              node3.raws.before = sample2.raws.before;
-            }
-          }
-        }
-        return nodes;
-      }
-      removeChild(child, ignore3) {
-        let index4 = this.index(child);
-        if (!ignore3 && index4 === 0 && this.nodes.length > 1) {
-          this.nodes[1].raws.before = this.nodes[index4].raws.before;
-        }
-        return super.removeChild(child);
-      }
-      toResult(opts = {}) {
-        let lazy = new LazyResult(new Processor2(), this, opts);
-        return lazy.stringify();
-      }
-    };
-    Root.registerLazyResult = (dependant) => {
-      LazyResult = dependant;
-    };
-    Root.registerProcessor = (dependant) => {
-      Processor2 = dependant;
-    };
-    module2.exports = Root;
-    Root.default = Root;
-    Container.registerRoot(Root);
-  }
-});
-
-// ../../node_modules/postcss/lib/list.js
-var require_list = __commonJS({
-  "../../node_modules/postcss/lib/list.js"(exports2, module2) {
-    "use strict";
-    var list6 = {
-      comma(string2) {
-        return list6.split(string2, [","], true);
-      },
-      space(string2) {
-        let spaces = [" ", "\n", "	"];
-        return list6.split(string2, spaces);
-      },
-      split(string2, separators, last) {
-        let array = [];
-        let current2 = "";
-        let split2 = false;
-        let func = 0;
-        let inQuote = false;
-        let prevQuote = "";
-        let escape5 = false;
-        for (let letter of string2) {
-          if (escape5) {
-            escape5 = false;
-          } else if (letter === "\\") {
-            escape5 = 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))
-              split2 = true;
-          }
-          if (split2) {
-            if (current2 !== "")
-              array.push(current2.trim());
-            current2 = "";
-            split2 = false;
-          } else {
-            current2 += letter;
-          }
-        }
-        if (last || current2 !== "")
-          array.push(current2.trim());
-        return array;
-      }
-    };
-    module2.exports = list6;
-    list6.default = list6;
-  }
-});
-
-// ../../node_modules/postcss/lib/rule.js
-var require_rule = __commonJS({
-  "../../node_modules/postcss/lib/rule.js"(exports2, module2) {
-    "use strict";
-    var Container = require_container();
-    var list6 = require_list();
-    var Rule = class extends Container {
-      constructor(defaults4) {
-        super(defaults4);
-        this.type = "rule";
-        if (!this.nodes)
-          this.nodes = [];
-      }
-      get selectors() {
-        return list6.comma(this.selector);
-      }
-      set selectors(values) {
-        let match3 = this.selector ? this.selector.match(/,\s*/) : null;
-        let sep5 = match3 ? match3[0] : "," + this.raw("between", "beforeOpen");
-        this.selector = values.join(sep5);
-      }
-    };
-    module2.exports = Rule;
-    Rule.default = Rule;
-    Container.registerRule(Rule);
-  }
-});
-
 // ../../node_modules/postcss/lib/parser.js
 var require_parser3 = __commonJS({
   "../../node_modules/postcss/lib/parser.js"(exports2, module2) {
     "use strict";
-    var Declaration = require_declaration();
-    var tokenizer = require_tokenize();
-    var Comment = require_comment();
     var AtRule = require_at_rule();
+    var Comment = require_comment();
+    var Declaration = require_declaration();
     var Root = require_root();
     var Rule = require_rule();
+    var tokenizer = require_tokenize();
     var SAFE_COMMENT_NEIGHBOR = {
       empty: true,
       space: true
@@ -47516,7 +47534,7 @@ var require_parser3 = __commonJS({
       }
       colon(tokens) {
         let brackets = 0;
-        let token, type2, prev;
+        let prev, token, type2;
         for (let [i2, element5] of tokens.entries()) {
           token = element5;
           type2 = token[0];
@@ -47626,12 +47644,12 @@ var require_parser3 = __commonJS({
             let str2 = "";
             for (let j = i2; j > 0; j--) {
               let type2 = cache[j][0];
-              if (str2.trim().indexOf("!") === 0 && type2 !== "space") {
+              if (str2.trim().startsWith("!") && type2 !== "space") {
                 break;
               }
               str2 = cache.pop()[1] + str2;
             }
-            if (str2.trim().indexOf("!") === 0) {
+            if (str2.trim().startsWith("!")) {
               node3.important = true;
               node3.raws.important = str2;
               tokens = cache;
@@ -47939,8 +47957,8 @@ var require_parse3 = __commonJS({
   "../../node_modules/postcss/lib/parse.js"(exports2, module2) {
     "use strict";
     var Container = require_container();
-    var Parser3 = require_parser3();
     var Input = require_input4();
+    var Parser3 = require_parser3();
     function parse16(css, opts) {
       let input3 = new Input(css, opts);
       let parser3 = new Parser3(input3);
@@ -47968,19 +47986,111 @@ var require_parse3 = __commonJS({
   }
 });
 
+// ../../node_modules/postcss/lib/warning.js
+var require_warning = __commonJS({
+  "../../node_modules/postcss/lib/warning.js"(exports2, module2) {
+    "use strict";
+    var Warning = class {
+      constructor(text7, opts = {}) {
+        this.type = "warning";
+        this.text = text7;
+        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;
+      }
+    };
+    module2.exports = Warning;
+    Warning.default = Warning;
+  }
+});
+
+// ../../node_modules/postcss/lib/result.js
+var require_result = __commonJS({
+  "../../node_modules/postcss/lib/result.js"(exports2, module2) {
+    "use strict";
+    var Warning = require_warning();
+    var Result = class {
+      constructor(processor2, root6, opts) {
+        this.processor = processor2;
+        this.messages = [];
+        this.root = root6;
+        this.opts = opts;
+        this.css = void 0;
+        this.map = void 0;
+      }
+      toString() {
+        return this.css;
+      }
+      warn(text7, opts = {}) {
+        if (!opts.plugin) {
+          if (this.lastPlugin && this.lastPlugin.postcssPlugin) {
+            opts.plugin = this.lastPlugin.postcssPlugin;
+          }
+        }
+        let warning2 = new Warning(text7, opts);
+        this.messages.push(warning2);
+        return warning2;
+      }
+      warnings() {
+        return this.messages.filter((i2) => i2.type === "warning");
+      }
+      get content() {
+        return this.css;
+      }
+    };
+    module2.exports = Result;
+    Result.default = Result;
+  }
+});
+
+// ../../node_modules/postcss/lib/warn-once.js
+var require_warn_once = __commonJS({
+  "../../node_modules/postcss/lib/warn-once.js"(exports2, module2) {
+    "use strict";
+    var printed = {};
+    module2.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"(exports2, module2) {
     "use strict";
-    var { isClean, my } = require_symbols();
-    var MapGenerator = require_map_generator();
-    var stringify4 = require_stringify2();
     var Container = require_container();
     var Document2 = require_document();
-    var warnOnce = require_warn_once();
-    var Result = require_result();
+    var MapGenerator = require_map_generator();
     var parse16 = require_parse3();
+    var Result = require_result();
     var Root = require_root();
+    var stringify4 = require_stringify2();
+    var { isClean, my } = require_symbols();
+    var warnOnce = require_warn_once();
     var TYPE_TO_CLASS_NAME = {
       atrule: "AtRule",
       comment: "Comment",
@@ -48467,10 +48577,10 @@ var require_no_work_result = __commonJS({
   "../../node_modules/postcss/lib/no-work-result.js"(exports2, module2) {
     "use strict";
     var MapGenerator = require_map_generator();
-    var stringify4 = require_stringify2();
-    var warnOnce = require_warn_once();
     var parse16 = require_parse3();
     var Result = require_result();
+    var stringify4 = require_stringify2();
+    var warnOnce = require_warn_once();
     var NoWorkResult = class {
       constructor(processor2, css, opts) {
         css = css.toString();
@@ -48584,13 +48694,13 @@ var require_no_work_result = __commonJS({
 var require_processor = __commonJS({
   "../../node_modules/postcss/lib/processor.js"(exports2, module2) {
     "use strict";
-    var NoWorkResult = require_no_work_result();
-    var LazyResult = require_lazy_result();
     var Document2 = require_document();
+    var LazyResult = require_lazy_result();
+    var NoWorkResult = require_no_work_result();
     var Root = require_root();
     var Processor2 = class {
       constructor(plugins3 = []) {
-        this.version = "8.4.38";
+        this.version = "8.4.47";
         this.plugins = this.normalize(plugins3);
       }
       normalize(plugins3) {
@@ -48638,85 +48748,28 @@ var require_processor = __commonJS({
   }
 });
 
-// ../../node_modules/postcss/lib/fromJSON.js
-var require_fromJSON = __commonJS({
-  "../../node_modules/postcss/lib/fromJSON.js"(exports2, module2) {
-    "use strict";
-    var Declaration = require_declaration();
-    var PreviousMap = require_previous_map();
-    var Comment = require_comment();
-    var AtRule = require_at_rule();
-    var Input = require_input4();
-    var Root = require_root();
-    var Rule = require_rule();
-    function fromJSON(json2, inputs) {
-      if (Array.isArray(json2))
-        return json2.map((n) => fromJSON(n));
-      let { inputs: ownInputs, ...defaults4 } = json2;
-      if (ownInputs) {
-        inputs = [];
-        for (let input3 of ownInputs) {
-          let inputHydrated = { ...input3, __proto__: Input.prototype };
-          if (inputHydrated.map) {
-            inputHydrated.map = {
-              ...inputHydrated.map,
-              __proto__: PreviousMap.prototype
-            };
-          }
-          inputs.push(inputHydrated);
-        }
-      }
-      if (defaults4.nodes) {
-        defaults4.nodes = json2.nodes.map((n) => fromJSON(n, inputs));
-      }
-      if (defaults4.source) {
-        let { inputId, ...source2 } = defaults4.source;
-        defaults4.source = source2;
-        if (inputId != null) {
-          defaults4.source.input = inputs[inputId];
-        }
-      }
-      if (defaults4.type === "root") {
-        return new Root(defaults4);
-      } else if (defaults4.type === "decl") {
-        return new Declaration(defaults4);
-      } else if (defaults4.type === "rule") {
-        return new Rule(defaults4);
-      } else if (defaults4.type === "comment") {
-        return new Comment(defaults4);
-      } else if (defaults4.type === "atrule") {
-        return new AtRule(defaults4);
-      } else {
-        throw new Error("Unknown node type: " + json2.type);
-      }
-    }
-    module2.exports = fromJSON;
-    fromJSON.default = fromJSON;
-  }
-});
-
 // ../../node_modules/postcss/lib/postcss.js
 var require_postcss = __commonJS({
   "../../node_modules/postcss/lib/postcss.js"(exports2, module2) {
     "use strict";
+    var AtRule = require_at_rule();
+    var Comment = require_comment();
+    var Container = require_container();
     var CssSyntaxError = require_css_syntax_error();
     var Declaration = require_declaration();
-    var LazyResult = require_lazy_result();
-    var Container = require_container();
-    var Processor2 = require_processor();
-    var stringify4 = require_stringify2();
-    var fromJSON = require_fromJSON();
     var Document2 = require_document();
-    var Warning = require_warning();
-    var Comment = require_comment();
-    var AtRule = require_at_rule();
-    var Result = require_result();
+    var fromJSON = require_fromJSON();
     var Input = require_input4();
-    var parse16 = require_parse3();
+    var LazyResult = require_lazy_result();
     var list6 = require_list();
-    var Rule = require_rule();
-    var Root = require_root();
     var Node = require_node2();
+    var parse16 = require_parse3();
+    var Processor2 = require_processor();
+    var Result = require_result();
+    var Root = require_root();
+    var Rule = require_rule();
+    var stringify4 = require_stringify2();
+    var Warning = require_warning();
     function postcss(...plugins3) {
       if (plugins3.length === 1 && Array.isArray(plugins3[0])) {
         plugins3 = plugins3[0];
@@ -135536,9 +135589,9 @@ var require_mime2 = __commonJS({
   }
 });
 
-// ../../node_modules/send/node_modules/ms/index.js
+// ../../node_modules/ms/index.js
 var require_ms5 = __commonJS({
-  "../../node_modules/send/node_modules/ms/index.js"(exports2, module2) {
+  "../../node_modules/ms/index.js"(exports2, module2) {
     var s5 = 1e3;
     var m2 = s5 * 60;
     var h4 = m2 * 60;
@@ -180773,122 +180826,6 @@ var require_ansi_align = __commonJS({
   }
 });
 
-// ../../node_modules/ms/index.js
-var require_ms6 = __commonJS({
-  "../../node_modules/ms/index.js"(exports2, module2) {
-    var s5 = 1e3;
-    var m2 = s5 * 60;
-    var h4 = m2 * 60;
-    var d = h4 * 24;
-    var w = d * 7;
-    var y = d * 365.25;
-    module2.exports = function(val, options) {
-      options = options || {};
-      var type2 = typeof val;
-      if (type2 === "string" && val.length > 0) {
-        return parse16(val);
-      } else if (type2 === "number" && isFinite(val)) {
-        return options.long ? fmtLong(val) : fmtShort(val);
-      }
-      throw new Error(
-        "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
-      );
-    };
-    function parse16(str2) {
-      str2 = String(str2);
-      if (str2.length > 100) {
-        return;
-      }
-      var match3 = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
-        str2
-      );
-      if (!match3) {
-        return;
-      }
-      var n = parseFloat(match3[1]);
-      var type2 = (match3[2] || "ms").toLowerCase();
-      switch (type2) {
-        case "years":
-        case "year":
-        case "yrs":
-        case "yr":
-        case "y":
-          return n * y;
-        case "weeks":
-        case "week":
-        case "w":
-          return n * w;
-        case "days":
-        case "day":
-        case "d":
-          return n * d;
-        case "hours":
-        case "hour":
-        case "hrs":
-        case "hr":
-        case "h":
-          return n * h4;
-        case "minutes":
-        case "minute":
-        case "mins":
-        case "min":
-        case "m":
-          return n * m2;
-        case "seconds":
-        case "second":
-        case "secs":
-        case "sec":
-        case "s":
-          return n * s5;
-        case "milliseconds":
-        case "millisecond":
-        case "msecs":
-        case "msec":
-        case "ms":
-          return n;
-        default:
-          return void 0;
-      }
-    }
-    function fmtShort(ms) {
-      var msAbs = Math.abs(ms);
-      if (msAbs >= d) {
-        return Math.round(ms / d) + "d";
-      }
-      if (msAbs >= h4) {
-        return Math.round(ms / h4) + "h";
-      }
-      if (msAbs >= m2) {
-        return Math.round(ms / m2) + "m";
-      }
-      if (msAbs >= s5) {
-        return Math.round(ms / s5) + "s";
-      }
-      return ms + "ms";
-    }
-    function fmtLong(ms) {
-      var msAbs = Math.abs(ms);
-      if (msAbs >= d) {
-        return plural2(ms, msAbs, d, "day");
-      }
-      if (msAbs >= h4) {
-        return plural2(ms, msAbs, h4, "hour");
-      }
-      if (msAbs >= m2) {
-        return plural2(ms, msAbs, m2, "minute");
-      }
-      if (msAbs >= s5) {
-        return plural2(ms, msAbs, s5, "second");
-      }
-      return ms + " ms";
-    }
-    function plural2(ms, msAbs, n, name3) {
-      var isPlural = msAbs >= n * 1.5;
-      return Math.round(ms / n) + " " + name3 + (isPlural ? "s" : "");
-    }
-  }
-});
-
 // ../../node_modules/debug/src/common.js
 var require_common = __commonJS({
   "../../node_modules/debug/src/common.js"(exports2, module2) {
@@ -180899,7 +180836,7 @@ var require_common = __commonJS({
       createDebug.disable = disable;
       createDebug.enable = enable;
       createDebug.enabled = enabled;
-      createDebug.humanize = require_ms6();
+      createDebug.humanize = require_ms5();
       createDebug.destroy = destroy;
       Object.keys(env7).forEach((key2) => {
         createDebug[key2] = env7[key2];
@@ -181154,10 +181091,11 @@ var require_browser5 = __commonJS({
       if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
         return false;
       }
+      let m2;
       return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
       typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
       // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
-      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
+      typeof navigator !== "undefined" && navigator.userAgent && (m2 = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m2[1], 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
       typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
     }
     function formatArgs(args) {
@@ -181472,7 +181410,7 @@ var require_node8 = __commonJS({
       return (/* @__PURE__ */ new Date()).toISOString() + " ";
     }
     function log(...args) {
-      return process.stderr.write(util4.format(...args) + "\n");
+      return process.stderr.write(util4.formatWithOptions(exports2.inspectOpts, ...args) + "\n");
     }
     function save(namespaces) {
       if (namespaces) {
@@ -193562,7 +193500,7 @@ var {
 } = import_index.default;
 
 // src/version.ts
-var version = "1.3.11";
+var version = "1.3.12";
 var version_default = version;
 
 // ../myst-cli/dist/build/build.js
@@ -194682,27 +194620,29 @@ function validateAffiliation(input3, opts) {
 }
 
 // ../myst-frontmatter/dist/biblio/validators.js
-var BIBLIO_KEYS = ["volume", "issue", "doi", "first_page", "last_page"];
-function validateBiblio(input3, opts) {
-  const value = validateObjectKeys(input3, { optional: BIBLIO_KEYS }, opts);
+var PUBLICATION_META_KEYS = ["number", "doi", "title", "subject"];
+function validatePublicationMeta(input3, opts) {
+  if (typeof input3 !== "object") {
+    input3 = { number: input3 };
+  }
+  const value = validateObjectKeys(input3, { optional: PUBLICATION_META_KEYS, alias: { name: "number" } }, opts);
   if (value === void 0)
     return void 0;
   const output2 = {};
-  if (defined(value.volume)) {
-    output2.volume = validateStringOrNumber(value.volume, incrementOptions("volume", opts));
-  }
-  if (defined(value.issue)) {
-    output2.issue = validateStringOrNumber(value.issue, incrementOptions("issue", opts));
+  if (defined(value.number)) {
+    output2.number = validateStringOrNumber(value.number, incrementOptions("number", opts));
   }
   if (defined(value.doi)) {
     output2.doi = validateDoi(value.doi, incrementOptions("doi", opts));
   }
-  if (defined(value.first_page)) {
-    output2.first_page = validateStringOrNumber(value.first_page, incrementOptions("first_page", opts));
+  if (defined(value.title)) {
+    output2.title = validateString(value.title, incrementOptions("title", opts));
   }
-  if (defined(value.last_page)) {
-    output2.last_page = validateStringOrNumber(value.last_page, incrementOptions("last_page", opts));
+  if (defined(value.subject)) {
+    output2.subject = validateString(value.subject, incrementOptions("subject", opts));
   }
+  if (Object.keys(output2).length === 0)
+    return void 0;
   return output2;
 }
 
@@ -195228,7 +195168,10 @@ var PROJECT_AND_PAGE_FRONTMATTER_KEYS = [
   "binder",
   "source",
   "subject",
-  "biblio",
+  "volume",
+  "issue",
+  "first_page",
+  "last_page",
   "oxa",
   "numbering",
   "bibliography",
@@ -198075,10 +198018,10 @@ function correctLicense(license) {
     return "CC-BY-4.0";
   return void 0;
 }
-function createURL(license) {
+function createURL(id, cc, osi) {
   var _a6, _b;
-  if (license.CC) {
-    const match3 = /^([CBYSAND0-]+)(?:(?:-)([0-9].[0-9]))?(?:(?:-)([A-Z]{2}))?$/.exec(license.id);
+  if (cc) {
+    const match3 = /^([CBYSAND0ZEROPD-]+)(?:(?:-)([0-9].[0-9]))?(?:(?:-)([A-Z]{2,3}))?$/.exec(id);
     if (!match3) {
       throw new Error("Creative Commons license not found");
     }
@@ -198120,47 +198063,131 @@ function createURL(license) {
       link4 += `${extra}/`;
     return `https://creativecommons.org/licenses${link4}`;
   }
-  if (license.osi) {
-    return `https://opensource.org/licenses/${license.id}`;
+  if (osi) {
+    return `https://opensource.org/licenses/${id.replace(/(-or-later)|(-only)$/, "")}`;
+  }
+  return `https://spdx.org/licenses/${id}`;
+}
+function cleanUrl(url) {
+  return url.replace(/^http:/, "https:").replace(/\/$/, "");
+}
+function isUrl(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.protocol.includes("http");
+  } catch (error) {
+    return false;
   }
-  return `https://spdx.org/licenses/${license.id}`;
 }
+var ID_LICENSE_LOOKUP = Object.fromEntries(Object.entries(licenses_default).map(([key2, value]) => {
+  return [key2, { id: key2, ...value, url: createURL(key2, value.CC, value.osi) }];
+}));
+var URL_ID_LOOKUP = Object.fromEntries(Object.values(ID_LICENSE_LOOKUP).filter((value) => !!value.url && !!value.id).map((value) => {
+  return [cleanUrl(value.url), value.id];
+}));
 function validateLicense(input3, opts) {
-  if (typeof input3 === "object") {
-    const revalidated = validateLicense(input3.id, {
-      ...opts,
-      suppressErrors: true,
-      suppressWarnings: true
-    });
-    let equal = Boolean(revalidated);
-    if (revalidated) {
-      Object.entries(revalidated).forEach(([key2, val]) => {
-        if (val !== input3[key2])
-          equal = false;
-      });
-    }
-    if (!equal) {
-      return validationError(`invalid license object - use a valid license ID string instead, see https://spdx.org/licenses/`, opts);
+  if (typeof input3 === "string") {
+    const value2 = validateString(input3, opts);
+    if (value2 === void 0)
+      return void 0;
+    const valueSpdx = correctLicense(value2);
+    if (URL_ID_LOOKUP[cleanUrl(value2)]) {
+      input3 = { id: URL_ID_LOOKUP[cleanUrl(value2)] };
+    } else if (isUrl(value2)) {
+      input3 = { url: value2 };
+    } else if (valueSpdx) {
+      input3 = { id: value2 };
+    } else if (value2.match(/^[^\s]*$/)) {
+      input3 = { id: value2 };
+    } else if (value2.length < 100) {
+      input3 = { name: value2 };
+    } else {
+      input3 = { note: value2 };
     }
-    return revalidated;
   }
-  const valueUnvalidated = validateString(input3, opts);
-  if (valueUnvalidated === void 0)
+  const value = validateObjectKeys(input3, {
+    optional: ["id", "name", "url", "note", "free", "CC", "osi"],
+    alias: { cc: "CC" }
+  }, opts);
+  if (!value)
     return void 0;
-  const value = correctLicense(valueUnvalidated);
-  if (!value) {
-    return validationError(`invalid value "${valueUnvalidated}" - must be a valid license ID, see https://spdx.org/licenses/`, opts);
+  const output2 = {};
+  if (value.id != null) {
+    const id = validateString(value.id, incrementOptions("id", opts));
+    const idSpdx = correctLicense(id);
+    if (!idSpdx) {
+      validationWarning(`unknown license ID "${id}" - using a SPDX license ID is recommended, see https://spdx.org/licenses/`, opts);
+    } else if (idSpdx !== id) {
+      validationWarning(`The SPDX ID for the license is "${idSpdx}". Corrected from "${id}".`, opts);
+    }
+    output2.id = idSpdx !== null && idSpdx !== void 0 ? idSpdx : id;
+  } else {
+    validationWarning(`no license ID - using a SPDX license ID is recommended, see https://spdx.org/licenses/`, opts);
+  }
+  const expected = output2.id ? ID_LICENSE_LOOKUP[output2.id] : void 0;
+  if (value.url != null) {
+    const urlOpts = incrementOptions("url", opts);
+    const url = validateUrl(value.url, urlOpts);
+    if (url && (expected === null || expected === void 0 ? void 0 : expected.url) && cleanUrl(url) !== cleanUrl(expected.url)) {
+      validationWarning(`incorrect URL for SPDX license ${expected.id} - "${url}"`, urlOpts);
+    }
+    output2.url = url;
+  } else if (expected === null || expected === void 0 ? void 0 : expected.url) {
+    output2.url = expected.url;
+  }
+  if (value.name != null) {
+    const nameOpts = incrementOptions("name", opts);
+    const name3 = validateString(value.name, nameOpts);
+    if (name3 && (expected === null || expected === void 0 ? void 0 : expected.name) && name3 !== expected.name) {
+      validationWarning(`incorrect name for SPDX license ${expected.id} - "${name3}"`, nameOpts);
+    }
+    output2.name = name3;
+  } else if (expected === null || expected === void 0 ? void 0 : expected.name) {
+    output2.name = expected.name;
+  }
+  if (value.note != null) {
+    output2.note = validateString(value.note, incrementOptions("note", opts));
+  }
+  if (value.free != null) {
+    const freeOpts = incrementOptions("free", opts);
+    const free = validateBoolean(value.free, freeOpts);
+    if (free && !(expected === null || expected === void 0 ? void 0 : expected.free)) {
+      validationWarning('only SPDX licenses may specify they are "free" as listed by the FSF', freeOpts);
+    } else {
+      output2.free = free;
+    }
+  } else if ((expected === null || expected === void 0 ? void 0 : expected.free) != null) {
+    output2.free = expected.free;
   }
-  if (value !== valueUnvalidated) {
-    validationWarning(`The SPDX ID for the license is "${value}". Corrected from "${valueUnvalidated}".`, opts);
+  if (value.CC != null) {
+    const ccOpts = incrementOptions("CC", opts);
+    const cc = validateBoolean(value.CC, ccOpts);
+    if (cc && !((expected === null || expected === void 0 ? void 0 : expected.CC) || output2.url && new URL(output2.url).host === "creativecommons.org")) {
+      validationWarning('only licenses that link to creativecommons.org may specify that they are "CC"', ccOpts);
+    } else {
+      output2.CC = cc;
+    }
+  } else if ((expected === null || expected === void 0 ? void 0 : expected.CC) != null) {
+    output2.CC = expected.CC;
   }
-  const spdx = { id: value, ...licenses_default[value] };
-  const url = createURL(spdx);
-  return { ...spdx, url };
+  if (value.osi != null) {
+    const osiOpts = incrementOptions("osi", opts);
+    const osi = validateBoolean(value.osi, osiOpts);
+    if (osi && !(expected === null || expected === void 0 ? void 0 : expected.osi)) {
+      validationWarning('only SPDX licenses may specify they are "OSI approved"', osiOpts);
+    } else {
+      output2.osi = osi;
+    }
+  } else if ((expected === null || expected === void 0 ? void 0 : expected.osi) != null) {
+    output2.osi = expected.osi;
+  }
+  if (Object.keys(output2).length === 0)
+    return void 0;
+  return output2;
 }
 function validateLicenses(input3, opts) {
   let contentOpts;
-  if (typeof input3 === "string") {
+  if (typeof input3 === "string" || typeof input3 === "object" && input3.content == null && input3.code == null) {
     input3 = { content: input3 };
     contentOpts = opts;
   } else {
@@ -198171,25 +198198,63 @@ function validateLicenses(input3, opts) {
     return void 0;
   const output2 = {};
   if (defined(value.content)) {
-    output2.content = validateLicense(value.content, contentOpts);
+    const content3 = validateLicense(value.content, contentOpts);
+    if (content3)
+      output2.content = content3;
   }
   if (defined(value.code) && value.code !== value.content) {
-    output2.code = validateLicense(value.code, incrementOptions("code", opts));
+    const code7 = validateLicense(value.code, incrementOptions("code", opts));
+    if (code7)
+      output2.code = code7;
   }
+  if (Object.keys(output2).length === 0)
+    return void 0;
+  return output2;
+}
+function removeExpectedKeys(license, expected) {
+  const output2 = {};
+  Object.entries(license).forEach(([key2, val]) => {
+    const licenseKey = key2;
+    if (licenseKey === "id" || val !== expected[licenseKey]) {
+      output2[licenseKey] = val;
+    }
+  });
+  if (Object.keys(output2).length === 1 && output2.id)
+    return output2.id;
   return output2;
 }
-function licensesToString(licenses2) {
-  const stringLicenses = {};
-  if (licenses2.content) {
-    if (!licenses2.code || licenses2.content.id === licenses2.code.id) {
-      return licenses2.content.id;
+function objectsEqual(a2, b) {
+  if (a2 == null || b == null)
+    return false;
+  const aAsString = typeof a2 === "string" ? a2 : JSON.stringify(Object.entries(a2).sort());
+  const bAsString = typeof b === "string" ? b : JSON.stringify(Object.entries(b).sort());
+  return aAsString === bAsString;
+}
+function simplifyLicenses(licenses2) {
+  var _a6, _b;
+  const { content: content3, code: code7 } = licenses2;
+  const simplified = {};
+  if (content3) {
+    if (content3.id) {
+      simplified.content = removeExpectedKeys(content3, (_a6 = ID_LICENSE_LOOKUP[content3.id]) !== null && _a6 !== void 0 ? _a6 : {});
+    } else {
+      simplified.content = { ...content3 };
+    }
+  }
+  if (code7) {
+    if (code7.id) {
+      simplified.code = removeExpectedKeys(code7, (_b = ID_LICENSE_LOOKUP[code7.id]) !== null && _b !== void 0 ? _b : {});
+    } else {
+      simplified.code = { ...code7 };
     }
-    stringLicenses.content = licenses2.content.id;
   }
-  if (licenses2.code) {
-    stringLicenses.code = licenses2.code.id;
+  if (objectsEqual(simplified.content, simplified.code)) {
+    delete simplified.code;
   }
-  return stringLicenses;
+  if (!simplified.code && typeof simplified.content === "string") {
+    return simplified.content;
+  }
+  return simplified;
 }
 
 // ../myst-frontmatter/dist/numbering/validators.js
@@ -198397,7 +198462,20 @@ function validateVenue(input3, opts) {
   } else {
     titleOpts = incrementOptions("title", opts);
   }
-  const value = validateObjectKeys(input3, { optional: ["title", "short_title", "url", "doi"] }, opts);
+  const value = validateObjectKeys(input3, {
+    optional: [
+      "title",
+      "short_title",
+      "url",
+      "doi",
+      "number",
+      "location",
+      "date",
+      "series",
+      "issn",
+      "publisher"
+    ]
+  }, opts);
   if (value === void 0)
     return void 0;
   const output2 = {};
@@ -198413,6 +198491,24 @@ function validateVenue(input3, opts) {
   if (defined(value.doi)) {
     output2.doi = validateDoi(value.doi, incrementOptions("doi", opts));
   }
+  if (defined(value.number)) {
+    output2.number = validateStringOrNumber(value.number, incrementOptions("number", opts));
+  }
+  if (defined(value.location)) {
+    output2.location = validateString(value.location, incrementOptions("location", opts));
+  }
+  if (defined(value.date)) {
+    output2.date = validateString(value.date, incrementOptions("date", opts));
+  }
+  if (defined(value.series)) {
+    output2.series = validateString(value.series, incrementOptions("series", opts));
+  }
+  if (defined(value.issn)) {
+    output2.issn = validateString(value.issn, incrementOptions("issn", opts));
+  }
+  if (defined(value.publisher)) {
+    output2.publisher = validateString(value.publisher, incrementOptions("publisher", opts));
+  }
   return output2;
 }
 
@@ -198807,8 +198903,17 @@ function validateProjectAndPageFrontmatterKeys(value, opts) {
       return validateString(req, incrementOptions(`bibliography.${index4}`, opts));
     });
   }
-  if (defined(value.biblio)) {
-    output2.biblio = validateBiblio(value.biblio, incrementOptions("biblio", opts));
+  if (defined(value.volume)) {
+    output2.volume = validatePublicationMeta(value.volume, incrementOptions("volume", opts));
+  }
+  if (defined(value.issue)) {
+    output2.issue = validatePublicationMeta(value.issue, incrementOptions("issue", opts));
+  }
+  if (defined(value.first_page)) {
+    output2.first_page = validateStringOrNumber(value.first_page, incrementOptions("first_page", opts));
+  }
+  if (defined(value.last_page)) {
+    output2.last_page = validateStringOrNumber(value.last_page, incrementOptions("last_page", opts));
   }
   if (defined(value.oxa)) {
     output2.oxa = validateString(value.oxa, incrementOptions("oxa", opts));
@@ -198952,7 +199057,10 @@ var USE_PROJECT_FALLBACK = [
   "source",
   "subject",
   "venue",
-  "biblio",
+  "volume",
+  "issue",
+  "first_page",
+  "last_page",
   "numbering",
   "keywords",
   "funding",
@@ -199114,7 +199222,7 @@ function fillSiteFrontmatter(base5, filler, opts, keys2, trimUnused) {
   return frontmatter;
 }
 function fillProjectFrontmatter(base5, filler, opts, keys2, trimUnused) {
-  var _a6, _b, _c, _d2, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x2, _y, _z, _0, _1;
+  var _a6, _b, _c, _d2, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x2, _y, _z;
   const frontmatter = fillSiteFrontmatter(base5, filler, opts, keys2 !== null && keys2 !== void 0 ? keys2 : Object.keys(filler), trimUnused);
   if (filler.numbering || base5.numbering) {
     frontmatter.numbering = fillNumbering(base5.numbering, filler.numbering);
@@ -199134,44 +199242,38 @@ function fillProjectFrontmatter(base5, filler, opts, keys2, trimUnused) {
       ...(_f = base5.settings) !== null && _f !== void 0 ? _f : {}
     };
   }
-  if (filler.biblio || base5.biblio) {
-    frontmatter.biblio = {
-      ...(_g = filler.biblio) !== null && _g !== void 0 ? _g : {},
-      ...(_h = base5.biblio) !== null && _h !== void 0 ? _h : {}
-    };
-  }
   if (!trimUnused) {
     if (filler.bibliography || base5.bibliography) {
       frontmatter.bibliography = [
-        .../* @__PURE__ */ new Set([...(_j = filler.bibliography) !== null && _j !== void 0 ? _j : [], ...(_k = base5.bibliography) !== null && _k !== void 0 ? _k : []])
+        .../* @__PURE__ */ new Set([...(_g = filler.bibliography) !== null && _g !== void 0 ? _g : [], ...(_h = base5.bibliography) !== null && _h !== void 0 ? _h : []])
       ];
     }
     if (filler.requirements || base5.requirements) {
       frontmatter.requirements = [
-        .../* @__PURE__ */ new Set([...(_l = filler.requirements) !== null && _l !== void 0 ? _l : [], ...(_m = base5.requirements) !== null && _m !== void 0 ? _m : []])
+        .../* @__PURE__ */ new Set([...(_j = filler.requirements) !== null && _j !== void 0 ? _j : [], ...(_k = base5.requirements) !== null && _k !== void 0 ? _k : []])
       ];
     }
     if (filler.resources || base5.resources) {
       frontmatter.resources = [
-        .../* @__PURE__ */ new Set([...(_o = filler.resources) !== null && _o !== void 0 ? _o : [], ...(_p = base5.resources) !== null && _p !== void 0 ? _p : []])
+        .../* @__PURE__ */ new Set([...(_l = filler.resources) !== null && _l !== void 0 ? _l : [], ...(_m = base5.resources) !== null && _m !== void 0 ? _m : []])
       ];
     }
     if (filler.exports || base5.exports) {
       frontmatter.exports = [];
-      const ids = (_r = (_q = base5.exports) === null || _q === void 0 ? void 0 : _q.map(({ id }) => id)) !== null && _r !== void 0 ? _r : [];
-      (_s = filler.exports) === null || _s === void 0 ? void 0 : _s.forEach((exp) => {
+      const ids = (_p = (_o = base5.exports) === null || _o === void 0 ? void 0 : _o.map(({ id }) => id)) !== null && _p !== void 0 ? _p : [];
+      (_q = filler.exports) === null || _q === void 0 ? void 0 : _q.forEach((exp) => {
         var _a7;
         if (!exp.id || !ids.includes(exp.id)) {
           (_a7 = frontmatter.exports) === null || _a7 === void 0 ? void 0 : _a7.push(exp);
         }
       });
-      (_t = frontmatter.exports) === null || _t === void 0 ? void 0 : _t.push(...(_u = base5.exports) !== null && _u !== void 0 ? _u : []);
+      (_r = frontmatter.exports) === null || _r === void 0 ? void 0 : _r.push(...(_s = base5.exports) !== null && _s !== void 0 ? _s : []);
     }
     if (filler.downloads || base5.downloads) {
       frontmatter.downloads = [];
-      const ids = (_w = (_v = base5.downloads) === null || _v === void 0 ? void 0 : _v.map(({ id }) => id).filter(Boolean)) !== null && _w !== void 0 ? _w : [];
-      const urls = (_y = (_x2 = base5.downloads) === null || _x2 === void 0 ? void 0 : _x2.map(({ url }) => url).filter(Boolean)) !== null && _y !== void 0 ? _y : [];
-      (_z = filler.downloads) === null || _z === void 0 ? void 0 : _z.forEach((download) => {
+      const ids = (_u = (_t = base5.downloads) === null || _t === void 0 ? void 0 : _t.map(({ id }) => id).filter(Boolean)) !== null && _u !== void 0 ? _u : [];
+      const urls = (_w = (_v = base5.downloads) === null || _v === void 0 ? void 0 : _v.map(({ url }) => url).filter(Boolean)) !== null && _w !== void 0 ? _w : [];
+      (_x2 = filler.downloads) === null || _x2 === void 0 ? void 0 : _x2.forEach((download) => {
         var _a7, _b2;
         if (download.id && !ids.includes(download.id)) {
           (_a7 = frontmatter.downloads) === null || _a7 === void 0 ? void 0 : _a7.push(download);
@@ -199180,7 +199282,7 @@ function fillProjectFrontmatter(base5, filler, opts, keys2, trimUnused) {
           (_b2 = frontmatter.downloads) === null || _b2 === void 0 ? void 0 : _b2.push(download);
         }
       });
-      (_0 = frontmatter.downloads) === null || _0 === void 0 ? void 0 : _0.push(...(_1 = base5.downloads) !== null && _1 !== void 0 ? _1 : []);
+      (_y = frontmatter.downloads) === null || _y === void 0 ? void 0 : _y.push(...(_z = base5.downloads) !== null && _z !== void 0 ? _z : []);
     }
   }
   return frontmatter;
@@ -202508,7 +202610,7 @@ function tic() {
 }
 
 // ../myst-cli-utils/dist/isUrl.js
-function isUrl(url) {
+function isUrl2(url) {
   if (!url)
     return false;
   try {
@@ -204404,7 +204506,7 @@ var import_process = __toESM(require("process"), 1);
 var import_url = require("url");
 
 // ../../node_modules/vfile/lib/minurl.shared.js
-function isUrl2(fileUrlOrPath) {
+function isUrl3(fileUrlOrPath) {
   return fileUrlOrPath !== null && typeof fileUrlOrPath === "object" && // @ts-expect-error: indexable.
   fileUrlOrPath.href && // @ts-expect-error: indexable.
   fileUrlOrPath.origin;
@@ -204441,7 +204543,7 @@ var VFile = class {
       options = {};
     } else if (typeof value === "string" || buffer(value)) {
       options = { value };
-    } else if (isUrl2(value)) {
+    } else if (isUrl3(value)) {
       options = { path: value };
     } else {
       options = value;
@@ -204486,7 +204588,7 @@ var VFile = class {
    * @param {string | URL} path
    */
   set path(path41) {
-    if (isUrl2(path41)) {
+    if (isUrl3(path41)) {
       path41 = (0, import_url.fileURLToPath)(path41);
     }
     assertNonEmpty(path41, "path");
@@ -220584,7 +220686,7 @@ var import_node_process3 = __toESM(require("process"), 1);
 var import_node_url = require("url");
 
 // ../../node_modules/hast-util-from-html/node_modules/vfile/lib/minurl.shared.js
-function isUrl3(fileUrlOrPath) {
+function isUrl4(fileUrlOrPath) {
   return Boolean(
     fileUrlOrPath !== null && typeof fileUrlOrPath === "object" && "href" in fileUrlOrPath && fileUrlOrPath.href && "protocol" in fileUrlOrPath && fileUrlOrPath.protocol && // @ts-expect-error: indexing is fine.
     fileUrlOrPath.auth === void 0
@@ -220630,7 +220732,7 @@ var VFile2 = class {
     let options;
     if (!value) {
       options = {};
-    } else if (isUrl3(value)) {
+    } else if (isUrl4(value)) {
       options = { path: value };
     } else if (typeof value === "string" || isUint8Array(value)) {
       options = { value };
@@ -220764,7 +220866,7 @@ var VFile2 = class {
    *   Nothing.
    */
   set path(path41) {
-    if (isUrl3(path41)) {
+    if (isUrl4(path41)) {
       path41 = (0, import_node_url.fileURLToPath)(path41);
     }
     assertNonEmpty2(path41, "path");
@@ -238273,7 +238375,7 @@ function shouldEnumerate(node3, kind, numbering) {
     return (_d2 = (_c = numbering[`heading_${node3.depth}`]) === null || _c === void 0 ? void 0 : _c.enabled) !== null && _d2 !== void 0 ? _d2 : enabledDefault;
   }
   if (node3.subcontainer)
-    return (_f = !!((_e = numbering.subfigure) === null || _e === void 0 ? void 0 : _e.enabled)) !== null && _f !== void 0 ? _f : enabledDefault;
+    return (_f = (_e = numbering.subfigure) === null || _e === void 0 ? void 0 : _e.enabled) !== null && _f !== void 0 ? _f : enabledDefault;
   return (_h = (_g = numbering[kind]) === null || _g === void 0 ? void 0 : _g.enabled) !== null && _h !== void 0 ? _h : enabledDefault;
 }
 function incrementHeadingCounts2(depth, counts) {
@@ -241412,7 +241514,7 @@ function processPageFrontmatter(session, pageFrontmatter, validationOpts, path41
 function prepareToWrite(frontmatter) {
   if (!frontmatter.license)
     return { ...frontmatter };
-  return { ...frontmatter, license: licensesToString(frontmatter.license) };
+  return { ...frontmatter, license: simplifyLicenses(frontmatter.license) };
 }
 function getExportListFromRawFrontmatter(session, rawFrontmatter, file) {
   var _a6;
@@ -241494,8 +241596,33 @@ function configValidationOpts(vfile2, property, ruleId) {
 function fillSiteConfig(base5, filler, opts) {
   return fillSiteFrontmatter(base5, filler, opts, Object.keys(filler));
 }
-async function getValidatedConfigsFromFile(session, file, vfile2, stack) {
+function handleDeprecatedFields(conf, file, vfile2) {
   var _a6, _b, _c, _d2;
+  if ((_a6 = conf.site) === null || _a6 === void 0 ? void 0 : _a6.frontmatter) {
+    fileWarn(vfile2, `Frontmatter fields should be defined directly on site, not nested under "${file}#site.frontmatter"`, { ruleId: RuleId.configHasNoDeprecatedFields });
+    const { frontmatter, ...rest } = conf.site;
+    conf.site = { ...frontmatter, ...rest };
+  }
+  if ((_b = conf.project) === null || _b === void 0 ? void 0 : _b.frontmatter) {
+    fileWarn(vfile2, `Frontmatter fields should be defined directly on project, not nested under "${file}#project.frontmatter"`, { ruleId: RuleId.configHasNoDeprecatedFields });
+    const { frontmatter, ...rest } = conf.project;
+    conf.project = { ...frontmatter, ...rest };
+  }
+  if ((_c = conf.project) === null || _c === void 0 ? void 0 : _c.biblio) {
+    fileWarn(vfile2, `biblio is deprecated, please use first_page/last_page/volume/issue fields "${file}#project"`, { ruleId: RuleId.configHasNoDeprecatedFields });
+    const { biblio, ...rest } = conf.project;
+    conf.project = { ...biblio, ...rest };
+  }
+  if ((_d2 = conf.site) === null || _d2 === void 0 ? void 0 : _d2.logoText) {
+    fileWarn(vfile2, `logoText is deprecated, please use logo_text in "${file}#site"`, {
+      ruleId: RuleId.configHasNoDeprecatedFields
+    });
+    const { logoText, ...rest } = conf.site;
+    conf.site = { logo_text: logoText, ...rest };
+  }
+}
+async function getValidatedConfigsFromFile(session, file, vfile2, stack) {
+  var _a6;
   if (!vfile2) {
     vfile2 = new VFile();
     vfile2.path = file;
@@ -241513,31 +241640,15 @@ async function getValidatedConfigsFromFile(session, file, vfile2, stack) {
   if (!conf || opts.messages.errors) {
     throw Error(`Please address invalid config file ${file}`);
   }
-  if ((_a6 = conf.site) === null || _a6 === void 0 ? void 0 : _a6.frontmatter) {
-    fileWarn(vfile2, `Frontmatter fields should be defined directly on site, not nested under "${file}#site.frontmatter"`, { ruleId: RuleId.configHasNoDeprecatedFields });
-    const { frontmatter, ...rest } = conf.site;
-    conf.site = { ...frontmatter, ...rest };
-  }
-  if ((_b = conf.project) === null || _b === void 0 ? void 0 : _b.frontmatter) {
-    fileWarn(vfile2, `Frontmatter fields should be defined directly on project, not nested under "${file}#project.frontmatter"`, { ruleId: RuleId.configHasNoDeprecatedFields });
-    const { frontmatter, ...rest } = conf.project;
-    conf.project = { ...frontmatter, ...rest };
-  }
-  if ((_c = conf.site) === null || _c === void 0 ? void 0 : _c.logoText) {
-    fileWarn(vfile2, `logoText is deprecated, please use logo_text in "${file}#site"`, {
-      ruleId: RuleId.configHasNoDeprecatedFields
-    });
-    const { logoText, ...rest } = conf.site;
-    conf.site = { logo_text: logoText, ...rest };
-  }
+  handleDeprecatedFields(conf, file, vfile2);
   let site;
   let project;
   const projectOpts = configValidationOpts(vfile2, "config.project", RuleId.validProjectConfig);
   let extend5;
   if (conf.extend) {
-    extend5 = await Promise.all(((_d2 = validateList(conf.extend, { coerce: true, ...incrementOptions("extend", opts) }, (item, index4) => {
+    extend5 = await Promise.all(((_a6 = validateList(conf.extend, { coerce: true, ...incrementOptions("extend", opts) }, (item, index4) => {
       return validateString(item, incrementOptions(`extend.${index4}`, opts));
-    })) !== null && _d2 !== void 0 ? _d2 : []).map(async (extendFile) => {
+    })) !== null && _a6 !== void 0 ? _a6 : []).map(async (extendFile) => {
       const resolvedFile = await resolveToAbsolute(session, (0, import_node_path8.dirname)(file), extendFile, {
         allowRemote: true
       });
@@ -241612,7 +241723,7 @@ async function loadConfig(session, path41, opts) {
 }
 async function resolveToAbsolute(session, basePath, relativePath, opts) {
   let message;
-  if ((opts === null || opts === void 0 ? void 0 : opts.allowRemote) && isUrl(relativePath)) {
+  if ((opts === null || opts === void 0 ? void 0 : opts.allowRemote) && isUrl2(relativePath)) {
     const cacheFilename = `config-item-${computeHash(relativePath)}${(0, import_node_path8.extname)(new URL(relativePath).pathname)}`;
     if (!loadFromCache(session, cacheFilename, { maxAge: 30 })) {
       try {
@@ -242082,7 +242193,7 @@ function getCitationRenderers(data) {
 async function loadBibTeXCitationRenderers(session, path41) {
   const toc = tic();
   let data;
-  if (isUrl(path41)) {
+  if (isUrl2(path41)) {
     session.log.debug(`Fetching citations at "${path41}"`);
     const res = await session.fetch(path41);
     if (!res.ok) {
@@ -242096,7 +242207,7 @@ async function loadBibTeXCitationRenderers(session, path41) {
   }
   const csl = parseBibTeX(data);
   const renderer = getCitationRenderers(csl);
-  session.log.debug(toc(`Read ${plural("%s citations(s)", renderer)} from ${path41} in %s.`));
+  session.log.debug(toc(`Read ${plural("%s citation(s)", renderer)} from ${path41} in %s.`));
   return renderer;
 }
 function combineCitationRenderers(cache, ...files) {
@@ -289112,7 +289223,7 @@ var import_node_path15 = __toESM(require("path"), 1);
 var import_nbtx = __toESM(require_cjs2(), 1);
 
 // ../myst-cli/dist/version.js
-var version2 = "1.3.11";
+var version2 = "1.3.12";
 var version_default2 = version2;
 
 // ../myst-cli/dist/utils/headers.js
@@ -289740,7 +289851,7 @@ async function saveImageInStaticFolder(session, urlSource, sourceFile, writeFold
   const sourceFileFolder = import_node_path15.default.dirname(sourceFile);
   const imageLocalFile = import_node_path15.default.join(sourceFileFolder, urlSource);
   let file;
-  if (isUrl(urlSource)) {
+  if (isUrl2(urlSource)) {
     file = await downloadAndSaveImage(session, urlSource, computeHash(urlSource), writeFolder);
   } else if (import_node_fs11.default.existsSync(imageLocalFile)) {
     if (import_node_path15.default.resolve(import_node_path15.default.dirname(imageLocalFile)) === import_node_path15.default.resolve(writeFolder)) {
@@ -297417,7 +297528,7 @@ Consider running "${binaryName()} init --project" in that directory`, "warn", {
     bibliography2 = projectConfig.bibliography.filter((bib) => {
       if (allBibFiles.includes(bib))
         return true;
-      if (isUrl(bib))
+      if (isUrl2(bib))
         return true;
       if (import_node_fs16.default.existsSync(bib)) {
         allBibFiles.push(bib);
@@ -298451,9 +298562,6 @@ var getNodeRequestOptions = (request) => {
   if (typeof agent === "function") {
     agent = agent(parsedURL);
   }
-  if (!headers.has("Connection") && !agent) {
-    headers.set("Connection", "close");
-  }
   const search4 = getSearch(parsedURL);
   const options = {
     // Overwrite search to retain trailing ? (issue #776)
@@ -298745,7 +298853,7 @@ function fixResponseChunkedTransferBadEnding(request, errorCallback) {
 }
 
 // ../../node_modules/intersphinx/node_modules/myst-cli-utils/dist/isUrl.js
-function isUrl4(url) {
+function isUrl5(url) {
   if (!url)
     return false;
   try {
@@ -298772,7 +298880,7 @@ var Inventory = class {
       this.project = opts === null || opts === void 0 ? void 0 : opts.project;
     if (opts === null || opts === void 0 ? void 0 : opts.version)
       this.version = opts === null || opts === void 0 ? void 0 : opts.version;
-    if ((opts === null || opts === void 0 ? void 0 : opts.path) && isUrl4(opts === null || opts === void 0 ? void 0 : opts.path)) {
+    if ((opts === null || opts === void 0 ? void 0 : opts.path) && isUrl5(opts === null || opts === void 0 ? void 0 : opts.path)) {
       this.path = opts === null || opts === void 0 ? void 0 : opts.path.replace(/\/$/, "");
       if (this.path.endsWith(".inv") && !(opts === null || opts === void 0 ? void 0 : opts.invName)) {
         const parts = this.path.split("/");
@@ -298814,7 +298922,7 @@ ${data.toString("binary")}`, { encoding: "binary" });
     if (!this.path) {
       throw new Error("Inventory path must be specified to load an object");
     }
-    if (isUrl4(this.path)) {
+    if (isUrl5(this.path)) {
       const url = `${this.path}/${this.invName}`;
       const res = await fetch2(url);
       if (!res.ok) {
@@ -299235,7 +299343,7 @@ function validateFile(session, input3, opts) {
   const filename = validateString(input3, opts);
   if (!filename)
     return;
-  if (opts.allowRemote && isUrl(filename))
+  if (opts.allowRemote && isUrl2(filename))
     return filename;
   let resolvedFile;
   if (opts.file) {
@@ -300445,7 +300553,7 @@ async function resolveTemplateFileOptions(session, mystTemplate, options) {
 function isInternalUrl(value) {
   return !!value.match("^(/[a-zA-Z0-9._-]+)+$");
 }
-function isUrl5(value) {
+function isUrl6(value) {
   if (isInternalUrl(value))
     return true;
   try {
@@ -300478,7 +300586,7 @@ function resolveSiteAction(session, action, file, property) {
       addWarningForFile(session, file, `Could not find static resource at "${action.url}" in ${property}`, "error", { ruleId: RuleId.staticActionFileCopied });
       return void 0;
     }
-    if (!isUrl5(action.url)) {
+    if (!isUrl6(action.url)) {
       addWarningForFile(session, file, `Resource "${action.url}" in ${property} should be a URL or path to static file`, "error");
       return void 0;
     }
@@ -300495,7 +300603,7 @@ function resolveSiteAction(session, action, file, property) {
       static: false
     };
   }
-  if (!action.static && isUrl5(action.url)) {
+  if (!action.static && isUrl6(action.url)) {
     addWarningForFile(session, file, `Linking resource "${action.url}" in ${property} to static file; to mark this as a URL instead, use 'static: false'`);
   }
   const fileHash = hashAndCopyStaticFile(session, resolvedFile, session.publicPath(), (m2) => {
@@ -300902,7 +301010,7 @@ ${error === null || error === void 0 ? void 0 : error.stack}
     }
     reference.kind = "intersphinx";
     reference.value = inventory;
-    if (inventory.id && inventory.path && isUrl(inventory.path)) {
+    if (inventory.id && inventory.path && isUrl2(inventory.path)) {
       const intersphinxPath = cachePath(session, inventoryCacheFilename("intersphinx", inventory.id, inventory.path));
       if (!import_node_fs25.default.existsSync(intersphinxPath)) {
         session.log.debug(`Saving remote inventory file to cache: ${inventory.path}`);
@@ -306916,6 +307024,12 @@ ${node3.value}
   legend: captionHandler2,
   captionNumber: () => void 0,
   crossReference(node3, state, parent2) {
+    var _a6, _b;
+    if (node3.remote) {
+      const url = ((_a6 = node3.remoteBaseUrl) !== null && _a6 !== void 0 ? _a6 : "") + (node3.url === "/" ? "" : (_b = node3.url) !== null && _b !== void 0 ? _b : "") + (node3.html_id ? `#${node3.html_id}` : "");
+      linkHandler({ ...node3, url }, state);
+      return;
+    }
     const id = node3.identifier;
     const next = nextCharacterIsText(parent2, node3);
     state.write(next ? `#[@${id}]` : `@${id}`);
@@ -309259,17 +309373,16 @@ function getFundingGroup(frontmatter) {
 }
 function getArticleVolume(frontmatter) {
   var _a6;
-  const text7 = (_a6 = frontmatter.biblio) === null || _a6 === void 0 ? void 0 : _a6.volume;
+  const text7 = (_a6 = frontmatter.volume) === null || _a6 === void 0 ? void 0 : _a6.number;
   return text7 ? [{ type: "element", name: "volume", elements: [{ type: "text", text: `${text7}` }] }] : [];
 }
 function getArticleIssue(frontmatter) {
   var _a6;
-  const text7 = (_a6 = frontmatter.biblio) === null || _a6 === void 0 ? void 0 : _a6.issue;
+  const text7 = (_a6 = frontmatter.issue) === null || _a6 === void 0 ? void 0 : _a6.number;
   return text7 ? [{ type: "element", name: "issue", elements: [{ type: "text", text: `${text7}` }] }] : [];
 }
 function getArticlePages(frontmatter) {
-  var _a6;
-  const { first_page, last_page } = (_a6 = frontmatter.biblio) !== null && _a6 !== void 0 ? _a6 : {};
+  const { first_page, last_page } = frontmatter !== null && frontmatter !== void 0 ? frontmatter : {};
   const pages = [];
   if (first_page) {
     pages.push({
@@ -315052,7 +315165,7 @@ function runValidators(tree, validators, file) {
 function addFrontmatter(page, frontmatter) {
   if (!frontmatter || !Object.keys(frontmatter).length)
     return page;
-  const fm = frontmatter.license ? { ...frontmatter, license: licensesToString(frontmatter.license) } : { ...frontmatter };
+  const fm = frontmatter.license ? { ...frontmatter, license: simplifyLicenses(frontmatter.license) } : { ...frontmatter };
   return `---
 ${js_yaml_default.dump(fm)}---
 ${page}`;