@oscloudlab/knowledge-card 0.0.1 → 0.0.2

package/dist/abap-bNFqRLO1.js

@@ -0,0 +1,84 @@
+import { g as L } from "./index-Sj89RFCY.js";
+function D(E, I) {
+  for (var O = 0; O < I.length; O++) {
+    const N = I[O];
+    if (typeof N != "string" && !Array.isArray(N)) {
+      for (const T in N)
+        if (T !== "default" && !(T in E)) {
+          const A = Object.getOwnPropertyDescriptor(N, T);
+          A && Object.defineProperty(E, T, A.get ? A : {
+            enumerable: !0,
+            get: () => N[T]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(E, Symbol.toStringTag, { value: "Module" }));
+}
+var S, R;
+function P() {
+  if (R) return S;
+  R = 1, S = E, E.displayName = "abap", E.aliases = [];
+  function E(I) {
+    I.languages.abap = {
+      comment: /^\*.*/m,
+      string: /(`|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+      "string-template": {
+        pattern: /([|}])(?:\\.|[^\\|{\r\n])*(?=[|{])/,
+        lookbehind: !0,
+        alias: "string"
+      },
+      /* End Of Line comments should not interfere with strings when the
+      quote character occurs within them. We assume a string being highlighted
+      inside an EOL comment is more acceptable than the opposite.
+      */
+      "eol-comment": {
+        pattern: /(^|\s)".*/m,
+        lookbehind: !0,
+        alias: "comment"
+      },
+      keyword: {
+        pattern: /(\s|\.|^)(?:SCIENTIFIC_WITH_LEADING_ZERO|SCALE_PRESERVING_SCIENTIFIC|RMC_COMMUNICATION_FAILURE|END-ENHANCEMENT-SECTION|MULTIPLY-CORRESPONDING|SUBTRACT-CORRESPONDING|VERIFICATION-MESSAGE|DIVIDE-CORRESPONDING|ENHANCEMENT-SECTION|CURRENCY_CONVERSION|RMC_SYSTEM_FAILURE|START-OF-SELECTION|MOVE-CORRESPONDING|RMC_INVALID_STATUS|CUSTOMER-FUNCTION|END-OF-DEFINITION|ENHANCEMENT-POINT|SYSTEM-EXCEPTIONS|ADD-CORRESPONDING|SCALE_PRESERVING|SELECTION-SCREEN|CURSOR-SELECTION|END-OF-SELECTION|LOAD-OF-PROGRAM|SCROLL-BOUNDARY|SELECTION-TABLE|EXCEPTION-TABLE|IMPLEMENTATIONS|PARAMETER-TABLE|RIGHT-JUSTIFIED|UNIT_CONVERSION|AUTHORITY-CHECK|LIST-PROCESSING|SIGN_AS_POSTFIX|COL_BACKGROUND|IMPLEMENTATION|INTERFACE-POOL|TRANSFORMATION|IDENTIFICATION|ENDENHANCEMENT|LINE-SELECTION|INITIALIZATION|LEFT-JUSTIFIED|SELECT-OPTIONS|SELECTION-SETS|COMMUNICATION|CORRESPONDING|DECIMAL_SHIFT|PRINT-CONTROL|VALUE-REQUEST|CHAIN-REQUEST|FUNCTION-POOL|FIELD-SYMBOLS|FUNCTIONALITY|INVERTED-DATE|SELECTION-SET|CLASS-METHODS|OUTPUT-LENGTH|CLASS-CODING|COL_NEGATIVE|ERRORMESSAGE|FIELD-GROUPS|HELP-REQUEST|NO-EXTENSION|NO-TOPOFPAGE|REDEFINITION|DISPLAY-MODE|ENDINTERFACE|EXIT-COMMAND|FIELD-SYMBOL|NO-SCROLLING|SHORTDUMP-ID|ACCESSPOLICY|CLASS-EVENTS|COL_POSITIVE|DECLARATIONS|ENHANCEMENTS|FILTER-TABLE|SWITCHSTATES|SYNTAX-CHECK|TRANSPORTING|ASYNCHRONOUS|SYNTAX-TRACE|TOKENIZATION|USER-COMMAND|WITH-HEADING|ABAP-SOURCE|BREAK-POINT|CHAIN-INPUT|COMPRESSION|FIXED-POINT|NEW-SECTION|NON-UNICODE|OCCURRENCES|RESPONSIBLE|SYSTEM-CALL|TRACE-TABLE|ABBREVIATED|CHAR-TO-HEX|END-OF-FILE|ENDFUNCTION|ENVIRONMENT|ASSOCIATION|COL_HEADING|EDITOR-CALL|END-OF-PAGE|ENGINEERING|IMPLEMENTED|INTENSIFIED|RADIOBUTTON|SYSTEM-EXIT|TOP-OF-PAGE|TRANSACTION|APPLICATION|CONCATENATE|DESTINATION|ENHANCEMENT|IMMEDIATELY|NO-GROUPING|PRECOMPILED|REPLACEMENT|TITLE-LINES|ACTIVATION|BYTE-ORDER|CLASS-POOL|CONNECTION|CONVERSION|DEFINITION|DEPARTMENT|EXPIRATION|INHERITING|MESSAGE-ID|NO-HEADING|PERFORMING|QUEUE-ONLY|RIGHTSPACE|SCIENTIFIC|STATUSINFO|STRUCTURES|SYNCPOINTS|WITH-TITLE|ATTRIBUTES|BOUNDARIES|CLASS-DATA|COL_NORMAL|DD\/MM\/YYYY|DESCENDING|INTERFACES|LINE-COUNT|MM\/DD\/YYYY|NON-UNIQUE|PRESERVING|SELECTIONS|STATEMENTS|SUBROUTINE|TRUNCATION|TYPE-POOLS|ARITHMETIC|BACKGROUND|ENDPROVIDE|EXCEPTIONS|IDENTIFIER|INDEX-LINE|OBLIGATORY|PARAMETERS|PERCENTAGE|PUSHBUTTON|RESOLUTION|COMPONENTS|DEALLOCATE|DISCONNECT|DUPLICATES|FIRST-LINE|HEAD-LINES|NO-DISPLAY|OCCURRENCE|RESPECTING|RETURNCODE|SUBMATCHES|TRACE-FILE|ASCENDING|BYPASSING|ENDMODULE|EXCEPTION|EXCLUDING|EXPORTING|INCREMENT|MATCHCODE|PARAMETER|PARTIALLY|PREFERRED|REFERENCE|REPLACING|RETURNING|SELECTION|SEPARATED|SPECIFIED|STATEMENT|TIMESTAMP|TYPE-POOL|ACCEPTING|APPENDAGE|ASSIGNING|COL_GROUP|COMPARING|CONSTANTS|DANGEROUS|IMPORTING|INSTANCES|LEFTSPACE|LOG-POINT|QUICKINFO|READ-ONLY|SCROLLING|SQLSCRIPT|STEP-LOOP|TOP-LINES|TRANSLATE|APPENDING|AUTHORITY|CHARACTER|COMPONENT|CONDITION|DIRECTORY|DUPLICATE|MESSAGING|RECEIVING|SUBSCREEN|ACCORDING|COL_TOTAL|END-LINES|ENDMETHOD|ENDSELECT|EXPANDING|EXTENSION|INCLUDING|INFOTYPES|INTERFACE|INTERVALS|LINE-SIZE|PF-STATUS|PROCEDURE|PROTECTED|REQUESTED|RESUMABLE|RIGHTPLUS|SAP-SPOOL|SECONDARY|STRUCTURE|SUBSTRING|TABLEVIEW|NUMOFCHAR|ADJACENT|ANALYSIS|ASSIGNED|BACKWARD|CHANNELS|CHECKBOX|CONTINUE|CRITICAL|DATAINFO|DD\/MM\/YY|DURATION|ENCODING|ENDCLASS|FUNCTION|LEFTPLUS|LINEFEED|MM\/DD\/YY|OVERFLOW|RECEIVED|SKIPPING|SORTABLE|STANDARD|SUBTRACT|SUPPRESS|TABSTRIP|TITLEBAR|TRUNCATE|UNASSIGN|WHENEVER|ANALYZER|COALESCE|COMMENTS|CONDENSE|DECIMALS|DEFERRED|ENDWHILE|EXPLICIT|KEYWORDS|MESSAGES|POSITION|PRIORITY|RECEIVER|RENAMING|TIMEZONE|TRAILING|ALLOCATE|CENTERED|CIRCULAR|CONTROLS|CURRENCY|DELETING|DESCRIBE|DISTANCE|ENDCATCH|EXPONENT|EXTENDED|GENERATE|IGNORING|INCLUDES|INTERNAL|MAJOR-ID|MODIFIER|NEW-LINE|OPTIONAL|PROPERTY|ROLLBACK|STARTING|SUPPLIED|ABSTRACT|CHANGING|CONTEXTS|CREATING|CUSTOMER|DATABASE|DAYLIGHT|DEFINING|DISTINCT|DIVISION|ENABLING|ENDCHAIN|ESCAPING|HARMLESS|IMPLICIT|INACTIVE|LANGUAGE|MINOR-ID|MULTIPLY|NEW-PAGE|NO-TITLE|POS_HIGH|SEPARATE|TEXTPOOL|TRANSFER|SELECTOR|DBMAXLEN|ITERATOR|ARCHIVE|BIT-XOR|BYTE-CO|COLLECT|COMMENT|CURRENT|DEFAULT|DISPLAY|ENDFORM|EXTRACT|LEADING|LISTBOX|LOCATOR|MEMBERS|METHODS|NESTING|POS_LOW|PROCESS|PROVIDE|RAISING|RESERVE|SECONDS|SUMMARY|VISIBLE|BETWEEN|BIT-AND|BYTE-CS|CLEANUP|COMPUTE|CONTROL|CONVERT|DATASET|ENDCASE|FORWARD|HEADERS|HOTSPOT|INCLUDE|INVERSE|KEEPING|NO-ZERO|OBJECTS|OVERLAY|PADDING|PATTERN|PROGRAM|REFRESH|SECTION|SUMMING|TESTING|VERSION|WINDOWS|WITHOUT|BIT-NOT|BYTE-CA|BYTE-NA|CASTING|CONTEXT|COUNTRY|DYNAMIC|ENABLED|ENDLOOP|EXECUTE|FRIENDS|HANDLER|HEADING|INITIAL|\*-INPUT|LOGFILE|MAXIMUM|MINIMUM|NO-GAPS|NO-SIGN|PRAGMAS|PRIMARY|PRIVATE|REDUCED|REPLACE|REQUEST|RESULTS|UNICODE|WARNING|ALIASES|BYTE-CN|BYTE-NS|CALLING|COL_KEY|COLUMNS|CONNECT|ENDEXEC|ENTRIES|EXCLUDE|FILTERS|FURTHER|HELP-ID|LOGICAL|MAPPING|MESSAGE|NAMETAB|OPTIONS|PACKAGE|PERFORM|RECEIVE|STATICS|VARYING|BINDING|CHARLEN|GREATER|XSTRLEN|ACCEPT|APPEND|DETAIL|ELSEIF|ENDING|ENDTRY|FORMAT|FRAMES|GIVING|HASHED|HEADER|IMPORT|INSERT|MARGIN|MODULE|NATIVE|OBJECT|OFFSET|REMOTE|RESUME|SAVING|SIMPLE|SUBMIT|TABBED|TOKENS|UNIQUE|UNPACK|UPDATE|WINDOW|YELLOW|ACTUAL|ASPECT|CENTER|CURSOR|DELETE|DIALOG|DIVIDE|DURING|ERRORS|EVENTS|EXTEND|FILTER|HANDLE|HAVING|IGNORE|LITTLE|MEMORY|NO-GAP|OCCURS|OPTION|PERSON|PLACES|PUBLIC|REDUCE|REPORT|RESULT|SINGLE|SORTED|SWITCH|SYNTAX|TARGET|VALUES|WRITER|ASSERT|BLOCKS|BOUNDS|BUFFER|CHANGE|COLUMN|COMMIT|CONCAT|COPIES|CREATE|DDMMYY|DEFINE|ENDIAN|ESCAPE|EXPAND|KERNEL|LAYOUT|LEGACY|LEVELS|MMDDYY|NUMBER|OUTPUT|RANGES|READER|RETURN|SCREEN|SEARCH|SELECT|SHARED|SOURCE|STABLE|STATIC|SUBKEY|SUFFIX|TABLES|UNWIND|YYMMDD|ASSIGN|BACKUP|BEFORE|BINARY|BIT-OR|BLANKS|CLIENT|CODING|COMMON|DEMAND|DYNPRO|EXCEPT|EXISTS|EXPORT|FIELDS|GLOBAL|GROUPS|LENGTH|LOCALE|MEDIUM|METHOD|MODIFY|NESTED|OTHERS|REJECT|SCROLL|SUPPLY|SYMBOL|ENDFOR|STRLEN|ALIGN|BEGIN|BOUND|ENDAT|ENTRY|EVENT|FINAL|FLUSH|GRANT|INNER|SHORT|USING|WRITE|AFTER|BLACK|BLOCK|CLOCK|COLOR|COUNT|DUMMY|EMPTY|ENDDO|ENDON|GREEN|INDEX|INOUT|LEAVE|LEVEL|LINES|MODIF|ORDER|OUTER|RANGE|RESET|RETRY|RIGHT|SMART|SPLIT|STYLE|TABLE|THROW|UNDER|UNTIL|UPPER|UTF-8|WHERE|ALIAS|BLANK|CLEAR|CLOSE|EXACT|FETCH|FIRST|FOUND|GROUP|LLANG|LOCAL|OTHER|REGEX|SPOOL|TITLE|TYPES|VALID|WHILE|ALPHA|BOXED|CATCH|CHAIN|CHECK|CLASS|COVER|ENDIF|EQUIV|FIELD|FLOOR|FRAME|INPUT|LOWER|MATCH|NODES|PAGES|PRINT|RAISE|ROUND|SHIFT|SPACE|SPOTS|STAMP|STATE|TASKS|TIMES|TRMAC|ULINE|UNION|VALUE|WIDTH|EQUAL|LOG10|TRUNC|BLOB|CASE|CEIL|CLOB|COND|EXIT|FILE|GAPS|HOLD|INCL|INTO|KEEP|KEYS|LAST|LINE|LONG|LPAD|MAIL|MODE|OPEN|PINK|READ|ROWS|TEST|THEN|ZERO|AREA|BACK|BADI|BYTE|CAST|EDIT|EXEC|FAIL|FIND|FKEQ|FONT|FREE|GKEQ|HIDE|INIT|ITNO|LATE|LOOP|MAIN|MARK|MOVE|NEXT|NULL|RISK|ROLE|UNIT|WAIT|ZONE|BASE|CALL|CODE|DATA|DATE|FKGE|GKGE|HIGH|KIND|LEFT|LIST|MASK|MESH|NAME|NODE|PACK|PAGE|POOL|SEND|SIGN|SIZE|SOME|STOP|TASK|TEXT|TIME|USER|VARY|WITH|WORD|BLUE|CONV|COPY|DEEP|ELSE|FORM|FROM|HINT|ICON|JOIN|LIKE|LOAD|ONLY|PART|SCAN|SKIP|SORT|TYPE|UNIX|VIEW|WHEN|WORK|ACOS|ASIN|ATAN|COSH|EACH|FRAC|LESS|RTTI|SINH|SQRT|TANH|AVG|BIT|DIV|ISO|LET|OUT|PAD|SQL|ALL|CI_|CPI|END|LOB|LPI|MAX|MIN|NEW|OLE|RUN|SET|\?TO|YES|ABS|ADD|AND|BIG|FOR|HDB|JOB|LOW|NOT|SAP|TRY|VIA|XML|ANY|GET|IDS|KEY|MOD|OFF|PUT|RAW|RED|REF|SUM|TAB|XSD|CNT|COS|EXP|LOG|SIN|TAN|XOR|AT|CO|CP|DO|GT|ID|IF|NS|OR|BT|CA|CS|GE|NA|NB|EQ|IN|LT|NE|NO|OF|ON|PF|TO|AS|BY|CN|IS|LE|NP|UP|E|I|M|O|Z|C|X)\b/i,
+        lookbehind: !0
+      },
+      /* Numbers can be only integers. Decimal or Hex appear only as strings */
+      number: /\b\d+\b/,
+      /* Operators must always be surrounded by whitespace, they cannot be put
+      adjacent to operands.
+      */
+      operator: {
+        pattern: /(\s)(?:\*\*?|<[=>]?|>=?|\?=|[-+\/=])(?=\s)/,
+        lookbehind: !0
+      },
+      "string-operator": {
+        pattern: /(\s)&&?(?=\s)/,
+        lookbehind: !0,
+        /* The official editor highlights */
+        alias: "keyword"
+      },
+      "token-operator": [
+        {
+          /* Special operators used to access structure components, class methods/attributes, etc. */
+          pattern: /(\w)(?:->?|=>|[~|{}])(?=\w)/,
+          lookbehind: !0,
+          alias: "punctuation"
+        },
+        {
+          /* Special tokens used do delimit string templates */
+          pattern: /[|{}]/,
+          alias: "punctuation"
+        }
+      ],
+      punctuation: /[,.:()]/
+    };
+  }
+  return S;
+}
+var C = P();
+const M = /* @__PURE__ */ L(C), G = /* @__PURE__ */ D({
+  __proto__: null,
+  default: M
+}, [C]);
+export {
+  G as a
+};

package/dist/abnf-hvXtkKLY.js

@@ -0,0 +1,87 @@
+import { g as d } from "./index-Sj89RFCY.js";
+function f(t, a) {
+  for (var n = 0; n < a.length; n++) {
+    const e = a[n];
+    if (typeof e != "string" && !Array.isArray(e)) {
+      for (const r in e)
+        if (r !== "default" && !(r in t)) {
+          const i = Object.getOwnPropertyDescriptor(e, r);
+          i && Object.defineProperty(t, r, i.get ? i : {
+            enumerable: !0,
+            get: () => e[r]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
+}
+var o, u;
+function p() {
+  if (u) return o;
+  u = 1, o = t, t.displayName = "abnf", t.aliases = [];
+  function t(a) {
+    (function(n) {
+      var e = "(?:ALPHA|BIT|CHAR|CR|CRLF|CTL|DIGIT|DQUOTE|HEXDIG|HTAB|LF|LWSP|OCTET|SP|VCHAR|WSP)";
+      n.languages.abnf = {
+        comment: /;.*/,
+        string: {
+          pattern: /(?:%[is])?"[^"\n\r]*"/,
+          greedy: !0,
+          inside: {
+            punctuation: /^%[is]/
+          }
+        },
+        range: {
+          pattern: /%(?:b[01]+-[01]+|d\d+-\d+|x[A-F\d]+-[A-F\d]+)/i,
+          alias: "number"
+        },
+        terminal: {
+          pattern: /%(?:b[01]+(?:\.[01]+)*|d\d+(?:\.\d+)*|x[A-F\d]+(?:\.[A-F\d]+)*)/i,
+          alias: "number"
+        },
+        repetition: {
+          pattern: /(^|[^\w-])(?:\d*\*\d*|\d+)/,
+          lookbehind: !0,
+          alias: "operator"
+        },
+        definition: {
+          pattern: /(^[ \t]*)(?:[a-z][\w-]*|<[^<>\r\n]*>)(?=\s*=)/m,
+          lookbehind: !0,
+          alias: "keyword",
+          inside: {
+            punctuation: /<|>/
+          }
+        },
+        "core-rule": {
+          pattern: RegExp(
+            "(?:(^|[^<\\w-])" + e + "|<" + e + ">)(?![\\w-])",
+            "i"
+          ),
+          lookbehind: !0,
+          alias: ["rule", "constant"],
+          inside: {
+            punctuation: /<|>/
+          }
+        },
+        rule: {
+          pattern: /(^|[^<\w-])[a-z][\w-]*|<[^<>\r\n]*>/i,
+          lookbehind: !0,
+          inside: {
+            punctuation: /<|>/
+          }
+        },
+        operator: /=\/?|\//,
+        punctuation: /[()\[\]]/
+      };
+    })(a);
+  }
+  return o;
+}
+var s = p();
+const l = /* @__PURE__ */ d(s), b = /* @__PURE__ */ f({
+  __proto__: null,
+  default: l
+}, [s]);
+export {
+  b as a
+};

package/dist/actionscript-6i80VbAv.js

@@ -0,0 +1,43 @@
+import { g as l } from "./index-Sj89RFCY.js";
+function p(t, e) {
+  for (var n = 0; n < e.length; n++) {
+    const a = e[n];
+    if (typeof a != "string" && !Array.isArray(a)) {
+      for (const r in a)
+        if (r !== "default" && !(r in t)) {
+          const i = Object.getOwnPropertyDescriptor(a, r);
+          i && Object.defineProperty(t, r, i.get ? i : {
+            enumerable: !0,
+            get: () => a[r]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
+}
+var c, s;
+function u() {
+  if (s) return c;
+  s = 1, c = t, t.displayName = "actionscript", t.aliases = [];
+  function t(e) {
+    e.languages.actionscript = e.languages.extend("javascript", {
+      keyword: /\b(?:as|break|case|catch|class|const|default|delete|do|dynamic|each|else|extends|final|finally|for|function|get|if|implements|import|in|include|instanceof|interface|internal|is|namespace|native|new|null|override|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|use|var|void|while|with)\b/,
+      operator: /\+\+|--|(?:[+\-*\/%^]|&&?|\|\|?|<<?|>>?>?|[!=]=?)=?|[~?@]/
+    }), e.languages.actionscript["class-name"].alias = "function", delete e.languages.actionscript.parameter, delete e.languages.actionscript["literal-property"], e.languages.markup && e.languages.insertBefore("actionscript", "string", {
+      xml: {
+        pattern: /(^|[^.])<\/?\w+(?:\s+[^\s>\/=]+=("|')(?:\\[\s\S]|(?!\2)[^\\])*\2)*\s*\/?>/,
+        lookbehind: !0,
+        inside: e.languages.markup
+      }
+    });
+  }
+  return c;
+}
+var o = u();
+const f = /* @__PURE__ */ l(o), d = /* @__PURE__ */ p({
+  __proto__: null,
+  default: f
+}, [o]);
+export {
+  d as a
+};

package/dist/ada-CiSKRw34.js

@@ -0,0 +1,52 @@
+import { g as c } from "./index-Sj89RFCY.js";
+function l(e, t) {
+  for (var n = 0; n < t.length; n++) {
+    const a = t[n];
+    if (typeof a != "string" && !Array.isArray(a)) {
+      for (const r in a)
+        if (r !== "default" && !(r in e)) {
+          const o = Object.getOwnPropertyDescriptor(a, r);
+          o && Object.defineProperty(e, r, o.get ? o : {
+            enumerable: !0,
+            get: () => a[r]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var i, d;
+function u() {
+  if (d) return i;
+  d = 1, i = e, e.displayName = "ada", e.aliases = [];
+  function e(t) {
+    t.languages.ada = {
+      comment: /--.*/,
+      string: /"(?:""|[^"\r\f\n])*"/,
+      number: [
+        {
+          pattern: /\b\d(?:_?\d)*#[\dA-F](?:_?[\dA-F])*(?:\.[\dA-F](?:_?[\dA-F])*)?#(?:E[+-]?\d(?:_?\d)*)?/i
+        },
+        {
+          pattern: /\b\d(?:_?\d)*(?:\.\d(?:_?\d)*)?(?:E[+-]?\d(?:_?\d)*)?\b/i
+        }
+      ],
+      "attr-name": /\b'\w+/,
+      keyword: /\b(?:abort|abs|abstract|accept|access|aliased|all|and|array|at|begin|body|case|constant|declare|delay|delta|digits|do|else|elsif|end|entry|exception|exit|for|function|generic|goto|if|in|interface|is|limited|loop|mod|new|not|null|of|others|out|overriding|package|pragma|private|procedure|protected|raise|range|record|rem|renames|requeue|return|reverse|select|separate|some|subtype|synchronized|tagged|task|terminate|then|type|until|use|when|while|with|xor)\b/i,
+      boolean: /\b(?:false|true)\b/i,
+      operator: /<[=>]?|>=?|=>?|:=|\/=?|\*\*?|[&+-]/,
+      punctuation: /\.\.?|[,;():]/,
+      char: /'.'/,
+      variable: /\b[a-z](?:\w)*\b/i
+    };
+  }
+  return i;
+}
+var s = u();
+const p = /* @__PURE__ */ c(s), f = /* @__PURE__ */ l({
+  __proto__: null,
+  default: p
+}, [s]);
+export {
+  f as a
+};

package/dist/agda-BELchEdZ.js

@@ -0,0 +1,56 @@
+import { g as l } from "./index-Sj89RFCY.js";
+function c(e, n) {
+  for (var t = 0; t < n.length; t++) {
+    const r = n[t];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const a in r)
+        if (a !== "default" && !(a in e)) {
+          const o = Object.getOwnPropertyDescriptor(r, a);
+          o && Object.defineProperty(e, a, o.get ? o : {
+            enumerable: !0,
+            get: () => r[a]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var i, u;
+function d() {
+  if (u) return i;
+  u = 1, i = e, e.displayName = "agda", e.aliases = [];
+  function e(n) {
+    (function(t) {
+      t.languages.agda = {
+        comment: /\{-[\s\S]*?(?:-\}|$)|--.*/,
+        string: {
+          pattern: /"(?:\\(?:\r\n|[\s\S])|[^\\\r\n"])*"/,
+          greedy: !0
+        },
+        punctuation: /[(){}⦃⦄.;@]/,
+        "class-name": {
+          pattern: /((?:data|record) +)\S+/,
+          lookbehind: !0
+        },
+        function: {
+          pattern: /(^[ \t]*)(?!\s)[^:\r\n]+(?=:)/m,
+          lookbehind: !0
+        },
+        operator: {
+          pattern: /(^\s*|\s)(?:[=|:∀→λ\\?_]|->)(?=\s)/,
+          lookbehind: !0
+        },
+        keyword: /\b(?:Set|abstract|constructor|data|eta-equality|field|forall|hiding|import|in|inductive|infix|infixl|infixr|instance|let|macro|module|mutual|no-eta-equality|open|overlap|pattern|postulate|primitive|private|public|quote|quoteContext|quoteGoal|quoteTerm|record|renaming|rewrite|syntax|tactic|unquote|unquoteDecl|unquoteDef|using|variable|where|with)\b/
+      };
+    })(n);
+  }
+  return i;
+}
+var s = d();
+const g = /* @__PURE__ */ l(s), f = /* @__PURE__ */ c({
+  __proto__: null,
+  default: g
+}, [s]);
+export {
+  f as a
+};

package/dist/al-DkPZllof.js

@@ -0,0 +1,56 @@
+import { g as d } from "./index-Sj89RFCY.js";
+function c(e, o) {
+  for (var a = 0; a < o.length; a++) {
+    const t = o[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 n, s;
+function m() {
+  if (s) return n;
+  s = 1, n = e, e.displayName = "al", e.aliases = [];
+  function e(o) {
+    o.languages.al = {
+      comment: /\/\/.*|\/\*[\s\S]*?\*\//,
+      string: {
+        pattern: /'(?:''|[^'\r\n])*'(?!')|"(?:""|[^"\r\n])*"(?!")/,
+        greedy: !0
+      },
+      function: {
+        pattern: /(\b(?:event|procedure|trigger)\s+|(?:^|[^.])\.\s*)[a-z_]\w*(?=\s*\()/i,
+        lookbehind: !0
+      },
+      keyword: [
+        // keywords
+        /\b(?:array|asserterror|begin|break|case|do|downto|else|end|event|exit|for|foreach|function|if|implements|in|indataset|interface|internal|local|of|procedure|program|protected|repeat|runonclient|securityfiltering|suppressdispose|temporary|then|to|trigger|until|var|while|with|withevents)\b/i,
+        // objects and metadata that are used like keywords
+        /\b(?:action|actions|addafter|addbefore|addfirst|addlast|area|assembly|chartpart|codeunit|column|controladdin|cuegroup|customizes|dataitem|dataset|dotnet|elements|enum|enumextension|extends|field|fieldattribute|fieldelement|fieldgroup|fieldgroups|fields|filter|fixed|grid|group|key|keys|label|labels|layout|modify|moveafter|movebefore|movefirst|movelast|page|pagecustomization|pageextension|part|profile|query|repeater|report|requestpage|schema|separator|systempart|table|tableelement|tableextension|textattribute|textelement|type|usercontrol|value|xmlport)\b/i
+      ],
+      number: /\b(?:0x[\da-f]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?)(?:F|LL?|U(?:LL?)?)?\b/i,
+      boolean: /\b(?:false|true)\b/i,
+      variable: /\b(?:Curr(?:FieldNo|Page|Report)|x?Rec|RequestOptionsPage)\b/,
+      "class-name": /\b(?:automation|biginteger|bigtext|blob|boolean|byte|char|clienttype|code|completiontriggererrorlevel|connectiontype|database|dataclassification|datascope|date|dateformula|datetime|decimal|defaultlayout|dialog|dictionary|dotnetassembly|dotnettypedeclaration|duration|errorinfo|errortype|executioncontext|executionmode|fieldclass|fieldref|fieldtype|file|filterpagebuilder|guid|httpclient|httpcontent|httpheaders|httprequestmessage|httpresponsemessage|instream|integer|joker|jsonarray|jsonobject|jsontoken|jsonvalue|keyref|list|moduledependencyinfo|moduleinfo|none|notification|notificationscope|objecttype|option|outstream|pageresult|record|recordid|recordref|reportformat|securityfilter|sessionsettings|tableconnectiontype|tablefilter|testaction|testfield|testfilterfield|testpage|testpermissions|testrequestpage|text|textbuilder|textconst|textencoding|time|transactionmodel|transactiontype|variant|verbosity|version|view|views|webserviceactioncontext|webserviceactionresultcode|xmlattribute|xmlattributecollection|xmlcdata|xmlcomment|xmldeclaration|xmldocument|xmldocumenttype|xmlelement|xmlnamespacemanager|xmlnametable|xmlnode|xmlnodelist|xmlprocessinginstruction|xmlreadoptions|xmltext|xmlwriteoptions)\b/i,
+      operator: /\.\.|:[=:]|[-+*/]=?|<>|[<>]=?|=|\b(?:and|div|mod|not|or|xor)\b/i,
+      punctuation: /[()\[\]{}:.;,]/
+    };
+  }
+  return n;
+}
+var l = m();
+const p = /* @__PURE__ */ d(l), f = /* @__PURE__ */ c({
+  __proto__: null,
+  default: p
+}, [l]);
+export {
+  f as a
+};

package/dist/antlr4-D6U2qvIr.js

@@ -0,0 +1,96 @@
+import { g as u } from "./index-Sj89RFCY.js";
+function c(t, e) {
+  for (var r = 0; r < e.length; r++) {
+    const n = e[r];
+    if (typeof n != "string" && !Array.isArray(n)) {
+      for (const a in n)
+        if (a !== "default" && !(a in t)) {
+          const o = Object.getOwnPropertyDescriptor(n, a);
+          o && Object.defineProperty(t, a, o.get ? o : {
+            enumerable: !0,
+            get: () => n[a]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
+}
+var s, i;
+function p() {
+  if (i) return s;
+  i = 1, s = t, t.displayName = "antlr4", t.aliases = ["g4"];
+  function t(e) {
+    e.languages.antlr4 = {
+      comment: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
+      string: {
+        pattern: /'(?:\\.|[^\\'\r\n])*'/,
+        greedy: !0
+      },
+      "character-class": {
+        pattern: /\[(?:\\.|[^\\\]\r\n])*\]/,
+        greedy: !0,
+        alias: "regex",
+        inside: {
+          range: {
+            pattern: /([^[]|(?:^|[^\\])(?:\\\\)*\\\[)-(?!\])/,
+            lookbehind: !0,
+            alias: "punctuation"
+          },
+          escape: /\\(?:u(?:[a-fA-F\d]{4}|\{[a-fA-F\d]+\})|[pP]\{[=\w-]+\}|[^\r\nupP])/,
+          punctuation: /[\[\]]/
+        }
+      },
+      action: {
+        pattern: /\{(?:[^{}]|\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\})*\}/,
+        greedy: !0,
+        inside: {
+          content: {
+            // this might be C, C++, Python, Java, C#, or any other language ANTLR4 compiles to
+            pattern: /(\{)[\s\S]+(?=\})/,
+            lookbehind: !0
+          },
+          punctuation: /[{}]/
+        }
+      },
+      command: {
+        pattern: /(->\s*(?!\s))(?:\s*(?:,\s*)?\b[a-z]\w*(?:\s*\([^()\r\n]*\))?)+(?=\s*;)/i,
+        lookbehind: !0,
+        inside: {
+          function: /\b\w+(?=\s*(?:[,(]|$))/,
+          punctuation: /[,()]/
+        }
+      },
+      annotation: {
+        pattern: /@\w+(?:::\w+)*/,
+        alias: "keyword"
+      },
+      label: {
+        pattern: /#[ \t]*\w+/,
+        alias: "punctuation"
+      },
+      keyword: /\b(?:catch|channels|finally|fragment|grammar|import|lexer|locals|mode|options|parser|returns|throws|tokens)\b/,
+      definition: [
+        {
+          pattern: /\b[a-z]\w*(?=\s*:)/,
+          alias: ["rule", "class-name"]
+        },
+        {
+          pattern: /\b[A-Z]\w*(?=\s*:)/,
+          alias: ["token", "constant"]
+        }
+      ],
+      constant: /\b[A-Z][A-Z_]*\b/,
+      operator: /\.\.|->|[|~]|[*+?]\??/,
+      punctuation: /[;:()=]/
+    }, e.languages.g4 = e.languages.antlr4;
+  }
+  return s;
+}
+var l = p();
+const g = /* @__PURE__ */ u(l), f = /* @__PURE__ */ c({
+  __proto__: null,
+  default: g
+}, [l]);
+export {
+  f as a
+};

package/dist/apacheconf-DoADUQkC.js

@@ -0,0 +1,80 @@
+import { g as l } from "./index-Sj89RFCY.js";
+function u(e, i) {
+  for (var a = 0; a < i.length; a++) {
+    const r = i[a];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const t in r)
+        if (t !== "default" && !(t in e)) {
+          const o = Object.getOwnPropertyDescriptor(r, t);
+          o && Object.defineProperty(e, t, o.get ? o : {
+            enumerable: !0,
+            get: () => r[t]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var n, s;
+function d() {
+  if (s) return n;
+  s = 1, n = e, e.displayName = "apacheconf", e.aliases = [];
+  function e(i) {
+    i.languages.apacheconf = {
+      comment: /#.*/,
+      "directive-inline": {
+        pattern: /(^[\t ]*)\b(?:AcceptFilter|AcceptPathInfo|AccessFileName|Action|Add(?:Alt|AltByEncoding|AltByType|Charset|DefaultCharset|Description|Encoding|Handler|Icon|IconByEncoding|IconByType|InputFilter|Language|ModuleInfo|OutputFilter|OutputFilterByType|Type)|Alias|AliasMatch|Allow(?:CONNECT|EncodedSlashes|Methods|Override|OverrideList)?|Anonymous(?:_LogEmail|_MustGiveEmail|_NoUserID|_VerifyEmail)?|AsyncRequestWorkerFactor|Auth(?:BasicAuthoritative|BasicFake|BasicProvider|BasicUseDigestAlgorithm|DBDUserPWQuery|DBDUserRealmQuery|DBMGroupFile|DBMType|DBMUserFile|Digest(?:Algorithm|Domain|NonceLifetime|Provider|Qop|ShmemSize)|Form(?:Authoritative|Body|DisableNoStore|FakeBasicAuth|Location|LoginRequiredLocation|LoginSuccessLocation|LogoutLocation|Method|Mimetype|Password|Provider|SitePassphrase|Size|Username)|GroupFile|LDAP(?:AuthorizePrefix|BindAuthoritative|BindDN|BindPassword|CharsetConfig|CompareAsUser|CompareDNOnServer|DereferenceAliases|GroupAttribute|GroupAttributeIsDN|InitialBindAsUser|InitialBindPattern|MaxSubGroupDepth|RemoteUserAttribute|RemoteUserIsDN|SearchAsUser|SubGroupAttribute|SubGroupClass|Url)|Merging|Name|nCache(?:Context|Enable|ProvideFor|SOCache|Timeout)|nzFcgiCheckAuthnProvider|nzFcgiDefineProvider|Type|UserFile|zDBDLoginToReferer|zDBDQuery|zDBDRedirectQuery|zDBMType|zSendForbiddenOnFailure)|BalancerGrowth|BalancerInherit|BalancerMember|BalancerPersist|BrowserMatch|BrowserMatchNoCase|BufferedLogs|BufferSize|Cache(?:DefaultExpire|DetailHeader|DirLength|DirLevels|Disable|Enable|File|Header|IgnoreCacheControl|IgnoreHeaders|IgnoreNoLastMod|IgnoreQueryString|IgnoreURLSessionIdentifiers|KeyBaseURL|LastModifiedFactor|Lock|LockMaxAge|LockPath|MaxExpire|MaxFileSize|MinExpire|MinFileSize|NegotiatedDocs|QuickHandler|ReadSize|ReadTime|Root|Socache(?:MaxSize|MaxTime|MinTime|ReadSize|ReadTime)?|StaleOnError|StoreExpired|StoreNoStore|StorePrivate)|CGIDScriptTimeout|CGIMapExtension|CharsetDefault|CharsetOptions|CharsetSourceEnc|CheckCaseOnly|CheckSpelling|ChrootDir|ContentDigest|CookieDomain|CookieExpires|CookieName|CookieStyle|CookieTracking|CoreDumpDirectory|CustomLog|Dav|DavDepthInfinity|DavGenericLockDB|DavLockDB|DavMinTimeout|DBDExptime|DBDInitSQL|DBDKeep|DBDMax|DBDMin|DBDParams|DBDPersist|DBDPrepareSQL|DBDriver|DefaultIcon|DefaultLanguage|DefaultRuntimeDir|DefaultType|Define|Deflate(?:BufferSize|CompressionLevel|FilterNote|InflateLimitRequestBody|InflateRatio(?:Burst|Limit)|MemLevel|WindowSize)|Deny|DirectoryCheckHandler|DirectoryIndex|DirectoryIndexRedirect|DirectorySlash|DocumentRoot|DTracePrivileges|DumpIOInput|DumpIOOutput|EnableExceptionHook|EnableMMAP|EnableSendfile|Error|ErrorDocument|ErrorLog|ErrorLogFormat|Example|ExpiresActive|ExpiresByType|ExpiresDefault|ExtendedStatus|ExtFilterDefine|ExtFilterOptions|FallbackResource|FileETag|FilterChain|FilterDeclare|FilterProtocol|FilterProvider|FilterTrace|ForceLanguagePriority|ForceType|ForensicLog|GprofDir|GracefulShutdownTimeout|Group|Header|HeaderName|Heartbeat(?:Address|Listen|MaxServers|Storage)|HostnameLookups|IdentityCheck|IdentityCheckTimeout|ImapBase|ImapDefault|ImapMenu|Include|IncludeOptional|Index(?:HeadInsert|Ignore|IgnoreReset|Options|OrderDefault|StyleSheet)|InputSed|ISAPI(?:AppendLogToErrors|AppendLogToQuery|CacheFile|FakeAsync|LogNotSupported|ReadAheadBuffer)|KeepAlive|KeepAliveTimeout|KeptBodySize|LanguagePriority|LDAP(?:CacheEntries|CacheTTL|ConnectionPoolTTL|ConnectionTimeout|LibraryDebug|OpCacheEntries|OpCacheTTL|ReferralHopLimit|Referrals|Retries|RetryDelay|SharedCacheFile|SharedCacheSize|Timeout|TrustedClientCert|TrustedGlobalCert|TrustedMode|VerifyServerCert)|Limit(?:InternalRecursion|Request(?:Body|Fields|FieldSize|Line)|XMLRequestBody)|Listen|ListenBackLog|LoadFile|LoadModule|LogFormat|LogLevel|LogMessage|LuaAuthzProvider|LuaCodeCache|Lua(?:Hook(?:AccessChecker|AuthChecker|CheckUserID|Fixups|InsertFilter|Log|MapToStorage|TranslateName|TypeChecker)|Inherit|InputFilter|MapHandler|OutputFilter|PackageCPath|PackagePath|QuickHandler|Root|Scope)|Max(?:ConnectionsPerChild|KeepAliveRequests|MemFree|RangeOverlaps|RangeReversals|Ranges|RequestWorkers|SpareServers|SpareThreads|Threads)|MergeTrailers|MetaDir|MetaFiles|MetaSuffix|MimeMagicFile|MinSpareServers|MinSpareThreads|MMapFile|ModemStandard|ModMimeUsePathInfo|MultiviewsMatch|Mutex|NameVirtualHost|NoProxy|NWSSLTrustedCerts|NWSSLUpgradeable|Options|Order|OutputSed|PassEnv|PidFile|PrivilegesMode|Protocol|ProtocolEcho|Proxy(?:AddHeaders|BadHeader|Block|Domain|ErrorOverride|ExpressDBMFile|ExpressDBMType|ExpressEnable|FtpDirCharset|FtpEscapeWildcards|FtpListOnWildcard|HTML(?:BufSize|CharsetOut|DocType|Enable|Events|Extended|Fixups|Interp|Links|Meta|StripComments|URLMap)|IOBufferSize|MaxForwards|Pass(?:Inherit|InterpolateEnv|Match|Reverse|ReverseCookieDomain|ReverseCookiePath)?|PreserveHost|ReceiveBufferSize|Remote|RemoteMatch|Requests|SCGIInternalRedirect|SCGISendfile|Set|SourceAddress|Status|Timeout|Via)|ReadmeName|ReceiveBufferSize|Redirect|RedirectMatch|RedirectPermanent|RedirectTemp|ReflectorHeader|RemoteIP(?:Header|InternalProxy|InternalProxyList|ProxiesHeader|TrustedProxy|TrustedProxyList)|RemoveCharset|RemoveEncoding|RemoveHandler|RemoveInputFilter|RemoveLanguage|RemoveOutputFilter|RemoveType|RequestHeader|RequestReadTimeout|Require|Rewrite(?:Base|Cond|Engine|Map|Options|Rule)|RLimitCPU|RLimitMEM|RLimitNPROC|Satisfy|ScoreBoardFile|Script(?:Alias|AliasMatch|InterpreterSource|Log|LogBuffer|LogLength|Sock)?|SecureListen|SeeRequestTail|SendBufferSize|Server(?:Admin|Alias|Limit|Name|Path|Root|Signature|Tokens)|Session(?:Cookie(?:Name|Name2|Remove)|Crypto(?:Cipher|Driver|Passphrase|PassphraseFile)|DBD(?:CookieName|CookieName2|CookieRemove|DeleteLabel|InsertLabel|PerUser|SelectLabel|UpdateLabel)|Env|Exclude|Header|Include|MaxAge)?|SetEnv|SetEnvIf|SetEnvIfExpr|SetEnvIfNoCase|SetHandler|SetInputFilter|SetOutputFilter|SSIEndTag|SSIErrorMsg|SSIETag|SSILastModified|SSILegacyExprParser|SSIStartTag|SSITimeFormat|SSIUndefinedEcho|SSL(?:CACertificateFile|CACertificatePath|CADNRequestFile|CADNRequestPath|CARevocationCheck|CARevocationFile|CARevocationPath|CertificateChainFile|CertificateFile|CertificateKeyFile|CipherSuite|Compression|CryptoDevice|Engine|FIPS|HonorCipherOrder|InsecureRenegotiation|OCSP(?:DefaultResponder|Enable|OverrideResponder|ResponderTimeout|ResponseMaxAge|ResponseTimeSkew|UseRequestNonce)|OpenSSLConfCmd|Options|PassPhraseDialog|Protocol|Proxy(?:CACertificateFile|CACertificatePath|CARevocation(?:Check|File|Path)|CheckPeer(?:CN|Expire|Name)|CipherSuite|Engine|MachineCertificate(?:ChainFile|File|Path)|Protocol|Verify|VerifyDepth)|RandomSeed|RenegBufferSize|Require|RequireSSL|Session(?:Cache|CacheTimeout|TicketKeyFile|Tickets)|SRPUnknownUserSeed|SRPVerifierFile|Stapling(?:Cache|ErrorCacheTimeout|FakeTryLater|ForceURL|ResponderTimeout|ResponseMaxAge|ResponseTimeSkew|ReturnResponderErrors|StandardCacheTimeout)|StrictSNIVHostCheck|UserName|UseStapling|VerifyClient|VerifyDepth)|StartServers|StartThreads|Substitute|Suexec|SuexecUserGroup|ThreadLimit|ThreadsPerChild|ThreadStackSize|TimeOut|TraceEnable|TransferLog|TypesConfig|UnDefine|UndefMacro|UnsetEnv|Use|UseCanonicalName|UseCanonicalPhysicalPort|User|UserDir|VHostCGIMode|VHostCGIPrivs|VHostGroup|VHostPrivs|VHostSecure|VHostUser|Virtual(?:DocumentRoot|ScriptAlias)(?:IP)?|WatchdogInterval|XBitHack|xml2EncAlias|xml2EncDefault|xml2StartParse)\b/im,
+        lookbehind: !0,
+        alias: "property"
+      },
+      "directive-block": {
+        pattern: /<\/?\b(?:Auth[nz]ProviderAlias|Directory|DirectoryMatch|Else|ElseIf|Files|FilesMatch|If|IfDefine|IfModule|IfVersion|Limit|LimitExcept|Location|LocationMatch|Macro|Proxy|Require(?:All|Any|None)|VirtualHost)\b.*>/i,
+        inside: {
+          "directive-block": {
+            pattern: /^<\/?\w+/,
+            inside: {
+              punctuation: /^<\/?/
+            },
+            alias: "tag"
+          },
+          "directive-block-parameter": {
+            pattern: /.*[^>]/,
+            inside: {
+              punctuation: /:/,
+              string: {
+                pattern: /("|').*\1/,
+                inside: {
+                  variable: /[$%]\{?(?:\w\.?[-+:]?)+\}?/
+                }
+              }
+            },
+            alias: "attr-value"
+          },
+          punctuation: />/
+        },
+        alias: "tag"
+      },
+      "directive-flags": {
+        pattern: /\[(?:[\w=],?)+\]/,
+        alias: "keyword"
+      },
+      string: {
+        pattern: /("|').*\1/,
+        inside: {
+          variable: /[$%]\{?(?:\w\.?[-+:]?)+\}?/
+        }
+      },
+      variable: /[$%]\{?(?:\w\.?[-+:]?)+\}?/,
+      regex: /\^?.*\$|\^.*\$?/
+    };
+  }
+  return n;
+}
+var c = d();
+const p = /* @__PURE__ */ l(c), h = /* @__PURE__ */ u({
+  __proto__: null,
+  default: p
+}, [c]);
+export {
+  h as a
+};