@trishchuk/coolors-mcp 1.0.0 → 1.0.1

package/docs/.vitepress/cache/deps/prismjs_components_prism-python.js

@@ -1,65 +1,72 @@
 // node_modules/prismjs/components/prism-python.js
 Prism.languages.python = {
-  "comment": {
+  comment: {
     pattern: /(^|[^\\])#.*/,
     lookbehind: true,
-    greedy: true
+    greedy: true,
   },
   "string-interpolation": {
-    pattern: /(?:f|fr|rf)(?:("""|''')[\s\S]*?\1|("|')(?:\\.|(?!\2)[^\\\r\n])*\2)/i,
+    pattern:
+      /(?:f|fr|rf)(?:("""|''')[\s\S]*?\1|("|')(?:\\.|(?!\2)[^\\\r\n])*\2)/i,
     greedy: true,
     inside: {
-      "interpolation": {
+      interpolation: {
         // "{" <expression> <optional "!s", "!r", or "!a"> <optional ":" format specifier> "}"
-        pattern: /((?:^|[^{])(?:\{\{)*)\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}])+\})+\})+\}/,
+        pattern:
+          /((?:^|[^{])(?:\{\{)*)\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}])+\})+\})+\}/,
         lookbehind: true,
         inside: {
           "format-spec": {
             pattern: /(:)[^:(){}]+(?=\}$)/,
-            lookbehind: true
+            lookbehind: true,
           },
           "conversion-option": {
             pattern: /![sra](?=[:}]$)/,
-            alias: "punctuation"
+            alias: "punctuation",
           },
-          rest: null
-        }
+          rest: null,
+        },
       },
-      "string": /[\s\S]+/
-    }
+      string: /[\s\S]+/,
+    },
   },
   "triple-quoted-string": {
     pattern: /(?:[rub]|br|rb)?("""|''')[\s\S]*?\1/i,
     greedy: true,
-    alias: "string"
+    alias: "string",
   },
-  "string": {
+  string: {
     pattern: /(?:[rub]|br|rb)?("|')(?:\\.|(?!\1)[^\\\r\n])*\1/i,
-    greedy: true
+    greedy: true,
   },
-  "function": {
+  function: {
     pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/g,
-    lookbehind: true
+    lookbehind: true,
   },
   "class-name": {
     pattern: /(\bclass\s+)\w+/i,
-    lookbehind: true
+    lookbehind: true,
   },
-  "decorator": {
+  decorator: {
     pattern: /(^[\t ]*)@\w+(?:\.\w+)*/m,
     lookbehind: true,
     alias: ["annotation", "punctuation"],
     inside: {
-      "punctuation": /\./
-    }
+      punctuation: /\./,
+    },
   },
-  "keyword": /\b(?:_(?=\s*:)|and|as|assert|async|await|break|case|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|match|nonlocal|not|or|pass|print|raise|return|try|while|with|yield)\b/,
-  "builtin": /\b(?:__import__|abs|all|any|apply|ascii|basestring|bin|bool|buffer|bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|file|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|map|max|memoryview|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip)\b/,
-  "boolean": /\b(?:False|None|True)\b/,
-  "number": /\b0(?:b(?:_?[01])+|o(?:_?[0-7])+|x(?:_?[a-f0-9])+)\b|(?:\b\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\B\.\d+(?:_\d+)*)(?:e[+-]?\d+(?:_\d+)*)?j?(?!\w)/i,
-  "operator": /[-+%=]=?|!=|:=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
-  "punctuation": /[{}[\];(),.:]/
+  keyword:
+    /\b(?:_(?=\s*:)|and|as|assert|async|await|break|case|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|match|nonlocal|not|or|pass|print|raise|return|try|while|with|yield)\b/,
+  builtin:
+    /\b(?:__import__|abs|all|any|apply|ascii|basestring|bin|bool|buffer|bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|file|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|map|max|memoryview|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip)\b/,
+  boolean: /\b(?:False|None|True)\b/,
+  number:
+    /\b0(?:b(?:_?[01])+|o(?:_?[0-7])+|x(?:_?[a-f0-9])+)\b|(?:\b\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\B\.\d+(?:_\d+)*)(?:e[+-]?\d+(?:_\d+)*)?j?(?!\w)/i,
+  operator: /[-+%=]=?|!=|:=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
+  punctuation: /[{}[\];(),.:]/,
 };
-Prism.languages.python["string-interpolation"].inside["interpolation"].inside.rest = Prism.languages.python;
+Prism.languages.python["string-interpolation"].inside[
+  "interpolation"
+].inside.rest = Prism.languages.python;
 Prism.languages.py = Prism.languages.python;
 //# sourceMappingURL=prismjs_components_prism-python.js.map

package/docs/.vitepress/cache/deps/prismjs_components_prism-typescript.js

@@ -1,21 +1,23 @@
 // node_modules/prismjs/components/prism-typescript.js
-(function(Prism2) {
+(function (Prism2) {
   Prism2.languages.typescript = Prism2.languages.extend("javascript", {
     "class-name": {
-      pattern: /(\b(?:class|extends|implements|instanceof|interface|new|type)\s+)(?!keyof\b)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?:\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?/,
+      pattern:
+        /(\b(?:class|extends|implements|instanceof|interface|new|type)\s+)(?!keyof\b)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?:\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?/,
       lookbehind: true,
       greedy: true,
-      inside: null
+      inside: null,
       // see below
     },
-    "builtin": /\b(?:Array|Function|Promise|any|boolean|console|never|number|string|symbol|unknown)\b/
+    builtin:
+      /\b(?:Array|Function|Promise|any|boolean|console|never|number|string|symbol|unknown)\b/,
   });
   Prism2.languages.typescript.keyword.push(
     /\b(?:abstract|declare|is|keyof|readonly|require)\b/,
     // keywords that have to be followed by an identifier
     /\b(?:asserts|infer|interface|module|namespace|type)\b(?=\s*(?:[{_$a-zA-Z\xA0-\uFFFF]|$))/,
     // This is for `import type *, {}`
-    /\btype\b(?=\s*(?:[\{*]|$))/
+    /\btype\b(?=\s*(?:[\{*]|$))/,
   );
   delete Prism2.languages.typescript["parameter"];
   delete Prism2.languages.typescript["literal-property"];
@@ -23,30 +25,31 @@
   delete typeInside["class-name"];
   Prism2.languages.typescript["class-name"].inside = typeInside;
   Prism2.languages.insertBefore("typescript", "function", {
-    "decorator": {
+    decorator: {
       pattern: /@[$\w\xA0-\uFFFF]+/,
       inside: {
-        "at": {
+        at: {
           pattern: /^@/,
-          alias: "operator"
+          alias: "operator",
         },
-        "function": /^[\s\S]+/
-      }
+        function: /^[\s\S]+/,
+      },
     },
     "generic-function": {
       // e.g. foo<T extends "bar" | "baz">( ...
-      pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>(?=\s*\()/,
+      pattern:
+        /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>(?=\s*\()/,
       greedy: true,
       inside: {
-        "function": /^#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/,
-        "generic": {
+        function: /^#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/,
+        generic: {
           pattern: /<[\s\S]+/,
           // everything after the first <
           alias: "class-name",
-          inside: typeInside
-        }
-      }
-    }
+          inside: typeInside,
+        },
+      },
+    },
   });
   Prism2.languages.ts = Prism2.languages.typescript;
 })(Prism);

package/docs/.vitepress/cache/deps/prismjs_components_prism-yaml.js

@@ -1,72 +1,106 @@
 // node_modules/prismjs/components/prism-yaml.js
-(function(Prism2) {
+(function (Prism2) {
   var anchorOrAlias = /[*&][^\s[\]{},]+/;
-  var tag = /!(?:<[\w\-%#;/?:@&=+$,.!~*'()[\]]+>|(?:[a-zA-Z\d-]*!)?[\w\-%#;/?:@&=+$.~*'()]+)?/;
-  var properties = "(?:" + tag.source + "(?:[ 	]+" + anchorOrAlias.source + ")?|" + anchorOrAlias.source + "(?:[ 	]+" + tag.source + ")?)";
-  var plainKey = /(?:[^\s\x00-\x08\x0e-\x1f!"#%&'*,\-:>?@[\]`{|}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]|[?:-]<PLAIN>)(?:[ \t]*(?:(?![#:])<PLAIN>|:<PLAIN>))*/.source.replace(/<PLAIN>/g, function() {
-    return /[^\s\x00-\x08\x0e-\x1f,[\]{}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]/.source;
-  });
+  var tag =
+    /!(?:<[\w\-%#;/?:@&=+$,.!~*'()[\]]+>|(?:[a-zA-Z\d-]*!)?[\w\-%#;/?:@&=+$.~*'()]+)?/;
+  var properties =
+    "(?:" +
+    tag.source +
+    "(?:[ 	]+" +
+    anchorOrAlias.source +
+    ")?|" +
+    anchorOrAlias.source +
+    "(?:[ 	]+" +
+    tag.source +
+    ")?)";
+  var plainKey =
+    /(?:[^\s\x00-\x08\x0e-\x1f!"#%&'*,\-:>?@[\]`{|}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]|[?:-]<PLAIN>)(?:[ \t]*(?:(?![#:])<PLAIN>|:<PLAIN>))*/.source.replace(
+      /<PLAIN>/g,
+      function () {
+        return /[^\s\x00-\x08\x0e-\x1f,[\]{}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]/
+          .source;
+      },
+    );
   var string = /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/.source;
   function createValuePattern(value, flags) {
     flags = (flags || "").replace(/m/g, "") + "m";
-    var pattern = /([:\-,[{]\s*(?:\s<<prop>>[ \t]+)?)(?:<<value>>)(?=[ \t]*(?:$|,|\]|\}|(?:[\r\n]\s*)?#))/.source.replace(/<<prop>>/g, function() {
-      return properties;
-    }).replace(/<<value>>/g, function() {
-      return value;
-    });
+    var pattern =
+      /([:\-,[{]\s*(?:\s<<prop>>[ \t]+)?)(?:<<value>>)(?=[ \t]*(?:$|,|\]|\}|(?:[\r\n]\s*)?#))/.source
+        .replace(/<<prop>>/g, function () {
+          return properties;
+        })
+        .replace(/<<value>>/g, function () {
+          return value;
+        });
     return RegExp(pattern, flags);
   }
   Prism2.languages.yaml = {
-    "scalar": {
-      pattern: RegExp(/([\-:]\s*(?:\s<<prop>>[ \t]+)?[|>])[ \t]*(?:((?:\r?\n|\r)[ \t]+)\S[^\r\n]*(?:\2[^\r\n]+)*)/.source.replace(/<<prop>>/g, function() {
-        return properties;
-      })),
+    scalar: {
+      pattern: RegExp(
+        /([\-:]\s*(?:\s<<prop>>[ \t]+)?[|>])[ \t]*(?:((?:\r?\n|\r)[ \t]+)\S[^\r\n]*(?:\2[^\r\n]+)*)/.source.replace(
+          /<<prop>>/g,
+          function () {
+            return properties;
+          },
+        ),
+      ),
       lookbehind: true,
-      alias: "string"
+      alias: "string",
     },
-    "comment": /#.*/,
-    "key": {
-      pattern: RegExp(/((?:^|[:\-,[{\r\n?])[ \t]*(?:<<prop>>[ \t]+)?)<<key>>(?=\s*:\s)/.source.replace(/<<prop>>/g, function() {
-        return properties;
-      }).replace(/<<key>>/g, function() {
-        return "(?:" + plainKey + "|" + string + ")";
-      })),
+    comment: /#.*/,
+    key: {
+      pattern: RegExp(
+        /((?:^|[:\-,[{\r\n?])[ \t]*(?:<<prop>>[ \t]+)?)<<key>>(?=\s*:\s)/.source
+          .replace(/<<prop>>/g, function () {
+            return properties;
+          })
+          .replace(/<<key>>/g, function () {
+            return "(?:" + plainKey + "|" + string + ")";
+          }),
+      ),
       lookbehind: true,
       greedy: true,
-      alias: "atrule"
+      alias: "atrule",
     },
-    "directive": {
+    directive: {
       pattern: /(^[ \t]*)%.+/m,
       lookbehind: true,
-      alias: "important"
+      alias: "important",
     },
-    "datetime": {
-      pattern: createValuePattern(/\d{4}-\d\d?-\d\d?(?:[tT]|[ \t]+)\d\d?:\d{2}:\d{2}(?:\.\d*)?(?:[ \t]*(?:Z|[-+]\d\d?(?::\d{2})?))?|\d{4}-\d{2}-\d{2}|\d\d?:\d{2}(?::\d{2}(?:\.\d*)?)?/.source),
+    datetime: {
+      pattern: createValuePattern(
+        /\d{4}-\d\d?-\d\d?(?:[tT]|[ \t]+)\d\d?:\d{2}:\d{2}(?:\.\d*)?(?:[ \t]*(?:Z|[-+]\d\d?(?::\d{2})?))?|\d{4}-\d{2}-\d{2}|\d\d?:\d{2}(?::\d{2}(?:\.\d*)?)?/
+          .source,
+      ),
       lookbehind: true,
-      alias: "number"
+      alias: "number",
     },
-    "boolean": {
+    boolean: {
       pattern: createValuePattern(/false|true/.source, "i"),
       lookbehind: true,
-      alias: "important"
+      alias: "important",
     },
-    "null": {
+    null: {
       pattern: createValuePattern(/null|~/.source, "i"),
       lookbehind: true,
-      alias: "important"
+      alias: "important",
     },
-    "string": {
+    string: {
       pattern: createValuePattern(string),
       lookbehind: true,
-      greedy: true
+      greedy: true,
     },
-    "number": {
-      pattern: createValuePattern(/[+-]?(?:0x[\da-f]+|0o[0-7]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|\.inf|\.nan)/.source, "i"),
-      lookbehind: true
+    number: {
+      pattern: createValuePattern(
+        /[+-]?(?:0x[\da-f]+|0o[0-7]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|\.inf|\.nan)/
+          .source,
+        "i",
+      ),
+      lookbehind: true,
     },
-    "tag": tag,
-    "important": anchorOrAlias,
-    "punctuation": /---|[:[\]{}\-,|>?]|\.\.\./
+    tag: tag,
+    important: anchorOrAlias,
+    punctuation: /---|[:[\]{}\-,|>?]|\.\.\./,
   };
   Prism2.languages.yml = Prism2.languages.yaml;
 })(Prism);