@photonix/basic 1.5.1 → 1.6.1

package/dist/chunk-RCZFHDWV.mjs

@@ -0,0 +1,82 @@
+import {
+  markup
+} from "./chunk-ACDTS7FW.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/velocity.js
+velocity.displayName = "velocity";
+velocity.aliases = [];
+function velocity(Prism) {
+  Prism.register(markup);
+  (function(Prism2) {
+    Prism2.languages.velocity = Prism2.languages.extend("markup", {});
+    var velocity2 = {
+      variable: {
+        pattern: /(^|[^\\](?:\\\\)*)\$!?(?:[a-z][\w-]*(?:\([^)]*\))?(?:\.[a-z][\w-]*(?:\([^)]*\))?|\[[^\]]+\])*|\{[^}]+\})/i,
+        lookbehind: true,
+        inside: {}
+        // See below
+      },
+      string: {
+        pattern: /"[^"]*"|'[^']*'/,
+        greedy: true
+      },
+      number: /\b\d+\b/,
+      boolean: /\b(?:false|true)\b/,
+      operator: /[=!<>]=?|[+*/%-]|&&|\|\||\.\.|\b(?:eq|g[et]|l[et]|n(?:e|ot))\b/,
+      punctuation: /[(){}[\]:,.]/
+    };
+    velocity2.variable.inside = {
+      string: velocity2["string"],
+      function: {
+        pattern: /([^\w-])[a-z][\w-]*(?=\()/,
+        lookbehind: true
+      },
+      number: velocity2["number"],
+      boolean: velocity2["boolean"],
+      punctuation: velocity2["punctuation"]
+    };
+    Prism2.languages.insertBefore("velocity", "comment", {
+      unparsed: {
+        pattern: /(^|[^\\])#\[\[[\s\S]*?\]\]#/,
+        lookbehind: true,
+        greedy: true,
+        inside: {
+          punctuation: /^#\[\[|\]\]#$/
+        }
+      },
+      "velocity-comment": [
+        {
+          pattern: /(^|[^\\])#\*[\s\S]*?\*#/,
+          lookbehind: true,
+          greedy: true,
+          alias: "comment"
+        },
+        {
+          pattern: /(^|[^\\])##.*/,
+          lookbehind: true,
+          greedy: true,
+          alias: "comment"
+        }
+      ],
+      directive: {
+        pattern: /(^|[^\\](?:\\\\)*)#@?(?:[a-z][\w-]*|\{[a-z][\w-]*\})(?:\s*\((?:[^()]|\([^()]*\))*\))?/i,
+        lookbehind: true,
+        inside: {
+          keyword: {
+            pattern: /^#@?(?:[a-z][\w-]*|\{[a-z][\w-]*\})|\bin\b/,
+            inside: {
+              punctuation: /[{}]/
+            }
+          },
+          rest: velocity2
+        }
+      },
+      variable: velocity2["variable"]
+    });
+    Prism2.languages.velocity["tag"].inside["attr-value"].inside.rest = Prism2.languages.velocity;
+  })(Prism);
+}
+
+export {
+  velocity
+};

package/dist/chunk-RECTN3PY.mjs

@@ -0,0 +1,37 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/bbcode.js
+bbcode.displayName = "bbcode";
+bbcode.aliases = ["shortcode"];
+function bbcode(Prism) {
+  Prism.languages.bbcode = {
+    tag: {
+      pattern: /\[\/?[^\s=\]]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'"\]=]+))?(?:\s+[^\s=\]]+\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'"\]=]+))*\s*\]/,
+      inside: {
+        tag: {
+          pattern: /^\[\/?[^\s=\]]+/,
+          inside: {
+            punctuation: /^\[\/?/
+          }
+        },
+        "attr-value": {
+          pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'"\]=]+)/,
+          inside: {
+            punctuation: [
+              /^=/,
+              {
+                pattern: /^(\s*)["']|["']$/,
+                lookbehind: true
+              }
+            ]
+          }
+        },
+        punctuation: /\]/,
+        "attr-name": /[^\s=\]]+/
+      }
+    }
+  };
+  Prism.languages.shortcode = Prism.languages.bbcode;
+}
+
+export {
+  bbcode
+};

package/dist/chunk-RQHEOH4E.mjs

@@ -0,0 +1,131 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/rust.js
+rust.displayName = "rust";
+rust.aliases = [];
+function rust(Prism) {
+  ;
+  (function(Prism2) {
+    var multilineComment = /\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|<self>)*\*\//.source;
+    for (var i = 0; i < 2; i++) {
+      multilineComment = multilineComment.replace(/<self>/g, function() {
+        return multilineComment;
+      });
+    }
+    multilineComment = multilineComment.replace(/<self>/g, function() {
+      return /[^\s\S]/.source;
+    });
+    Prism2.languages.rust = {
+      comment: [
+        {
+          pattern: RegExp(/(^|[^\\])/.source + multilineComment),
+          lookbehind: true,
+          greedy: true
+        },
+        {
+          pattern: /(^|[^\\:])\/\/.*/,
+          lookbehind: true,
+          greedy: true
+        }
+      ],
+      string: {
+        pattern: /b?"(?:\\[\s\S]|[^\\"])*"|b?r(#*)"(?:[^"]|"(?!\1))*"\1/,
+        greedy: true
+      },
+      char: {
+        pattern: /b?'(?:\\(?:x[0-7][\da-fA-F]|u\{(?:[\da-fA-F]_*){1,6}\}|.)|[^\\\r\n\t'])'/,
+        greedy: true
+      },
+      attribute: {
+        pattern: /#!?\[(?:[^\[\]"]|"(?:\\[\s\S]|[^\\"])*")*\]/,
+        greedy: true,
+        alias: "attr-name",
+        inside: {
+          string: null
+          // see below
+        }
+      },
+      // Closure params should not be confused with bitwise OR |
+      "closure-params": {
+        pattern: /([=(,:]\s*|\bmove\s*)\|[^|]*\||\|[^|]*\|(?=\s*(?:\{|->))/,
+        lookbehind: true,
+        greedy: true,
+        inside: {
+          "closure-punctuation": {
+            pattern: /^\||\|$/,
+            alias: "punctuation"
+          },
+          rest: null
+          // see below
+        }
+      },
+      "lifetime-annotation": {
+        pattern: /'\w+/,
+        alias: "symbol"
+      },
+      "fragment-specifier": {
+        pattern: /(\$\w+:)[a-z]+/,
+        lookbehind: true,
+        alias: "punctuation"
+      },
+      variable: /\$\w+/,
+      "function-definition": {
+        pattern: /(\bfn\s+)\w+/,
+        lookbehind: true,
+        alias: "function"
+      },
+      "type-definition": {
+        pattern: /(\b(?:enum|struct|trait|type|union)\s+)\w+/,
+        lookbehind: true,
+        alias: "class-name"
+      },
+      "module-declaration": [
+        {
+          pattern: /(\b(?:crate|mod)\s+)[a-z][a-z_\d]*/,
+          lookbehind: true,
+          alias: "namespace"
+        },
+        {
+          pattern: /(\b(?:crate|self|super)\s*)::\s*[a-z][a-z_\d]*\b(?:\s*::(?:\s*[a-z][a-z_\d]*\s*::)*)?/,
+          lookbehind: true,
+          alias: "namespace",
+          inside: {
+            punctuation: /::/
+          }
+        }
+      ],
+      keyword: [
+        // https://github.com/rust-lang/reference/blob/master/src/keywords.md
+        /\b(?:Self|abstract|as|async|await|become|box|break|const|continue|crate|do|dyn|else|enum|extern|final|fn|for|if|impl|in|let|loop|macro|match|mod|move|mut|override|priv|pub|ref|return|self|static|struct|super|trait|try|type|typeof|union|unsafe|unsized|use|virtual|where|while|yield)\b/,
+        // primitives and str
+        // https://doc.rust-lang.org/stable/rust-by-example/primitives.html
+        /\b(?:bool|char|f(?:32|64)|[ui](?:8|16|32|64|128|size)|str)\b/
+      ],
+      // functions can technically start with an upper-case letter, but this will introduce a lot of false positives
+      // and Rust's naming conventions recommend snake_case anyway.
+      // https://doc.rust-lang.org/1.0.0/style/style/naming/README.html
+      function: /\b[a-z_]\w*(?=\s*(?:::\s*<|\())/,
+      macro: {
+        pattern: /\b\w+!/,
+        alias: "property"
+      },
+      constant: /\b[A-Z_][A-Z_\d]+\b/,
+      "class-name": /\b[A-Z]\w*\b/,
+      namespace: {
+        pattern: /(?:\b[a-z][a-z_\d]*\s*::\s*)*\b[a-z][a-z_\d]*\s*::(?!\s*<)/,
+        inside: {
+          punctuation: /::/
+        }
+      },
+      // Hex, oct, bin, dec numbers with visual separators and type suffix
+      number: /\b(?:0x[\dA-Fa-f](?:_?[\dA-Fa-f])*|0o[0-7](?:_?[0-7])*|0b[01](?:_?[01])*|(?:(?:\d(?:_?\d)*)?\.)?\d(?:_?\d)*(?:[Ee][+-]?\d+)?)(?:_?(?:f32|f64|[iu](?:8|16|32|64|size)?))?\b/,
+      boolean: /\b(?:false|true)\b/,
+      punctuation: /->|\.\.=|\.{1,3}|::|[{}[\];(),:]/,
+      operator: /[-+*\/%!^]=?|=[=>]?|&[&=]?|\|[|=]?|<<?=?|>>?=?|[@?]/
+    };
+    Prism2.languages.rust["closure-params"].inside.rest = Prism2.languages.rust;
+    Prism2.languages.rust["attribute"].inside["string"] = Prism2.languages.rust["string"];
+  })(Prism);
+}
+
+export {
+  rust
+};

package/dist/chunk-RT2GPFOP.mjs

@@ -0,0 +1,34 @@
+import {
+  json
+} from "./chunk-AI7UQ3R6.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/json5.js
+json5.displayName = "json5";
+json5.aliases = [];
+function json5(Prism) {
+  Prism.register(json);
+  (function(Prism2) {
+    var string = /("|')(?:\\(?:\r\n?|\n|.)|(?!\1)[^\\\r\n])*\1/;
+    Prism2.languages.json5 = Prism2.languages.extend("json", {
+      property: [
+        {
+          pattern: RegExp(string.source + "(?=\\s*:)"),
+          greedy: true
+        },
+        {
+          pattern: /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/,
+          alias: "unquoted"
+        }
+      ],
+      string: {
+        pattern: string,
+        greedy: true
+      },
+      number: /[+-]?\b(?:NaN|Infinity|0x[a-fA-F\d]+)\b|[+-]?(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[eE][+-]?\d+\b)?/
+    });
+  })(Prism);
+}
+
+export {
+  json5
+};

package/dist/chunk-RTHH6L2P.mjs

@@ -0,0 +1,28 @@
+import {
+  php
+} from "./chunk-4PP7IENX.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/php-extras.js
+phpExtras.displayName = "php-extras";
+phpExtras.aliases = [];
+function phpExtras(Prism) {
+  Prism.register(php);
+  Prism.languages.insertBefore("php", "variable", {
+    this: {
+      pattern: /\$this\b/,
+      alias: "keyword"
+    },
+    global: /\$(?:GLOBALS|HTTP_RAW_POST_DATA|_(?:COOKIE|ENV|FILES|GET|POST|REQUEST|SERVER|SESSION)|argc|argv|http_response_header|php_errormsg)\b/,
+    scope: {
+      pattern: /\b[\w\\]+::/,
+      inside: {
+        keyword: /\b(?:parent|self|static)\b/,
+        punctuation: /::|\\/
+      }
+    }
+  });
+}
+
+export {
+  phpExtras
+};

package/dist/chunk-RU3WBR6C.mjs

@@ -0,0 +1,107 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/regex.js
+regex.displayName = "regex";
+regex.aliases = [];
+function regex(Prism) {
+  ;
+  (function(Prism2) {
+    var specialEscape = {
+      pattern: /\\[\\(){}[\]^$+*?|.]/,
+      alias: "escape"
+    };
+    var escape = /\\(?:x[\da-fA-F]{2}|u[\da-fA-F]{4}|u\{[\da-fA-F]+\}|0[0-7]{0,2}|[123][0-7]{2}|c[a-zA-Z]|.)/;
+    var charSet = {
+      pattern: /\.|\\[wsd]|\\p\{[^{}]+\}/i,
+      alias: "class-name"
+    };
+    var charSetWithoutDot = {
+      pattern: /\\[wsd]|\\p\{[^{}]+\}/i,
+      alias: "class-name"
+    };
+    var rangeChar = "(?:[^\\\\-]|" + escape.source + ")";
+    var range = RegExp(rangeChar + "-" + rangeChar);
+    var groupName = {
+      pattern: /(<|')[^<>']+(?=[>']$)/,
+      lookbehind: true,
+      alias: "variable"
+    };
+    Prism2.languages.regex = {
+      "char-class": {
+        pattern: /((?:^|[^\\])(?:\\\\)*)\[(?:[^\\\]]|\\[\s\S])*\]/,
+        lookbehind: true,
+        inside: {
+          "char-class-negation": {
+            pattern: /(^\[)\^/,
+            lookbehind: true,
+            alias: "operator"
+          },
+          "char-class-punctuation": {
+            pattern: /^\[|\]$/,
+            alias: "punctuation"
+          },
+          range: {
+            pattern: range,
+            inside: {
+              escape,
+              "range-punctuation": {
+                pattern: /-/,
+                alias: "operator"
+              }
+            }
+          },
+          "special-escape": specialEscape,
+          "char-set": charSetWithoutDot,
+          escape
+        }
+      },
+      "special-escape": specialEscape,
+      "char-set": charSet,
+      backreference: [
+        {
+          // a backreference which is not an octal escape
+          pattern: /\\(?![123][0-7]{2})[1-9]/,
+          alias: "keyword"
+        },
+        {
+          pattern: /\\k<[^<>']+>/,
+          alias: "keyword",
+          inside: {
+            "group-name": groupName
+          }
+        }
+      ],
+      anchor: {
+        pattern: /[$^]|\\[ABbGZz]/,
+        alias: "function"
+      },
+      escape,
+      group: [
+        {
+          // https://docs.oracle.com/javase/10/docs/api/java/util/regex/Pattern.html
+          // https://docs.microsoft.com/en-us/dotnet/standard/base-types/regular-expression-language-quick-reference?view=netframework-4.7.2#grouping-constructs
+          // (), (?<name>), (?'name'), (?>), (?:), (?=), (?!), (?<=), (?<!), (?is-m), (?i-m:)
+          pattern: /\((?:\?(?:<[^<>']+>|'[^<>']+'|[>:]|<?[=!]|[idmnsuxU]+(?:-[idmnsuxU]+)?:?))?/,
+          alias: "punctuation",
+          inside: {
+            "group-name": groupName
+          }
+        },
+        {
+          pattern: /\)/,
+          alias: "punctuation"
+        }
+      ],
+      quantifier: {
+        pattern: /(?:[+*?]|\{\d+(?:,\d*)?\})[?+]?/,
+        alias: "number"
+      },
+      alternation: {
+        pattern: /\|/,
+        alias: "keyword"
+      }
+    };
+  })(Prism);
+}
+
+export {
+  regex
+};

package/dist/chunk-RY2GIWN4.mjs

@@ -0,0 +1,48 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/unrealscript.js
+unrealscript.displayName = "unrealscript";
+unrealscript.aliases = ["uc", "uscript"];
+function unrealscript(Prism) {
+  Prism.languages.unrealscript = {
+    comment: /\/\/.*|\/\*[\s\S]*?\*\//,
+    string: {
+      pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+      greedy: true
+    },
+    category: {
+      pattern: /(\b(?:(?:autoexpand|hide|show)categories|var)\s*\()[^()]+(?=\))/,
+      lookbehind: true,
+      greedy: true,
+      alias: "property"
+    },
+    metadata: {
+      pattern: /(\w\s*)<\s*\w+\s*=[^<>|=\r\n]+(?:\|\s*\w+\s*=[^<>|=\r\n]+)*>/,
+      lookbehind: true,
+      greedy: true,
+      inside: {
+        property: /\b\w+(?=\s*=)/,
+        operator: /=/,
+        punctuation: /[<>|]/
+      }
+    },
+    macro: {
+      pattern: /`\w+/,
+      alias: "property"
+    },
+    "class-name": {
+      pattern: /(\b(?:class|enum|extends|interface|state(?:\(\))?|struct|within)\s+)\w+/,
+      lookbehind: true
+    },
+    keyword: /\b(?:abstract|actor|array|auto|autoexpandcategories|bool|break|byte|case|class|classgroup|client|coerce|collapsecategories|config|const|continue|default|defaultproperties|delegate|dependson|deprecated|do|dontcollapsecategories|editconst|editinlinenew|else|enum|event|exec|export|extends|final|float|for|forcescriptorder|foreach|function|goto|guid|hidecategories|hidedropdown|if|ignores|implements|inherits|input|int|interface|iterator|latent|local|material|name|native|nativereplication|noexport|nontransient|noteditinlinenew|notplaceable|operator|optional|out|pawn|perobjectconfig|perobjectlocalized|placeable|postoperator|preoperator|private|protected|reliable|replication|return|server|showcategories|simulated|singular|state|static|string|struct|structdefault|structdefaultproperties|switch|texture|transient|travel|unreliable|until|var|vector|while|within)\b/,
+    function: /\b[a-z_]\w*(?=\s*\()/i,
+    boolean: /\b(?:false|true)\b/,
+    number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
+    // https://docs.unrealengine.com/udk/Three/UnrealScriptExpressions.html
+    operator: />>|<<|--|\+\+|\*\*|[-+*/~!=<>$@]=?|&&?|\|\|?|\^\^?|[?:%]|\b(?:ClockwiseFrom|Cross|Dot)\b/,
+    punctuation: /[()[\]{};,.]/
+  };
+  Prism.languages.uc = Prism.languages.uscript = Prism.languages.unrealscript;
+}
+
+export {
+  unrealscript
+};

package/dist/chunk-RZO56MQ5.mjs

@@ -0,0 +1,40 @@
+import {
+  clike
+} from "./chunk-XWTEQUC3.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/go.js
+go.displayName = "go";
+go.aliases = [];
+function go(Prism) {
+  Prism.register(clike);
+  Prism.languages.go = Prism.languages.extend("clike", {
+    string: {
+      pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"|`[^`]*`/,
+      lookbehind: true,
+      greedy: true
+    },
+    keyword: /\b(?:break|case|chan|const|continue|default|defer|else|fallthrough|for|func|go(?:to)?|if|import|interface|map|package|range|return|select|struct|switch|type|var)\b/,
+    boolean: /\b(?:_|false|iota|nil|true)\b/,
+    number: [
+      // binary and octal integers
+      /\b0(?:b[01_]+|o[0-7_]+)i?\b/i,
+      // hexadecimal integers and floats
+      /\b0x(?:[a-f\d_]+(?:\.[a-f\d_]*)?|\.[a-f\d_]+)(?:p[+-]?\d+(?:_\d+)*)?i?(?!\w)/i,
+      // decimal integers and floats
+      /(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?[\d_]+)?i?(?!\w)/i
+    ],
+    operator: /[*\/%^!=]=?|\+[=+]?|-[=-]?|\|[=|]?|&(?:=|&|\^=?)?|>(?:>=?|=)?|<(?:<=?|=|-)?|:=|\.\.\./,
+    builtin: /\b(?:append|bool|byte|cap|close|complex|complex(?:64|128)|copy|delete|error|float(?:32|64)|u?int(?:8|16|32|64)?|imag|len|make|new|panic|print(?:ln)?|real|recover|rune|string|uintptr)\b/
+  });
+  Prism.languages.insertBefore("go", "string", {
+    char: {
+      pattern: /'(?:\\.|[^'\\\r\n]){0,10}'/,
+      greedy: true
+    }
+  });
+  delete Prism.languages.go["class-name"];
+}
+
+export {
+  go
+};

package/dist/chunk-RZPDZII4.mjs

@@ -0,0 +1,91 @@
+import {
+  css
+} from "./chunk-4RG7ZGOZ.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/scss.js
+scss.displayName = "scss";
+scss.aliases = [];
+function scss(Prism) {
+  Prism.register(css);
+  Prism.languages.scss = Prism.languages.extend("css", {
+    comment: {
+      pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/,
+      lookbehind: true
+    },
+    atrule: {
+      pattern: /@[\w-](?:\([^()]+\)|[^()\s]|\s+(?!\s))*?(?=\s+[{;])/,
+      inside: {
+        rule: /@[\w-]+/
+        // See rest below
+      }
+    },
+    // url, compassified
+    url: /(?:[-a-z]+-)?url(?=\()/i,
+    // CSS selector regex is not appropriate for Sass
+    // since there can be lot more things (var, @ directive, nesting..)
+    // a selector must start at the end of a property or after a brace (end of other rules or nesting)
+    // it can contain some characters that aren't used for defining rules or end of selector, & (parent selector), or interpolated variable
+    // the end of a selector is found when there is no rules in it ( {} or {\s}) or if there is a property (because an interpolated var
+    // can "pass" as a selector- e.g: proper#{$erty})
+    // this one was hard to do, so please be careful if you edit this one :)
+    selector: {
+      // Initial look-ahead is used to prevent matching of blank selectors
+      pattern: /(?=\S)[^@;{}()]?(?:[^@;{}()\s]|\s+(?!\s)|#\{\$[-\w]+\})+(?=\s*\{(?:\}|\s|[^}][^:{}]*[:{][^}]))/,
+      inside: {
+        parent: {
+          pattern: /&/,
+          alias: "important"
+        },
+        placeholder: /%[-\w]+/,
+        variable: /\$[-\w]+|#\{\$[-\w]+\}/
+      }
+    },
+    property: {
+      pattern: /(?:[-\w]|\$[-\w]|#\{\$[-\w]+\})+(?=\s*:)/,
+      inside: {
+        variable: /\$[-\w]+|#\{\$[-\w]+\}/
+      }
+    }
+  });
+  Prism.languages.insertBefore("scss", "atrule", {
+    keyword: [
+      /@(?:content|debug|each|else(?: if)?|extend|for|forward|function|if|import|include|mixin|return|use|warn|while)\b/i,
+      {
+        pattern: /( )(?:from|through)(?= )/,
+        lookbehind: true
+      }
+    ]
+  });
+  Prism.languages.insertBefore("scss", "important", {
+    // var and interpolated vars
+    variable: /\$[-\w]+|#\{\$[-\w]+\}/
+  });
+  Prism.languages.insertBefore("scss", "function", {
+    "module-modifier": {
+      pattern: /\b(?:as|hide|show|with)\b/i,
+      alias: "keyword"
+    },
+    placeholder: {
+      pattern: /%[-\w]+/,
+      alias: "selector"
+    },
+    statement: {
+      pattern: /\B!(?:default|optional)\b/i,
+      alias: "keyword"
+    },
+    boolean: /\b(?:false|true)\b/,
+    null: {
+      pattern: /\bnull\b/,
+      alias: "keyword"
+    },
+    operator: {
+      pattern: /(\s)(?:[-+*\/%]|[=!]=|<=?|>=?|and|not|or)(?=\s)/,
+      lookbehind: true
+    }
+  });
+  Prism.languages.scss["atrule"].inside.rest = Prism.languages.scss;
+}
+
+export {
+  scss
+};

package/dist/chunk-S6F4C4AN.mjs

@@ -0,0 +1,17 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/hpkp.js
+hpkp.displayName = "hpkp";
+hpkp.aliases = [];
+function hpkp(Prism) {
+  Prism.languages.hpkp = {
+    directive: {
+      pattern: /\b(?:includeSubDomains|max-age|pin-sha256|preload|report-to|report-uri|strict)(?=[\s;=]|$)/i,
+      alias: "property"
+    },
+    operator: /=/,
+    punctuation: /;/
+  };
+}
+
+export {
+  hpkp
+};

package/dist/chunk-S7BWTMYF.mjs

@@ -0,0 +1,18 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/nand2tetris-hdl.js
+nand2tetrisHdl.displayName = "nand2tetris-hdl";
+nand2tetrisHdl.aliases = [];
+function nand2tetrisHdl(Prism) {
+  Prism.languages["nand2tetris-hdl"] = {
+    comment: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
+    keyword: /\b(?:BUILTIN|CHIP|CLOCKED|IN|OUT|PARTS)\b/,
+    boolean: /\b(?:false|true)\b/,
+    function: /\b[A-Za-z][A-Za-z0-9]*(?=\()/,
+    number: /\b\d+\b/,
+    operator: /=|\.\./,
+    punctuation: /[{}[\];(),:]/
+  };
+}
+
+export {
+  nand2tetrisHdl
+};