@oscloudlab/knowledge-card 0.0.1 → 0.0.2

package/dist/regex-Z8MvaNEm.js

@@ -0,0 +1,124 @@
+import { g as d } from "./index-Sj89RFCY.js";
+function f(r, s) {
+  for (var t = 0; t < s.length; t++) {
+    const a = s[t];
+    if (typeof a != "string" && !Array.isArray(a)) {
+      for (const e in a)
+        if (e !== "default" && !(e in r)) {
+          const n = Object.getOwnPropertyDescriptor(a, e);
+          n && Object.defineProperty(r, e, n.get ? n : {
+            enumerable: !0,
+            get: () => a[e]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(r, Symbol.toStringTag, { value: "Module" }));
+}
+var i, c;
+function x() {
+  if (c) return i;
+  c = 1, i = r, r.displayName = "regex", r.aliases = [];
+  function r(s) {
+    (function(t) {
+      var a = {
+        pattern: /\\[\\(){}[\]^$+*?|.]/,
+        alias: "escape"
+      }, e = /\\(?:x[\da-fA-F]{2}|u[\da-fA-F]{4}|u\{[\da-fA-F]+\}|0[0-7]{0,2}|[123][0-7]{2}|c[a-zA-Z]|.)/, n = {
+        pattern: /\.|\\[wsd]|\\p\{[^{}]+\}/i,
+        alias: "class-name"
+      }, l = {
+        pattern: /\\[wsd]|\\p\{[^{}]+\}/i,
+        alias: "class-name"
+      }, o = "(?:[^\\\\-]|" + e.source + ")", g = RegExp(o + "-" + o), p = {
+        pattern: /(<|')[^<>']+(?=[>']$)/,
+        lookbehind: !0,
+        alias: "variable"
+      };
+      t.languages.regex = {
+        "char-class": {
+          pattern: /((?:^|[^\\])(?:\\\\)*)\[(?:[^\\\]]|\\[\s\S])*\]/,
+          lookbehind: !0,
+          inside: {
+            "char-class-negation": {
+              pattern: /(^\[)\^/,
+              lookbehind: !0,
+              alias: "operator"
+            },
+            "char-class-punctuation": {
+              pattern: /^\[|\]$/,
+              alias: "punctuation"
+            },
+            range: {
+              pattern: g,
+              inside: {
+                escape: e,
+                "range-punctuation": {
+                  pattern: /-/,
+                  alias: "operator"
+                }
+              }
+            },
+            "special-escape": a,
+            "char-set": l,
+            escape: e
+          }
+        },
+        "special-escape": a,
+        "char-set": n,
+        backreference: [
+          {
+            // a backreference which is not an octal escape
+            pattern: /\\(?![123][0-7]{2})[1-9]/,
+            alias: "keyword"
+          },
+          {
+            pattern: /\\k<[^<>']+>/,
+            alias: "keyword",
+            inside: {
+              "group-name": p
+            }
+          }
+        ],
+        anchor: {
+          pattern: /[$^]|\\[ABbGZz]/,
+          alias: "function"
+        },
+        escape: e,
+        group: [
+          {
+            // https://docs.oracle.com/javase/10/docs/api/java/util/regex/Pattern.html
+            // https://docs.microsoft.com/en-us/dotnet/standard/base-types/regular-expression-language-quick-reference?view=netframework-4.7.2#grouping-constructs
+            // (), (?<name>), (?'name'), (?>), (?:), (?=), (?!), (?<=), (?<!), (?is-m), (?i-m:)
+            pattern: /\((?:\?(?:<[^<>']+>|'[^<>']+'|[>:]|<?[=!]|[idmnsuxU]+(?:-[idmnsuxU]+)?:?))?/,
+            alias: "punctuation",
+            inside: {
+              "group-name": p
+            }
+          },
+          {
+            pattern: /\)/,
+            alias: "punctuation"
+          }
+        ],
+        quantifier: {
+          pattern: /(?:[+*?]|\{\d+(?:,\d*)?\})[?+]?/,
+          alias: "number"
+        },
+        alternation: {
+          pattern: /\|/,
+          alias: "keyword"
+        }
+      };
+    })(s);
+  }
+  return i;
+}
+var u = x();
+const h = /* @__PURE__ */ d(u), b = /* @__PURE__ */ f({
+  __proto__: null,
+  default: h
+}, [u]);
+export {
+  b as r
+};

package/dist/rego-CcGrxeab.js

@@ -0,0 +1,58 @@
+import { g as b } from "./index-Sj89RFCY.js";
+function g(e, o) {
+  for (var n = 0; n < o.length; n++) {
+    const r = o[n];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const t in r)
+        if (t !== "default" && !(t in e)) {
+          const a = Object.getOwnPropertyDescriptor(r, t);
+          a && Object.defineProperty(e, t, a.get ? a : {
+            enumerable: !0,
+            get: () => r[t]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var s, i;
+function p() {
+  if (i) return s;
+  i = 1, s = e, e.displayName = "rego", e.aliases = [];
+  function e(o) {
+    o.languages.rego = {
+      comment: /#.*/,
+      property: {
+        pattern: /(^|[^\\.])(?:"(?:\\.|[^\\"\r\n])*"|`[^`]*`|\b[a-z_]\w*\b)(?=\s*:(?!=))/i,
+        lookbehind: !0,
+        greedy: !0
+      },
+      string: {
+        pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"|`[^`]*`/,
+        lookbehind: !0,
+        greedy: !0
+      },
+      keyword: /\b(?:as|default|else|import|not|null|package|set(?=\s*\()|some|with)\b/,
+      boolean: /\b(?:false|true)\b/,
+      function: {
+        pattern: /\b[a-z_]\w*\b(?:\s*\.\s*\b[a-z_]\w*\b)*(?=\s*\()/i,
+        inside: {
+          namespace: /\b\w+\b(?=\s*\.)/,
+          punctuation: /\./
+        }
+      },
+      number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+      operator: /[-+*/%|&]|[<>:=]=?|!=|\b_\b/,
+      punctuation: /[,;.\[\]{}()]/
+    };
+  }
+  return s;
+}
+var u = p();
+const l = /* @__PURE__ */ b(u), f = /* @__PURE__ */ g({
+  __proto__: null,
+  default: l
+}, [u]);
+export {
+  f as r
+};

package/dist/renpy-mByYQWSM.js

@@ -0,0 +1,51 @@
+import { g as d } from "./index-Sj89RFCY.js";
+function _(e, t) {
+  for (var a = 0; a < t.length; a++) {
+    const n = t[a];
+    if (typeof n != "string" && !Array.isArray(n)) {
+      for (const i in n)
+        if (i !== "default" && !(i in e)) {
+          const o = Object.getOwnPropertyDescriptor(n, i);
+          o && Object.defineProperty(e, i, o.get ? o : {
+            enumerable: !0,
+            get: () => n[i]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var r, s;
+function u() {
+  if (s) return r;
+  s = 1, r = e, e.displayName = "renpy", e.aliases = ["rpy"];
+  function e(t) {
+    t.languages.renpy = {
+      comment: {
+        pattern: /(^|[^\\])#.+/,
+        lookbehind: !0
+      },
+      string: {
+        pattern: /("""|''')[\s\S]+?\1|("|')(?:\\.|(?!\2)[^\\])*\2|(?:^#?(?:(?:[0-9a-fA-F]){3}|[0-9a-fA-F]{6})$)/m,
+        greedy: !0
+      },
+      function: /\b[a-z_]\w*(?=\()/i,
+      property: /\b(?:Update|UpdateVersion|action|activate_sound|adv_nvl_transition|after_load_transition|align|alpha|alt|anchor|antialias|area|auto|background|bar_invert|bar_resizing|bar_vertical|black_color|bold|bottom_bar|bottom_gutter|bottom_margin|bottom_padding|box_reverse|box_wrap|can_update|caret|child|color|crop|default_afm_enable|default_afm_time|default_fullscreen|default_text_cps|developer|directory_name|drag_handle|drag_joined|drag_name|drag_raise|draggable|dragged|drop_shadow|drop_shadow_color|droppable|dropped|easein|easeout|edgescroll|end_game_transition|end_splash_transition|enter_replay_transition|enter_sound|enter_transition|enter_yesno_transition|executable_name|exit_replay_transition|exit_sound|exit_transition|exit_yesno_transition|fadein|fadeout|first_indent|first_spacing|fit_first|focus|focus_mask|font|foreground|game_main_transition|get_installed_packages|google_play_key|google_play_salt|ground|has_music|has_sound|has_voice|height|help|hinting|hover|hover_background|hover_color|hover_sound|hovered|hyperlink_functions|idle|idle_color|image_style|include_update|insensitive|insensitive_background|insensitive_color|inside|intra_transition|italic|justify|kerning|keyboard_focus|language|layer_clipping|layers|layout|left_bar|left_gutter|left_margin|left_padding|length|line_leading|line_overlap_split|line_spacing|linear|main_game_transition|main_menu_music|maximum|min_width|minimum|minwidth|modal|mouse|mousewheel|name|narrator_menu|newline_indent|nvl_adv_transition|offset|order_reverse|outlines|overlay_functions|pos|position|prefix|radius|range|rest_indent|right_bar|right_gutter|right_margin|right_padding|rotate|rotate_pad|ruby_style|sample_sound|save_directory|say_attribute_transition|screen_height|screen_width|scrollbars|selected_hover|selected_hover_color|selected_idle|selected_idle_color|selected_insensitive|show_side_image|show_two_window|side_spacing|side_xpos|side_ypos|size|size_group|slow_cps|slow_cps_multiplier|spacing|strikethrough|subpixel|text_align|text_style|text_xpos|text_y_fudge|text_ypos|thumb|thumb_offset|thumb_shadow|thumbnail_height|thumbnail_width|time|top_bar|top_gutter|top_margin|top_padding|translations|underline|unscrollable|update|value|version|version_name|version_tuple|vertical|width|window_hide_transition|window_icon|window_left_padding|window_show_transition|window_title|windows_icon|xadjustment|xalign|xanchor|xanchoraround|xaround|xcenter|xfill|xinitial|xmargin|xmaximum|xminimum|xoffset|xofsset|xpadding|xpos|xsize|xzoom|yadjustment|yalign|yanchor|yanchoraround|yaround|ycenter|yfill|yinitial|ymargin|ymaximum|yminimum|yoffset|ypadding|ypos|ysize|ysizexysize|yzoom|zoom|zorder)\b/,
+      tag: /\b(?:bar|block|button|buttoscreenn|drag|draggroup|fixed|frame|grid|[hv]box|hotbar|hotspot|image|imagebutton|imagemap|input|key|label|menu|mm_menu_frame|mousearea|nvl|parallel|screen|self|side|tag|text|textbutton|timer|vbar|viewport|window)\b|\$/,
+      keyword: /\b(?:None|add|adjustment|alignaround|allow|angle|animation|around|as|assert|behind|box_layout|break|build|cache|call|center|changed|child_size|choice|circles|class|clear|clicked|clipping|clockwise|config|contains|continue|corner1|corner2|counterclockwise|def|default|define|del|delay|disabled|disabled_text|dissolve|elif|else|event|except|exclude|exec|expression|fade|finally|for|from|function|global|gm_root|has|hide|id|if|import|in|init|is|jump|knot|lambda|left|less_rounded|mm_root|movie|music|null|on|onlayer|pass|pause|persistent|play|print|python|queue|raise|random|renpy|repeat|return|right|rounded_window|scene|scope|set|show|slow|slow_abortable|slow_done|sound|stop|store|style|style_group|substitute|suffix|theme|transform|transform_anchor|transpose|try|ui|unhovered|updater|use|voice|while|widget|widget_hover|widget_selected|widget_text|yield)\b/,
+      boolean: /\b(?:[Ff]alse|[Tt]rue)\b/,
+      number: /(?:\b(?:0[bo])?(?:(?:\d|0x[\da-f])[\da-f]*(?:\.\d*)?)|\B\.\d+)(?:e[+-]?\d+)?j?/i,
+      operator: /[-+%=]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]|\b(?:and|at|not|or|with)\b/,
+      punctuation: /[{}[\];(),.:]/
+    }, t.languages.rpy = t.languages.renpy;
+  }
+  return r;
+}
+var l = u();
+const c = /* @__PURE__ */ d(l), g = /* @__PURE__ */ _({
+  __proto__: null,
+  default: c
+}, [l]);
+export {
+  g as r
+};

package/dist/rest-BoR9ZMoX.js

@@ -0,0 +1,231 @@
+import { g as s } from "./index-Sj89RFCY.js";
+function p(t, r) {
+  for (var i = 0; i < r.length; i++) {
+    const n = r[i];
+    if (typeof n != "string" && !Array.isArray(n)) {
+      for (const e in n)
+        if (e !== "default" && !(e in t)) {
+          const a = Object.getOwnPropertyDescriptor(n, e);
+          a && Object.defineProperty(t, e, a.get ? a : {
+            enumerable: !0,
+            get: () => n[e]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
+}
+var o, u;
+function d() {
+  if (u) return o;
+  u = 1, o = t, t.displayName = "rest", t.aliases = [];
+  function t(r) {
+    r.languages.rest = {
+      table: [
+        {
+          pattern: /(^[\t ]*)(?:\+[=-]+)+\+(?:\r?\n|\r)(?:\1[+|].+[+|](?:\r?\n|\r))+\1(?:\+[=-]+)+\+/m,
+          lookbehind: !0,
+          inside: {
+            punctuation: /\||(?:\+[=-]+)+\+/
+          }
+        },
+        {
+          pattern: /(^[\t ]*)=+ [ =]*=(?:(?:\r?\n|\r)\1.+)+(?:\r?\n|\r)\1=+ [ =]*=(?=(?:\r?\n|\r){2}|\s*$)/m,
+          lookbehind: !0,
+          inside: {
+            punctuation: /[=-]+/
+          }
+        }
+      ],
+      // Directive-like patterns
+      "substitution-def": {
+        pattern: /(^[\t ]*\.\. )\|(?:[^|\s](?:[^|]*[^|\s])?)\| [^:]+::/m,
+        lookbehind: !0,
+        inside: {
+          substitution: {
+            pattern: /^\|(?:[^|\s]|[^|\s][^|]*[^|\s])\|/,
+            alias: "attr-value",
+            inside: {
+              punctuation: /^\||\|$/
+            }
+          },
+          directive: {
+            pattern: /( )(?! )[^:]+::/,
+            lookbehind: !0,
+            alias: "function",
+            inside: {
+              punctuation: /::$/
+            }
+          }
+        }
+      },
+      "link-target": [
+        {
+          pattern: /(^[\t ]*\.\. )\[[^\]]+\]/m,
+          lookbehind: !0,
+          alias: "string",
+          inside: {
+            punctuation: /^\[|\]$/
+          }
+        },
+        {
+          pattern: /(^[\t ]*\.\. )_(?:`[^`]+`|(?:[^:\\]|\\.)+):/m,
+          lookbehind: !0,
+          alias: "string",
+          inside: {
+            punctuation: /^_|:$/
+          }
+        }
+      ],
+      directive: {
+        pattern: /(^[\t ]*\.\. )[^:]+::/m,
+        lookbehind: !0,
+        alias: "function",
+        inside: {
+          punctuation: /::$/
+        }
+      },
+      comment: {
+        // The two alternatives try to prevent highlighting of blank comments
+        pattern: /(^[\t ]*\.\.)(?:(?: .+)?(?:(?:\r?\n|\r).+)+| .+)(?=(?:\r?\n|\r){2}|$)/m,
+        lookbehind: !0
+      },
+      title: [
+        // Overlined and underlined
+        {
+          pattern: /^(([!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~])\2+)(?:\r?\n|\r).+(?:\r?\n|\r)\1$/m,
+          inside: {
+            punctuation: /^[!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~]+|[!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~]+$/,
+            important: /.+/
+          }
+        },
+        // Underlined only
+        {
+          pattern: /(^|(?:\r?\n|\r){2}).+(?:\r?\n|\r)([!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~])\2+(?=\r?\n|\r|$)/,
+          lookbehind: !0,
+          inside: {
+            punctuation: /[!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~]+$/,
+            important: /.+/
+          }
+        }
+      ],
+      hr: {
+        pattern: /((?:\r?\n|\r){2})([!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~])\2{3,}(?=(?:\r?\n|\r){2})/,
+        lookbehind: !0,
+        alias: "punctuation"
+      },
+      field: {
+        pattern: /(^[\t ]*):[^:\r\n]+:(?= )/m,
+        lookbehind: !0,
+        alias: "attr-name"
+      },
+      "command-line-option": {
+        pattern: /(^[\t ]*)(?:[+-][a-z\d]|(?:--|\/)[a-z\d-]+)(?:[ =](?:[a-z][\w-]*|<[^<>]+>))?(?:, (?:[+-][a-z\d]|(?:--|\/)[a-z\d-]+)(?:[ =](?:[a-z][\w-]*|<[^<>]+>))?)*(?=(?:\r?\n|\r)? {2,}\S)/im,
+        lookbehind: !0,
+        alias: "symbol"
+      },
+      "literal-block": {
+        pattern: /::(?:\r?\n|\r){2}([ \t]+)(?![ \t]).+(?:(?:\r?\n|\r)\1.+)*/,
+        inside: {
+          "literal-block-punctuation": {
+            pattern: /^::/,
+            alias: "punctuation"
+          }
+        }
+      },
+      "quoted-literal-block": {
+        pattern: /::(?:\r?\n|\r){2}([!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~]).*(?:(?:\r?\n|\r)\1.*)*/,
+        inside: {
+          "literal-block-punctuation": {
+            pattern: /^(?:::|([!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~])\1*)/m,
+            alias: "punctuation"
+          }
+        }
+      },
+      "list-bullet": {
+        pattern: /(^[\t ]*)(?:[*+\-•‣⁃]|\(?(?:\d+|[a-z]|[ivxdclm]+)\)|(?:\d+|[a-z]|[ivxdclm]+)\.)(?= )/im,
+        lookbehind: !0,
+        alias: "punctuation"
+      },
+      "doctest-block": {
+        pattern: /(^[\t ]*)>>> .+(?:(?:\r?\n|\r).+)*/m,
+        lookbehind: !0,
+        inside: {
+          punctuation: /^>>>/
+        }
+      },
+      inline: [
+        {
+          pattern: /(^|[\s\-:\/'"<(\[{])(?::[^:]+:`.*?`|`.*?`:[^:]+:|(\*\*?|``?|\|)(?!\s)(?:(?!\2).)*\S\2(?=[\s\-.,:;!?\\\/'")\]}]|$))/m,
+          lookbehind: !0,
+          inside: {
+            bold: {
+              pattern: /(^\*\*).+(?=\*\*$)/,
+              lookbehind: !0
+            },
+            italic: {
+              pattern: /(^\*).+(?=\*$)/,
+              lookbehind: !0
+            },
+            "inline-literal": {
+              pattern: /(^``).+(?=``$)/,
+              lookbehind: !0,
+              alias: "symbol"
+            },
+            role: {
+              pattern: /^:[^:]+:|:[^:]+:$/,
+              alias: "function",
+              inside: {
+                punctuation: /^:|:$/
+              }
+            },
+            "interpreted-text": {
+              pattern: /(^`).+(?=`$)/,
+              lookbehind: !0,
+              alias: "attr-value"
+            },
+            substitution: {
+              pattern: /(^\|).+(?=\|$)/,
+              lookbehind: !0,
+              alias: "attr-value"
+            },
+            punctuation: /\*\*?|``?|\|/
+          }
+        }
+      ],
+      link: [
+        {
+          pattern: /\[[^\[\]]+\]_(?=[\s\-.,:;!?\\\/'")\]}]|$)/,
+          alias: "string",
+          inside: {
+            punctuation: /^\[|\]_$/
+          }
+        },
+        {
+          pattern: /(?:\b[a-z\d]+(?:[_.:+][a-z\d]+)*_?_|`[^`]+`_?_|_`[^`]+`)(?=[\s\-.,:;!?\\\/'")\]}]|$)/i,
+          alias: "string",
+          inside: {
+            punctuation: /^_?`|`$|`?_?_$/
+          }
+        }
+      ],
+      // Line block start,
+      // quote attribution,
+      // explicit markup start,
+      // and anonymous hyperlink target shortcut (__)
+      punctuation: {
+        pattern: /(^[\t ]*)(?:\|(?= |$)|(?:---?|—|\.\.|__)(?= )|\.\.$)/m,
+        lookbehind: !0
+      }
+    };
+  }
+  return o;
+}
+var l = d();
+const c = /* @__PURE__ */ s(l), $ = /* @__PURE__ */ p({
+  __proto__: null,
+  default: c
+}, [l]);
+export {
+  $ as r
+};

package/dist/rip-C3Bf4Bpl.js

@@ -0,0 +1,62 @@
+import { g as u } from "./index-Sj89RFCY.js";
+function b(e, n) {
+  for (var i = 0; i < n.length; i++) {
+    const r = n[i];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const t in r)
+        if (t !== "default" && !(t in e)) {
+          const a = Object.getOwnPropertyDescriptor(r, t);
+          a && Object.defineProperty(e, t, a.get ? a : {
+            enumerable: !0,
+            get: () => r[t]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var s, o;
+function p() {
+  if (o) return s;
+  o = 1, s = e, e.displayName = "rip", e.aliases = [];
+  function e(n) {
+    n.languages.rip = {
+      comment: {
+        pattern: /#.*/,
+        greedy: !0
+      },
+      char: {
+        pattern: /\B`[^\s`'",.:;#\/\\()<>\[\]{}]\b/,
+        greedy: !0
+      },
+      string: {
+        pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+        greedy: !0
+      },
+      regex: {
+        pattern: /(^|[^/])\/(?!\/)(?:\[[^\n\r\]]*\]|\\.|[^/\\\r\n\[])+\/(?=\s*(?:$|[\r\n,.;})]))/,
+        lookbehind: !0,
+        greedy: !0
+      },
+      keyword: /(?:=>|->)|\b(?:case|catch|class|else|exit|finally|if|raise|return|switch|try)\b/,
+      builtin: /@|\bSystem\b/,
+      boolean: /\b(?:false|true)\b/,
+      date: /\b\d{4}-\d{2}-\d{2}\b/,
+      time: /\b\d{2}:\d{2}:\d{2}\b/,
+      datetime: /\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\b/,
+      symbol: /:[^\d\s`'",.:;#\/\\()<>\[\]{}][^\s`'",.:;#\/\\()<>\[\]{}]*/,
+      number: /[+-]?\b(?:\d+\.\d+|\d+)\b/,
+      punctuation: /(?:\.{2,3})|[`,.:;=\/\\()<>\[\]{}]/,
+      reference: /[^\d\s`'",.:;#\/\\()<>\[\]{}][^\s`'",.:;#\/\\()<>\[\]{}]*/
+    };
+  }
+  return s;
+}
+var d = p();
+const c = /* @__PURE__ */ u(d), f = /* @__PURE__ */ b({
+  __proto__: null,
+  default: c
+}, [d]);
+export {
+  f as r
+};

package/dist/roboconf-1MYmsJJ7.js

@@ -0,0 +1,60 @@
+import { g as l } from "./index-Sj89RFCY.js";
+function p(o, r) {
+  for (var n = 0; n < r.length; n++) {
+    const t = r[n];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const e in t)
+        if (e !== "default" && !(e in o)) {
+          const a = Object.getOwnPropertyDescriptor(t, e);
+          a && Object.defineProperty(o, e, a.get ? a : {
+            enumerable: !0,
+            get: () => t[e]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(o, Symbol.toStringTag, { value: "Module" }));
+}
+var i, c;
+function s() {
+  if (c) return i;
+  c = 1, i = o, o.displayName = "roboconf", o.aliases = [];
+  function o(r) {
+    r.languages.roboconf = {
+      comment: /#.*/,
+      keyword: {
+        pattern: /(^|\s)(?:(?:external|import)\b|(?:facet|instance of)(?=[ \t]+[\w-]+[ \t]*\{))/,
+        lookbehind: !0
+      },
+      component: {
+        pattern: /[\w-]+(?=[ \t]*\{)/,
+        alias: "variable"
+      },
+      property: /[\w.-]+(?=[ \t]*:)/,
+      value: {
+        pattern: /(=[ \t]*(?![ \t]))[^,;]+/,
+        lookbehind: !0,
+        alias: "attr-value"
+      },
+      optional: {
+        pattern: /\(optional\)/,
+        alias: "builtin"
+      },
+      wildcard: {
+        pattern: /(\.)\*/,
+        lookbehind: !0,
+        alias: "operator"
+      },
+      punctuation: /[{},.;:=]/
+    };
+  }
+  return i;
+}
+var f = s();
+const u = /* @__PURE__ */ l(f), d = /* @__PURE__ */ p({
+  __proto__: null,
+  default: u
+}, [f]);
+export {
+  d as r
+};