@photonix/basic 1.5.1 → 1.6.1

package/dist/chunk-6DOJJBKM.mjs

@@ -0,0 +1,158 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/naniscript.js
+naniscript.displayName = "naniscript";
+naniscript.aliases = ["nani"];
+function naniscript(Prism) {
+  ;
+  (function(Prism2) {
+    var expressionDef = /\{[^\r\n\[\]{}]*\}/;
+    var params = {
+      "quoted-string": {
+        pattern: /"(?:[^"\\]|\\.)*"/,
+        alias: "operator"
+      },
+      "command-param-id": {
+        pattern: /(\s)\w+:/,
+        lookbehind: true,
+        alias: "property"
+      },
+      "command-param-value": [
+        {
+          pattern: expressionDef,
+          alias: "selector"
+        },
+        {
+          pattern: /([\t ])\S+/,
+          lookbehind: true,
+          greedy: true,
+          alias: "operator"
+        },
+        {
+          pattern: /\S(?:.*\S)?/,
+          alias: "operator"
+        }
+      ]
+    };
+    Prism2.languages.naniscript = {
+      // ; ...
+      comment: {
+        pattern: /^([\t ]*);.*/m,
+        lookbehind: true
+      },
+      // > ...
+      // Define is a control line starting with '>' followed by a word, a space and a text.
+      define: {
+        pattern: /^>.+/m,
+        alias: "tag",
+        inside: {
+          value: {
+            pattern: /(^>\w+[\t ]+)(?!\s)[^{}\r\n]+/,
+            lookbehind: true,
+            alias: "operator"
+          },
+          key: {
+            pattern: /(^>)\w+/,
+            lookbehind: true
+          }
+        }
+      },
+      // # ...
+      label: {
+        pattern: /^([\t ]*)#[\t ]*\w+[\t ]*$/m,
+        lookbehind: true,
+        alias: "regex"
+      },
+      command: {
+        pattern: /^([\t ]*)@\w+(?=[\t ]|$).*/m,
+        lookbehind: true,
+        alias: "function",
+        inside: {
+          "command-name": /^@\w+/,
+          expression: {
+            pattern: expressionDef,
+            greedy: true,
+            alias: "selector"
+          },
+          "command-params": {
+            pattern: /\s*\S[\s\S]*/,
+            inside: params
+          }
+        }
+      },
+      // Generic is any line that doesn't start with operators: ;>#@
+      "generic-text": {
+        pattern: /(^[ \t]*)[^#@>;\s].*/m,
+        lookbehind: true,
+        alias: "punctuation",
+        inside: {
+          // \{ ... \} ... \[ ... \] ... \"
+          "escaped-char": /\\[{}\[\]"]/,
+          expression: {
+            pattern: expressionDef,
+            greedy: true,
+            alias: "selector"
+          },
+          "inline-command": {
+            pattern: /\[[\t ]*\w[^\r\n\[\]]*\]/,
+            greedy: true,
+            alias: "function",
+            inside: {
+              "command-params": {
+                pattern: /(^\[[\t ]*\w+\b)[\s\S]+(?=\]$)/,
+                lookbehind: true,
+                inside: params
+              },
+              "command-param-name": {
+                pattern: /^(\[[\t ]*)\w+/,
+                lookbehind: true,
+                alias: "name"
+              },
+              "start-stop-char": /[\[\]]/
+            }
+          }
+        }
+      }
+    };
+    Prism2.languages.nani = Prism2.languages["naniscript"];
+    Prism2.hooks.add("after-tokenize", function(env) {
+      var tokens = env.tokens;
+      tokens.forEach(function(token) {
+        if (typeof token !== "string" && token.type === "generic-text") {
+          var content = getTextContent(token);
+          if (!isBracketsBalanced(content)) {
+            token.type = "bad-line";
+            token.content = content;
+          }
+        }
+      });
+    });
+    function isBracketsBalanced(input) {
+      var brackets = "[]{}";
+      var stack = [];
+      for (var i = 0; i < input.length; i++) {
+        var bracket = input[i];
+        var bracketsIndex = brackets.indexOf(bracket);
+        if (bracketsIndex !== -1) {
+          if (bracketsIndex % 2 === 0) {
+            stack.push(bracketsIndex + 1);
+          } else if (stack.pop() !== bracketsIndex) {
+            return false;
+          }
+        }
+      }
+      return stack.length === 0;
+    }
+    function getTextContent(token) {
+      if (typeof token === "string") {
+        return token;
+      } else if (Array.isArray(token)) {
+        return token.map(getTextContent).join("");
+      } else {
+        return getTextContent(token.content);
+      }
+    }
+  })(Prism);
+}
+
+export {
+  naniscript
+};

package/dist/chunk-6FXUATT6.mjs

@@ -0,0 +1,31 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/ada.js
+ada.displayName = "ada";
+ada.aliases = [];
+function ada(Prism) {
+  Prism.languages.ada = {
+    comment: /--.*/,
+    string: /"(?:""|[^"\r\f\n])*"/,
+    number: [
+      {
+        pattern: /\b\d(?:_?\d)*#[\dA-F](?:_?[\dA-F])*(?:\.[\dA-F](?:_?[\dA-F])*)?#(?:E[+-]?\d(?:_?\d)*)?/i
+      },
+      {
+        pattern: /\b\d(?:_?\d)*(?:\.\d(?:_?\d)*)?(?:E[+-]?\d(?:_?\d)*)?\b/i
+      }
+    ],
+    attribute: {
+      pattern: /\b'\w+/,
+      alias: "attr-name"
+    },
+    keyword: /\b(?:abort|abs|abstract|accept|access|aliased|all|and|array|at|begin|body|case|constant|declare|delay|delta|digits|do|else|elsif|end|entry|exception|exit|for|function|generic|goto|if|in|interface|is|limited|loop|mod|new|not|null|of|or|others|out|overriding|package|pragma|private|procedure|protected|raise|range|record|rem|renames|requeue|return|reverse|select|separate|some|subtype|synchronized|tagged|task|terminate|then|type|until|use|when|while|with|xor)\b/i,
+    boolean: /\b(?:false|true)\b/i,
+    operator: /<[=>]?|>=?|=>?|:=|\/=?|\*\*?|[&+-]/,
+    punctuation: /\.\.?|[,;():]/,
+    char: /'.'/,
+    variable: /\b[a-z](?:\w)*\b/i
+  };
+}
+
+export {
+  ada
+};

package/dist/chunk-6G5OZ7F7.mjs

@@ -0,0 +1,53 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/mata.js
+mata.displayName = "mata";
+mata.aliases = [];
+function mata(Prism) {
+  ;
+  (function(Prism2) {
+    var orgType = /\b(?:(?:col|row)?vector|matrix|scalar)\b/.source;
+    var type = /\bvoid\b|<org>|\b(?:complex|numeric|pointer(?:\s*\([^()]*\))?|real|string|(?:class|struct)\s+\w+|transmorphic)(?:\s*<org>)?/.source.replace(
+      /<org>/g,
+      orgType
+    );
+    Prism2.languages.mata = {
+      comment: {
+        pattern: /\/\/.*|\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/)*\*\//,
+        greedy: true
+      },
+      string: {
+        pattern: /"[^"\r\n]*"|[‘`']".*?"[’`']/,
+        greedy: true
+      },
+      "class-name": {
+        pattern: /(\b(?:class|extends|struct)\s+)\w+(?=\s*(?:\{|\bextends\b))/,
+        lookbehind: true
+      },
+      type: {
+        pattern: RegExp(type),
+        alias: "class-name",
+        inside: {
+          punctuation: /[()]/,
+          keyword: /\b(?:class|function|struct|void)\b/
+        }
+      },
+      keyword: /\b(?:break|class|continue|do|else|end|extends|external|final|for|function|goto|if|pragma|private|protected|public|return|static|struct|unset|unused|version|virtual|while)\b/,
+      constant: /\bNULL\b/,
+      number: {
+        pattern: /(^|[^\w.])(?:\d+(?:\.\d+)?(?:e[+-]?\d+)?|\d[a-f0-9]*(?:\.[a-f0-9]+)?x[+-]?\d+)i?(?![\w.])/i,
+        lookbehind: true
+      },
+      missing: {
+        pattern: /(^|[^\w.])(?:\.[a-z]?)(?![\w.])/,
+        lookbehind: true,
+        alias: "symbol"
+      },
+      function: /\b[a-z_]\w*(?=\s*\()/i,
+      operator: /\.\.|\+\+|--|&&|\|\||:?(?:[!=<>]=|[+\-*/^<>&|:])|[!?=\\#’`']/,
+      punctuation: /[()[\]{},;.]/
+    };
+  })(Prism);
+}
+
+export {
+  mata
+};

package/dist/chunk-6MWXFNJ7.mjs

@@ -0,0 +1,43 @@
+import {
+  markupTemplating
+} from "./chunk-DFNMTLAN.mjs";
+import {
+  javascript
+} from "./chunk-ZJYVOTZA.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/ejs.js
+ejs.displayName = "ejs";
+ejs.aliases = ["eta"];
+function ejs(Prism) {
+  Prism.register(javascript);
+  Prism.register(markupTemplating);
+  (function(Prism2) {
+    Prism2.languages.ejs = {
+      delimiter: {
+        pattern: /^<%[-_=]?|[-_]?%>$/,
+        alias: "punctuation"
+      },
+      comment: /^#[\s\S]*/,
+      "language-javascript": {
+        pattern: /[\s\S]+/,
+        inside: Prism2.languages.javascript
+      }
+    };
+    Prism2.hooks.add("before-tokenize", function(env) {
+      var ejsPattern = /<%(?!%)[\s\S]+?%>/g;
+      Prism2.languages["markup-templating"].buildPlaceholders(
+        env,
+        "ejs",
+        ejsPattern
+      );
+    });
+    Prism2.hooks.add("after-tokenize", function(env) {
+      Prism2.languages["markup-templating"].tokenizePlaceholders(env, "ejs");
+    });
+    Prism2.languages.eta = Prism2.languages.ejs;
+  })(Prism);
+}
+
+export {
+  ejs
+};

package/dist/chunk-6QDZGS6I.mjs

@@ -0,0 +1,74 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/maxscript.js
+maxscript.displayName = "maxscript";
+maxscript.aliases = [];
+function maxscript(Prism) {
+  ;
+  (function(Prism2) {
+    var keywords = /\b(?:about|and|animate|as|at|attributes|by|case|catch|collect|continue|coordsys|do|else|exit|fn|for|from|function|global|if|in|local|macroscript|mapped|max|not|of|off|on|or|parameters|persistent|plugin|rcmenu|return|rollout|set|struct|then|throw|to|tool|try|undo|utility|when|where|while|with)\b/i;
+    Prism2.languages.maxscript = {
+      comment: {
+        pattern: /\/\*[\s\S]*?(?:\*\/|$)|--.*/,
+        greedy: true
+      },
+      string: {
+        pattern: /(^|[^"\\@])(?:"(?:[^"\\]|\\[\s\S])*"|@"[^"]*")/,
+        lookbehind: true,
+        greedy: true
+      },
+      path: {
+        pattern: /\$(?:[\w/\\.*?]|'[^']*')*/,
+        greedy: true,
+        alias: "string"
+      },
+      "function-call": {
+        pattern: RegExp(
+          "((?:" + // start of line
+          (/^/.source + "|" + // operators and other language constructs
+          /[;=<>+\-*/^({\[]/.source + "|" + // keywords as part of statements
+          /\b(?:and|by|case|catch|collect|do|else|if|in|not|or|return|then|to|try|where|while|with)\b/.source) + ")[ 	]*)(?!" + keywords.source + ")" + /[a-z_]\w*\b/.source + "(?=[ 	]*(?:" + // variable
+          ("(?!" + keywords.source + ")" + /[a-z_]/.source + "|" + // number
+          /\d|-\.?\d/.source + "|" + // other expressions or literals
+          /[({'"$@#?]/.source) + "))",
+          "im"
+        ),
+        lookbehind: true,
+        greedy: true,
+        alias: "function"
+      },
+      "function-definition": {
+        pattern: /(\b(?:fn|function)\s+)\w+\b/i,
+        lookbehind: true,
+        alias: "function"
+      },
+      argument: {
+        pattern: /\b[a-z_]\w*(?=:)/i,
+        alias: "attr-name"
+      },
+      keyword: keywords,
+      boolean: /\b(?:false|true)\b/,
+      time: {
+        pattern: /(^|[^\w.])(?:(?:(?:\d+(?:\.\d*)?|\.\d+)(?:[eEdD][+-]\d+|[LP])?[msft])+|\d+:\d+(?:\.\d*)?)(?![\w.:])/,
+        lookbehind: true,
+        alias: "number"
+      },
+      number: [
+        {
+          pattern: /(^|[^\w.])(?:(?:\d+(?:\.\d*)?|\.\d+)(?:[eEdD][+-]\d+|[LP])?|0x[a-fA-F0-9]+)(?![\w.:])/,
+          lookbehind: true
+        },
+        /\b(?:e|pi)\b/
+      ],
+      constant: /\b(?:dontcollect|ok|silentValue|undefined|unsupplied)\b/,
+      color: {
+        pattern: /\b(?:black|blue|brown|gray|green|orange|red|white|yellow)\b/i,
+        alias: "constant"
+      },
+      operator: /[-+*/<>=!]=?|[&^?]|#(?!\()/,
+      punctuation: /[()\[\]{}.:,;]|#(?=\()|\\$/m
+    };
+  })(Prism);
+}
+
+export {
+  maxscript
+};

package/dist/chunk-6R3GYXSX.mjs

@@ -0,0 +1,107 @@
+import {
+  java
+} from "./chunk-TG6MIYIG.mjs";
+import {
+  javadoclike
+} from "./chunk-NHRQUFUX.mjs";
+import {
+  markup
+} from "./chunk-ACDTS7FW.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/javadoc.js
+javadoc.displayName = "javadoc";
+javadoc.aliases = [];
+function javadoc(Prism) {
+  Prism.register(java);
+  Prism.register(javadoclike);
+  Prism.register(markup);
+  (function(Prism2) {
+    var codeLinePattern = /(^(?:[\t ]*(?:\*\s*)*))[^*\s].*$/m;
+    var memberReference = /#\s*\w+(?:\s*\([^()]*\))?/.source;
+    var reference = /(?:\b[a-zA-Z]\w+\s*\.\s*)*\b[A-Z]\w*(?:\s*<mem>)?|<mem>/.source.replace(
+      /<mem>/g,
+      function() {
+        return memberReference;
+      }
+    );
+    Prism2.languages.javadoc = Prism2.languages.extend("javadoclike", {});
+    Prism2.languages.insertBefore("javadoc", "keyword", {
+      reference: {
+        pattern: RegExp(
+          /(@(?:exception|link|linkplain|see|throws|value)\s+(?:\*\s*)?)/.source + "(?:" + reference + ")"
+        ),
+        lookbehind: true,
+        inside: {
+          function: {
+            pattern: /(#\s*)\w+(?=\s*\()/,
+            lookbehind: true
+          },
+          field: {
+            pattern: /(#\s*)\w+/,
+            lookbehind: true
+          },
+          namespace: {
+            pattern: /\b(?:[a-z]\w*\s*\.\s*)+/,
+            inside: {
+              punctuation: /\./
+            }
+          },
+          "class-name": /\b[A-Z]\w*/,
+          keyword: Prism2.languages.java.keyword,
+          punctuation: /[#()[\],.]/
+        }
+      },
+      "class-name": {
+        // @param <T> the first generic type parameter
+        pattern: /(@param\s+)<[A-Z]\w*>/,
+        lookbehind: true,
+        inside: {
+          punctuation: /[.<>]/
+        }
+      },
+      "code-section": [
+        {
+          pattern: /(\{@code\s+(?!\s))(?:[^\s{}]|\s+(?![\s}])|\{(?:[^{}]|\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\})*\})+(?=\s*\})/,
+          lookbehind: true,
+          inside: {
+            code: {
+              // there can't be any HTML inside of {@code} tags
+              pattern: codeLinePattern,
+              lookbehind: true,
+              inside: Prism2.languages.java,
+              alias: "language-java"
+            }
+          }
+        },
+        {
+          pattern: /(<(code|pre|tt)>(?!<code>)\s*)\S(?:\S|\s+\S)*?(?=\s*<\/\2>)/,
+          lookbehind: true,
+          inside: {
+            line: {
+              pattern: codeLinePattern,
+              lookbehind: true,
+              inside: {
+                // highlight HTML tags and entities
+                tag: Prism2.languages.markup.tag,
+                entity: Prism2.languages.markup.entity,
+                code: {
+                  // everything else is Java code
+                  pattern: /.+/,
+                  inside: Prism2.languages.java,
+                  alias: "language-java"
+                }
+              }
+            }
+          }
+        }
+      ],
+      tag: Prism2.languages.markup.tag,
+      entity: Prism2.languages.markup.entity
+    });
+    Prism2.languages.javadoclike.addSupport("java", Prism2.languages.javadoc);
+  })(Prism);
+}
+
+export {
+  javadoc
+};

package/dist/chunk-754A44NQ.mjs

@@ -0,0 +1,25 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/gcode.js
+gcode.displayName = "gcode";
+gcode.aliases = [];
+function gcode(Prism) {
+  Prism.languages.gcode = {
+    comment: /;.*|\B\(.*?\)\B/,
+    string: {
+      pattern: /"(?:""|[^"])*"/,
+      greedy: true
+    },
+    keyword: /\b[GM]\d+(?:\.\d+)?\b/,
+    property: /\b[A-Z]/,
+    checksum: {
+      pattern: /(\*)\d+/,
+      lookbehind: true,
+      alias: "number"
+    },
+    // T0:0:0
+    punctuation: /[:*]/
+  };
+}
+
+export {
+  gcode
+};

package/dist/chunk-76342V4V.mjs

@@ -0,0 +1,53 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/armasm.js
+armasm.displayName = "armasm";
+armasm.aliases = ["arm-asm"];
+function armasm(Prism) {
+  Prism.languages.armasm = {
+    comment: {
+      pattern: /;.*/,
+      greedy: true
+    },
+    string: {
+      pattern: /"(?:[^"\r\n]|"")*"/,
+      greedy: true,
+      inside: {
+        variable: {
+          pattern: /((?:^|[^$])(?:\${2})*)\$\w+/,
+          lookbehind: true
+        }
+      }
+    },
+    char: {
+      pattern: /'(?:[^'\r\n]{0,4}|'')'/,
+      greedy: true
+    },
+    "version-symbol": {
+      pattern: /\|[\w@]+\|/,
+      greedy: true,
+      alias: "property"
+    },
+    boolean: /\b(?:FALSE|TRUE)\b/,
+    directive: {
+      pattern: /\b(?:ALIAS|ALIGN|AREA|ARM|ASSERT|ATTR|CN|CODE|CODE16|CODE32|COMMON|CP|DATA|DCB|DCD|DCDO|DCDU|DCFD|DCFDU|DCI|DCQ|DCQU|DCW|DCWU|DN|ELIF|ELSE|END|ENDFUNC|ENDIF|ENDP|ENTRY|EQU|EXPORT|EXPORTAS|EXTERN|FIELD|FILL|FN|FUNCTION|GBLA|GBLL|GBLS|GET|GLOBAL|IF|IMPORT|INCBIN|INCLUDE|INFO|KEEP|LCLA|LCLL|LCLS|LTORG|MACRO|MAP|MEND|MEXIT|NOFP|OPT|PRESERVE8|PROC|QN|READONLY|RELOC|REQUIRE|REQUIRE8|RLIST|ROUT|SETA|SETL|SETS|SN|SPACE|SUBT|THUMB|THUMBX|TTL|WEND|WHILE)\b/,
+      alias: "property"
+    },
+    instruction: {
+      pattern: /((?:^|(?:^|[^\\])(?:\r\n?|\n))[ \t]*(?:(?:[A-Z][A-Z0-9_]*[a-z]\w*|[a-z]\w*|\d+)[ \t]+)?)\b[A-Z.]+\b/,
+      lookbehind: true,
+      alias: "keyword"
+    },
+    variable: /\$\w+/,
+    number: /(?:\b[2-9]_\d+|(?:\b\d+(?:\.\d+)?|\B\.\d+)(?:e-?\d+)?|\b0(?:[fd]_|x)[0-9a-f]+|&[0-9a-f]+)\b/i,
+    register: {
+      pattern: /\b(?:r\d|lr)\b/,
+      alias: "symbol"
+    },
+    operator: /<>|<<|>>|&&|\|\||[=!<>/]=?|[+\-*%#?&|^]|:[A-Z]+:/,
+    punctuation: /[()[\],]/
+  };
+  Prism.languages["arm-asm"] = Prism.languages.armasm;
+}
+
+export {
+  armasm
+};

package/dist/chunk-7DNOFDAC.mjs

@@ -0,0 +1,144 @@
+import {
+  markup
+} from "./chunk-ACDTS7FW.mjs";
+import {
+  javascript
+} from "./chunk-ZJYVOTZA.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/jsx.js
+jsx.displayName = "jsx";
+jsx.aliases = [];
+function jsx(Prism) {
+  Prism.register(javascript);
+  Prism.register(markup);
+  (function(Prism2) {
+    var javascript2 = Prism2.util.clone(Prism2.languages.javascript);
+    var space = /(?:\s|\/\/.*(?!.)|\/\*(?:[^*]|\*(?!\/))\*\/)/.source;
+    var braces = /(?:\{(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])*\})/.source;
+    var spread = /(?:\{<S>*\.{3}(?:[^{}]|<BRACES>)*\})/.source;
+    function re(source, flags) {
+      source = source.replace(/<S>/g, function() {
+        return space;
+      }).replace(/<BRACES>/g, function() {
+        return braces;
+      }).replace(/<SPREAD>/g, function() {
+        return spread;
+      });
+      return RegExp(source, flags);
+    }
+    spread = re(spread).source;
+    Prism2.languages.jsx = Prism2.languages.extend("markup", javascript2);
+    Prism2.languages.jsx.tag.pattern = re(
+      /<\/?(?:[\w.:-]+(?:<S>+(?:[\w.:$-]+(?:=(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s{'"/>=]+|<BRACES>))?|<SPREAD>))*<S>*\/?)?>/.source
+    );
+    Prism2.languages.jsx.tag.inside["tag"].pattern = /^<\/?[^\s>\/]*/;
+    Prism2.languages.jsx.tag.inside["attr-value"].pattern = /=(?!\{)(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s'">]+)/;
+    Prism2.languages.jsx.tag.inside["tag"].inside["class-name"] = /^[A-Z]\w*(?:\.[A-Z]\w*)*$/;
+    Prism2.languages.jsx.tag.inside["comment"] = javascript2["comment"];
+    Prism2.languages.insertBefore(
+      "inside",
+      "attr-name",
+      {
+        spread: {
+          pattern: re(/<SPREAD>/.source),
+          inside: Prism2.languages.jsx
+        }
+      },
+      Prism2.languages.jsx.tag
+    );
+    Prism2.languages.insertBefore(
+      "inside",
+      "special-attr",
+      {
+        script: {
+          // Allow for two levels of nesting
+          pattern: re(/=<BRACES>/.source),
+          alias: "language-javascript",
+          inside: {
+            "script-punctuation": {
+              pattern: /^=(?=\{)/,
+              alias: "punctuation"
+            },
+            rest: Prism2.languages.jsx
+          }
+        }
+      },
+      Prism2.languages.jsx.tag
+    );
+    var stringifyToken = function(token) {
+      if (!token) {
+        return "";
+      }
+      if (typeof token === "string") {
+        return token;
+      }
+      if (typeof token.content === "string") {
+        return token.content;
+      }
+      return token.content.map(stringifyToken).join("");
+    };
+    var walkTokens = function(tokens) {
+      var openedTags = [];
+      for (var i = 0; i < tokens.length; i++) {
+        var token = tokens[i];
+        var notTagNorBrace = false;
+        if (typeof token !== "string") {
+          if (token.type === "tag" && token.content[0] && token.content[0].type === "tag") {
+            if (token.content[0].content[0].content === "</") {
+              if (openedTags.length > 0 && openedTags[openedTags.length - 1].tagName === stringifyToken(token.content[0].content[1])) {
+                openedTags.pop();
+              }
+            } else {
+              if (token.content[token.content.length - 1].content === "/>") {
+              } else {
+                openedTags.push({
+                  tagName: stringifyToken(token.content[0].content[1]),
+                  openedBraces: 0
+                });
+              }
+            }
+          } else if (openedTags.length > 0 && token.type === "punctuation" && token.content === "{") {
+            openedTags[openedTags.length - 1].openedBraces++;
+          } else if (openedTags.length > 0 && openedTags[openedTags.length - 1].openedBraces > 0 && token.type === "punctuation" && token.content === "}") {
+            openedTags[openedTags.length - 1].openedBraces--;
+          } else {
+            notTagNorBrace = true;
+          }
+        }
+        if (notTagNorBrace || typeof token === "string") {
+          if (openedTags.length > 0 && openedTags[openedTags.length - 1].openedBraces === 0) {
+            var plainText = stringifyToken(token);
+            if (i < tokens.length - 1 && (typeof tokens[i + 1] === "string" || tokens[i + 1].type === "plain-text")) {
+              plainText += stringifyToken(tokens[i + 1]);
+              tokens.splice(i + 1, 1);
+            }
+            if (i > 0 && (typeof tokens[i - 1] === "string" || tokens[i - 1].type === "plain-text")) {
+              plainText = stringifyToken(tokens[i - 1]) + plainText;
+              tokens.splice(i - 1, 1);
+              i--;
+            }
+            tokens[i] = new Prism2.Token(
+              "plain-text",
+              plainText,
+              null,
+              plainText
+            );
+          }
+        }
+        if (token.content && typeof token.content !== "string") {
+          walkTokens(token.content);
+        }
+      }
+    };
+    Prism2.hooks.add("after-tokenize", function(env) {
+      if (env.language !== "jsx" && env.language !== "tsx") {
+        return;
+      }
+      walkTokens(env.tokens);
+    });
+  })(Prism);
+}
+
+export {
+  jsx
+};