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

package/dist/_browser-chunks/chunk-7WCWWVLB.js

@@ -1,36 +0,0 @@
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/refractor/lang/gcode.js
-var require_gcode = __commonJS({
-  "../node_modules/refractor/lang/gcode.js"(exports, module) {
-    module.exports = gcode;
-    gcode.displayName = "gcode";
-    gcode.aliases = [];
-    function gcode(Prism) {
-      Prism.languages.gcode = {
-        comment: /;.*|\B\(.*?\)\B/,
-        string: {
-          pattern: /"(?:""|[^"])*"/,
-          greedy: true
-        },
-        keyword: /\b[GM]\d+(?:\.\d+)?\b/,
-        property: /\b[A-Z]/,
-        checksum: {
-          pattern: /(\*)\d+/,
-          lookbehind: true,
-          alias: "number"
-        },
-        // T0:0:0
-        punctuation: /[:*]/
-      };
-    }
-    __name(gcode, "gcode");
-  }
-});
-
-export {
-  require_gcode
-};

package/dist/_browser-chunks/chunk-7WH22TYV.js

@@ -1,62 +0,0 @@
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/refractor/lang/nim.js
-var require_nim = __commonJS({
-  "../node_modules/refractor/lang/nim.js"(exports, module) {
-    module.exports = nim;
-    nim.displayName = "nim";
-    nim.aliases = [];
-    function nim(Prism) {
-      Prism.languages.nim = {
-        comment: {
-          pattern: /#.*/,
-          greedy: true
-        },
-        string: {
-          // Double-quoted strings can be prefixed by an identifier (Generalized raw string literals)
-          pattern: /(?:\b(?!\d)(?:\w|\\x[89a-fA-F][0-9a-fA-F])+)?(?:"""[\s\S]*?"""(?!")|"(?:\\[\s\S]|""|[^"\\])*")/,
-          greedy: true
-        },
-        char: {
-          // Character literals are handled specifically to prevent issues with numeric type suffixes
-          pattern: /'(?:\\(?:\d+|x[\da-fA-F]{0,2}|.)|[^'])'/,
-          greedy: true
-        },
-        function: {
-          pattern: /(?:(?!\d)(?:\w|\\x[89a-fA-F][0-9a-fA-F])+|`[^`\r\n]+`)\*?(?:\[[^\]]+\])?(?=\s*\()/,
-          greedy: true,
-          inside: {
-            operator: /\*$/
-          }
-        },
-        // We don't want to highlight operators (and anything really) inside backticks
-        identifier: {
-          pattern: /`[^`\r\n]+`/,
-          greedy: true,
-          inside: {
-            punctuation: /`/
-          }
-        },
-        // The negative look ahead prevents wrong highlighting of the .. operator
-        number: /\b(?:0[xXoObB][\da-fA-F_]+|\d[\d_]*(?:(?!\.\.)\.[\d_]*)?(?:[eE][+-]?\d[\d_]*)?)(?:'?[iuf]\d*)?/,
-        keyword: /\b(?:addr|as|asm|atomic|bind|block|break|case|cast|concept|const|continue|converter|defer|discard|distinct|do|elif|else|end|enum|except|export|finally|for|from|func|generic|if|import|include|interface|iterator|let|macro|method|mixin|nil|object|out|proc|ptr|raise|ref|return|static|template|try|tuple|type|using|var|when|while|with|without|yield)\b/,
-        operator: {
-          // Look behind and look ahead prevent wrong highlighting of punctuations [. .] {. .} (. .)
-          // but allow the slice operator .. to take precedence over them
-          // One can define his own operators in Nim so all combination of operators might be an operator.
-          pattern: /(^|[({\[](?=\.\.)|(?![({\[]\.).)(?:(?:[=+\-*\/<>@$~&%|!?^:\\]|\.\.|\.(?![)}\]]))+|\b(?:and|div|in|is|isnot|mod|not|notin|of|or|shl|shr|xor)\b)/m,
-          lookbehind: true
-        },
-        punctuation: /[({\[]\.|\.[)}\]]|[`(){}\[\],:]/
-      };
-    }
-    __name(nim, "nim");
-  }
-});
-
-export {
-  require_nim
-};

package/dist/_browser-chunks/chunk-7Y3XUAEO.js

@@ -1,137 +0,0 @@
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/refractor/lang/xeora.js
-var require_xeora = __commonJS({
-  "../node_modules/refractor/lang/xeora.js"(exports, module) {
-    module.exports = xeora;
-    xeora.displayName = "xeora";
-    xeora.aliases = ["xeoracube"];
-    function xeora(Prism) {
-      ;
-      (function(Prism2) {
-        Prism2.languages.xeora = Prism2.languages.extend("markup", {
-          constant: {
-            pattern: /\$(?:DomainContents|PageRenderDuration)\$/,
-            inside: {
-              punctuation: {
-                pattern: /\$/
-              }
-            }
-          },
-          variable: {
-            pattern: /\$@?(?:#+|[-+*~=^])?[\w.]+\$/,
-            inside: {
-              punctuation: {
-                pattern: /[$.]/
-              },
-              operator: {
-                pattern: /#+|[-+*~=^@]/
-              }
-            }
-          },
-          "function-inline": {
-            pattern: /\$F:[-\w.]+\?[-\w.]+(?:,(?:(?:@[-#]*\w+\.[\w+.]\.*)*\|)*(?:(?:[\w+]|[-#*.~^]+[\w+]|=\S)(?:[^$=]|=+[^=])*=*|(?:@[-#]*\w+\.[\w+.]\.*)+(?:(?:[\w+]|[-#*~^][-#*.~^]*[\w+]|=\S)(?:[^$=]|=+[^=])*=*)?)?)?\$/,
-            inside: {
-              variable: {
-                pattern: /(?:[,|])@?(?:#+|[-+*~=^])?[\w.]+/,
-                inside: {
-                  punctuation: {
-                    pattern: /[,.|]/
-                  },
-                  operator: {
-                    pattern: /#+|[-+*~=^@]/
-                  }
-                }
-              },
-              punctuation: {
-                pattern: /\$\w:|[$:?.,|]/
-              }
-            },
-            alias: "function"
-          },
-          "function-block": {
-            pattern: /\$XF:\{[-\w.]+\?[-\w.]+(?:,(?:(?:@[-#]*\w+\.[\w+.]\.*)*\|)*(?:(?:[\w+]|[-#*.~^]+[\w+]|=\S)(?:[^$=]|=+[^=])*=*|(?:@[-#]*\w+\.[\w+.]\.*)+(?:(?:[\w+]|[-#*~^][-#*.~^]*[\w+]|=\S)(?:[^$=]|=+[^=])*=*)?)?)?\}:XF\$/,
-            inside: {
-              punctuation: {
-                pattern: /[$:{}?.,|]/
-              }
-            },
-            alias: "function"
-          },
-          "directive-inline": {
-            pattern: /\$\w(?:#\d+\+?)?(?:\[[-\w.]+\])?:[-\/\w.]+\$/,
-            inside: {
-              punctuation: {
-                pattern: /\$(?:\w:|C(?:\[|#\d))?|[:{[\]]/,
-                inside: {
-                  tag: {
-                    pattern: /#\d/
-                  }
-                }
-              }
-            },
-            alias: "function"
-          },
-          "directive-block-open": {
-            pattern: /\$\w+:\{|\$\w(?:#\d+\+?)?(?:\[[-\w.]+\])?:[-\w.]+:\{(?:![A-Z]+)?/,
-            inside: {
-              punctuation: {
-                pattern: /\$(?:\w:|C(?:\[|#\d))?|[:{[\]]/,
-                inside: {
-                  tag: {
-                    pattern: /#\d/
-                  }
-                }
-              },
-              attribute: {
-                pattern: /![A-Z]+$/,
-                inside: {
-                  punctuation: {
-                    pattern: /!/
-                  }
-                },
-                alias: "keyword"
-              }
-            },
-            alias: "function"
-          },
-          "directive-block-separator": {
-            pattern: /\}:[-\w.]+:\{/,
-            inside: {
-              punctuation: {
-                pattern: /[:{}]/
-              }
-            },
-            alias: "function"
-          },
-          "directive-block-close": {
-            pattern: /\}:[-\w.]+\$/,
-            inside: {
-              punctuation: {
-                pattern: /[:{}$]/
-              }
-            },
-            alias: "function"
-          }
-        });
-        Prism2.languages.insertBefore(
-          "inside",
-          "punctuation",
-          {
-            variable: Prism2.languages.xeora["function-inline"].inside["variable"]
-          },
-          Prism2.languages.xeora["function-block"]
-        );
-        Prism2.languages.xeoracube = Prism2.languages.xeora;
-      })(Prism);
-    }
-    __name(xeora, "xeora");
-  }
-});
-
-export {
-  require_xeora
-};

package/dist/_browser-chunks/chunk-7Y6D7NRG.js

@@ -1,112 +0,0 @@
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/refractor/lang/java.js
-var require_java = __commonJS({
-  "../node_modules/refractor/lang/java.js"(exports, module) {
-    module.exports = java;
-    java.displayName = "java";
-    java.aliases = [];
-    function java(Prism) {
-      ;
-      (function(Prism2) {
-        var keywords = /\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|requires|return|sealed|short|static|strictfp|super|switch|synchronized|this|throw|throws|to|transient|transitive|try|uses|var|void|volatile|while|with|yield)\b/;
-        var classNamePrefix = /(^|[^\w.])(?:[a-z]\w*\s*\.\s*)*(?:[A-Z]\w*\s*\.\s*)*/.source;
-        var className = {
-          pattern: RegExp(classNamePrefix + /[A-Z](?:[\d_A-Z]*[a-z]\w*)?\b/.source),
-          lookbehind: true,
-          inside: {
-            namespace: {
-              pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/,
-              inside: {
-                punctuation: /\./
-              }
-            },
-            punctuation: /\./
-          }
-        };
-        Prism2.languages.java = Prism2.languages.extend("clike", {
-          string: {
-            pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"/,
-            lookbehind: true,
-            greedy: true
-          },
-          "class-name": [
-            className,
-            {
-              // variables and parameters
-              // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)
-              pattern: RegExp(
-                classNamePrefix + /[A-Z]\w*(?=\s+\w+\s*[;,=()])/.source
-              ),
-              lookbehind: true,
-              inside: className.inside
-            }
-          ],
-          keyword: keywords,
-          function: [
-            Prism2.languages.clike.function,
-            {
-              pattern: /(::\s*)[a-z_]\w*/,
-              lookbehind: true
-            }
-          ],
-          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: true
-          }
-        });
-        Prism2.languages.insertBefore("java", "string", {
-          "triple-quoted-string": {
-            // http://openjdk.java.net/jeps/355#Description
-            pattern: /"""[ \t]*[\r\n](?:(?:"|"")?(?:\\.|[^"\\]))*"""/,
-            greedy: true,
-            alias: "string"
-          },
-          char: {
-            pattern: /'(?:\\.|[^'\\\r\n]){1,6}'/,
-            greedy: true
-          }
-        });
-        Prism2.languages.insertBefore("java", "class-name", {
-          annotation: {
-            pattern: /(^|[^.])@\w+(?:\s*\.\s*\w+)*/,
-            lookbehind: true,
-            alias: "punctuation"
-          },
-          generics: {
-            pattern: /<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&))*>)*>)*>)*>/,
-            inside: {
-              "class-name": className,
-              keyword: keywords,
-              punctuation: /[<>(),.:]/,
-              operator: /[?&|]/
-            }
-          },
-          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 keywords.source;
-                }
-              )
-            ),
-            lookbehind: true,
-            inside: {
-              punctuation: /\./
-            }
-          }
-        });
-      })(Prism);
-    }
-    __name(java, "java");
-  }
-});
-
-export {
-  require_java
-};

package/dist/_browser-chunks/chunk-7YZFNJ2V.js

@@ -1,134 +0,0 @@
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/refractor/lang/scheme.js
-var require_scheme = __commonJS({
-  "../node_modules/refractor/lang/scheme.js"(exports, module) {
-    module.exports = scheme;
-    scheme.displayName = "scheme";
-    scheme.aliases = [];
-    function scheme(Prism) {
-      ;
-      (function(Prism2) {
-        Prism2.languages.scheme = {
-          // this supports "normal" single-line comments:
-          //   ; comment
-          // and (potentially nested) multiline comments:
-          //   #| comment #| nested |# still comment |#
-          // (only 1 level of nesting is supported)
-          comment: /;.*|#;\s*(?:\((?:[^()]|\([^()]*\))*\)|\[(?:[^\[\]]|\[[^\[\]]*\])*\])|#\|(?:[^#|]|#(?!\|)|\|(?!#)|#\|(?:[^#|]|#(?!\|)|\|(?!#))*\|#)*\|#/,
-          string: {
-            pattern: /"(?:[^"\\]|\\.)*"/,
-            greedy: true
-          },
-          symbol: {
-            pattern: /'[^()\[\]#'\s]+/,
-            greedy: true
-          },
-          char: {
-            pattern: /#\\(?:[ux][a-fA-F\d]+\b|[-a-zA-Z]+\b|[\uD800-\uDBFF][\uDC00-\uDFFF]|\S)/,
-            greedy: true
-          },
-          "lambda-parameter": [
-            // https://www.cs.cmu.edu/Groups/AI/html/r4rs/r4rs_6.html#SEC30
-            {
-              pattern: /((?:^|[^'`#])[(\[]lambda\s+)(?:[^|()\[\]'\s]+|\|(?:[^\\|]|\\.)*\|)/,
-              lookbehind: true
-            },
-            {
-              pattern: /((?:^|[^'`#])[(\[]lambda\s+[(\[])[^()\[\]']+/,
-              lookbehind: true
-            }
-          ],
-          keyword: {
-            pattern: /((?:^|[^'`#])[(\[])(?:begin|case(?:-lambda)?|cond(?:-expand)?|define(?:-library|-macro|-record-type|-syntax|-values)?|defmacro|delay(?:-force)?|do|else|except|export|guard|if|import|include(?:-ci|-library-declarations)?|lambda|let(?:rec)?(?:-syntax|-values|\*)?|let\*-values|only|parameterize|prefix|(?:quasi-?)?quote|rename|set!|syntax-(?:case|rules)|unless|unquote(?:-splicing)?|when)(?=[()\[\]\s]|$)/,
-            lookbehind: true
-          },
-          builtin: {
-            // all functions of the base library of R7RS plus some of built-ins of R5Rs
-            pattern: /((?:^|[^'`#])[(\[])(?:abs|and|append|apply|assoc|ass[qv]|binary-port\?|boolean=?\?|bytevector(?:-append|-copy|-copy!|-length|-u8-ref|-u8-set!|\?)?|caar|cadr|call-with-(?:current-continuation|port|values)|call\/cc|car|cdar|cddr|cdr|ceiling|char(?:->integer|-ready\?|\?|<\?|<=\?|=\?|>\?|>=\?)|close-(?:input-port|output-port|port)|complex\?|cons|current-(?:error|input|output)-port|denominator|dynamic-wind|eof-object\??|eq\?|equal\?|eqv\?|error|error-object(?:-irritants|-message|\?)|eval|even\?|exact(?:-integer-sqrt|-integer\?|\?)?|expt|features|file-error\?|floor(?:-quotient|-remainder|\/)?|flush-output-port|for-each|gcd|get-output-(?:bytevector|string)|inexact\??|input-port(?:-open\?|\?)|integer(?:->char|\?)|lcm|length|list(?:->string|->vector|-copy|-ref|-set!|-tail|\?)?|make-(?:bytevector|list|parameter|string|vector)|map|max|member|memq|memv|min|modulo|negative\?|newline|not|null\?|number(?:->string|\?)|numerator|odd\?|open-(?:input|output)-(?:bytevector|string)|or|output-port(?:-open\?|\?)|pair\?|peek-char|peek-u8|port\?|positive\?|procedure\?|quotient|raise|raise-continuable|rational\?|rationalize|read-(?:bytevector|bytevector!|char|error\?|line|string|u8)|real\?|remainder|reverse|round|set-c[ad]r!|square|string(?:->list|->number|->symbol|->utf8|->vector|-append|-copy|-copy!|-fill!|-for-each|-length|-map|-ref|-set!|\?|<\?|<=\?|=\?|>\?|>=\?)?|substring|symbol(?:->string|\?|=\?)|syntax-error|textual-port\?|truncate(?:-quotient|-remainder|\/)?|u8-ready\?|utf8->string|values|vector(?:->list|->string|-append|-copy|-copy!|-fill!|-for-each|-length|-map|-ref|-set!|\?)?|with-exception-handler|write-(?:bytevector|char|string|u8)|zero\?)(?=[()\[\]\s]|$)/,
-            lookbehind: true
-          },
-          operator: {
-            pattern: /((?:^|[^'`#])[(\[])(?:[-+*%/]|[<>]=?|=>?)(?=[()\[\]\s]|$)/,
-            lookbehind: true
-          },
-          number: {
-            // The number pattern from [the R7RS spec](https://small.r7rs.org/attachment/r7rs.pdf).
-            //
-            // <number>      := <num 2>|<num 8>|<num 10>|<num 16>
-            // <num R>       := <prefix R><complex R>
-            // <complex R>   := <real R>(?:@<real R>|<imaginary R>)?|<imaginary R>
-            // <imaginary R> := [+-](?:<ureal R>|(?:inf|nan)\.0)?i
-            // <real R>      := [+-]?<ureal R>|[+-](?:inf|nan)\.0
-            // <ureal R>     := <uint R>(?:\/<uint R>)?
-            //                | <decimal R>
-            //
-            // <decimal 10>  := (?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?
-            // <uint R>      := <digit R>+
-            // <prefix R>    := <radix R>(?:#[ei])?|(?:#[ei])?<radix R>
-            // <radix 2>     := #b
-            // <radix 8>     := #o
-            // <radix 10>    := (?:#d)?
-            // <radix 16>    := #x
-            // <digit 2>     := [01]
-            // <digit 8>     := [0-7]
-            // <digit 10>    := \d
-            // <digit 16>    := [0-9a-f]
-            //
-            // The problem with this grammar is that the resulting regex is way to complex, so we simplify by grouping all
-            // non-decimal bases together. This results in a decimal (dec) and combined binary, octal, and hexadecimal (box)
-            // pattern:
-            pattern: RegExp(
-              SortedBNF({
-                "<ureal dec>": /\d+(?:\/\d+)|(?:\d+(?:\.\d*)?|\.\d+)(?:[esfdl][+-]?\d+)?/.source,
-                "<real dec>": /[+-]?<ureal dec>|[+-](?:inf|nan)\.0/.source,
-                "<imaginary dec>": /[+-](?:<ureal dec>|(?:inf|nan)\.0)?i/.source,
-                "<complex dec>": /<real dec>(?:@<real dec>|<imaginary dec>)?|<imaginary dec>/.source,
-                "<num dec>": /(?:#d(?:#[ei])?|#[ei](?:#d)?)?<complex dec>/.source,
-                "<ureal box>": /[0-9a-f]+(?:\/[0-9a-f]+)?/.source,
-                "<real box>": /[+-]?<ureal box>|[+-](?:inf|nan)\.0/.source,
-                "<imaginary box>": /[+-](?:<ureal box>|(?:inf|nan)\.0)?i/.source,
-                "<complex box>": /<real box>(?:@<real box>|<imaginary box>)?|<imaginary box>/.source,
-                "<num box>": /#[box](?:#[ei])?|(?:#[ei])?#[box]<complex box>/.source,
-                "<number>": /(^|[()\[\]\s])(?:<num dec>|<num box>)(?=[()\[\]\s]|$)/.source
-              }),
-              "i"
-            ),
-            lookbehind: true
-          },
-          boolean: {
-            pattern: /(^|[()\[\]\s])#(?:[ft]|false|true)(?=[()\[\]\s]|$)/,
-            lookbehind: true
-          },
-          function: {
-            pattern: /((?:^|[^'`#])[(\[])(?:[^|()\[\]'\s]+|\|(?:[^\\|]|\\.)*\|)(?=[()\[\]\s]|$)/,
-            lookbehind: true
-          },
-          identifier: {
-            pattern: /(^|[()\[\]\s])\|(?:[^\\|]|\\.)*\|(?=[()\[\]\s]|$)/,
-            lookbehind: true,
-            greedy: true
-          },
-          punctuation: /[()\[\]']/
-        };
-        function SortedBNF(grammar) {
-          for (var key in grammar) {
-            grammar[key] = grammar[key].replace(/<[\w\s]+>/g, function(key2) {
-              return "(?:" + grammar[key2].trim() + ")";
-            });
-          }
-          return grammar[key];
-        }
-        __name(SortedBNF, "SortedBNF");
-      })(Prism);
-    }
-    __name(scheme, "scheme");
-  }
-});
-
-export {
-  require_scheme
-};