storybook 10.0.0-beta.9 → 10.0.0-rc.1

package/dist/_browser-chunks/chunk-A4MLX43Y.js

@@ -1,239 +0,0 @@
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/refractor/lang/bash.js
-var require_bash = __commonJS({
-  "../node_modules/refractor/lang/bash.js"(exports, module) {
-    module.exports = bash;
-    bash.displayName = "bash";
-    bash.aliases = ["shell"];
-    function bash(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";
-        var commandAfterHeredoc = {
-          pattern: /(^(["']?)\w+\2)[ \t]+\S.*/,
-          lookbehind: true,
-          alias: "punctuation",
-          // this looks reasonably well in all themes
-          inside: null
-          // see below
-        };
-        var insideString = {
-          bash: commandAfterHeredoc,
-          environment: {
-            pattern: RegExp("\\$" + envVars),
-            alias: "constant"
-          },
-          variable: [
-            // [0]: Arithmetic Environment
-            {
-              pattern: /\$?\(\([\s\S]+?\)\)/,
-              greedy: true,
-              inside: {
-                // If there is a $ sign at the beginning highlight $(( and )) as variable
-                variable: [
-                  {
-                    pattern: /(^\$\(\([\s\S]+)\)\)/,
-                    lookbehind: true
-                  },
-                  /^\$\(\(/
-                ],
-                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: true,
-              inside: {
-                variable: /^\$\(|^`|\)$|`$/
-              }
-            },
-            // [2]: Brace expansion
-            {
-              pattern: /\$\{[^}]+\}/,
-              greedy: true,
-              inside: {
-                operator: /:[-=?+]?|[!\/]|##?|%%?|\^\^?|,,?/,
-                punctuation: /[\[\]]/,
-                environment: {
-                  pattern: RegExp("(\\{)" + envVars),
-                  lookbehind: true,
-                  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: true
-          },
-          "function-name": [
-            // a) function foo {
-            // b) foo() {
-            // c) function foo() {
-            // but not “foo {”
-            {
-              // a) and c)
-              pattern: /(\bfunction\s+)[\w-]+(?=(?:\s*\(?:\s*\))?\s*\{)/,
-              lookbehind: true,
-              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: true
-          },
-          // 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: true,
-                alias: "constant"
-              }
-            },
-            alias: "variable",
-            lookbehind: true
-          },
-          string: [
-            // Support for Here-documents https://en.wikipedia.org/wiki/Here_document
-            {
-              pattern: /((?:^|[^<])<<-?\s*)(\w+)\s[\s\S]*?(?:\r?\n|\r)\2/,
-              lookbehind: true,
-              greedy: true,
-              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: true,
-              greedy: true,
-              inside: {
-                bash: commandAfterHeredoc
-              }
-            },
-            // “Normal” string
-            {
-              // https://www.gnu.org/software/bash/manual/html_node/Double-Quotes.html
-              pattern: /(^|[^\\](?:\\\\)*)"(?:\\[\s\S]|\$\([^)]+\)|\$(?!\()|`[^`]+`|[^"\\`$])*"/,
-              lookbehind: true,
-              greedy: true,
-              inside: insideString
-            },
-            {
-              // https://www.gnu.org/software/bash/manual/html_node/Single-Quotes.html
-              pattern: /(^|[^$\\])'[^']*'/,
-              lookbehind: true,
-              greedy: true
-            },
-            {
-              // https://www.gnu.org/software/bash/manual/html_node/ANSI_002dC-Quoting.html
-              pattern: /\$'(?:[^'\\]|\\[\s\S])*'/,
-              greedy: true,
-              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: true
-          },
-          keyword: {
-            pattern: /(^|[\s;|&]|[<>]\()(?:case|do|done|elif|else|esac|fi|for|function|if|in|select|then|until|while)(?=$|[)\s;|&])/,
-            lookbehind: true
-          },
-          // 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: true,
-            // Alias added to make those easier to distinguish from strings.
-            alias: "class-name"
-          },
-          boolean: {
-            pattern: /(^|[\s;|&]|[<>]\()(?:false|true)(?=$|[)\s;|&])/,
-            lookbehind: true
-          },
-          "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: true
-          }
-        };
-        commandAfterHeredoc.inside = Prism2.languages.bash;
-        var toBeCopied = [
-          "comment",
-          "function-name",
-          "for-or-select",
-          "assign-left",
-          "string",
-          "environment",
-          "function",
-          "keyword",
-          "builtin",
-          "boolean",
-          "file-descriptor",
-          "operator",
-          "punctuation",
-          "number"
-        ];
-        var inside = insideString.variable[1].inside;
-        for (var i = 0; i < toBeCopied.length; i++) {
-          inside[toBeCopied[i]] = Prism2.languages.bash[toBeCopied[i]];
-        }
-        Prism2.languages.shell = Prism2.languages.bash;
-      })(Prism);
-    }
-    __name(bash, "bash");
-  }
-});
-
-export {
-  require_bash
-};

package/dist/_browser-chunks/chunk-A5XGERWS.js

@@ -1,420 +0,0 @@
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/highlight.js/lib/languages/python.js
-var require_python = __commonJS({
-  "../node_modules/highlight.js/lib/languages/python.js"(exports, module) {
-    function source(re) {
-      if (!re) return null;
-      if (typeof re === "string") return re;
-      return re.source;
-    }
-    __name(source, "source");
-    function lookahead(re) {
-      return concat("(?=", re, ")");
-    }
-    __name(lookahead, "lookahead");
-    function concat(...args) {
-      const joined = args.map((x) => source(x)).join("");
-      return joined;
-    }
-    __name(concat, "concat");
-    function python(hljs) {
-      const RESERVED_WORDS = [
-        "and",
-        "as",
-        "assert",
-        "async",
-        "await",
-        "break",
-        "class",
-        "continue",
-        "def",
-        "del",
-        "elif",
-        "else",
-        "except",
-        "finally",
-        "for",
-        "from",
-        "global",
-        "if",
-        "import",
-        "in",
-        "is",
-        "lambda",
-        "nonlocal|10",
-        "not",
-        "or",
-        "pass",
-        "raise",
-        "return",
-        "try",
-        "while",
-        "with",
-        "yield"
-      ];
-      const BUILT_INS = [
-        "__import__",
-        "abs",
-        "all",
-        "any",
-        "ascii",
-        "bin",
-        "bool",
-        "breakpoint",
-        "bytearray",
-        "bytes",
-        "callable",
-        "chr",
-        "classmethod",
-        "compile",
-        "complex",
-        "delattr",
-        "dict",
-        "dir",
-        "divmod",
-        "enumerate",
-        "eval",
-        "exec",
-        "filter",
-        "float",
-        "format",
-        "frozenset",
-        "getattr",
-        "globals",
-        "hasattr",
-        "hash",
-        "help",
-        "hex",
-        "id",
-        "input",
-        "int",
-        "isinstance",
-        "issubclass",
-        "iter",
-        "len",
-        "list",
-        "locals",
-        "map",
-        "max",
-        "memoryview",
-        "min",
-        "next",
-        "object",
-        "oct",
-        "open",
-        "ord",
-        "pow",
-        "print",
-        "property",
-        "range",
-        "repr",
-        "reversed",
-        "round",
-        "set",
-        "setattr",
-        "slice",
-        "sorted",
-        "staticmethod",
-        "str",
-        "sum",
-        "super",
-        "tuple",
-        "type",
-        "vars",
-        "zip"
-      ];
-      const LITERALS = [
-        "__debug__",
-        "Ellipsis",
-        "False",
-        "None",
-        "NotImplemented",
-        "True"
-      ];
-      const TYPES = [
-        "Any",
-        "Callable",
-        "Coroutine",
-        "Dict",
-        "List",
-        "Literal",
-        "Generic",
-        "Optional",
-        "Sequence",
-        "Set",
-        "Tuple",
-        "Type",
-        "Union"
-      ];
-      const KEYWORDS = {
-        $pattern: /[A-Za-z]\w+|__\w+__/,
-        keyword: RESERVED_WORDS,
-        built_in: BUILT_INS,
-        literal: LITERALS,
-        type: TYPES
-      };
-      const PROMPT = {
-        className: "meta",
-        begin: /^(>>>|\.\.\.) /
-      };
-      const SUBST = {
-        className: "subst",
-        begin: /\{/,
-        end: /\}/,
-        keywords: KEYWORDS,
-        illegal: /#/
-      };
-      const LITERAL_BRACKET = {
-        begin: /\{\{/,
-        relevance: 0
-      };
-      const STRING = {
-        className: "string",
-        contains: [hljs.BACKSLASH_ESCAPE],
-        variants: [
-          {
-            begin: /([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?'''/,
-            end: /'''/,
-            contains: [
-              hljs.BACKSLASH_ESCAPE,
-              PROMPT
-            ],
-            relevance: 10
-          },
-          {
-            begin: /([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?"""/,
-            end: /"""/,
-            contains: [
-              hljs.BACKSLASH_ESCAPE,
-              PROMPT
-            ],
-            relevance: 10
-          },
-          {
-            begin: /([fF][rR]|[rR][fF]|[fF])'''/,
-            end: /'''/,
-            contains: [
-              hljs.BACKSLASH_ESCAPE,
-              PROMPT,
-              LITERAL_BRACKET,
-              SUBST
-            ]
-          },
-          {
-            begin: /([fF][rR]|[rR][fF]|[fF])"""/,
-            end: /"""/,
-            contains: [
-              hljs.BACKSLASH_ESCAPE,
-              PROMPT,
-              LITERAL_BRACKET,
-              SUBST
-            ]
-          },
-          {
-            begin: /([uU]|[rR])'/,
-            end: /'/,
-            relevance: 10
-          },
-          {
-            begin: /([uU]|[rR])"/,
-            end: /"/,
-            relevance: 10
-          },
-          {
-            begin: /([bB]|[bB][rR]|[rR][bB])'/,
-            end: /'/
-          },
-          {
-            begin: /([bB]|[bB][rR]|[rR][bB])"/,
-            end: /"/
-          },
-          {
-            begin: /([fF][rR]|[rR][fF]|[fF])'/,
-            end: /'/,
-            contains: [
-              hljs.BACKSLASH_ESCAPE,
-              LITERAL_BRACKET,
-              SUBST
-            ]
-          },
-          {
-            begin: /([fF][rR]|[rR][fF]|[fF])"/,
-            end: /"/,
-            contains: [
-              hljs.BACKSLASH_ESCAPE,
-              LITERAL_BRACKET,
-              SUBST
-            ]
-          },
-          hljs.APOS_STRING_MODE,
-          hljs.QUOTE_STRING_MODE
-        ]
-      };
-      const digitpart = "[0-9](_?[0-9])*";
-      const pointfloat = `(\\b(${digitpart}))?\\.(${digitpart})|\\b(${digitpart})\\.`;
-      const NUMBER = {
-        className: "number",
-        relevance: 0,
-        variants: [
-          // exponentfloat, pointfloat
-          // https://docs.python.org/3.9/reference/lexical_analysis.html#floating-point-literals
-          // optionally imaginary
-          // https://docs.python.org/3.9/reference/lexical_analysis.html#imaginary-literals
-          // Note: no leading \b because floats can start with a decimal point
-          // and we don't want to mishandle e.g. `fn(.5)`,
-          // no trailing \b for pointfloat because it can end with a decimal point
-          // and we don't want to mishandle e.g. `0..hex()`; this should be safe
-          // because both MUST contain a decimal point and so cannot be confused with
-          // the interior part of an identifier
-          {
-            begin: `(\\b(${digitpart})|(${pointfloat}))[eE][+-]?(${digitpart})[jJ]?\\b`
-          },
-          {
-            begin: `(${pointfloat})[jJ]?`
-          },
-          // decinteger, bininteger, octinteger, hexinteger
-          // https://docs.python.org/3.9/reference/lexical_analysis.html#integer-literals
-          // optionally "long" in Python 2
-          // https://docs.python.org/2.7/reference/lexical_analysis.html#integer-and-long-integer-literals
-          // decinteger is optionally imaginary
-          // https://docs.python.org/3.9/reference/lexical_analysis.html#imaginary-literals
-          {
-            begin: "\\b([1-9](_?[0-9])*|0+(_?0)*)[lLjJ]?\\b"
-          },
-          {
-            begin: "\\b0[bB](_?[01])+[lL]?\\b"
-          },
-          {
-            begin: "\\b0[oO](_?[0-7])+[lL]?\\b"
-          },
-          {
-            begin: "\\b0[xX](_?[0-9a-fA-F])+[lL]?\\b"
-          },
-          // imagnumber (digitpart-based)
-          // https://docs.python.org/3.9/reference/lexical_analysis.html#imaginary-literals
-          {
-            begin: `\\b(${digitpart})[jJ]\\b`
-          }
-        ]
-      };
-      const COMMENT_TYPE = {
-        className: "comment",
-        begin: lookahead(/# type:/),
-        end: /$/,
-        keywords: KEYWORDS,
-        contains: [
-          {
-            // prevent keywords from coloring `type`
-            begin: /# type:/
-          },
-          // comment within a datatype comment includes no keywords
-          {
-            begin: /#/,
-            end: /\b\B/,
-            endsWithParent: true
-          }
-        ]
-      };
-      const PARAMS = {
-        className: "params",
-        variants: [
-          // Exclude params in functions without params
-          {
-            className: "",
-            begin: /\(\s*\)/,
-            skip: true
-          },
-          {
-            begin: /\(/,
-            end: /\)/,
-            excludeBegin: true,
-            excludeEnd: true,
-            keywords: KEYWORDS,
-            contains: [
-              "self",
-              PROMPT,
-              NUMBER,
-              STRING,
-              hljs.HASH_COMMENT_MODE
-            ]
-          }
-        ]
-      };
-      SUBST.contains = [
-        STRING,
-        NUMBER,
-        PROMPT
-      ];
-      return {
-        name: "Python",
-        aliases: [
-          "py",
-          "gyp",
-          "ipython"
-        ],
-        keywords: KEYWORDS,
-        illegal: /(<\/|->|\?)|=>/,
-        contains: [
-          PROMPT,
-          NUMBER,
-          {
-            // very common convention
-            begin: /\bself\b/
-          },
-          {
-            // eat "if" prior to string so that it won't accidentally be
-            // labeled as an f-string
-            beginKeywords: "if",
-            relevance: 0
-          },
-          STRING,
-          COMMENT_TYPE,
-          hljs.HASH_COMMENT_MODE,
-          {
-            variants: [
-              {
-                className: "function",
-                beginKeywords: "def"
-              },
-              {
-                className: "class",
-                beginKeywords: "class"
-              }
-            ],
-            end: /:/,
-            illegal: /[${=;\n,]/,
-            contains: [
-              hljs.UNDERSCORE_TITLE_MODE,
-              PARAMS,
-              {
-                begin: /->/,
-                endsWithParent: true,
-                keywords: KEYWORDS
-              }
-            ]
-          },
-          {
-            className: "meta",
-            begin: /^[\t ]*@/,
-            end: /(?=#)|$/,
-            contains: [
-              NUMBER,
-              PARAMS,
-              STRING
-            ]
-          }
-        ]
-      };
-    }
-    __name(python, "python");
-    module.exports = python;
-  }
-});
-
-export {
-  require_python
-};

package/dist/_browser-chunks/chunk-AGG3X3HS.js

@@ -1,44 +0,0 @@
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/refractor/lang/nasm.js
-var require_nasm = __commonJS({
-  "../node_modules/refractor/lang/nasm.js"(exports, module) {
-    module.exports = nasm;
-    nasm.displayName = "nasm";
-    nasm.aliases = [];
-    function nasm(Prism) {
-      Prism.languages.nasm = {
-        comment: /;.*$/m,
-        string: /(["'`])(?:\\.|(?!\1)[^\\\r\n])*\1/,
-        label: {
-          pattern: /(^\s*)[A-Za-z._?$][\w.?$@~#]*:/m,
-          lookbehind: true,
-          alias: "function"
-        },
-        keyword: [
-          /\[?BITS (?:16|32|64)\]?/,
-          {
-            pattern: /(^\s*)section\s*[a-z.]+:?/im,
-            lookbehind: true
-          },
-          /(?:extern|global)[^;\r\n]*/i,
-          /(?:CPU|DEFAULT|FLOAT).*$/m
-        ],
-        register: {
-          pattern: /\b(?:st\d|[xyz]mm\d\d?|[cdt]r\d|r\d\d?[bwd]?|[er]?[abcd]x|[abcd][hl]|[er]?(?:bp|di|si|sp)|[cdefgs]s)\b/i,
-          alias: "variable"
-        },
-        number: /(?:\b|(?=\$))(?:0[hx](?:\.[\da-f]+|[\da-f]+(?:\.[\da-f]+)?)(?:p[+-]?\d+)?|\d[\da-f]+[hx]|\$\d[\da-f]*|0[oq][0-7]+|[0-7]+[oq]|0[by][01]+|[01]+[by]|0[dt]\d+|(?:\d+(?:\.\d+)?|\.\d+)(?:\.?e[+-]?\d+)?[dt]?)\b/i,
-        operator: /[\[\]*+\-\/%<>=&|$!]/
-      };
-    }
-    __name(nasm, "nasm");
-  }
-});
-
-export {
-  require_nasm
-};