@clickhouse/click-ui 0.0.177 → 0.0.178

package/dist/click-ui.es.js

@@ -5,7 +5,7 @@ var __publicField = (obj, key, value) => {
   return value;
 };
 import { jsxs, jsx, Fragment as Fragment$1 } from "react/jsx-runtime";
-import styled$1, { keyframes, styled, useTheme, createGlobalStyle, ThemeProvider as ThemeProvider$1 } from "styled-components";
+import { keyframes, styled, useTheme, css as css$1, createGlobalStyle, ThemeProvider as ThemeProvider$1 } from "styled-components";
 import * as React from "react";
 import React__default, { forwardRef, useCallback, createContext, useMemo, createElement as createElement$1, useContext, useRef, useEffect, useState, Children, isValidElement, cloneElement, Fragment, useLayoutEffect, useReducer, useId, PureComponent, Component, memo } from "react";
 import * as ReactDOM from "react-dom";
@@ -13547,6 +13547,634 @@ function requireSql() {
   sql_1 = sql2;
   return sql_1;
 }
+var typescript_1;
+var hasRequiredTypescript;
+function requireTypescript() {
+  if (hasRequiredTypescript)
+    return typescript_1;
+  hasRequiredTypescript = 1;
+  const IDENT_RE2 = "[A-Za-z$_][0-9A-Za-z$_]*";
+  const KEYWORDS = [
+    "as",
+    // for exports
+    "in",
+    "of",
+    "if",
+    "for",
+    "while",
+    "finally",
+    "var",
+    "new",
+    "function",
+    "do",
+    "return",
+    "void",
+    "else",
+    "break",
+    "catch",
+    "instanceof",
+    "with",
+    "throw",
+    "case",
+    "default",
+    "try",
+    "switch",
+    "continue",
+    "typeof",
+    "delete",
+    "let",
+    "yield",
+    "const",
+    "class",
+    // JS handles these with a special rule
+    // "get",
+    // "set",
+    "debugger",
+    "async",
+    "await",
+    "static",
+    "import",
+    "from",
+    "export",
+    "extends"
+  ];
+  const LITERALS = [
+    "true",
+    "false",
+    "null",
+    "undefined",
+    "NaN",
+    "Infinity"
+  ];
+  const TYPES = [
+    "Intl",
+    "DataView",
+    "Number",
+    "Math",
+    "Date",
+    "String",
+    "RegExp",
+    "Object",
+    "Function",
+    "Boolean",
+    "Error",
+    "Symbol",
+    "Set",
+    "Map",
+    "WeakSet",
+    "WeakMap",
+    "Proxy",
+    "Reflect",
+    "JSON",
+    "Promise",
+    "Float64Array",
+    "Int16Array",
+    "Int32Array",
+    "Int8Array",
+    "Uint16Array",
+    "Uint32Array",
+    "Float32Array",
+    "Array",
+    "Uint8Array",
+    "Uint8ClampedArray",
+    "ArrayBuffer",
+    "BigInt64Array",
+    "BigUint64Array",
+    "BigInt"
+  ];
+  const ERROR_TYPES = [
+    "EvalError",
+    "InternalError",
+    "RangeError",
+    "ReferenceError",
+    "SyntaxError",
+    "TypeError",
+    "URIError"
+  ];
+  const BUILT_IN_GLOBALS = [
+    "setInterval",
+    "setTimeout",
+    "clearInterval",
+    "clearTimeout",
+    "require",
+    "exports",
+    "eval",
+    "isFinite",
+    "isNaN",
+    "parseFloat",
+    "parseInt",
+    "decodeURI",
+    "decodeURIComponent",
+    "encodeURI",
+    "encodeURIComponent",
+    "escape",
+    "unescape"
+  ];
+  const BUILT_IN_VARIABLES = [
+    "arguments",
+    "this",
+    "super",
+    "console",
+    "window",
+    "document",
+    "localStorage",
+    "module",
+    "global"
+    // Node.js
+  ];
+  const BUILT_INS = [].concat(
+    BUILT_IN_GLOBALS,
+    BUILT_IN_VARIABLES,
+    TYPES,
+    ERROR_TYPES
+  );
+  function source2(re) {
+    if (!re)
+      return null;
+    if (typeof re === "string")
+      return re;
+    return re.source;
+  }
+  function lookahead(re) {
+    return concat2("(?=", re, ")");
+  }
+  function concat2(...args) {
+    const joined = args.map((x) => source2(x)).join("");
+    return joined;
+  }
+  function javascript(hljs) {
+    const hasClosingTag = (match, { after }) => {
+      const tag2 = "</" + match[0].slice(1);
+      const pos = match.input.indexOf(tag2, after);
+      return pos !== -1;
+    };
+    const IDENT_RE$1 = IDENT_RE2;
+    const FRAGMENT = {
+      begin: "<>",
+      end: "</>"
+    };
+    const XML_TAG = {
+      begin: /<[A-Za-z0-9\\._:-]+/,
+      end: /\/[A-Za-z0-9\\._:-]+>|\/>/,
+      /**
+       * @param {RegExpMatchArray} match
+       * @param {CallbackResponse} response
+       */
+      isTrulyOpeningTag: (match, response) => {
+        const afterMatchIndex = match[0].length + match.index;
+        const nextChar = match.input[afterMatchIndex];
+        if (nextChar === "<") {
+          response.ignoreMatch();
+          return;
+        }
+        if (nextChar === ">") {
+          if (!hasClosingTag(match, { after: afterMatchIndex })) {
+            response.ignoreMatch();
+          }
+        }
+      }
+    };
+    const KEYWORDS$1 = {
+      $pattern: IDENT_RE2,
+      keyword: KEYWORDS,
+      literal: LITERALS,
+      built_in: BUILT_INS
+    };
+    const decimalDigits = "[0-9](_?[0-9])*";
+    const frac = `\\.(${decimalDigits})`;
+    const decimalInteger = `0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*`;
+    const NUMBER = {
+      className: "number",
+      variants: [
+        // DecimalLiteral
+        { begin: `(\\b(${decimalInteger})((${frac})|\\.)?|(${frac}))[eE][+-]?(${decimalDigits})\\b` },
+        { begin: `\\b(${decimalInteger})\\b((${frac})\\b|\\.)?|(${frac})\\b` },
+        // DecimalBigIntegerLiteral
+        { begin: `\\b(0|[1-9](_?[0-9])*)n\\b` },
+        // NonDecimalIntegerLiteral
+        { begin: "\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*n?\\b" },
+        { begin: "\\b0[bB][0-1](_?[0-1])*n?\\b" },
+        { begin: "\\b0[oO][0-7](_?[0-7])*n?\\b" },
+        // LegacyOctalIntegerLiteral (does not include underscore separators)
+        // https://tc39.es/ecma262/#sec-additional-syntax-numeric-literals
+        { begin: "\\b0[0-7]+n?\\b" }
+      ],
+      relevance: 0
+    };
+    const SUBST = {
+      className: "subst",
+      begin: "\\$\\{",
+      end: "\\}",
+      keywords: KEYWORDS$1,
+      contains: []
+      // defined later
+    };
+    const HTML_TEMPLATE = {
+      begin: "html`",
+      end: "",
+      starts: {
+        end: "`",
+        returnEnd: false,
+        contains: [
+          hljs.BACKSLASH_ESCAPE,
+          SUBST
+        ],
+        subLanguage: "xml"
+      }
+    };
+    const CSS_TEMPLATE = {
+      begin: "css`",
+      end: "",
+      starts: {
+        end: "`",
+        returnEnd: false,
+        contains: [
+          hljs.BACKSLASH_ESCAPE,
+          SUBST
+        ],
+        subLanguage: "css"
+      }
+    };
+    const TEMPLATE_STRING = {
+      className: "string",
+      begin: "`",
+      end: "`",
+      contains: [
+        hljs.BACKSLASH_ESCAPE,
+        SUBST
+      ]
+    };
+    const JSDOC_COMMENT = hljs.COMMENT(
+      /\/\*\*(?!\/)/,
+      "\\*/",
+      {
+        relevance: 0,
+        contains: [
+          {
+            className: "doctag",
+            begin: "@[A-Za-z]+",
+            contains: [
+              {
+                className: "type",
+                begin: "\\{",
+                end: "\\}",
+                relevance: 0
+              },
+              {
+                className: "variable",
+                begin: IDENT_RE$1 + "(?=\\s*(-)|$)",
+                endsParent: true,
+                relevance: 0
+              },
+              // eat spaces (not newlines) so we can find
+              // types or variables
+              {
+                begin: /(?=[^\n])\s/,
+                relevance: 0
+              }
+            ]
+          }
+        ]
+      }
+    );
+    const COMMENT2 = {
+      className: "comment",
+      variants: [
+        JSDOC_COMMENT,
+        hljs.C_BLOCK_COMMENT_MODE,
+        hljs.C_LINE_COMMENT_MODE
+      ]
+    };
+    const SUBST_INTERNALS = [
+      hljs.APOS_STRING_MODE,
+      hljs.QUOTE_STRING_MODE,
+      HTML_TEMPLATE,
+      CSS_TEMPLATE,
+      TEMPLATE_STRING,
+      NUMBER,
+      hljs.REGEXP_MODE
+    ];
+    SUBST.contains = SUBST_INTERNALS.concat({
+      // we need to pair up {} inside our subst to prevent
+      // it from ending too early by matching another }
+      begin: /\{/,
+      end: /\}/,
+      keywords: KEYWORDS$1,
+      contains: [
+        "self"
+      ].concat(SUBST_INTERNALS)
+    });
+    const SUBST_AND_COMMENTS = [].concat(COMMENT2, SUBST.contains);
+    const PARAMS_CONTAINS = SUBST_AND_COMMENTS.concat([
+      // eat recursive parens in sub expressions
+      {
+        begin: /\(/,
+        end: /\)/,
+        keywords: KEYWORDS$1,
+        contains: ["self"].concat(SUBST_AND_COMMENTS)
+      }
+    ]);
+    const PARAMS = {
+      className: "params",
+      begin: /\(/,
+      end: /\)/,
+      excludeBegin: true,
+      excludeEnd: true,
+      keywords: KEYWORDS$1,
+      contains: PARAMS_CONTAINS
+    };
+    return {
+      name: "Javascript",
+      aliases: ["js", "jsx", "mjs", "cjs"],
+      keywords: KEYWORDS$1,
+      // this will be extended by TypeScript
+      exports: { PARAMS_CONTAINS },
+      illegal: /#(?![$_A-z])/,
+      contains: [
+        hljs.SHEBANG({
+          label: "shebang",
+          binary: "node",
+          relevance: 5
+        }),
+        {
+          label: "use_strict",
+          className: "meta",
+          relevance: 10,
+          begin: /^\s*['"]use (strict|asm)['"]/
+        },
+        hljs.APOS_STRING_MODE,
+        hljs.QUOTE_STRING_MODE,
+        HTML_TEMPLATE,
+        CSS_TEMPLATE,
+        TEMPLATE_STRING,
+        COMMENT2,
+        NUMBER,
+        {
+          // object attr container
+          begin: concat2(
+            /[{,\n]\s*/,
+            // we need to look ahead to make sure that we actually have an
+            // attribute coming up so we don't steal a comma from a potential
+            // "value" container
+            //
+            // NOTE: this might not work how you think.  We don't actually always
+            // enter this mode and stay.  Instead it might merely match `,
+            // <comments up next>` and then immediately end after the , because it
+            // fails to find any actual attrs. But this still does the job because
+            // it prevents the value contain rule from grabbing this instead and
+            // prevening this rule from firing when we actually DO have keys.
+            lookahead(concat2(
+              // we also need to allow for multiple possible comments inbetween
+              // the first key:value pairing
+              /(((\/\/.*$)|(\/\*(\*[^/]|[^*])*\*\/))\s*)*/,
+              IDENT_RE$1 + "\\s*:"
+            ))
+          ),
+          relevance: 0,
+          contains: [
+            {
+              className: "attr",
+              begin: IDENT_RE$1 + lookahead("\\s*:"),
+              relevance: 0
+            }
+          ]
+        },
+        {
+          // "value" container
+          begin: "(" + hljs.RE_STARTERS_RE + "|\\b(case|return|throw)\\b)\\s*",
+          keywords: "return throw case",
+          contains: [
+            COMMENT2,
+            hljs.REGEXP_MODE,
+            {
+              className: "function",
+              // we have to count the parens to make sure we actually have the
+              // correct bounding ( ) before the =>.  There could be any number of
+              // sub-expressions inside also surrounded by parens.
+              begin: "(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|" + hljs.UNDERSCORE_IDENT_RE + ")\\s*=>",
+              returnBegin: true,
+              end: "\\s*=>",
+              contains: [
+                {
+                  className: "params",
+                  variants: [
+                    {
+                      begin: hljs.UNDERSCORE_IDENT_RE,
+                      relevance: 0
+                    },
+                    {
+                      className: null,
+                      begin: /\(\s*\)/,
+                      skip: true
+                    },
+                    {
+                      begin: /\(/,
+                      end: /\)/,
+                      excludeBegin: true,
+                      excludeEnd: true,
+                      keywords: KEYWORDS$1,
+                      contains: PARAMS_CONTAINS
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              // could be a comma delimited list of params to a function call
+              begin: /,/,
+              relevance: 0
+            },
+            {
+              className: "",
+              begin: /\s/,
+              end: /\s*/,
+              skip: true
+            },
+            {
+              // JSX
+              variants: [
+                { begin: FRAGMENT.begin, end: FRAGMENT.end },
+                {
+                  begin: XML_TAG.begin,
+                  // we carefully check the opening tag to see if it truly
+                  // is a tag and not a false positive
+                  "on:begin": XML_TAG.isTrulyOpeningTag,
+                  end: XML_TAG.end
+                }
+              ],
+              subLanguage: "xml",
+              contains: [
+                {
+                  begin: XML_TAG.begin,
+                  end: XML_TAG.end,
+                  skip: true,
+                  contains: ["self"]
+                }
+              ]
+            }
+          ],
+          relevance: 0
+        },
+        {
+          className: "function",
+          beginKeywords: "function",
+          end: /[{;]/,
+          excludeEnd: true,
+          keywords: KEYWORDS$1,
+          contains: [
+            "self",
+            hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1 }),
+            PARAMS
+          ],
+          illegal: /%/
+        },
+        {
+          // prevent this from getting swallowed up by function
+          // since they appear "function like"
+          beginKeywords: "while if switch catch for"
+        },
+        {
+          className: "function",
+          // we have to count the parens to make sure we actually have the correct
+          // bounding ( ).  There could be any number of sub-expressions inside
+          // also surrounded by parens.
+          begin: hljs.UNDERSCORE_IDENT_RE + "\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",
+          // end parens
+          returnBegin: true,
+          contains: [
+            PARAMS,
+            hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1 })
+          ]
+        },
+        // hack: prevents detection of keywords in some circumstances
+        // .keyword()
+        // $keyword = x
+        {
+          variants: [
+            { begin: "\\." + IDENT_RE$1 },
+            { begin: "\\$" + IDENT_RE$1 }
+          ],
+          relevance: 0
+        },
+        {
+          // ES6 class
+          className: "class",
+          beginKeywords: "class",
+          end: /[{;=]/,
+          excludeEnd: true,
+          illegal: /[:"[\]]/,
+          contains: [
+            { beginKeywords: "extends" },
+            hljs.UNDERSCORE_TITLE_MODE
+          ]
+        },
+        {
+          begin: /\b(?=constructor)/,
+          end: /[{;]/,
+          excludeEnd: true,
+          contains: [
+            hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1 }),
+            "self",
+            PARAMS
+          ]
+        },
+        {
+          begin: "(get|set)\\s+(?=" + IDENT_RE$1 + "\\()",
+          end: /\{/,
+          keywords: "get set",
+          contains: [
+            hljs.inherit(hljs.TITLE_MODE, { begin: IDENT_RE$1 }),
+            { begin: /\(\)/ },
+            // eat to avoid empty params
+            PARAMS
+          ]
+        },
+        {
+          begin: /\$[(.]/
+          // relevance booster for a pattern common to JS libs: `$(something)` and `$.something`
+        }
+      ]
+    };
+  }
+  function typescript2(hljs) {
+    const IDENT_RE$1 = IDENT_RE2;
+    const NAMESPACE = {
+      beginKeywords: "namespace",
+      end: /\{/,
+      excludeEnd: true
+    };
+    const INTERFACE = {
+      beginKeywords: "interface",
+      end: /\{/,
+      excludeEnd: true,
+      keywords: "interface extends"
+    };
+    const USE_STRICT = {
+      className: "meta",
+      relevance: 10,
+      begin: /^\s*['"]use strict['"]/
+    };
+    const TYPES2 = [
+      "any",
+      "void",
+      "number",
+      "boolean",
+      "string",
+      "object",
+      "never",
+      "enum"
+    ];
+    const TS_SPECIFIC_KEYWORDS = [
+      "type",
+      "namespace",
+      "typedef",
+      "interface",
+      "public",
+      "private",
+      "protected",
+      "implements",
+      "declare",
+      "abstract",
+      "readonly"
+    ];
+    const KEYWORDS$1 = {
+      $pattern: IDENT_RE2,
+      keyword: KEYWORDS.concat(TS_SPECIFIC_KEYWORDS),
+      literal: LITERALS,
+      built_in: BUILT_INS.concat(TYPES2)
+    };
+    const DECORATOR = {
+      className: "meta",
+      begin: "@" + IDENT_RE$1
+    };
+    const swapMode = (mode, label, replacement) => {
+      const indx = mode.contains.findIndex((m) => m.label === label);
+      if (indx === -1) {
+        throw new Error("can not find mode to replace");
+      }
+      mode.contains.splice(indx, 1, replacement);
+    };
+    const tsLanguage = javascript(hljs);
+    Object.assign(tsLanguage.keywords, KEYWORDS$1);
+    tsLanguage.exports.PARAMS_CONTAINS.push(DECORATOR);
+    tsLanguage.contains = tsLanguage.contains.concat([
+      DECORATOR,
+      NAMESPACE,
+      INTERFACE
+    ]);
+    swapMode(tsLanguage, "shebang", hljs.SHEBANG());
+    swapMode(tsLanguage, "use_strict", USE_STRICT);
+    const functionDeclaration = tsLanguage.contains.find((m) => m.className === "function");
+    functionDeclaration.relevance = 0;
+    Object.assign(tsLanguage, {
+      name: "TypeScript",
+      aliases: ["ts", "tsx"]
+    });
+    return tsLanguage;
+  }
+  typescript_1 = typescript2;
+  return typescript_1;
+}
 function _setPrototypeOf(o, p) {
   _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf2(o2, p2) {
     o2.__proto__ = p2;
@@ -13562,70 +14190,6 @@ function _assertThisInitialized(self2) {
 }
 var SyntaxHighlighter = highlight$2(core$1, {});
 SyntaxHighlighter.registerLanguage = core$1.registerLanguage;
-var typescript_1;
-var hasRequiredTypescript;
-function requireTypescript() {
-  if (hasRequiredTypescript)
-    return typescript_1;
-  hasRequiredTypescript = 1;
-  typescript_1 = typescript2;
-  typescript2.displayName = "typescript";
-  typescript2.aliases = ["ts"];
-  function typescript2(Prism) {
-    (function(Prism2) {
-      Prism2.languages.typescript = Prism2.languages.extend("javascript", {
-        "class-name": {
-          pattern: /(\b(?:class|extends|implements|instanceof|interface|new|type)\s+)(?!keyof\b)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?:\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?/,
-          lookbehind: true,
-          greedy: true,
-          inside: null
-          // see below
-        },
-        builtin: /\b(?:Array|Function|Promise|any|boolean|console|never|number|string|symbol|unknown)\b/
-      });
-      Prism2.languages.typescript.keyword.push(
-        /\b(?:abstract|declare|is|keyof|readonly|require)\b/,
-        // keywords that have to be followed by an identifier
-        /\b(?:asserts|infer|interface|module|namespace|type)\b(?=\s*(?:[{_$a-zA-Z\xA0-\uFFFF]|$))/,
-        // This is for `import type *, {}`
-        /\btype\b(?=\s*(?:[\{*]|$))/
-      );
-      delete Prism2.languages.typescript["parameter"];
-      delete Prism2.languages.typescript["literal-property"];
-      var typeInside = Prism2.languages.extend("typescript", {});
-      delete typeInside["class-name"];
-      Prism2.languages.typescript["class-name"].inside = typeInside;
-      Prism2.languages.insertBefore("typescript", "function", {
-        decorator: {
-          pattern: /@[$\w\xA0-\uFFFF]+/,
-          inside: {
-            at: {
-              pattern: /^@/,
-              alias: "operator"
-            },
-            function: /^[\s\S]+/
-          }
-        },
-        "generic-function": {
-          // e.g. foo<T extends "bar" | "baz">( ...
-          pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>(?=\s*\()/,
-          greedy: true,
-          inside: {
-            function: /^#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/,
-            generic: {
-              pattern: /<[\s\S]+/,
-              // everything after the first <
-              alias: "class-name",
-              inside: typeInside
-            }
-          }
-        }
-      });
-      Prism2.languages.ts = Prism2.languages.typescript;
-    })(Prism);
-  }
-  return typescript_1;
-}
 const useColorStyle = (defaultTheme) => {
   const theme2 = useTheme();
   const inheritedThemeName = theme2.name !== "classic" ? theme2.name : "light";
@@ -13806,7 +14370,7 @@ const tsx = /* @__PURE__ */ getDefaultExportFromCjs(typescript);
 SyntaxHighlighter.registerLanguage("sql", sql);
 SyntaxHighlighter.registerLanguage("bash", bash);
 SyntaxHighlighter.registerLanguage("json", json);
-SyntaxHighlighter.registerLanguage("text", tsx);
+SyntaxHighlighter.registerLanguage("tsx", tsx);
 const CodeBlockContainer = styled.div.withConfig({
   componentId: "sc-18gnqgi-0"
 })(["width:100%;width:-webkit-fill-available;width:fill-available;width:stretch;position:relative;cursor:pointer;", ""], ({
@@ -14519,7 +15083,7 @@ const selectedDateFormatter = new Intl.DateTimeFormat(locale, {
   year: "numeric"
 });
 const explicitWidth = "250px";
-const HighlightedInputWrapper = styled$1(InputWrapper).withConfig({
+const HighlightedInputWrapper = styled(InputWrapper).withConfig({
   componentId: "sc-1kfphgn-0"
 })(["", " width:", ";}"], ({
   $isActive,
@@ -14527,12 +15091,12 @@ const HighlightedInputWrapper = styled$1(InputWrapper).withConfig({
 }) => {
   return `border: ${theme2.click.datePicker.dateOption.stroke} solid ${$isActive ? theme2.click.datePicker.dateOption.color.stroke.active : theme2.click.field.color.stroke.default};`;
 }, explicitWidth);
-const DatePickerContainer = styled$1(Container).withConfig({
+const DatePickerContainer = styled(Container).withConfig({
   componentId: "sc-1kfphgn-1"
 })(["background:", ";"], ({
   theme: theme2
 }) => theme2.click.datePicker.dateOption.color.background.default);
-const UnselectableTitle = styled$1.h2.withConfig({
+const UnselectableTitle = styled.h2.withConfig({
   componentId: "sc-1kfphgn-2"
 })(["", " user-select:none;"], ({
   theme: theme2
@@ -14540,7 +15104,7 @@ const UnselectableTitle = styled$1.h2.withConfig({
     color: ${theme2.click.datePicker.color.title.default};
     font: ${theme2.click.datePicker.typography.title.default};
   `);
-const DateTable = styled$1.table.withConfig({
+const DateTable = styled.table.withConfig({
   componentId: "sc-1kfphgn-3"
 })(["border-collapse:separate;border-spacing:0;font:", " table-layout:fixed;user-select:none;width:", ";thead tr{height:", ";}tbody{cursor:pointer;}td,th{", ";padding:4px;}"], ({
   theme: theme2
@@ -14549,7 +15113,7 @@ const DateTable = styled$1.table.withConfig({
 }) => theme2.click.datePicker.dateOption.size.height, ({
   theme: theme2
 }) => `border: ${theme2.click.datePicker.dateOption.stroke} solid ${theme2.click.datePicker.dateOption.color.stroke.default}`);
-const DateTableHeader = styled$1.th.withConfig({
+const DateTableHeader = styled.th.withConfig({
   componentId: "sc-1kfphgn-4"
 })(["", " width:14%;"], ({
   theme: theme2
@@ -14557,7 +15121,7 @@ const DateTableHeader = styled$1.th.withConfig({
     color: ${theme2.click.datePicker.color.daytitle.default};
     font: ${theme2.click.datePicker.typography.daytitle.default};
   `);
-const DateTableCell = styled$1.td.withConfig({
+const DateTableCell = styled.td.withConfig({
   componentId: "sc-1kfphgn-5"
 })(["", " ", " ", " text-align:center;", " &:hover{", ";}"], ({
   theme: theme2
@@ -32716,9 +33280,7 @@ const HoverCardContent = ({
 };
 HoverCardContent.displayName = "HoverCardContent";
 HoverCard.Content = HoverCardContent;
-const CuiLink = styled.a.withConfig({
-  componentId: "sc-1bwz77u-0"
-})(["font:", ";color:", ";margin:0;text-decoration:none;display:inline-flex;gap:", ";margin-right:", ";align-items:center;&:hover,&:focus{color:", ";transition:", ";text-decoration:underline;cursor:pointer;}&:visited{color:", ";}"], ({
+const linkStyles = css$1(["font:", ";color:", ";margin:0;text-decoration:none;display:inline-flex;gap:", ";margin-right:", ";align-items:center;&:hover,&:focus{color:", ";transition:", ";text-decoration:underline;cursor:pointer;}&:visited{color:", ";}"], ({
   $size,
   $weight = "normal",
   theme: theme2
@@ -32737,6 +33299,9 @@ const CuiLink = styled.a.withConfig({
 }) => theme2.transition.default, ({
   theme: theme2
 }) => theme2.click.global.color.text.link.default);
+const CuiLink = styled.a.withConfig({
+  componentId: "sc-1bwz77u-0"
+})(["", ""], linkStyles);
 const IconWrapper$1 = styled.span.withConfig({
   componentId: "sc-1bwz77u-1"
 })([".external-icon{height:", ";width:", ";}"], ({
@@ -32968,24 +33533,25 @@ const Pagination = ({
   ] });
 };
 const Panel = ({
-  hasBorder,
-  hasShadow,
+  alignItems = "center",
+  children,
   color,
-  padding,
+  cursor,
+  fillHeight,
+  fillWidth,
   gap,
-  children,
+  hasBorder,
+  hasShadow,
+  height,
   orientation = "horizontal",
-  width,
+  padding,
   radii = "sm",
-  fillWidth,
-  height,
-  fillHeight,
-  alignItems = "center",
+  width,
   ...props
-}) => /* @__PURE__ */ jsx(Wrapper$2, { $hasBorder: hasBorder, $hasShadow: hasShadow, $color: color, $padding: padding, $gap: gap, $width: width, $radii: radii, $orientation: orientation, $fillWidth: fillWidth, $height: height, $fillHeight: fillHeight, $alignItems: alignItems, ...props, children });
+}) => /* @__PURE__ */ jsx(Wrapper$2, { $alignItems: alignItems, $color: color, $cursor: cursor, $fillHeight: fillHeight, $fillWidth: fillWidth, $gap: gap, $hasBorder: hasBorder, $hasShadow: hasShadow, $height: height, $orientation: orientation, $padding: padding, $radii: radii, $width: width, ...props, children });
 const Wrapper$2 = styled.div.withConfig({
   componentId: "sc-1q78udp-0"
-})(["display:flex;flex-flow:", ";align-items:", ";width:", ";height:", ";background-color:", ";border-radius:", ";padding:", ";border:", ";box-shadow:", ";gap:", ";"], ({
+})(["display:flex;flex-flow:", ";align-items:", ";width:", ";height:", ";background-color:", ";border-radius:", ";padding:", ";border:", ";box-shadow:", ";gap:", ";", ";"], ({
   $orientation = "horizontal"
 }) => $orientation === "horizontal" ? "row wrap" : "column", ({
   $alignItems = "center"
@@ -33013,7 +33579,9 @@ const Wrapper$2 = styled.div.withConfig({
 }) => $hasShadow ? theme2.shadow[1] : "none", ({
   $gap = "sm",
   theme: theme2
-}) => theme2.click.panel.space.gap[$gap]);
+}) => theme2.click.panel.space.gap[$gap], ({
+  $cursor
+}) => $cursor && `cursor: ${$cursor}`);
 const ProgressContainer = styled.div.withConfig({
   componentId: "sc-16gr3cg-0"
 })(["display:flex;justify-content:space-between;align-items:center;overflow:hidden;transition:all 100ms ease-in-out;width:100%;width:-webkit-fill-available;width:fill-available;width:stretch;min-height:2px;", ";"], ({
@@ -49536,6 +50104,7 @@ export {
   VerticalStepper,
   WarningAlert,
   createToast,
+  linkStyles,
   themes,
   useCUITheme,
   useToast