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

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

@@ -1,97 +0,0 @@
-import {
-  require_scheme
-} from "./chunk-7YZFNJ2V.js";
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/refractor/lang/lilypond.js
-var require_lilypond = __commonJS({
-  "../node_modules/refractor/lang/lilypond.js"(exports, module) {
-    var refractorScheme = require_scheme();
-    module.exports = lilypond;
-    lilypond.displayName = "lilypond";
-    lilypond.aliases = [];
-    function lilypond(Prism) {
-      Prism.register(refractorScheme);
-      (function(Prism2) {
-        var schemeExpression = /\((?:[^();"#\\]|\\[\s\S]|;.*(?!.)|"(?:[^"\\]|\\.)*"|#(?:\{(?:(?!#\})[\s\S])*#\}|[^{])|<expr>)*\)/.source;
-        var recursivenessLog2 = 5;
-        for (var i = 0; i < recursivenessLog2; i++) {
-          schemeExpression = schemeExpression.replace(/<expr>/g, function() {
-            return schemeExpression;
-          });
-        }
-        schemeExpression = schemeExpression.replace(/<expr>/g, /[^\s\S]/.source);
-        var lilypond2 = Prism2.languages.lilypond = {
-          comment: /%(?:(?!\{).*|\{[\s\S]*?%\})/,
-          "embedded-scheme": {
-            pattern: RegExp(
-              /(^|[=\s])#(?:"(?:[^"\\]|\\.)*"|[^\s()"]*(?:[^\s()]|<expr>))/.source.replace(
-                /<expr>/g,
-                function() {
-                  return schemeExpression;
-                }
-              ),
-              "m"
-            ),
-            lookbehind: true,
-            greedy: true,
-            inside: {
-              scheme: {
-                pattern: /^(#)[\s\S]+$/,
-                lookbehind: true,
-                alias: "language-scheme",
-                inside: {
-                  "embedded-lilypond": {
-                    pattern: /#\{[\s\S]*?#\}/,
-                    greedy: true,
-                    inside: {
-                      punctuation: /^#\{|#\}$/,
-                      lilypond: {
-                        pattern: /[\s\S]+/,
-                        alias: "language-lilypond",
-                        inside: null
-                        // see below
-                      }
-                    }
-                  },
-                  rest: Prism2.languages.scheme
-                }
-              },
-              punctuation: /#/
-            }
-          },
-          string: {
-            pattern: /"(?:[^"\\]|\\.)*"/,
-            greedy: true
-          },
-          "class-name": {
-            pattern: /(\\new\s+)[\w-]+/,
-            lookbehind: true
-          },
-          keyword: {
-            pattern: /\\[a-z][-\w]*/i,
-            inside: {
-              punctuation: /^\\/
-            }
-          },
-          operator: /[=|]|<<|>>/,
-          punctuation: {
-            pattern: /(^|[a-z\d])(?:'+|,+|[_^]?-[_^]?(?:[-+^!>._]|(?=\d))|[_^]\.?|[.!])|[{}()[\]<>^~]|\\[()[\]<>\\!]|--|__/,
-            lookbehind: true
-          },
-          number: /\b\d+(?:\/\d+)?\b/
-        };
-        lilypond2["embedded-scheme"].inside["scheme"].inside["embedded-lilypond"].inside["lilypond"].inside = lilypond2;
-        Prism2.languages.ly = lilypond2;
-      })(Prism);
-    }
-    __name(lilypond, "lilypond");
-  }
-});
-
-export {
-  require_lilypond
-};

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

@@ -1,138 +0,0 @@
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/refractor/lang/livescript.js
-var require_livescript = __commonJS({
-  "../node_modules/refractor/lang/livescript.js"(exports, module) {
-    module.exports = livescript;
-    livescript.displayName = "livescript";
-    livescript.aliases = [];
-    function livescript(Prism) {
-      Prism.languages.livescript = {
-        comment: [
-          {
-            pattern: /(^|[^\\])\/\*[\s\S]*?\*\//,
-            lookbehind: true
-          },
-          {
-            pattern: /(^|[^\\])#.*/,
-            lookbehind: true
-          }
-        ],
-        "interpolated-string": {
-          /* Look-behind and look-ahead prevents wrong behavior of the greedy pattern
-           * forcing it to match """-quoted string when it would otherwise match "-quoted first. */
-          pattern: /(^|[^"])("""|")(?:\\[\s\S]|(?!\2)[^\\])*\2(?!")/,
-          lookbehind: true,
-          greedy: true,
-          inside: {
-            variable: {
-              pattern: /(^|[^\\])#[a-z_](?:-?[a-z]|[\d_])*/m,
-              lookbehind: true
-            },
-            interpolation: {
-              pattern: /(^|[^\\])#\{[^}]+\}/m,
-              lookbehind: true,
-              inside: {
-                "interpolation-punctuation": {
-                  pattern: /^#\{|\}$/,
-                  alias: "variable"
-                }
-                // See rest below
-              }
-            },
-            string: /[\s\S]+/
-          }
-        },
-        string: [
-          {
-            pattern: /('''|')(?:\\[\s\S]|(?!\1)[^\\])*\1/,
-            greedy: true
-          },
-          {
-            pattern: /<\[[\s\S]*?\]>/,
-            greedy: true
-          },
-          /\\[^\s,;\])}]+/
-        ],
-        regex: [
-          {
-            pattern: /\/\/(?:\[[^\r\n\]]*\]|\\.|(?!\/\/)[^\\\[])+\/\/[gimyu]{0,5}/,
-            greedy: true,
-            inside: {
-              comment: {
-                pattern: /(^|[^\\])#.*/,
-                lookbehind: true
-              }
-            }
-          },
-          {
-            pattern: /\/(?:\[[^\r\n\]]*\]|\\.|[^/\\\r\n\[])+\/[gimyu]{0,5}/,
-            greedy: true
-          }
-        ],
-        keyword: {
-          pattern: /(^|(?!-).)\b(?:break|case|catch|class|const|continue|default|do|else|extends|fallthrough|finally|for(?: ever)?|function|if|implements|it|let|loop|new|null|otherwise|own|return|super|switch|that|then|this|throw|try|unless|until|var|void|when|while|yield)(?!-)\b/m,
-          lookbehind: true
-        },
-        "keyword-operator": {
-          pattern: /(^|[^-])\b(?:(?:delete|require|typeof)!|(?:and|by|delete|export|from|import(?: all)?|in|instanceof|is(?: not|nt)?|not|of|or|til|to|typeof|with|xor)(?!-)\b)/m,
-          lookbehind: true,
-          alias: "operator"
-        },
-        boolean: {
-          pattern: /(^|[^-])\b(?:false|no|off|on|true|yes)(?!-)\b/m,
-          lookbehind: true
-        },
-        argument: {
-          // Don't match .&. nor &&
-          pattern: /(^|(?!\.&\.)[^&])&(?!&)\d*/m,
-          lookbehind: true,
-          alias: "variable"
-        },
-        number: /\b(?:\d+~[\da-z]+|\d[\d_]*(?:\.\d[\d_]*)?(?:[a-z]\w*)?)/i,
-        identifier: /[a-z_](?:-?[a-z]|[\d_])*/i,
-        operator: [
-          // Spaced .
-          {
-            pattern: /( )\.(?= )/,
-            lookbehind: true
-          },
-          // Full list, in order:
-          // .= .~ .. ...
-          // .&. .^. .<<. .>>. .>>>.
-          // := :: ::=
-          // &&
-          // || |>
-          // < << <<< <<<<
-          // <- <-- <-! <--!
-          // <~ <~~ <~! <~~!
-          // <| <= <?
-          // > >> >= >?
-          // - -- -> -->
-          // + ++
-          // @ @@
-          // % %%
-          // * **
-          // ! != !~=
-          // !~> !~~>
-          // !-> !-->
-          // ~ ~> ~~> ~=
-          // = ==
-          // ^ ^^
-          // / ?
-          /\.(?:[=~]|\.\.?)|\.(?:[&|^]|<<|>>>?)\.|:(?:=|:=?)|&&|\|[|>]|<(?:<<?<?|--?!?|~~?!?|[|=?])?|>[>=?]?|-(?:->?|>)?|\+\+?|@@?|%%?|\*\*?|!(?:~?=|--?>|~?~>)?|~(?:~?>|=)?|==?|\^\^?|[\/?]/
-        ],
-        punctuation: /[(){}\[\]|.,:;`]/
-      };
-      Prism.languages.livescript["interpolated-string"].inside["interpolation"].inside.rest = Prism.languages.livescript;
-    }
-    __name(livescript, "livescript");
-  }
-});
-
-export {
-  require_livescript
-};

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

@@ -1,63 +0,0 @@
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/refractor/lang/erlang.js
-var require_erlang = __commonJS({
-  "../node_modules/refractor/lang/erlang.js"(exports, module) {
-    module.exports = erlang;
-    erlang.displayName = "erlang";
-    erlang.aliases = [];
-    function erlang(Prism) {
-      Prism.languages.erlang = {
-        comment: /%.+/,
-        string: {
-          pattern: /"(?:\\.|[^\\"\r\n])*"/,
-          greedy: true
-        },
-        "quoted-function": {
-          pattern: /'(?:\\.|[^\\'\r\n])+'(?=\()/,
-          alias: "function"
-        },
-        "quoted-atom": {
-          pattern: /'(?:\\.|[^\\'\r\n])+'/,
-          alias: "atom"
-        },
-        boolean: /\b(?:false|true)\b/,
-        keyword: /\b(?:after|case|catch|end|fun|if|of|receive|try|when)\b/,
-        number: [
-          /\$\\?./,
-          /\b\d+#[a-z0-9]+/i,
-          /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i
-        ],
-        function: /\b[a-z][\w@]*(?=\()/,
-        variable: {
-          // Look-behind is used to prevent wrong highlighting of atoms containing "@"
-          pattern: /(^|[^@])(?:\b|\?)[A-Z_][\w@]*/,
-          lookbehind: true
-        },
-        operator: [
-          /[=\/<>:]=|=[:\/]=|\+\+?|--?|[=*\/!]|\b(?:and|andalso|band|bnot|bor|bsl|bsr|bxor|div|not|or|orelse|rem|xor)\b/,
-          {
-            // We don't want to match <<
-            pattern: /(^|[^<])<(?!<)/,
-            lookbehind: true
-          },
-          {
-            // We don't want to match >>
-            pattern: /(^|[^>])>(?!>)/,
-            lookbehind: true
-          }
-        ],
-        atom: /\b[a-z][\w@]*/,
-        punctuation: /[()[\]{}:;,.#|]|<<|>>/
-      };
-    }
-    __name(erlang, "erlang");
-  }
-});
-
-export {
-  require_erlang
-};

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

@@ -1,76 +0,0 @@
-import {
-  require_csharp
-} from "./chunk-GBR5WRBI.js";
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/refractor/lang/aspnet.js
-var require_aspnet = __commonJS({
-  "../node_modules/refractor/lang/aspnet.js"(exports, module) {
-    var refractorCsharp = require_csharp();
-    module.exports = aspnet;
-    aspnet.displayName = "aspnet";
-    aspnet.aliases = [];
-    function aspnet(Prism) {
-      Prism.register(refractorCsharp);
-      Prism.languages.aspnet = Prism.languages.extend("markup", {
-        "page-directive": {
-          pattern: /<%\s*@.*%>/,
-          alias: "tag",
-          inside: {
-            "page-directive": {
-              pattern: /<%\s*@\s*(?:Assembly|Control|Implements|Import|Master(?:Type)?|OutputCache|Page|PreviousPageType|Reference|Register)?|%>/i,
-              alias: "tag"
-            },
-            rest: Prism.languages.markup.tag.inside
-          }
-        },
-        directive: {
-          pattern: /<%.*%>/,
-          alias: "tag",
-          inside: {
-            directive: {
-              pattern: /<%\s*?[$=%#:]{0,2}|%>/,
-              alias: "tag"
-            },
-            rest: Prism.languages.csharp
-          }
-        }
-      });
-      Prism.languages.aspnet.tag.pattern = /<(?!%)\/?[^\s>\/]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s'">=]+))?)*\s*\/?>/;
-      Prism.languages.insertBefore(
-        "inside",
-        "punctuation",
-        {
-          directive: Prism.languages.aspnet["directive"]
-        },
-        Prism.languages.aspnet.tag.inside["attr-value"]
-      );
-      Prism.languages.insertBefore("aspnet", "comment", {
-        "asp-comment": {
-          pattern: /<%--[\s\S]*?--%>/,
-          alias: ["asp", "comment"]
-        }
-      });
-      Prism.languages.insertBefore(
-        "aspnet",
-        Prism.languages.javascript ? "script" : "tag",
-        {
-          "asp-script": {
-            pattern: /(<script(?=.*runat=['"]?server\b)[^>]*>)[\s\S]*?(?=<\/script>)/i,
-            lookbehind: true,
-            alias: ["asp", "script"],
-            inside: Prism.languages.csharp || {}
-          }
-        }
-      );
-    }
-    __name(aspnet, "aspnet");
-  }
-});
-
-export {
-  require_aspnet
-};

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

@@ -1,63 +0,0 @@
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/refractor/lang/squirrel.js
-var require_squirrel = __commonJS({
-  "../node_modules/refractor/lang/squirrel.js"(exports, module) {
-    module.exports = squirrel;
-    squirrel.displayName = "squirrel";
-    squirrel.aliases = [];
-    function squirrel(Prism) {
-      Prism.languages.squirrel = Prism.languages.extend("clike", {
-        comment: [
-          Prism.languages.clike["comment"][0],
-          {
-            pattern: /(^|[^\\:])(?:\/\/|#).*/,
-            lookbehind: true,
-            greedy: true
-          }
-        ],
-        string: {
-          pattern: /(^|[^\\"'@])(?:@"(?:[^"]|"")*"(?!")|"(?:[^\\\r\n"]|\\.)*")/,
-          lookbehind: true,
-          greedy: true
-        },
-        "class-name": {
-          pattern: /(\b(?:class|enum|extends|instanceof)\s+)\w+(?:\.\w+)*/,
-          lookbehind: true,
-          inside: {
-            punctuation: /\./
-          }
-        },
-        keyword: /\b(?:__FILE__|__LINE__|base|break|case|catch|class|clone|const|constructor|continue|default|delete|else|enum|extends|for|foreach|function|if|in|instanceof|local|null|resume|return|static|switch|this|throw|try|typeof|while|yield)\b/,
-        number: /\b(?:0x[0-9a-fA-F]+|\d+(?:\.(?:\d+|[eE][+-]?\d+))?)\b/,
-        operator: /\+\+|--|<=>|<[-<]|>>>?|&&?|\|\|?|[-+*/%!=<>]=?|[~^]|::?/,
-        punctuation: /[(){}\[\],;.]/
-      });
-      Prism.languages.insertBefore("squirrel", "string", {
-        char: {
-          pattern: /(^|[^\\"'])'(?:[^\\']|\\(?:[xuU][0-9a-fA-F]{0,8}|[\s\S]))'/,
-          lookbehind: true,
-          greedy: true
-        }
-      });
-      Prism.languages.insertBefore("squirrel", "operator", {
-        "attribute-punctuation": {
-          pattern: /<\/|\/>/,
-          alias: "important"
-        },
-        lambda: {
-          pattern: /@(?=\()/,
-          alias: "operator"
-        }
-      });
-    }
-    __name(squirrel, "squirrel");
-  }
-});
-
-export {
-  require_squirrel
-};

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

@@ -1,41 +0,0 @@
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/refractor/lang/warpscript.js
-var require_warpscript = __commonJS({
-  "../node_modules/refractor/lang/warpscript.js"(exports, module) {
-    module.exports = warpscript;
-    warpscript.displayName = "warpscript";
-    warpscript.aliases = [];
-    function warpscript(Prism) {
-      Prism.languages.warpscript = {
-        comment: /#.*|\/\/.*|\/\*[\s\S]*?\*\//,
-        string: {
-          pattern: /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'|<'(?:[^\\']|'(?!>)|\\.)*'>/,
-          greedy: true
-        },
-        variable: /\$\S+/,
-        macro: {
-          pattern: /@\S+/,
-          alias: "property"
-        },
-        // WarpScript doesn't have any keywords, these are all functions under the control category
-        // https://www.warp10.io/tags/control
-        keyword: /\b(?:BREAK|CHECKMACRO|CONTINUE|CUDF|DEFINED|DEFINEDMACRO|EVAL|FAIL|FOR|FOREACH|FORSTEP|IFT|IFTE|MSGFAIL|NRETURN|RETHROW|RETURN|SWITCH|TRY|UDF|UNTIL|WHILE)\b/,
-        number: /[+-]?\b(?:NaN|Infinity|\d+(?:\.\d*)?(?:[Ee][+-]?\d+)?|0x[\da-fA-F]+|0b[01]+)\b/,
-        boolean: /\b(?:F|T|false|true)\b/,
-        punctuation: /<%|%>|[{}[\]()]/,
-        // Some operators from the "operators" category
-        // https://www.warp10.io/tags/operators
-        operator: /==|&&?|\|\|?|\*\*?|>>>?|<<|[<>!~]=?|[-/%^]|\+!?|\b(?:AND|NOT|OR)\b/
-      };
-    }
-    __name(warpscript, "warpscript");
-  }
-});
-
-export {
-  require_warpscript
-};

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

@@ -1,39 +0,0 @@
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/refractor/lang/cil.js
-var require_cil = __commonJS({
-  "../node_modules/refractor/lang/cil.js"(exports, module) {
-    module.exports = cil;
-    cil.displayName = "cil";
-    cil.aliases = [];
-    function cil(Prism) {
-      Prism.languages.cil = {
-        comment: /\/\/.*/,
-        string: {
-          pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
-          greedy: true
-        },
-        directive: {
-          pattern: /(^|\W)\.[a-z]+(?=\s)/,
-          lookbehind: true,
-          alias: "class-name"
-        },
-        // Actually an assembly reference
-        variable: /\[[\w\.]+\]/,
-        keyword: /\b(?:abstract|ansi|assembly|auto|autochar|beforefieldinit|bool|bstr|byvalstr|catch|char|cil|class|currency|date|decimal|default|enum|error|explicit|extends|extern|famandassem|family|famorassem|final(?:ly)?|float32|float64|hidebysig|u?int(?:8|16|32|64)?|iant|idispatch|implements|import|initonly|instance|interface|iunknown|literal|lpstr|lpstruct|lptstr|lpwstr|managed|method|native(?:Type)?|nested|newslot|object(?:ref)?|pinvokeimpl|private|privatescope|public|reqsecobj|rtspecialname|runtime|sealed|sequential|serializable|specialname|static|string|struct|syschar|tbstr|unicode|unmanagedexp|unsigned|value(?:type)?|variant|virtual|void)\b/,
-        function: /\b(?:(?:constrained|no|readonly|tail|unaligned|volatile)\.)?(?:conv\.(?:[iu][1248]?|ovf\.[iu][1248]?(?:\.un)?|r\.un|r4|r8)|ldc\.(?:i4(?:\.\d+|\.[mM]1|\.s)?|i8|r4|r8)|ldelem(?:\.[iu][1248]?|\.r[48]|\.ref|a)?|ldind\.(?:[iu][1248]?|r[48]|ref)|stelem\.?(?:i[1248]?|r[48]|ref)?|stind\.(?:i[1248]?|r[48]|ref)?|end(?:fault|filter|finally)|ldarg(?:\.[0-3s]|a(?:\.s)?)?|ldloc(?:\.\d+|\.s)?|sub(?:\.ovf(?:\.un)?)?|mul(?:\.ovf(?:\.un)?)?|add(?:\.ovf(?:\.un)?)?|stloc(?:\.[0-3s])?|refany(?:type|val)|blt(?:\.un)?(?:\.s)?|ble(?:\.un)?(?:\.s)?|bgt(?:\.un)?(?:\.s)?|bge(?:\.un)?(?:\.s)?|unbox(?:\.any)?|init(?:blk|obj)|call(?:i|virt)?|brfalse(?:\.s)?|bne\.un(?:\.s)?|ldloca(?:\.s)?|brzero(?:\.s)?|brtrue(?:\.s)?|brnull(?:\.s)?|brinst(?:\.s)?|starg(?:\.s)?|leave(?:\.s)?|shr(?:\.un)?|rem(?:\.un)?|div(?:\.un)?|clt(?:\.un)?|alignment|castclass|ldvirtftn|beq(?:\.s)?|ckfinite|ldsflda|ldtoken|localloc|mkrefany|rethrow|cgt\.un|arglist|switch|stsfld|sizeof|newobj|newarr|ldsfld|ldnull|ldflda|isinst|throw|stobj|stfld|ldstr|ldobj|ldlen|ldftn|ldfld|cpobj|cpblk|break|br\.s|xor|shl|ret|pop|not|nop|neg|jmp|dup|cgt|ceq|box|and|or|br)\b/,
-        boolean: /\b(?:false|true)\b/,
-        number: /\b-?(?:0x[0-9a-f]+|\d+)(?:\.[0-9a-f]+)?\b/i,
-        punctuation: /[{}[\];(),:=]|IL_[0-9A-Za-z]+/
-      };
-    }
-    __name(cil, "cil");
-  }
-});
-
-export {
-  require_cil
-};

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

@@ -1,71 +0,0 @@
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/refractor/lang/abap.js
-var require_abap = __commonJS({
-  "../node_modules/refractor/lang/abap.js"(exports, module) {
-    module.exports = abap;
-    abap.displayName = "abap";
-    abap.aliases = [];
-    function abap(Prism) {
-      Prism.languages.abap = {
-        comment: /^\*.*/m,
-        string: /(`|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
-        "string-template": {
-          pattern: /([|}])(?:\\.|[^\\|{\r\n])*(?=[|{])/,
-          lookbehind: true,
-          alias: "string"
-        },
-        /* End Of Line comments should not interfere with strings when the
-        quote character occurs within them. We assume a string being highlighted
-        inside an EOL comment is more acceptable than the opposite.
-        */
-        "eol-comment": {
-          pattern: /(^|\s)".*/m,
-          lookbehind: true,
-          alias: "comment"
-        },
-        keyword: {
-          pattern: /(\s|\.|^)(?:SCIENTIFIC_WITH_LEADING_ZERO|SCALE_PRESERVING_SCIENTIFIC|RMC_COMMUNICATION_FAILURE|END-ENHANCEMENT-SECTION|MULTIPLY-CORRESPONDING|SUBTRACT-CORRESPONDING|VERIFICATION-MESSAGE|DIVIDE-CORRESPONDING|ENHANCEMENT-SECTION|CURRENCY_CONVERSION|RMC_SYSTEM_FAILURE|START-OF-SELECTION|MOVE-CORRESPONDING|RMC_INVALID_STATUS|CUSTOMER-FUNCTION|END-OF-DEFINITION|ENHANCEMENT-POINT|SYSTEM-EXCEPTIONS|ADD-CORRESPONDING|SCALE_PRESERVING|SELECTION-SCREEN|CURSOR-SELECTION|END-OF-SELECTION|LOAD-OF-PROGRAM|SCROLL-BOUNDARY|SELECTION-TABLE|EXCEPTION-TABLE|IMPLEMENTATIONS|PARAMETER-TABLE|RIGHT-JUSTIFIED|UNIT_CONVERSION|AUTHORITY-CHECK|LIST-PROCESSING|SIGN_AS_POSTFIX|COL_BACKGROUND|IMPLEMENTATION|INTERFACE-POOL|TRANSFORMATION|IDENTIFICATION|ENDENHANCEMENT|LINE-SELECTION|INITIALIZATION|LEFT-JUSTIFIED|SELECT-OPTIONS|SELECTION-SETS|COMMUNICATION|CORRESPONDING|DECIMAL_SHIFT|PRINT-CONTROL|VALUE-REQUEST|CHAIN-REQUEST|FUNCTION-POOL|FIELD-SYMBOLS|FUNCTIONALITY|INVERTED-DATE|SELECTION-SET|CLASS-METHODS|OUTPUT-LENGTH|CLASS-CODING|COL_NEGATIVE|ERRORMESSAGE|FIELD-GROUPS|HELP-REQUEST|NO-EXTENSION|NO-TOPOFPAGE|REDEFINITION|DISPLAY-MODE|ENDINTERFACE|EXIT-COMMAND|FIELD-SYMBOL|NO-SCROLLING|SHORTDUMP-ID|ACCESSPOLICY|CLASS-EVENTS|COL_POSITIVE|DECLARATIONS|ENHANCEMENTS|FILTER-TABLE|SWITCHSTATES|SYNTAX-CHECK|TRANSPORTING|ASYNCHRONOUS|SYNTAX-TRACE|TOKENIZATION|USER-COMMAND|WITH-HEADING|ABAP-SOURCE|BREAK-POINT|CHAIN-INPUT|COMPRESSION|FIXED-POINT|NEW-SECTION|NON-UNICODE|OCCURRENCES|RESPONSIBLE|SYSTEM-CALL|TRACE-TABLE|ABBREVIATED|CHAR-TO-HEX|END-OF-FILE|ENDFUNCTION|ENVIRONMENT|ASSOCIATION|COL_HEADING|EDITOR-CALL|END-OF-PAGE|ENGINEERING|IMPLEMENTED|INTENSIFIED|RADIOBUTTON|SYSTEM-EXIT|TOP-OF-PAGE|TRANSACTION|APPLICATION|CONCATENATE|DESTINATION|ENHANCEMENT|IMMEDIATELY|NO-GROUPING|PRECOMPILED|REPLACEMENT|TITLE-LINES|ACTIVATION|BYTE-ORDER|CLASS-POOL|CONNECTION|CONVERSION|DEFINITION|DEPARTMENT|EXPIRATION|INHERITING|MESSAGE-ID|NO-HEADING|PERFORMING|QUEUE-ONLY|RIGHTSPACE|SCIENTIFIC|STATUSINFO|STRUCTURES|SYNCPOINTS|WITH-TITLE|ATTRIBUTES|BOUNDARIES|CLASS-DATA|COL_NORMAL|DD\/MM\/YYYY|DESCENDING|INTERFACES|LINE-COUNT|MM\/DD\/YYYY|NON-UNIQUE|PRESERVING|SELECTIONS|STATEMENTS|SUBROUTINE|TRUNCATION|TYPE-POOLS|ARITHMETIC|BACKGROUND|ENDPROVIDE|EXCEPTIONS|IDENTIFIER|INDEX-LINE|OBLIGATORY|PARAMETERS|PERCENTAGE|PUSHBUTTON|RESOLUTION|COMPONENTS|DEALLOCATE|DISCONNECT|DUPLICATES|FIRST-LINE|HEAD-LINES|NO-DISPLAY|OCCURRENCE|RESPECTING|RETURNCODE|SUBMATCHES|TRACE-FILE|ASCENDING|BYPASSING|ENDMODULE|EXCEPTION|EXCLUDING|EXPORTING|INCREMENT|MATCHCODE|PARAMETER|PARTIALLY|PREFERRED|REFERENCE|REPLACING|RETURNING|SELECTION|SEPARATED|SPECIFIED|STATEMENT|TIMESTAMP|TYPE-POOL|ACCEPTING|APPENDAGE|ASSIGNING|COL_GROUP|COMPARING|CONSTANTS|DANGEROUS|IMPORTING|INSTANCES|LEFTSPACE|LOG-POINT|QUICKINFO|READ-ONLY|SCROLLING|SQLSCRIPT|STEP-LOOP|TOP-LINES|TRANSLATE|APPENDING|AUTHORITY|CHARACTER|COMPONENT|CONDITION|DIRECTORY|DUPLICATE|MESSAGING|RECEIVING|SUBSCREEN|ACCORDING|COL_TOTAL|END-LINES|ENDMETHOD|ENDSELECT|EXPANDING|EXTENSION|INCLUDING|INFOTYPES|INTERFACE|INTERVALS|LINE-SIZE|PF-STATUS|PROCEDURE|PROTECTED|REQUESTED|RESUMABLE|RIGHTPLUS|SAP-SPOOL|SECONDARY|STRUCTURE|SUBSTRING|TABLEVIEW|NUMOFCHAR|ADJACENT|ANALYSIS|ASSIGNED|BACKWARD|CHANNELS|CHECKBOX|CONTINUE|CRITICAL|DATAINFO|DD\/MM\/YY|DURATION|ENCODING|ENDCLASS|FUNCTION|LEFTPLUS|LINEFEED|MM\/DD\/YY|OVERFLOW|RECEIVED|SKIPPING|SORTABLE|STANDARD|SUBTRACT|SUPPRESS|TABSTRIP|TITLEBAR|TRUNCATE|UNASSIGN|WHENEVER|ANALYZER|COALESCE|COMMENTS|CONDENSE|DECIMALS|DEFERRED|ENDWHILE|EXPLICIT|KEYWORDS|MESSAGES|POSITION|PRIORITY|RECEIVER|RENAMING|TIMEZONE|TRAILING|ALLOCATE|CENTERED|CIRCULAR|CONTROLS|CURRENCY|DELETING|DESCRIBE|DISTANCE|ENDCATCH|EXPONENT|EXTENDED|GENERATE|IGNORING|INCLUDES|INTERNAL|MAJOR-ID|MODIFIER|NEW-LINE|OPTIONAL|PROPERTY|ROLLBACK|STARTING|SUPPLIED|ABSTRACT|CHANGING|CONTEXTS|CREATING|CUSTOMER|DATABASE|DAYLIGHT|DEFINING|DISTINCT|DIVISION|ENABLING|ENDCHAIN|ESCAPING|HARMLESS|IMPLICIT|INACTIVE|LANGUAGE|MINOR-ID|MULTIPLY|NEW-PAGE|NO-TITLE|POS_HIGH|SEPARATE|TEXTPOOL|TRANSFER|SELECTOR|DBMAXLEN|ITERATOR|ARCHIVE|BIT-XOR|BYTE-CO|COLLECT|COMMENT|CURRENT|DEFAULT|DISPLAY|ENDFORM|EXTRACT|LEADING|LISTBOX|LOCATOR|MEMBERS|METHODS|NESTING|POS_LOW|PROCESS|PROVIDE|RAISING|RESERVE|SECONDS|SUMMARY|VISIBLE|BETWEEN|BIT-AND|BYTE-CS|CLEANUP|COMPUTE|CONTROL|CONVERT|DATASET|ENDCASE|FORWARD|HEADERS|HOTSPOT|INCLUDE|INVERSE|KEEPING|NO-ZERO|OBJECTS|OVERLAY|PADDING|PATTERN|PROGRAM|REFRESH|SECTION|SUMMING|TESTING|VERSION|WINDOWS|WITHOUT|BIT-NOT|BYTE-CA|BYTE-NA|CASTING|CONTEXT|COUNTRY|DYNAMIC|ENABLED|ENDLOOP|EXECUTE|FRIENDS|HANDLER|HEADING|INITIAL|\*-INPUT|LOGFILE|MAXIMUM|MINIMUM|NO-GAPS|NO-SIGN|PRAGMAS|PRIMARY|PRIVATE|REDUCED|REPLACE|REQUEST|RESULTS|UNICODE|WARNING|ALIASES|BYTE-CN|BYTE-NS|CALLING|COL_KEY|COLUMNS|CONNECT|ENDEXEC|ENTRIES|EXCLUDE|FILTERS|FURTHER|HELP-ID|LOGICAL|MAPPING|MESSAGE|NAMETAB|OPTIONS|PACKAGE|PERFORM|RECEIVE|STATICS|VARYING|BINDING|CHARLEN|GREATER|XSTRLEN|ACCEPT|APPEND|DETAIL|ELSEIF|ENDING|ENDTRY|FORMAT|FRAMES|GIVING|HASHED|HEADER|IMPORT|INSERT|MARGIN|MODULE|NATIVE|OBJECT|OFFSET|REMOTE|RESUME|SAVING|SIMPLE|SUBMIT|TABBED|TOKENS|UNIQUE|UNPACK|UPDATE|WINDOW|YELLOW|ACTUAL|ASPECT|CENTER|CURSOR|DELETE|DIALOG|DIVIDE|DURING|ERRORS|EVENTS|EXTEND|FILTER|HANDLE|HAVING|IGNORE|LITTLE|MEMORY|NO-GAP|OCCURS|OPTION|PERSON|PLACES|PUBLIC|REDUCE|REPORT|RESULT|SINGLE|SORTED|SWITCH|SYNTAX|TARGET|VALUES|WRITER|ASSERT|BLOCKS|BOUNDS|BUFFER|CHANGE|COLUMN|COMMIT|CONCAT|COPIES|CREATE|DDMMYY|DEFINE|ENDIAN|ESCAPE|EXPAND|KERNEL|LAYOUT|LEGACY|LEVELS|MMDDYY|NUMBER|OUTPUT|RANGES|READER|RETURN|SCREEN|SEARCH|SELECT|SHARED|SOURCE|STABLE|STATIC|SUBKEY|SUFFIX|TABLES|UNWIND|YYMMDD|ASSIGN|BACKUP|BEFORE|BINARY|BIT-OR|BLANKS|CLIENT|CODING|COMMON|DEMAND|DYNPRO|EXCEPT|EXISTS|EXPORT|FIELDS|GLOBAL|GROUPS|LENGTH|LOCALE|MEDIUM|METHOD|MODIFY|NESTED|OTHERS|REJECT|SCROLL|SUPPLY|SYMBOL|ENDFOR|STRLEN|ALIGN|BEGIN|BOUND|ENDAT|ENTRY|EVENT|FINAL|FLUSH|GRANT|INNER|SHORT|USING|WRITE|AFTER|BLACK|BLOCK|CLOCK|COLOR|COUNT|DUMMY|EMPTY|ENDDO|ENDON|GREEN|INDEX|INOUT|LEAVE|LEVEL|LINES|MODIF|ORDER|OUTER|RANGE|RESET|RETRY|RIGHT|SMART|SPLIT|STYLE|TABLE|THROW|UNDER|UNTIL|UPPER|UTF-8|WHERE|ALIAS|BLANK|CLEAR|CLOSE|EXACT|FETCH|FIRST|FOUND|GROUP|LLANG|LOCAL|OTHER|REGEX|SPOOL|TITLE|TYPES|VALID|WHILE|ALPHA|BOXED|CATCH|CHAIN|CHECK|CLASS|COVER|ENDIF|EQUIV|FIELD|FLOOR|FRAME|INPUT|LOWER|MATCH|NODES|PAGES|PRINT|RAISE|ROUND|SHIFT|SPACE|SPOTS|STAMP|STATE|TASKS|TIMES|TRMAC|ULINE|UNION|VALUE|WIDTH|EQUAL|LOG10|TRUNC|BLOB|CASE|CEIL|CLOB|COND|EXIT|FILE|GAPS|HOLD|INCL|INTO|KEEP|KEYS|LAST|LINE|LONG|LPAD|MAIL|MODE|OPEN|PINK|READ|ROWS|TEST|THEN|ZERO|AREA|BACK|BADI|BYTE|CAST|EDIT|EXEC|FAIL|FIND|FKEQ|FONT|FREE|GKEQ|HIDE|INIT|ITNO|LATE|LOOP|MAIN|MARK|MOVE|NEXT|NULL|RISK|ROLE|UNIT|WAIT|ZONE|BASE|CALL|CODE|DATA|DATE|FKGE|GKGE|HIGH|KIND|LEFT|LIST|MASK|MESH|NAME|NODE|PACK|PAGE|POOL|SEND|SIGN|SIZE|SOME|STOP|TASK|TEXT|TIME|USER|VARY|WITH|WORD|BLUE|CONV|COPY|DEEP|ELSE|FORM|FROM|HINT|ICON|JOIN|LIKE|LOAD|ONLY|PART|SCAN|SKIP|SORT|TYPE|UNIX|VIEW|WHEN|WORK|ACOS|ASIN|ATAN|COSH|EACH|FRAC|LESS|RTTI|SINH|SQRT|TANH|AVG|BIT|DIV|ISO|LET|OUT|PAD|SQL|ALL|CI_|CPI|END|LOB|LPI|MAX|MIN|NEW|OLE|RUN|SET|\?TO|YES|ABS|ADD|AND|BIG|FOR|HDB|JOB|LOW|NOT|SAP|TRY|VIA|XML|ANY|GET|IDS|KEY|MOD|OFF|PUT|RAW|RED|REF|SUM|TAB|XSD|CNT|COS|EXP|LOG|SIN|TAN|XOR|AT|CO|CP|DO|GT|ID|IF|NS|OR|BT|CA|CS|GE|NA|NB|EQ|IN|LT|NE|NO|OF|ON|PF|TO|AS|BY|CN|IS|LE|NP|UP|E|I|M|O|Z|C|X)\b/i,
-          lookbehind: true
-        },
-        /* Numbers can be only integers. Decimal or Hex appear only as strings */
-        number: /\b\d+\b/,
-        /* Operators must always be surrounded by whitespace, they cannot be put
-        adjacent to operands.
-        */
-        operator: {
-          pattern: /(\s)(?:\*\*?|<[=>]?|>=?|\?=|[-+\/=])(?=\s)/,
-          lookbehind: true
-        },
-        "string-operator": {
-          pattern: /(\s)&&?(?=\s)/,
-          lookbehind: true,
-          /* The official editor highlights */
-          alias: "keyword"
-        },
-        "token-operator": [
-          {
-            /* Special operators used to access structure components, class methods/attributes, etc. */
-            pattern: /(\w)(?:->?|=>|[~|{}])(?=\w)/,
-            lookbehind: true,
-            alias: "punctuation"
-          },
-          {
-            /* Special tokens used do delimit string templates */
-            pattern: /[|{}]/,
-            alias: "punctuation"
-          }
-        ],
-        punctuation: /[,.:()]/
-      };
-    }
-    __name(abap, "abap");
-  }
-});
-
-export {
-  require_abap
-};

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

@@ -1,49 +0,0 @@
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/refractor/lang/asm6502.js
-var require_asm6502 = __commonJS({
-  "../node_modules/refractor/lang/asm6502.js"(exports, module) {
-    module.exports = asm6502;
-    asm6502.displayName = "asm6502";
-    asm6502.aliases = [];
-    function asm6502(Prism) {
-      Prism.languages.asm6502 = {
-        comment: /;.*/,
-        directive: {
-          pattern: /\.\w+(?= )/,
-          alias: "property"
-        },
-        string: /(["'`])(?:\\.|(?!\1)[^\\\r\n])*\1/,
-        "op-code": {
-          pattern: /\b(?:ADC|AND|ASL|BCC|BCS|BEQ|BIT|BMI|BNE|BPL|BRK|BVC|BVS|CLC|CLD|CLI|CLV|CMP|CPX|CPY|DEC|DEX|DEY|EOR|INC|INX|INY|JMP|JSR|LDA|LDX|LDY|LSR|NOP|ORA|PHA|PHP|PLA|PLP|ROL|ROR|RTI|RTS|SBC|SEC|SED|SEI|STA|STX|STY|TAX|TAY|TSX|TXA|TXS|TYA|adc|and|asl|bcc|bcs|beq|bit|bmi|bne|bpl|brk|bvc|bvs|clc|cld|cli|clv|cmp|cpx|cpy|dec|dex|dey|eor|inc|inx|iny|jmp|jsr|lda|ldx|ldy|lsr|nop|ora|pha|php|pla|plp|rol|ror|rti|rts|sbc|sec|sed|sei|sta|stx|sty|tax|tay|tsx|txa|txs|tya)\b/,
-          alias: "keyword"
-        },
-        "hex-number": {
-          pattern: /#?\$[\da-f]{1,4}\b/i,
-          alias: "number"
-        },
-        "binary-number": {
-          pattern: /#?%[01]+\b/,
-          alias: "number"
-        },
-        "decimal-number": {
-          pattern: /#?\b\d+\b/,
-          alias: "number"
-        },
-        register: {
-          pattern: /\b[xya]\b/i,
-          alias: "variable"
-        },
-        punctuation: /[(),:]/
-      };
-    }
-    __name(asm6502, "asm6502");
-  }
-});
-
-export {
-  require_asm6502
-};