@distri/react 0.2.8 → 0.3.1

package/dist/chunk-BAVP462O.js

@@ -1,240 +0,0 @@
-"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

@@ -1,103 +0,0 @@
-"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

@@ -1,94 +0,0 @@
-"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

@@ -1,71 +0,0 @@
-"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

@@ -1,66 +0,0 @@
-"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

@@ -1,60 +0,0 @@
-"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
-};