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

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

@@ -1,808 +0,0 @@
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/highlight.js/lib/languages/swift.js
-var require_swift = __commonJS({
-  "../node_modules/highlight.js/lib/languages/swift.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 either(...args) {
-      const joined = "(" + args.map((x) => source(x)).join("|") + ")";
-      return joined;
-    }
-    __name(either, "either");
-    var keywordWrapper = /* @__PURE__ */ __name((keyword) => concat(
-      /\b/,
-      keyword,
-      /\w$/.test(keyword) ? /\b/ : /\B/
-    ), "keywordWrapper");
-    var dotKeywords = [
-      "Protocol",
-      // contextual
-      "Type"
-      // contextual
-    ].map(keywordWrapper);
-    var optionalDotKeywords = [
-      "init",
-      "self"
-    ].map(keywordWrapper);
-    var keywordTypes = [
-      "Any",
-      "Self"
-    ];
-    var keywords = [
-      // strings below will be fed into the regular `keywords` engine while regex
-      // will result in additional modes being created to scan for those keywords to
-      // avoid conflicts with other rules
-      "associatedtype",
-      "async",
-      "await",
-      /as\?/,
-      // operator
-      /as!/,
-      // operator
-      "as",
-      // operator
-      "break",
-      "case",
-      "catch",
-      "class",
-      "continue",
-      "convenience",
-      // contextual
-      "default",
-      "defer",
-      "deinit",
-      "didSet",
-      // contextual
-      "do",
-      "dynamic",
-      // contextual
-      "else",
-      "enum",
-      "extension",
-      "fallthrough",
-      /fileprivate\(set\)/,
-      "fileprivate",
-      "final",
-      // contextual
-      "for",
-      "func",
-      "get",
-      // contextual
-      "guard",
-      "if",
-      "import",
-      "indirect",
-      // contextual
-      "infix",
-      // contextual
-      /init\?/,
-      /init!/,
-      "inout",
-      /internal\(set\)/,
-      "internal",
-      "in",
-      "is",
-      // operator
-      "lazy",
-      // contextual
-      "let",
-      "mutating",
-      // contextual
-      "nonmutating",
-      // contextual
-      /open\(set\)/,
-      // contextual
-      "open",
-      // contextual
-      "operator",
-      "optional",
-      // contextual
-      "override",
-      // contextual
-      "postfix",
-      // contextual
-      "precedencegroup",
-      "prefix",
-      // contextual
-      /private\(set\)/,
-      "private",
-      "protocol",
-      /public\(set\)/,
-      "public",
-      "repeat",
-      "required",
-      // contextual
-      "rethrows",
-      "return",
-      "set",
-      // contextual
-      "some",
-      // contextual
-      "static",
-      "struct",
-      "subscript",
-      "super",
-      "switch",
-      "throws",
-      "throw",
-      /try\?/,
-      // operator
-      /try!/,
-      // operator
-      "try",
-      // operator
-      "typealias",
-      /unowned\(safe\)/,
-      // contextual
-      /unowned\(unsafe\)/,
-      // contextual
-      "unowned",
-      // contextual
-      "var",
-      "weak",
-      // contextual
-      "where",
-      "while",
-      "willSet"
-      // contextual
-    ];
-    var literals = [
-      "false",
-      "nil",
-      "true"
-    ];
-    var precedencegroupKeywords = [
-      "assignment",
-      "associativity",
-      "higherThan",
-      "left",
-      "lowerThan",
-      "none",
-      "right"
-    ];
-    var numberSignKeywords = [
-      "#colorLiteral",
-      "#column",
-      "#dsohandle",
-      "#else",
-      "#elseif",
-      "#endif",
-      "#error",
-      "#file",
-      "#fileID",
-      "#fileLiteral",
-      "#filePath",
-      "#function",
-      "#if",
-      "#imageLiteral",
-      "#keyPath",
-      "#line",
-      "#selector",
-      "#sourceLocation",
-      "#warn_unqualified_access",
-      "#warning"
-    ];
-    var builtIns = [
-      "abs",
-      "all",
-      "any",
-      "assert",
-      "assertionFailure",
-      "debugPrint",
-      "dump",
-      "fatalError",
-      "getVaList",
-      "isKnownUniquelyReferenced",
-      "max",
-      "min",
-      "numericCast",
-      "pointwiseMax",
-      "pointwiseMin",
-      "precondition",
-      "preconditionFailure",
-      "print",
-      "readLine",
-      "repeatElement",
-      "sequence",
-      "stride",
-      "swap",
-      "swift_unboxFromSwiftValueWithType",
-      "transcode",
-      "type",
-      "unsafeBitCast",
-      "unsafeDowncast",
-      "withExtendedLifetime",
-      "withUnsafeMutablePointer",
-      "withUnsafePointer",
-      "withVaList",
-      "withoutActuallyEscaping",
-      "zip"
-    ];
-    var operatorHead = either(
-      /[/=\-+!*%<>&|^~?]/,
-      /[\u00A1-\u00A7]/,
-      /[\u00A9\u00AB]/,
-      /[\u00AC\u00AE]/,
-      /[\u00B0\u00B1]/,
-      /[\u00B6\u00BB\u00BF\u00D7\u00F7]/,
-      /[\u2016-\u2017]/,
-      /[\u2020-\u2027]/,
-      /[\u2030-\u203E]/,
-      /[\u2041-\u2053]/,
-      /[\u2055-\u205E]/,
-      /[\u2190-\u23FF]/,
-      /[\u2500-\u2775]/,
-      /[\u2794-\u2BFF]/,
-      /[\u2E00-\u2E7F]/,
-      /[\u3001-\u3003]/,
-      /[\u3008-\u3020]/,
-      /[\u3030]/
-    );
-    var operatorCharacter = either(
-      operatorHead,
-      /[\u0300-\u036F]/,
-      /[\u1DC0-\u1DFF]/,
-      /[\u20D0-\u20FF]/,
-      /[\uFE00-\uFE0F]/,
-      /[\uFE20-\uFE2F]/
-      // TODO: The following characters are also allowed, but the regex isn't supported yet.
-      // /[\u{E0100}-\u{E01EF}]/u
-    );
-    var operator = concat(operatorHead, operatorCharacter, "*");
-    var identifierHead = either(
-      /[a-zA-Z_]/,
-      /[\u00A8\u00AA\u00AD\u00AF\u00B2-\u00B5\u00B7-\u00BA]/,
-      /[\u00BC-\u00BE\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF]/,
-      /[\u0100-\u02FF\u0370-\u167F\u1681-\u180D\u180F-\u1DBF]/,
-      /[\u1E00-\u1FFF]/,
-      /[\u200B-\u200D\u202A-\u202E\u203F-\u2040\u2054\u2060-\u206F]/,
-      /[\u2070-\u20CF\u2100-\u218F\u2460-\u24FF\u2776-\u2793]/,
-      /[\u2C00-\u2DFF\u2E80-\u2FFF]/,
-      /[\u3004-\u3007\u3021-\u302F\u3031-\u303F\u3040-\uD7FF]/,
-      /[\uF900-\uFD3D\uFD40-\uFDCF\uFDF0-\uFE1F\uFE30-\uFE44]/,
-      /[\uFE47-\uFEFE\uFF00-\uFFFD]/
-      // Should be /[\uFE47-\uFFFD]/, but we have to exclude FEFF.
-      // The following characters are also allowed, but the regexes aren't supported yet.
-      // /[\u{10000}-\u{1FFFD}\u{20000-\u{2FFFD}\u{30000}-\u{3FFFD}\u{40000}-\u{4FFFD}]/u,
-      // /[\u{50000}-\u{5FFFD}\u{60000-\u{6FFFD}\u{70000}-\u{7FFFD}\u{80000}-\u{8FFFD}]/u,
-      // /[\u{90000}-\u{9FFFD}\u{A0000-\u{AFFFD}\u{B0000}-\u{BFFFD}\u{C0000}-\u{CFFFD}]/u,
-      // /[\u{D0000}-\u{DFFFD}\u{E0000-\u{EFFFD}]/u
-    );
-    var identifierCharacter = either(
-      identifierHead,
-      /\d/,
-      /[\u0300-\u036F\u1DC0-\u1DFF\u20D0-\u20FF\uFE20-\uFE2F]/
-    );
-    var identifier = concat(identifierHead, identifierCharacter, "*");
-    var typeIdentifier = concat(/[A-Z]/, identifierCharacter, "*");
-    var keywordAttributes = [
-      "autoclosure",
-      concat(/convention\(/, either("swift", "block", "c"), /\)/),
-      "discardableResult",
-      "dynamicCallable",
-      "dynamicMemberLookup",
-      "escaping",
-      "frozen",
-      "GKInspectable",
-      "IBAction",
-      "IBDesignable",
-      "IBInspectable",
-      "IBOutlet",
-      "IBSegueAction",
-      "inlinable",
-      "main",
-      "nonobjc",
-      "NSApplicationMain",
-      "NSCopying",
-      "NSManaged",
-      concat(/objc\(/, identifier, /\)/),
-      "objc",
-      "objcMembers",
-      "propertyWrapper",
-      "requires_stored_property_inits",
-      "testable",
-      "UIApplicationMain",
-      "unknown",
-      "usableFromInline"
-    ];
-    var availabilityKeywords = [
-      "iOS",
-      "iOSApplicationExtension",
-      "macOS",
-      "macOSApplicationExtension",
-      "macCatalyst",
-      "macCatalystApplicationExtension",
-      "watchOS",
-      "watchOSApplicationExtension",
-      "tvOS",
-      "tvOSApplicationExtension",
-      "swift"
-    ];
-    function swift(hljs) {
-      const WHITESPACE = {
-        match: /\s+/,
-        relevance: 0
-      };
-      const BLOCK_COMMENT = hljs.COMMENT(
-        "/\\*",
-        "\\*/",
-        {
-          contains: ["self"]
-        }
-      );
-      const COMMENTS = [
-        hljs.C_LINE_COMMENT_MODE,
-        BLOCK_COMMENT
-      ];
-      const DOT_KEYWORD = {
-        className: "keyword",
-        begin: concat(/\./, lookahead(either(...dotKeywords, ...optionalDotKeywords))),
-        end: either(...dotKeywords, ...optionalDotKeywords),
-        excludeBegin: true
-      };
-      const KEYWORD_GUARD = {
-        // Consume .keyword to prevent highlighting properties and methods as keywords.
-        match: concat(/\./, either(...keywords)),
-        relevance: 0
-      };
-      const PLAIN_KEYWORDS = keywords.filter((kw) => typeof kw === "string").concat(["_|0"]);
-      const REGEX_KEYWORDS = keywords.filter((kw) => typeof kw !== "string").concat(keywordTypes).map(keywordWrapper);
-      const KEYWORD = {
-        variants: [
-          {
-            className: "keyword",
-            match: either(...REGEX_KEYWORDS, ...optionalDotKeywords)
-          }
-        ]
-      };
-      const KEYWORDS = {
-        $pattern: either(
-          /\b\w+/,
-          // regular keywords
-          /#\w+/
-          // number keywords
-        ),
-        keyword: PLAIN_KEYWORDS.concat(numberSignKeywords),
-        literal: literals
-      };
-      const KEYWORD_MODES = [
-        DOT_KEYWORD,
-        KEYWORD_GUARD,
-        KEYWORD
-      ];
-      const BUILT_IN_GUARD = {
-        // Consume .built_in to prevent highlighting properties and methods.
-        match: concat(/\./, either(...builtIns)),
-        relevance: 0
-      };
-      const BUILT_IN = {
-        className: "built_in",
-        match: concat(/\b/, either(...builtIns), /(?=\()/)
-      };
-      const BUILT_INS = [
-        BUILT_IN_GUARD,
-        BUILT_IN
-      ];
-      const OPERATOR_GUARD = {
-        // Prevent -> from being highlighting as an operator.
-        match: /->/,
-        relevance: 0
-      };
-      const OPERATOR = {
-        className: "operator",
-        relevance: 0,
-        variants: [
-          {
-            match: operator
-          },
-          {
-            // dot-operator: only operators that start with a dot are allowed to use dots as
-            // characters (..., ...<, .*, etc). So there rule here is: a dot followed by one or more
-            // characters that may also include dots.
-            match: `\\.(\\.|${operatorCharacter})+`
-          }
-        ]
-      };
-      const OPERATORS = [
-        OPERATOR_GUARD,
-        OPERATOR
-      ];
-      const decimalDigits = "([0-9]_*)+";
-      const hexDigits = "([0-9a-fA-F]_*)+";
-      const NUMBER = {
-        className: "number",
-        relevance: 0,
-        variants: [
-          // decimal floating-point-literal (subsumes decimal-literal)
-          {
-            match: `\\b(${decimalDigits})(\\.(${decimalDigits}))?([eE][+-]?(${decimalDigits}))?\\b`
-          },
-          // hexadecimal floating-point-literal (subsumes hexadecimal-literal)
-          {
-            match: `\\b0x(${hexDigits})(\\.(${hexDigits}))?([pP][+-]?(${decimalDigits}))?\\b`
-          },
-          // octal-literal
-          {
-            match: /\b0o([0-7]_*)+\b/
-          },
-          // binary-literal
-          {
-            match: /\b0b([01]_*)+\b/
-          }
-        ]
-      };
-      const ESCAPED_CHARACTER = /* @__PURE__ */ __name((rawDelimiter = "") => ({
-        className: "subst",
-        variants: [
-          {
-            match: concat(/\\/, rawDelimiter, /[0\\tnr"']/)
-          },
-          {
-            match: concat(/\\/, rawDelimiter, /u\{[0-9a-fA-F]{1,8}\}/)
-          }
-        ]
-      }), "ESCAPED_CHARACTER");
-      const ESCAPED_NEWLINE = /* @__PURE__ */ __name((rawDelimiter = "") => ({
-        className: "subst",
-        match: concat(/\\/, rawDelimiter, /[\t ]*(?:[\r\n]|\r\n)/)
-      }), "ESCAPED_NEWLINE");
-      const INTERPOLATION = /* @__PURE__ */ __name((rawDelimiter = "") => ({
-        className: "subst",
-        label: "interpol",
-        begin: concat(/\\/, rawDelimiter, /\(/),
-        end: /\)/
-      }), "INTERPOLATION");
-      const MULTILINE_STRING = /* @__PURE__ */ __name((rawDelimiter = "") => ({
-        begin: concat(rawDelimiter, /"""/),
-        end: concat(/"""/, rawDelimiter),
-        contains: [
-          ESCAPED_CHARACTER(rawDelimiter),
-          ESCAPED_NEWLINE(rawDelimiter),
-          INTERPOLATION(rawDelimiter)
-        ]
-      }), "MULTILINE_STRING");
-      const SINGLE_LINE_STRING = /* @__PURE__ */ __name((rawDelimiter = "") => ({
-        begin: concat(rawDelimiter, /"/),
-        end: concat(/"/, rawDelimiter),
-        contains: [
-          ESCAPED_CHARACTER(rawDelimiter),
-          INTERPOLATION(rawDelimiter)
-        ]
-      }), "SINGLE_LINE_STRING");
-      const STRING = {
-        className: "string",
-        variants: [
-          MULTILINE_STRING(),
-          MULTILINE_STRING("#"),
-          MULTILINE_STRING("##"),
-          MULTILINE_STRING("###"),
-          SINGLE_LINE_STRING(),
-          SINGLE_LINE_STRING("#"),
-          SINGLE_LINE_STRING("##"),
-          SINGLE_LINE_STRING("###")
-        ]
-      };
-      const QUOTED_IDENTIFIER = {
-        match: concat(/`/, identifier, /`/)
-      };
-      const IMPLICIT_PARAMETER = {
-        className: "variable",
-        match: /\$\d+/
-      };
-      const PROPERTY_WRAPPER_PROJECTION = {
-        className: "variable",
-        match: `\\$${identifierCharacter}+`
-      };
-      const IDENTIFIERS = [
-        QUOTED_IDENTIFIER,
-        IMPLICIT_PARAMETER,
-        PROPERTY_WRAPPER_PROJECTION
-      ];
-      const AVAILABLE_ATTRIBUTE = {
-        match: /(@|#)available/,
-        className: "keyword",
-        starts: {
-          contains: [
-            {
-              begin: /\(/,
-              end: /\)/,
-              keywords: availabilityKeywords,
-              contains: [
-                ...OPERATORS,
-                NUMBER,
-                STRING
-              ]
-            }
-          ]
-        }
-      };
-      const KEYWORD_ATTRIBUTE = {
-        className: "keyword",
-        match: concat(/@/, either(...keywordAttributes))
-      };
-      const USER_DEFINED_ATTRIBUTE = {
-        className: "meta",
-        match: concat(/@/, identifier)
-      };
-      const ATTRIBUTES = [
-        AVAILABLE_ATTRIBUTE,
-        KEYWORD_ATTRIBUTE,
-        USER_DEFINED_ATTRIBUTE
-      ];
-      const TYPE = {
-        match: lookahead(/\b[A-Z]/),
-        relevance: 0,
-        contains: [
-          {
-            // Common Apple frameworks, for relevance boost
-            className: "type",
-            match: concat(/(AV|CA|CF|CG|CI|CL|CM|CN|CT|MK|MP|MTK|MTL|NS|SCN|SK|UI|WK|XC)/, identifierCharacter, "+")
-          },
-          {
-            // Type identifier
-            className: "type",
-            match: typeIdentifier,
-            relevance: 0
-          },
-          {
-            // Optional type
-            match: /[?!]+/,
-            relevance: 0
-          },
-          {
-            // Variadic parameter
-            match: /\.\.\./,
-            relevance: 0
-          },
-          {
-            // Protocol composition
-            match: concat(/\s+&\s+/, lookahead(typeIdentifier)),
-            relevance: 0
-          }
-        ]
-      };
-      const GENERIC_ARGUMENTS = {
-        begin: /</,
-        end: />/,
-        keywords: KEYWORDS,
-        contains: [
-          ...COMMENTS,
-          ...KEYWORD_MODES,
-          ...ATTRIBUTES,
-          OPERATOR_GUARD,
-          TYPE
-        ]
-      };
-      TYPE.contains.push(GENERIC_ARGUMENTS);
-      const TUPLE_ELEMENT_NAME = {
-        match: concat(identifier, /\s*:/),
-        keywords: "_|0",
-        relevance: 0
-      };
-      const TUPLE = {
-        begin: /\(/,
-        end: /\)/,
-        relevance: 0,
-        keywords: KEYWORDS,
-        contains: [
-          "self",
-          TUPLE_ELEMENT_NAME,
-          ...COMMENTS,
-          ...KEYWORD_MODES,
-          ...BUILT_INS,
-          ...OPERATORS,
-          NUMBER,
-          STRING,
-          ...IDENTIFIERS,
-          ...ATTRIBUTES,
-          TYPE
-        ]
-      };
-      const FUNC_PLUS_TITLE = {
-        beginKeywords: "func",
-        contains: [
-          {
-            className: "title",
-            match: either(QUOTED_IDENTIFIER.match, identifier, operator),
-            // Required to make sure the opening < of the generic parameter clause
-            // isn't parsed as a second title.
-            endsParent: true,
-            relevance: 0
-          },
-          WHITESPACE
-        ]
-      };
-      const GENERIC_PARAMETERS = {
-        begin: /</,
-        end: />/,
-        contains: [
-          ...COMMENTS,
-          TYPE
-        ]
-      };
-      const FUNCTION_PARAMETER_NAME = {
-        begin: either(
-          lookahead(concat(identifier, /\s*:/)),
-          lookahead(concat(identifier, /\s+/, identifier, /\s*:/))
-        ),
-        end: /:/,
-        relevance: 0,
-        contains: [
-          {
-            className: "keyword",
-            match: /\b_\b/
-          },
-          {
-            className: "params",
-            match: identifier
-          }
-        ]
-      };
-      const FUNCTION_PARAMETERS = {
-        begin: /\(/,
-        end: /\)/,
-        keywords: KEYWORDS,
-        contains: [
-          FUNCTION_PARAMETER_NAME,
-          ...COMMENTS,
-          ...KEYWORD_MODES,
-          ...OPERATORS,
-          NUMBER,
-          STRING,
-          ...ATTRIBUTES,
-          TYPE,
-          TUPLE
-        ],
-        endsParent: true,
-        illegal: /["']/
-      };
-      const FUNCTION = {
-        className: "function",
-        match: lookahead(/\bfunc\b/),
-        contains: [
-          FUNC_PLUS_TITLE,
-          GENERIC_PARAMETERS,
-          FUNCTION_PARAMETERS,
-          WHITESPACE
-        ],
-        illegal: [
-          /\[/,
-          /%/
-        ]
-      };
-      const INIT_SUBSCRIPT = {
-        className: "function",
-        match: /\b(subscript|init[?!]?)\s*(?=[<(])/,
-        keywords: {
-          keyword: "subscript init init? init!",
-          $pattern: /\w+[?!]?/
-        },
-        contains: [
-          GENERIC_PARAMETERS,
-          FUNCTION_PARAMETERS,
-          WHITESPACE
-        ],
-        illegal: /\[|%/
-      };
-      const OPERATOR_DECLARATION = {
-        beginKeywords: "operator",
-        end: hljs.MATCH_NOTHING_RE,
-        contains: [
-          {
-            className: "title",
-            match: operator,
-            endsParent: true,
-            relevance: 0
-          }
-        ]
-      };
-      const PRECEDENCEGROUP = {
-        beginKeywords: "precedencegroup",
-        end: hljs.MATCH_NOTHING_RE,
-        contains: [
-          {
-            className: "title",
-            match: typeIdentifier,
-            relevance: 0
-          },
-          {
-            begin: /{/,
-            end: /}/,
-            relevance: 0,
-            endsParent: true,
-            keywords: [
-              ...precedencegroupKeywords,
-              ...literals
-            ],
-            contains: [TYPE]
-          }
-        ]
-      };
-      for (const variant of STRING.variants) {
-        const interpolation = variant.contains.find((mode) => mode.label === "interpol");
-        interpolation.keywords = KEYWORDS;
-        const submodes = [
-          ...KEYWORD_MODES,
-          ...BUILT_INS,
-          ...OPERATORS,
-          NUMBER,
-          STRING,
-          ...IDENTIFIERS
-        ];
-        interpolation.contains = [
-          ...submodes,
-          {
-            begin: /\(/,
-            end: /\)/,
-            contains: [
-              "self",
-              ...submodes
-            ]
-          }
-        ];
-      }
-      return {
-        name: "Swift",
-        keywords: KEYWORDS,
-        contains: [
-          ...COMMENTS,
-          FUNCTION,
-          INIT_SUBSCRIPT,
-          {
-            className: "class",
-            beginKeywords: "struct protocol class extension enum",
-            end: "\\{",
-            excludeEnd: true,
-            keywords: KEYWORDS,
-            contains: [
-              hljs.inherit(hljs.TITLE_MODE, {
-                begin: /[A-Za-z$_][\u00C0-\u02B80-9A-Za-z$_]*/
-              }),
-              ...KEYWORD_MODES
-            ]
-          },
-          OPERATOR_DECLARATION,
-          PRECEDENCEGROUP,
-          {
-            beginKeywords: "import",
-            end: /$/,
-            contains: [...COMMENTS],
-            relevance: 0
-          },
-          ...KEYWORD_MODES,
-          ...BUILT_INS,
-          ...OPERATORS,
-          NUMBER,
-          STRING,
-          ...IDENTIFIERS,
-          ...ATTRIBUTES,
-          TYPE,
-          TUPLE
-        ]
-      };
-    }
-    __name(swift, "swift");
-    module.exports = swift;
-  }
-});
-
-export {
-  require_swift
-};