@photonix/basic 2.3.0 → 3.0.0

package/dist/chunk-7WPXI5M5.mjs

@@ -1,100 +0,0 @@
-// ../../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

@@ -1,30 +0,0 @@
-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

@@ -1,36 +0,0 @@
-// ../../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

@@ -1,192 +0,0 @@
-// ../../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

@@ -1,38 +0,0 @@
-// ../../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

@@ -1,34 +0,0 @@
-// ../../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

@@ -1,146 +0,0 @@
-// ../../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

@@ -1,26 +0,0 @@
-// ../../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

@@ -1,22 +0,0 @@
-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
-};