@apiuikit/web-component 1.3.0 → 1.5.0

package/dist/crystal-BtD5fR4q-B1F7Ovrt.js

@@ -0,0 +1,283 @@
+function v(e) {
+  const i = "(_?[ui](8|16|32|64|128))?", g = "(_?f(32|64))?", d = "[a-zA-Z_]\\w*[!?=]?", s = "[a-zA-Z_]\\w*[!?=]?|[-+~]@|<<|>>|[=!]~|===?|<=>|[<>]=?|\\*\\*|[-/+%^&*~|]|//|//=|&[-+*]=?|&\\*\\*|\\[\\][=?]?", t = "[A-Za-z_]\\w*(::\\w+)*(\\?|!)?", c = {
+    $pattern: d,
+    keyword: "abstract alias annotation as as? asm begin break case class def do else elsif end ensure enum extend for fun if include instance_sizeof is_a? lib macro module next nil? of out pointerof private protected rescue responds_to? return require select self sizeof struct super then type typeof union uninitialized unless until verbatim when while with yield __DIR__ __END_LINE__ __FILE__ __LINE__",
+    literal: "false nil true"
+  }, a = {
+    className: "subst",
+    begin: /#\{/,
+    end: /\}/,
+    keywords: c
+  }, _ = {
+    // negative-look forward attemps to prevent false matches like:
+    // @ident@ or $ident$ that might indicate this is not ruby at all
+    className: "variable",
+    begin: "(\\$\\W)|((\\$|@@?)(\\w+))(?=[^@$?])(?![A-Za-z])(?![@$?'])"
+  }, b = {
+    className: "template-variable",
+    variants: [
+      {
+        begin: "\\{\\{",
+        end: "\\}\\}"
+      },
+      {
+        begin: "\\{%",
+        end: "%\\}"
+      }
+    ],
+    keywords: c
+  };
+  function n(N, f) {
+    const l = [
+      {
+        begin: N,
+        end: f
+      }
+    ];
+    return l[0].contains = l, l;
+  }
+  const o = {
+    className: "string",
+    contains: [
+      e.BACKSLASH_ESCAPE,
+      a
+    ],
+    variants: [
+      {
+        begin: /'/,
+        end: /'/
+      },
+      {
+        begin: /"/,
+        end: /"/
+      },
+      {
+        begin: /`/,
+        end: /`/
+      },
+      {
+        begin: "%[Qwi]?\\(",
+        end: "\\)",
+        contains: n("\\(", "\\)")
+      },
+      {
+        begin: "%[Qwi]?\\[",
+        end: "\\]",
+        contains: n("\\[", "\\]")
+      },
+      {
+        begin: "%[Qwi]?\\{",
+        end: /\}/,
+        contains: n(/\{/, /\}/)
+      },
+      {
+        begin: "%[Qwi]?<",
+        end: ">",
+        contains: n("<", ">")
+      },
+      {
+        begin: "%[Qwi]?\\|",
+        end: "\\|"
+      },
+      {
+        begin: /<<-\w+$/,
+        end: /^\s*\w+$/
+      }
+    ],
+    relevance: 0
+  }, E = {
+    className: "string",
+    variants: [
+      {
+        begin: "%q\\(",
+        end: "\\)",
+        contains: n("\\(", "\\)")
+      },
+      {
+        begin: "%q\\[",
+        end: "\\]",
+        contains: n("\\[", "\\]")
+      },
+      {
+        begin: "%q\\{",
+        end: /\}/,
+        contains: n(/\{/, /\}/)
+      },
+      {
+        begin: "%q<",
+        end: ">",
+        contains: n("<", ">")
+      },
+      {
+        begin: "%q\\|",
+        end: "\\|"
+      },
+      {
+        begin: /<<-'\w+'$/,
+        end: /^\s*\w+$/
+      }
+    ],
+    relevance: 0
+  }, u = {
+    begin: "(?!%\\})(" + e.RE_STARTERS_RE + "|\\n|\\b(case|if|select|unless|until|when|while)\\b)\\s*",
+    keywords: "case if select unless until when while",
+    contains: [
+      {
+        className: "regexp",
+        contains: [
+          e.BACKSLASH_ESCAPE,
+          a
+        ],
+        variants: [
+          {
+            begin: "//[a-z]*",
+            relevance: 0
+          },
+          {
+            begin: "/(?!\\/)",
+            end: "/[a-z]*"
+          }
+        ]
+      }
+    ],
+    relevance: 0
+  }, w = {
+    className: "regexp",
+    contains: [
+      e.BACKSLASH_ESCAPE,
+      a
+    ],
+    variants: [
+      {
+        begin: "%r\\(",
+        end: "\\)",
+        contains: n("\\(", "\\)")
+      },
+      {
+        begin: "%r\\[",
+        end: "\\]",
+        contains: n("\\[", "\\]")
+      },
+      {
+        begin: "%r\\{",
+        end: /\}/,
+        contains: n(/\{/, /\}/)
+      },
+      {
+        begin: "%r<",
+        end: ">",
+        contains: n("<", ">")
+      },
+      {
+        begin: "%r\\|",
+        end: "\\|"
+      }
+    ],
+    relevance: 0
+  }, m = {
+    className: "meta",
+    begin: "@\\[",
+    end: "\\]",
+    contains: [e.inherit(e.QUOTE_STRING_MODE, { className: "string" })]
+  }, r = [
+    b,
+    o,
+    E,
+    w,
+    u,
+    m,
+    _,
+    e.HASH_COMMENT_MODE,
+    {
+      className: "class",
+      beginKeywords: "class module struct",
+      end: "$|;",
+      illegal: /=/,
+      contains: [
+        e.HASH_COMMENT_MODE,
+        e.inherit(e.TITLE_MODE, { begin: t }),
+        {
+          // relevance booster for inheritance
+          begin: "<"
+        }
+      ]
+    },
+    {
+      className: "class",
+      beginKeywords: "lib enum union",
+      end: "$|;",
+      illegal: /=/,
+      contains: [
+        e.HASH_COMMENT_MODE,
+        e.inherit(e.TITLE_MODE, { begin: t })
+      ]
+    },
+    {
+      beginKeywords: "annotation",
+      end: "$|;",
+      illegal: /=/,
+      contains: [
+        e.HASH_COMMENT_MODE,
+        e.inherit(e.TITLE_MODE, { begin: t })
+      ],
+      relevance: 2
+    },
+    {
+      className: "function",
+      beginKeywords: "def",
+      end: /\B\b/,
+      contains: [
+        e.inherit(e.TITLE_MODE, {
+          begin: s,
+          endsParent: !0
+        })
+      ]
+    },
+    {
+      className: "function",
+      beginKeywords: "fun macro",
+      end: /\B\b/,
+      contains: [
+        e.inherit(e.TITLE_MODE, {
+          begin: s,
+          endsParent: !0
+        })
+      ],
+      relevance: 2
+    },
+    {
+      className: "symbol",
+      begin: e.UNDERSCORE_IDENT_RE + "(!|\\?)?:",
+      relevance: 0
+    },
+    {
+      className: "symbol",
+      begin: ":",
+      contains: [
+        o,
+        { begin: s }
+      ],
+      relevance: 0
+    },
+    {
+      className: "number",
+      variants: [
+        { begin: "\\b0b([01_]+)" + i },
+        { begin: "\\b0o([0-7_]+)" + i },
+        { begin: "\\b0x([A-Fa-f0-9_]+)" + i },
+        { begin: "\\b([1-9][0-9_]*[0-9]|[0-9])(\\.[0-9][0-9_]*)?([eE]_?[-+]?[0-9_]*)?" + g + "(?!_)" },
+        { begin: "\\b([1-9][0-9_]*|0)" + i }
+      ],
+      relevance: 0
+    }
+  ];
+  return a.contains = r, b.contains = r.slice(1), {
+    name: "Crystal",
+    aliases: ["cr"],
+    keywords: c,
+    contains: r
+  };
+}
+export {
+  v as default
+};

package/dist/csharp-AnFv7wyC-DBJ0ahb9.js

@@ -0,0 +1,382 @@
+function m(e) {
+  const g = [
+    "bool",
+    "byte",
+    "char",
+    "decimal",
+    "delegate",
+    "double",
+    "dynamic",
+    "enum",
+    "float",
+    "int",
+    "long",
+    "nint",
+    "nuint",
+    "object",
+    "sbyte",
+    "short",
+    "string",
+    "ulong",
+    "uint",
+    "ushort"
+  ], E = [
+    "public",
+    "private",
+    "protected",
+    "static",
+    "internal",
+    "protected",
+    "abstract",
+    "async",
+    "extern",
+    "override",
+    "unsafe",
+    "virtual",
+    "new",
+    "sealed",
+    "partial"
+  ], _ = [
+    "default",
+    "false",
+    "null",
+    "true"
+  ], b = [
+    "abstract",
+    "as",
+    "base",
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "continue",
+    "do",
+    "else",
+    "event",
+    "explicit",
+    "extern",
+    "finally",
+    "fixed",
+    "for",
+    "foreach",
+    "goto",
+    "if",
+    "implicit",
+    "in",
+    "interface",
+    "internal",
+    "is",
+    "lock",
+    "namespace",
+    "new",
+    "operator",
+    "out",
+    "override",
+    "params",
+    "private",
+    "protected",
+    "public",
+    "readonly",
+    "record",
+    "ref",
+    "return",
+    "scoped",
+    "sealed",
+    "sizeof",
+    "stackalloc",
+    "static",
+    "struct",
+    "switch",
+    "this",
+    "throw",
+    "try",
+    "typeof",
+    "unchecked",
+    "unsafe",
+    "using",
+    "virtual",
+    "void",
+    "volatile",
+    "while"
+  ], u = [
+    "add",
+    "alias",
+    "and",
+    "ascending",
+    "args",
+    "async",
+    "await",
+    "by",
+    "descending",
+    "dynamic",
+    "equals",
+    "file",
+    "from",
+    "get",
+    "global",
+    "group",
+    "init",
+    "into",
+    "join",
+    "let",
+    "nameof",
+    "not",
+    "notnull",
+    "on",
+    "or",
+    "orderby",
+    "partial",
+    "record",
+    "remove",
+    "required",
+    "scoped",
+    "select",
+    "set",
+    "unmanaged",
+    "value|0",
+    "var",
+    "when",
+    "where",
+    "with",
+    "yield"
+  ], n = {
+    keyword: b.concat(u),
+    built_in: g,
+    literal: _
+  }, i = e.inherit(e.TITLE_MODE, { begin: "[a-zA-Z](\\.?\\w)*" }), a = {
+    className: "number",
+    variants: [
+      { begin: "\\b(0b[01']+)" },
+      { begin: "(-?)\\b([\\d']+(\\.[\\d']*)?|\\.[\\d']+)(u|U|l|L|ul|UL|f|F|b|B)" },
+      { begin: "(-?)(\\b0[xX][a-fA-F0-9']+|(\\b[\\d']+(\\.[\\d']*)?|\\.[\\d']+)([eE][-+]?[\\d']+)?)" }
+    ],
+    relevance: 0
+  }, M = {
+    className: "string",
+    begin: /"""("*)(?!")(.|\n)*?"""\1/,
+    relevance: 1
+  }, s = {
+    className: "string",
+    begin: '@"',
+    end: '"',
+    contains: [{ begin: '""' }]
+  }, O = e.inherit(s, { illegal: /\n/ }), t = {
+    className: "subst",
+    begin: /\{/,
+    end: /\}/,
+    keywords: n
+  }, r = e.inherit(t, { illegal: /\n/ }), l = {
+    className: "string",
+    begin: /\$"/,
+    end: '"',
+    illegal: /\n/,
+    contains: [
+      { begin: /\{\{/ },
+      { begin: /\}\}/ },
+      e.BACKSLASH_ESCAPE,
+      r
+    ]
+  }, c = {
+    className: "string",
+    begin: /\$@"/,
+    end: '"',
+    contains: [
+      { begin: /\{\{/ },
+      { begin: /\}\}/ },
+      { begin: '""' },
+      t
+    ]
+  }, N = e.inherit(c, {
+    illegal: /\n/,
+    contains: [
+      { begin: /\{\{/ },
+      { begin: /\}\}/ },
+      { begin: '""' },
+      r
+    ]
+  });
+  t.contains = [
+    c,
+    l,
+    s,
+    e.APOS_STRING_MODE,
+    e.QUOTE_STRING_MODE,
+    a,
+    e.C_BLOCK_COMMENT_MODE
+  ], r.contains = [
+    N,
+    l,
+    O,
+    e.APOS_STRING_MODE,
+    e.QUOTE_STRING_MODE,
+    a,
+    e.inherit(e.C_BLOCK_COMMENT_MODE, { illegal: /\n/ })
+  ];
+  const d = { variants: [
+    M,
+    c,
+    l,
+    s,
+    e.APOS_STRING_MODE,
+    e.QUOTE_STRING_MODE
+  ] }, o = {
+    begin: "<",
+    end: ">",
+    contains: [
+      { beginKeywords: "in out" },
+      i
+    ]
+  }, C = e.IDENT_RE + "(<" + e.IDENT_RE + "(\\s*,\\s*" + e.IDENT_RE + ")*>)?(\\[\\])?", T = {
+    // prevents expressions like `@class` from incorrect flagging
+    // `class` as a keyword
+    begin: "@" + e.IDENT_RE,
+    relevance: 0
+  };
+  return {
+    name: "C#",
+    aliases: [
+      "cs",
+      "c#"
+    ],
+    keywords: n,
+    illegal: /::/,
+    contains: [
+      e.COMMENT(
+        "///",
+        "$",
+        {
+          returnBegin: !0,
+          contains: [
+            {
+              className: "doctag",
+              variants: [
+                {
+                  begin: "///",
+                  relevance: 0
+                },
+                { begin: "<!--|-->" },
+                {
+                  begin: "</?",
+                  end: ">"
+                }
+              ]
+            }
+          ]
+        }
+      ),
+      e.C_LINE_COMMENT_MODE,
+      e.C_BLOCK_COMMENT_MODE,
+      {
+        className: "meta",
+        begin: "#",
+        end: "$",
+        keywords: { keyword: "if else elif endif define undef warning error line region endregion pragma checksum" }
+      },
+      d,
+      a,
+      {
+        beginKeywords: "class interface",
+        relevance: 0,
+        end: /[{;=]/,
+        illegal: /[^\s:,]/,
+        contains: [
+          { beginKeywords: "where class" },
+          i,
+          o,
+          e.C_LINE_COMMENT_MODE,
+          e.C_BLOCK_COMMENT_MODE
+        ]
+      },
+      {
+        beginKeywords: "namespace",
+        relevance: 0,
+        end: /[{;=]/,
+        illegal: /[^\s:]/,
+        contains: [
+          i,
+          e.C_LINE_COMMENT_MODE,
+          e.C_BLOCK_COMMENT_MODE
+        ]
+      },
+      {
+        beginKeywords: "record",
+        relevance: 0,
+        end: /[{;=]/,
+        illegal: /[^\s:]/,
+        contains: [
+          i,
+          o,
+          e.C_LINE_COMMENT_MODE,
+          e.C_BLOCK_COMMENT_MODE
+        ]
+      },
+      {
+        // [Attributes("")]
+        className: "meta",
+        begin: "^\\s*\\[(?=[\\w])",
+        excludeBegin: !0,
+        end: "\\]",
+        excludeEnd: !0,
+        contains: [
+          {
+            className: "string",
+            begin: /"/,
+            end: /"/
+          }
+        ]
+      },
+      {
+        // Expression keywords prevent 'keyword Name(...)' from being
+        // recognized as a function definition
+        beginKeywords: "new return throw await else",
+        relevance: 0
+      },
+      {
+        className: "function",
+        begin: "(" + C + "\\s+)+" + e.IDENT_RE + "\\s*(<[^=]+>\\s*)?\\(",
+        returnBegin: !0,
+        end: /\s*[{;=]/,
+        excludeEnd: !0,
+        keywords: n,
+        contains: [
+          // prevents these from being highlighted `title`
+          {
+            beginKeywords: E.join(" "),
+            relevance: 0
+          },
+          {
+            begin: e.IDENT_RE + "\\s*(<[^=]+>\\s*)?\\(",
+            returnBegin: !0,
+            contains: [
+              e.TITLE_MODE,
+              o
+            ],
+            relevance: 0
+          },
+          { match: /\(\)/ },
+          {
+            className: "params",
+            begin: /\(/,
+            end: /\)/,
+            excludeBegin: !0,
+            excludeEnd: !0,
+            keywords: n,
+            relevance: 0,
+            contains: [
+              d,
+              a,
+              e.C_BLOCK_COMMENT_MODE
+            ]
+          },
+          e.C_LINE_COMMENT_MODE,
+          e.C_BLOCK_COMMENT_MODE
+        ]
+      },
+      T
+    ]
+  };
+}
+export {
+  m as default
+};

package/dist/elements/asyncapi-info.d.ts

@@ -0,0 +1,7 @@
+import { ConfigInterface, AsyncAPIDocumentData, SectionLayout } from 'apiuikit';
+export interface AsyncApiInfoElementProps {
+    spec?: AsyncAPIDocumentData;
+    config?: ConfigInterface;
+    layout?: SectionLayout;
+}
+export declare function AsyncApiInfoElement({ spec, config, layout }: AsyncApiInfoElementProps): import("react").JSX.Element | null;

package/dist/elements/asyncapi-info.js

@@ -0,0 +1,17 @@
+import { d as s, s as t, j as e, X as r } from "../registerElement-DAVqIcyy.js";
+function p({ spec: n, config: i, layout: o }) {
+  return n ? /* @__PURE__ */ e.jsx(r, { document: n, config: i, layout: o }) : null;
+}
+s(
+  "apiuikit-asyncapi-info",
+  t(p, {
+    props: {
+      spec: void 0,
+      config: "json",
+      layout: "string"
+    }
+  })
+);
+export {
+  p as AsyncApiInfoElement
+};

package/dist/elements/asyncapi-messages.d.ts

@@ -0,0 +1,7 @@
+import { ConfigInterface, AsyncAPIDocumentData, SectionLayout } from 'apiuikit';
+export interface AsyncApiMessagesElementProps {
+    spec?: AsyncAPIDocumentData;
+    config?: ConfigInterface;
+    layout?: SectionLayout;
+}
+export declare function AsyncApiMessagesElement({ spec, config, layout }: AsyncApiMessagesElementProps): import("react").JSX.Element | null;

package/dist/elements/asyncapi-messages.js

@@ -0,0 +1,17 @@
+import { d as i, s as t, j as o, J as r } from "../registerElement-DAVqIcyy.js";
+function a({ spec: s, config: n, layout: e }) {
+  return s ? /* @__PURE__ */ o.jsx(r, { document: s, config: n, layout: e }) : null;
+}
+i(
+  "apiuikit-asyncapi-messages",
+  t(a, {
+    props: {
+      spec: void 0,
+      config: "json",
+      layout: "string"
+    }
+  })
+);
+export {
+  a as AsyncApiMessagesElement
+};