@oscloudlab/knowledge-card 0.0.1 → 0.0.2

package/dist/scss-BU4D1BLj.js

@@ -0,0 +1,106 @@
+import { g as u } from "./index-Sj89RFCY.js";
+function c(s, e) {
+  for (var a = 0; a < e.length; a++) {
+    const t = e[a];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const r in t)
+        if (r !== "default" && !(r in s)) {
+          const n = Object.getOwnPropertyDescriptor(t, r);
+          n && Object.defineProperty(s, r, n.get ? n : {
+            enumerable: !0,
+            get: () => t[r]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(s, Symbol.toStringTag, { value: "Module" }));
+}
+var o, i;
+function p() {
+  if (i) return o;
+  i = 1, o = s, s.displayName = "scss", s.aliases = [];
+  function s(e) {
+    e.languages.scss = e.languages.extend("css", {
+      comment: {
+        pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/,
+        lookbehind: !0
+      },
+      atrule: {
+        pattern: /@[\w-](?:\([^()]+\)|[^()\s]|\s+(?!\s))*?(?=\s+[{;])/,
+        inside: {
+          rule: /@[\w-]+/
+          // See rest below
+        }
+      },
+      // url, compassified
+      url: /(?:[-a-z]+-)?url(?=\()/i,
+      // CSS selector regex is not appropriate for Sass
+      // since there can be lot more things (var, @ directive, nesting..)
+      // a selector must start at the end of a property or after a brace (end of other rules or nesting)
+      // it can contain some characters that aren't used for defining rules or end of selector, & (parent selector), or interpolated variable
+      // the end of a selector is found when there is no rules in it ( {} or {\s}) or if there is a property (because an interpolated var
+      // can "pass" as a selector- e.g: proper#{$erty})
+      // this one was hard to do, so please be careful if you edit this one :)
+      selector: {
+        // Initial look-ahead is used to prevent matching of blank selectors
+        pattern: /(?=\S)[^@;{}()]?(?:[^@;{}()\s]|\s+(?!\s)|#\{\$[-\w]+\})+(?=\s*\{(?:\}|\s|[^}][^:{}]*[:{][^}]))/,
+        inside: {
+          parent: {
+            pattern: /&/,
+            alias: "important"
+          },
+          placeholder: /%[-\w]+/,
+          variable: /\$[-\w]+|#\{\$[-\w]+\}/
+        }
+      },
+      property: {
+        pattern: /(?:[-\w]|\$[-\w]|#\{\$[-\w]+\})+(?=\s*:)/,
+        inside: {
+          variable: /\$[-\w]+|#\{\$[-\w]+\}/
+        }
+      }
+    }), e.languages.insertBefore("scss", "atrule", {
+      keyword: [
+        /@(?:content|debug|each|else(?: if)?|extend|for|forward|function|if|import|include|mixin|return|use|warn|while)\b/i,
+        {
+          pattern: /( )(?:from|through)(?= )/,
+          lookbehind: !0
+        }
+      ]
+    }), e.languages.insertBefore("scss", "important", {
+      // var and interpolated vars
+      variable: /\$[-\w]+|#\{\$[-\w]+\}/
+    }), e.languages.insertBefore("scss", "function", {
+      "module-modifier": {
+        pattern: /\b(?:as|hide|show|with)\b/i,
+        alias: "keyword"
+      },
+      placeholder: {
+        pattern: /%[-\w]+/,
+        alias: "selector"
+      },
+      statement: {
+        pattern: /\B!(?:default|optional)\b/i,
+        alias: "keyword"
+      },
+      boolean: /\b(?:false|true)\b/,
+      null: {
+        pattern: /\bnull\b/,
+        alias: "keyword"
+      },
+      operator: {
+        pattern: /(\s)(?:[-+*\/%]|[=!]=|<=?|>=?|and|not|or)(?=\s)/,
+        lookbehind: !0
+      }
+    }), e.languages.scss.atrule.inside.rest = e.languages.scss;
+  }
+  return o;
+}
+var l = p();
+const d = /* @__PURE__ */ u(l), g = /* @__PURE__ */ c({
+  __proto__: null,
+  default: d
+}, [l]);
+export {
+  g as s
+};

package/dist/shell-session-6QFBv7G6.js

@@ -0,0 +1,93 @@
+import { g as u } from "./index-Sj89RFCY.js";
+import { r as c } from "./bash-0-vitIuH.js";
+function g(t, r) {
+  for (var n = 0; n < r.length; n++) {
+    const e = r[n];
+    if (typeof e != "string" && !Array.isArray(e)) {
+      for (const s in e)
+        if (s !== "default" && !(s in t)) {
+          const o = Object.getOwnPropertyDescriptor(e, s);
+          o && Object.defineProperty(t, s, o.get ? o : {
+            enumerable: !0,
+            get: () => e[s]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
+}
+var a, l;
+function p() {
+  if (l) return a;
+  l = 1;
+  var t = c();
+  a = r, r.displayName = "shellSession", r.aliases = [];
+  function r(n) {
+    n.register(t), function(e) {
+      var s = [
+        // normal string
+        /"(?:\\[\s\S]|\$\([^)]+\)|\$(?!\()|`[^`]+`|[^"\\`$])*"/.source,
+        /'[^']*'/.source,
+        /\$'(?:[^'\\]|\\[\s\S])*'/.source,
+        // here doc
+        // 2 capturing groups
+        /<<-?\s*(["']?)(\w+)\1\s[\s\S]*?[\r\n]\2/.source
+      ].join("|");
+      e.languages["shell-session"] = {
+        command: {
+          pattern: RegExp(
+            // user info
+            /^/.source + "(?:" + // <user> ":" ( <path> )?
+            (/[^\s@:$#%*!/\\]+@[^\r\n@:$#%*!/\\]+(?::[^\0-\x1F$#%*?"<>:;|]+)?/.source + "|" + // <path>
+            // Since the path pattern is quite general, we will require it to start with a special character to
+            // prevent false positives.
+            /[/~.][^\0-\x1F$#%*?"<>@:;|]*/.source) + ")?" + // shell symbol
+            /[$#%](?=\s)/.source + // bash command
+            /(?:[^\\\r\n \t'"<$]|[ \t](?:(?!#)|#.*$)|\\(?:[^\r]|\r\n?)|\$(?!')|<(?!<)|<<str>>)+/.source.replace(
+              /<<str>>/g,
+              function() {
+                return s;
+              }
+            ),
+            "m"
+          ),
+          greedy: !0,
+          inside: {
+            info: {
+              // foo@bar:~/files$ exit
+              // foo@bar$ exit
+              // ~/files$ exit
+              pattern: /^[^#$%]+/,
+              alias: "punctuation",
+              inside: {
+                user: /^[^\s@:$#%*!/\\]+@[^\r\n@:$#%*!/\\]+/,
+                punctuation: /:/,
+                path: /[\s\S]+/
+              }
+            },
+            bash: {
+              pattern: /(^[$#%]\s*)\S[\s\S]*/,
+              lookbehind: !0,
+              alias: "language-bash",
+              inside: e.languages.bash
+            },
+            "shell-symbol": {
+              pattern: /^[$#%]/,
+              alias: "important"
+            }
+          }
+        },
+        output: /.(?:.*(?:[\r\n]|.$))*/
+      }, e.languages["sh-session"] = e.languages.shellsession = e.languages["shell-session"];
+    }(n);
+  }
+  return a;
+}
+var i = p();
+const f = /* @__PURE__ */ u(i), S = /* @__PURE__ */ g({
+  __proto__: null,
+  default: f
+}, [i]);
+export {
+  S as s
+};

package/dist/smali-B48Y4QYt.js

@@ -0,0 +1,112 @@
+import { g as u } from "./index-Sj89RFCY.js";
+function d(e, n) {
+  for (var a = 0; a < n.length; a++) {
+    const t = n[a];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const r in t)
+        if (r !== "default" && !(r in e)) {
+          const i = Object.getOwnPropertyDescriptor(t, r);
+          i && Object.defineProperty(e, r, i.get ? i : {
+            enumerable: !0,
+            get: () => t[r]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var o, l;
+function p() {
+  if (l) return o;
+  l = 1, o = e, e.displayName = "smali", e.aliases = [];
+  function e(n) {
+    n.languages.smali = {
+      comment: /#.*/,
+      string: {
+        pattern: /"(?:[^\r\n\\"]|\\.)*"|'(?:[^\r\n\\']|\\(?:.|u[\da-fA-F]{4}))'/,
+        greedy: !0
+      },
+      "class-name": {
+        pattern: /(^|[^L])L(?:(?:\w+|`[^`\r\n]*`)\/)*(?:[\w$]+|`[^`\r\n]*`)(?=\s*;)/,
+        lookbehind: !0,
+        inside: {
+          "class-name": {
+            pattern: /(^L|\/)(?:[\w$]+|`[^`\r\n]*`)$/,
+            lookbehind: !0
+          },
+          namespace: {
+            pattern: /^(L)(?:(?:\w+|`[^`\r\n]*`)\/)+/,
+            lookbehind: !0,
+            inside: {
+              punctuation: /\//
+            }
+          },
+          builtin: /^L/
+        }
+      },
+      builtin: [
+        {
+          // Reference: https://github.com/JesusFreke/smali/wiki/TypesMethodsAndFields#types
+          pattern: /([();\[])[BCDFIJSVZ]+/,
+          lookbehind: !0
+        },
+        {
+          // e.g. .field mWifiOnUid:I
+          pattern: /([\w$>]:)[BCDFIJSVZ]/,
+          lookbehind: !0
+        }
+      ],
+      keyword: [
+        {
+          pattern: /(\.end\s+)[\w-]+/,
+          lookbehind: !0
+        },
+        {
+          pattern: /(^|[^\w.-])\.(?!\d)[\w-]+/,
+          lookbehind: !0
+        },
+        {
+          pattern: /(^|[^\w.-])(?:abstract|annotation|bridge|constructor|enum|final|interface|private|protected|public|runtime|static|synthetic|system|transient)(?![\w.-])/,
+          lookbehind: !0
+        }
+      ],
+      function: {
+        pattern: /(^|[^\w.-])(?:\w+|<[\w$-]+>)(?=\()/,
+        lookbehind: !0
+      },
+      field: {
+        pattern: /[\w$]+(?=:)/,
+        alias: "variable"
+      },
+      register: {
+        pattern: /(^|[^\w.-])[vp]\d(?![\w.-])/,
+        lookbehind: !0,
+        alias: "variable"
+      },
+      boolean: {
+        pattern: /(^|[^\w.-])(?:false|true)(?![\w.-])/,
+        lookbehind: !0
+      },
+      number: {
+        pattern: /(^|[^/\w.-])-?(?:NAN|INFINITY|0x(?:[\dA-F]+(?:\.[\dA-F]*)?|\.[\dA-F]+)(?:p[+-]?[\dA-F]+)?|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?)[dflst]?(?![\w.-])/i,
+        lookbehind: !0
+      },
+      label: {
+        pattern: /(:)\w+/,
+        lookbehind: !0,
+        alias: "property"
+      },
+      operator: /->|\.\.|[\[=]/,
+      punctuation: /[{}(),;:]/
+    };
+  }
+  return o;
+}
+var s = p();
+const b = /* @__PURE__ */ u(s), m = /* @__PURE__ */ d({
+  __proto__: null,
+  default: b
+}, [s]);
+export {
+  m as s
+};

package/dist/smalltalk-w59b04aF.js

@@ -0,0 +1,71 @@
+import { g as u } from "./index-Sj89RFCY.js";
+function d(e, a) {
+  for (var l = 0; l < a.length; l++) {
+    const t = a[l];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const r in t)
+        if (r !== "default" && !(r in e)) {
+          const n = Object.getOwnPropertyDescriptor(t, r);
+          n && Object.defineProperty(e, r, n.get ? n : {
+            enumerable: !0,
+            get: () => t[r]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var o, s;
+function p() {
+  if (s) return o;
+  s = 1, o = e, e.displayName = "smalltalk", e.aliases = [];
+  function e(a) {
+    a.languages.smalltalk = {
+      comment: {
+        pattern: /"(?:""|[^"])*"/,
+        greedy: !0
+      },
+      char: {
+        pattern: /\$./,
+        greedy: !0
+      },
+      string: {
+        pattern: /'(?:''|[^'])*'/,
+        greedy: !0
+      },
+      symbol: /#[\da-z]+|#(?:-|([+\/\\*~<>=@%|&?!])\1?)|#(?=\()/i,
+      "block-arguments": {
+        pattern: /(\[\s*):[^\[|]*\|/,
+        lookbehind: !0,
+        inside: {
+          variable: /:[\da-z]+/i,
+          punctuation: /\|/
+        }
+      },
+      "temporary-variables": {
+        pattern: /\|[^|]+\|/,
+        inside: {
+          variable: /[\da-z]+/i,
+          punctuation: /\|/
+        }
+      },
+      keyword: /\b(?:new|nil|self|super)\b/,
+      boolean: /\b(?:false|true)\b/,
+      number: [
+        /\d+r-?[\dA-Z]+(?:\.[\dA-Z]+)?(?:e-?\d+)?/,
+        /\b\d+(?:\.\d+)?(?:e-?\d+)?/
+      ],
+      operator: /[<=]=?|:=|~[~=]|\/\/?|\\\\|>[>=]?|[!^+\-*&|,@]/,
+      punctuation: /[.;:?\[\](){}]/
+    };
+  }
+  return o;
+}
+var i = p();
+const m = /* @__PURE__ */ u(i), b = /* @__PURE__ */ d({
+  __proto__: null,
+  default: m
+}, [i]);
+export {
+  b as s
+};

package/dist/smarty-CnWvL-Ef.js

@@ -0,0 +1,147 @@
+import { g as f } from "./index-Sj89RFCY.js";
+import { r as m } from "./markup-templating-CVTxtFGH.js";
+function c(n, r) {
+  for (var a = 0; a < r.length; a++) {
+    const e = r[a];
+    if (typeof e != "string" && !Array.isArray(e)) {
+      for (const t in e)
+        if (t !== "default" && !(t in n)) {
+          const s = Object.getOwnPropertyDescriptor(e, t);
+          s && Object.defineProperty(n, t, s.get ? s : {
+            enumerable: !0,
+            get: () => e[t]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var p, l;
+function b() {
+  if (l) return p;
+  l = 1;
+  var n = m();
+  p = r, r.displayName = "smarty", r.aliases = [];
+  function r(a) {
+    a.register(n), function(e) {
+      e.languages.smarty = {
+        comment: {
+          pattern: /^\{\*[\s\S]*?\*\}/,
+          greedy: !0
+        },
+        "embedded-php": {
+          pattern: /^\{php\}[\s\S]*?\{\/php\}/,
+          greedy: !0,
+          inside: {
+            smarty: {
+              pattern: /^\{php\}|\{\/php\}$/,
+              inside: null
+              // see below
+            },
+            php: {
+              pattern: /[\s\S]+/,
+              alias: "language-php",
+              inside: e.languages.php
+            }
+          }
+        },
+        string: [
+          {
+            pattern: /"(?:\\.|[^"\\\r\n])*"/,
+            greedy: !0,
+            inside: {
+              interpolation: {
+                pattern: /\{[^{}]*\}|`[^`]*`/,
+                inside: {
+                  "interpolation-punctuation": {
+                    pattern: /^[{`]|[`}]$/,
+                    alias: "punctuation"
+                  },
+                  expression: {
+                    pattern: /[\s\S]+/,
+                    inside: null
+                    // see below
+                  }
+                }
+              },
+              variable: /\$\w+/
+            }
+          },
+          {
+            pattern: /'(?:\\.|[^'\\\r\n])*'/,
+            greedy: !0
+          }
+        ],
+        keyword: {
+          pattern: /(^\{\/?)[a-z_]\w*\b(?!\()/i,
+          lookbehind: !0,
+          greedy: !0
+        },
+        delimiter: {
+          pattern: /^\{\/?|\}$/,
+          greedy: !0,
+          alias: "punctuation"
+        },
+        number: /\b0x[\dA-Fa-f]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee][-+]?\d+)?/,
+        variable: [
+          /\$(?!\d)\w+/,
+          /#(?!\d)\w+#/,
+          {
+            pattern: /(\.|->|\w\s*=)(?!\d)\w+\b(?!\()/,
+            lookbehind: !0
+          },
+          {
+            pattern: /(\[)(?!\d)\w+(?=\])/,
+            lookbehind: !0
+          }
+        ],
+        function: {
+          pattern: /(\|\s*)@?[a-z_]\w*|\b[a-z_]\w*(?=\()/i,
+          lookbehind: !0
+        },
+        "attr-name": /\b[a-z_]\w*(?=\s*=)/i,
+        boolean: /\b(?:false|no|off|on|true|yes)\b/,
+        punctuation: /[\[\](){}.,:`]|->/,
+        operator: [
+          /[+\-*\/%]|==?=?|[!<>]=?|&&|\|\|?/,
+          /\bis\s+(?:not\s+)?(?:div|even|odd)(?:\s+by)?\b/,
+          /\b(?:and|eq|gt?e|gt|lt?e|lt|mod|neq?|not|or)\b/
+        ]
+      }, e.languages.smarty["embedded-php"].inside.smarty.inside = e.languages.smarty, e.languages.smarty.string[0].inside.interpolation.inside.expression.inside = e.languages.smarty;
+      var t = /"(?:\\.|[^"\\\r\n])*"|'(?:\\.|[^'\\\r\n])*'/, s = RegExp(
+        // comments
+        /\{\*[\s\S]*?\*\}/.source + "|" + // php tags
+        /\{php\}[\s\S]*?\{\/php\}/.source + "|" + // smarty blocks
+        /\{(?:[^{}"']|<str>|\{(?:[^{}"']|<str>|\{(?:[^{}"']|<str>)*\})*\})*\}/.source.replace(
+          /<str>/g,
+          function() {
+            return t.source;
+          }
+        ),
+        "g"
+      );
+      e.hooks.add("before-tokenize", function(i) {
+        var g = "{literal}", y = "{/literal}", o = !1;
+        e.languages["markup-templating"].buildPlaceholders(
+          i,
+          "smarty",
+          s,
+          function(u) {
+            return u === y && (o = !1), o ? !1 : (u === g && (o = !0), !0);
+          }
+        );
+      }), e.hooks.add("after-tokenize", function(i) {
+        e.languages["markup-templating"].tokenizePlaceholders(i, "smarty");
+      });
+    }(a);
+  }
+  return p;
+}
+var d = b();
+const h = /* @__PURE__ */ f(d), w = /* @__PURE__ */ c({
+  __proto__: null,
+  default: h
+}, [d]);
+export {
+  w as s
+};

package/dist/sml-cUUD1qMQ.js

@@ -0,0 +1,91 @@
+import { g as l } from "./index-Sj89RFCY.js";
+function c(r, a) {
+  for (var e = 0; e < a.length; e++) {
+    const t = a[e];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const n in t)
+        if (n !== "default" && !(n in r)) {
+          const s = Object.getOwnPropertyDescriptor(t, n);
+          s && Object.defineProperty(r, n, s.get ? s : {
+            enumerable: !0,
+            get: () => t[n]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(r, Symbol.toStringTag, { value: "Module" }));
+}
+var o, u;
+function f() {
+  if (u) return o;
+  u = 1, o = r, r.displayName = "sml", r.aliases = ["smlnj"];
+  function r(a) {
+    (function(e) {
+      var t = /\b(?:abstype|and|andalso|as|case|datatype|do|else|end|eqtype|exception|fn|fun|functor|handle|if|in|include|infix|infixr|let|local|nonfix|of|op|open|orelse|raise|rec|sharing|sig|signature|struct|structure|then|type|val|where|while|with|withtype)\b/i;
+      e.languages.sml = {
+        // allow one level of nesting
+        comment: /\(\*(?:[^*(]|\*(?!\))|\((?!\*)|\(\*(?:[^*(]|\*(?!\))|\((?!\*))*\*\))*\*\)/,
+        string: {
+          pattern: /#?"(?:[^"\\]|\\.)*"/,
+          greedy: !0
+        },
+        "class-name": [
+          {
+            // This is only an approximation since the real grammar is context-free
+            //
+            // Why the main loop so complex?
+            // The main loop is approximately the same as /(?:\s*(?:[*,]|->)\s*<TERMINAL>)*/ which is, obviously, a lot
+            // simpler. The difference is that if a comma is the last iteration of the loop, then the terminal must be
+            // followed by a long identifier.
+            pattern: RegExp(
+              /((?:^|[^:]):\s*)<TERMINAL>(?:\s*(?:(?:\*|->)\s*<TERMINAL>|,\s*<TERMINAL>(?:(?=<NOT-LAST>)|(?!<NOT-LAST>)\s+<LONG-ID>)))*/.source.replace(/<NOT-LAST>/g, function() {
+                return /\s*(?:[*,]|->)/.source;
+              }).replace(/<TERMINAL>/g, function() {
+                return /(?:'[\w']*|<LONG-ID>|\((?:[^()]|\([^()]*\))*\)|\{(?:[^{}]|\{[^{}]*\})*\})(?:\s+<LONG-ID>)*/.source;
+              }).replace(/<LONG-ID>/g, function() {
+                return /(?!<KEYWORD>)[a-z\d_][\w'.]*/.source;
+              }).replace(/<KEYWORD>/g, function() {
+                return t.source;
+              }),
+              "i"
+            ),
+            lookbehind: !0,
+            greedy: !0,
+            inside: null
+            // see below
+          },
+          {
+            pattern: /((?:^|[^\w'])(?:datatype|exception|functor|signature|structure|type)\s+)[a-z_][\w'.]*/i,
+            lookbehind: !0
+          }
+        ],
+        function: {
+          pattern: /((?:^|[^\w'])fun\s+)[a-z_][\w'.]*/i,
+          lookbehind: !0
+        },
+        keyword: t,
+        variable: {
+          pattern: /(^|[^\w'])'[\w']*/,
+          lookbehind: !0
+        },
+        number: /~?\b(?:\d+(?:\.\d+)?(?:e~?\d+)?|0x[\da-f]+)\b/i,
+        word: {
+          pattern: /\b0w(?:\d+|x[\da-f]+)\b/i,
+          alias: "constant"
+        },
+        boolean: /\b(?:false|true)\b/i,
+        operator: /\.\.\.|:[>=:]|=>?|->|[<>]=?|[!+\-*/^#|@~]/,
+        punctuation: /[(){}\[\].:,;]/
+      }, e.languages.sml["class-name"][0].inside = e.languages.sml, e.languages.smlnj = e.languages.sml;
+    })(a);
+  }
+  return o;
+}
+var i = f();
+const p = /* @__PURE__ */ l(i), g = /* @__PURE__ */ c({
+  __proto__: null,
+  default: p
+}, [i]);
+export {
+  g as s
+};

package/dist/solidity-Drt__SLk.js

@@ -0,0 +1,49 @@
+import { g as u } from "./index-Sj89RFCY.js";
+function d(t, e) {
+  for (var o = 0; o < e.length; o++) {
+    const r = e[o];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const i in r)
+        if (i !== "default" && !(i in t)) {
+          const n = Object.getOwnPropertyDescriptor(r, i);
+          n && Object.defineProperty(t, i, n.get ? n : {
+            enumerable: !0,
+            get: () => r[i]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
+}
+var a, s;
+function c() {
+  if (s) return a;
+  s = 1, a = t, t.displayName = "solidity", t.aliases = ["sol"];
+  function t(e) {
+    e.languages.solidity = e.languages.extend("clike", {
+      "class-name": {
+        pattern: /(\b(?:contract|enum|interface|library|new|struct|using)\s+)(?!\d)[\w$]+/,
+        lookbehind: !0
+      },
+      keyword: /\b(?:_|anonymous|as|assembly|assert|break|calldata|case|constant|constructor|continue|contract|default|delete|do|else|emit|enum|event|external|for|from|function|if|import|indexed|inherited|interface|internal|is|let|library|mapping|memory|modifier|new|payable|pragma|private|public|pure|require|returns?|revert|selfdestruct|solidity|storage|struct|suicide|switch|this|throw|using|var|view|while)\b/,
+      operator: /=>|->|:=|=:|\*\*|\+\+|--|\|\||&&|<<=?|>>=?|[-+*/%^&|<>!=]=?|[~?]/
+    }), e.languages.insertBefore("solidity", "keyword", {
+      builtin: /\b(?:address|bool|byte|u?int(?:8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?|string|bytes(?:[1-9]|[12]\d|3[0-2])?)\b/
+    }), e.languages.insertBefore("solidity", "number", {
+      version: {
+        pattern: /([<>]=?|\^)\d+\.\d+\.\d+\b/,
+        lookbehind: !0,
+        alias: "number"
+      }
+    }), e.languages.sol = e.languages.solidity;
+  }
+  return a;
+}
+var l = c();
+const y = /* @__PURE__ */ u(l), g = /* @__PURE__ */ d({
+  __proto__: null,
+  default: y
+}, [l]);
+export {
+  g as s
+};