@oscloudlab/knowledge-card 0.0.1 → 0.0.3

package/dist/lolcode-DsVapdHo.js

@@ -0,0 +1,90 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var lolcode_1;
+var hasRequiredLolcode;
+function requireLolcode() {
+  if (hasRequiredLolcode) return lolcode_1;
+  hasRequiredLolcode = 1;
+  lolcode_1 = lolcode2;
+  lolcode2.displayName = "lolcode";
+  lolcode2.aliases = [];
+  function lolcode2(Prism) {
+    Prism.languages.lolcode = {
+      comment: [/\bOBTW\s[\s\S]*?\sTLDR\b/, /\bBTW.+/],
+      string: {
+        pattern: /"(?::.|[^":])*"/,
+        inside: {
+          variable: /:\{[^}]+\}/,
+          symbol: [/:\([a-f\d]+\)/i, /:\[[^\]]+\]/, /:[)>o":]/]
+        },
+        greedy: true
+      },
+      number: /(?:\B-)?(?:\b\d+(?:\.\d*)?|\B\.\d+)/,
+      symbol: {
+        pattern: /(^|\s)(?:A )?(?:BUKKIT|NOOB|NUMBAR|NUMBR|TROOF|YARN)(?=\s|,|$)/,
+        lookbehind: true,
+        inside: {
+          keyword: /A(?=\s)/
+        }
+      },
+      label: {
+        pattern: /((?:^|\s)(?:IM IN YR|IM OUTTA YR) )[a-zA-Z]\w*/,
+        lookbehind: true,
+        alias: "string"
+      },
+      function: {
+        pattern: /((?:^|\s)(?:HOW IZ I|I IZ|IZ) )[a-zA-Z]\w*/,
+        lookbehind: true
+      },
+      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: true
+        },
+        /'Z(?=\s|,|$)/
+      ],
+      boolean: {
+        pattern: /(^|\s)(?:FAIL|WIN)(?=\s|,|$)/,
+        lookbehind: true
+      },
+      variable: {
+        pattern: /(^|\s)IT(?=\s|,|$)/,
+        lookbehind: true
+      },
+      operator: {
+        pattern: /(^|\s)(?:NOT|BOTH SAEM|DIFFRINT|(?:ALL|ANY|BIGGR|BOTH|DIFF|EITHER|MOD|PRODUKT|QUOSHUNT|SMALLR|SUM|WON) OF)(?=\s|,|$)/,
+        lookbehind: true
+      },
+      punctuation: /\.{3}|…|,|!/
+    };
+  }
+  return lolcode_1;
+}
+var lolcodeExports = requireLolcode();
+const lolcode = /* @__PURE__ */ getDefaultExportFromCjs(lolcodeExports);
+const lolcode$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: lolcode
+}, [lolcodeExports]);
+export {
+  lolcode$1 as l
+};
+//# sourceMappingURL=lolcode-DsVapdHo.js.map

package/dist/lolcode-DsVapdHo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lolcode-DsVapdHo.js","sources":["../node_modules/refractor/lang/lolcode.js"],"sourcesContent":["'use strict'\n\nmodule.exports = lolcode\nlolcode.displayName = 'lolcode'\nlolcode.aliases = []\nfunction lolcode(Prism) {\n  Prism.languages.lolcode = {\n    comment: [/\\bOBTW\\s[\\s\\S]*?\\sTLDR\\b/, /\\bBTW.+/],\n    string: {\n      pattern: /\"(?::.|[^\":])*\"/,\n      inside: {\n        variable: /:\\{[^}]+\\}/,\n        symbol: [/:\\([a-f\\d]+\\)/i, /:\\[[^\\]]+\\]/, /:[)>o\":]/]\n      },\n      greedy: true\n    },\n    number: /(?:\\B-)?(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)/,\n    symbol: {\n      pattern: /(^|\\s)(?:A )?(?:BUKKIT|NOOB|NUMBAR|NUMBR|TROOF|YARN)(?=\\s|,|$)/,\n      lookbehind: true,\n      inside: {\n        keyword: /A(?=\\s)/\n      }\n    },\n    label: {\n      pattern: /((?:^|\\s)(?:IM IN YR|IM OUTTA YR) )[a-zA-Z]\\w*/,\n      lookbehind: true,\n      alias: 'string'\n    },\n    function: {\n      pattern: /((?:^|\\s)(?:HOW IZ I|I IZ|IZ) )[a-zA-Z]\\w*/,\n      lookbehind: true\n    },\n    keyword: [\n      {\n        pattern:\n          /(^|\\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|,|$)/,\n        lookbehind: true\n      },\n      /'Z(?=\\s|,|$)/\n    ],\n    boolean: {\n      pattern: /(^|\\s)(?:FAIL|WIN)(?=\\s|,|$)/,\n      lookbehind: true\n    },\n    variable: {\n      pattern: /(^|\\s)IT(?=\\s|,|$)/,\n      lookbehind: true\n    },\n    operator: {\n      pattern:\n        /(^|\\s)(?:NOT|BOTH SAEM|DIFFRINT|(?:ALL|ANY|BIGGR|BOTH|DIFF|EITHER|MOD|PRODUKT|QUOSHUNT|SMALLR|SUM|WON) OF)(?=\\s|,|$)/,\n      lookbehind: true\n    },\n    punctuation: /\\.{3}|…|,|!/\n  }\n}\n"],"names":["lolcode"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,cAAiBA;AACjB,EAAAA,SAAQ,cAAc;AACtB,EAAAA,SAAQ,UAAU,CAAA;AAClB,WAASA,SAAQ,OAAO;AACtB,UAAM,UAAU,UAAU;AAAA,MACxB,SAAS,CAAC,4BAA4B,SAAS;AAAA,MAC/C,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA,UACN,UAAU;AAAA,UACV,QAAQ,CAAC,kBAAkB,eAAe,UAAU;AAAA;QAEtD,QAAQ;AAAA;MAEV,QAAQ;AAAA,MACR,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,QAAQ;AAAA,UACN,SAAS;AAAA;;MAGb,OAAO;AAAA,QACL,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,OAAO;AAAA;MAET,UAAU;AAAA,QACR,SAAS;AAAA,QACT,YAAY;AAAA;MAEd,SAAS;AAAA,QACP;AAAA,UACE,SACE;AAAA,UACF,YAAY;AAAA;QAEd;AAAA;MAEF,SAAS;AAAA,QACP,SAAS;AAAA,QACT,YAAY;AAAA;MAEd,UAAU;AAAA,QACR,SAAS;AAAA,QACT,YAAY;AAAA;MAEd,UAAU;AAAA,QACR,SACE;AAAA,QACF,YAAY;AAAA;MAEd,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/lua-J1sbiTxE.js

@@ -0,0 +1,31 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+import { r as requireLua } from "./lua-RL-GTNsS.js";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var luaExports = requireLua();
+const lua = /* @__PURE__ */ getDefaultExportFromCjs(luaExports);
+const lua$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: lua
+}, [luaExports]);
+export {
+  lua$1 as l
+};
+//# sourceMappingURL=lua-J1sbiTxE.js.map

package/dist/lua-J1sbiTxE.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lua-J1sbiTxE.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/lua-RL-GTNsS.js

@@ -0,0 +1,36 @@
+var lua_1;
+var hasRequiredLua;
+function requireLua() {
+  if (hasRequiredLua) return lua_1;
+  hasRequiredLua = 1;
+  lua_1 = lua;
+  lua.displayName = "lua";
+  lua.aliases = [];
+  function lua(Prism) {
+    Prism.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: true
+      },
+      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: true
+        }
+      ],
+      punctuation: /[\[\](){},;]|\.+|:+/
+    };
+  }
+  return lua_1;
+}
+export {
+  requireLua as r
+};
+//# sourceMappingURL=lua-RL-GTNsS.js.map

package/dist/lua-RL-GTNsS.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lua-RL-GTNsS.js","sources":["../node_modules/refractor/lang/lua.js"],"sourcesContent":["'use strict'\n\nmodule.exports = lua\nlua.displayName = 'lua'\nlua.aliases = []\nfunction lua(Prism) {\n  Prism.languages.lua = {\n    comment: /^#!.+|--(?:\\[(=*)\\[[\\s\\S]*?\\]\\1\\]|.*)/m,\n    // \\z may be used to skip the following space\n    string: {\n      pattern:\n        /([\"'])(?:(?!\\1)[^\\\\\\r\\n]|\\\\z(?:\\r\\n|\\s)|\\\\(?:\\r\\n|[^z]))*\\1|\\[(=*)\\[[\\s\\S]*?\\]\\2\\]/,\n      greedy: true\n    },\n    number:\n      /\\b0x[a-f\\d]+(?:\\.[a-f\\d]*)?(?:p[+-]?\\d+)?\\b|\\b\\d+(?:\\.\\B|(?:\\.\\d*)?(?:e[+-]?\\d+)?\\b)|\\B\\.\\d+(?:e[+-]?\\d+)?\\b/i,\n    keyword:\n      /\\b(?:and|break|do|else|elseif|end|false|for|function|goto|if|in|local|nil|not|or|repeat|return|then|true|until|while)\\b/,\n    function: /(?!\\d)\\w+(?=\\s*(?:[({]))/,\n    operator: [\n      /[-+*%^&|#]|\\/\\/?|<[<=]?|>[>=]?|[=~]=?/,\n      {\n        // Match \"..\" but don't break \"...\"\n        pattern: /(^|[^.])\\.\\.(?!\\.)/,\n        lookbehind: true\n      }\n    ],\n    punctuation: /[\\[\\](){},;]|\\.+|:+/\n  }\n}\n"],"names":[],"mappings":";;;;;AAEA,UAAiB;AACjB,MAAI,cAAc;AAClB,MAAI,UAAU,CAAA;AACd,WAAS,IAAI,OAAO;AAClB,UAAM,UAAU,MAAM;AAAA,MACpB,SAAS;AAAA;AAAA,MAET,QAAQ;AAAA,QACN,SACE;AAAA,QACF,QAAQ;AAAA;MAEV,QACE;AAAA,MACF,SACE;AAAA,MACF,UAAU;AAAA,MACV,UAAU;AAAA,QACR;AAAA,QACA;AAAA;AAAA,UAEE,SAAS;AAAA,UACT,YAAY;AAAA;;MAGhB,aAAa;AAAA;EAEjB;;;","x_google_ignoreList":[0]}

package/dist/magma-DHxwMnrh.js

@@ -0,0 +1,72 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var magma_1;
+var hasRequiredMagma;
+function requireMagma() {
+  if (hasRequiredMagma) return magma_1;
+  hasRequiredMagma = 1;
+  magma_1 = magma2;
+  magma2.displayName = "magma";
+  magma2.aliases = [];
+  function magma2(Prism) {
+    Prism.languages.magma = {
+      output: {
+        pattern: /^(>.*(?:\r(?:\n|(?!\n))|\n))(?!>)(?:.+|(?:\r(?:\n|(?!\n))|\n)(?!>).*)(?:(?:\r(?:\n|(?!\n))|\n)(?!>).*)*/m,
+        lookbehind: true,
+        greedy: true
+      },
+      comment: {
+        pattern: /\/\/.*|\/\*[\s\S]*?\*\//,
+        greedy: true
+      },
+      string: {
+        pattern: /(^|[^\\"])"(?:[^\r\n\\"]|\\.)*"/,
+        lookbehind: true,
+        greedy: true
+      },
+      // 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: true
+      },
+      operator: /->|[-+*/^~!|#=]|:=|\.\./,
+      punctuation: /[()[\]{}<>,;.:]/
+    };
+  }
+  return magma_1;
+}
+var magmaExports = requireMagma();
+const magma = /* @__PURE__ */ getDefaultExportFromCjs(magmaExports);
+const magma$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: magma
+}, [magmaExports]);
+export {
+  magma$1 as m
+};
+//# sourceMappingURL=magma-DHxwMnrh.js.map

package/dist/magma-DHxwMnrh.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"magma-DHxwMnrh.js","sources":["../node_modules/refractor/lang/magma.js"],"sourcesContent":["'use strict'\n\nmodule.exports = magma\nmagma.displayName = 'magma'\nmagma.aliases = []\nfunction magma(Prism) {\n  Prism.languages.magma = {\n    output: {\n      pattern:\n        /^(>.*(?:\\r(?:\\n|(?!\\n))|\\n))(?!>)(?:.+|(?:\\r(?:\\n|(?!\\n))|\\n)(?!>).*)(?:(?:\\r(?:\\n|(?!\\n))|\\n)(?!>).*)*/m,\n      lookbehind: true,\n      greedy: true\n    },\n    comment: {\n      pattern: /\\/\\/.*|\\/\\*[\\s\\S]*?\\*\\//,\n      greedy: true\n    },\n    string: {\n      pattern: /(^|[^\\\\\"])\"(?:[^\\r\\n\\\\\"]|\\\\.)*\"/,\n      lookbehind: true,\n      greedy: true\n    },\n    // http://magma.maths.usyd.edu.au/magma/handbook/text/82\n    keyword:\n      /\\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/,\n    boolean: /\\b(?:false|true)\\b/,\n    generator: {\n      pattern: /\\b[a-z_]\\w*(?=\\s*<)/i,\n      alias: 'class-name'\n    },\n    function: /\\b[a-z_]\\w*(?=\\s*\\()/i,\n    number: {\n      pattern:\n        /(^|[^\\w.]|\\.\\.)(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:[eE][+-]?\\d+)?(?:_[a-z]?)?(?=$|[^\\w.]|\\.\\.)/,\n      lookbehind: true\n    },\n    operator: /->|[-+*/^~!|#=]|:=|\\.\\./,\n    punctuation: /[()[\\]{}<>,;.:]/\n  }\n}\n"],"names":["magma"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,YAAiBA;AACjB,EAAAA,OAAM,cAAc;AACpB,EAAAA,OAAM,UAAU,CAAA;AAChB,WAASA,OAAM,OAAO;AACpB,UAAM,UAAU,QAAQ;AAAA,MACtB,QAAQ;AAAA,QACN,SACE;AAAA,QACF,YAAY;AAAA,QACZ,QAAQ;AAAA;MAEV,SAAS;AAAA,QACP,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,QAAQ;AAAA;;MAGV,SACE;AAAA,MACF,SAAS;AAAA,MACT,WAAW;AAAA,QACT,SAAS;AAAA,QACT,OAAO;AAAA;MAET,UAAU;AAAA,MACV,QAAQ;AAAA,QACN,SACE;AAAA,QACF,YAAY;AAAA;MAEd,UAAU;AAAA,MACV,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/makefile-D9bOM9tF.js

@@ -0,0 +1,72 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var makefile_1;
+var hasRequiredMakefile;
+function requireMakefile() {
+  if (hasRequiredMakefile) return makefile_1;
+  hasRequiredMakefile = 1;
+  makefile_1 = makefile2;
+  makefile2.displayName = "makefile";
+  makefile2.aliases = [];
+  function makefile2(Prism) {
+    Prism.languages.makefile = {
+      comment: {
+        pattern: /(^|[^\\])#(?:\\(?:\r\n|[\s\S])|[^\\\r\n])*/,
+        lookbehind: true
+      },
+      string: {
+        pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+        greedy: true
+      },
+      "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: true
+      },
+      operator: /(?:::|[?:+!])?=|[|@]/,
+      punctuation: /[:;(){}]/
+    };
+  }
+  return makefile_1;
+}
+var makefileExports = requireMakefile();
+const makefile = /* @__PURE__ */ getDefaultExportFromCjs(makefileExports);
+const makefile$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: makefile
+}, [makefileExports]);
+export {
+  makefile$1 as m
+};
+//# sourceMappingURL=makefile-D9bOM9tF.js.map

package/dist/makefile-D9bOM9tF.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"makefile-D9bOM9tF.js","sources":["../node_modules/refractor/lang/makefile.js"],"sourcesContent":["'use strict'\n\nmodule.exports = makefile\nmakefile.displayName = 'makefile'\nmakefile.aliases = []\nfunction makefile(Prism) {\n  Prism.languages.makefile = {\n    comment: {\n      pattern: /(^|[^\\\\])#(?:\\\\(?:\\r\\n|[\\s\\S])|[^\\\\\\r\\n])*/,\n      lookbehind: true\n    },\n    string: {\n      pattern: /([\"'])(?:\\\\(?:\\r\\n|[\\s\\S])|(?!\\1)[^\\\\\\r\\n])*\\1/,\n      greedy: true\n    },\n    'builtin-target': {\n      pattern: /\\.[A-Z][^:#=\\s]+(?=\\s*:(?!=))/,\n      alias: 'builtin'\n    },\n    target: {\n      pattern: /^(?:[^:=\\s]|[ \\t]+(?![\\s:]))+(?=\\s*:(?!=))/m,\n      alias: 'symbol',\n      inside: {\n        variable: /\\$+(?:(?!\\$)[^(){}:#=\\s]+|(?=[({]))/\n      }\n    },\n    variable: /\\$+(?:(?!\\$)[^(){}:#=\\s]+|\\([@*%<^+?][DF]\\)|(?=[({]))/,\n    // Directives\n    keyword:\n      /-include\\b|\\b(?:define|else|endef|endif|export|ifn?def|ifn?eq|include|override|private|sinclude|undefine|unexport|vpath)\\b/,\n    function: {\n      pattern:\n        /(\\()(?: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])/,\n      lookbehind: true\n    },\n    operator: /(?:::|[?:+!])?=|[|@]/,\n    punctuation: /[:;(){}]/\n  }\n}\n"],"names":["makefile"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,eAAiBA;AACjB,EAAAA,UAAS,cAAc;AACvB,EAAAA,UAAS,UAAU,CAAA;AACnB,WAASA,UAAS,OAAO;AACvB,UAAM,UAAU,WAAW;AAAA,MACzB,SAAS;AAAA,QACP,SAAS;AAAA,QACT,YAAY;AAAA;MAEd,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,kBAAkB;AAAA,QAChB,SAAS;AAAA,QACT,OAAO;AAAA;MAET,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,OAAO;AAAA,QACP,QAAQ;AAAA,UACN,UAAU;AAAA;;MAGd,UAAU;AAAA;AAAA,MAEV,SACE;AAAA,MACF,UAAU;AAAA,QACR,SACE;AAAA,QACF,YAAY;AAAA;MAEd,UAAU;AAAA,MACV,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}