@distri/react 0.2.7 → 0.3.0

package/dist/chunk-BAVP462O.js

@@ -0,0 +1,240 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/js-templates.js
+var require_js_templates = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/js-templates.js"(exports, module) {
+    module.exports = jsTemplates;
+    jsTemplates.displayName = "jsTemplates";
+    jsTemplates.aliases = [];
+    function jsTemplates(Prism) {
+      ;
+      (function(Prism2) {
+        var templateString = Prism2.languages.javascript["template-string"];
+        var templateLiteralPattern = templateString.pattern.source;
+        var interpolationObject = templateString.inside["interpolation"];
+        var interpolationPunctuationObject = interpolationObject.inside["interpolation-punctuation"];
+        var interpolationPattern = interpolationObject.pattern.source;
+        function createTemplate(language, tag) {
+          if (!Prism2.languages[language]) {
+            return void 0;
+          }
+          return {
+            pattern: RegExp("((?:" + tag + ")\\s*)" + templateLiteralPattern),
+            lookbehind: true,
+            greedy: true,
+            inside: {
+              "template-punctuation": {
+                pattern: /^`|`$/,
+                alias: "string"
+              },
+              "embedded-code": {
+                pattern: /[\s\S]+/,
+                alias: language
+              }
+            }
+          };
+        }
+        Prism2.languages.javascript["template-string"] = [
+          // styled-jsx:
+          //   css`a { color: #25F; }`
+          // styled-components:
+          //   styled.h1`color: red;`
+          createTemplate(
+            "css",
+            /\b(?:styled(?:\([^)]*\))?(?:\s*\.\s*\w+(?:\([^)]*\))*)*|css(?:\s*\.\s*(?:global|resolve))?|createGlobalStyle|keyframes)/.source
+          ),
+          // html`<p></p>`
+          // div.innerHTML = `<p></p>`
+          createTemplate("html", /\bhtml|\.\s*(?:inner|outer)HTML\s*\+?=/.source),
+          // svg`<path fill="#fff" d="M55.37 ..."/>`
+          createTemplate("svg", /\bsvg/.source),
+          // md`# h1`, markdown`## h2`
+          createTemplate("markdown", /\b(?:markdown|md)/.source),
+          // gql`...`, graphql`...`, graphql.experimental`...`
+          createTemplate(
+            "graphql",
+            /\b(?:gql|graphql(?:\s*\.\s*experimental)?)/.source
+          ),
+          // sql`...`
+          createTemplate("sql", /\bsql/.source),
+          // vanilla template string
+          templateString
+        ].filter(Boolean);
+        function getPlaceholder(counter, language) {
+          return "___" + language.toUpperCase() + "_" + counter + "___";
+        }
+        function tokenizeWithHooks(code, grammar, language) {
+          var env = {
+            code,
+            grammar,
+            language
+          };
+          Prism2.hooks.run("before-tokenize", env);
+          env.tokens = Prism2.tokenize(env.code, env.grammar);
+          Prism2.hooks.run("after-tokenize", env);
+          return env.tokens;
+        }
+        function tokenizeInterpolationExpression(expression) {
+          var tempGrammar = {};
+          tempGrammar["interpolation-punctuation"] = interpolationPunctuationObject;
+          var tokens = Prism2.tokenize(expression, tempGrammar);
+          if (tokens.length === 3) {
+            var args = [1, 1];
+            args.push.apply(
+              args,
+              tokenizeWithHooks(tokens[1], Prism2.languages.javascript, "javascript")
+            );
+            tokens.splice.apply(tokens, args);
+          }
+          return new Prism2.Token(
+            "interpolation",
+            tokens,
+            interpolationObject.alias,
+            expression
+          );
+        }
+        function tokenizeEmbedded(code, grammar, language) {
+          var _tokens = Prism2.tokenize(code, {
+            interpolation: {
+              pattern: RegExp(interpolationPattern),
+              lookbehind: true
+            }
+          });
+          var placeholderCounter = 0;
+          var placeholderMap = {};
+          var embeddedCode = _tokens.map(function(token) {
+            if (typeof token === "string") {
+              return token;
+            } else {
+              var interpolationExpression = token.content;
+              var placeholder;
+              while (code.indexOf(
+                placeholder = getPlaceholder(placeholderCounter++, language)
+              ) !== -1) {
+              }
+              placeholderMap[placeholder] = interpolationExpression;
+              return placeholder;
+            }
+          }).join("");
+          var embeddedTokens = tokenizeWithHooks(embeddedCode, grammar, language);
+          var placeholders = Object.keys(placeholderMap);
+          placeholderCounter = 0;
+          function walkTokens(tokens) {
+            for (var i = 0; i < tokens.length; i++) {
+              if (placeholderCounter >= placeholders.length) {
+                return;
+              }
+              var token = tokens[i];
+              if (typeof token === "string" || typeof token.content === "string") {
+                var placeholder = placeholders[placeholderCounter];
+                var s = typeof token === "string" ? token : (
+                  /** @type {string} */
+                  token.content
+                );
+                var index = s.indexOf(placeholder);
+                if (index !== -1) {
+                  ++placeholderCounter;
+                  var before = s.substring(0, index);
+                  var middle = tokenizeInterpolationExpression(
+                    placeholderMap[placeholder]
+                  );
+                  var after = s.substring(index + placeholder.length);
+                  var replacement = [];
+                  if (before) {
+                    replacement.push(before);
+                  }
+                  replacement.push(middle);
+                  if (after) {
+                    var afterTokens = [after];
+                    walkTokens(afterTokens);
+                    replacement.push.apply(replacement, afterTokens);
+                  }
+                  if (typeof token === "string") {
+                    tokens.splice.apply(tokens, [i, 1].concat(replacement));
+                    i += replacement.length - 1;
+                  } else {
+                    token.content = replacement;
+                  }
+                }
+              } else {
+                var content = token.content;
+                if (Array.isArray(content)) {
+                  walkTokens(content);
+                } else {
+                  walkTokens([content]);
+                }
+              }
+            }
+          }
+          walkTokens(embeddedTokens);
+          return new Prism2.Token(
+            language,
+            embeddedTokens,
+            "language-" + language,
+            code
+          );
+        }
+        var supportedLanguages = {
+          javascript: true,
+          js: true,
+          typescript: true,
+          ts: true,
+          jsx: true,
+          tsx: true
+        };
+        Prism2.hooks.add("after-tokenize", function(env) {
+          if (!(env.language in supportedLanguages)) {
+            return;
+          }
+          function findTemplateStrings(tokens) {
+            for (var i = 0, l = tokens.length; i < l; i++) {
+              var token = tokens[i];
+              if (typeof token === "string") {
+                continue;
+              }
+              var content = token.content;
+              if (!Array.isArray(content)) {
+                if (typeof content !== "string") {
+                  findTemplateStrings([content]);
+                }
+                continue;
+              }
+              if (token.type === "template-string") {
+                var embedded = content[1];
+                if (content.length === 3 && typeof embedded !== "string" && embedded.type === "embedded-code") {
+                  var code = stringContent(embedded);
+                  var alias = embedded.alias;
+                  var language = Array.isArray(alias) ? alias[0] : alias;
+                  var grammar = Prism2.languages[language];
+                  if (!grammar) {
+                    continue;
+                  }
+                  content[1] = tokenizeEmbedded(code, grammar, language);
+                }
+              } else {
+                findTemplateStrings(content);
+              }
+            }
+          }
+          findTemplateStrings(env.tokens);
+        });
+        function stringContent(value) {
+          if (typeof value === "string") {
+            return value;
+          } else if (Array.isArray(value)) {
+            return value.map(stringContent).join("");
+          } else {
+            return stringContent(value.content);
+          }
+        }
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_js_templates
+};

package/dist/chunk-BB7U4H7S.js

@@ -0,0 +1,103 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/uri.js
+var require_uri = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/uri.js"(exports, module) {
+    module.exports = uri;
+    uri.displayName = "uri";
+    uri.aliases = ["url"];
+    function uri(Prism) {
+      Prism.languages.uri = {
+        scheme: {
+          pattern: /^[a-z][a-z0-9+.-]*:/im,
+          greedy: true,
+          inside: {
+            "scheme-delimiter": /:$/
+          }
+        },
+        fragment: {
+          pattern: /#[\w\-.~!$&'()*+,;=%:@/?]*/,
+          inside: {
+            "fragment-delimiter": /^#/
+          }
+        },
+        query: {
+          pattern: /\?[\w\-.~!$&'()*+,;=%:@/?]*/,
+          inside: {
+            "query-delimiter": {
+              pattern: /^\?/,
+              greedy: true
+            },
+            "pair-delimiter": /[&;]/,
+            pair: {
+              pattern: /^[^=][\s\S]*/,
+              inside: {
+                key: /^[^=]+/,
+                value: {
+                  pattern: /(^=)[\s\S]+/,
+                  lookbehind: true
+                }
+              }
+            }
+          }
+        },
+        authority: {
+          pattern: RegExp(
+            /^\/\//.source + // [ userinfo "@" ]
+            /(?:[\w\-.~!$&'()*+,;=%:]*@)?/.source + // host
+            ("(?:" + // IP-literal
+            /\[(?:[0-9a-fA-F:.]{2,48}|v[0-9a-fA-F]+\.[\w\-.~!$&'()*+,;=]+)\]/.source + "|" + // IPv4address or registered name
+            /[\w\-.~!$&'()*+,;=%]*/.source + ")") + // [ ":" port ]
+            /(?::\d*)?/.source,
+            "m"
+          ),
+          inside: {
+            "authority-delimiter": /^\/\//,
+            "user-info-segment": {
+              pattern: /^[\w\-.~!$&'()*+,;=%:]*@/,
+              inside: {
+                "user-info-delimiter": /@$/,
+                "user-info": /^[\w\-.~!$&'()*+,;=%:]+/
+              }
+            },
+            "port-segment": {
+              pattern: /:\d*$/,
+              inside: {
+                "port-delimiter": /^:/,
+                port: /^\d+/
+              }
+            },
+            host: {
+              pattern: /[\s\S]+/,
+              inside: {
+                "ip-literal": {
+                  pattern: /^\[[\s\S]+\]$/,
+                  inside: {
+                    "ip-literal-delimiter": /^\[|\]$/,
+                    "ipv-future": /^v[\s\S]+/,
+                    "ipv6-address": /^[\s\S]+/
+                  }
+                },
+                "ipv4-address": /^(?:(?:[03-9]\d?|[12]\d{0,2})\.){3}(?:[03-9]\d?|[12]\d{0,2})$/
+              }
+            }
+          }
+        },
+        path: {
+          pattern: /^[\w\-.~!$&'()*+,;=%:@/]+/m,
+          inside: {
+            "path-separator": /\//
+          }
+        }
+      };
+      Prism.languages.url = Prism.languages.uri;
+    }
+  }
+});
+
+export {
+  require_uri
+};

package/dist/chunk-BBQV2JXP.js

@@ -0,0 +1,94 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/parser.js
+var require_parser = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/parser.js"(exports, module) {
+    module.exports = parser;
+    parser.displayName = "parser";
+    parser.aliases = [];
+    function parser(Prism) {
+      ;
+      (function(Prism2) {
+        var parser2 = Prism2.languages.parser = Prism2.languages.extend("markup", {
+          keyword: {
+            pattern: /(^|[^^])(?:\^(?:case|eval|for|if|switch|throw)\b|@(?:BASE|CLASS|GET(?:_DEFAULT)?|OPTIONS|SET_DEFAULT|USE)\b)/,
+            lookbehind: true
+          },
+          variable: {
+            pattern: /(^|[^^])\B\$(?:\w+|(?=[.{]))(?:(?:\.|::?)\w+)*(?:\.|::?)?/,
+            lookbehind: true,
+            inside: {
+              punctuation: /\.|:+/
+            }
+          },
+          function: {
+            pattern: /(^|[^^])\B[@^]\w+(?:(?:\.|::?)\w+)*(?:\.|::?)?/,
+            lookbehind: true,
+            inside: {
+              keyword: {
+                pattern: /(^@)(?:GET_|SET_)/,
+                lookbehind: true
+              },
+              punctuation: /\.|:+/
+            }
+          },
+          escape: {
+            pattern: /\^(?:[$^;@()\[\]{}"':]|#[a-f\d]*)/i,
+            alias: "builtin"
+          },
+          punctuation: /[\[\](){};]/
+        });
+        parser2 = Prism2.languages.insertBefore("parser", "keyword", {
+          "parser-comment": {
+            pattern: /(\s)#.*/,
+            lookbehind: true,
+            alias: "comment"
+          },
+          expression: {
+            // Allow for 3 levels of depth
+            pattern: /(^|[^^])\((?:[^()]|\((?:[^()]|\((?:[^()])*\))*\))*\)/,
+            greedy: true,
+            lookbehind: true,
+            inside: {
+              string: {
+                pattern: /(^|[^^])(["'])(?:(?!\2)[^^]|\^[\s\S])*\2/,
+                lookbehind: true
+              },
+              keyword: parser2.keyword,
+              variable: parser2.variable,
+              function: parser2.function,
+              boolean: /\b(?:false|true)\b/,
+              number: /\b(?:0x[a-f\d]+|\d+(?:\.\d*)?(?:e[+-]?\d+)?)\b/i,
+              escape: parser2.escape,
+              operator: /[~+*\/\\%]|!(?:\|\|?|=)?|&&?|\|\|?|==|<[<=]?|>[>=]?|-[fd]?|\b(?:def|eq|ge|gt|in|is|le|lt|ne)\b/,
+              punctuation: parser2.punctuation
+            }
+          }
+        });
+        Prism2.languages.insertBefore(
+          "inside",
+          "punctuation",
+          {
+            expression: parser2.expression,
+            keyword: parser2.keyword,
+            variable: parser2.variable,
+            function: parser2.function,
+            escape: parser2.escape,
+            "parser-punctuation": {
+              pattern: parser2.punctuation,
+              alias: "punctuation"
+            }
+          },
+          parser2["tag"].inside["attr-value"]
+        );
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_parser
+};

package/dist/chunk-BFG2SVED.js

@@ -0,0 +1,71 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/coq.js
+var require_coq = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/coq.js"(exports, module) {
+    module.exports = coq;
+    coq.displayName = "coq";
+    coq.aliases = [];
+    function coq(Prism) {
+      ;
+      (function(Prism2) {
+        var commentSource = /\(\*(?:[^(*]|\((?!\*)|\*(?!\))|<self>)*\*\)/.source;
+        for (var i = 0; i < 2; i++) {
+          commentSource = commentSource.replace(/<self>/g, function() {
+            return commentSource;
+          });
+        }
+        commentSource = commentSource.replace(/<self>/g, "[]");
+        Prism2.languages.coq = {
+          comment: RegExp(commentSource),
+          string: {
+            pattern: /"(?:[^"]|"")*"(?!")/,
+            greedy: true
+          },
+          attribute: [
+            {
+              pattern: RegExp(
+                /#\[(?:[^\[\]("]|"(?:[^"]|"")*"(?!")|\((?!\*)|<comment>)*\]/.source.replace(
+                  /<comment>/g,
+                  function() {
+                    return commentSource;
+                  }
+                )
+              ),
+              greedy: true,
+              alias: "attr-name",
+              inside: {
+                comment: RegExp(commentSource),
+                string: {
+                  pattern: /"(?:[^"]|"")*"(?!")/,
+                  greedy: true
+                },
+                operator: /=/,
+                punctuation: /^#\[|\]$|[,()]/
+              }
+            },
+            {
+              pattern: /\b(?:Cumulative|Global|Local|Monomorphic|NonCumulative|Polymorphic|Private|Program)\b/,
+              alias: "attr-name"
+            }
+          ],
+          keyword: /\b(?:Abort|About|Add|Admit|Admitted|All|Arguments|As|Assumptions|Axiom|Axioms|Back|BackTo|Backtrace|BinOp|BinOpSpec|BinRel|Bind|Blacklist|Canonical|Case|Cd|Check|Class|Classes|Close|CoFixpoint|CoInductive|Coercion|Coercions|Collection|Combined|Compute|Conjecture|Conjectures|Constant|Constants|Constraint|Constructors|Context|Corollary|Create|CstOp|Custom|Cut|Debug|Declare|Defined|Definition|Delimit|Dependencies|Dependent|Derive|Diffs|Drop|Elimination|End|Entry|Equality|Eval|Example|Existential|Existentials|Existing|Export|Extern|Extraction|Fact|Fail|Field|File|Firstorder|Fixpoint|Flags|Focus|From|Funclass|Function|Functional|GC|Generalizable|Goal|Grab|Grammar|Graph|Guarded|Haskell|Heap|Hide|Hint|HintDb|Hints|Hypotheses|Hypothesis|IF|Identity|Immediate|Implicit|Implicits|Import|Include|Induction|Inductive|Infix|Info|Initial|InjTyp|Inline|Inspect|Instance|Instances|Intro|Intros|Inversion|Inversion_clear|JSON|Language|Left|Lemma|Let|Lia|Libraries|Library|Load|LoadPath|Locate|Ltac|Ltac2|ML|Match|Method|Minimality|Module|Modules|Morphism|Next|NoInline|Notation|Number|OCaml|Obligation|Obligations|Opaque|Open|Optimize|Parameter|Parameters|Parametric|Path|Paths|Prenex|Preterm|Primitive|Print|Profile|Projections|Proof|Prop|PropBinOp|PropOp|PropUOp|Property|Proposition|Pwd|Qed|Quit|Rec|Record|Recursive|Redirect|Reduction|Register|Relation|Remark|Remove|Require|Reserved|Reset|Resolve|Restart|Rewrite|Right|Ring|Rings|SProp|Saturate|Save|Scheme|Scope|Scopes|Search|SearchHead|SearchPattern|SearchRewrite|Section|Separate|Set|Setoid|Show|Signatures|Solve|Solver|Sort|Sortclass|Sorted|Spec|Step|Strategies|Strategy|String|Structure|SubClass|Subgraph|SuchThat|Tactic|Term|TestCompile|Theorem|Time|Timeout|To|Transparent|Type|Typeclasses|Types|Typing|UnOp|UnOpSpec|Undelimit|Undo|Unfocus|Unfocused|Unfold|Universe|Universes|Unshelve|Variable|Variables|Variant|Verbose|View|Visibility|Zify|_|apply|as|at|by|cofix|else|end|exists|exists2|fix|for|forall|fun|if|in|let|match|measure|move|removed|return|struct|then|using|wf|where|with)\b/,
+          number: /\b(?:0x[a-f0-9][a-f0-9_]*(?:\.[a-f0-9_]+)?(?:p[+-]?\d[\d_]*)?|\d[\d_]*(?:\.[\d_]+)?(?:e[+-]?\d[\d_]*)?)\b/i,
+          punct: {
+            pattern: /@\{|\{\||\[=|:>/,
+            alias: "punctuation"
+          },
+          operator: /\/\\|\\\/|\.{2,3}|:{1,2}=|\*\*|[-=]>|<(?:->?|[+:=>]|<:)|>(?:=|->)|\|[-|]?|[-!%&*+/<=>?@^~']/,
+          punctuation: /\.\(|`\(|@\{|`\{|\{\||\[=|:>|[:.,;(){}\[\]]/
+        };
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_coq
+};

package/dist/chunk-BTRWHRUR.js

@@ -0,0 +1,66 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/t4-templating.js
+var require_t4_templating = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/t4-templating.js"(exports, module) {
+    module.exports = t4Templating;
+    t4Templating.displayName = "t4Templating";
+    t4Templating.aliases = [];
+    function t4Templating(Prism) {
+      ;
+      (function(Prism2) {
+        function createBlock(prefix, inside, contentAlias) {
+          return {
+            pattern: RegExp("<#" + prefix + "[\\s\\S]*?#>"),
+            alias: "block",
+            inside: {
+              delimiter: {
+                pattern: RegExp("^<#" + prefix + "|#>$"),
+                alias: "important"
+              },
+              content: {
+                pattern: /[\s\S]+/,
+                inside,
+                alias: contentAlias
+              }
+            }
+          };
+        }
+        function createT4(insideLang) {
+          var grammar = Prism2.languages[insideLang];
+          var className = "language-" + insideLang;
+          return {
+            block: {
+              pattern: /<#[\s\S]+?#>/,
+              inside: {
+                directive: createBlock("@", {
+                  "attr-value": {
+                    pattern: /=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s'">=]+)/,
+                    inside: {
+                      punctuation: /^=|^["']|["']$/
+                    }
+                  },
+                  keyword: /\b\w+(?=\s)/,
+                  "attr-name": /\b\w+/
+                }),
+                expression: createBlock("=", grammar, className),
+                "class-feature": createBlock("\\+", grammar, className),
+                standard: createBlock("", grammar, className)
+              }
+            }
+          };
+        }
+        Prism2.languages["t4-templating"] = Object.defineProperty({}, "createT4", {
+          value: createT4
+        });
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_t4_templating
+};

package/dist/chunk-BU4UGOKB.js

@@ -0,0 +1,60 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/dataweave.js
+var require_dataweave = __commonJS({
+  "../../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/dataweave.js"(exports, module) {
+    module.exports = dataweave;
+    dataweave.displayName = "dataweave";
+    dataweave.aliases = [];
+    function dataweave(Prism) {
+      ;
+      (function(Prism2) {
+        Prism2.languages.dataweave = {
+          url: /\b[A-Za-z]+:\/\/[\w/:.?=&-]+|\burn:[\w:.?=&-]+/,
+          property: {
+            pattern: /(?:\b\w+#)?(?:"(?:\\.|[^\\"\r\n])*"|\b\w+)(?=\s*[:@])/,
+            greedy: true
+          },
+          string: {
+            pattern: /(["'`])(?:\\[\s\S]|(?!\1)[^\\])*\1/,
+            greedy: true
+          },
+          "mime-type": /\b(?:application|audio|image|multipart|text|video)\/[\w+-]+/,
+          date: {
+            pattern: /\|[\w:+-]+\|/,
+            greedy: true
+          },
+          comment: [
+            {
+              pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
+              lookbehind: true,
+              greedy: true
+            },
+            {
+              pattern: /(^|[^\\:])\/\/.*/,
+              lookbehind: true,
+              greedy: true
+            }
+          ],
+          regex: {
+            pattern: /\/(?:[^\\\/\r\n]|\\[^\r\n])+\//,
+            greedy: true
+          },
+          keyword: /\b(?:and|as|at|case|do|else|fun|if|input|is|match|not|ns|null|or|output|type|unless|update|using|var)\b/,
+          function: /\b[A-Z_]\w*(?=\s*\()/i,
+          number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+          punctuation: /[{}[\];(),.:@]/,
+          operator: /<<|>>|->|[<>~=]=?|!=|--?-?|\+\+?|!|\?/,
+          boolean: /\b(?:false|true)\b/
+        };
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_dataweave
+};