@oscloudlab/knowledge-card 0.0.1 → 0.0.3

package/dist/psl-BuM8q5hK.js

@@ -0,0 +1,77 @@
+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 psl_1;
+var hasRequiredPsl;
+function requirePsl() {
+  if (hasRequiredPsl) return psl_1;
+  hasRequiredPsl = 1;
+  psl_1 = psl2;
+  psl2.displayName = "psl";
+  psl2.aliases = [];
+  function psl2(Prism) {
+    Prism.languages.psl = {
+      comment: {
+        pattern: /#.*/,
+        greedy: true
+      },
+      string: {
+        pattern: /"(?:\\.|[^\\"])*"/,
+        greedy: true,
+        inside: {
+          symbol: /\\[ntrbA-Z"\\]/
+        }
+      },
+      "heredoc-string": {
+        pattern: /<<<([a-zA-Z_]\w*)[\r\n](?:.*[\r\n])*?\1\b/,
+        alias: "string",
+        greedy: true
+      },
+      keyword: /\b(?:__multi|__single|case|default|do|else|elsif|exit|export|for|foreach|function|if|last|line|local|next|requires|return|switch|until|while|word)\b/,
+      constant: /\b(?:ALARM|CHART_ADD_GRAPH|CHART_DELETE_GRAPH|CHART_DESTROY|CHART_LOAD|CHART_PRINT|EOF|OFFLINE|OK|PSL_PROF_LOG|R_CHECK_HORIZ|R_CHECK_VERT|R_CLICKER|R_COLUMN|R_FRAME|R_ICON|R_LABEL|R_LABEL_CENTER|R_LIST_MULTIPLE|R_LIST_MULTIPLE_ND|R_LIST_SINGLE|R_LIST_SINGLE_ND|R_MENU|R_POPUP|R_POPUP_SCROLLED|R_RADIO_HORIZ|R_RADIO_VERT|R_ROW|R_SCALE_HORIZ|R_SCALE_VERT|R_SEP_HORIZ|R_SEP_VERT|R_SPINNER|R_TEXT_FIELD|R_TEXT_FIELD_LABEL|R_TOGGLE|TRIM_LEADING|TRIM_LEADING_AND_TRAILING|TRIM_REDUNDANT|TRIM_TRAILING|VOID|WARN)\b/,
+      boolean: /\b(?:FALSE|False|NO|No|TRUE|True|YES|Yes|false|no|true|yes)\b/,
+      variable: /\b(?:PslDebug|errno|exit_status)\b/,
+      builtin: {
+        pattern: /\b(?:PslExecute|PslFunctionCall|PslFunctionExists|PslSetOptions|_snmp_debug|acos|add_diary|annotate|annotate_get|ascii_to_ebcdic|asctime|asin|atan|atexit|batch_set|blackout|cat|ceil|chan_exists|change_state|close|code_cvt|cond_signal|cond_wait|console_type|convert_base|convert_date|convert_locale_date|cos|cosh|create|date|dcget_text|destroy|destroy_lock|dget_text|difference|dump_hist|ebcdic_to_ascii|encrypt|event_archive|event_catalog_get|event_check|event_query|event_range_manage|event_range_query|event_report|event_schedule|event_trigger|event_trigger2|execute|exists|exp|fabs|file|floor|fmod|fopen|fseek|ftell|full_discovery|get|get_chan_info|get_ranges|get_text|get_vars|getenv|gethostinfo|getpid|getpname|grep|history|history_get_retention|in_transition|index|int|internal|intersection|is_var|isnumber|join|kill|length|lines|lock|lock_info|log|log10|loge|matchline|msg_check|msg_get_format|msg_get_severity|msg_printf|msg_sprintf|ntharg|nthargf|nthline|nthlinef|num_bytes|num_consoles|pconfig|popen|poplines|pow|print|printf|proc_exists|process|random|read|readln|refresh_parameters|remote_check|remote_close|remote_event_query|remote_event_trigger|remote_file_send|remote_open|remove|replace|rindex|sec_check_priv|sec_store_get|sec_store_set|set|set_alarm_ranges|set_locale|share|sin|sinh|sleep|snmp_agent_config|snmp_agent_start|snmp_agent_stop|snmp_close|snmp_config|snmp_get|snmp_get_next|snmp_h_get|snmp_h_get_next|snmp_h_set|snmp_open|snmp_set|snmp_trap_ignore|snmp_trap_listen|snmp_trap_raise_std_trap|snmp_trap_receive|snmp_trap_register_im|snmp_trap_send|snmp_walk|sopen|sort|splitline|sprintf|sqrt|srandom|str_repeat|strcasecmp|subset|substr|system|tail|tan|tanh|text_domain|time|tmpnam|tolower|toupper|trace_psl_process|trim|union|unique|unlock|unset|va_arg|va_start|write)\b/,
+        alias: "builtin-function"
+      },
+      "foreach-variable": {
+        pattern: /(\bforeach\s+(?:(?:\w+\b|"(?:\\.|[^\\"])*")\s+){0,2})[_a-zA-Z]\w*(?=\s*\()/,
+        lookbehind: true,
+        greedy: true
+      },
+      function: /\b[_a-z]\w*\b(?=\s*\()/i,
+      number: /\b(?:0x[0-9a-f]+|\d+(?:\.\d+)?)\b/i,
+      operator: /--|\+\+|&&=?|\|\|=?|<<=?|>>=?|[=!]~|[-+*/%&|^!=<>]=?|\.|[:?]/,
+      punctuation: /[(){}\[\];,]/
+    };
+  }
+  return psl_1;
+}
+var pslExports = requirePsl();
+const psl = /* @__PURE__ */ getDefaultExportFromCjs(pslExports);
+const psl$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: psl
+}, [pslExports]);
+export {
+  psl$1 as p
+};
+//# sourceMappingURL=psl-BuM8q5hK.js.map

package/dist/psl-BuM8q5hK.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"psl-BuM8q5hK.js","sources":["../node_modules/refractor/lang/psl.js"],"sourcesContent":["'use strict'\n\nmodule.exports = psl\npsl.displayName = 'psl'\npsl.aliases = []\nfunction psl(Prism) {\n  Prism.languages.psl = {\n    comment: {\n      pattern: /#.*/,\n      greedy: true\n    },\n    string: {\n      pattern: /\"(?:\\\\.|[^\\\\\"])*\"/,\n      greedy: true,\n      inside: {\n        symbol: /\\\\[ntrbA-Z\"\\\\]/\n      }\n    },\n    'heredoc-string': {\n      pattern: /<<<([a-zA-Z_]\\w*)[\\r\\n](?:.*[\\r\\n])*?\\1\\b/,\n      alias: 'string',\n      greedy: true\n    },\n    keyword:\n      /\\b(?:__multi|__single|case|default|do|else|elsif|exit|export|for|foreach|function|if|last|line|local|next|requires|return|switch|until|while|word)\\b/,\n    constant:\n      /\\b(?:ALARM|CHART_ADD_GRAPH|CHART_DELETE_GRAPH|CHART_DESTROY|CHART_LOAD|CHART_PRINT|EOF|OFFLINE|OK|PSL_PROF_LOG|R_CHECK_HORIZ|R_CHECK_VERT|R_CLICKER|R_COLUMN|R_FRAME|R_ICON|R_LABEL|R_LABEL_CENTER|R_LIST_MULTIPLE|R_LIST_MULTIPLE_ND|R_LIST_SINGLE|R_LIST_SINGLE_ND|R_MENU|R_POPUP|R_POPUP_SCROLLED|R_RADIO_HORIZ|R_RADIO_VERT|R_ROW|R_SCALE_HORIZ|R_SCALE_VERT|R_SEP_HORIZ|R_SEP_VERT|R_SPINNER|R_TEXT_FIELD|R_TEXT_FIELD_LABEL|R_TOGGLE|TRIM_LEADING|TRIM_LEADING_AND_TRAILING|TRIM_REDUNDANT|TRIM_TRAILING|VOID|WARN)\\b/,\n    boolean: /\\b(?:FALSE|False|NO|No|TRUE|True|YES|Yes|false|no|true|yes)\\b/,\n    variable: /\\b(?:PslDebug|errno|exit_status)\\b/,\n    builtin: {\n      pattern:\n        /\\b(?:PslExecute|PslFunctionCall|PslFunctionExists|PslSetOptions|_snmp_debug|acos|add_diary|annotate|annotate_get|ascii_to_ebcdic|asctime|asin|atan|atexit|batch_set|blackout|cat|ceil|chan_exists|change_state|close|code_cvt|cond_signal|cond_wait|console_type|convert_base|convert_date|convert_locale_date|cos|cosh|create|date|dcget_text|destroy|destroy_lock|dget_text|difference|dump_hist|ebcdic_to_ascii|encrypt|event_archive|event_catalog_get|event_check|event_query|event_range_manage|event_range_query|event_report|event_schedule|event_trigger|event_trigger2|execute|exists|exp|fabs|file|floor|fmod|fopen|fseek|ftell|full_discovery|get|get_chan_info|get_ranges|get_text|get_vars|getenv|gethostinfo|getpid|getpname|grep|history|history_get_retention|in_transition|index|int|internal|intersection|is_var|isnumber|join|kill|length|lines|lock|lock_info|log|log10|loge|matchline|msg_check|msg_get_format|msg_get_severity|msg_printf|msg_sprintf|ntharg|nthargf|nthline|nthlinef|num_bytes|num_consoles|pconfig|popen|poplines|pow|print|printf|proc_exists|process|random|read|readln|refresh_parameters|remote_check|remote_close|remote_event_query|remote_event_trigger|remote_file_send|remote_open|remove|replace|rindex|sec_check_priv|sec_store_get|sec_store_set|set|set_alarm_ranges|set_locale|share|sin|sinh|sleep|snmp_agent_config|snmp_agent_start|snmp_agent_stop|snmp_close|snmp_config|snmp_get|snmp_get_next|snmp_h_get|snmp_h_get_next|snmp_h_set|snmp_open|snmp_set|snmp_trap_ignore|snmp_trap_listen|snmp_trap_raise_std_trap|snmp_trap_receive|snmp_trap_register_im|snmp_trap_send|snmp_walk|sopen|sort|splitline|sprintf|sqrt|srandom|str_repeat|strcasecmp|subset|substr|system|tail|tan|tanh|text_domain|time|tmpnam|tolower|toupper|trace_psl_process|trim|union|unique|unlock|unset|va_arg|va_start|write)\\b/,\n      alias: 'builtin-function'\n    },\n    'foreach-variable': {\n      pattern:\n        /(\\bforeach\\s+(?:(?:\\w+\\b|\"(?:\\\\.|[^\\\\\"])*\")\\s+){0,2})[_a-zA-Z]\\w*(?=\\s*\\()/,\n      lookbehind: true,\n      greedy: true\n    },\n    function: /\\b[_a-z]\\w*\\b(?=\\s*\\()/i,\n    number: /\\b(?:0x[0-9a-f]+|\\d+(?:\\.\\d+)?)\\b/i,\n    operator: /--|\\+\\+|&&=?|\\|\\|=?|<<=?|>>=?|[=!]~|[-+*/%&|^!=<>]=?|\\.|[:?]/,\n    punctuation: /[(){}\\[\\];,]/\n  }\n}\n"],"names":["psl"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,UAAiBA;AACjB,EAAAA,KAAI,cAAc;AAClB,EAAAA,KAAI,UAAU,CAAA;AACd,WAASA,KAAI,OAAO;AAClB,UAAM,UAAU,MAAM;AAAA,MACpB,SAAS;AAAA,QACP,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA,QACR,QAAQ;AAAA,UACN,QAAQ;AAAA;;MAGZ,kBAAkB;AAAA,QAChB,SAAS;AAAA,QACT,OAAO;AAAA,QACP,QAAQ;AAAA;MAEV,SACE;AAAA,MACF,UACE;AAAA,MACF,SAAS;AAAA,MACT,UAAU;AAAA,MACV,SAAS;AAAA,QACP,SACE;AAAA,QACF,OAAO;AAAA;MAET,oBAAoB;AAAA,QAClB,SACE;AAAA,QACF,YAAY;AAAA,QACZ,QAAQ;AAAA;MAEV,UAAU;AAAA,MACV,QAAQ;AAAA,MACR,UAAU;AAAA,MACV,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/pug-D8RezS0m.js

@@ -0,0 +1,227 @@
+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 pug_1;
+var hasRequiredPug;
+function requirePug() {
+  if (hasRequiredPug) return pug_1;
+  hasRequiredPug = 1;
+  pug_1 = pug2;
+  pug2.displayName = "pug";
+  pug2.aliases = [];
+  function pug2(Prism) {
+    (function(Prism2) {
+      Prism2.languages.pug = {
+        // Multiline stuff should appear before the rest
+        // This handles both single-line and multi-line comments
+        comment: {
+          pattern: /(^([\t ]*))\/\/.*(?:(?:\r?\n|\r)\2[\t ].+)*/m,
+          lookbehind: true
+        },
+        // All the tag-related part is in lookbehind
+        // so that it can be highlighted by the "tag" pattern
+        "multiline-script": {
+          pattern: /(^([\t ]*)script\b.*\.[\t ]*)(?:(?:\r?\n|\r(?!\n))(?:\2[\t ].+|\s*?(?=\r?\n|\r)))+/m,
+          lookbehind: true,
+          inside: Prism2.languages.javascript
+        },
+        // See at the end of the file for known filters
+        filter: {
+          pattern: /(^([\t ]*)):.+(?:(?:\r?\n|\r(?!\n))(?:\2[\t ].+|\s*?(?=\r?\n|\r)))+/m,
+          lookbehind: true,
+          inside: {
+            "filter-name": {
+              pattern: /^:[\w-]+/,
+              alias: "variable"
+            },
+            text: /\S[\s\S]*/
+          }
+        },
+        "multiline-plain-text": {
+          pattern: /(^([\t ]*)[\w\-#.]+\.[\t ]*)(?:(?:\r?\n|\r(?!\n))(?:\2[\t ].+|\s*?(?=\r?\n|\r)))+/m,
+          lookbehind: true
+        },
+        markup: {
+          pattern: /(^[\t ]*)<.+/m,
+          lookbehind: true,
+          inside: Prism2.languages.markup
+        },
+        doctype: {
+          pattern: /((?:^|\n)[\t ]*)doctype(?: .+)?/,
+          lookbehind: true
+        },
+        // This handle all conditional and loop keywords
+        "flow-control": {
+          pattern: /(^[\t ]*)(?:case|default|each|else|if|unless|when|while)\b(?: .+)?/m,
+          lookbehind: true,
+          inside: {
+            each: {
+              pattern: /^each .+? in\b/,
+              inside: {
+                keyword: /\b(?:each|in)\b/,
+                punctuation: /,/
+              }
+            },
+            branch: {
+              pattern: /^(?:case|default|else|if|unless|when|while)\b/,
+              alias: "keyword"
+            },
+            rest: Prism2.languages.javascript
+          }
+        },
+        keyword: {
+          pattern: /(^[\t ]*)(?:append|block|extends|include|prepend)\b.+/m,
+          lookbehind: true
+        },
+        mixin: [
+          // Declaration
+          {
+            pattern: /(^[\t ]*)mixin .+/m,
+            lookbehind: true,
+            inside: {
+              keyword: /^mixin/,
+              function: /\w+(?=\s*\(|\s*$)/,
+              punctuation: /[(),.]/
+            }
+          },
+          // Usage
+          {
+            pattern: /(^[\t ]*)\+.+/m,
+            lookbehind: true,
+            inside: {
+              name: {
+                pattern: /^\+\w+/,
+                alias: "function"
+              },
+              rest: Prism2.languages.javascript
+            }
+          }
+        ],
+        script: {
+          pattern: /(^[\t ]*script(?:(?:&[^(]+)?\([^)]+\))*[\t ]).+/m,
+          lookbehind: true,
+          inside: Prism2.languages.javascript
+        },
+        "plain-text": {
+          pattern: /(^[\t ]*(?!-)[\w\-#.]*[\w\-](?:(?:&[^(]+)?\([^)]+\))*\/?[\t ]).+/m,
+          lookbehind: true
+        },
+        tag: {
+          pattern: /(^[\t ]*)(?!-)[\w\-#.]*[\w\-](?:(?:&[^(]+)?\([^)]+\))*\/?:?/m,
+          lookbehind: true,
+          inside: {
+            attributes: [
+              {
+                pattern: /&[^(]+\([^)]+\)/,
+                inside: Prism2.languages.javascript
+              },
+              {
+                pattern: /\([^)]+\)/,
+                inside: {
+                  "attr-value": {
+                    pattern: /(=\s*(?!\s))(?:\{[^}]*\}|[^,)\r\n]+)/,
+                    lookbehind: true,
+                    inside: Prism2.languages.javascript
+                  },
+                  "attr-name": /[\w-]+(?=\s*!?=|\s*[,)])/,
+                  punctuation: /[!=(),]+/
+                }
+              }
+            ],
+            punctuation: /:/,
+            "attr-id": /#[\w\-]+/,
+            "attr-class": /\.[\w\-]+/
+          }
+        },
+        code: [
+          {
+            pattern: /(^[\t ]*(?:-|!?=)).+/m,
+            lookbehind: true,
+            inside: Prism2.languages.javascript
+          }
+        ],
+        punctuation: /[.\-!=|]+/
+      };
+      var filter_pattern = /(^([\t ]*)):<filter_name>(?:(?:\r?\n|\r(?!\n))(?:\2[\t ].+|\s*?(?=\r?\n|\r)))+/.source;
+      var filters = [
+        {
+          filter: "atpl",
+          language: "twig"
+        },
+        {
+          filter: "coffee",
+          language: "coffeescript"
+        },
+        "ejs",
+        "handlebars",
+        "less",
+        "livescript",
+        "markdown",
+        {
+          filter: "sass",
+          language: "scss"
+        },
+        "stylus"
+      ];
+      var all_filters = {};
+      for (var i = 0, l = filters.length; i < l; i++) {
+        var filter = filters[i];
+        filter = typeof filter === "string" ? {
+          filter,
+          language: filter
+        } : filter;
+        if (Prism2.languages[filter.language]) {
+          all_filters["filter-" + filter.filter] = {
+            pattern: RegExp(
+              filter_pattern.replace("<filter_name>", function() {
+                return filter.filter;
+              }),
+              "m"
+            ),
+            lookbehind: true,
+            inside: {
+              "filter-name": {
+                pattern: /^:[\w-]+/,
+                alias: "variable"
+              },
+              text: {
+                pattern: /\S[\s\S]*/,
+                alias: [filter.language, "language-" + filter.language],
+                inside: Prism2.languages[filter.language]
+              }
+            }
+          };
+        }
+      }
+      Prism2.languages.insertBefore("pug", "filter", all_filters);
+    })(Prism);
+  }
+  return pug_1;
+}
+var pugExports = requirePug();
+const pug = /* @__PURE__ */ getDefaultExportFromCjs(pugExports);
+const pug$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: pug
+}, [pugExports]);
+export {
+  pug$1 as p
+};
+//# sourceMappingURL=pug-D8RezS0m.js.map

package/dist/pug-D8RezS0m.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pug-D8RezS0m.js","sources":["../node_modules/refractor/lang/pug.js"],"sourcesContent":["'use strict'\n\nmodule.exports = pug\npug.displayName = 'pug'\npug.aliases = []\nfunction pug(Prism) {\n  ;(function (Prism) {\n    // TODO:\n    // - Add CSS highlighting inside <style> tags\n    // - Add support for multi-line code blocks\n    // - Add support for interpolation #{} and !{}\n    // - Add support for tag interpolation #[]\n    // - Add explicit support for plain text using |\n    // - Add support for markup embedded in plain text\n    Prism.languages.pug = {\n      // Multiline stuff should appear before the rest\n      // This handles both single-line and multi-line comments\n      comment: {\n        pattern: /(^([\\t ]*))\\/\\/.*(?:(?:\\r?\\n|\\r)\\2[\\t ].+)*/m,\n        lookbehind: true\n      },\n      // All the tag-related part is in lookbehind\n      // so that it can be highlighted by the \"tag\" pattern\n      'multiline-script': {\n        pattern:\n          /(^([\\t ]*)script\\b.*\\.[\\t ]*)(?:(?:\\r?\\n|\\r(?!\\n))(?:\\2[\\t ].+|\\s*?(?=\\r?\\n|\\r)))+/m,\n        lookbehind: true,\n        inside: Prism.languages.javascript\n      },\n      // See at the end of the file for known filters\n      filter: {\n        pattern:\n          /(^([\\t ]*)):.+(?:(?:\\r?\\n|\\r(?!\\n))(?:\\2[\\t ].+|\\s*?(?=\\r?\\n|\\r)))+/m,\n        lookbehind: true,\n        inside: {\n          'filter-name': {\n            pattern: /^:[\\w-]+/,\n            alias: 'variable'\n          },\n          text: /\\S[\\s\\S]*/\n        }\n      },\n      'multiline-plain-text': {\n        pattern:\n          /(^([\\t ]*)[\\w\\-#.]+\\.[\\t ]*)(?:(?:\\r?\\n|\\r(?!\\n))(?:\\2[\\t ].+|\\s*?(?=\\r?\\n|\\r)))+/m,\n        lookbehind: true\n      },\n      markup: {\n        pattern: /(^[\\t ]*)<.+/m,\n        lookbehind: true,\n        inside: Prism.languages.markup\n      },\n      doctype: {\n        pattern: /((?:^|\\n)[\\t ]*)doctype(?: .+)?/,\n        lookbehind: true\n      },\n      // This handle all conditional and loop keywords\n      'flow-control': {\n        pattern:\n          /(^[\\t ]*)(?:case|default|each|else|if|unless|when|while)\\b(?: .+)?/m,\n        lookbehind: true,\n        inside: {\n          each: {\n            pattern: /^each .+? in\\b/,\n            inside: {\n              keyword: /\\b(?:each|in)\\b/,\n              punctuation: /,/\n            }\n          },\n          branch: {\n            pattern: /^(?:case|default|else|if|unless|when|while)\\b/,\n            alias: 'keyword'\n          },\n          rest: Prism.languages.javascript\n        }\n      },\n      keyword: {\n        pattern: /(^[\\t ]*)(?:append|block|extends|include|prepend)\\b.+/m,\n        lookbehind: true\n      },\n      mixin: [\n        // Declaration\n        {\n          pattern: /(^[\\t ]*)mixin .+/m,\n          lookbehind: true,\n          inside: {\n            keyword: /^mixin/,\n            function: /\\w+(?=\\s*\\(|\\s*$)/,\n            punctuation: /[(),.]/\n          }\n        }, // Usage\n        {\n          pattern: /(^[\\t ]*)\\+.+/m,\n          lookbehind: true,\n          inside: {\n            name: {\n              pattern: /^\\+\\w+/,\n              alias: 'function'\n            },\n            rest: Prism.languages.javascript\n          }\n        }\n      ],\n      script: {\n        pattern: /(^[\\t ]*script(?:(?:&[^(]+)?\\([^)]+\\))*[\\t ]).+/m,\n        lookbehind: true,\n        inside: Prism.languages.javascript\n      },\n      'plain-text': {\n        pattern:\n          /(^[\\t ]*(?!-)[\\w\\-#.]*[\\w\\-](?:(?:&[^(]+)?\\([^)]+\\))*\\/?[\\t ]).+/m,\n        lookbehind: true\n      },\n      tag: {\n        pattern: /(^[\\t ]*)(?!-)[\\w\\-#.]*[\\w\\-](?:(?:&[^(]+)?\\([^)]+\\))*\\/?:?/m,\n        lookbehind: true,\n        inside: {\n          attributes: [\n            {\n              pattern: /&[^(]+\\([^)]+\\)/,\n              inside: Prism.languages.javascript\n            },\n            {\n              pattern: /\\([^)]+\\)/,\n              inside: {\n                'attr-value': {\n                  pattern: /(=\\s*(?!\\s))(?:\\{[^}]*\\}|[^,)\\r\\n]+)/,\n                  lookbehind: true,\n                  inside: Prism.languages.javascript\n                },\n                'attr-name': /[\\w-]+(?=\\s*!?=|\\s*[,)])/,\n                punctuation: /[!=(),]+/\n              }\n            }\n          ],\n          punctuation: /:/,\n          'attr-id': /#[\\w\\-]+/,\n          'attr-class': /\\.[\\w\\-]+/\n        }\n      },\n      code: [\n        {\n          pattern: /(^[\\t ]*(?:-|!?=)).+/m,\n          lookbehind: true,\n          inside: Prism.languages.javascript\n        }\n      ],\n      punctuation: /[.\\-!=|]+/\n    }\n    var filter_pattern =\n      /(^([\\t ]*)):<filter_name>(?:(?:\\r?\\n|\\r(?!\\n))(?:\\2[\\t ].+|\\s*?(?=\\r?\\n|\\r)))+/\n        .source // Non exhaustive list of available filters and associated languages\n    var filters = [\n      {\n        filter: 'atpl',\n        language: 'twig'\n      },\n      {\n        filter: 'coffee',\n        language: 'coffeescript'\n      },\n      'ejs',\n      'handlebars',\n      'less',\n      'livescript',\n      'markdown',\n      {\n        filter: 'sass',\n        language: 'scss'\n      },\n      'stylus'\n    ]\n    var all_filters = {}\n    for (var i = 0, l = filters.length; i < l; i++) {\n      var filter = filters[i]\n      filter =\n        typeof filter === 'string'\n          ? {\n              filter: filter,\n              language: filter\n            }\n          : filter\n      if (Prism.languages[filter.language]) {\n        all_filters['filter-' + filter.filter] = {\n          pattern: RegExp(\n            filter_pattern.replace('<filter_name>', function () {\n              return filter.filter\n            }),\n            'm'\n          ),\n          lookbehind: true,\n          inside: {\n            'filter-name': {\n              pattern: /^:[\\w-]+/,\n              alias: 'variable'\n            },\n            text: {\n              pattern: /\\S[\\s\\S]*/,\n              alias: [filter.language, 'language-' + filter.language],\n              inside: Prism.languages[filter.language]\n            }\n          }\n        }\n      }\n    }\n    Prism.languages.insertBefore('pug', 'filter', all_filters)\n  })(Prism)\n}\n"],"names":["pug","Prism"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/puppet-CB-VBKbq.js

@@ -0,0 +1,177 @@
+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 puppet_1;
+var hasRequiredPuppet;
+function requirePuppet() {
+  if (hasRequiredPuppet) return puppet_1;
+  hasRequiredPuppet = 1;
+  puppet_1 = puppet2;
+  puppet2.displayName = "puppet";
+  puppet2.aliases = [];
+  function puppet2(Prism) {
+    (function(Prism2) {
+      Prism2.languages.puppet = {
+        heredoc: [
+          // Matches the content of a quoted heredoc string (subject to interpolation)
+          {
+            pattern: /(@\("([^"\r\n\/):]+)"(?:\/[nrts$uL]*)?\).*(?:\r?\n|\r))(?:.*(?:\r?\n|\r(?!\n)))*?[ \t]*(?:\|[ \t]*)?(?:-[ \t]*)?\2/,
+            lookbehind: true,
+            alias: "string",
+            inside: {
+              // Matches the end tag
+              punctuation: /(?=\S).*\S(?= *$)/
+              // See interpolation below
+            }
+          },
+          // Matches the content of an unquoted heredoc string (no interpolation)
+          {
+            pattern: /(@\(([^"\r\n\/):]+)(?:\/[nrts$uL]*)?\).*(?:\r?\n|\r))(?:.*(?:\r?\n|\r(?!\n)))*?[ \t]*(?:\|[ \t]*)?(?:-[ \t]*)?\2/,
+            lookbehind: true,
+            greedy: true,
+            alias: "string",
+            inside: {
+              // Matches the end tag
+              punctuation: /(?=\S).*\S(?= *$)/
+            }
+          },
+          // Matches the start tag of heredoc strings
+          {
+            pattern: /@\("?(?:[^"\r\n\/):]+)"?(?:\/[nrts$uL]*)?\)/,
+            alias: "string",
+            inside: {
+              punctuation: {
+                pattern: /(\().+?(?=\))/,
+                lookbehind: true
+              }
+            }
+          }
+        ],
+        "multiline-comment": {
+          pattern: /(^|[^\\])\/\*[\s\S]*?\*\//,
+          lookbehind: true,
+          greedy: true,
+          alias: "comment"
+        },
+        regex: {
+          // Must be prefixed with the keyword "node" or a non-word char
+          pattern: /((?:\bnode\s+|[~=\(\[\{,]\s*|[=+]>\s*|^\s*))\/(?:[^\/\\]|\\[\s\S])+\/(?:[imx]+\b|\B)/,
+          lookbehind: true,
+          greedy: true,
+          inside: {
+            // Extended regexes must have the x flag. They can contain single-line comments.
+            "extended-regex": {
+              pattern: /^\/(?:[^\/\\]|\\[\s\S])+\/[im]*x[im]*$/,
+              inside: {
+                comment: /#.*/
+              }
+            }
+          }
+        },
+        comment: {
+          pattern: /(^|[^\\])#.*/,
+          lookbehind: true,
+          greedy: true
+        },
+        string: {
+          // Allow for one nested level of double quotes inside interpolation
+          pattern: /(["'])(?:\$\{(?:[^'"}]|(["'])(?:(?!\2)[^\\]|\\[\s\S])*\2)+\}|\$(?!\{)|(?!\1)[^\\$]|\\[\s\S])*\1/,
+          greedy: true,
+          inside: {
+            "double-quoted": {
+              pattern: /^"[\s\S]*"$/,
+              inside: {
+                // See interpolation below
+              }
+            }
+          }
+        },
+        variable: {
+          pattern: /\$(?:::)?\w+(?:::\w+)*/,
+          inside: {
+            punctuation: /::/
+          }
+        },
+        "attr-name": /(?:\b\w+|\*)(?=\s*=>)/,
+        function: [
+          {
+            pattern: /(\.)(?!\d)\w+/,
+            lookbehind: true
+          },
+          /\b(?:contain|debug|err|fail|include|info|notice|realize|require|tag|warning)\b|\b(?!\d)\w+(?=\()/
+        ],
+        number: /\b(?:0x[a-f\d]+|\d+(?:\.\d+)?(?:e-?\d+)?)\b/i,
+        boolean: /\b(?:false|true)\b/,
+        // Includes words reserved for future use
+        keyword: /\b(?:application|attr|case|class|consumes|default|define|else|elsif|function|if|import|inherits|node|private|produces|type|undef|unless)\b/,
+        datatype: {
+          pattern: /\b(?:Any|Array|Boolean|Callable|Catalogentry|Class|Collection|Data|Default|Enum|Float|Hash|Integer|NotUndef|Numeric|Optional|Pattern|Regexp|Resource|Runtime|Scalar|String|Struct|Tuple|Type|Undef|Variant)\b/,
+          alias: "symbol"
+        },
+        operator: /=[=~>]?|![=~]?|<(?:<\|?|[=~|-])?|>[>=]?|->?|~>|\|>?>?|[*\/%+?]|\b(?:and|in|or)\b/,
+        punctuation: /[\[\]{}().,;]|:+/
+      };
+      var interpolation = [
+        {
+          // Allow for one nested level of braces inside interpolation
+          pattern: /(^|[^\\])\$\{(?:[^'"{}]|\{[^}]*\}|(["'])(?:(?!\2)[^\\]|\\[\s\S])*\2)+\}/,
+          lookbehind: true,
+          inside: {
+            "short-variable": {
+              // Negative look-ahead prevent wrong highlighting of functions
+              pattern: /(^\$\{)(?!\w+\()(?:::)?\w+(?:::\w+)*/,
+              lookbehind: true,
+              alias: "variable",
+              inside: {
+                punctuation: /::/
+              }
+            },
+            delimiter: {
+              pattern: /^\$/,
+              alias: "variable"
+            },
+            rest: Prism2.languages.puppet
+          }
+        },
+        {
+          pattern: /(^|[^\\])\$(?:::)?\w+(?:::\w+)*/,
+          lookbehind: true,
+          alias: "variable",
+          inside: {
+            punctuation: /::/
+          }
+        }
+      ];
+      Prism2.languages.puppet["heredoc"][0].inside.interpolation = interpolation;
+      Prism2.languages.puppet["string"].inside["double-quoted"].inside.interpolation = interpolation;
+    })(Prism);
+  }
+  return puppet_1;
+}
+var puppetExports = requirePuppet();
+const puppet = /* @__PURE__ */ getDefaultExportFromCjs(puppetExports);
+const puppet$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: puppet
+}, [puppetExports]);
+export {
+  puppet$1 as p
+};
+//# sourceMappingURL=puppet-CB-VBKbq.js.map

package/dist/puppet-CB-VBKbq.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"puppet-CB-VBKbq.js","sources":["../node_modules/refractor/lang/puppet.js"],"sourcesContent":["'use strict'\n\nmodule.exports = puppet\npuppet.displayName = 'puppet'\npuppet.aliases = []\nfunction puppet(Prism) {\n  ;(function (Prism) {\n    Prism.languages.puppet = {\n      heredoc: [\n        // Matches the content of a quoted heredoc string (subject to interpolation)\n        {\n          pattern:\n            /(@\\(\"([^\"\\r\\n\\/):]+)\"(?:\\/[nrts$uL]*)?\\).*(?:\\r?\\n|\\r))(?:.*(?:\\r?\\n|\\r(?!\\n)))*?[ \\t]*(?:\\|[ \\t]*)?(?:-[ \\t]*)?\\2/,\n          lookbehind: true,\n          alias: 'string',\n          inside: {\n            // Matches the end tag\n            punctuation: /(?=\\S).*\\S(?= *$)/ // See interpolation below\n          }\n        }, // Matches the content of an unquoted heredoc string (no interpolation)\n        {\n          pattern:\n            /(@\\(([^\"\\r\\n\\/):]+)(?:\\/[nrts$uL]*)?\\).*(?:\\r?\\n|\\r))(?:.*(?:\\r?\\n|\\r(?!\\n)))*?[ \\t]*(?:\\|[ \\t]*)?(?:-[ \\t]*)?\\2/,\n          lookbehind: true,\n          greedy: true,\n          alias: 'string',\n          inside: {\n            // Matches the end tag\n            punctuation: /(?=\\S).*\\S(?= *$)/\n          }\n        }, // Matches the start tag of heredoc strings\n        {\n          pattern: /@\\(\"?(?:[^\"\\r\\n\\/):]+)\"?(?:\\/[nrts$uL]*)?\\)/,\n          alias: 'string',\n          inside: {\n            punctuation: {\n              pattern: /(\\().+?(?=\\))/,\n              lookbehind: true\n            }\n          }\n        }\n      ],\n      'multiline-comment': {\n        pattern: /(^|[^\\\\])\\/\\*[\\s\\S]*?\\*\\//,\n        lookbehind: true,\n        greedy: true,\n        alias: 'comment'\n      },\n      regex: {\n        // Must be prefixed with the keyword \"node\" or a non-word char\n        pattern:\n          /((?:\\bnode\\s+|[~=\\(\\[\\{,]\\s*|[=+]>\\s*|^\\s*))\\/(?:[^\\/\\\\]|\\\\[\\s\\S])+\\/(?:[imx]+\\b|\\B)/,\n        lookbehind: true,\n        greedy: true,\n        inside: {\n          // Extended regexes must have the x flag. They can contain single-line comments.\n          'extended-regex': {\n            pattern: /^\\/(?:[^\\/\\\\]|\\\\[\\s\\S])+\\/[im]*x[im]*$/,\n            inside: {\n              comment: /#.*/\n            }\n          }\n        }\n      },\n      comment: {\n        pattern: /(^|[^\\\\])#.*/,\n        lookbehind: true,\n        greedy: true\n      },\n      string: {\n        // Allow for one nested level of double quotes inside interpolation\n        pattern:\n          /([\"'])(?:\\$\\{(?:[^'\"}]|([\"'])(?:(?!\\2)[^\\\\]|\\\\[\\s\\S])*\\2)+\\}|\\$(?!\\{)|(?!\\1)[^\\\\$]|\\\\[\\s\\S])*\\1/,\n        greedy: true,\n        inside: {\n          'double-quoted': {\n            pattern: /^\"[\\s\\S]*\"$/,\n            inside: {\n              // See interpolation below\n            }\n          }\n        }\n      },\n      variable: {\n        pattern: /\\$(?:::)?\\w+(?:::\\w+)*/,\n        inside: {\n          punctuation: /::/\n        }\n      },\n      'attr-name': /(?:\\b\\w+|\\*)(?=\\s*=>)/,\n      function: [\n        {\n          pattern: /(\\.)(?!\\d)\\w+/,\n          lookbehind: true\n        },\n        /\\b(?:contain|debug|err|fail|include|info|notice|realize|require|tag|warning)\\b|\\b(?!\\d)\\w+(?=\\()/\n      ],\n      number: /\\b(?:0x[a-f\\d]+|\\d+(?:\\.\\d+)?(?:e-?\\d+)?)\\b/i,\n      boolean: /\\b(?:false|true)\\b/,\n      // Includes words reserved for future use\n      keyword:\n        /\\b(?:application|attr|case|class|consumes|default|define|else|elsif|function|if|import|inherits|node|private|produces|type|undef|unless)\\b/,\n      datatype: {\n        pattern:\n          /\\b(?:Any|Array|Boolean|Callable|Catalogentry|Class|Collection|Data|Default|Enum|Float|Hash|Integer|NotUndef|Numeric|Optional|Pattern|Regexp|Resource|Runtime|Scalar|String|Struct|Tuple|Type|Undef|Variant)\\b/,\n        alias: 'symbol'\n      },\n      operator:\n        /=[=~>]?|![=~]?|<(?:<\\|?|[=~|-])?|>[>=]?|->?|~>|\\|>?>?|[*\\/%+?]|\\b(?:and|in|or)\\b/,\n      punctuation: /[\\[\\]{}().,;]|:+/\n    }\n    var interpolation = [\n      {\n        // Allow for one nested level of braces inside interpolation\n        pattern:\n          /(^|[^\\\\])\\$\\{(?:[^'\"{}]|\\{[^}]*\\}|([\"'])(?:(?!\\2)[^\\\\]|\\\\[\\s\\S])*\\2)+\\}/,\n        lookbehind: true,\n        inside: {\n          'short-variable': {\n            // Negative look-ahead prevent wrong highlighting of functions\n            pattern: /(^\\$\\{)(?!\\w+\\()(?:::)?\\w+(?:::\\w+)*/,\n            lookbehind: true,\n            alias: 'variable',\n            inside: {\n              punctuation: /::/\n            }\n          },\n          delimiter: {\n            pattern: /^\\$/,\n            alias: 'variable'\n          },\n          rest: Prism.languages.puppet\n        }\n      },\n      {\n        pattern: /(^|[^\\\\])\\$(?:::)?\\w+(?:::\\w+)*/,\n        lookbehind: true,\n        alias: 'variable',\n        inside: {\n          punctuation: /::/\n        }\n      }\n    ]\n    Prism.languages.puppet['heredoc'][0].inside.interpolation = interpolation\n    Prism.languages.puppet['string'].inside[\n      'double-quoted'\n    ].inside.interpolation = interpolation\n  })(Prism)\n}\n"],"names":["puppet","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,aAAiBA;AACjB,EAAAA,QAAO,cAAc;AACrB,EAAAA,QAAO,UAAU,CAAA;AACjB,WAASA,QAAO,OAAO;AACpB,KAAC,SAAUC,QAAO;AACjB,MAAAA,OAAM,UAAU,SAAS;AAAA,QACvB,SAAS;AAAA;AAAA,UAEP;AAAA,YACE,SACE;AAAA,YACF,YAAY;AAAA,YACZ,OAAO;AAAA,YACP,QAAQ;AAAA;AAAA,cAEN,aAAa;AAAA;AAAA;;;UAGjB;AAAA,YACE,SACE;AAAA,YACF,YAAY;AAAA,YACZ,QAAQ;AAAA,YACR,OAAO;AAAA,YACP,QAAQ;AAAA;AAAA,cAEN,aAAa;AAAA;;;UAGjB;AAAA,YACE,SAAS;AAAA,YACT,OAAO;AAAA,YACP,QAAQ;AAAA,cACN,aAAa;AAAA,gBACX,SAAS;AAAA,gBACT,YAAY;AAAA;;;;QAKpB,qBAAqB;AAAA,UACnB,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,QAAQ;AAAA,UACR,OAAO;AAAA;QAET,OAAO;AAAA;AAAA,UAEL,SACE;AAAA,UACF,YAAY;AAAA,UACZ,QAAQ;AAAA,UACR,QAAQ;AAAA;AAAA,YAEN,kBAAkB;AAAA,cAChB,SAAS;AAAA,cACT,QAAQ;AAAA,gBACN,SAAS;AAAA;;;;QAKjB,SAAS;AAAA,UACP,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,QAAQ;AAAA;QAEV,QAAQ;AAAA;AAAA,UAEN,SACE;AAAA,UACF,QAAQ;AAAA,UACR,QAAQ;AAAA,YACN,iBAAiB;AAAA,cACf,SAAS;AAAA,cACT,QAAQ;AAAA;AAAA;;;;QAMd,UAAU;AAAA,UACR,SAAS;AAAA,UACT,QAAQ;AAAA,YACN,aAAa;AAAA;;QAGjB,aAAa;AAAA,QACb,UAAU;AAAA,UACR;AAAA,YACE,SAAS;AAAA,YACT,YAAY;AAAA;UAEd;AAAA;QAEF,QAAQ;AAAA,QACR,SAAS;AAAA;AAAA,QAET,SACE;AAAA,QACF,UAAU;AAAA,UACR,SACE;AAAA,UACF,OAAO;AAAA;QAET,UACE;AAAA,QACF,aAAa;AAAA;AAEf,UAAI,gBAAgB;AAAA,QAClB;AAAA;AAAA,UAEE,SACE;AAAA,UACF,YAAY;AAAA,UACZ,QAAQ;AAAA,YACN,kBAAkB;AAAA;AAAA,cAEhB,SAAS;AAAA,cACT,YAAY;AAAA,cACZ,OAAO;AAAA,cACP,QAAQ;AAAA,gBACN,aAAa;AAAA;;YAGjB,WAAW;AAAA,cACT,SAAS;AAAA,cACT,OAAO;AAAA;YAET,MAAMA,OAAM,UAAU;AAAA;;QAG1B;AAAA,UACE,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,OAAO;AAAA,UACP,QAAQ;AAAA,YACN,aAAa;AAAA;;;AAInB,MAAAA,OAAM,UAAU,OAAO,SAAS,EAAE,CAAC,EAAE,OAAO,gBAAgB;AAC5D,MAAAA,OAAM,UAAU,OAAO,QAAQ,EAAE,OAC/B,eACN,EAAM,OAAO,gBAAgB;AAAA,IAC7B,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/pure-CSevquAM.js

@@ -0,0 +1,130 @@
+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 pure_1;
+var hasRequiredPure;
+function requirePure() {
+  if (hasRequiredPure) return pure_1;
+  hasRequiredPure = 1;
+  pure_1 = pure2;
+  pure2.displayName = "pure";
+  pure2.aliases = [];
+  function pure2(Prism) {
+    (function(Prism2) {
+      Prism2.languages.pure = {
+        comment: [
+          {
+            pattern: /(^|[^\\])\/\*[\s\S]*?\*\//,
+            lookbehind: true
+          },
+          {
+            pattern: /(^|[^\\:])\/\/.*/,
+            lookbehind: true
+          },
+          /#!.+/
+        ],
+        "inline-lang": {
+          pattern: /%<[\s\S]+?%>/,
+          greedy: true,
+          inside: {
+            lang: {
+              pattern: /(^%< *)-\*-.+?-\*-/,
+              lookbehind: true,
+              alias: "comment"
+            },
+            delimiter: {
+              pattern: /^%<.*|%>$/,
+              alias: "punctuation"
+            }
+          }
+        },
+        string: {
+          pattern: /"(?:\\.|[^"\\\r\n])*"/,
+          greedy: true
+        },
+        number: {
+          // The look-behind prevents wrong highlighting of the .. operator
+          pattern: /((?:\.\.)?)(?:\b(?:inf|nan)\b|\b0x[\da-f]+|(?:\b(?:0b)?\d+(?:\.\d+)?|\B\.\d+)(?:e[+-]?\d+)?L?)/i,
+          lookbehind: true
+        },
+        keyword: /\b(?:NULL|ans|break|bt|case|catch|cd|clear|const|def|del|dump|else|end|exit|extern|false|force|help|if|infix[lr]?|interface|let|ls|mem|namespace|nonfix|of|otherwise|outfix|override|postfix|prefix|private|public|pwd|quit|run|save|show|stats|then|throw|trace|true|type|underride|using|when|with)\b/,
+        function: /\b(?:abs|add_(?:addr|constdef|(?:fundef|interface|macdef|typedef)(?:_at)?|vardef)|all|any|applp?|arity|bigintp?|blob(?:_crc|_size|p)?|boolp?|byte_c?string(?:_pointer)?|byte_(?:matrix|pointer)|calloc|cat|catmap|ceil|char[ps]?|check_ptrtag|chr|clear_sentry|clearsym|closurep?|cmatrixp?|cols?|colcat(?:map)?|colmap|colrev|colvector(?:p|seq)?|complex(?:_float_(?:matrix|pointer)|_matrix(?:_view)?|_pointer|p)?|conj|cookedp?|cst|cstring(?:_(?:dup|list|vector))?|curry3?|cyclen?|del_(?:constdef|fundef|interface|macdef|typedef|vardef)|delete|diag(?:mat)?|dim|dmatrixp?|do|double(?:_matrix(?:_view)?|_pointer|p)?|dowith3?|drop|dropwhile|eval(?:cmd)?|exactp|filter|fix|fixity|flip|float(?:_matrix|_pointer)|floor|fold[lr]1?|frac|free|funp?|functionp?|gcd|get(?:_(?:byte|constdef|double|float|fundef|int(?:64)?|interface(?:_typedef)?|long|macdef|pointer|ptrtag|sentry|short|string|typedef|vardef))?|globsym|hash|head|id|im|imatrixp?|index|inexactp|infp|init|insert|int(?:_matrix(?:_view)?|_pointer|p)?|int64_(?:matrix|pointer)|integerp?|iteraten?|iterwhile|join|keys?|lambdap?|last(?:err(?:pos)?)?|lcd|list[2p]?|listmap|make_ptrtag|malloc|map|matcat|matrixp?|max|member|min|nanp|nargs|nmatrixp?|null|numberp?|ord|pack(?:ed)?|pointer(?:_cast|_tag|_type|p)?|pow|pred|ptrtag|put(?:_(?:byte|double|float|int(?:64)?|long|pointer|short|string))?|rationalp?|re|realp?|realloc|recordp?|redim|reduce(?:_with)?|refp?|repeatn?|reverse|rlistp?|round|rows?|rowcat(?:map)?|rowmap|rowrev|rowvector(?:p|seq)?|same|scan[lr]1?|sentry|sgn|short_(?:matrix|pointer)|slice|smatrixp?|sort|split|str|strcat|stream|stride|string(?:_(?:dup|list|vector)|p)?|subdiag(?:mat)?|submat|subseq2?|substr|succ|supdiag(?:mat)?|symbolp?|tail|take|takewhile|thunkp?|transpose|trunc|tuplep?|typep|ubyte|uint(?:64)?|ulong|uncurry3?|unref|unzip3?|update|ushort|vals?|varp?|vector(?:p|seq)?|void|zip3?|zipwith3?)\b/,
+        special: {
+          pattern: /\b__[a-z]+__\b/i,
+          alias: "builtin"
+        },
+        // Any combination of operator chars can be an operator
+        // eslint-disable-next-line no-misleading-character-class
+        operator: /(?:[!"#$%&'*+,\-.\/:<=>?@\\^`|~\u00a1-\u00bf\u00d7-\u00f7\u20d0-\u2bff]|\b_+\b)+|\b(?:and|div|mod|not|or)\b/,
+        // FIXME: How can we prevent | and , to be highlighted as operator when they are used alone?
+        punctuation: /[(){}\[\];,|]/
+      };
+      var inlineLanguages = [
+        "c",
+        {
+          lang: "c++",
+          alias: "cpp"
+        },
+        "fortran"
+      ];
+      var inlineLanguageRe = /%< *-\*- *<lang>\d* *-\*-[\s\S]+?%>/.source;
+      inlineLanguages.forEach(function(lang) {
+        var alias = lang;
+        if (typeof lang !== "string") {
+          alias = lang.alias;
+          lang = lang.lang;
+        }
+        if (Prism2.languages[alias]) {
+          var o = {};
+          o["inline-lang-" + alias] = {
+            pattern: RegExp(
+              inlineLanguageRe.replace(
+                "<lang>",
+                lang.replace(/([.+*?\/\\(){}\[\]])/g, "\\$1")
+              ),
+              "i"
+            ),
+            inside: Prism2.util.clone(Prism2.languages.pure["inline-lang"].inside)
+          };
+          o["inline-lang-" + alias].inside.rest = Prism2.util.clone(
+            Prism2.languages[alias]
+          );
+          Prism2.languages.insertBefore("pure", "inline-lang", o);
+        }
+      });
+      if (Prism2.languages.c) {
+        Prism2.languages.pure["inline-lang"].inside.rest = Prism2.util.clone(
+          Prism2.languages.c
+        );
+      }
+    })(Prism);
+  }
+  return pure_1;
+}
+var pureExports = requirePure();
+const pure = /* @__PURE__ */ getDefaultExportFromCjs(pureExports);
+const pure$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: pure
+}, [pureExports]);
+export {
+  pure$1 as p
+};
+//# sourceMappingURL=pure-CSevquAM.js.map