@distri/react 0.3.1 → 0.3.2

package/dist/chunk-YXLPUUQE.js

@@ -0,0 +1,352 @@
+"use client";
+import {
+  require_markup_templating
+} from "./chunk-XUQ4ZZPG.js";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/php.js
+var require_php = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/php.js"(exports, module) {
+    var refractorMarkupTemplating = require_markup_templating();
+    module.exports = php;
+    php.displayName = "php";
+    php.aliases = [];
+    function php(Prism) {
+      Prism.register(refractorMarkupTemplating);
+      (function(Prism2) {
+        var comment = /\/\*[\s\S]*?\*\/|\/\/.*|#(?!\[).*/;
+        var constant = [
+          {
+            pattern: /\b(?:false|true)\b/i,
+            alias: "boolean"
+          },
+          {
+            pattern: /(::\s*)\b[a-z_]\w*\b(?!\s*\()/i,
+            greedy: true,
+            lookbehind: true
+          },
+          {
+            pattern: /(\b(?:case|const)\s+)\b[a-z_]\w*(?=\s*[;=])/i,
+            greedy: true,
+            lookbehind: true
+          },
+          /\b(?:null)\b/i,
+          /\b[A-Z_][A-Z0-9_]*\b(?!\s*\()/
+        ];
+        var number = /\b0b[01]+(?:_[01]+)*\b|\b0o[0-7]+(?:_[0-7]+)*\b|\b0x[\da-f]+(?:_[\da-f]+)*\b|(?:\b\d+(?:_\d+)*\.?(?:\d+(?:_\d+)*)?|\B\.\d+)(?:e[+-]?\d+)?/i;
+        var operator = /<?=>|\?\?=?|\.{3}|\??->|[!=]=?=?|::|\*\*=?|--|\+\+|&&|\|\||<<|>>|[?~]|[/^|%*&<>.+-]=?/;
+        var punctuation = /[{}\[\](),:;]/;
+        Prism2.languages.php = {
+          delimiter: {
+            pattern: /\?>$|^<\?(?:php(?=\s)|=)?/i,
+            alias: "important"
+          },
+          comment,
+          variable: /\$+(?:\w+\b|(?=\{))/,
+          package: {
+            pattern: /(namespace\s+|use\s+(?:function\s+)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
+            lookbehind: true,
+            inside: {
+              punctuation: /\\/
+            }
+          },
+          "class-name-definition": {
+            pattern: /(\b(?:class|enum|interface|trait)\s+)\b[a-z_]\w*(?!\\)\b/i,
+            lookbehind: true,
+            alias: "class-name"
+          },
+          "function-definition": {
+            pattern: /(\bfunction\s+)[a-z_]\w*(?=\s*\()/i,
+            lookbehind: true,
+            alias: "function"
+          },
+          keyword: [
+            {
+              pattern: /(\(\s*)\b(?:array|bool|boolean|float|int|integer|object|string)\b(?=\s*\))/i,
+              alias: "type-casting",
+              greedy: true,
+              lookbehind: true
+            },
+            {
+              pattern: /([(,?]\s*)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|object|self|static|string)\b(?=\s*\$)/i,
+              alias: "type-hint",
+              greedy: true,
+              lookbehind: true
+            },
+            {
+              pattern: /(\)\s*:\s*(?:\?\s*)?)\b(?:array(?!\s*\()|bool|callable|(?:false|null)(?=\s*\|)|float|int|iterable|mixed|object|self|static|string|void)\b/i,
+              alias: "return-type",
+              greedy: true,
+              lookbehind: true
+            },
+            {
+              pattern: /\b(?:array(?!\s*\()|bool|float|int|iterable|mixed|object|string|void)\b/i,
+              alias: "type-declaration",
+              greedy: true
+            },
+            {
+              pattern: /(\|\s*)(?:false|null)\b|\b(?:false|null)(?=\s*\|)/i,
+              alias: "type-declaration",
+              greedy: true,
+              lookbehind: true
+            },
+            {
+              pattern: /\b(?:parent|self|static)(?=\s*::)/i,
+              alias: "static-context",
+              greedy: true
+            },
+            {
+              // yield from
+              pattern: /(\byield\s+)from\b/i,
+              lookbehind: true
+            },
+            // `class` is always a keyword unlike other keywords
+            /\bclass\b/i,
+            {
+              // https://www.php.net/manual/en/reserved.keywords.php
+              //
+              // keywords cannot be preceded by "->"
+              // the complex lookbehind means `(?<!(?:->|::)\s*)`
+              pattern: /((?:^|[^\s>:]|(?:^|[^-])>|(?:^|[^:]):)\s*)\b(?:abstract|and|array|as|break|callable|case|catch|clone|const|continue|declare|default|die|do|echo|else|elseif|empty|enddeclare|endfor|endforeach|endif|endswitch|endwhile|enum|eval|exit|extends|final|finally|fn|for|foreach|function|global|goto|if|implements|include|include_once|instanceof|insteadof|interface|isset|list|match|namespace|new|or|parent|print|private|protected|public|require|require_once|return|self|static|switch|throw|trait|try|unset|use|var|while|xor|yield|__halt_compiler)\b/i,
+              lookbehind: true
+            }
+          ],
+          "argument-name": {
+            pattern: /([(,]\s+)\b[a-z_]\w*(?=\s*:(?!:))/i,
+            lookbehind: true
+          },
+          "class-name": [
+            {
+              pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self|\s+static))\s+|\bcatch\s*\()\b[a-z_]\w*(?!\\)\b/i,
+              greedy: true,
+              lookbehind: true
+            },
+            {
+              pattern: /(\|\s*)\b[a-z_]\w*(?!\\)\b/i,
+              greedy: true,
+              lookbehind: true
+            },
+            {
+              pattern: /\b[a-z_]\w*(?!\\)\b(?=\s*\|)/i,
+              greedy: true
+            },
+            {
+              pattern: /(\|\s*)(?:\\?\b[a-z_]\w*)+\b/i,
+              alias: "class-name-fully-qualified",
+              greedy: true,
+              lookbehind: true,
+              inside: {
+                punctuation: /\\/
+              }
+            },
+            {
+              pattern: /(?:\\?\b[a-z_]\w*)+\b(?=\s*\|)/i,
+              alias: "class-name-fully-qualified",
+              greedy: true,
+              inside: {
+                punctuation: /\\/
+              }
+            },
+            {
+              pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self\b|\s+static\b))\s+|\bcatch\s*\()(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
+              alias: "class-name-fully-qualified",
+              greedy: true,
+              lookbehind: true,
+              inside: {
+                punctuation: /\\/
+              }
+            },
+            {
+              pattern: /\b[a-z_]\w*(?=\s*\$)/i,
+              alias: "type-declaration",
+              greedy: true
+            },
+            {
+              pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i,
+              alias: ["class-name-fully-qualified", "type-declaration"],
+              greedy: true,
+              inside: {
+                punctuation: /\\/
+              }
+            },
+            {
+              pattern: /\b[a-z_]\w*(?=\s*::)/i,
+              alias: "static-context",
+              greedy: true
+            },
+            {
+              pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*::)/i,
+              alias: ["class-name-fully-qualified", "static-context"],
+              greedy: true,
+              inside: {
+                punctuation: /\\/
+              }
+            },
+            {
+              pattern: /([(,?]\s*)[a-z_]\w*(?=\s*\$)/i,
+              alias: "type-hint",
+              greedy: true,
+              lookbehind: true
+            },
+            {
+              pattern: /([(,?]\s*)(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i,
+              alias: ["class-name-fully-qualified", "type-hint"],
+              greedy: true,
+              lookbehind: true,
+              inside: {
+                punctuation: /\\/
+              }
+            },
+            {
+              pattern: /(\)\s*:\s*(?:\?\s*)?)\b[a-z_]\w*(?!\\)\b/i,
+              alias: "return-type",
+              greedy: true,
+              lookbehind: true
+            },
+            {
+              pattern: /(\)\s*:\s*(?:\?\s*)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
+              alias: ["class-name-fully-qualified", "return-type"],
+              greedy: true,
+              lookbehind: true,
+              inside: {
+                punctuation: /\\/
+              }
+            }
+          ],
+          constant,
+          function: {
+            pattern: /(^|[^\\\w])\\?[a-z_](?:[\w\\]*\w)?(?=\s*\()/i,
+            lookbehind: true,
+            inside: {
+              punctuation: /\\/
+            }
+          },
+          property: {
+            pattern: /(->\s*)\w+/,
+            lookbehind: true
+          },
+          number,
+          operator,
+          punctuation
+        };
+        var string_interpolation = {
+          pattern: /\{\$(?:\{(?:\{[^{}]+\}|[^{}]+)\}|[^{}])+\}|(^|[^\\{])\$+(?:\w+(?:\[[^\r\n\[\]]+\]|->\w+)?)/,
+          lookbehind: true,
+          inside: Prism2.languages.php
+        };
+        var string = [
+          {
+            pattern: /<<<'([^']+)'[\r\n](?:.*[\r\n])*?\1;/,
+            alias: "nowdoc-string",
+            greedy: true,
+            inside: {
+              delimiter: {
+                pattern: /^<<<'[^']+'|[a-z_]\w*;$/i,
+                alias: "symbol",
+                inside: {
+                  punctuation: /^<<<'?|[';]$/
+                }
+              }
+            }
+          },
+          {
+            pattern: /<<<(?:"([^"]+)"[\r\n](?:.*[\r\n])*?\1;|([a-z_]\w*)[\r\n](?:.*[\r\n])*?\2;)/i,
+            alias: "heredoc-string",
+            greedy: true,
+            inside: {
+              delimiter: {
+                pattern: /^<<<(?:"[^"]+"|[a-z_]\w*)|[a-z_]\w*;$/i,
+                alias: "symbol",
+                inside: {
+                  punctuation: /^<<<"?|[";]$/
+                }
+              },
+              interpolation: string_interpolation
+            }
+          },
+          {
+            pattern: /`(?:\\[\s\S]|[^\\`])*`/,
+            alias: "backtick-quoted-string",
+            greedy: true
+          },
+          {
+            pattern: /'(?:\\[\s\S]|[^\\'])*'/,
+            alias: "single-quoted-string",
+            greedy: true
+          },
+          {
+            pattern: /"(?:\\[\s\S]|[^\\"])*"/,
+            alias: "double-quoted-string",
+            greedy: true,
+            inside: {
+              interpolation: string_interpolation
+            }
+          }
+        ];
+        Prism2.languages.insertBefore("php", "variable", {
+          string,
+          attribute: {
+            pattern: /#\[(?:[^"'\/#]|\/(?![*/])|\/\/.*$|#(?!\[).*$|\/\*(?:[^*]|\*(?!\/))*\*\/|"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*')+\](?=\s*[a-z$#])/im,
+            greedy: true,
+            inside: {
+              "attribute-content": {
+                pattern: /^(#\[)[\s\S]+(?=\]$)/,
+                lookbehind: true,
+                // inside can appear subset of php
+                inside: {
+                  comment,
+                  string,
+                  "attribute-class-name": [
+                    {
+                      pattern: /([^:]|^)\b[a-z_]\w*(?!\\)\b/i,
+                      alias: "class-name",
+                      greedy: true,
+                      lookbehind: true
+                    },
+                    {
+                      pattern: /([^:]|^)(?:\\?\b[a-z_]\w*)+/i,
+                      alias: ["class-name", "class-name-fully-qualified"],
+                      greedy: true,
+                      lookbehind: true,
+                      inside: {
+                        punctuation: /\\/
+                      }
+                    }
+                  ],
+                  constant,
+                  number,
+                  operator,
+                  punctuation
+                }
+              },
+              delimiter: {
+                pattern: /^#\[|\]$/,
+                alias: "punctuation"
+              }
+            }
+          }
+        });
+        Prism2.hooks.add("before-tokenize", function(env) {
+          if (!/<\?/.test(env.code)) {
+            return;
+          }
+          var phpPattern = /<\?(?:[^"'/#]|\/(?![*/])|("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|(?:\/\/|#(?!\[))(?:[^?\n\r]|\?(?!>))*(?=$|\?>|[\r\n])|#\[|\/\*(?:[^*]|\*(?!\/))*(?:\*\/|$))*?(?:\?>|$)/g;
+          Prism2.languages["markup-templating"].buildPlaceholders(
+            env,
+            "php",
+            phpPattern
+          );
+        });
+        Prism2.hooks.add("after-tokenize", function(env) {
+          Prism2.languages["markup-templating"].tokenizePlaceholders(env, "php");
+        });
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_php
+};

package/dist/chunk-Z7PWFZG5.js

@@ -0,0 +1,31 @@
+"use client";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __commonJS,
+  __toESM
+};

package/dist/chunk-ZFT3ZS7W.js

@@ -0,0 +1,51 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/dns-zone-file.js
+var require_dns_zone_file = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/dns-zone-file.js"(exports, module) {
+    module.exports = dnsZoneFile;
+    dnsZoneFile.displayName = "dnsZoneFile";
+    dnsZoneFile.aliases = [];
+    function dnsZoneFile(Prism) {
+      Prism.languages["dns-zone-file"] = {
+        comment: /;.*/,
+        string: {
+          pattern: /"(?:\\.|[^"\\\r\n])*"/,
+          greedy: true
+        },
+        variable: [
+          {
+            pattern: /(^\$ORIGIN[ \t]+)\S+/m,
+            lookbehind: true
+          },
+          {
+            pattern: /(^|\s)@(?=\s|$)/,
+            lookbehind: true
+          }
+        ],
+        keyword: /^\$(?:INCLUDE|ORIGIN|TTL)(?=\s|$)/m,
+        class: {
+          // https://tools.ietf.org/html/rfc1035#page-13
+          pattern: /(^|\s)(?:CH|CS|HS|IN)(?=\s|$)/,
+          lookbehind: true,
+          alias: "keyword"
+        },
+        type: {
+          // https://en.wikipedia.org/wiki/List_of_DNS_record_types
+          pattern: /(^|\s)(?:A|A6|AAAA|AFSDB|APL|ATMA|CAA|CDNSKEY|CDS|CERT|CNAME|DHCID|DLV|DNAME|DNSKEY|DS|EID|GID|GPOS|HINFO|HIP|IPSECKEY|ISDN|KEY|KX|LOC|MAILA|MAILB|MB|MD|MF|MG|MINFO|MR|MX|NAPTR|NB|NBSTAT|NIMLOC|NINFO|NS|NSAP|NSAP-PTR|NSEC|NSEC3|NSEC3PARAM|NULL|NXT|OPENPGPKEY|PTR|PX|RKEY|RP|RRSIG|RT|SIG|SINK|SMIMEA|SOA|SPF|SRV|SSHFP|TA|TKEY|TLSA|TSIG|TXT|UID|UINFO|UNSPEC|URI|WKS|X25)(?=\s|$)/,
+          lookbehind: true,
+          alias: "keyword"
+        },
+        punctuation: /[()]/
+      };
+      Prism.languages["dns-zone"] = Prism.languages["dns-zone-file"];
+    }
+  }
+});
+
+export {
+  require_dns_zone_file
+};

package/dist/chunk-ZJPNZEZR.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-ZJRUSLCY.js

@@ -0,0 +1,35 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/actionscript.js
+var require_actionscript = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/actionscript.js"(exports, module) {
+    module.exports = actionscript;
+    actionscript.displayName = "actionscript";
+    actionscript.aliases = [];
+    function actionscript(Prism) {
+      Prism.languages.actionscript = Prism.languages.extend("javascript", {
+        keyword: /\b(?:as|break|case|catch|class|const|default|delete|do|dynamic|each|else|extends|final|finally|for|function|get|if|implements|import|in|include|instanceof|interface|internal|is|namespace|native|new|null|override|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|use|var|void|while|with)\b/,
+        operator: /\+\+|--|(?:[+\-*\/%^]|&&?|\|\|?|<<?|>>?>?|[!=]=?)=?|[~?@]/
+      });
+      Prism.languages.actionscript["class-name"].alias = "function";
+      delete Prism.languages.actionscript["parameter"];
+      delete Prism.languages.actionscript["literal-property"];
+      if (Prism.languages.markup) {
+        Prism.languages.insertBefore("actionscript", "string", {
+          xml: {
+            pattern: /(^|[^.])<\/?\w+(?:\s+[^\s>\/=]+=("|')(?:\\[\s\S]|(?!\2)[^\\])*\2)*\s*\/?>/,
+            lookbehind: true,
+            inside: Prism.languages.markup
+          }
+        });
+      }
+    }
+  }
+});
+
+export {
+  require_actionscript
+};

package/dist/chunk-ZN7VL73E.js

@@ -0,0 +1,80 @@
+"use client";
+import {
+  __commonJS
+} from "./chunk-Z7PWFZG5.js";
+
+// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/sml.js
+var require_sml = __commonJS({
+  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/sml.js"(exports, module) {
+    module.exports = sml;
+    sml.displayName = "sml";
+    sml.aliases = ["smlnj"];
+    function sml(Prism) {
+      ;
+      (function(Prism2) {
+        var keywords = /\b(?:abstype|and|andalso|as|case|datatype|do|else|end|eqtype|exception|fn|fun|functor|handle|if|in|include|infix|infixr|let|local|nonfix|of|op|open|orelse|raise|rec|sharing|sig|signature|struct|structure|then|type|val|where|while|with|withtype)\b/i;
+        Prism2.languages.sml = {
+          // allow one level of nesting
+          comment: /\(\*(?:[^*(]|\*(?!\))|\((?!\*)|\(\*(?:[^*(]|\*(?!\))|\((?!\*))*\*\))*\*\)/,
+          string: {
+            pattern: /#?"(?:[^"\\]|\\.)*"/,
+            greedy: true
+          },
+          "class-name": [
+            {
+              // This is only an approximation since the real grammar is context-free
+              //
+              // Why the main loop so complex?
+              // The main loop is approximately the same as /(?:\s*(?:[*,]|->)\s*<TERMINAL>)*/ which is, obviously, a lot
+              // simpler. The difference is that if a comma is the last iteration of the loop, then the terminal must be
+              // followed by a long identifier.
+              pattern: RegExp(
+                /((?:^|[^:]):\s*)<TERMINAL>(?:\s*(?:(?:\*|->)\s*<TERMINAL>|,\s*<TERMINAL>(?:(?=<NOT-LAST>)|(?!<NOT-LAST>)\s+<LONG-ID>)))*/.source.replace(/<NOT-LAST>/g, function() {
+                  return /\s*(?:[*,]|->)/.source;
+                }).replace(/<TERMINAL>/g, function() {
+                  return /(?:'[\w']*|<LONG-ID>|\((?:[^()]|\([^()]*\))*\)|\{(?:[^{}]|\{[^{}]*\})*\})(?:\s+<LONG-ID>)*/.source;
+                }).replace(/<LONG-ID>/g, function() {
+                  return /(?!<KEYWORD>)[a-z\d_][\w'.]*/.source;
+                }).replace(/<KEYWORD>/g, function() {
+                  return keywords.source;
+                }),
+                "i"
+              ),
+              lookbehind: true,
+              greedy: true,
+              inside: null
+              // see below
+            },
+            {
+              pattern: /((?:^|[^\w'])(?:datatype|exception|functor|signature|structure|type)\s+)[a-z_][\w'.]*/i,
+              lookbehind: true
+            }
+          ],
+          function: {
+            pattern: /((?:^|[^\w'])fun\s+)[a-z_][\w'.]*/i,
+            lookbehind: true
+          },
+          keyword: keywords,
+          variable: {
+            pattern: /(^|[^\w'])'[\w']*/,
+            lookbehind: true
+          },
+          number: /~?\b(?:\d+(?:\.\d+)?(?:e~?\d+)?|0x[\da-f]+)\b/i,
+          word: {
+            pattern: /\b0w(?:\d+|x[\da-f]+)\b/i,
+            alias: "constant"
+          },
+          boolean: /\b(?:false|true)\b/i,
+          operator: /\.\.\.|:[>=:]|=>?|->|[<>]=?|[!+\-*/^#|@~]/,
+          punctuation: /[(){}\[\].:,;]/
+        };
+        Prism2.languages.sml["class-name"][0].inside = Prism2.languages.sml;
+        Prism2.languages.smlnj = Prism2.languages.sml;
+      })(Prism);
+    }
+  }
+});
+
+export {
+  require_sml
+};