schummar-table 0.38.3 → 0.39.2

package/dist/chunk-YWWFSINO.js

@@ -0,0 +1,786 @@
+import {
+  CsvExporter
+} from "./chunk-WFCJ3D3G.js";
+import {
+  __spreadProps,
+  __spreadValues
+} from "./chunk-EEBUKP6F.js";
+
+// src/theme/defaultTheme/popover.tsx
+import { useLayoutEffect, useRef, useState } from "react";
+import { createPortal } from "react-dom";
+
+// src/theme/defaultTheme/defaultClasses.ts
+import { css } from "@emotion/react";
+var white = "#ffffff";
+var lightGray = "#eeeeee";
+var gray = "#bdbdbd";
+var darkGray = "#777";
+var cell = css({
+  padding: `calc(var(--spacing) * 0.1) calc(2 * var(--spacing))`,
+  display: "flex",
+  alignItems: "center",
+  borderBottom: `1px solid #dfe2e9`,
+  whiteSpace: "nowrap",
+  overflow: "hidden",
+  background: "white"
+});
+var defaultClasses = {
+  table: css({
+    position: "relative",
+    display: "grid"
+  }),
+  cell,
+  cellFill: css({
+    borderBottom: `1px solid ${lightGray}`
+  }),
+  headerCell: css(cell, {
+    padding: `var(--spacing) 0 var(--spacing) calc(2 * var(--spacing))`,
+    borderBottom: `1px solid #c9cfda`
+  }),
+  footerCell: css(cell, {
+    padding: `var(--spacing) calc(2 * var(--spacing))`,
+    borderTop: `1px solid #c9cfda`,
+    borderBottom: "none"
+  }),
+  firstCell: css({
+    justifyContent: "start"
+  }),
+  sticky: css({
+    position: "sticky",
+    top: 0,
+    zIndex: 2
+  }),
+  stickyBottom: css({
+    position: "sticky",
+    bottom: 0,
+    zIndex: 2
+  }),
+  headerFill: css({
+    borderBottom: `1px solid #c9cfda`,
+    background: white
+  }),
+  footerFill: css({
+    borderTop: `1px solid #c9cfda`,
+    background: white
+  }),
+  text: css({
+    minWidth: 0,
+    overflow: "hidden",
+    textOverflow: "ellipsis"
+  }),
+  card: css({
+    borderRadius: 4,
+    boxShadow: "0px 3px 14px 2px rgb(0 0 0 / 12%)",
+    background: "white"
+  }),
+  clearFiltersButton: css({
+    padding: `0 calc(2 * var(--spacing))`,
+    fontWeight: "bold",
+    position: "sticky",
+    left: 0,
+    maxWidth: "fit-content",
+    gridColumn: "2/-1",
+    button: {
+      color: "var(--primaryMain) !important",
+      border: "solid 1px",
+      borderColor: "var(--primaryMain) !important",
+      margin: "var(--spacing)"
+    }
+  }),
+  details: css(cell, {
+    gridColumn: "1 / -1",
+    whiteSpace: "normal"
+  })
+};
+
+// src/theme/defaultTheme/popover.tsx
+import { Fragment, jsx, jsxs } from "@emotion/react/jsx-runtime";
+var MARGIN = 10;
+var MAX_OFFSET = 20;
+var Popover = ({
+  anchorEl,
+  open,
+  hidden,
+  onClose,
+  children,
+  className,
+  backdropClassName,
+  align
+}) => {
+  const popper = useRef(null);
+  const [position, setPosition] = useState();
+  const [maxHeight, setMaxHeight] = useState(document.documentElement.clientHeight - 2 * MARGIN);
+  const [zIndex, setZIndex] = useState(1);
+  useLayoutEffect(() => {
+    if (!anchorEl || !open) {
+      setPosition(void 0);
+      return;
+    }
+    let last;
+    function check() {
+      var _a, _b;
+      if (!anchorEl) return;
+      const {
+        left: anchorLeft,
+        bottom: anchorBottom,
+        width: anchorWidth
+      } = anchorEl.getBoundingClientRect();
+      const { width: popperWidth = 0 } = (_b = (_a = popper.current) == null ? void 0 : _a.getBoundingClientRect()) != null ? _b : {};
+      const viewportWidth = document.documentElement.clientWidth;
+      const viewportHeight = document.documentElement.clientHeight;
+      const next = {
+        left: align === "center" ? anchorLeft + anchorWidth / 2 - popperWidth / 2 : anchorLeft - Math.min(popperWidth ? popperWidth / 2 : Number.POSITIVE_INFINITY, MAX_OFFSET),
+        top: anchorBottom
+      };
+      if (next.left < MARGIN) {
+        next.left = MARGIN;
+      }
+      if (next.left + popperWidth > viewportWidth - MARGIN) {
+        next.left = viewportWidth - MARGIN - popperWidth;
+      }
+      if (next.top < MARGIN) {
+        next.top = MARGIN;
+      }
+      if (next.left !== (last == null ? void 0 : last.left) || next.top !== (last == null ? void 0 : last.top)) {
+        setPosition(next);
+      }
+      setMaxHeight(viewportHeight - MARGIN - next.top);
+      last = next;
+    }
+    check();
+    const handle = setInterval(check, 16);
+    return () => {
+      clearInterval(handle);
+    };
+  }, [anchorEl, open, align]);
+  function updateZIndex(div) {
+    var _a;
+    const ancestors = [];
+    for (let node = div == null ? void 0 : div.parentElement; node; node = node.parentElement) {
+      ancestors.push(node);
+    }
+    for (const node of ancestors.reverse()) {
+      const value = (_a = document.defaultView) == null ? void 0 : _a.getComputedStyle(node).getPropertyValue("z-index");
+      if (value && !Number.isNaN(Number(value))) {
+        setZIndex(Number(value) + 1);
+        return;
+      }
+    }
+  }
+  if (!open) return null;
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref: updateZIndex,
+        css: {
+          display: "none"
+        }
+      }
+    ),
+    createPortal(
+      /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: backdropClassName,
+            css: [
+              {
+                position: "fixed",
+                left: 0,
+                right: 0,
+                top: 0,
+                bottom: 0,
+                zIndex
+              },
+              hidden && { display: "none" }
+            ],
+            onClick: () => onClose()
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            ref: popper,
+            className,
+            css: [
+              defaultClasses.card,
+              __spreadProps(__spreadValues({
+                position: "fixed",
+                maxWidth: document.documentElement.clientWidth - 2 * MARGIN,
+                maxHeight
+              }, position), {
+                zIndex: zIndex + 1,
+                overflowY: "auto"
+              }),
+              hidden && { display: "none" },
+              !position && { visibility: "hidden" }
+            ],
+            children
+          }
+        )
+      ] }),
+      document.body
+    )
+  ] });
+};
+
+// node_modules/schummar-state/dist/es/store.js
+import { freeze, enableMapSet, enablePatches, produce, applyPatches } from "immer";
+var react = function equal(a, b) {
+  if (a === b)
+    return true;
+  if (a && b && typeof a == "object" && typeof b == "object") {
+    if (a.constructor !== b.constructor)
+      return false;
+    var length, i, keys;
+    if (Array.isArray(a)) {
+      length = a.length;
+      if (length != b.length)
+        return false;
+      for (i = length; i-- !== 0; )
+        if (!equal(a[i], b[i]))
+          return false;
+      return true;
+    }
+    if (a instanceof Map && b instanceof Map) {
+      if (a.size !== b.size)
+        return false;
+      for (i of a.entries())
+        if (!b.has(i[0]))
+          return false;
+      for (i of a.entries())
+        if (!equal(i[1], b.get(i[0])))
+          return false;
+      return true;
+    }
+    if (a instanceof Set && b instanceof Set) {
+      if (a.size !== b.size)
+        return false;
+      for (i of a.entries())
+        if (!b.has(i[0]))
+          return false;
+      return true;
+    }
+    if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
+      length = a.length;
+      if (length != b.length)
+        return false;
+      for (i = length; i-- !== 0; )
+        if (a[i] !== b[i])
+          return false;
+      return true;
+    }
+    if (a.constructor === RegExp)
+      return a.source === b.source && a.flags === b.flags;
+    if (a.valueOf !== Object.prototype.valueOf)
+      return a.valueOf() === b.valueOf();
+    if (a.toString !== Object.prototype.toString)
+      return a.toString() === b.toString();
+    keys = Object.keys(a);
+    length = keys.length;
+    if (length !== Object.keys(b).length)
+      return false;
+    for (i = length; i-- !== 0; )
+      if (!Object.prototype.hasOwnProperty.call(b, keys[i]))
+        return false;
+    for (i = length; i-- !== 0; ) {
+      var key = keys[i];
+      if (key === "_owner" && a.$$typeof) {
+        continue;
+      }
+      if (!equal(a[key], b[key]))
+        return false;
+    }
+    return true;
+  }
+  return a !== a && b !== b;
+};
+function createSelector(stringSelector) {
+  const parts = stringSelector.split(".");
+  return (state) => parts.reduce((v2, p2) => v2 instanceof Object && p2 in v2 ? v2[p2] : void 0, state);
+}
+function setWithSelector(state, stringSelector, value) {
+  const parts = stringSelector.split(".");
+  const prefix = parts.slice(0, -1);
+  const last = parts[parts.length - 1];
+  for (const part of prefix) {
+    if (state instanceof Object && part in state) {
+      state = state[part];
+    } else {
+      throw Error(`Could not set ${stringSelector} because path ${stringSelector} doesn't exist`);
+    }
+  }
+  if (state instanceof Object) {
+    state[last] = value;
+  } else {
+    throw Error(`Could not set ${stringSelector} because path ${stringSelector} doesn't exist`);
+  }
+}
+function throttle(fn, ms) {
+  let last = 0;
+  let lastArgs;
+  let timeout;
+  function run() {
+    const args = lastArgs;
+    last = Date.now();
+    lastArgs = void 0;
+    timeout = void 0;
+    fn(...args);
+  }
+  return function(...args) {
+    const now = Date.now();
+    lastArgs = args;
+    if (timeout)
+      ;
+    else if (now < last + ms) {
+      timeout = setTimeout(run, last + ms - now);
+    } else {
+      run();
+    }
+  };
+}
+var RESTART_UPDATE = Symbol("RESTART_UPDATE");
+var Store = class {
+  constructor(state, { log = (...data) => console.error(...data) } = {}) {
+    this.state = state;
+    this.subscriptions = /* @__PURE__ */ new Set();
+    this.batchCounter = 0;
+    this.reactions = /* @__PURE__ */ new Set();
+    this.patches = new Array();
+    freeze(state, true);
+    enableMapSet();
+    enablePatches();
+    this.options = {
+      log
+    };
+  }
+  getState() {
+    return this.state;
+  }
+  update(update) {
+    this.checkLock();
+    this.state = produce(this.state, (draft) => update(draft, this.state), (patches) => this.patches.push(...patches));
+    this.notify();
+  }
+  set(state) {
+    this.checkLock();
+    this.state = produce(this.state, () => state, (patches) => this.patches.push(...patches));
+    this.notify();
+  }
+  applyPatches(patches) {
+    this.checkLock();
+    this.state = applyPatches(this.state, patches);
+    this.patches.push(...patches);
+    this.notify();
+  }
+  batchUpdates(fn) {
+    try {
+      this.batchCounter++;
+      fn();
+    } finally {
+      this.batchCounter--;
+      if (this.batchCounter === 0) {
+        this.notify();
+      }
+    }
+  }
+  subscribe(...args) {
+    let selector, listener, options;
+    if (args[1] instanceof Function) {
+      [selector, listener, options] = args;
+      if (typeof selector === "string") {
+        selector = createSelector(selector);
+      }
+    } else {
+      [selector, listener, options] = [(x) => x, ...args];
+    }
+    const { runNow = true, throttle: throttle$1 = 0, compare = react } = options != null ? options : {};
+    const throttledListener = throttle$1 ? throttle(listener, throttle$1) : listener;
+    let value = selector(this.state);
+    const internalListener = (state, _patches, init) => {
+      try {
+        const oldValue = value;
+        value = selector(state);
+        if (!init && compare(value, oldValue))
+          return;
+        (init ? listener : throttledListener)(value, oldValue, this.state);
+      } catch (e2) {
+        this.options.log("Failed to execute listener:", e2);
+      }
+    };
+    this.subscriptions.add(internalListener);
+    if (runNow)
+      internalListener(this.state, [], true);
+    return () => {
+      this.subscriptions.delete(internalListener);
+    };
+  }
+  addReaction(...args) {
+    let selector, reaction, options;
+    if (args[1] instanceof Function) {
+      [selector, reaction, options] = args;
+      if (typeof selector === "string") {
+        selector = createSelector(selector);
+      }
+    } else {
+      [selector, reaction, options] = [(x) => x, ...args];
+    }
+    const { runNow = true, compare = react } = options != null ? options : {};
+    let value = selector(this.state);
+    const internalListener = (init) => {
+      let hasChanged = false;
+      try {
+        this.lock = "reaction";
+        const oldValue = value;
+        value = selector(this.state);
+        if (!init && compare(value, oldValue))
+          return;
+        this.state = produce(this.state, (draft) => reaction(value, draft, this.state, oldValue), (patches) => {
+          hasChanged = true;
+          this.patches.push(...patches);
+        });
+      } catch (e2) {
+        this.options.log("Failed to execute reaction:", e2);
+      } finally {
+        delete this.lock;
+      }
+      if (hasChanged && !init)
+        throw RESTART_UPDATE;
+      if (hasChanged && init)
+        this.notify();
+    };
+    this.reactions.add(internalListener);
+    if (runNow)
+      internalListener(true);
+    return () => {
+      this.reactions.delete(internalListener);
+    };
+  }
+  subscribePatches(listener) {
+    const internalListener = (_state, patches) => {
+      try {
+        listener(patches);
+      } catch (e2) {
+        this.options.log("Failed to execute patch listener:", e2);
+      }
+    };
+    this.subscriptions.add(internalListener);
+    return () => {
+      this.subscriptions.delete(internalListener);
+    };
+  }
+  checkLock() {
+    if (this.lock === "reaction") {
+      throw Error("You cannot call update from within a reaction. Use the passed draft instead.");
+    }
+  }
+  notify() {
+    if (this.batchCounter > 0 || this.patches.length === 0)
+      return;
+    try {
+      for (const reaction of this.reactions) {
+        reaction();
+      }
+    } catch (e2) {
+      return this.notify();
+    }
+    const patches = this.patches;
+    this.patches = [];
+    this.batchUpdates(() => {
+      for (const subscription of this.subscriptions) {
+        subscription(this.state, patches);
+      }
+    });
+  }
+};
+
+// node_modules/schummar-state/dist/es/react.js
+import React, { useCallback, useDebugValue, useMemo, createContext, useContext, useEffect } from "react";
+import "immer";
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues2 = (a2, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a2, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a2, prop, b[prop]);
+    }
+  return a2;
+};
+var withSelector = { exports: {} };
+var withSelector_production_min = {};
+var shim = { exports: {} };
+var useSyncExternalStoreShim_production_min = {};
+var e = React;
+function h$1(a2, b) {
+  return a2 === b && (a2 !== 0 || 1 / a2 === 1 / b) || a2 !== a2 && b !== b;
+}
+var k = typeof Object.is === "function" ? Object.is : h$1;
+var l = e.useState;
+var m = e.useEffect;
+var n$1 = e.useLayoutEffect;
+var p$1 = e.useDebugValue;
+function q$1(a2, b) {
+  var d = b(), f = l({ inst: { value: d, getSnapshot: b } }), c = f[0].inst, g = f[1];
+  n$1(function() {
+    c.value = d;
+    c.getSnapshot = b;
+    r$1(c) && g({ inst: c });
+  }, [a2, d, b]);
+  m(function() {
+    r$1(c) && g({ inst: c });
+    return a2(function() {
+      r$1(c) && g({ inst: c });
+    });
+  }, [a2]);
+  p$1(d);
+  return d;
+}
+function r$1(a2) {
+  var b = a2.getSnapshot;
+  a2 = a2.value;
+  try {
+    var d = b();
+    return !k(a2, d);
+  } catch (f) {
+    return true;
+  }
+}
+function t$1(a2, b) {
+  return b();
+}
+var u$1 = typeof window === "undefined" || typeof window.document === "undefined" || typeof window.document.createElement === "undefined" ? t$1 : q$1;
+useSyncExternalStoreShim_production_min.useSyncExternalStore = e.useSyncExternalStore !== void 0 ? e.useSyncExternalStore : u$1;
+{
+  shim.exports = useSyncExternalStoreShim_production_min;
+}
+var h = React;
+var n = shim.exports;
+function p(a2, b) {
+  return a2 === b && (a2 !== 0 || 1 / a2 === 1 / b) || a2 !== a2 && b !== b;
+}
+var q = typeof Object.is === "function" ? Object.is : p;
+var r = n.useSyncExternalStore;
+var t = h.useRef;
+var u = h.useEffect;
+var v = h.useMemo;
+var w = h.useDebugValue;
+withSelector_production_min.useSyncExternalStoreWithSelector = function(a2, b, e2, l2, g) {
+  var c = t(null);
+  if (c.current === null) {
+    var f = { hasValue: false, value: null };
+    c.current = f;
+  } else
+    f = c.current;
+  c = v(function() {
+    function a3(a4) {
+      if (!c2) {
+        c2 = true;
+        d2 = a4;
+        a4 = l2(a4);
+        if (g !== void 0 && f.hasValue) {
+          var b2 = f.value;
+          if (g(b2, a4))
+            return k2 = b2;
+        }
+        return k2 = a4;
+      }
+      b2 = k2;
+      if (q(d2, a4))
+        return b2;
+      var e3 = l2(a4);
+      if (g !== void 0 && g(b2, e3))
+        return b2;
+      d2 = a4;
+      return k2 = e3;
+    }
+    var c2 = false, d2, k2, m2 = e2 === void 0 ? null : e2;
+    return [function() {
+      return a3(b());
+    }, m2 === null ? void 0 : function() {
+      return a3(m2());
+    }];
+  }, [b, e2, l2, g]);
+  var d = r(a2, c[0], c[1]);
+  u(function() {
+    f.hasValue = true;
+    f.value = d;
+  }, [d]);
+  w(d);
+  return d;
+};
+{
+  withSelector.exports = withSelector_production_min;
+}
+function useStoreState(store, ...args) {
+  var _a, _b, _c, _d;
+  let selector, options;
+  if (args[0] instanceof Function) {
+    selector = args[0];
+    options = (_a = args[1]) != null ? _a : {};
+  } else if (typeof args[0] === "string") {
+    selector = createSelector(args[0]);
+    options = (_b = args[1]) != null ? _b : {};
+  } else {
+    selector = (x) => x;
+    options = (_c = args[0]) != null ? _c : {};
+  }
+  const subscribe = useCallback((listener) => {
+    return store.subscribe((x) => x, listener, {
+      throttle: options.throttle,
+      runNow: false,
+      compare: (a2, b) => a2 === b
+    });
+  }, [store, options.throttle]);
+  const getSnapshot = useCallback(() => store.getState(), [store]);
+  const value = withSelector.exports.useSyncExternalStoreWithSelector(subscribe, getSnapshot, getSnapshot, selector, (_d = options.compare) != null ? _d : react);
+  useDebugValue(value);
+  return value;
+}
+function useStoreProp(store, selector) {
+  const value = useStoreState(store, selector);
+  const update = (value2) => store.update((state) => setWithSelector(state, selector, value2));
+  return [value, update];
+}
+var Store2 = class extends Store {
+  useState(...args) {
+    return useStoreState(this, ...args);
+  }
+  useProp(selector) {
+    return useStoreProp(this, selector);
+  }
+};
+var StoreScope = class {
+  constructor(defaultValue) {
+    this.defaultValue = defaultValue;
+    this.Provider = ({ children, store }) => {
+      const _store = useMemo(() => store != null ? store : new Store2(this.defaultValue), [store]);
+      return /* @__PURE__ */ React.createElement(this.context.Provider, {
+        value: _store
+      }, children);
+    };
+    this.withScope = (Component) => {
+      return (args) => /* @__PURE__ */ React.createElement(this.Provider, null, /* @__PURE__ */ React.createElement(Component, __spreadValues2({}, args)));
+    };
+    this.context = createContext(new Store2(defaultValue));
+  }
+  useStore() {
+    return useContext(this.context);
+  }
+  useState(...args) {
+    const store = this.useStore();
+    return useStoreState(store, ...args);
+  }
+  useProp(selector) {
+    const store = this.useStore();
+    return useStoreProp(store, selector);
+  }
+};
+
+// src/theme/tableTheme.tsx
+var globalTableTheme = new Store2({});
+function configureTableTheme(tableTheme) {
+  globalTableTheme.set(tableTheme);
+}
+function mergeThemes(...themes) {
+  return {
+    text: Object.assign({}, ...themes.map((theme) => theme.text)),
+    classes: Object.assign({}, ...themes.map((theme) => theme.classes)),
+    styles: Object.assign({}, ...themes.map((theme) => theme.styles)),
+    components: Object.assign({}, ...themes.map((theme) => theme.components)),
+    icons: Object.assign({}, ...themes.map((theme) => theme.icons)),
+    colors: {
+      primary: Object.assign({}, ...themes.map((theme) => {
+        var _a;
+        return (_a = theme.colors) == null ? void 0 : _a.primary;
+      })),
+      secondary: Object.assign({}, ...themes.map((theme) => {
+        var _a;
+        return (_a = theme.colors) == null ? void 0 : _a.secondary;
+      })),
+      blocked: Object.assign({}, ...themes.map((theme) => {
+        var _a;
+        return (_a = theme.colors) == null ? void 0 : _a.blocked;
+      }))
+    },
+    spacing: themes.map((theme) => theme.spacing).reverse().find((x) => x !== void 0)
+  };
+}
+
+// src/misc/tableSettings.tsx
+import { createContext as createContext2, useContext as useContext2 } from "react";
+import { jsx as jsx2 } from "@emotion/react/jsx-runtime";
+var TableSettingsContext = createContext2({
+  theme: {},
+  exporters: [
+    { action: "copy", exporter: new CsvExporter() },
+    { action: "download", exporter: new CsvExporter() }
+  ]
+});
+function TableSettingsProvider({
+  theme,
+  exporters,
+  additionalExporters,
+  children
+}) {
+  const inherited = useContext2(TableSettingsContext);
+  theme != null ? theme : theme = inherited.theme;
+  exporters != null ? exporters : exporters = inherited.exporters;
+  if (additionalExporters) {
+    exporters = [...exporters, ...additionalExporters];
+  }
+  return /* @__PURE__ */ jsx2(
+    TableSettingsContext.Provider,
+    {
+      value: {
+        theme,
+        exporters
+      },
+      children
+    }
+  );
+}
+
+export {
+  Store2 as Store,
+  StoreScope,
+  lightGray,
+  gray,
+  darkGray,
+  defaultClasses,
+  Popover,
+  globalTableTheme,
+  configureTableTheme,
+  mergeThemes,
+  TableSettingsContext,
+  TableSettingsProvider
+};
+/*! Bundled license information:
+
+schummar-state/dist/es/react.js:
+  (** @license React vundefined
+   * use-sync-external-store-shim.production.min.js
+   *
+   * Copyright (c) Facebook, Inc. and its affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
+  (** @license React vundefined
+   * use-sync-external-store-shim/with-selector.production.min.js
+   *
+   * Copyright (c) Facebook, Inc. and its affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
+*/
+//# sourceMappingURL=chunk-YWWFSINO.js.map