storybook
Version:
Storybook: Develop, document, and test UI components in isolation
1,249 lines (1,240 loc) • 176 kB
JavaScript
import {
ActionBar,
ScrollArea,
createCopyToClipboardFunction
} from "./chunk-P4F4UVXX.js";
import {
_defineProperty,
_objectWithoutProperties
} from "./chunk-H6XK3RSC.js";
import "./chunk-45UGUKRX.js";
import {
_extends
} from "./chunk-CHUV5WSW.js";
import {
require_memoizerific
} from "./chunk-WJYERY3R.js";
import {
__commonJS,
__toESM
} from "./chunk-A242L54C.js";
// ../node_modules/refractor/lang/bash.js
var require_bash = __commonJS({
"../node_modules/refractor/lang/bash.js"(exports, module) {
"use strict";
module.exports = bash2;
bash2.displayName = "bash";
bash2.aliases = ["shell"];
function bash2(Prism) {
(function(Prism2) {
var envVars = "\\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", commandAfterHeredoc = {
pattern: /(^(["']?)\w+\2)[ \t]+\S.*/,
lookbehind: !0,
alias: "punctuation",
// this looks reasonably well in all themes
inside: null
// see below
}, insideString = {
bash: commandAfterHeredoc,
environment: {
pattern: RegExp("\\$" + envVars),
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("(\\{)" + envVars),
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})/
};
Prism2.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+(?=\+?=)/,
inside: {
environment: {
pattern: RegExp("(^|[\\s;|&]|[<>]\\()" + envVars),
lookbehind: !0,
alias: "constant"
}
},
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: insideString
},
// 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: commandAfterHeredoc
}
},
// “Normal” string
{
// https://www.gnu.org/software/bash/manual/html_node/Double-Quotes.html
pattern: /(^|[^\\](?:\\\\)*)"(?:\\[\s\S]|\$\([^)]+\)|\$(?!\()|`[^`]+`|[^"\\`$])*"/,
lookbehind: !0,
greedy: !0,
inside: insideString
},
{
// 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: insideString.entity
}
}
],
environment: {
pattern: RegExp("\\$?" + envVars),
alias: "constant"
},
variable: insideString.variable,
function: {
pattern: /(^|[\s;|&]|[<>]\()(?:add|apropos|apt|apt-cache|apt-get|aptitude|aspell|automysqlbackup|awk|basename|bash|bc|bconsole|bg|bzip2|cal|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|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|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
}
}, commandAfterHeredoc.inside = Prism2.languages.bash;
for (var toBeCopied = [
"comment",
"function-name",
"for-or-select",
"assign-left",
"string",
"environment",
"function",
"keyword",
"builtin",
"boolean",
"file-descriptor",
"operator",
"punctuation",
"number"
], inside = insideString.variable[1].inside, i = 0; i < toBeCopied.length; i++)
inside[toBeCopied[i]] = Prism2.languages.bash[toBeCopied[i]];
Prism2.languages.shell = Prism2.languages.bash;
})(Prism);
}
}
});
// ../node_modules/refractor/lang/css.js
var require_css = __commonJS({
"../node_modules/refractor/lang/css.js"(exports, module) {
"use strict";
module.exports = css2;
css2.displayName = "css";
css2.aliases = [];
function css2(Prism) {
(function(Prism2) {
var string = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;
Prism2.languages.css = {
comment: /\/\*[\s\S]*?\*\//,
atrule: {
pattern: /@[\w-](?:[^;{\s]|\s+(?![\s{]))*(?:;|(?=\s*\{))/,
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\\((?:" + string.source + "|" + /(?:[^\\\r\n()"']|\\[\s\S])*/.source + ")\\)",
"i"
),
greedy: !0,
inside: {
function: /^url/i,
punctuation: /^\(|\)$/,
string: {
pattern: RegExp("^" + string.source + "$"),
alias: "url"
}
}
},
selector: {
pattern: RegExp(
`(^|[{}\\s])[^{}\\s](?:[^{};"'\\s]|\\s+(?![\\s{])|` + string.source + ")*(?=\\s*\\{)"
),
lookbehind: !0
},
string: {
pattern: string,
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: /[(){};:,]/
}, Prism2.languages.css.atrule.inside.rest = Prism2.languages.css;
var markup2 = Prism2.languages.markup;
markup2 && (markup2.tag.addInlined("style", "css"), markup2.tag.addAttribute("style", "css"));
})(Prism);
}
}
});
// ../node_modules/refractor/lang/graphql.js
var require_graphql = __commonJS({
"../node_modules/refractor/lang/graphql.js"(exports, module) {
"use strict";
module.exports = graphql2;
graphql2.displayName = "graphql";
graphql2.aliases = [];
function graphql2(Prism) {
Prism.languages.graphql = {
comment: /#.*/,
description: {
pattern: /(?:"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*")(?=\s*[a-z_])/i,
greedy: !0,
alias: "string",
inside: {
"language-markdown": {
pattern: /(^"(?:"")?)(?!\1)[\s\S]+(?=\1$)/,
lookbehind: !0,
inside: Prism.languages.markdown
}
}
},
string: {
pattern: /"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*"/,
greedy: !0
},
number: /(?:\B-|\b)\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
boolean: /\b(?:false|true)\b/,
variable: /\$[a-z_]\w*/i,
directive: {
pattern: /@[a-z_]\w*/i,
alias: "function"
},
"attr-name": {
pattern: /\b[a-z_]\w*(?=\s*(?:\((?:[^()"]|"(?:\\.|[^\\"\r\n])*")*\))?:)/i,
greedy: !0
},
"atom-input": {
pattern: /\b[A-Z]\w*Input\b/,
alias: "class-name"
},
scalar: /\b(?:Boolean|Float|ID|Int|String)\b/,
constant: /\b[A-Z][A-Z_\d]*\b/,
"class-name": {
pattern: /(\b(?:enum|implements|interface|on|scalar|type|union)\s+|&\s*|:\s*|\[)[A-Z_]\w*/,
lookbehind: !0
},
fragment: {
pattern: /(\bfragment\s+|\.{3}\s*(?!on\b))[a-zA-Z_]\w*/,
lookbehind: !0,
alias: "function"
},
"definition-mutation": {
pattern: /(\bmutation\s+)[a-zA-Z_]\w*/,
lookbehind: !0,
alias: "function"
},
"definition-query": {
pattern: /(\bquery\s+)[a-zA-Z_]\w*/,
lookbehind: !0,
alias: "function"
},
keyword: /\b(?:directive|enum|extend|fragment|implements|input|interface|mutation|on|query|repeatable|scalar|schema|subscription|type|union)\b/,
operator: /[!=|&]|\.{3}/,
"property-query": /\w+(?=\s*\()/,
object: /\w+(?=\s*\{)/,
punctuation: /[!(){}\[\]:=,]/,
property: /\w+/
}, Prism.hooks.add("after-tokenize", function(env) {
if (env.language !== "graphql")
return;
var validTokens = env.tokens.filter(function(token) {
return typeof token != "string" && token.type !== "comment" && token.type !== "scalar";
}), currentIndex = 0;
function getToken(offset) {
return validTokens[currentIndex + offset];
}
function isTokenType(types, offset) {
offset = offset || 0;
for (var i2 = 0; i2 < types.length; i2++) {
var token = getToken(i2 + offset);
if (!token || token.type !== types[i2])
return !1;
}
return !0;
}
function findClosingBracket(open, close) {
for (var stackHeight = 1, i2 = currentIndex; i2 < validTokens.length; i2++) {
var token = validTokens[i2], content = token.content;
if (token.type === "punctuation" && typeof content == "string") {
if (open.test(content))
stackHeight++;
else if (close.test(content) && (stackHeight--, stackHeight === 0))
return i2;
}
}
return -1;
}
function addAlias(token, alias) {
var aliases = token.alias;
aliases ? Array.isArray(aliases) || (token.alias = aliases = [aliases]) : token.alias = aliases = [], aliases.push(alias);
}
for (; currentIndex < validTokens.length; ) {
var startToken = validTokens[currentIndex++];
if (startToken.type === "keyword" && startToken.content === "mutation") {
var inputVariables = [];
if (isTokenType(["definition-mutation", "punctuation"]) && getToken(1).content === "(") {
currentIndex += 2;
var definitionEnd = findClosingBracket(/^\($/, /^\)$/);
if (definitionEnd === -1)
continue;
for (; currentIndex < definitionEnd; currentIndex++) {
var t = getToken(0);
t.type === "variable" && (addAlias(t, "variable-input"), inputVariables.push(t.content));
}
currentIndex = definitionEnd + 1;
}
if (isTokenType(["punctuation", "property-query"]) && getToken(0).content === "{" && (currentIndex++, addAlias(getToken(0), "property-mutation"), inputVariables.length > 0)) {
var mutationEnd = findClosingBracket(/^\{$/, /^\}$/);
if (mutationEnd === -1)
continue;
for (var i = currentIndex; i < mutationEnd; i++) {
var varToken = validTokens[i];
varToken.type === "variable" && inputVariables.indexOf(varToken.content) >= 0 && addAlias(varToken, "variable-input");
}
}
}
}
});
}
}
});
// ../node_modules/refractor/lang/js-extras.js
var require_js_extras = __commonJS({
"../node_modules/refractor/lang/js-extras.js"(exports, module) {
"use strict";
module.exports = jsExtras2;
jsExtras2.displayName = "jsExtras";
jsExtras2.aliases = [];
function jsExtras2(Prism) {
(function(Prism2) {
Prism2.languages.insertBefore("javascript", "function-variable", {
"method-variable": {
pattern: RegExp(
"(\\.\\s*)" + Prism2.languages.javascript["function-variable"].pattern.source
),
lookbehind: !0,
alias: ["function-variable", "method", "function", "property-access"]
}
}), Prism2.languages.insertBefore("javascript", "function", {
method: {
pattern: RegExp(
"(\\.\\s*)" + Prism2.languages.javascript.function.source
),
lookbehind: !0,
alias: ["function", "property-access"]
}
}), Prism2.languages.insertBefore("javascript", "constant", {
"known-class-name": [
{
// standard built-ins
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects
pattern: /\b(?:(?:Float(?:32|64)|(?:Int|Uint)(?:8|16|32)|Uint8Clamped)?Array|ArrayBuffer|BigInt|Boolean|DataView|Date|Error|Function|Intl|JSON|(?:Weak)?(?:Map|Set)|Math|Number|Object|Promise|Proxy|Reflect|RegExp|String|Symbol|WebAssembly)\b/,
alias: "class-name"
},
{
// errors
pattern: /\b(?:[A-Z]\w*)Error\b/,
alias: "class-name"
}
]
});
function withId(source, flags) {
return RegExp(
source.replace(/<ID>/g, function() {
return /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/.source;
}),
flags
);
}
Prism2.languages.insertBefore("javascript", "keyword", {
imports: {
// https://tc39.es/ecma262/#sec-imports
pattern: withId(
/(\bimport\b\s*)(?:<ID>(?:\s*,\s*(?:\*\s*as\s+<ID>|\{[^{}]*\}))?|\*\s*as\s+<ID>|\{[^{}]*\})(?=\s*\bfrom\b)/.source
),
lookbehind: !0,
inside: Prism2.languages.javascript
},
exports: {
// https://tc39.es/ecma262/#sec-exports
pattern: withId(
/(\bexport\b\s*)(?:\*(?:\s*as\s+<ID>)?(?=\s*\bfrom\b)|\{[^{}]*\})/.source
),
lookbehind: !0,
inside: Prism2.languages.javascript
}
}), Prism2.languages.javascript.keyword.unshift(
{
pattern: /\b(?:as|default|export|from|import)\b/,
alias: "module"
},
{
pattern: /\b(?:await|break|catch|continue|do|else|finally|for|if|return|switch|throw|try|while|yield)\b/,
alias: "control-flow"
},
{
pattern: /\bnull\b/,
alias: ["null", "nil"]
},
{
pattern: /\bundefined\b/,
alias: "nil"
}
), Prism2.languages.insertBefore("javascript", "operator", {
spread: {
pattern: /\.{3}/,
alias: "operator"
},
arrow: {
pattern: /=>/,
alias: "operator"
}
}), Prism2.languages.insertBefore("javascript", "punctuation", {
"property-access": {
pattern: withId(/(\.\s*)#?<ID>/.source),
lookbehind: !0
},
"maybe-class-name": {
pattern: /(^|[^$\w\xA0-\uFFFF])[A-Z][$\w\xA0-\uFFFF]+/,
lookbehind: !0
},
dom: {
// this contains only a few commonly used DOM variables
pattern: /\b(?:document|(?:local|session)Storage|location|navigator|performance|window)\b/,
alias: "variable"
},
console: {
pattern: /\bconsole(?=\s*\.)/,
alias: "class-name"
}
});
for (var maybeClassNameTokens = [
"function",
"function-variable",
"method",
"method-variable",
"property-access"
], i = 0; i < maybeClassNameTokens.length; i++) {
var token = maybeClassNameTokens[i], value = Prism2.languages.javascript[token];
Prism2.util.type(value) === "RegExp" && (value = Prism2.languages.javascript[token] = {
pattern: value
});
var inside = value.inside || {};
value.inside = inside, inside["maybe-class-name"] = /^[A-Z][\s\S]*/;
}
})(Prism);
}
}
});
// ../node_modules/refractor/lang/json.js
var require_json = __commonJS({
"../node_modules/refractor/lang/json.js"(exports, module) {
"use strict";
module.exports = json2;
json2.displayName = "json";
json2.aliases = ["webmanifest"];
function json2(Prism) {
Prism.languages.json = {
property: {
pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?=\s*:)/,
lookbehind: !0,
greedy: !0
},
string: {
pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?!\s*:)/,
lookbehind: !0,
greedy: !0
},
comment: {
pattern: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
greedy: !0
},
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;
}
}
});
// ../node_modules/refractor/lang/jsx.js
var require_jsx = __commonJS({
"../node_modules/refractor/lang/jsx.js"(exports, module) {
"use strict";
module.exports = jsx2;
jsx2.displayName = "jsx";
jsx2.aliases = [];
function jsx2(Prism) {
(function(Prism2) {
var javascript = Prism2.util.clone(Prism2.languages.javascript), space = /(?:\s|\/\/.*(?!.)|\/\*(?:[^*]|\*(?!\/))\*\/)/.source, braces = /(?:\{(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])*\})/.source, spread = /(?:\{<S>*\.{3}(?:[^{}]|<BRACES>)*\})/.source;
function re(source, flags) {
return source = source.replace(/<S>/g, function() {
return space;
}).replace(/<BRACES>/g, function() {
return braces;
}).replace(/<SPREAD>/g, function() {
return spread;
}), RegExp(source, flags);
}
spread = re(spread).source, Prism2.languages.jsx = Prism2.languages.extend("markup", javascript), Prism2.languages.jsx.tag.pattern = re(
/<\/?(?:[\w.:-]+(?:<S>+(?:[\w.:$-]+(?:=(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s{'"/>=]+|<BRACES>))?|<SPREAD>))*<S>*\/?)?>/.source
), Prism2.languages.jsx.tag.inside.tag.pattern = /^<\/?[^\s>\/]*/, Prism2.languages.jsx.tag.inside["attr-value"].pattern = /=(?!\{)(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s'">]+)/, Prism2.languages.jsx.tag.inside.tag.inside["class-name"] = /^[A-Z]\w*(?:\.[A-Z]\w*)*$/, Prism2.languages.jsx.tag.inside.comment = javascript.comment, Prism2.languages.insertBefore(
"inside",
"attr-name",
{
spread: {
pattern: re(/<SPREAD>/.source),
inside: Prism2.languages.jsx
}
},
Prism2.languages.jsx.tag
), Prism2.languages.insertBefore(
"inside",
"special-attr",
{
script: {
// Allow for two levels of nesting
pattern: re(/=<BRACES>/.source),
alias: "language-javascript",
inside: {
"script-punctuation": {
pattern: /^=(?=\{)/,
alias: "punctuation"
},
rest: Prism2.languages.jsx
}
}
},
Prism2.languages.jsx.tag
);
var stringifyToken = function(token) {
return token ? typeof token == "string" ? token : typeof token.content == "string" ? token.content : token.content.map(stringifyToken).join("") : "";
}, walkTokens = function(tokens) {
for (var openedTags = [], i = 0; i < tokens.length; i++) {
var token = tokens[i], notTagNorBrace = !1;
if (typeof token != "string" && (token.type === "tag" && token.content[0] && token.content[0].type === "tag" ? token.content[0].content[0].content === "</" ? openedTags.length > 0 && openedTags[openedTags.length - 1].tagName === stringifyToken(token.content[0].content[1]) && openedTags.pop() : token.content[token.content.length - 1].content === "/>" || openedTags.push({
tagName: stringifyToken(token.content[0].content[1]),
openedBraces: 0
}) : openedTags.length > 0 && token.type === "punctuation" && token.content === "{" ? openedTags[openedTags.length - 1].openedBraces++ : openedTags.length > 0 && openedTags[openedTags.length - 1].openedBraces > 0 && token.type === "punctuation" && token.content === "}" ? openedTags[openedTags.length - 1].openedBraces-- : notTagNorBrace = !0), (notTagNorBrace || typeof token == "string") && openedTags.length > 0 && openedTags[openedTags.length - 1].openedBraces === 0) {
var plainText = stringifyToken(token);
i < tokens.length - 1 && (typeof tokens[i + 1] == "string" || tokens[i + 1].type === "plain-text") && (plainText += stringifyToken(tokens[i + 1]), tokens.splice(i + 1, 1)), i > 0 && (typeof tokens[i - 1] == "string" || tokens[i - 1].type === "plain-text") && (plainText = stringifyToken(tokens[i - 1]) + plainText, tokens.splice(i - 1, 1), i--), tokens[i] = new Prism2.Token(
"plain-text",
plainText,
null,
plainText
);
}
token.content && typeof token.content != "string" && walkTokens(token.content);
}
};
Prism2.hooks.add("after-tokenize", function(env) {
env.language !== "jsx" && env.language !== "tsx" || walkTokens(env.tokens);
});
})(Prism);
}
}
});
// ../node_modules/refractor/lang/markdown.js
var require_markdown = __commonJS({
"../node_modules/refractor/lang/markdown.js"(exports, module) {
"use strict";
module.exports = markdown2;
markdown2.displayName = "markdown";
markdown2.aliases = ["md"];
function markdown2(Prism) {
(function(Prism2) {
var inner = /(?:\\.|[^\\\n\r]|(?:\n|\r\n?)(?![\r\n]))/.source;
function createInline(pattern) {
return pattern = pattern.replace(/<inner>/g, function() {
return inner;
}), RegExp(/((?:^|[^\\])(?:\\{2})*)/.source + "(?:" + pattern + ")");
}
var tableCell = /(?:\\.|``(?:[^`\r\n]|`(?!`))+``|`[^`\r\n]+`|[^\\|\r\n`])+/.source, tableRow = /\|?__(?:\|__)+\|?(?:(?:\n|\r\n?)|(?![\s\S]))/.source.replace(
/__/g,
function() {
return tableCell;
}
), tableLine = /\|?[ \t]*:?-{3,}:?[ \t]*(?:\|[ \t]*:?-{3,}:?[ \t]*)+\|?(?:\n|\r\n?)/.source;
Prism2.languages.markdown = Prism2.languages.extend("markup", {}), Prism2.languages.insertBefore("markdown", "prolog", {
"front-matter-block": {
pattern: /(^(?:\s*[\r\n])?)---(?!.)[\s\S]*?[\r\n]---(?!.)/,
lookbehind: !0,
greedy: !0,
inside: {
punctuation: /^---|---$/,
"front-matter": {
pattern: /\S+(?:\s+\S+)*/,
alias: ["yaml", "language-yaml"],
inside: Prism2.languages.yaml
}
}
},
blockquote: {
// > ...
pattern: /^>(?:[\t ]*>)*/m,
alias: "punctuation"
},
table: {
pattern: RegExp(
"^" + tableRow + tableLine + "(?:" + tableRow + ")*",
"m"
),
inside: {
"table-data-rows": {
pattern: RegExp(
"^(" + tableRow + tableLine + ")(?:" + tableRow + ")*$"
),
lookbehind: !0,
inside: {
"table-data": {
pattern: RegExp(tableCell),
inside: Prism2.languages.markdown
},
punctuation: /\|/
}
},
"table-line": {
pattern: RegExp("^(" + tableRow + ")" + tableLine + "$"),
lookbehind: !0,
inside: {
punctuation: /\||:?-{3,}:?/
}
},
"table-header-row": {
pattern: RegExp("^" + tableRow + "$"),
inside: {
"table-header": {
pattern: RegExp(tableCell),
alias: "important",
inside: Prism2.languages.markdown
},
punctuation: /\|/
}
}
}
},
code: [
{
// Prefixed by 4 spaces or 1 tab and preceded by an empty line
pattern: /((?:^|\n)[ \t]*\n|(?:^|\r\n?)[ \t]*\r\n?)(?: {4}|\t).+(?:(?:\n|\r\n?)(?: {4}|\t).+)*/,
lookbehind: !0,
alias: "keyword"
},
{
// ```optional language
// code block
// ```
pattern: /^```[\s\S]*?^```$/m,
greedy: !0,
inside: {
"code-block": {
pattern: /^(```.*(?:\n|\r\n?))[\s\S]+?(?=(?:\n|\r\n?)^```$)/m,
lookbehind: !0
},
"code-language": {
pattern: /^(```).+/,
lookbehind: !0
},
punctuation: /```/
}
}
],
title: [
{
// title 1
// =======
// title 2
// -------
pattern: /\S.*(?:\n|\r\n?)(?:==+|--+)(?=[ \t]*$)/m,
alias: "important",
inside: {
punctuation: /==+$|--+$/
}
},
{
// # title 1
// ###### title 6
pattern: /(^\s*)#.+/m,
lookbehind: !0,
alias: "important",
inside: {
punctuation: /^#+|#+$/
}
}
],
hr: {
// ***
// ---
// * * *
// -----------
pattern: /(^\s*)([*-])(?:[\t ]*\2){2,}(?=\s*$)/m,
lookbehind: !0,
alias: "punctuation"
},
list: {
// * item
// + item
// - item
// 1. item
pattern: /(^\s*)(?:[*+-]|\d+\.)(?=[\t ].)/m,
lookbehind: !0,
alias: "punctuation"
},
"url-reference": {
// [id]: http://example.com "Optional title"
// [id]: http://example.com 'Optional title'
// [id]: http://example.com (Optional title)
// [id]: <http://example.com> "Optional title"
pattern: /!?\[[^\]]+\]:[\t ]+(?:\S+|<(?:\\.|[^>\\])+>)(?:[\t ]+(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\)))?/,
inside: {
variable: {
pattern: /^(!?\[)[^\]]+/,
lookbehind: !0
},
string: /(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\))$/,
punctuation: /^[\[\]!:]|[<>]/
},
alias: "url"
},
bold: {
// **strong**
// __strong__
// allow one nested instance of italic text using the same delimiter
pattern: createInline(
/\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\b|\*\*(?:(?!\*)<inner>|\*(?:(?!\*)<inner>)+\*)+\*\*/.source
),
lookbehind: !0,
greedy: !0,
inside: {
content: {
pattern: /(^..)[\s\S]+(?=..$)/,
lookbehind: !0,
inside: {}
// see below
},
punctuation: /\*\*|__/
}
},
italic: {
// *em*
// _em_
// allow one nested instance of bold text using the same delimiter
pattern: createInline(
/\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\b|\*(?:(?!\*)<inner>|\*\*(?:(?!\*)<inner>)+\*\*)+\*/.source
),
lookbehind: !0,
greedy: !0,
inside: {
content: {
pattern: /(^.)[\s\S]+(?=.$)/,
lookbehind: !0,
inside: {}
// see below
},
punctuation: /[*_]/
}
},
strike: {
// ~~strike through~~
// ~strike~
// eslint-disable-next-line regexp/strict
pattern: createInline(/(~~?)(?:(?!~)<inner>)+\2/.source),
lookbehind: !0,
greedy: !0,
inside: {
content: {
pattern: /(^~~?)[\s\S]+(?=\1$)/,
lookbehind: !0,
inside: {}
// see below
},
punctuation: /~~?/
}
},
"code-snippet": {
// `code`
// ``code``
pattern: /(^|[^\\`])(?:``[^`\r\n]+(?:`[^`\r\n]+)*``(?!`)|`[^`\r\n]+`(?!`))/,
lookbehind: !0,
greedy: !0,
alias: ["code", "keyword"]
},
url: {
// [example](http://example.com "Optional title")
// [example][id]
// [example] [id]
pattern: createInline(
/!?\[(?:(?!\])<inner>)+\](?:\([^\s)]+(?:[\t ]+"(?:\\.|[^"\\])*")?\)|[ \t]?\[(?:(?!\])<inner>)+\])/.source
),
lookbehind: !0,
greedy: !0,
inside: {
operator: /^!/,
content: {
pattern: /(^\[)[^\]]+(?=\])/,
lookbehind: !0,
inside: {}
// see below
},
variable: {
pattern: /(^\][ \t]?\[)[^\]]+(?=\]$)/,
lookbehind: !0
},
url: {
pattern: /(^\]\()[^\s)]+/,
lookbehind: !0
},
string: {
pattern: /(^[ \t]+)"(?:\\.|[^"\\])*"(?=\)$)/,
lookbehind: !0
}
}
}
}), ["url", "bold", "italic", "strike"].forEach(function(token) {
["url", "bold", "italic", "strike", "code-snippet"].forEach(function(inside) {
token !== inside && (Prism2.languages.markdown[token].inside.content.inside[inside] = Prism2.languages.markdown[inside]);
});
}), Prism2.hooks.add("after-tokenize", function(env) {
if (env.language !== "markdown" && env.language !== "md")
return;
function walkTokens(tokens) {
if (!(!tokens || typeof tokens == "string"))
for (var i = 0, l = tokens.length; i < l; i++) {
var token = tokens[i];
if (token.type !== "code") {
walkTokens(token.content);
continue;
}
var codeLang = token.content[1], codeBlock = token.content[3];
if (codeLang && codeBlock && codeLang.type === "code-language" && codeBlock.type === "code-block" && typeof codeLang.content == "string") {
var lang = codeLang.content.replace(/\b#/g, "sharp").replace(/\b\+\+/g, "pp");
lang = (/[a-z][\w-]*/i.exec(lang) || [""])[0].toLowerCase();
var alias = "language-" + lang;
codeBlock.alias ? typeof codeBlock.alias == "string" ? codeBlock.alias = [codeBlock.alias, alias] : codeBlock.alias.push(alias) : codeBlock.alias = [alias];
}
}
}
walkTokens(env.tokens);
}), Prism2.hooks.add("wrap", function(env) {
if (env.type === "code-block") {
for (var codeLang = "", i = 0, l = env.classes.length; i < l; i++) {
var cls = env.classes[i], match = /language-(.+)/.exec(cls);
if (match) {
codeLang = match[1];
break;
}
}
var grammar = Prism2.languages[codeLang];
if (grammar)
env.content = Prism2.highlight(
textContent(env.content.value),
grammar,
codeLang
);
else if (codeLang && codeLang !== "none" && Prism2.plugins.autoloader) {
var id = "md-" + (/* @__PURE__ */ new Date()).valueOf() + "-" + Math.floor(Math.random() * 1e16);
env.attributes.id = id, Prism2.plugins.autoloader.loadLanguages(codeLang, function() {
var ele = document.getElementById(id);
ele && (ele.innerHTML = Prism2.highlight(
ele.textContent,
Prism2.languages[codeLang],
codeLang
));
});
}
}
});
var tagPattern = RegExp(Prism2.languages.markup.tag.pattern.source, "gi"), KNOWN_ENTITY_NAMES = {
amp: "&",
lt: "<",
gt: ">",
quot: '"'
}, fromCodePoint = String.fromCodePoint || String.fromCharCode;
function textContent(html) {
var text = html.replace(tagPattern, "");
return text = text.replace(/&(\w{1,8}|#x?[\da-f]{1,8});/gi, function(m, code) {
if (code = code.toLowerCase(), code[0] === "#") {
var value;
return code[1] === "x" ? value = parseInt(code.slice(2), 16) : value = Number(code.slice(1)), fromCodePoint(value);
} else {
var known = KNOWN_ENTITY_NAMES[code];
return known || m;
}
}), text;
}
Prism2.languages.md = Prism2.languages.markdown;
})(Prism);
}
}
});
// ../node_modules/refractor/lang/markup.js
var require_markup = __commonJS({
"../node_modules/refractor/lang/markup.js"(exports, module) {
"use strict";
module.exports = markup2;
markup2.displayName = "markup";
markup2.aliases = ["html", "mathml", "svg", "xml", "ssml", "atom", "rss"];
function markup2(Prism) {
Prism.languages.markup = {
comment: {
pattern: /<!--(?:(?!<!--)[\s\S])*?-->/,
greedy: !0
},
prolog: {
pattern: /<\?[\s\S]+?\?>/,
greedy: !0
},
doctype: {
// https://www.w3.org/TR/xml/#NT-doctypedecl
pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
greedy: !0,
inside: {
"internal-subset": {
pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/,
lookbehind: !0,
greedy: !0,
inside: null
// see below
},
string: {
pattern: /"[^"]*"|'[^']*'/,
greedy: !0
},
punctuation: /^<!|>$|[[\]]/,
"doctype-tag": /^DOCTYPE/i,
name: /[^\s<>'"]+/
}
},
cdata: {
pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
greedy: !0
},
tag: {
pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
greedy: !0,
inside: {
tag: {
pattern: /^<\/?[^\s>\/]+/,
inside: {
punctuation: /^<\/?/,
namespace: /^[^\s>\/:]+:/
}
},
"special-attr": [],
"attr-value": {
pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
inside: {
punctuation: [
{
pattern: /^=/,
alias: "attr-equals"
},
/"|'/
]
}
},
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) {
env.type === "entity" && (env.attributes.title = env.content.value.replace(/&/, "&"));
}), 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(tagName, lang) {
var includedCdataInside = {};
includedCdataInside["language-" + lang] = {
pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
lookbehind: !0,
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: !0,
greedy: !0,
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: !0,
inside: {
"attr-name": /^[^\s=]+/,
"attr-value": {
pattern: /=[\s\S]+/,
inside: {
value: {
pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
lookbehind: !0,
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;
}
}
});
// ../node_modules/refractor/lang/typescript.js
var require_typescript = __commonJS({
"../node_modules/refractor/lang/typescript.js"(exports, module) {
"use strict";
module.exports = typescript2;
typescript2.displayName = "typescript";
typescript2.aliases = ["ts"];
function typescript2(Prism) {
(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*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?/,
lookbehind: !0,
greedy: !0,
inside: null
// see below
},
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*(?:[\{*]|$))/
), delete Prism2.languages.typescript.parameter, delete Prism2.languages.typescript["literal-property"];
var typeInside = Prism2.languages.extend("typescript", {});
delete typeInside["class-name"], Prism2.languages.typescript["class-name"].inside = typeInside, Prism2.languages.insertBefore("typescript", "function", {
decorator: {
pattern: /@[$\w\xA0-\uFFFF]+/,
inside: {
at: {
pattern: /^@/,
alias: "operator"
},
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*\()/,
greedy: !0,
inside: {
function: /^#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/,
generic: {
pattern: /<[\s\S]+/,
// everything after the