laif-ds 0.2.85 → 0.2.87

package/dist/node_modules/prismjs/components/prism-c.js

@@ -1,77 +0,0 @@
-"use client";
-Prism.languages.c = Prism.languages.extend("clike", {
-  comment: {
-    pattern: /\/\/(?:[^\r\n\\]|\\(?:\r\n?|\n|(?![\r\n])))*|\/\*[\s\S]*?(?:\*\/|$)/,
-    greedy: !0
-  },
-  string: {
-    // https://en.cppreference.com/w/c/language/string_literal
-    pattern: /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/,
-    greedy: !0
-  },
-  "class-name": {
-    pattern: /(\b(?:enum|struct)\s+(?:__attribute__\s*\(\([\s\S]*?\)\)\s*)?)\w+|\b[a-z]\w*_t\b/,
-    lookbehind: !0
-  },
-  keyword: /\b(?:_Alignas|_Alignof|_Atomic|_Bool|_Complex|_Generic|_Imaginary|_Noreturn|_Static_assert|_Thread_local|__attribute__|asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|inline|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|typeof|union|unsigned|void|volatile|while)\b/,
-  function: /\b[a-z_]\w*(?=\s*\()/i,
-  number: /(?:\b0x(?:[\da-f]+(?:\.[\da-f]*)?|\.[\da-f]+)(?:p[+-]?\d+)?|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)[ful]{0,4}/i,
-  operator: />>=?|<<=?|->|([-+&|:])\1|[?:~]|[-+*/%&|^!=<>]=?/
-});
-Prism.languages.insertBefore("c", "string", {
-  char: {
-    // https://en.cppreference.com/w/c/language/character_constant
-    pattern: /'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n]){0,32}'/,
-    greedy: !0
-  }
-});
-Prism.languages.insertBefore("c", "string", {
-  macro: {
-    // allow for multiline macro definitions
-    // spaces after the # character compile fine with gcc
-    pattern: /(^[\t ]*)#\s*[a-z](?:[^\r\n\\/]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|\\(?:\r\n|[\s\S]))*/im,
-    lookbehind: !0,
-    greedy: !0,
-    alias: "property",
-    inside: {
-      string: [
-        {
-          // highlight the path of the include statement as a string
-          pattern: /^(#\s*include\s*)<[^>]+>/,
-          lookbehind: !0
-        },
-        Prism.languages.c.string
-      ],
-      char: Prism.languages.c.char,
-      comment: Prism.languages.c.comment,
-      "macro-name": [
-        {
-          pattern: /(^#\s*define\s+)\w+\b(?!\()/i,
-          lookbehind: !0
-        },
-        {
-          pattern: /(^#\s*define\s+)\w+\b(?=\()/i,
-          lookbehind: !0,
-          alias: "function"
-        }
-      ],
-      // highlight macro directives as keywords
-      directive: {
-        pattern: /^(#\s*)[a-z]+/,
-        lookbehind: !0,
-        alias: "keyword"
-      },
-      "directive-hash": /^#/,
-      punctuation: /##|\\(?=[\r\n])/,
-      expression: {
-        pattern: /\S[\s\S]*/,
-        inside: Prism.languages.c
-      }
-    }
-  }
-});
-Prism.languages.insertBefore("c", "function", {
-  // highlight predefined macros as constants
-  constant: /\b(?:EOF|NULL|SEEK_CUR|SEEK_END|SEEK_SET|__DATE__|__FILE__|__LINE__|__TIMESTAMP__|__TIME__|__func__|stderr|stdin|stdout)\b/
-});
-delete Prism.languages.c.boolean;

package/dist/node_modules/prismjs/components/prism-clike.js

@@ -1,32 +0,0 @@
-"use client";
-Prism.languages.clike = {
-  comment: [
-    {
-      pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
-      lookbehind: !0,
-      greedy: !0
-    },
-    {
-      pattern: /(^|[^\\:])\/\/.*/,
-      lookbehind: !0,
-      greedy: !0
-    }
-  ],
-  string: {
-    pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
-    greedy: !0
-  },
-  "class-name": {
-    pattern: /(\b(?:class|extends|implements|instanceof|interface|new|trait)\s+|\bcatch\s+\()[\w.\\]+/i,
-    lookbehind: !0,
-    inside: {
-      punctuation: /[.\\]/
-    }
-  },
-  keyword: /\b(?:break|catch|continue|do|else|finally|for|function|if|in|instanceof|new|null|return|throw|try|while)\b/,
-  boolean: /\b(?:false|true)\b/,
-  function: /\b\w+(?=\()/,
-  number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
-  operator: /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/,
-  punctuation: /[{}[\];(),.:]/
-};

package/dist/node_modules/prismjs/components/prism-cpp.js

@@ -1,93 +0,0 @@
-"use client";
-import { __exports as n } from "../../../_virtual/prism-cpp2.js";
-var r;
-function o() {
-  return r ? n : (r = 1, (function(e) {
-    var t = /\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|char8_t|class|co_await|co_return|co_yield|compl|concept|const|const_cast|consteval|constexpr|constinit|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|final|float|for|friend|goto|if|import|inline|int|int16_t|int32_t|int64_t|int8_t|long|module|mutable|namespace|new|noexcept|nullptr|operator|override|private|protected|public|register|reinterpret_cast|requires|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|uint16_t|uint32_t|uint64_t|uint8_t|union|unsigned|using|virtual|void|volatile|wchar_t|while)\b/, a = /\b(?!<keyword>)\w+(?:\s*\.\s*\w+)*\b/.source.replace(/<keyword>/g, function() {
-      return t.source;
-    });
-    e.languages.cpp = e.languages.extend("c", {
-      "class-name": [
-        {
-          pattern: RegExp(/(\b(?:class|concept|enum|struct|typename)\s+)(?!<keyword>)\w+/.source.replace(/<keyword>/g, function() {
-            return t.source;
-          })),
-          lookbehind: !0
-        },
-        // This is intended to capture the class name of method implementations like:
-        //   void foo::bar() const {}
-        // However! The `foo` in the above example could also be a namespace, so we only capture the class name if
-        // it starts with an uppercase letter. This approximation should give decent results.
-        /\b[A-Z]\w*(?=\s*::\s*\w+\s*\()/,
-        // This will capture the class name before destructors like:
-        //   Foo::~Foo() {}
-        /\b[A-Z_]\w*(?=\s*::\s*~\w+\s*\()/i,
-        // This also intends to capture the class name of method implementations but here the class has template
-        // parameters, so it can't be a namespace (until C++ adds generic namespaces).
-        /\b\w+(?=\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>\s*::\s*\w+\s*\()/
-      ],
-      keyword: t,
-      number: {
-        pattern: /(?:\b0b[01']+|\b0x(?:[\da-f']+(?:\.[\da-f']*)?|\.[\da-f']+)(?:p[+-]?[\d']+)?|(?:\b[\d']+(?:\.[\d']*)?|\B\.[\d']+)(?:e[+-]?[\d']+)?)[ful]{0,4}/i,
-        greedy: !0
-      },
-      operator: />>=?|<<=?|->|--|\+\+|&&|\|\||[?:~]|<=>|[-+*/%&|^!=<>]=?|\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\b/,
-      boolean: /\b(?:false|true)\b/
-    }), e.languages.insertBefore("cpp", "string", {
-      module: {
-        // https://en.cppreference.com/w/cpp/language/modules
-        pattern: RegExp(
-          /(\b(?:import|module)\s+)/.source + "(?:" + // header-name
-          /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|<[^<>\r\n]*>/.source + "|" + // module name or partition or both
-          /<mod-name>(?:\s*:\s*<mod-name>)?|:\s*<mod-name>/.source.replace(/<mod-name>/g, function() {
-            return a;
-          }) + ")"
-        ),
-        lookbehind: !0,
-        greedy: !0,
-        inside: {
-          string: /^[<"][\s\S]+/,
-          operator: /:/,
-          punctuation: /\./
-        }
-      },
-      "raw-string": {
-        pattern: /R"([^()\\ ]{0,16})\([\s\S]*?\)\1"/,
-        alias: "string",
-        greedy: !0
-      }
-    }), e.languages.insertBefore("cpp", "keyword", {
-      "generic-function": {
-        pattern: /\b(?!operator\b)[a-z_]\w*\s*<(?:[^<>]|<[^<>]*>)*>(?=\s*\()/i,
-        inside: {
-          function: /^\w+/,
-          generic: {
-            pattern: /<[\s\S]+/,
-            alias: "class-name",
-            inside: e.languages.cpp
-          }
-        }
-      }
-    }), e.languages.insertBefore("cpp", "operator", {
-      "double-colon": {
-        pattern: /::/,
-        alias: "punctuation"
-      }
-    }), e.languages.insertBefore("cpp", "class-name", {
-      // the base clause is an optional list of parent classes
-      // https://en.cppreference.com/w/cpp/language/class
-      "base-clause": {
-        pattern: /(\b(?:class|struct)\s+\w+\s*:\s*)[^;{}"'\s]+(?:\s+[^;{}"'\s]+)*(?=\s*[;{])/,
-        lookbehind: !0,
-        greedy: !0,
-        inside: e.languages.extend("cpp", {})
-      }
-    }), e.languages.insertBefore("inside", "double-colon", {
-      // All untokenized words that are not namespaces should be class names
-      "class-name": /\b[a-z_]\w*\b(?!\s*::)/i
-    }, e.languages.cpp["base-clause"]);
-  })(Prism), n);
-}
-export {
-  o as __require
-};

package/dist/node_modules/prismjs/components/prism-css.js

@@ -1,56 +0,0 @@
-"use client";
-(function(s) {
-  var e = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;
-  s.languages.css = {
-    comment: /\/\*[\s\S]*?\*\//,
-    atrule: {
-      pattern: RegExp("@[\\w-](?:" + /[^;{\s"']|\s+(?!\s)/.source + "|" + e.source + ")*?" + /(?:;|(?=\s*\{))/.source),
-      inside: {
-        rule: /^@[\w-]+/,
-        "selector-function-argument": {
-          pattern: /(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/,
-          lookbehind: !0,
-          alias: "selector"
-        },
-        keyword: {
-          pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/,
-          lookbehind: !0
-        }
-        // See rest below
-      }
-    },
-    url: {
-      // https://drafts.csswg.org/css-values-3/#urls
-      pattern: RegExp("\\burl\\((?:" + e.source + "|" + /(?:[^\\\r\n()"']|\\[\s\S])*/.source + ")\\)", "i"),
-      greedy: !0,
-      inside: {
-        function: /^url/i,
-        punctuation: /^\(|\)$/,
-        string: {
-          pattern: RegExp("^" + e.source + "$"),
-          alias: "url"
-        }
-      }
-    },
-    selector: {
-      pattern: RegExp(`(^|[{}\\s])[^{}\\s](?:[^{};"'\\s]|\\s+(?![\\s{])|` + e.source + ")*(?=\\s*\\{)"),
-      lookbehind: !0
-    },
-    string: {
-      pattern: e,
-      greedy: !0
-    },
-    property: {
-      pattern: /(^|[^-\w\xA0-\uFFFF])(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i,
-      lookbehind: !0
-    },
-    important: /!important\b/i,
-    function: {
-      pattern: /(^|[^-a-z0-9])[-a-z0-9]+(?=\()/i,
-      lookbehind: !0
-    },
-    punctuation: /[(){};:,]/
-  }, s.languages.css.atrule.inside.rest = s.languages.css;
-  var t = s.languages.markup;
-  t && (t.tag.addInlined("style", "css"), t.tag.addAttribute("style", "css"));
-})(Prism);

package/dist/node_modules/prismjs/components/prism-java.js

@@ -1,122 +0,0 @@
-"use client";
-import { __exports as n } from "../../../_virtual/prism-java2.js";
-var r;
-function o() {
-  return r ? n : (r = 1, (function(t) {
-    var a = /\b(?:abstract|assert|boolean|break|byte|case|catch|char|class|const|continue|default|do|double|else|enum|exports|extends|final|finally|float|for|goto|if|implements|import|instanceof|int|interface|long|module|native|new|non-sealed|null|open|opens|package|permits|private|protected|provides|public|record(?!\s*[(){}[\]<>=%~.:,;?+\-*/&|^])|requires|return|sealed|short|static|strictfp|super|switch|synchronized|this|throw|throws|to|transient|transitive|try|uses|var|void|volatile|while|with|yield)\b/, s = /(?:[a-z]\w*\s*\.\s*)*(?:[A-Z]\w*\s*\.\s*)*/.source, e = {
-      pattern: RegExp(/(^|[^\w.])/.source + s + /[A-Z](?:[\d_A-Z]*[a-z]\w*)?\b/.source),
-      lookbehind: !0,
-      inside: {
-        namespace: {
-          pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/,
-          inside: {
-            punctuation: /\./
-          }
-        },
-        punctuation: /\./
-      }
-    };
-    t.languages.java = t.languages.extend("clike", {
-      string: {
-        pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"/,
-        lookbehind: !0,
-        greedy: !0
-      },
-      "class-name": [
-        e,
-        {
-          // variables, parameters, and constructor references
-          // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)
-          pattern: RegExp(/(^|[^\w.])/.source + s + /[A-Z]\w*(?=\s+\w+\s*[;,=()]|\s*(?:\[[\s,]*\]\s*)?::\s*new\b)/.source),
-          lookbehind: !0,
-          inside: e.inside
-        },
-        {
-          // class names based on keyword
-          // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)
-          pattern: RegExp(/(\b(?:class|enum|extends|implements|instanceof|interface|new|record|throws)\s+)/.source + s + /[A-Z]\w*\b/.source),
-          lookbehind: !0,
-          inside: e.inside
-        }
-      ],
-      keyword: a,
-      function: [
-        t.languages.clike.function,
-        {
-          pattern: /(::\s*)[a-z_]\w*/,
-          lookbehind: !0
-        }
-      ],
-      number: /\b0b[01][01_]*L?\b|\b0x(?:\.[\da-f_p+-]+|[\da-f_]+(?:\.[\da-f_p+-]+)?)\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?\d[\d_]*)?[dfl]?/i,
-      operator: {
-        pattern: /(^|[^.])(?:<<=?|>>>?=?|->|--|\+\+|&&|\|\||::|[?:~]|[-+*/%&|^!=<>]=?)/m,
-        lookbehind: !0
-      },
-      constant: /\b[A-Z][A-Z_\d]+\b/
-    }), t.languages.insertBefore("java", "string", {
-      "triple-quoted-string": {
-        // http://openjdk.java.net/jeps/355#Description
-        pattern: /"""[ \t]*[\r\n](?:(?:"|"")?(?:\\.|[^"\\]))*"""/,
-        greedy: !0,
-        alias: "string"
-      },
-      char: {
-        pattern: /'(?:\\.|[^'\\\r\n]){1,6}'/,
-        greedy: !0
-      }
-    }), t.languages.insertBefore("java", "class-name", {
-      annotation: {
-        pattern: /(^|[^.])@\w+(?:\s*\.\s*\w+)*/,
-        lookbehind: !0,
-        alias: "punctuation"
-      },
-      generics: {
-        pattern: /<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&))*>)*>)*>)*>/,
-        inside: {
-          "class-name": e,
-          keyword: a,
-          punctuation: /[<>(),.:]/,
-          operator: /[?&|]/
-        }
-      },
-      import: [
-        {
-          pattern: RegExp(/(\bimport\s+)/.source + s + /(?:[A-Z]\w*|\*)(?=\s*;)/.source),
-          lookbehind: !0,
-          inside: {
-            namespace: e.inside.namespace,
-            punctuation: /\./,
-            operator: /\*/,
-            "class-name": /\w+/
-          }
-        },
-        {
-          pattern: RegExp(/(\bimport\s+static\s+)/.source + s + /(?:\w+|\*)(?=\s*;)/.source),
-          lookbehind: !0,
-          alias: "static",
-          inside: {
-            namespace: e.inside.namespace,
-            static: /\b\w+$/,
-            punctuation: /\./,
-            operator: /\*/,
-            "class-name": /\w+/
-          }
-        }
-      ],
-      namespace: {
-        pattern: RegExp(
-          /(\b(?:exports|import(?:\s+static)?|module|open|opens|package|provides|requires|to|transitive|uses|with)\s+)(?!<keyword>)[a-z]\w*(?:\.[a-z]\w*)*\.?/.source.replace(/<keyword>/g, function() {
-            return a.source;
-          })
-        ),
-        lookbehind: !0,
-        inside: {
-          punctuation: /\./
-        }
-      }
-    });
-  })(Prism), n);
-}
-export {
-  o as __require
-};

package/dist/node_modules/prismjs/components/prism-javascript.js

@@ -1,138 +0,0 @@
-"use client";
-Prism.languages.javascript = Prism.languages.extend("clike", {
-  "class-name": [
-    Prism.languages.clike["class-name"],
-    {
-      pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/,
-      lookbehind: !0
-    }
-  ],
-  keyword: [
-    {
-      pattern: /((?:^|\})\s*)catch\b/,
-      lookbehind: !0
-    },
-    {
-      pattern: /(^|[^.]|\.\.\.\s*)\b(?:as|assert(?=\s*\{)|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally(?=\s*(?:\{|$))|for|from(?=\s*(?:['"]|$))|function|(?:get|set)(?=\s*(?:[#\[$\w\xA0-\uFFFF]|$))|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/,
-      lookbehind: !0
-    }
-  ],
-  // Allow for all non-ASCII characters (See http://stackoverflow.com/a/2008444)
-  function: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
-  number: {
-    pattern: RegExp(
-      /(^|[^\w$])/.source + "(?:" + // constant
-      (/NaN|Infinity/.source + "|" + // binary integer
-      /0[bB][01]+(?:_[01]+)*n?/.source + "|" + // octal integer
-      /0[oO][0-7]+(?:_[0-7]+)*n?/.source + "|" + // hexadecimal integer
-      /0[xX][\dA-Fa-f]+(?:_[\dA-Fa-f]+)*n?/.source + "|" + // decimal bigint
-      /\d+(?:_\d+)*n/.source + "|" + // decimal number (integer or float) but no bigint
-      /(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[Ee][+-]?\d+(?:_\d+)*)?/.source) + ")" + /(?![\w$])/.source
-    ),
-    lookbehind: !0
-  },
-  operator: /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/
-});
-Prism.languages.javascript["class-name"][0].pattern = /(\b(?:class|extends|implements|instanceof|interface|new)\s+)[\w.\\]+/;
-Prism.languages.insertBefore("javascript", "keyword", {
-  regex: {
-    pattern: RegExp(
-      // lookbehind
-      // eslint-disable-next-line regexp/no-dupe-characters-character-class
-      /((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)/.source + // Regex pattern:
-      // There are 2 regex patterns here. The RegExp set notation proposal added support for nested character
-      // classes if the `v` flag is present. Unfortunately, nested CCs are both context-free and incompatible
-      // with the only syntax, so we have to define 2 different regex patterns.
-      /\//.source + "(?:" + /(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}/.source + "|" + // `v` flag syntax. This supports 3 levels of nested character classes.
-      /(?:\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.)*\])*\])*\]|\\.|[^/\\\[\r\n])+\/[dgimyus]{0,7}v[dgimyus]{0,7}/.source + ")" + // lookahead
-      /(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/.source
-    ),
-    lookbehind: !0,
-    greedy: !0,
-    inside: {
-      "regex-source": {
-        pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
-        lookbehind: !0,
-        alias: "language-regex",
-        inside: Prism.languages.regex
-      },
-      "regex-delimiter": /^\/|\/$/,
-      "regex-flags": /^[a-z]+$/
-    }
-  },
-  // This must be declared before keyword because we use "function" inside the look-forward
-  "function-variable": {
-    pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/,
-    alias: "function"
-  },
-  parameter: [
-    {
-      pattern: /(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/,
-      lookbehind: !0,
-      inside: Prism.languages.javascript
-    },
-    {
-      pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,
-      lookbehind: !0,
-      inside: Prism.languages.javascript
-    },
-    {
-      pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
-      lookbehind: !0,
-      inside: Prism.languages.javascript
-    },
-    {
-      pattern: /((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\w\xA0-\uFFFF]))(?:(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*)\(\s*|\]\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*\{)/,
-      lookbehind: !0,
-      inside: Prism.languages.javascript
-    }
-  ],
-  constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/
-});
-Prism.languages.insertBefore("javascript", "string", {
-  hashbang: {
-    pattern: /^#!.*/,
-    greedy: !0,
-    alias: "comment"
-  },
-  "template-string": {
-    pattern: /`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/,
-    greedy: !0,
-    inside: {
-      "template-punctuation": {
-        pattern: /^`|`$/,
-        alias: "string"
-      },
-      interpolation: {
-        pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
-        lookbehind: !0,
-        inside: {
-          "interpolation-punctuation": {
-            pattern: /^\$\{|\}$/,
-            alias: "punctuation"
-          },
-          rest: Prism.languages.javascript
-        }
-      },
-      string: /[\s\S]+/
-    }
-  },
-  "string-property": {
-    pattern: /((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m,
-    lookbehind: !0,
-    greedy: !0,
-    alias: "property"
-  }
-});
-Prism.languages.insertBefore("javascript", "operator", {
-  "literal-property": {
-    pattern: /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m,
-    lookbehind: !0,
-    alias: "property"
-  }
-});
-Prism.languages.markup && (Prism.languages.markup.tag.addInlined("script", "javascript"), Prism.languages.markup.tag.addAttribute(
-  /on(?:abort|blur|change|click|composition(?:end|start|update)|dblclick|error|focus(?:in|out)?|key(?:down|up)|load|mouse(?:down|enter|leave|move|out|over|up)|reset|resize|scroll|select|slotchange|submit|unload|wheel)/.source,
-  "javascript"
-));
-Prism.languages.js = Prism.languages.javascript;