@cccsaurora/clue-ui 1.2.3 → 1.2.4-dev.278

package/index-JcKyZeoY.js

@@ -0,0 +1,465 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { jsx, jsxs } from "react/jsx-runtime";
+import { ClickAwayListener, TextField, InputAdornment, Popper, Paper, MenuList, MenuItem, ListItemText, useTheme, Stack, Skeleton } from "@mui/material";
+import { useRef, useState, useEffect, useMemo, lazy } from "react";
+import { r as removeEmpty, s as searchObject, f as flatten } from "./utils-HmNPuoDB.js";
+import { ClueComponentContext } from "./hooks/ClueComponentContext.js";
+import { useMyLocalStorageItem } from "./hooks/useMyLocalStorage.js";
+import { StorageKey } from "./utils/constants.js";
+import { u as useContextSelector } from "./index-AMfoEg_6.js";
+const ENTER = "Enter";
+const ESCAPE = "Escape";
+const ARROW_LEFT = "ArrowLeft";
+const ARROW_UP = "ArrowUp";
+const ARROW_RIGHT = "ArrowRight";
+const ARROW_DOWN = "ArrowDown";
+const BACKSPACE = "Backspace";
+const SPACE = " ";
+function is(key, check) {
+  return key === check;
+}
+function isArrowUp(key) {
+  return is(key, ARROW_UP);
+}
+function isArrowDown(key) {
+  return is(key, ARROW_DOWN);
+}
+function isArrowLeft(key) {
+  return is(key, ARROW_LEFT);
+}
+function isArrowRight(key) {
+  return is(key, ARROW_RIGHT);
+}
+function isEscape(key) {
+  return is(key, ESCAPE);
+}
+function isEnter(key) {
+  return is(key, ENTER);
+}
+function isBackspace(key) {
+  return is(key, BACKSPACE);
+}
+function isSpace(key) {
+  return is(key, SPACE);
+}
+function parseEvent(event) {
+  return {
+    key: event.key,
+    isCtrl: event.ctrlKey,
+    isEnter: isEnter(event.key),
+    isSpace: isSpace(event.key),
+    isBackspace: isBackspace(event.key),
+    isEscape: isEscape(event.key),
+    isArrowLeft: isArrowLeft(event.key),
+    isArrowRight: isArrowRight(event.key),
+    isArrowUp: isArrowUp(event.key),
+    isArrowDown: isArrowDown(event.key)
+  };
+}
+class TuiPhraseLexer {
+  constructor() {
+    __publicField(this, "_phrase", null);
+    __publicField(this, "_buffer", null);
+    __publicField(this, "_tokens", null);
+    __publicField(this, "_consumers", null);
+    __publicField(this, "_consumer", null);
+    __publicField(this, "_startIndex", 0);
+    __publicField(this, "_endIndex", -1);
+  }
+  find(cursor, tokens) {
+    const index = tokens.findIndex((t) => t.startIndex <= cursor && cursor <= t.endIndex);
+    const token = tokens.at(index);
+    return { index, token };
+  }
+  parse(phrase, cursor = 0) {
+    this._phrase = phrase;
+    this._buffer = [];
+    this._tokens = [];
+    this._consumers = this.consumers();
+    this._consumer = null;
+    this._startIndex = 0;
+    this._endIndex = -1;
+    for (let i = 0; i < this._phrase.length; i++) {
+      this._endIndex += 1;
+      const next = this._phrase[i];
+      this._buffer.push(next);
+      let newLock = false;
+      if (!this._consumer) {
+        this._consumer = this.lock();
+        if (this._consumer) {
+          newLock = true;
+          this._consumer.init(this._buffer, this);
+        }
+      }
+      if (this._consumer) {
+        if (newLock) {
+          newLock = false;
+        } else {
+          this._consumer.append(next, this);
+        }
+        const token = this._consumer.consume(this);
+        if (token) {
+          this._tokens.push(token);
+          this._buffer = [];
+          this._consumer = null;
+          this._startIndex = this._endIndex + 1;
+        }
+      }
+    }
+    this._tokens.push({ type: "eop", startIndex: phrase.length, endIndex: phrase.length, value: "" });
+    const flatTokens = this._tokens.flatMap((t) => t.children && t.children.length > 0 ? t.children : [t]);
+    const { token: parent, index: parentIndex } = this.find(cursor, this._tokens);
+    const { token: current, index: currentIndex } = this.find(cursor, flatTokens);
+    const filter = cursor === current.startIndex && flatTokens[currentIndex - 1] ? flatTokens[currentIndex - 1] : current;
+    return {
+      cursor,
+      parentIndex,
+      parent,
+      currentIndex,
+      current,
+      suggest: {
+        token: filter,
+        parent: this.find(filter.startIndex, this._tokens).token,
+        value: filter.value.substring(0, cursor - filter.startIndex)
+      },
+      tokens: this._tokens
+    };
+  }
+  lock() {
+    return this._consumers.find((c) => c.lock(this));
+  }
+  buffer() {
+    return this._buffer;
+  }
+  bufferValue() {
+    return this._buffer.join("");
+  }
+  start() {
+    return this._startIndex;
+  }
+  end() {
+    return this._endIndex;
+  }
+  ahead(inc) {
+    const start = this._endIndex + 1;
+    if (inc) {
+      return this._phrase.slice(start, start + inc);
+    }
+    return this._phrase.substring(start);
+  }
+  behind(inc) {
+    if (inc) {
+      return this.bufferValue().slice(-inc);
+    }
+    return this.bufferValue();
+  }
+  behindEndsWithAny(trim, ...values) {
+    const behind = trim ? this.behind().trimEnd() : this.behind();
+    return values.some((v) => behind.endsWith(v));
+  }
+  testBehind(regex) {
+    return regex.test(this.behind());
+  }
+  aheadStartsWithAny(trim, ...values) {
+    const ahead = trim ? this.ahead().trimStart() : this.ahead();
+    return values.some((v) => ahead.startsWith(v));
+  }
+  aheadIsEmpty(trim = false) {
+    return trim ? this.ahead().trim().length === 0 : this.ahead().length === 0;
+  }
+  testAhead(regex) {
+    return regex.test(this.ahead());
+  }
+}
+class TuiPhraseConsumer {
+  constructor() {
+    __publicField(this, "_buffer", []);
+  }
+  reset() {
+    this._buffer = [];
+  }
+  init(buffer, lexer) {
+    this._buffer = [...buffer];
+  }
+  append(next, lexer) {
+    this._buffer.push(next);
+  }
+  bufferValue() {
+    return this._buffer.join("");
+  }
+  endsWithAny(...values) {
+    const _bufferValue = this.bufferValue();
+    return values.some((v) => _bufferValue.endsWith(v));
+  }
+  test(regex) {
+    return regex.test(this.bufferValue());
+  }
+}
+class WhitespaceConsumer extends TuiPhraseConsumer {
+  lock(lexer) {
+    return lexer.bufferValue().match(/\s/) && lexer.ahead(1) !== " ";
+  }
+  consume(lexer) {
+    if (lexer.ahead(1) !== " ") {
+      return {
+        type: "whitespace",
+        startIndex: lexer.start(),
+        endIndex: lexer.end(),
+        value: this._buffer.join("")
+      };
+    }
+    return null;
+  }
+}
+class WordConsumer extends TuiPhraseConsumer {
+  lock(lexer) {
+    return !lexer.bufferValue().match(/\s/) && (lexer.ahead(1) === " " || lexer.ahead(1) === "");
+  }
+  consume(lexer) {
+    if (lexer.ahead(1) === " " || lexer.aheadIsEmpty(true)) {
+      return {
+        type: "word",
+        startIndex: lexer.start(),
+        endIndex: lexer.end(),
+        value: this._buffer.join("")
+      };
+    }
+    return null;
+  }
+}
+class WordLexer extends TuiPhraseLexer {
+  consumers() {
+    return [new WordConsumer(), new WhitespaceConsumer()];
+  }
+}
+class WordSuggestor {
+  constructor(suggestions) {
+    this.suggestions = suggestions;
+  }
+  suggest(phrase) {
+    return this.suggestions.filter((s) => s.indexOf(phrase.suggest.value) > -1);
+  }
+}
+function TuiPhrase({
+  value = "",
+  variant = "outlined",
+  suggestions = [],
+  lexer,
+  suggester,
+  startAdornment,
+  endAdornment,
+  onChange,
+  onKeyDown,
+  ...props
+}) {
+  const containerRef = useRef();
+  const inputRef = useRef();
+  const menuRef = useRef();
+  const lexerRef = useRef(lexer || new WordLexer());
+  const analysisRef = useRef();
+  const suggesterRef = useRef(suggester || new WordSuggestor(suggestions));
+  const [optionsOpen, setOptionsOpen] = useState(false);
+  const [options, setOptions] = useState(suggestions);
+  useEffect(() => {
+    suggesterRef.current = suggester || new WordSuggestor(suggestions);
+  }, [suggester, suggestions]);
+  const lex = (inputValue, offset = 0) => {
+    let cursor = inputRef.current.querySelector("input").selectionStart + offset;
+    cursor = cursor < 0 ? 0 : cursor > inputValue.length ? inputValue.length : cursor;
+    analysisRef.current = lexerRef.current.parse(inputValue, cursor);
+    return analysisRef.current;
+  };
+  const _suggest = (inputValue, offset = 0) => {
+    const _suggestions = suggesterRef.current.suggest(lex(inputValue, offset));
+    setOptions((_suggestions == null ? void 0 : _suggestions.length) > 0 ? _suggestions : [...suggestions]);
+  };
+  const _onChange = (event) => {
+    onChange(event.target.value);
+  };
+  const _onInputKeyDown = (event) => {
+    const parsedEvent = parseEvent(event);
+    const { isEnter: isEnter2, isCtrl, isSpace: isSpace2, isEscape: isEscape2, isArrowDown: isArrowDown2 } = parsedEvent;
+    if (isArrowDown2) {
+      event.preventDefault();
+      menuRef.current.focus();
+    } else if (isCtrl && isSpace2) {
+      setOptionsOpen(true);
+      _suggest(value);
+    } else if (isEscape2) {
+      setOptionsOpen(!optionsOpen);
+    }
+    if (isEnter2 && optionsOpen && options.length === 1) {
+      onWordClick(options[0]);
+      event.preventDefault();
+    } else if (onKeyDown) {
+      onKeyDown(parsedEvent);
+    }
+  };
+  const _onSelectCapture = (event) => {
+    if (optionsOpen) {
+      _suggest(event.target.value);
+    }
+  };
+  const _onMenuKeyDown = (event) => {
+    const { isEscape: isEscape2 } = parseEvent(event);
+    if (isEscape2) {
+      inputRef.current.focus();
+      setOptionsOpen(false);
+    }
+  };
+  const onWordClick = (word) => {
+    const { suggest } = analysisRef.current;
+    const inputEl = inputRef.current.querySelector("input");
+    inputEl.focus();
+    inputEl.setSelectionRange(suggest.token.startIndex, suggest.token.endIndex + 1);
+    document.execCommand("insertText", false, word);
+    setOptionsOpen(false);
+  };
+  return /* @__PURE__ */ jsx(ClickAwayListener, { onClickAway: () => setOptionsOpen(false), children: /* @__PURE__ */ jsxs("div", { ref: containerRef, style: { position: "relative" }, children: [
+    /* @__PURE__ */ jsx(
+      TextField,
+      {
+        ref: inputRef,
+        ...props,
+        fullWidth: true,
+        autoComplete: "off",
+        value,
+        variant,
+        onChange: _onChange,
+        onKeyDown: _onInputKeyDown,
+        InputProps: {
+          ...props.InputProps,
+          onSelectCapture: _onSelectCapture,
+          startAdornment: startAdornment && /* @__PURE__ */ jsx(InputAdornment, { position: "start", children: startAdornment }),
+          endAdornment: endAdornment && /* @__PURE__ */ jsx(InputAdornment, { position: "end", children: endAdornment })
+        }
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      Popper,
+      {
+        anchorEl: containerRef.current,
+        style: { width: "100%", zIndex: 100 },
+        open: optionsOpen && options.length > 0,
+        disablePortal: true,
+        children: /* @__PURE__ */ jsx(
+          Paper,
+          {
+            elevation: 2,
+            sx: { maxHeight: 200, overflow: "auto", borderTopRightRadius: 0, borderTopLeftRadius: 0 },
+            children: /* @__PURE__ */ jsx(
+              MenuList,
+              {
+                ref: menuRef,
+                onKeyDown: _onMenuKeyDown,
+                sx: {
+                  "&:focus": {
+                    outline: "none"
+                  }
+                },
+                children: options == null ? void 0 : options.map((o) => /* @__PURE__ */ jsx(MenuItem, { onClick: () => onWordClick(o), children: /* @__PURE__ */ jsx(ListItemText, { children: o }) }, o))
+              }
+            )
+          }
+        )
+      }
+    )
+  ] }) });
+}
+const JSONViewer = ({ data, collapse = true, hideSearch = false, forceCompact = false, slotProps }) => {
+  var _a, _b, _c;
+  const theme = useTheme();
+  const [compact] = useMyLocalStorageItem(StorageKey.COMPACT_JSON);
+  const [flat] = useMyLocalStorageItem(StorageKey.FLATTEN_JSON);
+  const _ProvidedReactJson = useContextSelector(ClueComponentContext, (ctx) => ctx == null ? void 0 : ctx.ReactJson);
+  const { t } = useContextSelector(ClueComponentContext, (ctx) => ctx == null ? void 0 : ctx.i18next);
+  const [ReactJson, setReactJson] = useState(null);
+  const [query, setQuery] = useState("");
+  const isDark = useMemo(() => theme.palette.mode === "dark", [theme]);
+  const filteredData = useMemo(() => removeEmpty(data, compact || forceCompact), [compact, data, forceCompact]);
+  const searchedData = useMemo(() => {
+    const _searchedData = searchObject(filteredData, query);
+    return flat ? flatten(_searchedData) : _searchedData;
+  }, [filteredData, flat, query]);
+  const hasError = useMemo(() => {
+    try {
+      new RegExp(query);
+      return false;
+    } catch {
+      return true;
+    }
+  }, [query]);
+  useEffect(() => {
+    if (_ProvidedReactJson) {
+      setReactJson(() => _ProvidedReactJson);
+    } else {
+      setReactJson(lazy(() => import("@microlink/react-json-view")));
+    }
+  }, [_ProvidedReactJson]);
+  const shouldCollapse = (field) => {
+    return field.name !== "root" && field.type !== "object" || field.namespace.length > 3;
+  };
+  return data ? /* @__PURE__ */ jsxs(
+    Stack,
+    {
+      direction: "column",
+      spacing: 1,
+      ...slotProps == null ? void 0 : slotProps.stack,
+      sx: {
+        "& > div:first-of-type": { mt: 1, mr: 0.5 },
+        ...Array.isArray((_a = slotProps == null ? void 0 : slotProps.stack) == null ? void 0 : _a.sx) ? (_b = slotProps == null ? void 0 : slotProps.stack) == null ? void 0 : _b.sx : [(_c = slotProps == null ? void 0 : slotProps.stack) == null ? void 0 : _c.sx]
+      },
+      children: [
+        !hideSearch && /* @__PURE__ */ jsx(
+          TuiPhrase,
+          {
+            value: query,
+            onChange: setQuery,
+            size: "small",
+            error: hasError,
+            label: t("json.viewer.search.label"),
+            placeholder: t("json.viewer.search.prompt")
+          }
+        ),
+        ReactJson && /* @__PURE__ */ jsx(
+          ReactJson,
+          {
+            src: searchedData,
+            theme: isDark ? "summerfruit" : "summerfruit:inverted",
+            indentWidth: 2,
+            displayDataTypes: !compact && !forceCompact,
+            displayObjectSize: !compact && !forceCompact,
+            shouldCollapse: collapse ? shouldCollapse : false,
+            quotesOnKeys: false,
+            style: {
+              flex: 1,
+              overflow: "auto",
+              height: "100%",
+              fontSize: compact || forceCompact ? "small" : "smaller",
+              borderRadius: theme.shape.borderRadius,
+              padding: theme.spacing(1)
+            },
+            enableClipboard: (_data) => {
+              if (typeof _data.src === "string") {
+                navigator.clipboard.writeText(_data.src);
+              } else {
+                navigator.clipboard.writeText(JSON.stringify(_data.src));
+              }
+            },
+            ...{
+              // Type declaration is wrong - this is a valid prop
+              displayArrayKey: !compact && !forceCompact
+            },
+            ...slotProps == null ? void 0 : slotProps.json
+          }
+        )
+      ]
+    }
+  ) : /* @__PURE__ */ jsx(Skeleton, { width: "100%", height: "95%", variant: "rounded" });
+};
+export {
+  JSONViewer as J,
+  parseEvent as p
+};

package/isNil-CIubwp4T.js

@@ -0,0 +1,6 @@
+function isNil(value) {
+  return value == null;
+}
+export {
+  isNil as i
+};

package/isObject-FTY-5JQX.js

@@ -0,0 +1,7 @@
+function isObject(value) {
+  var type = typeof value;
+  return value != null && (type == "object" || type == "function");
+}
+export {
+  isObject as i
+};

package/isObjectLike-OAgjjZye.js

@@ -0,0 +1,48 @@
+var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root = freeGlobal || freeSelf || Function("return this")();
+var Symbol$1 = root.Symbol;
+var objectProto$1 = Object.prototype;
+var hasOwnProperty = objectProto$1.hasOwnProperty;
+var nativeObjectToString$1 = objectProto$1.toString;
+var symToStringTag$1 = Symbol$1 ? Symbol$1.toStringTag : void 0;
+function getRawTag(value) {
+  var isOwn = hasOwnProperty.call(value, symToStringTag$1), tag = value[symToStringTag$1];
+  try {
+    value[symToStringTag$1] = void 0;
+    var unmasked = true;
+  } catch (e) {
+  }
+  var result = nativeObjectToString$1.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag$1] = tag;
+    } else {
+      delete value[symToStringTag$1];
+    }
+  }
+  return result;
+}
+var objectProto = Object.prototype;
+var nativeObjectToString = objectProto.toString;
+function objectToString(value) {
+  return nativeObjectToString.call(value);
+}
+var nullTag = "[object Null]", undefinedTag = "[object Undefined]";
+var symToStringTag = Symbol$1 ? Symbol$1.toStringTag : void 0;
+function baseGetTag(value) {
+  if (value == null) {
+    return value === void 0 ? undefinedTag : nullTag;
+  }
+  return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+}
+function isObjectLike(value) {
+  return value != null && typeof value == "object";
+}
+export {
+  Symbol$1 as S,
+  baseGetTag as b,
+  freeGlobal as f,
+  isObjectLike as i,
+  root as r
+};

package/isSymbol-Xd2FsJyp.js

@@ -0,0 +1,8 @@
+import { i as isObjectLike, b as baseGetTag } from "./isObjectLike-OAgjjZye.js";
+var symbolTag = "[object Symbol]";
+function isSymbol(value) {
+  return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag;
+}
+export {
+  isSymbol as i
+};

package/last-CUCl67Im.js

@@ -0,0 +1,7 @@
+function last(array) {
+  var length = array == null ? 0 : array.length;
+  return length ? array[length - 1] : void 0;
+}
+export {
+  last as l
+};

package/main.js

@@ -1,63 +1,63 @@
-import { A as t, u as r, a, b as f, c as u } from "./ActionForm-DlOXqMUx.js";
-import { default as n } from "./components/AnnotationDetailPopover.js";
-import { A as l } from "./AnnotationDetails-Bk-p0F6h.js";
-import { default as m } from "./components/AnnotationEntry.js";
-import { A as d, C as i } from "./AnnotationPreview-jzZvkCxJ.js";
-import { default as A } from "./components/CountBadge.js";
-import { default as E } from "./components/EnrichedCard.js";
-import { default as b } from "./components/EnrichedChip.js";
-import { default as D } from "./components/EnrichedTypography.js";
-import { default as g } from "./components/fetchers/Fetcher.js";
-import { default as I } from "./components/fetchers/StatusChip.js";
-import { default as T } from "./components/group/Entry.js";
-import { default as G } from "./components/group/Group.js";
-import { default as _ } from "./components/group/GroupControl.js";
-import { default as q } from "./components/SourcePicker.js";
-import { SNACKBAR_EVENT_ID as K } from "./data/event.js";
-import { b as R } from "./index-BHAe_V9n.js";
-import { ClueComponentContext as j } from "./hooks/ClueComponentContext.js";
-import { ClueConfigContext as H } from "./hooks/ClueConfigProvider.js";
-import { ClueDatabaseContext as L } from "./hooks/ClueDatabaseContext.js";
-import { C as Q } from "./ClueEnrichContext-KqRuuWNS.js";
-import { ClueProvider as W } from "./hooks/ClueProvider.js";
-import { default as Y } from "./hooks/useClue.js";
-import { default as $ } from "./hooks/useClueConfig.js";
-import { default as oe } from "./icons/Assessment.js";
-import { default as re } from "./icons/Context.js";
-import { default as fe } from "./icons/Opinion.js";
-import { default as se } from "./text/Frequency.js";
+import { A, u, a, b, c } from "./ActionForm-BdW0Za1y.js";
+import { default as default2 } from "./components/AnnotationDetailPopover.js";
+import { A as A2 } from "./AnnotationDetails-BHZFzyt-.js";
+import { default as default3 } from "./components/AnnotationEntry.js";
+import { A as A3, C } from "./AnnotationPreview-DGoyoxRb.js";
+import { default as default4 } from "./components/CountBadge.js";
+import { default as default5 } from "./components/EnrichedCard.js";
+import { default as default6 } from "./components/EnrichedChip.js";
+import { default as default7 } from "./components/EnrichedTypography.js";
+import { default as default8 } from "./components/fetchers/Fetcher.js";
+import { default as default9 } from "./components/fetchers/StatusChip.js";
+import { default as default10 } from "./components/group/Entry.js";
+import { default as default11 } from "./components/group/Group.js";
+import { default as default12 } from "./components/group/GroupControl.js";
+import { default as default13 } from "./components/SourcePicker.js";
+import { SNACKBAR_EVENT_ID } from "./data/event.js";
+import { b as b2 } from "./index-C12gPw2W.js";
+import { ClueComponentContext } from "./hooks/ClueComponentContext.js";
+import { ClueConfigContext } from "./hooks/ClueConfigProvider.js";
+import { ClueDatabaseContext } from "./hooks/ClueDatabaseContext.js";
+import { C as C2 } from "./ClueEnrichContext-CJEJxrgs.js";
+import { ClueProvider } from "./hooks/ClueProvider.js";
+import { default as default14 } from "./hooks/useClue.js";
+import { default as default15 } from "./hooks/useClueConfig.js";
+import { default as default16 } from "./icons/Assessment.js";
+import { default as default17 } from "./icons/Context.js";
+import { default as default18 } from "./icons/Opinion.js";
+import { default as default19 } from "./text/Frequency.js";
 export {
-  t as ActionForm,
-  n as AnnotationDetailPopover,
-  l as AnnotationDetails,
-  m as AnnotationEntry,
-  d as AnnotationPreview,
-  oe as AssessmentIcon,
-  j as ClueComponentContext,
-  H as ClueConfigContext,
-  L as ClueDatabaseContext,
-  Q as ClueEnrichContext,
-  i as CluePopupContext,
-  W as ClueProvider,
-  re as ContextIcon,
-  A as CountBadge,
-  E as EnrichedCard,
-  b as EnrichedChip,
-  D as EnrichedTypography,
-  T as Entry,
-  g as Fetcher,
-  se as FrequencyText,
-  G as Group,
-  _ as GroupControl,
-  fe as OpinionIcon,
-  K as SNACKBAR_EVENT_ID,
-  q as SourcePicker,
-  I as StatusChip,
-  R as buildDatabase,
-  Y as useClue,
-  r as useClueActions,
+  A as ActionForm,
+  default2 as AnnotationDetailPopover,
+  A2 as AnnotationDetails,
+  default3 as AnnotationEntry,
+  A3 as AnnotationPreview,
+  default16 as AssessmentIcon,
+  ClueComponentContext,
+  ClueConfigContext,
+  ClueDatabaseContext,
+  C2 as ClueEnrichContext,
+  C as CluePopupContext,
+  ClueProvider,
+  default17 as ContextIcon,
+  default4 as CountBadge,
+  default5 as EnrichedCard,
+  default6 as EnrichedChip,
+  default7 as EnrichedTypography,
+  default10 as Entry,
+  default8 as Fetcher,
+  default19 as FrequencyText,
+  default11 as Group,
+  default12 as GroupControl,
+  default18 as OpinionIcon,
+  SNACKBAR_EVENT_ID,
+  default13 as SourcePicker,
+  default9 as StatusChip,
+  b2 as buildDatabase,
+  default14 as useClue,
+  u as useClueActions,
   a as useClueActionsSelector,
-  $ as useClueConfig,
-  f as useClueEnrichSelector,
-  u as useClueFetcherSelector
+  default15 as useClueConfig,
+  b as useClueEnrichSelector,
+  c as useClueFetcherSelector
 };

package/maxBy-IKHzFrCS.js

@@ -0,0 +1,8 @@
+import { b as baseExtremum, a as baseGt } from "./_baseExtremum-kob8QXyt.js";
+import { b as baseIteratee } from "./_baseIteratee-avi7MX2o.js";
+function maxBy(array, iteratee) {
+  return array && array.length ? baseExtremum(array, baseIteratee(iteratee), baseGt) : void 0;
+}
+export {
+  maxBy as m
+};

package/package.json

@@ -66,7 +66,7 @@
   },
   "type": "module",
   "types": "main.d.ts",
-  "version": "1.2.3",
+  "version": "1.2.4-dev.278",
   "exports": {
     ".": "./main.js",
     "./index.css": "./index.css",