@mxmweb/rtext 1.6.14 → 1.6.16

package/prism-bash-zSjFhtUz.js

@@ -1,219 +0,0 @@
-(function(e) {
-  var a = "\\b(?:BASH|BASHOPTS|BASH_ALIASES|BASH_ARGC|BASH_ARGV|BASH_CMDS|BASH_COMPLETION_COMPAT_DIR|BASH_LINENO|BASH_REMATCH|BASH_SOURCE|BASH_VERSINFO|BASH_VERSION|COLORTERM|COLUMNS|COMP_WORDBREAKS|DBUS_SESSION_BUS_ADDRESS|DEFAULTS_PATH|DESKTOP_SESSION|DIRSTACK|DISPLAY|EUID|GDMSESSION|GDM_LANG|GNOME_KEYRING_CONTROL|GNOME_KEYRING_PID|GPG_AGENT_INFO|GROUPS|HISTCONTROL|HISTFILE|HISTFILESIZE|HISTSIZE|HOME|HOSTNAME|HOSTTYPE|IFS|INSTANCE|JOB|LANG|LANGUAGE|LC_ADDRESS|LC_ALL|LC_IDENTIFICATION|LC_MEASUREMENT|LC_MONETARY|LC_NAME|LC_NUMERIC|LC_PAPER|LC_TELEPHONE|LC_TIME|LESSCLOSE|LESSOPEN|LINES|LOGNAME|LS_COLORS|MACHTYPE|MAILCHECK|MANDATORY_PATH|NO_AT_BRIDGE|OLDPWD|OPTERR|OPTIND|ORBIT_SOCKETDIR|OSTYPE|PAPERSIZE|PATH|PIPESTATUS|PPID|PS1|PS2|PS3|PS4|PWD|RANDOM|REPLY|SECONDS|SELINUX_INIT|SESSION|SESSIONTYPE|SESSION_MANAGER|SHELL|SHELLOPTS|SHLVL|SSH_AUTH_SOCK|TERM|UID|UPSTART_EVENTS|UPSTART_INSTANCE|UPSTART_JOB|UPSTART_SESSION|USER|WINDOWID|XAUTHORITY|XDG_CONFIG_DIRS|XDG_CURRENT_DESKTOP|XDG_DATA_DIRS|XDG_GREETER_DATA_DIR|XDG_MENU_PREFIX|XDG_RUNTIME_DIR|XDG_SEAT|XDG_SEAT_PATH|XDG_SESSION_DESKTOP|XDG_SESSION_ID|XDG_SESSION_PATH|XDG_SESSION_TYPE|XDG_VTNR|XMODIFIERS)\\b", r = {
-    pattern: /(^(["']?)\w+\2)[ \t]+\S.*/,
-    lookbehind: !0,
-    alias: "punctuation",
-    // this looks reasonably well in all themes
-    inside: null
-    // see below
-  }, t = {
-    bash: r,
-    environment: {
-      pattern: RegExp("\\$" + a),
-      alias: "constant"
-    },
-    variable: [
-      // [0]: Arithmetic Environment
-      {
-        pattern: /\$?\(\([\s\S]+?\)\)/,
-        greedy: !0,
-        inside: {
-          // If there is a $ sign at the beginning highlight $(( and )) as variable
-          variable: [
-            {
-              pattern: /(^\$\(\([\s\S]+)\)\)/,
-              lookbehind: !0
-            },
-            /^\$\(\(/
-          ],
-          number: /\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee]-?\d+)?/,
-          // Operators according to https://www.gnu.org/software/bash/manual/bashref.html#Shell-Arithmetic
-          operator: /--|\+\+|\*\*=?|<<=?|>>=?|&&|\|\||[=!+\-*/%<>^&|]=?|[?~:]/,
-          // If there is no $ sign at the beginning highlight (( and )) as punctuation
-          punctuation: /\(\(?|\)\)?|,|;/
-        }
-      },
-      // [1]: Command Substitution
-      {
-        pattern: /\$\((?:\([^)]+\)|[^()])+\)|`[^`]+`/,
-        greedy: !0,
-        inside: {
-          variable: /^\$\(|^`|\)$|`$/
-        }
-      },
-      // [2]: Brace expansion
-      {
-        pattern: /\$\{[^}]+\}/,
-        greedy: !0,
-        inside: {
-          operator: /:[-=?+]?|[!\/]|##?|%%?|\^\^?|,,?/,
-          punctuation: /[\[\]]/,
-          environment: {
-            pattern: RegExp("(\\{)" + a),
-            lookbehind: !0,
-            alias: "constant"
-          }
-        }
-      },
-      /\$(?:\w+|[#?*!@$])/
-    ],
-    // Escape sequences from echo and printf's manuals, and escaped quotes.
-    entity: /\\(?:[abceEfnrtv\\"]|O?[0-7]{1,3}|U[0-9a-fA-F]{8}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{1,2})/
-  };
-  e.languages.bash = {
-    shebang: {
-      pattern: /^#!\s*\/.*/,
-      alias: "important"
-    },
-    comment: {
-      pattern: /(^|[^"{\\$])#.*/,
-      lookbehind: !0
-    },
-    "function-name": [
-      // a) function foo {
-      // b) foo() {
-      // c) function foo() {
-      // but not “foo {”
-      {
-        // a) and c)
-        pattern: /(\bfunction\s+)[\w-]+(?=(?:\s*\(?:\s*\))?\s*\{)/,
-        lookbehind: !0,
-        alias: "function"
-      },
-      {
-        // b)
-        pattern: /\b[\w-]+(?=\s*\(\s*\)\s*\{)/,
-        alias: "function"
-      }
-    ],
-    // Highlight variable names as variables in for and select beginnings.
-    "for-or-select": {
-      pattern: /(\b(?:for|select)\s+)\w+(?=\s+in\s)/,
-      alias: "variable",
-      lookbehind: !0
-    },
-    // Highlight variable names as variables in the left-hand part
-    // of assignments (“=” and “+=”).
-    "assign-left": {
-      pattern: /(^|[\s;|&]|[<>]\()\w+(?:\.\w+)*(?=\+?=)/,
-      inside: {
-        environment: {
-          pattern: RegExp("(^|[\\s;|&]|[<>]\\()" + a),
-          lookbehind: !0,
-          alias: "constant"
-        }
-      },
-      alias: "variable",
-      lookbehind: !0
-    },
-    // Highlight parameter names as variables
-    parameter: {
-      pattern: /(^|\s)-{1,2}(?:\w+:[+-]?)?\w+(?:\.\w+)*(?=[=\s]|$)/,
-      alias: "variable",
-      lookbehind: !0
-    },
-    string: [
-      // Support for Here-documents https://en.wikipedia.org/wiki/Here_document
-      {
-        pattern: /((?:^|[^<])<<-?\s*)(\w+)\s[\s\S]*?(?:\r?\n|\r)\2/,
-        lookbehind: !0,
-        greedy: !0,
-        inside: t
-      },
-      // Here-document with quotes around the tag
-      // → No expansion (so no “inside”).
-      {
-        pattern: /((?:^|[^<])<<-?\s*)(["'])(\w+)\2\s[\s\S]*?(?:\r?\n|\r)\3/,
-        lookbehind: !0,
-        greedy: !0,
-        inside: {
-          bash: r
-        }
-      },
-      // “Normal” string
-      {
-        // https://www.gnu.org/software/bash/manual/html_node/Double-Quotes.html
-        pattern: /(^|[^\\](?:\\\\)*)"(?:\\[\s\S]|\$\([^)]+\)|\$(?!\()|`[^`]+`|[^"\\`$])*"/,
-        lookbehind: !0,
-        greedy: !0,
-        inside: t
-      },
-      {
-        // https://www.gnu.org/software/bash/manual/html_node/Single-Quotes.html
-        pattern: /(^|[^$\\])'[^']*'/,
-        lookbehind: !0,
-        greedy: !0
-      },
-      {
-        // https://www.gnu.org/software/bash/manual/html_node/ANSI_002dC-Quoting.html
-        pattern: /\$'(?:[^'\\]|\\[\s\S])*'/,
-        greedy: !0,
-        inside: {
-          entity: t.entity
-        }
-      }
-    ],
-    environment: {
-      pattern: RegExp("\\$?" + a),
-      alias: "constant"
-    },
-    variable: t.variable,
-    function: {
-      pattern: /(^|[\s;|&]|[<>]\()(?:add|apropos|apt|apt-cache|apt-get|aptitude|aspell|automysqlbackup|awk|basename|bash|bc|bconsole|bg|bzip2|cal|cargo|cat|cfdisk|chgrp|chkconfig|chmod|chown|chroot|cksum|clear|cmp|column|comm|composer|cp|cron|crontab|csplit|curl|cut|date|dc|dd|ddrescue|debootstrap|df|diff|diff3|dig|dir|dircolors|dirname|dirs|dmesg|docker|docker-compose|du|egrep|eject|env|ethtool|expand|expect|expr|fdformat|fdisk|fg|fgrep|file|find|fmt|fold|format|free|fsck|ftp|fuser|gawk|git|gparted|grep|groupadd|groupdel|groupmod|groups|grub-mkconfig|gzip|halt|head|hg|history|host|hostname|htop|iconv|id|ifconfig|ifdown|ifup|import|install|ip|java|jobs|join|kill|killall|less|link|ln|locate|logname|logrotate|look|lpc|lpr|lprint|lprintd|lprintq|lprm|ls|lsof|lynx|make|man|mc|mdadm|mkconfig|mkdir|mke2fs|mkfifo|mkfs|mkisofs|mknod|mkswap|mmv|more|most|mount|mtools|mtr|mutt|mv|nano|nc|netstat|nice|nl|node|nohup|notify-send|npm|nslookup|op|open|parted|passwd|paste|pathchk|ping|pkill|pnpm|podman|podman-compose|popd|pr|printcap|printenv|ps|pushd|pv|quota|quotacheck|quotactl|ram|rar|rcp|reboot|remsync|rename|renice|rev|rm|rmdir|rpm|rsync|scp|screen|sdiff|sed|sendmail|seq|service|sftp|sh|shellcheck|shuf|shutdown|sleep|slocate|sort|split|ssh|stat|strace|su|sudo|sum|suspend|swapon|sync|sysctl|tac|tail|tar|tee|time|timeout|top|touch|tr|traceroute|tsort|tty|umount|uname|unexpand|uniq|units|unrar|unshar|unzip|update-grub|uptime|useradd|userdel|usermod|users|uudecode|uuencode|v|vcpkg|vdir|vi|vim|virsh|vmstat|wait|watch|wc|wget|whereis|which|who|whoami|write|xargs|xdg-open|yarn|yes|zenity|zip|zsh|zypper)(?=$|[)\s;|&])/,
-      lookbehind: !0
-    },
-    keyword: {
-      pattern: /(^|[\s;|&]|[<>]\()(?:case|do|done|elif|else|esac|fi|for|function|if|in|select|then|until|while)(?=$|[)\s;|&])/,
-      lookbehind: !0
-    },
-    // https://www.gnu.org/software/bash/manual/html_node/Shell-Builtin-Commands.html
-    builtin: {
-      pattern: /(^|[\s;|&]|[<>]\()(?:\.|:|alias|bind|break|builtin|caller|cd|command|continue|declare|echo|enable|eval|exec|exit|export|getopts|hash|help|let|local|logout|mapfile|printf|pwd|read|readarray|readonly|return|set|shift|shopt|source|test|times|trap|type|typeset|ulimit|umask|unalias|unset)(?=$|[)\s;|&])/,
-      lookbehind: !0,
-      // Alias added to make those easier to distinguish from strings.
-      alias: "class-name"
-    },
-    boolean: {
-      pattern: /(^|[\s;|&]|[<>]\()(?:false|true)(?=$|[)\s;|&])/,
-      lookbehind: !0
-    },
-    "file-descriptor": {
-      pattern: /\B&\d\b/,
-      alias: "important"
-    },
-    operator: {
-      // Lots of redirections here, but not just that.
-      pattern: /\d?<>|>\||\+=|=[=~]?|!=?|<<[<-]?|[&\d]?>>|\d[<>]&?|[<>][&=]?|&[>&]?|\|[&|]?/,
-      inside: {
-        "file-descriptor": {
-          pattern: /^\d/,
-          alias: "important"
-        }
-      }
-    },
-    punctuation: /\$?\(\(?|\)\)?|\.\.|[{}[\];\\]/,
-    number: {
-      pattern: /(^|\s)(?:[1-9]\d*|0)(?:[.,]\d+)?\b/,
-      lookbehind: !0
-    }
-  }, r.inside = e.languages.bash;
-  for (var o = [
-    "comment",
-    "function-name",
-    "for-or-select",
-    "assign-left",
-    "parameter",
-    "string",
-    "environment",
-    "function",
-    "keyword",
-    "builtin",
-    "boolean",
-    "file-descriptor",
-    "operator",
-    "punctuation",
-    "number"
-  ], s = t.variable[1].inside, n = 0; n < o.length; n++)
-    s[o[n]] = e.languages.bash[o[n]];
-  e.languages.sh = e.languages.bash, e.languages.shell = e.languages.bash;
-})(Prism);

package/prism-c-CXS5tkeN.js

@@ -1,76 +0,0 @@
-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/prism-cpp-DTm5qrps.js

@@ -1,113 +0,0 @@
-import { g as p } from "./lib_enter-e1LoilHd.js";
-function u(e, t) {
-  for (var r = 0; r < t.length; r++) {
-    const n = t[r];
-    if (typeof n != "string" && !Array.isArray(n)) {
-      for (const a in n)
-        if (a !== "default" && !(a in e)) {
-          const s = Object.getOwnPropertyDescriptor(n, a);
-          s && Object.defineProperty(e, a, s.get ? s : {
-            enumerable: !0,
-            get: () => n[a]
-          });
-        }
-    }
-  }
-  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
-}
-var o = {}, i;
-function l() {
-  return i || (i = 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/, r = /\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 r;
-          }) + ")"
-        ),
-        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)), o;
-}
-var c = l();
-const d = /* @__PURE__ */ p(c), b = /* @__PURE__ */ u({
-  __proto__: null,
-  default: d
-}, [c]);
-export {
-  b as p
-};

package/prism-css-3Jya3wSQ.js

@@ -1,55 +0,0 @@
-(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/prism-diff-Apx1lkH_.js

@@ -1,42 +0,0 @@
-(function(i) {
-  i.languages.diff = {
-    coord: [
-      // Match all kinds of coord lines (prefixed by "+++", "---" or "***").
-      /^(?:\*{3}|-{3}|\+{3}).*$/m,
-      // Match "@@ ... @@" coord lines in unified diff.
-      /^@@.*@@$/m,
-      // Match coord lines in normal diff (starts with a number).
-      /^\d.*$/m
-    ]
-    // deleted, inserted, unchanged, diff
-  };
-  var r = {
-    "deleted-sign": "-",
-    "deleted-arrow": "<",
-    "inserted-sign": "+",
-    "inserted-arrow": ">",
-    unchanged: " ",
-    diff: "!"
-  };
-  Object.keys(r).forEach(function(e) {
-    var a = r[e], n = [];
-    /^\w+$/.test(e) || n.push(/\w+/.exec(e)[0]), e === "diff" && n.push("bold"), i.languages.diff[e] = {
-      pattern: RegExp("^(?:[" + a + `].*(?:\r
-?|
-|(?![\\s\\S])))+`, "m"),
-      alias: n,
-      inside: {
-        line: {
-          pattern: /(.)(?=[\s\S]).*(?:\r\n?|\n)?/,
-          lookbehind: !0
-        },
-        prefix: {
-          pattern: /[\s\S]/,
-          alias: /\w+/.exec(e)[0]
-        }
-      }
-    };
-  }), Object.defineProperty(i.languages.diff, "PREFIXES", {
-    value: r
-  });
-})(Prism);

package/prism-go-CHuRSSd-.js

@@ -1,26 +0,0 @@
-Prism.languages.go = Prism.languages.extend("clike", {
-  string: {
-    pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"|`[^`]*`/,
-    lookbehind: !0,
-    greedy: !0
-  },
-  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: !0
-  }
-});
-delete Prism.languages.go["class-name"];

package/prism-java-l04-K_JR.js

@@ -1,142 +0,0 @@
-import { g as u } from "./lib_enter-e1LoilHd.js";
-function p(t, a) {
-  for (var r = 0; r < a.length; r++) {
-    const e = a[r];
-    if (typeof e != "string" && !Array.isArray(e)) {
-      for (const s in e)
-        if (s !== "default" && !(s in t)) {
-          const n = Object.getOwnPropertyDescriptor(e, s);
-          n && Object.defineProperty(t, s, n.get ? n : {
-            enumerable: !0,
-            get: () => e[s]
-          });
-        }
-    }
-  }
-  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
-}
-var o = {}, i;
-function d() {
-  return i || (i = 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/, r = /(?:[a-z]\w*\s*\.\s*)*(?:[A-Z]\w*\s*\.\s*)*/.source, e = {
-      pattern: RegExp(/(^|[^\w.])/.source + r + /[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 + r + /[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 + r + /[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 + r + /(?:[A-Z]\w*|\*)(?=\s*;)/.source),
-          lookbehind: !0,
-          inside: {
-            namespace: e.inside.namespace,
-            punctuation: /\./,
-            operator: /\*/,
-            "class-name": /\w+/
-          }
-        },
-        {
-          pattern: RegExp(/(\bimport\s+static\s+)/.source + r + /(?:\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)), o;
-}
-var c = d();
-const l = /* @__PURE__ */ u(c), w = /* @__PURE__ */ p({
-  __proto__: null,
-  default: l
-}, [c]);
-export {
-  w as p
-};