@photonix/basic 1.5.0 → 1.6.0

package/dist/chunk-7WPXI5M5.mjs

@@ -0,0 +1,100 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/promql.js
+promql.displayName = "promql";
+promql.aliases = [];
+function promql(Prism) {
+  ;
+  (function(Prism2) {
+    var aggregations = [
+      "sum",
+      "min",
+      "max",
+      "avg",
+      "group",
+      "stddev",
+      "stdvar",
+      "count",
+      "count_values",
+      "bottomk",
+      "topk",
+      "quantile"
+    ];
+    var vectorMatching = [
+      "on",
+      "ignoring",
+      "group_right",
+      "group_left",
+      "by",
+      "without"
+    ];
+    var offsetModifier = ["offset"];
+    var keywords = aggregations.concat(vectorMatching, offsetModifier);
+    Prism2.languages.promql = {
+      comment: {
+        pattern: /(^[ \t]*)#.*/m,
+        lookbehind: true
+      },
+      "vector-match": {
+        // Match the comma-separated label lists inside vector matching:
+        pattern: new RegExp(
+          "((?:" + vectorMatching.join("|") + ")\\s*)\\([^)]*\\)"
+        ),
+        lookbehind: true,
+        inside: {
+          "label-key": {
+            pattern: /\b[^,]+\b/,
+            alias: "attr-name"
+          },
+          punctuation: /[(),]/
+        }
+      },
+      "context-labels": {
+        pattern: /\{[^{}]*\}/,
+        inside: {
+          "label-key": {
+            pattern: /\b[a-z_]\w*(?=\s*(?:=|![=~]))/,
+            alias: "attr-name"
+          },
+          "label-value": {
+            pattern: /(["'`])(?:\\[\s\S]|(?!\1)[^\\])*\1/,
+            greedy: true,
+            alias: "attr-value"
+          },
+          punctuation: /\{|\}|=~?|![=~]|,/
+        }
+      },
+      "context-range": [
+        {
+          pattern: /\[[\w\s:]+\]/,
+          // [1m]
+          inside: {
+            punctuation: /\[|\]|:/,
+            "range-duration": {
+              pattern: /\b(?:\d+(?:[smhdwy]|ms))+\b/i,
+              alias: "number"
+            }
+          }
+        },
+        {
+          pattern: /(\boffset\s+)\w+/,
+          // offset 1m
+          lookbehind: true,
+          inside: {
+            "range-duration": {
+              pattern: /\b(?:\d+(?:[smhdwy]|ms))+\b/i,
+              alias: "number"
+            }
+          }
+        }
+      ],
+      keyword: new RegExp("\\b(?:" + keywords.join("|") + ")\\b", "i"),
+      function: /\b[a-z_]\w*(?=\s*\()/i,
+      number: /[-+]?(?:(?:\b\d+(?:\.\d+)?|\B\.\d+)(?:e[-+]?\d+)?\b|\b(?:0x[0-9a-f]+|nan|inf)\b)/i,
+      operator: /[\^*/%+-]|==|!=|<=|<|>=|>|\b(?:and|or|unless)\b/i,
+      punctuation: /[{};()`,.[\]]/
+    };
+  })(Prism);
+}
+
+export {
+  promql
+};

package/dist/chunk-7ZK3RWTK.mjs

@@ -0,0 +1,30 @@
+import {
+  scheme
+} from "./chunk-OREANV5Y.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/racket.js
+racket.displayName = "racket";
+racket.aliases = ["rkt"];
+function racket(Prism) {
+  Prism.register(scheme);
+  Prism.languages.racket = Prism.languages.extend("scheme", {
+    "lambda-parameter": {
+      // the racket lambda syntax is a lot more complex, so we won't even attempt to capture it.
+      // this will just prevent false positives of the `function` pattern
+      pattern: /([(\[]lambda\s+[(\[])[^()\[\]'\s]+/,
+      lookbehind: true
+    }
+  });
+  Prism.languages.insertBefore("racket", "string", {
+    lang: {
+      pattern: /^#lang.+/m,
+      greedy: true,
+      alias: "keyword"
+    }
+  });
+  Prism.languages.rkt = Prism.languages.racket;
+}
+
+export {
+  racket
+};

package/dist/chunk-A434KIVF.mjs

@@ -0,0 +1,36 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/bro.js
+bro.displayName = "bro";
+bro.aliases = [];
+function bro(Prism) {
+  Prism.languages.bro = {
+    comment: {
+      pattern: /(^|[^\\$])#.*/,
+      lookbehind: true,
+      inside: {
+        italic: /\b(?:FIXME|TODO|XXX)\b/
+      }
+    },
+    string: {
+      pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+      greedy: true
+    },
+    boolean: /\b[TF]\b/,
+    function: {
+      pattern: /(\b(?:event|function|hook)[ \t]+)\w+(?:::\w+)?/,
+      lookbehind: true
+    },
+    builtin: /(?:@(?:load(?:-(?:plugin|sigs))?|unload|prefixes|ifn?def|else|(?:end)?if|DIR|FILENAME))|(?:&?(?:add_func|create_expire|default|delete_func|encrypt|error_handler|expire_func|group|log|mergeable|optional|persistent|priority|raw_output|read_expire|redef|rotate_interval|rotate_size|synchronized|type_column|write_expire))/,
+    constant: {
+      pattern: /(\bconst[ \t]+)\w+/i,
+      lookbehind: true
+    },
+    keyword: /\b(?:add|addr|alarm|any|bool|break|const|continue|count|delete|double|else|enum|event|export|file|for|function|global|hook|if|in|int|interval|local|module|next|of|opaque|pattern|port|print|record|return|schedule|set|string|subnet|table|time|timeout|using|vector|when)\b/,
+    operator: /--?|\+\+?|!=?=?|<=?|>=?|==?=?|&&|\|\|?|\?|\*|\/|~|\^|%/,
+    number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
+    punctuation: /[{}[\];(),.:]/
+  };
+}
+
+export {
+  bro
+};

package/dist/chunk-ACDTS7FW.mjs

@@ -0,0 +1,192 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/markup.js
+markup.displayName = "markup";
+markup.aliases = ["atom", "html", "mathml", "rss", "ssml", "svg", "xml"];
+function markup(Prism) {
+  Prism.languages.markup = {
+    comment: {
+      pattern: /<!--(?:(?!<!--)[\s\S])*?-->/,
+      greedy: true
+    },
+    prolog: {
+      pattern: /<\?[\s\S]+?\?>/,
+      greedy: true
+    },
+    doctype: {
+      // https://www.w3.org/TR/xml/#NT-doctypedecl
+      pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
+      greedy: true,
+      inside: {
+        "internal-subset": {
+          pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/,
+          lookbehind: true,
+          greedy: true,
+          inside: null
+          // see below
+        },
+        string: {
+          pattern: /"[^"]*"|'[^']*'/,
+          greedy: true
+        },
+        punctuation: /^<!|>$|[[\]]/,
+        "doctype-tag": /^DOCTYPE/i,
+        name: /[^\s<>'"]+/
+      }
+    },
+    cdata: {
+      pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+      greedy: true
+    },
+    tag: {
+      pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
+      greedy: true,
+      inside: {
+        tag: {
+          pattern: /^<\/?[^\s>\/]+/,
+          inside: {
+            punctuation: /^<\/?/,
+            namespace: /^[^\s>\/:]+:/
+          }
+        },
+        "special-attr": [],
+        "attr-value": {
+          pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
+          inside: {
+            punctuation: [
+              {
+                pattern: /^=/,
+                alias: "attr-equals"
+              },
+              {
+                pattern: /^(\s*)["']|["']$/,
+                lookbehind: true
+              }
+            ]
+          }
+        },
+        punctuation: /\/?>/,
+        "attr-name": {
+          pattern: /[^\s>\/]+/,
+          inside: {
+            namespace: /^[^\s>\/:]+:/
+          }
+        }
+      }
+    },
+    entity: [
+      {
+        pattern: /&[\da-z]{1,8};/i,
+        alias: "named-entity"
+      },
+      /&#x?[\da-f]{1,8};/i
+    ]
+  };
+  Prism.languages.markup["tag"].inside["attr-value"].inside["entity"] = Prism.languages.markup["entity"];
+  Prism.languages.markup["doctype"].inside["internal-subset"].inside = Prism.languages.markup;
+  Prism.hooks.add("wrap", function(env) {
+    if (env.type === "entity") {
+      env.attributes["title"] = env.content.value.replace(/&amp;/, "&");
+    }
+  });
+  Object.defineProperty(Prism.languages.markup.tag, "addInlined", {
+    /**
+     * Adds an inlined language to markup.
+     *
+     * An example of an inlined language is CSS with `<style>` tags.
+     *
+     * @param {string} tagName The name of the tag that contains the inlined language. This name will be treated as
+     * case insensitive.
+     * @param {string} lang The language key.
+     * @example
+     * addInlined('style', 'css');
+     */
+    value: function addInlined(tagName, lang) {
+      var includedCdataInside = {};
+      includedCdataInside["language-" + lang] = {
+        pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
+        lookbehind: true,
+        inside: Prism.languages[lang]
+      };
+      includedCdataInside["cdata"] = /^<!\[CDATA\[|\]\]>$/i;
+      var inside = {
+        "included-cdata": {
+          pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+          inside: includedCdataInside
+        }
+      };
+      inside["language-" + lang] = {
+        pattern: /[\s\S]+/,
+        inside: Prism.languages[lang]
+      };
+      var def = {};
+      def[tagName] = {
+        pattern: RegExp(
+          /(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(
+            /__/g,
+            function() {
+              return tagName;
+            }
+          ),
+          "i"
+        ),
+        lookbehind: true,
+        greedy: true,
+        inside
+      };
+      Prism.languages.insertBefore("markup", "cdata", def);
+    }
+  });
+  Object.defineProperty(Prism.languages.markup.tag, "addAttribute", {
+    /**
+     * Adds an pattern to highlight languages embedded in HTML attributes.
+     *
+     * An example of an inlined language is CSS with `style` attributes.
+     *
+     * @param {string} attrName The name of the tag that contains the inlined language. This name will be treated as
+     * case insensitive.
+     * @param {string} lang The language key.
+     * @example
+     * addAttribute('style', 'css');
+     */
+    value: function(attrName, lang) {
+      Prism.languages.markup.tag.inside["special-attr"].push({
+        pattern: RegExp(
+          /(^|["'\s])/.source + "(?:" + attrName + ")" + /\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))/.source,
+          "i"
+        ),
+        lookbehind: true,
+        inside: {
+          "attr-name": /^[^\s=]+/,
+          "attr-value": {
+            pattern: /=[\s\S]+/,
+            inside: {
+              value: {
+                pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
+                lookbehind: true,
+                alias: [lang, "language-" + lang],
+                inside: Prism.languages[lang]
+              },
+              punctuation: [
+                {
+                  pattern: /^=/,
+                  alias: "attr-equals"
+                },
+                /"|'/
+              ]
+            }
+          }
+        }
+      });
+    }
+  });
+  Prism.languages.html = Prism.languages.markup;
+  Prism.languages.mathml = Prism.languages.markup;
+  Prism.languages.svg = Prism.languages.markup;
+  Prism.languages.xml = Prism.languages.extend("markup", {});
+  Prism.languages.ssml = Prism.languages.xml;
+  Prism.languages.atom = Prism.languages.xml;
+  Prism.languages.rss = Prism.languages.xml;
+}
+
+export {
+  markup
+};

package/dist/chunk-AEMXR762.mjs

@@ -0,0 +1,38 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/rip.js
+rip.displayName = "rip";
+rip.aliases = [];
+function rip(Prism) {
+  Prism.languages.rip = {
+    comment: {
+      pattern: /#.*/,
+      greedy: true
+    },
+    char: {
+      pattern: /\B`[^\s`'",.:;#\/\\()<>\[\]{}]\b/,
+      greedy: true
+    },
+    string: {
+      pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+      greedy: true
+    },
+    regex: {
+      pattern: /(^|[^/])\/(?!\/)(?:\[[^\n\r\]]*\]|\\.|[^/\\\r\n\[])+\/(?=\s*(?:$|[\r\n,.;})]))/,
+      lookbehind: true,
+      greedy: true
+    },
+    keyword: /(?:=>|->)|\b(?:case|catch|class|else|exit|finally|if|raise|return|switch|try)\b/,
+    builtin: /@|\bSystem\b/,
+    boolean: /\b(?:false|true)\b/,
+    date: /\b\d{4}-\d{2}-\d{2}\b/,
+    time: /\b\d{2}:\d{2}:\d{2}\b/,
+    datetime: /\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\b/,
+    symbol: /:[^\d\s`'",.:;#\/\\()<>\[\]{}][^\s`'",.:;#\/\\()<>\[\]{}]*/,
+    number: /[+-]?\b(?:\d+\.\d+|\d+)\b/,
+    punctuation: /(?:\.{2,3})|[`,.:;=\/\\()<>\[\]{}]/,
+    reference: /[^\d\s`'",.:;#\/\\()<>\[\]{}][^\s`'",.:;#\/\\()<>\[\]{}]*/
+  };
+}
+
+export {
+  rip
+};

package/dist/chunk-AI7UQ3R6.mjs

@@ -0,0 +1,34 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/json.js
+json.displayName = "json";
+json.aliases = ["webmanifest"];
+function json(Prism) {
+  Prism.languages.json = {
+    property: {
+      pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?=\s*:)/,
+      lookbehind: true,
+      greedy: true
+    },
+    string: {
+      pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?!\s*:)/,
+      lookbehind: true,
+      greedy: true
+    },
+    comment: {
+      pattern: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
+      greedy: true
+    },
+    number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+    punctuation: /[{}[\],]/,
+    operator: /:/,
+    boolean: /\b(?:false|true)\b/,
+    null: {
+      pattern: /\bnull\b/,
+      alias: "keyword"
+    }
+  };
+  Prism.languages.webmanifest = Prism.languages.json;
+}
+
+export {
+  json
+};

package/dist/chunk-AKENKTU2.mjs

@@ -0,0 +1,146 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/stylus.js
+stylus.displayName = "stylus";
+stylus.aliases = [];
+function stylus(Prism) {
+  ;
+  (function(Prism2) {
+    var unit = {
+      pattern: /(\b\d+)(?:%|[a-z]+)/,
+      lookbehind: true
+    };
+    var number = {
+      pattern: /(^|[^\w.-])-?(?:\d+(?:\.\d+)?|\.\d+)/,
+      lookbehind: true
+    };
+    var inside = {
+      comment: {
+        pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/,
+        lookbehind: true
+      },
+      url: {
+        pattern: /\burl\((["']?).*?\1\)/i,
+        greedy: true
+      },
+      string: {
+        pattern: /("|')(?:(?!\1)[^\\\r\n]|\\(?:\r\n|[\s\S]))*\1/,
+        greedy: true
+      },
+      interpolation: null,
+      // See below
+      func: null,
+      // See below
+      important: /\B!(?:important|optional)\b/i,
+      keyword: {
+        pattern: /(^|\s+)(?:(?:else|for|if|return|unless)(?=\s|$)|@[\w-]+)/,
+        lookbehind: true
+      },
+      hexcode: /#[\da-f]{3,6}/i,
+      color: [
+        /\b(?:AliceBlue|AntiqueWhite|Aqua|Aquamarine|Azure|Beige|Bisque|Black|BlanchedAlmond|Blue|BlueViolet|Brown|BurlyWood|CadetBlue|Chartreuse|Chocolate|Coral|CornflowerBlue|Cornsilk|Crimson|Cyan|DarkBlue|DarkCyan|DarkGoldenRod|DarkGr[ae]y|DarkGreen|DarkKhaki|DarkMagenta|DarkOliveGreen|DarkOrange|DarkOrchid|DarkRed|DarkSalmon|DarkSeaGreen|DarkSlateBlue|DarkSlateGr[ae]y|DarkTurquoise|DarkViolet|DeepPink|DeepSkyBlue|DimGr[ae]y|DodgerBlue|FireBrick|FloralWhite|ForestGreen|Fuchsia|Gainsboro|GhostWhite|Gold|GoldenRod|Gr[ae]y|Green|GreenYellow|HoneyDew|HotPink|IndianRed|Indigo|Ivory|Khaki|Lavender|LavenderBlush|LawnGreen|LemonChiffon|LightBlue|LightCoral|LightCyan|LightGoldenRodYellow|LightGr[ae]y|LightGreen|LightPink|LightSalmon|LightSeaGreen|LightSkyBlue|LightSlateGr[ae]y|LightSteelBlue|LightYellow|Lime|LimeGreen|Linen|Magenta|Maroon|MediumAquaMarine|MediumBlue|MediumOrchid|MediumPurple|MediumSeaGreen|MediumSlateBlue|MediumSpringGreen|MediumTurquoise|MediumVioletRed|MidnightBlue|MintCream|MistyRose|Moccasin|NavajoWhite|Navy|OldLace|Olive|OliveDrab|Orange|OrangeRed|Orchid|PaleGoldenRod|PaleGreen|PaleTurquoise|PaleVioletRed|PapayaWhip|PeachPuff|Peru|Pink|Plum|PowderBlue|Purple|Red|RosyBrown|RoyalBlue|SaddleBrown|Salmon|SandyBrown|SeaGreen|SeaShell|Sienna|Silver|SkyBlue|SlateBlue|SlateGr[ae]y|Snow|SpringGreen|SteelBlue|Tan|Teal|Thistle|Tomato|Transparent|Turquoise|Violet|Wheat|White|WhiteSmoke|Yellow|YellowGreen)\b/i,
+        {
+          pattern: /\b(?:hsl|rgb)\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*\)\B|\b(?:hsl|rgb)a\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*,\s*(?:0|0?\.\d+|1)\s*\)\B/i,
+          inside: {
+            unit,
+            number,
+            function: /[\w-]+(?=\()/,
+            punctuation: /[(),]/
+          }
+        }
+      ],
+      entity: /\\[\da-f]{1,8}/i,
+      unit,
+      boolean: /\b(?:false|true)\b/,
+      operator: [
+        // We want non-word chars around "-" because it is
+        // accepted in property names.
+        /~|[+!\/%<>?=]=?|[-:]=|\*[*=]?|\.{2,3}|&&|\|\||\B-\B|\b(?:and|in|is(?: a| defined| not|nt)?|not|or)\b/
+      ],
+      number,
+      punctuation: /[{}()\[\];:,]/
+    };
+    inside["interpolation"] = {
+      pattern: /\{[^\r\n}:]+\}/,
+      alias: "variable",
+      inside: {
+        delimiter: {
+          pattern: /^\{|\}$/,
+          alias: "punctuation"
+        },
+        rest: inside
+      }
+    };
+    inside["func"] = {
+      pattern: /[\w-]+\([^)]*\).*/,
+      inside: {
+        function: /^[^(]+/,
+        rest: inside
+      }
+    };
+    Prism2.languages.stylus = {
+      "atrule-declaration": {
+        pattern: /(^[ \t]*)@.+/m,
+        lookbehind: true,
+        inside: {
+          atrule: /^@[\w-]+/,
+          rest: inside
+        }
+      },
+      "variable-declaration": {
+        pattern: /(^[ \t]*)[\w$-]+\s*.?=[ \t]*(?:\{[^{}]*\}|\S.*|$)/m,
+        lookbehind: true,
+        inside: {
+          variable: /^\S+/,
+          rest: inside
+        }
+      },
+      statement: {
+        pattern: /(^[ \t]*)(?:else|for|if|return|unless)[ \t].+/m,
+        lookbehind: true,
+        inside: {
+          keyword: /^\S+/,
+          rest: inside
+        }
+      },
+      // A property/value pair cannot end with a comma or a brace
+      // It cannot have indented content unless it ended with a semicolon
+      "property-declaration": {
+        pattern: /((?:^|\{)([ \t]*))(?:[\w-]|\{[^}\r\n]+\})+(?:\s*:\s*|[ \t]+)(?!\s)[^{\r\n]*(?:;|[^{\r\n,]$(?!(?:\r?\n|\r)(?:\{|\2[ \t])))/m,
+        lookbehind: true,
+        inside: {
+          property: {
+            pattern: /^[^\s:]+/,
+            inside: {
+              interpolation: inside.interpolation
+            }
+          },
+          rest: inside
+        }
+      },
+      // A selector can contain parentheses only as part of a pseudo-element
+      // It can span multiple lines.
+      // It must end with a comma or an accolade or have indented content.
+      selector: {
+        pattern: /(^[ \t]*)(?:(?=\S)(?:[^{}\r\n:()]|::?[\w-]+(?:\([^)\r\n]*\)|(?![\w-]))|\{[^}\r\n]+\})+)(?:(?:\r?\n|\r)(?:\1(?:(?=\S)(?:[^{}\r\n:()]|::?[\w-]+(?:\([^)\r\n]*\)|(?![\w-]))|\{[^}\r\n]+\})+)))*(?:,$|\{|(?=(?:\r?\n|\r)(?:\{|\1[ \t])))/m,
+        lookbehind: true,
+        inside: {
+          interpolation: inside.interpolation,
+          comment: inside.comment,
+          punctuation: /[{},]/
+        }
+      },
+      func: inside.func,
+      string: inside.string,
+      comment: {
+        pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/,
+        lookbehind: true,
+        greedy: true
+      },
+      interpolation: inside.interpolation,
+      punctuation: /[{}()\[\];:.]/
+    };
+  })(Prism);
+}
+
+export {
+  stylus
+};

package/dist/chunk-ATBA76CY.mjs

@@ -0,0 +1,26 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/basic.js
+basic.displayName = "basic";
+basic.aliases = [];
+function basic(Prism) {
+  Prism.languages.basic = {
+    comment: {
+      pattern: /(?:!|REM\b).+/i,
+      inside: {
+        keyword: /^REM/i
+      }
+    },
+    string: {
+      pattern: /"(?:""|[!#$%&'()*,\/:;<=>?^\w +\-.])*"/,
+      greedy: true
+    },
+    number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:E[+-]?\d+)?/i,
+    keyword: /\b(?:AS|BEEP|BLOAD|BSAVE|CALL(?: ABSOLUTE)?|CASE|CHAIN|CHDIR|CLEAR|CLOSE|CLS|COM|COMMON|CONST|DATA|DECLARE|DEF(?: FN| SEG|DBL|INT|LNG|SNG|STR)|DIM|DO|DOUBLE|ELSE|ELSEIF|END|ENVIRON|ERASE|ERROR|EXIT|FIELD|FILES|FOR|FUNCTION|GET|GOSUB|GOTO|IF|INPUT|INTEGER|IOCTL|KEY|KILL|LINE INPUT|LOCATE|LOCK|LONG|LOOP|LSET|MKDIR|NAME|NEXT|OFF|ON(?: COM| ERROR| KEY| TIMER)?|OPEN|OPTION BASE|OUT|POKE|PUT|READ|REDIM|REM|RESTORE|RESUME|RETURN|RMDIR|RSET|RUN|SELECT CASE|SHARED|SHELL|SINGLE|SLEEP|STATIC|STEP|STOP|STRING|SUB|SWAP|SYSTEM|THEN|TIMER|TO|TROFF|TRON|TYPE|UNLOCK|UNTIL|USING|VIEW PRINT|WAIT|WEND|WHILE|WRITE)(?:\$|\b)/i,
+    function: /\b(?:ABS|ACCESS|ACOS|ANGLE|AREA|ARITHMETIC|ARRAY|ASIN|ASK|AT|ATN|BASE|BEGIN|BREAK|CAUSE|CEIL|CHR|CLIP|COLLATE|COLOR|CON|COS|COSH|COT|CSC|DATE|DATUM|DEBUG|DECIMAL|DEF|DEG|DEGREES|DELETE|DET|DEVICE|DISPLAY|DOT|ELAPSED|EPS|ERASABLE|EXLINE|EXP|EXTERNAL|EXTYPE|FILETYPE|FIXED|FP|GO|GRAPH|HANDLER|IDN|IMAGE|IN|INT|INTERNAL|IP|IS|KEYED|LBOUND|LCASE|LEFT|LEN|LENGTH|LET|LINE|LINES|LOG|LOG10|LOG2|LTRIM|MARGIN|MAT|MAX|MAXNUM|MID|MIN|MISSING|MOD|NATIVE|NUL|NUMERIC|OF|OPTION|ORD|ORGANIZATION|OUTIN|OUTPUT|PI|POINT|POINTER|POINTS|POS|PRINT|PROGRAM|PROMPT|RAD|RADIANS|RANDOMIZE|RECORD|RECSIZE|RECTYPE|RELATIVE|REMAINDER|REPEAT|REST|RETRY|REWRITE|RIGHT|RND|ROUND|RTRIM|SAME|SEC|SELECT|SEQUENTIAL|SET|SETTER|SGN|SIN|SINH|SIZE|SKIP|SQR|STANDARD|STATUS|STR|STREAM|STYLE|TAB|TAN|TANH|TEMPLATE|TEXT|THERE|TIME|TIMEOUT|TRACE|TRANSFORM|TRUNCATE|UBOUND|UCASE|USE|VAL|VARIABLE|VIEWPORT|WHEN|WINDOW|WITH|ZER|ZONEWIDTH)(?:\$|\b)/i,
+    operator: /<[=>]?|>=?|[+\-*\/^=&]|\b(?:AND|EQV|IMP|NOT|OR|XOR)\b/i,
+    punctuation: /[,;:()]/
+  };
+}
+
+export {
+  basic
+};

package/dist/chunk-BAH7KB65.mjs

@@ -0,0 +1,22 @@
+import {
+  cpp
+} from "./chunk-BCCX6KVT.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/cilkcpp.js
+cilkcpp.displayName = "cilkcpp";
+cilkcpp.aliases = ["cilk", "cilk-cpp"];
+function cilkcpp(Prism) {
+  Prism.register(cpp);
+  Prism.languages.cilkcpp = Prism.languages.insertBefore("cpp", "function", {
+    "parallel-keyword": {
+      pattern: /\bcilk_(?:for|reducer|s(?:cope|pawn|ync))\b/,
+      alias: "keyword"
+    }
+  });
+  Prism.languages["cilk-cpp"] = Prism.languages["cilkcpp"];
+  Prism.languages["cilk"] = Prism.languages["cilkcpp"];
+}
+
+export {
+  cilkcpp
+};