storybook 10.0.0-rc.0 → 10.0.0-rc.2

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

@@ -1,25 +0,0 @@
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/highlight.js/lib/languages/mizar.js
-var require_mizar = __commonJS({
-  "../node_modules/highlight.js/lib/languages/mizar.js"(exports, module) {
-    function mizar(hljs) {
-      return {
-        name: "Mizar",
-        keywords: "environ vocabularies notations constructors definitions registrations theorems schemes requirements begin end definition registration cluster existence pred func defpred deffunc theorem proof let take assume then thus hence ex for st holds consider reconsider such that and in provided of as from be being by means equals implies iff redefine define now not or attr is mode suppose per cases set thesis contradiction scheme reserve struct correctness compatibility coherence symmetry assymetry reflexivity irreflexivity connectedness uniqueness commutativity idempotence involutiveness projectivity",
-        contains: [
-          hljs.COMMENT("::", "$")
-        ]
-      };
-    }
-    __name(mizar, "mizar");
-    module.exports = mizar;
-  }
-});
-
-export {
-  require_mizar
-};

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

@@ -1,145 +0,0 @@
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/refractor/lang/nevod.js
-var require_nevod = __commonJS({
-  "../node_modules/refractor/lang/nevod.js"(exports, module) {
-    module.exports = nevod;
-    nevod.displayName = "nevod";
-    nevod.aliases = [];
-    function nevod(Prism) {
-      Prism.languages.nevod = {
-        comment: /\/\/.*|(?:\/\*[\s\S]*?(?:\*\/|$))/,
-        string: {
-          pattern: /(?:"(?:""|[^"])*"(?!")|'(?:''|[^'])*'(?!'))!?\*?/,
-          greedy: true,
-          inside: {
-            "string-attrs": /!$|!\*$|\*$/
-          }
-        },
-        namespace: {
-          pattern: /(@namespace\s+)[a-zA-Z0-9\-.]+(?=\s*\{)/,
-          lookbehind: true
-        },
-        pattern: {
-          pattern: /(@pattern\s+)?#?[a-zA-Z0-9\-.]+(?:\s*\(\s*(?:~\s*)?[a-zA-Z0-9\-.]+\s*(?:,\s*(?:~\s*)?[a-zA-Z0-9\-.]*)*\))?(?=\s*=)/,
-          lookbehind: true,
-          inside: {
-            "pattern-name": {
-              pattern: /^#?[a-zA-Z0-9\-.]+/,
-              alias: "class-name"
-            },
-            fields: {
-              pattern: /\(.*\)/,
-              inside: {
-                "field-name": {
-                  pattern: /[a-zA-Z0-9\-.]+/,
-                  alias: "variable"
-                },
-                punctuation: /[,()]/,
-                operator: {
-                  pattern: /~/,
-                  alias: "field-hidden-mark"
-                }
-              }
-            }
-          }
-        },
-        search: {
-          pattern: /(@search\s+|#)[a-zA-Z0-9\-.]+(?:\.\*)?(?=\s*;)/,
-          alias: "function",
-          lookbehind: true
-        },
-        keyword: /@(?:having|inside|namespace|outside|pattern|require|search|where)\b/,
-        "standard-pattern": {
-          pattern: /\b(?:Alpha|AlphaNum|Any|Blank|End|LineBreak|Num|NumAlpha|Punct|Space|Start|Symbol|Word|WordBreak)\b(?:\([a-zA-Z0-9\-.,\s+]*\))?/,
-          inside: {
-            "standard-pattern-name": {
-              pattern: /^[a-zA-Z0-9\-.]+/,
-              alias: "builtin"
-            },
-            quantifier: {
-              pattern: /\b\d+(?:\s*\+|\s*-\s*\d+)?(?!\w)/,
-              alias: "number"
-            },
-            "standard-pattern-attr": {
-              pattern: /[a-zA-Z0-9\-.]+/,
-              alias: "builtin"
-            },
-            punctuation: /[,()]/
-          }
-        },
-        quantifier: {
-          pattern: /\b\d+(?:\s*\+|\s*-\s*\d+)?(?!\w)/,
-          alias: "number"
-        },
-        operator: [
-          {
-            pattern: /=/,
-            alias: "pattern-def"
-          },
-          {
-            pattern: /&/,
-            alias: "conjunction"
-          },
-          {
-            pattern: /~/,
-            alias: "exception"
-          },
-          {
-            pattern: /\?/,
-            alias: "optionality"
-          },
-          {
-            pattern: /[[\]]/,
-            alias: "repetition"
-          },
-          {
-            pattern: /[{}]/,
-            alias: "variation"
-          },
-          {
-            pattern: /[+_]/,
-            alias: "sequence"
-          },
-          {
-            pattern: /\.{2,3}/,
-            alias: "span"
-          }
-        ],
-        "field-capture": [
-          {
-            pattern: /([a-zA-Z0-9\-.]+\s*\()\s*[a-zA-Z0-9\-.]+\s*:\s*[a-zA-Z0-9\-.]+(?:\s*,\s*[a-zA-Z0-9\-.]+\s*:\s*[a-zA-Z0-9\-.]+)*(?=\s*\))/,
-            lookbehind: true,
-            inside: {
-              "field-name": {
-                pattern: /[a-zA-Z0-9\-.]+/,
-                alias: "variable"
-              },
-              colon: /:/
-            }
-          },
-          {
-            pattern: /[a-zA-Z0-9\-.]+\s*:/,
-            inside: {
-              "field-name": {
-                pattern: /[a-zA-Z0-9\-.]+/,
-                alias: "variable"
-              },
-              colon: /:/
-            }
-          }
-        ],
-        punctuation: /[:;,()]/,
-        name: /[a-zA-Z0-9\-.]+/
-      };
-    }
-    __name(nevod, "nevod");
-  }
-});
-
-export {
-  require_nevod
-};

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

@@ -1,119 +0,0 @@
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/refractor/lang/robotframework.js
-var require_robotframework = __commonJS({
-  "../node_modules/refractor/lang/robotframework.js"(exports, module) {
-    module.exports = robotframework;
-    robotframework.displayName = "robotframework";
-    robotframework.aliases = [];
-    function robotframework(Prism) {
-      ;
-      (function(Prism2) {
-        var comment = {
-          pattern: /(^[ \t]*| {2}|\t)#.*/m,
-          lookbehind: true,
-          greedy: true
-        };
-        var variable = {
-          pattern: /((?:^|[^\\])(?:\\{2})*)[$@&%]\{(?:[^{}\r\n]|\{[^{}\r\n]*\})*\}/,
-          lookbehind: true,
-          inside: {
-            punctuation: /^[$@&%]\{|\}$/
-          }
-        };
-        function createSection(name, inside) {
-          var extendecInside = {};
-          extendecInside["section-header"] = {
-            pattern: /^ ?\*{3}.+?\*{3}/,
-            alias: "keyword"
-          };
-          for (var token in inside) {
-            extendecInside[token] = inside[token];
-          }
-          extendecInside["tag"] = {
-            pattern: /([\r\n](?: {2}|\t)[ \t]*)\[[-\w]+\]/,
-            lookbehind: true,
-            inside: {
-              punctuation: /\[|\]/
-            }
-          };
-          extendecInside["variable"] = variable;
-          extendecInside["comment"] = comment;
-          return {
-            pattern: RegExp(
-              /^ ?\*{3}[ \t]*<name>[ \t]*\*{3}(?:.|[\r\n](?!\*{3}))*/.source.replace(
-                /<name>/g,
-                function() {
-                  return name;
-                }
-              ),
-              "im"
-            ),
-            alias: "section",
-            inside: extendecInside
-          };
-        }
-        __name(createSection, "createSection");
-        var docTag = {
-          pattern: /(\[Documentation\](?: {2}|\t)[ \t]*)(?![ \t]|#)(?:.|(?:\r\n?|\n)[ \t]*\.{3})+/,
-          lookbehind: true,
-          alias: "string"
-        };
-        var testNameLike = {
-          pattern: /([\r\n] ?)(?!#)(?:\S(?:[ \t]\S)*)+/,
-          lookbehind: true,
-          alias: "function",
-          inside: {
-            variable
-          }
-        };
-        var testPropertyLike = {
-          pattern: /([\r\n](?: {2}|\t)[ \t]*)(?!\[|\.{3}|#)(?:\S(?:[ \t]\S)*)+/,
-          lookbehind: true,
-          inside: {
-            variable
-          }
-        };
-        Prism2.languages["robotframework"] = {
-          settings: createSection("Settings", {
-            documentation: {
-              pattern: /([\r\n] ?Documentation(?: {2}|\t)[ \t]*)(?![ \t]|#)(?:.|(?:\r\n?|\n)[ \t]*\.{3})+/,
-              lookbehind: true,
-              alias: "string"
-            },
-            property: {
-              pattern: /([\r\n] ?)(?!\.{3}|#)(?:\S(?:[ \t]\S)*)+/,
-              lookbehind: true
-            }
-          }),
-          variables: createSection("Variables"),
-          "test-cases": createSection("Test Cases", {
-            "test-name": testNameLike,
-            documentation: docTag,
-            property: testPropertyLike
-          }),
-          keywords: createSection("Keywords", {
-            "keyword-name": testNameLike,
-            documentation: docTag,
-            property: testPropertyLike
-          }),
-          tasks: createSection("Tasks", {
-            "task-name": testNameLike,
-            documentation: docTag,
-            property: testPropertyLike
-          }),
-          comment
-        };
-        Prism2.languages.robot = Prism2.languages["robotframework"];
-      })(Prism);
-    }
-    __name(robotframework, "robotframework");
-  }
-});
-
-export {
-  require_robotframework
-};

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

@@ -1,66 +0,0 @@
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/highlight.js/lib/languages/dos.js
-var require_dos = __commonJS({
-  "../node_modules/highlight.js/lib/languages/dos.js"(exports, module) {
-    function dos(hljs) {
-      const COMMENT = hljs.COMMENT(
-        /^\s*@?rem\b/,
-        /$/,
-        {
-          relevance: 10
-        }
-      );
-      const LABEL = {
-        className: "symbol",
-        begin: "^\\s*[A-Za-z._?][A-Za-z0-9_$#@~.?]*(:|\\s+label)",
-        relevance: 0
-      };
-      return {
-        name: "Batch file (DOS)",
-        aliases: [
-          "bat",
-          "cmd"
-        ],
-        case_insensitive: true,
-        illegal: /\/\*/,
-        keywords: {
-          keyword: "if else goto for in do call exit not exist errorlevel defined equ neq lss leq gtr geq",
-          built_in: "prn nul lpt3 lpt2 lpt1 con com4 com3 com2 com1 aux shift cd dir echo setlocal endlocal set pause copy append assoc at attrib break cacls cd chcp chdir chkdsk chkntfs cls cmd color comp compact convert date dir diskcomp diskcopy doskey erase fs find findstr format ftype graftabl help keyb label md mkdir mode more move path pause print popd pushd promt rd recover rem rename replace restore rmdir shift sort start subst time title tree type ver verify vol ping net ipconfig taskkill xcopy ren del"
-        },
-        contains: [
-          {
-            className: "variable",
-            begin: /%%[^ ]|%[^ ]+?%|![^ ]+?!/
-          },
-          {
-            className: "function",
-            begin: LABEL.begin,
-            end: "goto:eof",
-            contains: [
-              hljs.inherit(hljs.TITLE_MODE, {
-                begin: "([_a-zA-Z]\\w*\\.)*([_a-zA-Z]\\w*:)?[_a-zA-Z]\\w*"
-              }),
-              COMMENT
-            ]
-          },
-          {
-            className: "number",
-            begin: "\\b\\d+",
-            relevance: 0
-          },
-          COMMENT
-        ]
-      };
-    }
-    __name(dos, "dos");
-    module.exports = dos;
-  }
-});
-
-export {
-  require_dos
-};

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

@@ -1,41 +0,0 @@
-import {
-  require_sql
-} from "./chunk-423QTYGC.js";
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/refractor/lang/plsql.js
-var require_plsql = __commonJS({
-  "../node_modules/refractor/lang/plsql.js"(exports, module) {
-    var refractorSql = require_sql();
-    module.exports = plsql;
-    plsql.displayName = "plsql";
-    plsql.aliases = [];
-    function plsql(Prism) {
-      Prism.register(refractorSql);
-      Prism.languages.plsql = Prism.languages.extend("sql", {
-        comment: {
-          pattern: /\/\*[\s\S]*?\*\/|--.*/,
-          greedy: true
-        },
-        // https://docs.oracle.com/en/database/oracle/oracle-database/21/lnpls/plsql-reserved-words-keywords.html
-        keyword: /\b(?:A|ACCESSIBLE|ADD|AGENT|AGGREGATE|ALL|ALTER|AND|ANY|ARRAY|AS|ASC|AT|ATTRIBUTE|AUTHID|AVG|BEGIN|BETWEEN|BFILE_BASE|BINARY|BLOB_BASE|BLOCK|BODY|BOTH|BOUND|BULK|BY|BYTE|C|CALL|CALLING|CASCADE|CASE|CHAR|CHARACTER|CHARSET|CHARSETFORM|CHARSETID|CHAR_BASE|CHECK|CLOB_BASE|CLONE|CLOSE|CLUSTER|CLUSTERS|COLAUTH|COLLECT|COLUMNS|COMMENT|COMMIT|COMMITTED|COMPILED|COMPRESS|CONNECT|CONSTANT|CONSTRUCTOR|CONTEXT|CONTINUE|CONVERT|COUNT|CRASH|CREATE|CREDENTIAL|CURRENT|CURSOR|CUSTOMDATUM|DANGLING|DATA|DATE|DATE_BASE|DAY|DECLARE|DEFAULT|DEFINE|DELETE|DESC|DETERMINISTIC|DIRECTORY|DISTINCT|DOUBLE|DROP|DURATION|ELEMENT|ELSE|ELSIF|EMPTY|END|ESCAPE|EXCEPT|EXCEPTION|EXCEPTIONS|EXCLUSIVE|EXECUTE|EXISTS|EXIT|EXTERNAL|FETCH|FINAL|FIRST|FIXED|FLOAT|FOR|FORALL|FORCE|FROM|FUNCTION|GENERAL|GOTO|GRANT|GROUP|HASH|HAVING|HEAP|HIDDEN|HOUR|IDENTIFIED|IF|IMMEDIATE|IMMUTABLE|IN|INCLUDING|INDEX|INDEXES|INDICATOR|INDICES|INFINITE|INSERT|INSTANTIABLE|INT|INTERFACE|INTERSECT|INTERVAL|INTO|INVALIDATE|IS|ISOLATION|JAVA|LANGUAGE|LARGE|LEADING|LENGTH|LEVEL|LIBRARY|LIKE|LIKE2|LIKE4|LIKEC|LIMIT|LIMITED|LOCAL|LOCK|LONG|LOOP|MAP|MAX|MAXLEN|MEMBER|MERGE|MIN|MINUS|MINUTE|MOD|MODE|MODIFY|MONTH|MULTISET|MUTABLE|NAME|NAN|NATIONAL|NATIVE|NCHAR|NEW|NOCOMPRESS|NOCOPY|NOT|NOWAIT|NULL|NUMBER_BASE|OBJECT|OCICOLL|OCIDATE|OCIDATETIME|OCIDURATION|OCIINTERVAL|OCILOBLOCATOR|OCINUMBER|OCIRAW|OCIREF|OCIREFCURSOR|OCIROWID|OCISTRING|OCITYPE|OF|OLD|ON|ONLY|OPAQUE|OPEN|OPERATOR|OPTION|OR|ORACLE|ORADATA|ORDER|ORGANIZATION|ORLANY|ORLVARY|OTHERS|OUT|OVERLAPS|OVERRIDING|PACKAGE|PARALLEL_ENABLE|PARAMETER|PARAMETERS|PARENT|PARTITION|PASCAL|PERSISTABLE|PIPE|PIPELINED|PLUGGABLE|POLYMORPHIC|PRAGMA|PRECISION|PRIOR|PRIVATE|PROCEDURE|PUBLIC|RAISE|RANGE|RAW|READ|RECORD|REF|REFERENCE|RELIES_ON|REM|REMAINDER|RENAME|RESOURCE|RESULT|RESULT_CACHE|RETURN|RETURNING|REVERSE|REVOKE|ROLLBACK|ROW|SAMPLE|SAVE|SAVEPOINT|SB1|SB2|SB4|SECOND|SEGMENT|SELECT|SELF|SEPARATE|SEQUENCE|SERIALIZABLE|SET|SHARE|SHORT|SIZE|SIZE_T|SOME|SPARSE|SQL|SQLCODE|SQLDATA|SQLNAME|SQLSTATE|STANDARD|START|STATIC|STDDEV|STORED|STRING|STRUCT|STYLE|SUBMULTISET|SUBPARTITION|SUBSTITUTABLE|SUBTYPE|SUM|SYNONYM|TABAUTH|TABLE|TDO|THE|THEN|TIME|TIMESTAMP|TIMEZONE_ABBR|TIMEZONE_HOUR|TIMEZONE_MINUTE|TIMEZONE_REGION|TO|TRAILING|TRANSACTION|TRANSACTIONAL|TRUSTED|TYPE|UB1|UB2|UB4|UNDER|UNION|UNIQUE|UNPLUG|UNSIGNED|UNTRUSTED|UPDATE|USE|USING|VALIST|VALUE|VALUES|VARIABLE|VARIANCE|VARRAY|VARYING|VIEW|VIEWS|VOID|WHEN|WHERE|WHILE|WITH|WORK|WRAPPED|WRITE|YEAR|ZONE)\b/i,
-        // https://docs.oracle.com/en/database/oracle/oracle-database/21/lnpls/plsql-language-fundamentals.html#GUID-96A42F7C-7A71-4B90-8255-CA9C8BD9722E
-        operator: /:=?|=>|[<>^~!]=|\.\.|\|\||\*\*|[-+*/%<>=@]/
-      });
-      Prism.languages.insertBefore("plsql", "operator", {
-        label: {
-          pattern: /<<\s*\w+\s*>>/,
-          alias: "symbol"
-        }
-      });
-    }
-    __name(plsql, "plsql");
-  }
-});
-
-export {
-  require_plsql
-};

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

@@ -1,79 +0,0 @@
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/refractor/lang/inform7.js
-var require_inform7 = __commonJS({
-  "../node_modules/refractor/lang/inform7.js"(exports, module) {
-    module.exports = inform7;
-    inform7.displayName = "inform7";
-    inform7.aliases = [];
-    function inform7(Prism) {
-      Prism.languages.inform7 = {
-        string: {
-          pattern: /"[^"]*"/,
-          inside: {
-            substitution: {
-              pattern: /\[[^\[\]]+\]/,
-              inside: {
-                delimiter: {
-                  pattern: /\[|\]/,
-                  alias: "punctuation"
-                }
-                // See rest below
-              }
-            }
-          }
-        },
-        comment: {
-          pattern: /\[[^\[\]]+\]/,
-          greedy: true
-        },
-        title: {
-          pattern: /^[ \t]*(?:book|chapter|part(?! of)|section|table|volume)\b.+/im,
-          alias: "important"
-        },
-        number: {
-          pattern: /(^|[^-])(?:\b\d+(?:\.\d+)?(?:\^\d+)?(?:(?!\d)\w+)?|\b(?:eight|eleven|five|four|nine|one|seven|six|ten|three|twelve|two))\b(?!-)/i,
-          lookbehind: true
-        },
-        verb: {
-          pattern: /(^|[^-])\b(?:answering|applying to|are|asking|attacking|be(?:ing)?|burning|buying|called|carries|carry(?! out)|carrying|climbing|closing|conceal(?:ing|s)?|consulting|contain(?:ing|s)?|cutting|drinking|dropping|eating|enclos(?:es?|ing)|entering|examining|exiting|getting|giving|going|ha(?:s|ve|ving)|hold(?:ing|s)?|impl(?:ies|y)|incorporat(?:es?|ing)|inserting|is|jumping|kissing|listening|locking|looking|mean(?:ing|s)?|opening|provid(?:es?|ing)|pulling|pushing|putting|relat(?:es?|ing)|removing|searching|see(?:ing|s)?|setting|showing|singing|sleeping|smelling|squeezing|support(?:ing|s)?|swearing|switching|taking|tasting|telling|thinking|throwing|touching|turning|tying|unlock(?:ing|s)?|var(?:ies|y|ying)|waiting|waking|waving|wear(?:ing|s)?)\b(?!-)/i,
-          lookbehind: true,
-          alias: "operator"
-        },
-        keyword: {
-          pattern: /(^|[^-])\b(?:after|before|carry out|check|continue the action|definition(?= *:)|do nothing|else|end (?:if|the story|unless)|every turn|if|include|instead(?: of)?|let|move|no|now|otherwise|repeat|report|resume the story|rule for|running through|say(?:ing)?|stop the action|test|try(?:ing)?|understand|unless|use|when|while|yes)\b(?!-)/i,
-          lookbehind: true
-        },
-        property: {
-          pattern: /(^|[^-])\b(?:adjacent(?! to)|carried|closed|concealed|contained|dark|described|edible|empty|enclosed|enterable|even|female|fixed in place|full|handled|held|improper-named|incorporated|inedible|invisible|lighted|lit|lock(?:able|ed)|male|marked for listing|mentioned|negative|neuter|non-(?:empty|full|recurring)|odd|opaque|open(?:able)?|plural-named|portable|positive|privately-named|proper-named|provided|publically-named|pushable between rooms|recurring|related|rubbing|scenery|seen|singular-named|supported|swinging|switch(?:able|ed(?: off| on)?)|touch(?:able|ed)|transparent|unconcealed|undescribed|unlit|unlocked|unmarked for listing|unmentioned|unopenable|untouchable|unvisited|variable|visible|visited|wearable|worn)\b(?!-)/i,
-          lookbehind: true,
-          alias: "symbol"
-        },
-        position: {
-          pattern: /(^|[^-])\b(?:above|adjacent to|back side of|below|between|down|east|everywhere|front side|here|in|inside(?: from)?|north(?:east|west)?|nowhere|on(?: top of)?|other side|outside(?: from)?|parts? of|regionally in|south(?:east|west)?|through|up|west|within)\b(?!-)/i,
-          lookbehind: true,
-          alias: "keyword"
-        },
-        type: {
-          pattern: /(^|[^-])\b(?:actions?|activit(?:ies|y)|actors?|animals?|backdrops?|containers?|devices?|directions?|doors?|holders?|kinds?|lists?|m[ae]n|nobody|nothing|nouns?|numbers?|objects?|people|persons?|player(?:'s holdall)?|regions?|relations?|rooms?|rule(?:book)?s?|scenes?|someone|something|supporters?|tables?|texts?|things?|time|vehicles?|wom[ae]n)\b(?!-)/i,
-          lookbehind: true,
-          alias: "variable"
-        },
-        punctuation: /[.,:;(){}]/
-      };
-      Prism.languages.inform7["string"].inside["substitution"].inside.rest = Prism.languages.inform7;
-      Prism.languages.inform7["string"].inside["substitution"].inside.rest.text = {
-        pattern: /\S(?:\s*\S)*/,
-        alias: "comment"
-      };
-    }
-    __name(inform7, "inform7");
-  }
-});
-
-export {
-  require_inform7
-};

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

@@ -1,99 +0,0 @@
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/refractor/lang/smali.js
-var require_smali = __commonJS({
-  "../node_modules/refractor/lang/smali.js"(exports, module) {
-    module.exports = smali;
-    smali.displayName = "smali";
-    smali.aliases = [];
-    function smali(Prism) {
-      Prism.languages.smali = {
-        comment: /#.*/,
-        string: {
-          pattern: /"(?:[^\r\n\\"]|\\.)*"|'(?:[^\r\n\\']|\\(?:.|u[\da-fA-F]{4}))'/,
-          greedy: true
-        },
-        "class-name": {
-          pattern: /(^|[^L])L(?:(?:\w+|`[^`\r\n]*`)\/)*(?:[\w$]+|`[^`\r\n]*`)(?=\s*;)/,
-          lookbehind: true,
-          inside: {
-            "class-name": {
-              pattern: /(^L|\/)(?:[\w$]+|`[^`\r\n]*`)$/,
-              lookbehind: true
-            },
-            namespace: {
-              pattern: /^(L)(?:(?:\w+|`[^`\r\n]*`)\/)+/,
-              lookbehind: true,
-              inside: {
-                punctuation: /\//
-              }
-            },
-            builtin: /^L/
-          }
-        },
-        builtin: [
-          {
-            // Reference: https://github.com/JesusFreke/smali/wiki/TypesMethodsAndFields#types
-            pattern: /([();\[])[BCDFIJSVZ]+/,
-            lookbehind: true
-          },
-          {
-            // e.g. .field mWifiOnUid:I
-            pattern: /([\w$>]:)[BCDFIJSVZ]/,
-            lookbehind: true
-          }
-        ],
-        keyword: [
-          {
-            pattern: /(\.end\s+)[\w-]+/,
-            lookbehind: true
-          },
-          {
-            pattern: /(^|[^\w.-])\.(?!\d)[\w-]+/,
-            lookbehind: true
-          },
-          {
-            pattern: /(^|[^\w.-])(?:abstract|annotation|bridge|constructor|enum|final|interface|private|protected|public|runtime|static|synthetic|system|transient)(?![\w.-])/,
-            lookbehind: true
-          }
-        ],
-        function: {
-          pattern: /(^|[^\w.-])(?:\w+|<[\w$-]+>)(?=\()/,
-          lookbehind: true
-        },
-        field: {
-          pattern: /[\w$]+(?=:)/,
-          alias: "variable"
-        },
-        register: {
-          pattern: /(^|[^\w.-])[vp]\d(?![\w.-])/,
-          lookbehind: true,
-          alias: "variable"
-        },
-        boolean: {
-          pattern: /(^|[^\w.-])(?:false|true)(?![\w.-])/,
-          lookbehind: true
-        },
-        number: {
-          pattern: /(^|[^/\w.-])-?(?:NAN|INFINITY|0x(?:[\dA-F]+(?:\.[\dA-F]*)?|\.[\dA-F]+)(?:p[+-]?[\dA-F]+)?|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?)[dflst]?(?![\w.-])/i,
-          lookbehind: true
-        },
-        label: {
-          pattern: /(:)\w+/,
-          lookbehind: true,
-          alias: "property"
-        },
-        operator: /->|\.\.|[\[=]/,
-        punctuation: /[{}(),;:]/
-      };
-    }
-    __name(smali, "smali");
-  }
-});
-
-export {
-  require_smali
-};