@blockbite/ui 1.0.4 → 2.0.0

package/dist/node_modules/postcss/lib/input.js

@@ -0,0 +1,133 @@
+import { n as v } from "../../nanoid/non-secure/index.js";
+import c from "../../../_virtual/___vite-browser-external.js";
+import { c as F } from "./css-syntax-error.js";
+import { p as y } from "./previous-map.js";
+let { nanoid: O } = v, { isAbsolute: g, resolve: S } = c, { SourceMapConsumer: L, SourceMapGenerator: M } = c, { fileURLToPath: C, pathToFileURL: m } = c, b = F, x = y, p = c, d = Symbol("fromOffsetCache"), R = !!(L && M), w = !!(S && g);
+class a {
+  get from() {
+    return this.file || this.id;
+  }
+  constructor(t, e = {}) {
+    if (t === null || typeof t > "u" || typeof t == "object" && !t.toString)
+      throw new Error(`PostCSS received ${t} instead of CSS string`);
+    if (this.css = t.toString(), this.css[0] === "\uFEFF" || this.css[0] === "￾" ? (this.hasBOM = !0, this.css = this.css.slice(1)) : this.hasBOM = !1, this.document = this.css, e.document && (this.document = e.document.toString()), e.from && (!w || /^\w+:\/\//.test(e.from) || g(e.from) ? this.file = e.from : this.file = S(e.from)), w && R) {
+      let i = new x(this.css, e);
+      if (i.text) {
+        this.map = i;
+        let n = i.consumer().file;
+        !this.file && n && (this.file = this.mapResolve(n));
+      }
+    }
+    this.file || (this.id = "<input css " + O(6) + ">"), this.map && (this.map.file = this.from);
+  }
+  error(t, e, i, n = {}) {
+    let o, s, l;
+    if (e && typeof e == "object") {
+      let f = e, u = i;
+      if (typeof f.offset == "number") {
+        let h = this.fromOffset(f.offset);
+        e = h.line, i = h.col;
+      } else
+        e = f.line, i = f.column;
+      if (typeof u.offset == "number") {
+        let h = this.fromOffset(u.offset);
+        s = h.line, o = h.col;
+      } else
+        s = u.line, o = u.column;
+    } else if (!i) {
+      let f = this.fromOffset(e);
+      e = f.line, i = f.col;
+    }
+    let r = this.origin(e, i, s, o);
+    return r ? l = new b(
+      t,
+      r.endLine === void 0 ? r.line : { column: r.column, line: r.line },
+      r.endLine === void 0 ? r.column : { column: r.endColumn, line: r.endLine },
+      r.source,
+      r.file,
+      n.plugin
+    ) : l = new b(
+      t,
+      s === void 0 ? e : { column: i, line: e },
+      s === void 0 ? i : { column: o, line: s },
+      this.css,
+      this.file,
+      n.plugin
+    ), l.input = { column: i, endColumn: o, endLine: s, line: e, source: this.css }, this.file && (m && (l.input.url = m(this.file).toString()), l.input.file = this.file), l;
+  }
+  fromOffset(t) {
+    let e, i;
+    if (this[d])
+      i = this[d];
+    else {
+      let o = this.css.split(`
+`);
+      i = new Array(o.length);
+      let s = 0;
+      for (let l = 0, r = o.length; l < r; l++)
+        i[l] = s, s += o[l].length + 1;
+      this[d] = i;
+    }
+    e = i[i.length - 1];
+    let n = 0;
+    if (t >= e)
+      n = i.length - 1;
+    else {
+      let o = i.length - 2, s;
+      for (; n < o; )
+        if (s = n + (o - n >> 1), t < i[s])
+          o = s - 1;
+        else if (t >= i[s + 1])
+          n = s + 1;
+        else {
+          n = s;
+          break;
+        }
+    }
+    return {
+      col: t - i[n] + 1,
+      line: n + 1
+    };
+  }
+  mapResolve(t) {
+    return /^\w+:\/\//.test(t) ? t : S(this.map.consumer().sourceRoot || this.map.root || ".", t);
+  }
+  origin(t, e, i, n) {
+    if (!this.map) return !1;
+    let o = this.map.consumer(), s = o.originalPositionFor({ column: e, line: t });
+    if (!s.source) return !1;
+    let l;
+    typeof i == "number" && (l = o.originalPositionFor({ column: n, line: i }));
+    let r;
+    g(s.source) ? r = m(s.source) : r = new URL(
+      s.source,
+      this.map.consumer().sourceRoot || m(this.map.mapFile)
+    );
+    let f = {
+      column: s.column,
+      endColumn: l && l.column,
+      endLine: l && l.line,
+      line: s.line,
+      url: r.toString()
+    };
+    if (r.protocol === "file:")
+      if (C)
+        f.file = C(r);
+      else
+        throw new Error("file: protocol is not available in this PostCSS build");
+    let u = o.sourceContentFor(s.source);
+    return u && (f.source = u), f;
+  }
+  toJSON() {
+    let t = {};
+    for (let e of ["hasBOM", "css", "file", "id"])
+      this[e] != null && (t[e] = this[e]);
+    return this.map && (t.map = { ...this.map }, t.map.consumerCache && (t.map.consumerCache = void 0)), t;
+  }
+}
+var U = a;
+a.default = a;
+p && p.registerInput && p.registerInput(a);
+export {
+  U as i
+};

package/dist/node_modules/postcss/lib/lazy-result.js

@@ -0,0 +1,346 @@
+import { c as w } from "./container.js";
+import { d as E } from "./document.js";
+import { m as v } from "./map-generator.js";
+import { p as x } from "./parse.js";
+import { r as S } from "./result.js";
+import { r as P } from "./root.js";
+import { s as O } from "./stringify.js";
+import "./symbols.js";
+import { w as R } from "./warn-once.js";
+import { __exports as I } from "../../../_virtual/symbols.js";
+let C = w, b = E, A = v, D = x, m = S, L = P, V = O, { isClean: l, my: _ } = I, k = R;
+const N = {
+  atrule: "AtRule",
+  comment: "Comment",
+  decl: "Declaration",
+  document: "Document",
+  root: "Root",
+  rule: "Rule"
+}, T = {
+  AtRule: !0,
+  AtRuleExit: !0,
+  Comment: !0,
+  CommentExit: !0,
+  Declaration: !0,
+  DeclarationExit: !0,
+  Document: !0,
+  DocumentExit: !0,
+  Once: !0,
+  OnceExit: !0,
+  postcssPlugin: !0,
+  prepare: !0,
+  Root: !0,
+  RootExit: !0,
+  Rule: !0,
+  RuleExit: !0
+}, j = {
+  Once: !0,
+  postcssPlugin: !0,
+  prepare: !0
+}, a = 0;
+function f(o) {
+  return typeof o == "object" && typeof o.then == "function";
+}
+function d(o) {
+  let e = !1, t = N[o.type];
+  return o.type === "decl" ? e = o.prop.toLowerCase() : o.type === "atrule" && (e = o.name.toLowerCase()), e && o.append ? [
+    t,
+    t + "-" + e,
+    a,
+    t + "Exit",
+    t + "Exit-" + e
+  ] : e ? [t, t + "-" + e, t + "Exit", t + "Exit-" + e] : o.append ? [t, a, t + "Exit"] : [t, t + "Exit"];
+}
+function g(o) {
+  let e;
+  return o.type === "document" ? e = ["Document", a, "DocumentExit"] : o.type === "root" ? e = ["Root", a, "RootExit"] : e = d(o), {
+    eventIndex: 0,
+    events: e,
+    iterator: 0,
+    node: o,
+    visitorIndex: 0,
+    visitors: []
+  };
+}
+function c(o) {
+  return o[l] = !1, o.nodes && o.nodes.forEach((e) => c(e)), o;
+}
+let y = {};
+class u {
+  get content() {
+    return this.stringify().content;
+  }
+  get css() {
+    return this.stringify().css;
+  }
+  get map() {
+    return this.stringify().map;
+  }
+  get messages() {
+    return this.sync().messages;
+  }
+  get opts() {
+    return this.result.opts;
+  }
+  get processor() {
+    return this.result.processor;
+  }
+  get root() {
+    return this.sync().root;
+  }
+  get [Symbol.toStringTag]() {
+    return "LazyResult";
+  }
+  constructor(e, t, r) {
+    this.stringified = !1, this.processed = !1;
+    let s;
+    if (typeof t == "object" && t !== null && (t.type === "root" || t.type === "document"))
+      s = c(t);
+    else if (t instanceof u || t instanceof m)
+      s = c(t.root), t.map && (typeof r.map > "u" && (r.map = {}), r.map.inline || (r.map.inline = !1), r.map.prev = t.map);
+    else {
+      let i = D;
+      r.syntax && (i = r.syntax.parse), r.parser && (i = r.parser), i.parse && (i = i.parse);
+      try {
+        s = i(t, r);
+      } catch (n) {
+        this.processed = !0, this.error = n;
+      }
+      s && !s[_] && C.rebuild(s);
+    }
+    this.result = new m(e, s, r), this.helpers = { ...y, postcss: y, result: this.result }, this.plugins = this.processor.plugins.map((i) => typeof i == "object" && i.prepare ? { ...i, ...i.prepare(this.result) } : i);
+  }
+  async() {
+    return this.error ? Promise.reject(this.error) : this.processed ? Promise.resolve(this.result) : (this.processing || (this.processing = this.runAsync()), this.processing);
+  }
+  catch(e) {
+    return this.async().catch(e);
+  }
+  finally(e) {
+    return this.async().then(e, e);
+  }
+  getAsyncError() {
+    throw new Error("Use process(css).then(cb) to work with async plugins");
+  }
+  handleError(e, t) {
+    let r = this.result.lastPlugin;
+    try {
+      if (t && t.addToError(e), this.error = e, e.name === "CssSyntaxError" && !e.plugin)
+        e.plugin = r.postcssPlugin, e.setMessage();
+      else if (r.postcssVersion && process.env.NODE_ENV !== "production") {
+        let s = r.postcssPlugin, i = r.postcssVersion, n = this.result.processor.version, h = i.split("."), p = n.split(".");
+        (h[0] !== p[0] || parseInt(h[1]) > parseInt(p[1])) && console.error(
+          "Unknown error from PostCSS plugin. Your current PostCSS version is " + n + ", but " + s + " uses " + i + ". Perhaps this is the source of the error below."
+        );
+      }
+    } catch (s) {
+      console && console.error && console.error(s);
+    }
+    return e;
+  }
+  prepareVisitors() {
+    this.listeners = {};
+    let e = (t, r, s) => {
+      this.listeners[r] || (this.listeners[r] = []), this.listeners[r].push([t, s]);
+    };
+    for (let t of this.plugins)
+      if (typeof t == "object")
+        for (let r in t) {
+          if (!T[r] && /^[A-Z]/.test(r))
+            throw new Error(
+              `Unknown event ${r} in ${t.postcssPlugin}. Try to update PostCSS (${this.processor.version} now).`
+            );
+          if (!j[r])
+            if (typeof t[r] == "object")
+              for (let s in t[r])
+                s === "*" ? e(t, r, t[r][s]) : e(
+                  t,
+                  r + "-" + s.toLowerCase(),
+                  t[r][s]
+                );
+            else typeof t[r] == "function" && e(t, r, t[r]);
+        }
+    this.hasListener = Object.keys(this.listeners).length > 0;
+  }
+  async runAsync() {
+    this.plugin = 0;
+    for (let e = 0; e < this.plugins.length; e++) {
+      let t = this.plugins[e], r = this.runOnRoot(t);
+      if (f(r))
+        try {
+          await r;
+        } catch (s) {
+          throw this.handleError(s);
+        }
+    }
+    if (this.prepareVisitors(), this.hasListener) {
+      let e = this.result.root;
+      for (; !e[l]; ) {
+        e[l] = !0;
+        let t = [g(e)];
+        for (; t.length > 0; ) {
+          let r = this.visitTick(t);
+          if (f(r))
+            try {
+              await r;
+            } catch (s) {
+              let i = t[t.length - 1].node;
+              throw this.handleError(s, i);
+            }
+        }
+      }
+      if (this.listeners.OnceExit)
+        for (let [t, r] of this.listeners.OnceExit) {
+          this.result.lastPlugin = t;
+          try {
+            if (e.type === "document") {
+              let s = e.nodes.map(
+                (i) => r(i, this.helpers)
+              );
+              await Promise.all(s);
+            } else
+              await r(e, this.helpers);
+          } catch (s) {
+            throw this.handleError(s);
+          }
+        }
+    }
+    return this.processed = !0, this.stringify();
+  }
+  runOnRoot(e) {
+    this.result.lastPlugin = e;
+    try {
+      if (typeof e == "object" && e.Once) {
+        if (this.result.root.type === "document") {
+          let t = this.result.root.nodes.map(
+            (r) => e.Once(r, this.helpers)
+          );
+          return f(t[0]) ? Promise.all(t) : t;
+        }
+        return e.Once(this.result.root, this.helpers);
+      } else if (typeof e == "function")
+        return e(this.result.root, this.result);
+    } catch (t) {
+      throw this.handleError(t);
+    }
+  }
+  stringify() {
+    if (this.error) throw this.error;
+    if (this.stringified) return this.result;
+    this.stringified = !0, this.sync();
+    let e = this.result.opts, t = V;
+    e.syntax && (t = e.syntax.stringify), e.stringifier && (t = e.stringifier), t.stringify && (t = t.stringify);
+    let s = new A(t, this.result.root, this.result.opts).generate();
+    return this.result.css = s[0], this.result.map = s[1], this.result;
+  }
+  sync() {
+    if (this.error) throw this.error;
+    if (this.processed) return this.result;
+    if (this.processed = !0, this.processing)
+      throw this.getAsyncError();
+    for (let e of this.plugins) {
+      let t = this.runOnRoot(e);
+      if (f(t))
+        throw this.getAsyncError();
+    }
+    if (this.prepareVisitors(), this.hasListener) {
+      let e = this.result.root;
+      for (; !e[l]; )
+        e[l] = !0, this.walkSync(e);
+      if (this.listeners.OnceExit)
+        if (e.type === "document")
+          for (let t of e.nodes)
+            this.visitSync(this.listeners.OnceExit, t);
+        else
+          this.visitSync(this.listeners.OnceExit, e);
+    }
+    return this.result;
+  }
+  then(e, t) {
+    return process.env.NODE_ENV !== "production" && ("from" in this.opts || k(
+      "Without `from` option PostCSS could generate wrong source map and will not find Browserslist config. Set it to CSS file path or to `undefined` to prevent this warning."
+    )), this.async().then(e, t);
+  }
+  toString() {
+    return this.css;
+  }
+  visitSync(e, t) {
+    for (let [r, s] of e) {
+      this.result.lastPlugin = r;
+      let i;
+      try {
+        i = s(t, this.helpers);
+      } catch (n) {
+        throw this.handleError(n, t.proxyOf);
+      }
+      if (t.type !== "root" && t.type !== "document" && !t.parent)
+        return !0;
+      if (f(i))
+        throw this.getAsyncError();
+    }
+  }
+  visitTick(e) {
+    let t = e[e.length - 1], { node: r, visitors: s } = t;
+    if (r.type !== "root" && r.type !== "document" && !r.parent) {
+      e.pop();
+      return;
+    }
+    if (s.length > 0 && t.visitorIndex < s.length) {
+      let [n, h] = s[t.visitorIndex];
+      t.visitorIndex += 1, t.visitorIndex === s.length && (t.visitors = [], t.visitorIndex = 0), this.result.lastPlugin = n;
+      try {
+        return h(r.toProxy(), this.helpers);
+      } catch (p) {
+        throw this.handleError(p, r);
+      }
+    }
+    if (t.iterator !== 0) {
+      let n = t.iterator, h;
+      for (; h = r.nodes[r.indexes[n]]; )
+        if (r.indexes[n] += 1, !h[l]) {
+          h[l] = !0, e.push(g(h));
+          return;
+        }
+      t.iterator = 0, delete r.indexes[n];
+    }
+    let i = t.events;
+    for (; t.eventIndex < i.length; ) {
+      let n = i[t.eventIndex];
+      if (t.eventIndex += 1, n === a) {
+        r.nodes && r.nodes.length && (r[l] = !0, t.iterator = r.getIterator());
+        return;
+      } else if (this.listeners[n]) {
+        t.visitors = this.listeners[n];
+        return;
+      }
+    }
+    e.pop();
+  }
+  walkSync(e) {
+    e[l] = !0;
+    let t = d(e);
+    for (let r of t)
+      if (r === a)
+        e.nodes && e.each((s) => {
+          s[l] || this.walkSync(s);
+        });
+      else {
+        let s = this.listeners[r];
+        if (s && this.visitSync(s, e.toProxy()))
+          return;
+      }
+  }
+  warnings() {
+    return this.sync().warnings();
+  }
+}
+u.registerPostcss = (o) => {
+  y = o;
+};
+var q = u;
+u.default = u;
+L.registerLazyResult(u);
+b.registerLazyResult(u);
+export {
+  q as l
+};

package/dist/node_modules/postcss/lib/list.js

@@ -0,0 +1,21 @@
+let s = {
+  comma(t) {
+    return s.split(t, [","], !0);
+  },
+  space(t) {
+    let i = [" ", `
+`, "	"];
+    return s.split(t, i);
+  },
+  split(t, i, c) {
+    let r = [], l = "", a = !1, f = 0, u = !1, n = "", p = !1;
+    for (let e of t)
+      p ? p = !1 : e === "\\" ? p = !0 : u ? e === n && (u = !1) : e === '"' || e === "'" ? (u = !0, n = e) : e === "(" ? f += 1 : e === ")" ? f > 0 && (f -= 1) : f === 0 && i.includes(e) && (a = !0), a ? (l !== "" && r.push(l.trim()), l = "", a = !1) : l += e;
+    return (c || l !== "") && r.push(l.trim()), r;
+  }
+};
+var o = s;
+s.default = s;
+export {
+  o as l
+};

package/dist/node_modules/postcss/lib/map-generator.js

@@ -0,0 +1,166 @@
+import l from "../../../_virtual/___vite-browser-external.js";
+import { i as M } from "./input.js";
+let { dirname: n, relative: f, resolve: g, sep: d } = l, { SourceMapConsumer: v, SourceMapGenerator: a } = l, { pathToFileURL: c } = l, U = M, O = !!(v && a), S = !!(n && g && f && d);
+class C {
+  constructor(t, e, s, i) {
+    this.stringify = t, this.mapOpts = s.map || {}, this.root = e, this.opts = s, this.css = i, this.originalCSS = i, this.usesFileUrls = !this.mapOpts.from && this.mapOpts.absolute, this.memoizedFileURLs = /* @__PURE__ */ new Map(), this.memoizedPaths = /* @__PURE__ */ new Map(), this.memoizedURLs = /* @__PURE__ */ new Map();
+  }
+  addAnnotation() {
+    let t;
+    this.isInline() ? t = "data:application/json;base64," + this.toBase64(this.map.toString()) : typeof this.mapOpts.annotation == "string" ? t = this.mapOpts.annotation : typeof this.mapOpts.annotation == "function" ? t = this.mapOpts.annotation(this.opts.to, this.root) : t = this.outputFile() + ".map";
+    let e = `
+`;
+    this.css.includes(`\r
+`) && (e = `\r
+`), this.css += e + "/*# sourceMappingURL=" + t + " */";
+  }
+  applyPrevMaps() {
+    for (let t of this.previous()) {
+      let e = this.toUrl(this.path(t.file)), s = t.root || n(t.file), i;
+      this.mapOpts.sourcesContent === !1 ? (i = new v(t.text), i.sourcesContent && (i.sourcesContent = null)) : i = t.consumer(), this.map.applySourceMap(i, e, this.toUrl(this.path(s)));
+    }
+  }
+  clearAnnotation() {
+    if (this.mapOpts.annotation !== !1)
+      if (this.root) {
+        let t;
+        for (let e = this.root.nodes.length - 1; e >= 0; e--)
+          t = this.root.nodes[e], t.type === "comment" && t.text.startsWith("# sourceMappingURL=") && this.root.removeChild(e);
+      } else this.css && (this.css = this.css.replace(/\n*\/\*#[\S\s]*?\*\/$/gm, ""));
+  }
+  generate() {
+    if (this.clearAnnotation(), S && O && this.isMap())
+      return this.generateMap();
+    {
+      let t = "";
+      return this.stringify(this.root, (e) => {
+        t += e;
+      }), [t];
+    }
+  }
+  generateMap() {
+    if (this.root)
+      this.generateString();
+    else if (this.previous().length === 1) {
+      let t = this.previous()[0].consumer();
+      t.file = this.outputFile(), this.map = a.fromSourceMap(t, {
+        ignoreInvalidMapping: !0
+      });
+    } else
+      this.map = new a({
+        file: this.outputFile(),
+        ignoreInvalidMapping: !0
+      }), this.map.addMapping({
+        generated: { column: 0, line: 1 },
+        original: { column: 0, line: 1 },
+        source: this.opts.from ? this.toUrl(this.path(this.opts.from)) : "<no source>"
+      });
+    return this.isSourcesContent() && this.setSourcesContent(), this.root && this.previous().length > 0 && this.applyPrevMaps(), this.isAnnotation() && this.addAnnotation(), this.isInline() ? [this.css] : [this.css, this.map];
+  }
+  generateString() {
+    this.css = "", this.map = new a({
+      file: this.outputFile(),
+      ignoreInvalidMapping: !0
+    });
+    let t = 1, e = 1, s = "<no source>", i = {
+      generated: { column: 0, line: 0 },
+      original: { column: 0, line: 0 },
+      source: ""
+    }, h, p;
+    this.stringify(this.root, (r, o, u) => {
+      if (this.css += r, o && u !== "end" && (i.generated.line = t, i.generated.column = e - 1, o.source && o.source.start ? (i.source = this.sourcePath(o), i.original.line = o.source.start.line, i.original.column = o.source.start.column - 1, this.map.addMapping(i)) : (i.source = s, i.original.line = 1, i.original.column = 0, this.map.addMapping(i))), p = r.match(/\n/g), p ? (t += p.length, h = r.lastIndexOf(`
+`), e = r.length - h) : e += r.length, o && u !== "start") {
+        let m = o.parent || { raws: {} };
+        (!(o.type === "decl" || o.type === "atrule" && !o.nodes) || o !== m.last || m.raws.semicolon) && (o.source && o.source.end ? (i.source = this.sourcePath(o), i.original.line = o.source.end.line, i.original.column = o.source.end.column - 1, i.generated.line = t, i.generated.column = e - 2, this.map.addMapping(i)) : (i.source = s, i.original.line = 1, i.original.column = 0, i.generated.line = t, i.generated.column = e - 1, this.map.addMapping(i)));
+      }
+    });
+  }
+  isAnnotation() {
+    return this.isInline() ? !0 : typeof this.mapOpts.annotation < "u" ? this.mapOpts.annotation : this.previous().length ? this.previous().some((t) => t.annotation) : !0;
+  }
+  isInline() {
+    if (typeof this.mapOpts.inline < "u")
+      return this.mapOpts.inline;
+    let t = this.mapOpts.annotation;
+    return typeof t < "u" && t !== !0 ? !1 : this.previous().length ? this.previous().some((e) => e.inline) : !0;
+  }
+  isMap() {
+    return typeof this.opts.map < "u" ? !!this.opts.map : this.previous().length > 0;
+  }
+  isSourcesContent() {
+    return typeof this.mapOpts.sourcesContent < "u" ? this.mapOpts.sourcesContent : this.previous().length ? this.previous().some((t) => t.withContent()) : !0;
+  }
+  outputFile() {
+    return this.opts.to ? this.path(this.opts.to) : this.opts.from ? this.path(this.opts.from) : "to.css";
+  }
+  path(t) {
+    if (this.mapOpts.absolute || t.charCodeAt(0) === 60 || /^\w+:\/\//.test(t)) return t;
+    let e = this.memoizedPaths.get(t);
+    if (e) return e;
+    let s = this.opts.to ? n(this.opts.to) : ".";
+    typeof this.mapOpts.annotation == "string" && (s = n(g(s, this.mapOpts.annotation)));
+    let i = f(s, t);
+    return this.memoizedPaths.set(t, i), i;
+  }
+  previous() {
+    if (!this.previousMaps)
+      if (this.previousMaps = [], this.root)
+        this.root.walk((t) => {
+          if (t.source && t.source.input.map) {
+            let e = t.source.input.map;
+            this.previousMaps.includes(e) || this.previousMaps.push(e);
+          }
+        });
+      else {
+        let t = new U(this.originalCSS, this.opts);
+        t.map && this.previousMaps.push(t.map);
+      }
+    return this.previousMaps;
+  }
+  setSourcesContent() {
+    let t = {};
+    if (this.root)
+      this.root.walk((e) => {
+        if (e.source) {
+          let s = e.source.input.from;
+          if (s && !t[s]) {
+            t[s] = !0;
+            let i = this.usesFileUrls ? this.toFileUrl(s) : this.toUrl(this.path(s));
+            this.map.setSourceContent(i, e.source.input.css);
+          }
+        }
+      });
+    else if (this.css) {
+      let e = this.opts.from ? this.toUrl(this.path(this.opts.from)) : "<no source>";
+      this.map.setSourceContent(e, this.css);
+    }
+  }
+  sourcePath(t) {
+    return this.mapOpts.from ? this.toUrl(this.mapOpts.from) : this.usesFileUrls ? this.toFileUrl(t.source.input.from) : this.toUrl(this.path(t.source.input.from));
+  }
+  toBase64(t) {
+    return Buffer ? Buffer.from(t).toString("base64") : window.btoa(unescape(encodeURIComponent(t)));
+  }
+  toFileUrl(t) {
+    let e = this.memoizedFileURLs.get(t);
+    if (e) return e;
+    if (c) {
+      let s = c(t).toString();
+      return this.memoizedFileURLs.set(t, s), s;
+    } else
+      throw new Error(
+        "`map.absolute` option is not available in this PostCSS build"
+      );
+  }
+  toUrl(t) {
+    let e = this.memoizedURLs.get(t);
+    if (e) return e;
+    d === "\\" && (t = t.replace(/\\/g, "/"));
+    let s = encodeURI(t).replace(/[#?]/g, encodeURIComponent);
+    return this.memoizedURLs.set(t, s), s;
+  }
+}
+var I = C;
+export {
+  I as m
+};