@oscloudlab/knowledge-card 0.0.1 → 0.0.2

package/dist/livescript-DQvJc3cA.js

@@ -0,0 +1,150 @@
+import { g as p } from "./index-Sj89RFCY.js";
+function u(e, t) {
+  for (var i = 0; i < t.length; i++) {
+    const r = t[i];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const n in r)
+        if (n !== "default" && !(n in e)) {
+          const o = Object.getOwnPropertyDescriptor(r, n);
+          o && Object.defineProperty(e, n, o.get ? o : {
+            enumerable: !0,
+            get: () => r[n]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var a, l;
+function d() {
+  if (l) return a;
+  l = 1, a = e, e.displayName = "livescript", e.aliases = [];
+  function e(t) {
+    t.languages.livescript = {
+      comment: [
+        {
+          pattern: /(^|[^\\])\/\*[\s\S]*?\*\//,
+          lookbehind: !0
+        },
+        {
+          pattern: /(^|[^\\])#.*/,
+          lookbehind: !0
+        }
+      ],
+      "interpolated-string": {
+        /* Look-behind and look-ahead prevents wrong behavior of the greedy pattern
+         * forcing it to match """-quoted string when it would otherwise match "-quoted first. */
+        pattern: /(^|[^"])("""|")(?:\\[\s\S]|(?!\2)[^\\])*\2(?!")/,
+        lookbehind: !0,
+        greedy: !0,
+        inside: {
+          variable: {
+            pattern: /(^|[^\\])#[a-z_](?:-?[a-z]|[\d_])*/m,
+            lookbehind: !0
+          },
+          interpolation: {
+            pattern: /(^|[^\\])#\{[^}]+\}/m,
+            lookbehind: !0,
+            inside: {
+              "interpolation-punctuation": {
+                pattern: /^#\{|\}$/,
+                alias: "variable"
+              }
+              // See rest below
+            }
+          },
+          string: /[\s\S]+/
+        }
+      },
+      string: [
+        {
+          pattern: /('''|')(?:\\[\s\S]|(?!\1)[^\\])*\1/,
+          greedy: !0
+        },
+        {
+          pattern: /<\[[\s\S]*?\]>/,
+          greedy: !0
+        },
+        /\\[^\s,;\])}]+/
+      ],
+      regex: [
+        {
+          pattern: /\/\/(?:\[[^\r\n\]]*\]|\\.|(?!\/\/)[^\\\[])+\/\/[gimyu]{0,5}/,
+          greedy: !0,
+          inside: {
+            comment: {
+              pattern: /(^|[^\\])#.*/,
+              lookbehind: !0
+            }
+          }
+        },
+        {
+          pattern: /\/(?:\[[^\r\n\]]*\]|\\.|[^/\\\r\n\[])+\/[gimyu]{0,5}/,
+          greedy: !0
+        }
+      ],
+      keyword: {
+        pattern: /(^|(?!-).)\b(?:break|case|catch|class|const|continue|default|do|else|extends|fallthrough|finally|for(?: ever)?|function|if|implements|it|let|loop|new|null|otherwise|own|return|super|switch|that|then|this|throw|try|unless|until|var|void|when|while|yield)(?!-)\b/m,
+        lookbehind: !0
+      },
+      "keyword-operator": {
+        pattern: /(^|[^-])\b(?:(?:delete|require|typeof)!|(?:and|by|delete|export|from|import(?: all)?|in|instanceof|is(?: not|nt)?|not|of|or|til|to|typeof|with|xor)(?!-)\b)/m,
+        lookbehind: !0,
+        alias: "operator"
+      },
+      boolean: {
+        pattern: /(^|[^-])\b(?:false|no|off|on|true|yes)(?!-)\b/m,
+        lookbehind: !0
+      },
+      argument: {
+        // Don't match .&. nor &&
+        pattern: /(^|(?!\.&\.)[^&])&(?!&)\d*/m,
+        lookbehind: !0,
+        alias: "variable"
+      },
+      number: /\b(?:\d+~[\da-z]+|\d[\d_]*(?:\.\d[\d_]*)?(?:[a-z]\w*)?)/i,
+      identifier: /[a-z_](?:-?[a-z]|[\d_])*/i,
+      operator: [
+        // Spaced .
+        {
+          pattern: /( )\.(?= )/,
+          lookbehind: !0
+        },
+        // Full list, in order:
+        // .= .~ .. ...
+        // .&. .^. .<<. .>>. .>>>.
+        // := :: ::=
+        // &&
+        // || |>
+        // < << <<< <<<<
+        // <- <-- <-! <--!
+        // <~ <~~ <~! <~~!
+        // <| <= <?
+        // > >> >= >?
+        // - -- -> -->
+        // + ++
+        // @ @@
+        // % %%
+        // * **
+        // ! != !~=
+        // !~> !~~>
+        // !-> !-->
+        // ~ ~> ~~> ~=
+        // = ==
+        // ^ ^^
+        // / ?
+        /\.(?:[=~]|\.\.?)|\.(?:[&|^]|<<|>>>?)\.|:(?:=|:=?)|&&|\|[|>]|<(?:<<?<?|--?!?|~~?!?|[|=?])?|>[>=?]?|-(?:->?|>)?|\+\+?|@@?|%%?|\*\*?|!(?:~?=|--?>|~?~>)?|~(?:~?>|=)?|==?|\^\^?|[\/?]/
+      ],
+      punctuation: /[(){}\[\]|.,:;`]/
+    }, t.languages.livescript["interpolated-string"].inside.interpolation.inside.rest = t.languages.livescript;
+  }
+  return a;
+}
+var s = d();
+const c = /* @__PURE__ */ p(s), b = /* @__PURE__ */ u({
+  __proto__: null,
+  default: c
+}, [s]);
+export {
+  b as l
+};

package/dist/llvm-B7k0U20m.js

@@ -0,0 +1,52 @@
+import { g as i } from "./index-Sj89RFCY.js";
+function d(e, l) {
+  for (var t = 0; t < l.length; t++) {
+    const a = l[t];
+    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 n, f;
+function s() {
+  if (f) return n;
+  f = 1, n = e, e.displayName = "llvm", e.aliases = [];
+  function e(l) {
+    (function(t) {
+      t.languages.llvm = {
+        comment: /;.*/,
+        string: {
+          pattern: /"[^"]*"/,
+          greedy: !0
+        },
+        boolean: /\b(?:false|true)\b/,
+        variable: /[%@!#](?:(?!\d)(?:[-$.\w]|\\[a-f\d]{2})+|\d+)/i,
+        label: /(?!\d)(?:[-$.\w]|\\[a-f\d]{2})+:/i,
+        type: {
+          pattern: /\b(?:double|float|fp128|half|i[1-9]\d*|label|metadata|ppc_fp128|token|void|x86_fp80|x86_mmx)\b/,
+          alias: "class-name"
+        },
+        keyword: /\b[a-z_][a-z_0-9]*\b/,
+        number: /[+-]?\b\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b|\b0x[\dA-Fa-f]+\b|\b0xK[\dA-Fa-f]{20}\b|\b0x[ML][\dA-Fa-f]{32}\b|\b0xH[\dA-Fa-f]{4}\b/,
+        punctuation: /[{}[\];(),.!*=<>]/
+      };
+    })(l);
+  }
+  return n;
+}
+var b = s();
+const u = /* @__PURE__ */ i(b), p = /* @__PURE__ */ d({
+  __proto__: null,
+  default: u
+}, [b]);
+export {
+  p as l
+};

package/dist/log-B7ulCZCI.js

@@ -0,0 +1,133 @@
+import { g as l } from "./index-Sj89RFCY.js";
+function u(a, e) {
+  for (var n = 0; n < e.length; n++) {
+    const t = e[n];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const r in t)
+        if (r !== "default" && !(r in a)) {
+          const o = Object.getOwnPropertyDescriptor(t, r);
+          o && Object.defineProperty(a, r, o.get ? o : {
+            enumerable: !0,
+            get: () => t[r]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(a, Symbol.toStringTag, { value: "Module" }));
+}
+var s, i;
+function d() {
+  if (i) return s;
+  i = 1, s = a, a.displayName = "log", a.aliases = [];
+  function a(e) {
+    e.languages.log = {
+      string: {
+        // Single-quoted strings must not be confused with plain text. E.g. Can't isn't Susan's Chris' toy
+        pattern: /"(?:[^"\\\r\n]|\\.)*"|'(?![st] | \w)(?:[^'\\\r\n]|\\.)*'/,
+        greedy: !0
+      },
+      exception: {
+        pattern: /(^|[^\w.])[a-z][\w.]*(?:Error|Exception):.*(?:(?:\r\n?|\n)[ \t]*(?:at[ \t].+|\.{3}.*|Caused by:.*))+(?:(?:\r\n?|\n)[ \t]*\.\.\. .*)?/,
+        lookbehind: !0,
+        greedy: !0,
+        alias: ["javastacktrace", "language-javastacktrace"],
+        inside: e.languages.javastacktrace || {
+          keyword: /\bat\b/,
+          function: /[a-z_][\w$]*(?=\()/,
+          punctuation: /[.:()]/
+        }
+      },
+      level: [
+        {
+          pattern: /\b(?:ALERT|CRIT|CRITICAL|EMERG|EMERGENCY|ERR|ERROR|FAILURE|FATAL|SEVERE)\b/,
+          alias: ["error", "important"]
+        },
+        {
+          pattern: /\b(?:WARN|WARNING|WRN)\b/,
+          alias: ["warning", "important"]
+        },
+        {
+          pattern: /\b(?:DISPLAY|INF|INFO|NOTICE|STATUS)\b/,
+          alias: ["info", "keyword"]
+        },
+        {
+          pattern: /\b(?:DBG|DEBUG|FINE)\b/,
+          alias: ["debug", "keyword"]
+        },
+        {
+          pattern: /\b(?:FINER|FINEST|TRACE|TRC|VERBOSE|VRB)\b/,
+          alias: ["trace", "comment"]
+        }
+      ],
+      property: {
+        pattern: /((?:^|[\]|])[ \t]*)[a-z_](?:[\w-]|\b\/\b)*(?:[. ]\(?\w(?:[\w-]|\b\/\b)*\)?)*:(?=\s)/im,
+        lookbehind: !0
+      },
+      separator: {
+        pattern: /(^|[^-+])-{3,}|={3,}|\*{3,}|- - /m,
+        lookbehind: !0,
+        alias: "comment"
+      },
+      url: /\b(?:file|ftp|https?):\/\/[^\s|,;'"]*[^\s|,;'">.]/,
+      email: {
+        pattern: /(^|\s)[-\w+.]+@[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)+(?=\s)/,
+        lookbehind: !0,
+        alias: "url"
+      },
+      "ip-address": {
+        pattern: /\b(?:\d{1,3}(?:\.\d{1,3}){3})\b/,
+        alias: "constant"
+      },
+      "mac-address": {
+        pattern: /\b[a-f0-9]{2}(?::[a-f0-9]{2}){5}\b/i,
+        alias: "constant"
+      },
+      domain: {
+        pattern: /(^|\s)[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)*\.[a-z][a-z0-9-]+(?=\s)/,
+        lookbehind: !0,
+        alias: "constant"
+      },
+      uuid: {
+        pattern: /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/i,
+        alias: "constant"
+      },
+      hash: {
+        pattern: /\b(?:[a-f0-9]{32}){1,2}\b/i,
+        alias: "constant"
+      },
+      "file-path": {
+        pattern: /\b[a-z]:[\\/][^\s|,;:(){}\[\]"']+|(^|[\s:\[\](>|])\.{0,2}\/\w[^\s|,;:(){}\[\]"']*/i,
+        lookbehind: !0,
+        greedy: !0,
+        alias: "string"
+      },
+      date: {
+        pattern: RegExp(
+          /\b\d{4}[-/]\d{2}[-/]\d{2}(?:T(?=\d{1,2}:)|(?=\s\d{1,2}:))/.source + "|" + /\b\d{1,4}[-/ ](?:\d{1,2}|Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep)[-/ ]\d{2,4}T?\b/.source + "|" + /\b(?:(?:Fri|Mon|Sat|Sun|Thu|Tue|Wed)(?:\s{1,2}(?:Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep))?|Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep)\s{1,2}\d{1,2}\b/.source,
+          "i"
+        ),
+        alias: "number"
+      },
+      time: {
+        pattern: /\b\d{1,2}:\d{1,2}:\d{1,2}(?:[.,:]\d+)?(?:\s?[+-]\d{2}:?\d{2}|Z)?\b/,
+        alias: "number"
+      },
+      boolean: /\b(?:false|null|true)\b/i,
+      number: {
+        pattern: /(^|[^.\w])(?:0x[a-f0-9]+|0o[0-7]+|0b[01]+|v?\d[\da-f]*(?:\.\d+)*(?:e[+-]?\d+)?[a-z]{0,3}\b)\b(?!\.\w)/i,
+        lookbehind: !0
+      },
+      operator: /[;:?<=>~/@!$%&+\-|^(){}*#]/,
+      punctuation: /[\[\].,]/
+    };
+  }
+  return s;
+}
+var b = d();
+const p = /* @__PURE__ */ l(b), g = /* @__PURE__ */ u({
+  __proto__: null,
+  default: p
+}, [b]);
+export {
+  g as l
+};

package/dist/lolcode-BEEMlfuU.js

@@ -0,0 +1,81 @@
+import { g as i } from "./index-Sj89RFCY.js";
+function O(e, r) {
+  for (var n = 0; n < r.length; n++) {
+    const o = r[n];
+    if (typeof o != "string" && !Array.isArray(o)) {
+      for (const t in o)
+        if (t !== "default" && !(t in e)) {
+          const l = Object.getOwnPropertyDescriptor(o, t);
+          l && Object.defineProperty(e, t, l.get ? l : {
+            enumerable: !0,
+            get: () => o[t]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var a, s;
+function d() {
+  if (s) return a;
+  s = 1, a = e, e.displayName = "lolcode", e.aliases = [];
+  function e(r) {
+    r.languages.lolcode = {
+      comment: [/\bOBTW\s[\s\S]*?\sTLDR\b/, /\bBTW.+/],
+      string: {
+        pattern: /"(?::.|[^":])*"/,
+        inside: {
+          variable: /:\{[^}]+\}/,
+          symbol: [/:\([a-f\d]+\)/i, /:\[[^\]]+\]/, /:[)>o":]/]
+        },
+        greedy: !0
+      },
+      number: /(?:\B-)?(?:\b\d+(?:\.\d*)?|\B\.\d+)/,
+      symbol: {
+        pattern: /(^|\s)(?:A )?(?:BUKKIT|NOOB|NUMBAR|NUMBR|TROOF|YARN)(?=\s|,|$)/,
+        lookbehind: !0,
+        inside: {
+          keyword: /A(?=\s)/
+        }
+      },
+      label: {
+        pattern: /((?:^|\s)(?:IM IN YR|IM OUTTA YR) )[a-zA-Z]\w*/,
+        lookbehind: !0,
+        alias: "string"
+      },
+      function: {
+        pattern: /((?:^|\s)(?:HOW IZ I|I IZ|IZ) )[a-zA-Z]\w*/,
+        lookbehind: !0
+      },
+      keyword: [
+        {
+          pattern: /(^|\s)(?:AN|FOUND YR|GIMMEH|GTFO|HAI|HAS A|HOW IZ I|I HAS A|I IZ|IF U SAY SO|IM IN YR|IM OUTTA YR|IS NOW(?: A)?|ITZ(?: A)?|IZ|KTHX|KTHXBYE|LIEK(?: A)?|MAEK|MEBBE|MKAY|NERFIN|NO WAI|O HAI IM|O RLY\?|OIC|OMG|OMGWTF|R|SMOOSH|SRS|TIL|UPPIN|VISIBLE|WILE|WTF\?|YA RLY|YR)(?=\s|,|$)/,
+          lookbehind: !0
+        },
+        /'Z(?=\s|,|$)/
+      ],
+      boolean: {
+        pattern: /(^|\s)(?:FAIL|WIN)(?=\s|,|$)/,
+        lookbehind: !0
+      },
+      variable: {
+        pattern: /(^|\s)IT(?=\s|,|$)/,
+        lookbehind: !0
+      },
+      operator: {
+        pattern: /(^|\s)(?:NOT|BOTH SAEM|DIFFRINT|(?:ALL|ANY|BIGGR|BOTH|DIFF|EITHER|MOD|PRODUKT|QUOSHUNT|SMALLR|SUM|WON) OF)(?=\s|,|$)/,
+        lookbehind: !0
+      },
+      punctuation: /\.{3}|…|,|!/
+    };
+  }
+  return a;
+}
+var I = d();
+const A = /* @__PURE__ */ i(I), c = /* @__PURE__ */ O({
+  __proto__: null,
+  default: A
+}, [I]);
+export {
+  c as l
+};

package/dist/lua-BggcDXQp.js

@@ -0,0 +1,31 @@
+var r, n;
+function t() {
+  if (n) return r;
+  n = 1, r = e, e.displayName = "lua", e.aliases = [];
+  function e(a) {
+    a.languages.lua = {
+      comment: /^#!.+|--(?:\[(=*)\[[\s\S]*?\]\1\]|.*)/m,
+      // \z may be used to skip the following space
+      string: {
+        pattern: /(["'])(?:(?!\1)[^\\\r\n]|\\z(?:\r\n|\s)|\\(?:\r\n|[^z]))*\1|\[(=*)\[[\s\S]*?\]\2\]/,
+        greedy: !0
+      },
+      number: /\b0x[a-f\d]+(?:\.[a-f\d]*)?(?:p[+-]?\d+)?\b|\b\d+(?:\.\B|(?:\.\d*)?(?:e[+-]?\d+)?\b)|\B\.\d+(?:e[+-]?\d+)?\b/i,
+      keyword: /\b(?:and|break|do|else|elseif|end|false|for|function|goto|if|in|local|nil|not|or|repeat|return|then|true|until|while)\b/,
+      function: /(?!\d)\w+(?=\s*(?:[({]))/,
+      operator: [
+        /[-+*%^&|#]|\/\/?|<[<=]?|>[>=]?|[=~]=?/,
+        {
+          // Match ".." but don't break "..."
+          pattern: /(^|[^.])\.\.(?!\.)/,
+          lookbehind: !0
+        }
+      ],
+      punctuation: /[\[\](){},;]|\.+|:+/
+    };
+  }
+  return r;
+}
+export {
+  t as r
+};

package/dist/lua-D-T62TZ5.js

@@ -0,0 +1,26 @@
+import { g as s } from "./index-Sj89RFCY.js";
+import { r as u } from "./lua-BggcDXQp.js";
+function l(t, n) {
+  for (var o = 0; o < n.length; o++) {
+    const e = n[o];
+    if (typeof e != "string" && !Array.isArray(e)) {
+      for (const r in e)
+        if (r !== "default" && !(r in t)) {
+          const a = Object.getOwnPropertyDescriptor(e, r);
+          a && Object.defineProperty(t, r, a.get ? a : {
+            enumerable: !0,
+            get: () => e[r]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
+}
+var f = u();
+const i = /* @__PURE__ */ s(f), g = /* @__PURE__ */ l({
+  __proto__: null,
+  default: i
+}, [f]);
+export {
+  g as l
+};

package/dist/magma-DAN3ZGAI.js

@@ -0,0 +1,63 @@
+import { g as d } from "./index-Sj89RFCY.js";
+function l(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, s;
+function m() {
+  if (s) return i;
+  s = 1, i = e, e.displayName = "magma", e.aliases = [];
+  function e(a) {
+    a.languages.magma = {
+      output: {
+        pattern: /^(>.*(?:\r(?:\n|(?!\n))|\n))(?!>)(?:.+|(?:\r(?:\n|(?!\n))|\n)(?!>).*)(?:(?:\r(?:\n|(?!\n))|\n)(?!>).*)*/m,
+        lookbehind: !0,
+        greedy: !0
+      },
+      comment: {
+        pattern: /\/\/.*|\/\*[\s\S]*?\*\//,
+        greedy: !0
+      },
+      string: {
+        pattern: /(^|[^\\"])"(?:[^\r\n\\"]|\\.)*"/,
+        lookbehind: !0,
+        greedy: !0
+      },
+      // http://magma.maths.usyd.edu.au/magma/handbook/text/82
+      keyword: /\b(?:_|adj|and|assert|assert2|assert3|assigned|break|by|case|cat|catch|clear|cmpeq|cmpne|continue|declare|default|delete|diff|div|do|elif|else|end|eq|error|eval|exists|exit|for|forall|forward|fprintf|freeze|function|ge|gt|if|iload|import|in|intrinsic|is|join|le|load|local|lt|meet|mod|ne|not|notadj|notin|notsubset|or|print|printf|procedure|quit|random|read|readi|repeat|require|requirege|requirerange|restore|return|save|sdiff|select|subset|then|time|to|try|until|vprint|vprintf|vtime|when|where|while|xor)\b/,
+      boolean: /\b(?:false|true)\b/,
+      generator: {
+        pattern: /\b[a-z_]\w*(?=\s*<)/i,
+        alias: "class-name"
+      },
+      function: /\b[a-z_]\w*(?=\s*\()/i,
+      number: {
+        pattern: /(^|[^\w.]|\.\.)(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?(?:_[a-z]?)?(?=$|[^\w.]|\.\.)/,
+        lookbehind: !0
+      },
+      operator: /->|[-+*/^~!|#=]|:=|\.\./,
+      punctuation: /[()[\]{}<>,;.:]/
+    };
+  }
+  return i;
+}
+var u = m();
+const f = /* @__PURE__ */ d(u), g = /* @__PURE__ */ l({
+  __proto__: null,
+  default: f
+}, [u]);
+export {
+  g as m
+};

package/dist/makefile-Bjl-N6S3.js

@@ -0,0 +1,63 @@
+import { g as f } 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 n = Object.getOwnPropertyDescriptor(r, t);
+          n && Object.defineProperty(e, t, n.get ? n : {
+            enumerable: !0,
+            get: () => r[t]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var o, s;
+function d() {
+  if (s) return o;
+  s = 1, o = e, e.displayName = "makefile", e.aliases = [];
+  function e(i) {
+    i.languages.makefile = {
+      comment: {
+        pattern: /(^|[^\\])#(?:\\(?:\r\n|[\s\S])|[^\\\r\n])*/,
+        lookbehind: !0
+      },
+      string: {
+        pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+        greedy: !0
+      },
+      "builtin-target": {
+        pattern: /\.[A-Z][^:#=\s]+(?=\s*:(?!=))/,
+        alias: "builtin"
+      },
+      target: {
+        pattern: /^(?:[^:=\s]|[ \t]+(?![\s:]))+(?=\s*:(?!=))/m,
+        alias: "symbol",
+        inside: {
+          variable: /\$+(?:(?!\$)[^(){}:#=\s]+|(?=[({]))/
+        }
+      },
+      variable: /\$+(?:(?!\$)[^(){}:#=\s]+|\([@*%<^+?][DF]\)|(?=[({]))/,
+      // Directives
+      keyword: /-include\b|\b(?:define|else|endef|endif|export|ifn?def|ifn?eq|include|override|private|sinclude|undefine|unexport|vpath)\b/,
+      function: {
+        pattern: /(\()(?:abspath|addsuffix|and|basename|call|dir|error|eval|file|filter(?:-out)?|findstring|firstword|flavor|foreach|guile|if|info|join|lastword|load|notdir|or|origin|patsubst|realpath|shell|sort|strip|subst|suffix|value|warning|wildcard|word(?:list|s)?)(?=[ \t])/,
+        lookbehind: !0
+      },
+      operator: /(?:::|[?:+!])?=|[|@]/,
+      punctuation: /[:;(){}]/
+    };
+  }
+  return o;
+}
+var l = d();
+const p = /* @__PURE__ */ f(l), b = /* @__PURE__ */ u({
+  __proto__: null,
+  default: p
+}, [l]);
+export {
+  b as m
+};