@oscloudlab/knowledge-card 0.0.1 → 0.0.2

package/dist/apex-Dwxgykqz.js

@@ -0,0 +1,104 @@
+import { g } from "./index-Sj89RFCY.js";
+import { r as d } from "./sql-qhcRp-Km.js";
+function b(a, r) {
+  for (var n = 0; n < r.length; n++) {
+    const e = r[n];
+    if (typeof e != "string" && !Array.isArray(e)) {
+      for (const t in e)
+        if (t !== "default" && !(t in a)) {
+          const i = Object.getOwnPropertyDescriptor(e, t);
+          i && Object.defineProperty(a, t, i.get ? i : {
+            enumerable: !0,
+            get: () => e[t]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(a, Symbol.toStringTag, { value: "Module" }));
+}
+var l, c;
+function f() {
+  if (c) return l;
+  c = 1;
+  var a = d();
+  l = r, r.displayName = "apex", r.aliases = [];
+  function r(n) {
+    n.register(a), function(e) {
+      var t = /\b(?:(?:after|before)(?=\s+[a-z])|abstract|activate|and|any|array|as|asc|autonomous|begin|bigdecimal|blob|boolean|break|bulk|by|byte|case|cast|catch|char|class|collect|commit|const|continue|currency|date|datetime|decimal|default|delete|desc|do|double|else|end|enum|exception|exit|export|extends|final|finally|float|for|from|get(?=\s*[{};])|global|goto|group|having|hint|if|implements|import|in|inner|insert|instanceof|int|integer|interface|into|join|like|limit|list|long|loop|map|merge|new|not|null|nulls|number|object|of|on|or|outer|override|package|parallel|pragma|private|protected|public|retrieve|return|rollback|select|set|short|sObject|sort|static|string|super|switch|synchronized|system|testmethod|then|this|throw|time|transaction|transient|trigger|try|undelete|update|upsert|using|virtual|void|webservice|when|where|while|(?:inherited|with|without)\s+sharing)\b/i, i = /\b(?:(?=[a-z_]\w*\s*[<\[])|(?!<keyword>))[A-Z_]\w*(?:\s*\.\s*[A-Z_]\w*)*\b(?:\s*(?:\[\s*\]|<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>))*/.source.replace(
+        /<keyword>/g,
+        function() {
+          return t.source;
+        }
+      );
+      function s(p) {
+        return RegExp(
+          p.replace(/<CLASS-NAME>/g, function() {
+            return i;
+          }),
+          "i"
+        );
+      }
+      var o = {
+        keyword: t,
+        punctuation: /[()\[\]{};,:.<>]/
+      };
+      e.languages.apex = {
+        comment: e.languages.clike.comment,
+        string: e.languages.clike.string,
+        sql: {
+          pattern: /((?:[=,({:]|\breturn)\s*)\[[^\[\]]*\]/i,
+          lookbehind: !0,
+          greedy: !0,
+          alias: "language-sql",
+          inside: e.languages.sql
+        },
+        annotation: {
+          pattern: /@\w+\b/,
+          alias: "punctuation"
+        },
+        "class-name": [
+          {
+            pattern: s(
+              /(\b(?:class|enum|extends|implements|instanceof|interface|new|trigger\s+\w+\s+on)\s+)<CLASS-NAME>/.source
+            ),
+            lookbehind: !0,
+            inside: o
+          },
+          {
+            // cast
+            pattern: s(
+              /(\(\s*)<CLASS-NAME>(?=\s*\)\s*[\w(])/.source
+            ),
+            lookbehind: !0,
+            inside: o
+          },
+          {
+            // variable/parameter declaration and return types
+            pattern: s(/<CLASS-NAME>(?=\s*\w+\s*[;=,(){:])/.source),
+            inside: o
+          }
+        ],
+        trigger: {
+          pattern: /(\btrigger\s+)\w+\b/i,
+          lookbehind: !0,
+          alias: "class-name"
+        },
+        keyword: t,
+        function: /\b[a-z_]\w*(?=\s*\()/i,
+        boolean: /\b(?:false|true)\b/i,
+        number: /(?:\B\.\d+|\b\d+(?:\.\d+|L)?)\b/i,
+        operator: /[!=](?:==?)?|\?\.?|&&|\|\||--|\+\+|[-+*/^&|]=?|:|<<?=?|>{1,3}=?/,
+        punctuation: /[()\[\]{};,.]/
+      };
+    }(n);
+  }
+  return l;
+}
+var u = f();
+const m = /* @__PURE__ */ g(u), y = /* @__PURE__ */ b({
+  __proto__: null,
+  default: m
+}, [u]);
+export {
+  y as a
+};

package/dist/apl-n43gQAL3.js

@@ -0,0 +1,65 @@
+import { g as l } from "./index-Sj89RFCY.js";
+function u(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 o = Object.getOwnPropertyDescriptor(e, r);
+          o && Object.defineProperty(t, r, o.get ? o : {
+            enumerable: !0,
+            get: () => e[r]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
+}
+var i, p;
+function c() {
+  if (p) return i;
+  p = 1, i = t, t.displayName = "apl", t.aliases = [];
+  function t(a) {
+    a.languages.apl = {
+      comment: /(?:⍝|#[! ]).*$/m,
+      string: {
+        pattern: /'(?:[^'\r\n]|'')*'/,
+        greedy: !0
+      },
+      number: /¯?(?:\d*\.?\b\d+(?:e[+¯]?\d+)?|¯|∞)(?:j¯?(?:(?:\d+(?:\.\d+)?|\.\d+)(?:e[+¯]?\d+)?|¯|∞))?/i,
+      statement: /:[A-Z][a-z][A-Za-z]*\b/,
+      "system-function": {
+        pattern: /⎕[A-Z]+/i,
+        alias: "function"
+      },
+      constant: /[⍬⌾#⎕⍞]/,
+      function: /[-+×÷⌈⌊∣|⍳⍸?*⍟○!⌹<≤=>≥≠≡≢∊⍷∪∩~∨∧⍱⍲⍴,⍪⌽⊖⍉↑↓⊂⊃⊆⊇⌷⍋⍒⊤⊥⍕⍎⊣⊢⍁⍂≈⍯↗¤→]/,
+      "monadic-operator": {
+        pattern: /[\\\/⌿⍀¨⍨⌶&∥]/,
+        alias: "operator"
+      },
+      "dyadic-operator": {
+        pattern: /[.⍣⍠⍤∘⌸@⌺⍥]/,
+        alias: "operator"
+      },
+      assignment: {
+        pattern: /←/,
+        alias: "keyword"
+      },
+      punctuation: /[\[;\]()◇⋄]/,
+      dfn: {
+        pattern: /[{}⍺⍵⍶⍹∇⍫:]/,
+        alias: "builtin"
+      }
+    };
+  }
+  return i;
+}
+var s = c();
+const d = /* @__PURE__ */ l(s), g = /* @__PURE__ */ u({
+  __proto__: null,
+  default: d
+}, [s]);
+export {
+  g as a
+};

package/dist/applescript-DUNzhl2t.js

@@ -0,0 +1,50 @@
+import { g as l } from "./index-Sj89RFCY.js";
+function u(e, s) {
+  for (var i = 0; i < s.length; i++) {
+    const t = s[i];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const r in t)
+        if (r !== "default" && !(r in e)) {
+          const o = Object.getOwnPropertyDescriptor(t, r);
+          o && Object.defineProperty(e, r, o.get ? o : {
+            enumerable: !0,
+            get: () => t[r]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var n, a;
+function p() {
+  if (a) return n;
+  a = 1, n = e, e.displayName = "applescript", e.aliases = [];
+  function e(s) {
+    s.languages.applescript = {
+      comment: [
+        // Allow one level of nesting
+        /\(\*(?:\(\*(?:[^*]|\*(?!\)))*\*\)|(?!\(\*)[\s\S])*?\*\)/,
+        /--.+/,
+        /#.+/
+      ],
+      string: /"(?:\\.|[^"\\\r\n])*"/,
+      number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e-?\d+)?\b/i,
+      operator: [
+        /[&=≠≤≥*+\-\/÷^]|[<>]=?/,
+        /\b(?:(?:begin|end|start)s? with|(?:contains?|(?:does not|doesn't) contain)|(?:is|isn't|is not) (?:contained by|in)|(?:(?:is|isn't|is not) )?(?:greater|less) than(?: or equal)?(?: to)?|(?:comes|(?:does not|doesn't) come) (?:after|before)|(?:is|isn't|is not) equal(?: to)?|(?:(?:does not|doesn't) equal|equal to|equals|is not|isn't)|(?:a )?(?:ref(?: to)?|reference to)|(?:and|as|div|mod|not|or))\b/
+      ],
+      keyword: /\b(?:about|above|after|against|apart from|around|aside from|at|back|before|beginning|behind|below|beneath|beside|between|but|by|considering|continue|copy|does|eighth|else|end|equal|error|every|exit|false|fifth|first|for|fourth|from|front|get|given|global|if|ignoring|in|instead of|into|is|it|its|last|local|me|middle|my|ninth|of|on|onto|out of|over|prop|property|put|repeat|return|returning|second|set|seventh|since|sixth|some|tell|tenth|that|the|then|third|through|thru|timeout|times|to|transaction|true|try|until|where|while|whose|with|without)\b/,
+      "class-name": /\b(?:POSIX file|RGB color|alias|application|boolean|centimeters|centimetres|class|constant|cubic centimeters|cubic centimetres|cubic feet|cubic inches|cubic meters|cubic metres|cubic yards|date|degrees Celsius|degrees Fahrenheit|degrees Kelvin|feet|file|gallons|grams|inches|integer|kilograms|kilometers|kilometres|list|liters|litres|meters|metres|miles|number|ounces|pounds|quarts|real|record|reference|script|square feet|square kilometers|square kilometres|square meters|square metres|square miles|square yards|text|yards)\b/,
+      punctuation: /[{}():,¬«»《》]/
+    };
+  }
+  return n;
+}
+var c = p();
+const d = /* @__PURE__ */ l(c), m = /* @__PURE__ */ u({
+  __proto__: null,
+  default: d
+}, [c]);
+export {
+  m as a
+};

package/dist/aql-BNnsomU8.js

@@ -0,0 +1,82 @@
+import { g as s } from "./index-Sj89RFCY.js";
+function u(e, a) {
+  for (var n = 0; n < a.length; n++) {
+    const r = a[n];
+    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 i, l;
+function b() {
+  if (l) return i;
+  l = 1, i = e, e.displayName = "aql", e.aliases = [];
+  function e(a) {
+    a.languages.aql = {
+      comment: /\/\/.*|\/\*[\s\S]*?\*\//,
+      property: {
+        pattern: /([{,]\s*)(?:(?!\d)\w+|(["'´`])(?:(?!\2)[^\\\r\n]|\\.)*\2)(?=\s*:)/,
+        lookbehind: !0,
+        greedy: !0
+      },
+      string: {
+        pattern: /(["'])(?:(?!\1)[^\\\r\n]|\\.)*\1/,
+        greedy: !0
+      },
+      identifier: {
+        pattern: /([´`])(?:(?!\1)[^\\\r\n]|\\.)*\1/,
+        greedy: !0
+      },
+      variable: /@@?\w+/,
+      keyword: [
+        {
+          pattern: /(\bWITH\s+)COUNT(?=\s+INTO\b)/i,
+          lookbehind: !0
+        },
+        /\b(?:AGGREGATE|ALL|AND|ANY|ASC|COLLECT|DESC|DISTINCT|FILTER|FOR|GRAPH|IN|INBOUND|INSERT|INTO|K_PATHS|K_SHORTEST_PATHS|LET|LIKE|LIMIT|NONE|NOT|NULL|OR|OUTBOUND|REMOVE|REPLACE|RETURN|SHORTEST_PATH|SORT|UPDATE|UPSERT|WINDOW|WITH)\b/i,
+        // pseudo keywords get a lookbehind to avoid false positives
+        {
+          pattern: /(^|[^\w.[])(?:KEEP|PRUNE|SEARCH|TO)\b/i,
+          lookbehind: !0
+        },
+        {
+          pattern: /(^|[^\w.[])(?:CURRENT|NEW|OLD)\b/,
+          lookbehind: !0
+        },
+        {
+          pattern: /\bOPTIONS(?=\s*\{)/i
+        }
+      ],
+      function: /\b(?!\d)\w+(?=\s*\()/,
+      boolean: /\b(?:false|true)\b/i,
+      range: {
+        pattern: /\.\./,
+        alias: "operator"
+      },
+      number: [
+        /\b0b[01]+/i,
+        /\b0x[0-9a-f]+/i,
+        /(?:\B\.\d+|\b(?:0|[1-9]\d*)(?:\.\d+)?)(?:e[+-]?\d+)?/i
+      ],
+      operator: /\*{2,}|[=!]~|[!=<>]=?|&&|\|\||[-+*/%]/,
+      punctuation: /::|[?.:,;()[\]{}]/
+    };
+  }
+  return i;
+}
+var T = b();
+const E = /* @__PURE__ */ s(T), O = /* @__PURE__ */ u({
+  __proto__: null,
+  default: E
+}, [T]);
+export {
+  O as a
+};

package/dist/arduino-Ctiiir5A.js

@@ -0,0 +1,41 @@
+import { g as d } from "./index-Sj89RFCY.js";
+import { r as c } from "./cpp-C0j-5811.js";
+function u(t, r) {
+  for (var e = 0; e < r.length; e++) {
+    const o = r[e];
+    if (typeof o != "string" && !Array.isArray(o)) {
+      for (const i in o)
+        if (i !== "default" && !(i in t)) {
+          const n = Object.getOwnPropertyDescriptor(o, i);
+          n && Object.defineProperty(t, i, n.get ? n : {
+            enumerable: !0,
+            get: () => o[i]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
+}
+var a, s;
+function g() {
+  if (s) return a;
+  s = 1;
+  var t = c();
+  a = r, r.displayName = "arduino", r.aliases = ["ino"];
+  function r(e) {
+    e.register(t), e.languages.arduino = e.languages.extend("cpp", {
+      keyword: /\b(?:String|array|bool|boolean|break|byte|case|catch|continue|default|do|double|else|finally|for|function|goto|if|in|instanceof|int|integer|long|loop|new|null|return|setup|string|switch|throw|try|void|while|word)\b/,
+      constant: /\b(?:ANALOG_MESSAGE|DEFAULT|DIGITAL_MESSAGE|EXTERNAL|FIRMATA_STRING|HIGH|INPUT|INPUT_PULLUP|INTERNAL|INTERNAL1V1|INTERNAL2V56|LED_BUILTIN|LOW|OUTPUT|REPORT_ANALOG|REPORT_DIGITAL|SET_PIN_MODE|SYSEX_START|SYSTEM_RESET)\b/,
+      builtin: /\b(?:Audio|BSSID|Bridge|Client|Console|EEPROM|Esplora|EsploraTFT|Ethernet|EthernetClient|EthernetServer|EthernetUDP|File|FileIO|FileSystem|Firmata|GPRS|GSM|GSMBand|GSMClient|GSMModem|GSMPIN|GSMScanner|GSMServer|GSMVoiceCall|GSM_SMS|HttpClient|IPAddress|IRread|Keyboard|KeyboardController|LiquidCrystal|LiquidCrystal_I2C|Mailbox|Mouse|MouseController|PImage|Process|RSSI|RobotControl|RobotMotor|SD|SPI|SSID|Scheduler|Serial|Server|Servo|SoftwareSerial|Stepper|Stream|TFT|Task|USBHost|WiFi|WiFiClient|WiFiServer|WiFiUDP|Wire|YunClient|YunServer|abs|addParameter|analogRead|analogReadResolution|analogReference|analogWrite|analogWriteResolution|answerCall|attach|attachGPRS|attachInterrupt|attached|autoscroll|available|background|beep|begin|beginPacket|beginSD|beginSMS|beginSpeaker|beginTFT|beginTransmission|beginWrite|bit|bitClear|bitRead|bitSet|bitWrite|blink|blinkVersion|buffer|changePIN|checkPIN|checkPUK|checkReg|circle|cityNameRead|cityNameWrite|clear|clearScreen|click|close|compassRead|config|connect|connected|constrain|cos|countryNameRead|countryNameWrite|createChar|cursor|debugPrint|delay|delayMicroseconds|detach|detachInterrupt|digitalRead|digitalWrite|disconnect|display|displayLogos|drawBMP|drawCompass|encryptionType|end|endPacket|endSMS|endTransmission|endWrite|exists|exitValue|fill|find|findUntil|flush|gatewayIP|get|getAsynchronously|getBand|getButton|getCurrentCarrier|getIMEI|getKey|getModifiers|getOemKey|getPINUsed|getResult|getSignalStrength|getSocket|getVoiceCallStatus|getXChange|getYChange|hangCall|height|highByte|home|image|interrupts|isActionDone|isDirectory|isListening|isPIN|isPressed|isValid|keyPressed|keyReleased|keyboardRead|knobRead|leftToRight|line|lineFollowConfig|listen|listenOnLocalhost|loadImage|localIP|lowByte|macAddress|maintain|map|max|messageAvailable|micros|millis|min|mkdir|motorsStop|motorsWrite|mouseDragged|mouseMoved|mousePressed|mouseReleased|move|noAutoscroll|noBlink|noBuffer|noCursor|noDisplay|noFill|noInterrupts|noListenOnLocalhost|noStroke|noTone|onReceive|onRequest|open|openNextFile|overflow|parseCommand|parseFloat|parseInt|parsePacket|pauseMode|peek|pinMode|playFile|playMelody|point|pointTo|position|pow|prepare|press|print|printFirmwareVersion|printVersion|println|process|processInput|pulseIn|put|random|randomSeed|read|readAccelerometer|readBlue|readButton|readBytes|readBytesUntil|readGreen|readJoystickButton|readJoystickSwitch|readJoystickX|readJoystickY|readLightSensor|readMessage|readMicrophone|readNetworks|readRed|readSlider|readString|readStringUntil|readTemperature|ready|rect|release|releaseAll|remoteIP|remoteNumber|remotePort|remove|requestFrom|retrieveCallingNumber|rewindDirectory|rightToLeft|rmdir|robotNameRead|robotNameWrite|run|runAsynchronously|runShellCommand|runShellCommandAsynchronously|running|scanNetworks|scrollDisplayLeft|scrollDisplayRight|seek|sendAnalog|sendDigitalPortPair|sendDigitalPorts|sendString|sendSysex|serialEvent|setBand|setBitOrder|setClockDivider|setCursor|setDNS|setDataMode|setFirmwareVersion|setMode|setPINUsed|setSpeed|setTextSize|setTimeout|shiftIn|shiftOut|shutdown|sin|size|sqrt|startLoop|step|stop|stroke|subnetMask|switchPIN|tan|tempoWrite|text|tone|transfer|tuneWrite|turn|updateIR|userNameRead|userNameWrite|voiceCall|waitContinue|width|write|writeBlue|writeGreen|writeJSON|writeMessage|writeMicroseconds|writeRGB|writeRed|yield)\b/
+    }), e.languages.ino = e.languages.arduino;
+  }
+  return a;
+}
+var l = g();
+const S = /* @__PURE__ */ d(l), y = /* @__PURE__ */ u({
+  __proto__: null,
+  default: S
+}, [l]);
+export {
+  y as a
+};

package/dist/arff-CF3A9Ff-.js

@@ -0,0 +1,43 @@
+import { g as s } from "./index-Sj89RFCY.js";
+function c(r, a) {
+  for (var f = 0; f < a.length; f++) {
+    const e = a[f];
+    if (typeof e != "string" && !Array.isArray(e)) {
+      for (const t in e)
+        if (t !== "default" && !(t in r)) {
+          const n = Object.getOwnPropertyDescriptor(e, t);
+          n && Object.defineProperty(r, t, n.get ? n : {
+            enumerable: !0,
+            get: () => e[t]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(r, Symbol.toStringTag, { value: "Module" }));
+}
+var o, i;
+function d() {
+  if (i) return o;
+  i = 1, o = r, r.displayName = "arff", r.aliases = [];
+  function r(a) {
+    a.languages.arff = {
+      comment: /%.*/,
+      string: {
+        pattern: /(["'])(?:\\.|(?!\1)[^\\\r\n])*\1/,
+        greedy: !0
+      },
+      keyword: /@(?:attribute|data|end|relation)\b/i,
+      number: /\b\d+(?:\.\d+)?\b/,
+      punctuation: /[{},]/
+    };
+  }
+  return o;
+}
+var u = d();
+const g = /* @__PURE__ */ s(u), p = /* @__PURE__ */ c({
+  __proto__: null,
+  default: g
+}, [u]);
+export {
+  p as a
+};

package/dist/asciidoc-BORHAu3L.js

@@ -0,0 +1,240 @@
+import { g as b } from "./index-Sj89RFCY.js";
+function m(a, o) {
+  for (var r = 0; r < o.length; r++) {
+    const n = o[r];
+    if (typeof n != "string" && !Array.isArray(n)) {
+      for (const t in n)
+        if (t !== "default" && !(t in a)) {
+          const e = Object.getOwnPropertyDescriptor(n, t);
+          e && Object.defineProperty(a, t, e.get ? e : {
+            enumerable: !0,
+            get: () => n[t]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(a, Symbol.toStringTag, { value: "Module" }));
+}
+var l, u;
+function $() {
+  if (u) return l;
+  u = 1, l = a, a.displayName = "asciidoc", a.aliases = ["adoc"];
+  function a(o) {
+    (function(r) {
+      var n = {
+        pattern: /(^[ \t]*)\[(?!\[)(?:(["'$`])(?:(?!\2)[^\\]|\\.)*\2|\[(?:[^\[\]\\]|\\.)*\]|[^\[\]\\"'$`]|\\.)*\]/m,
+        lookbehind: !0,
+        inside: {
+          quoted: {
+            pattern: /([$`])(?:(?!\1)[^\\]|\\.)*\1/,
+            inside: {
+              punctuation: /^[$`]|[$`]$/
+            }
+          },
+          interpreted: {
+            pattern: /'(?:[^'\\]|\\.)*'/,
+            inside: {
+              punctuation: /^'|'$/
+              // See rest below
+            }
+          },
+          string: /"(?:[^"\\]|\\.)*"/,
+          variable: /\w+(?==)/,
+          punctuation: /^\[|\]$|,/,
+          operator: /=/,
+          // The negative look-ahead prevents blank matches
+          "attr-value": /(?!^\s+$).+/
+        }
+      }, t = r.languages.asciidoc = {
+        "comment-block": {
+          pattern: /^(\/{4,})(?:\r?\n|\r)(?:[\s\S]*(?:\r?\n|\r))??\1/m,
+          alias: "comment"
+        },
+        table: {
+          pattern: /^\|={3,}(?:(?:\r?\n|\r(?!\n)).*)*?(?:\r?\n|\r)\|={3,}$/m,
+          inside: {
+            specifiers: {
+              pattern: /(?:(?:(?:\d+(?:\.\d+)?|\.\d+)[+*](?:[<^>](?:\.[<^>])?|\.[<^>])?|[<^>](?:\.[<^>])?|\.[<^>])[a-z]*|[a-z]+)(?=\|)/,
+              alias: "attr-value"
+            },
+            punctuation: {
+              pattern: /(^|[^\\])[|!]=*/,
+              lookbehind: !0
+            }
+            // See rest below
+          }
+        },
+        "passthrough-block": {
+          pattern: /^(\+{4,})(?:\r?\n|\r)(?:[\s\S]*(?:\r?\n|\r))??\1$/m,
+          inside: {
+            punctuation: /^\++|\++$/
+            // See rest below
+          }
+        },
+        // Literal blocks and listing blocks
+        "literal-block": {
+          pattern: /^(-{4,}|\.{4,})(?:\r?\n|\r)(?:[\s\S]*(?:\r?\n|\r))??\1$/m,
+          inside: {
+            punctuation: /^(?:-+|\.+)|(?:-+|\.+)$/
+            // See rest below
+          }
+        },
+        // Sidebar blocks, quote blocks, example blocks and open blocks
+        "other-block": {
+          pattern: /^(--|\*{4,}|_{4,}|={4,})(?:\r?\n|\r)(?:[\s\S]*(?:\r?\n|\r))??\1$/m,
+          inside: {
+            punctuation: /^(?:-+|\*+|_+|=+)|(?:-+|\*+|_+|=+)$/
+            // See rest below
+          }
+        },
+        // list-punctuation and list-label must appear before indented-block
+        "list-punctuation": {
+          pattern: /(^[ \t]*)(?:-|\*{1,5}|\.{1,5}|(?:[a-z]|\d+)\.|[xvi]+\))(?= )/im,
+          lookbehind: !0,
+          alias: "punctuation"
+        },
+        "list-label": {
+          pattern: /(^[ \t]*)[a-z\d].+(?::{2,4}|;;)(?=\s)/im,
+          lookbehind: !0,
+          alias: "symbol"
+        },
+        "indented-block": {
+          pattern: /((\r?\n|\r)\2)([ \t]+)\S.*(?:(?:\r?\n|\r)\3.+)*(?=\2{2}|$)/,
+          lookbehind: !0
+        },
+        comment: /^\/\/.*/m,
+        title: {
+          pattern: /^.+(?:\r?\n|\r)(?:={3,}|-{3,}|~{3,}|\^{3,}|\+{3,})$|^={1,5} .+|^\.(?![\s.]).*/m,
+          alias: "important",
+          inside: {
+            punctuation: /^(?:\.|=+)|(?:=+|-+|~+|\^+|\++)$/
+            // See rest below
+          }
+        },
+        "attribute-entry": {
+          pattern: /^:[^:\r\n]+:(?: .*?(?: \+(?:\r?\n|\r).*?)*)?$/m,
+          alias: "tag"
+        },
+        attributes: n,
+        hr: {
+          pattern: /^'{3,}$/m,
+          alias: "punctuation"
+        },
+        "page-break": {
+          pattern: /^<{3,}$/m,
+          alias: "punctuation"
+        },
+        admonition: {
+          pattern: /^(?:CAUTION|IMPORTANT|NOTE|TIP|WARNING):/m,
+          alias: "keyword"
+        },
+        callout: [
+          {
+            pattern: /(^[ \t]*)<?\d*>/m,
+            lookbehind: !0,
+            alias: "symbol"
+          },
+          {
+            pattern: /<\d+>/,
+            alias: "symbol"
+          }
+        ],
+        macro: {
+          pattern: /\b[a-z\d][a-z\d-]*::?(?:[^\s\[\]]*\[(?:[^\]\\"']|(["'])(?:(?!\1)[^\\]|\\.)*\1|\\.)*\])/,
+          inside: {
+            function: /^[a-z\d-]+(?=:)/,
+            punctuation: /^::?/,
+            attributes: {
+              pattern: /(?:\[(?:[^\]\\"']|(["'])(?:(?!\1)[^\\]|\\.)*\1|\\.)*\])/,
+              inside: n.inside
+            }
+          }
+        },
+        inline: {
+          /*
+          The initial look-behind prevents the highlighting of escaped quoted text.
+          Quoted text can be multi-line but cannot span an empty line.
+          All quoted text can have attributes before [foobar, 'foobar', baz="bar"].
+          First, we handle the constrained quotes.
+          Those must be bounded by non-word chars and cannot have spaces between the delimiter and the first char.
+          They are, in order: _emphasis_, ``double quotes'', `single quotes', `monospace`, 'emphasis', *strong*, +monospace+ and #unquoted#
+          Then we handle the unconstrained quotes.
+          Those do not have the restrictions of the constrained quotes.
+          They are, in order: __emphasis__, **strong**, ++monospace++, +++passthrough+++, ##unquoted##, $$passthrough$$, ~subscript~, ^superscript^, {attribute-reference}, [[anchor]], [[[bibliography anchor]]], <<xref>>, (((indexes))) and ((indexes))
+          */
+          pattern: /(^|[^\\])(?:(?:\B\[(?:[^\]\\"']|(["'])(?:(?!\2)[^\\]|\\.)*\2|\\.)*\])?(?:\b_(?!\s)(?: _|[^_\\\r\n]|\\.)+(?:(?:\r?\n|\r)(?: _|[^_\\\r\n]|\\.)+)*_\b|\B``(?!\s).+?(?:(?:\r?\n|\r).+?)*''\B|\B`(?!\s)(?:[^`'\s]|\s+\S)+['`]\B|\B(['*+#])(?!\s)(?: \3|(?!\3)[^\\\r\n]|\\.)+(?:(?:\r?\n|\r)(?: \3|(?!\3)[^\\\r\n]|\\.)+)*\3\B)|(?:\[(?:[^\]\\"']|(["'])(?:(?!\4)[^\\]|\\.)*\4|\\.)*\])?(?:(__|\*\*|\+\+\+?|##|\$\$|[~^]).+?(?:(?:\r?\n|\r).+?)*\5|\{[^}\r\n]+\}|\[\[\[?.+?(?:(?:\r?\n|\r).+?)*\]?\]\]|<<.+?(?:(?:\r?\n|\r).+?)*>>|\(\(\(?.+?(?:(?:\r?\n|\r).+?)*\)?\)\)))/m,
+          lookbehind: !0,
+          inside: {
+            attributes: n,
+            url: {
+              pattern: /^(?:\[\[\[?.+?\]?\]\]|<<.+?>>)$/,
+              inside: {
+                punctuation: /^(?:\[\[\[?|<<)|(?:\]\]\]?|>>)$/
+              }
+            },
+            "attribute-ref": {
+              pattern: /^\{.+\}$/,
+              inside: {
+                variable: {
+                  pattern: /(^\{)[a-z\d,+_-]+/,
+                  lookbehind: !0
+                },
+                operator: /^[=?!#%@$]|!(?=[:}])/,
+                punctuation: /^\{|\}$|::?/
+              }
+            },
+            italic: {
+              pattern: /^(['_])[\s\S]+\1$/,
+              inside: {
+                punctuation: /^(?:''?|__?)|(?:''?|__?)$/
+              }
+            },
+            bold: {
+              pattern: /^\*[\s\S]+\*$/,
+              inside: {
+                punctuation: /^\*\*?|\*\*?$/
+              }
+            },
+            punctuation: /^(?:``?|\+{1,3}|##?|\$\$|[~^]|\(\(\(?)|(?:''?|\+{1,3}|##?|\$\$|[~^`]|\)?\)\))$/
+          }
+        },
+        replacement: {
+          pattern: /\((?:C|R|TM)\)/,
+          alias: "builtin"
+        },
+        entity: /&#?[\da-z]{1,8};/i,
+        "line-continuation": {
+          pattern: /(^| )\+$/m,
+          lookbehind: !0,
+          alias: "punctuation"
+        }
+      };
+      function e(i) {
+        i = i.split(" ");
+        for (var c = {}, s = 0, d = i.length; s < d; s++)
+          c[i[s]] = t[i[s]];
+        return c;
+      }
+      n.inside.interpreted.inside.rest = e(
+        "macro inline replacement entity"
+      ), t["passthrough-block"].inside.rest = e("macro"), t["literal-block"].inside.rest = e("callout"), t.table.inside.rest = e(
+        "comment-block passthrough-block literal-block other-block list-punctuation indented-block comment title attribute-entry attributes hr page-break admonition list-label callout macro inline replacement entity line-continuation"
+      ), t["other-block"].inside.rest = e(
+        "table list-punctuation indented-block comment attribute-entry attributes hr page-break admonition list-label macro inline replacement entity line-continuation"
+      ), t.title.inside.rest = e(
+        "macro inline replacement entity"
+      ), r.hooks.add("wrap", function(i) {
+        i.type === "entity" && (i.attributes.title = i.content.value.replace(/&amp;/, "&"));
+      }), r.languages.adoc = r.languages.asciidoc;
+    })(o);
+  }
+  return l;
+}
+var p = $();
+const f = /* @__PURE__ */ b(p), h = /* @__PURE__ */ m({
+  __proto__: null,
+  default: f
+}, [p]);
+export {
+  h as a
+};