@photonix/basic 1.5.1 → 1.6.1

package/dist/chunk-4PP7IENX.mjs

@@ -0,0 +1,342 @@
+import {
+  markupTemplating
+} from "./chunk-DFNMTLAN.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/php.js
+php.displayName = "php";
+php.aliases = [];
+function php(Prism) {
+  Prism.register(markupTemplating);
+  (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|never|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|never|new|or|parent|print|private|protected|public|readonly|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 {
+  php
+};

package/dist/chunk-4QGWGXRH.mjs

@@ -0,0 +1,39 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/magma.js
+magma.displayName = "magma";
+magma.aliases = [];
+function magma(Prism) {
+  Prism.languages.magma = {
+    output: {
+      pattern: /^(>.*(?:\r(?:\n|(?!\n))|\n))(?!>)(?:.+|(?:\r(?:\n|(?!\n))|\n)(?!>).*)(?:(?:\r(?:\n|(?!\n))|\n)(?!>).*)*/m,
+      lookbehind: true,
+      greedy: true
+    },
+    comment: {
+      pattern: /\/\/.*|\/\*[\s\S]*?\*\//,
+      greedy: true
+    },
+    string: {
+      pattern: /(^|[^\\"])"(?:[^\r\n\\"]|\\.)*"/,
+      lookbehind: true,
+      greedy: true
+    },
+    // http://magma.maths.usyd.edu.au/magma/handbook/text/82
+    keyword: /\b(?:_|adj|and|assert|assert2|assert3|assigned|break|by|case|cat|catch|clear|cmpeq|cmpne|continue|declare|default|delete|diff|div|do|elif|else|end|eq|error|eval|exists|exit|for|forall|forward|fprintf|freeze|function|ge|gt|if|iload|import|in|intrinsic|is|join|le|load|local|lt|meet|mod|ne|not|notadj|notin|notsubset|or|print|printf|procedure|quit|random|read|readi|repeat|require|requirege|requirerange|restore|return|save|sdiff|select|subset|then|time|to|try|until|vprint|vprintf|vtime|when|where|while|xor)\b/,
+    boolean: /\b(?:false|true)\b/,
+    generator: {
+      pattern: /\b[a-z_]\w*(?=\s*<)/i,
+      alias: "class-name"
+    },
+    function: /\b[a-z_]\w*(?=\s*\()/i,
+    number: {
+      pattern: /(^|[^\w.]|\.\.)(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?(?:_[a-z]?)?(?=$|[^\w.]|\.\.)/,
+      lookbehind: true
+    },
+    operator: /->|[-+*/^~!|#=]|:=|\.\./,
+    punctuation: /[()[\]{}<>,;.:]/
+  };
+}
+
+export {
+  magma
+};

package/dist/chunk-4RG7ZGOZ.mjs

@@ -0,0 +1,76 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/css.js
+css.displayName = "css";
+css.aliases = [];
+function css(Prism) {
+  ;
+  (function(Prism2) {
+    var string = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;
+    Prism2.languages.css = {
+      comment: /\/\*[\s\S]*?\*\//,
+      atrule: {
+        pattern: RegExp(
+          "@[\\w-](?:" + /[^;{\s"']|\s+(?!\s)/.source + "|" + string.source + ")*?" + /(?:;|(?=\s*\{))/.source
+        ),
+        inside: {
+          rule: /^@[\w-]+/,
+          "selector-function-argument": {
+            pattern: /(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/,
+            lookbehind: true,
+            alias: "selector"
+          },
+          keyword: {
+            pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/,
+            lookbehind: true
+          }
+          // See rest below
+        }
+      },
+      url: {
+        // https://drafts.csswg.org/css-values-3/#urls
+        pattern: RegExp(
+          "\\burl\\((?:" + string.source + "|" + /(?:[^\\\r\n()"']|\\[\s\S])*/.source + ")\\)",
+          "i"
+        ),
+        greedy: true,
+        inside: {
+          function: /^url/i,
+          punctuation: /^\(|\)$/,
+          string: {
+            pattern: RegExp("^" + string.source + "$"),
+            alias: "url"
+          }
+        }
+      },
+      selector: {
+        pattern: RegExp(
+          `(^|[{}\\s])[^{}\\s](?:[^{};"'\\s]|\\s+(?![\\s{])|` + string.source + ")*(?=\\s*\\{)"
+        ),
+        lookbehind: true
+      },
+      string: {
+        pattern: string,
+        greedy: true
+      },
+      property: {
+        pattern: /(^|[^-\w\xA0-\uFFFF])(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i,
+        lookbehind: true
+      },
+      important: /!important\b/i,
+      function: {
+        pattern: /(^|[^-a-z0-9])[-a-z0-9]+(?=\()/i,
+        lookbehind: true
+      },
+      punctuation: /[(){};:,]/
+    };
+    Prism2.languages.css["atrule"].inside.rest = Prism2.languages.css;
+    var markup = Prism2.languages.markup;
+    if (markup) {
+      markup.tag.addInlined("style", "css");
+      markup.tag.addAttribute("style", "css");
+    }
+  })(Prism);
+}
+
+export {
+  css
+};

package/dist/chunk-4TVIJFTY.mjs

@@ -0,0 +1,41 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/apl.js
+apl.displayName = "apl";
+apl.aliases = [];
+function apl(Prism) {
+  Prism.languages.apl = {
+    comment: /(?:⍝|#[! ]).*$/m,
+    string: {
+      pattern: /'(?:[^'\r\n]|'')*'/,
+      greedy: true
+    },
+    number: /¯?(?:\d*\.?\b\d+(?:e[+¯]?\d+)?|¯|∞)(?:j¯?(?:(?:\d+(?:\.\d+)?|\.\d+)(?:e[+¯]?\d+)?|¯|∞))?/i,
+    statement: /:[A-Z][a-z][A-Za-z]*\b/,
+    "system-function": {
+      pattern: /⎕[A-Z]+/i,
+      alias: "function"
+    },
+    constant: /[⍬⌾#⎕⍞]/,
+    function: /[-+×÷⌈⌊∣|⍳⍸?*⍟○!⌹<≤=>≥≠≡≢∊⍷∪∩~∨∧⍱⍲⍴,⍪⌽⊖⍉↑↓⊂⊃⊆⊇⌷⍋⍒⊤⊥⍕⍎⊣⊢⍁⍂≈⍯↗¤→]/,
+    "monadic-operator": {
+      pattern: /[\\\/⌿⍀¨⍨⌶&∥]/,
+      alias: "operator"
+    },
+    "dyadic-operator": {
+      pattern: /[.⍣⍠⍤∘⌸@⌺⍥]/,
+      alias: "operator"
+    },
+    assignment: {
+      pattern: /←/,
+      alias: "keyword"
+    },
+    punctuation: /[\[;\]()◇⋄]/,
+    dfn: {
+      pattern: /[{}⍺⍵⍶⍹∇⍫:]/,
+      alias: "builtin"
+    }
+  };
+}
+
+export {
+  apl
+};

package/dist/chunk-4UFFAAYI.mjs

@@ -0,0 +1,29 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/bnf.js
+bnf.displayName = "bnf";
+bnf.aliases = ["rbnf"];
+function bnf(Prism) {
+  Prism.languages.bnf = {
+    string: {
+      pattern: /"[^\r\n"]*"|'[^\r\n']*'/
+    },
+    definition: {
+      pattern: /<[^<>\r\n\t]+>(?=\s*::=)/,
+      alias: ["rule", "keyword"],
+      inside: {
+        punctuation: /^<|>$/
+      }
+    },
+    rule: {
+      pattern: /<[^<>\r\n\t]+>/,
+      inside: {
+        punctuation: /^<|>$/
+      }
+    },
+    operator: /::=|[|()[\]{}*+?]|\.{3}/
+  };
+  Prism.languages.rbnf = Prism.languages.bnf;
+}
+
+export {
+  bnf
+};

package/dist/chunk-4V7KVWVD.mjs

@@ -0,0 +1,34 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/rego.js
+rego.displayName = "rego";
+rego.aliases = [];
+function rego(Prism) {
+  Prism.languages.rego = {
+    comment: /#.*/,
+    property: {
+      pattern: /(^|[^\\.])(?:"(?:\\.|[^\\"\r\n])*"|`[^`]*`|\b[a-z_]\w*\b)(?=\s*:(?!=))/i,
+      lookbehind: true,
+      greedy: true
+    },
+    string: {
+      pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"|`[^`]*`/,
+      lookbehind: true,
+      greedy: true
+    },
+    keyword: /\b(?:as|default|else|import|not|null|package|set(?=\s*\()|some|with)\b/,
+    boolean: /\b(?:false|true)\b/,
+    function: {
+      pattern: /\b[a-z_]\w*\b(?:\s*\.\s*\b[a-z_]\w*\b)*(?=\s*\()/i,
+      inside: {
+        namespace: /\b\w+\b(?=\s*\.)/,
+        punctuation: /\./
+      }
+    },
+    number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+    operator: /[-+*/%|&]|[<>:=]=?|!=|\b_\b/,
+    punctuation: /[,;.\[\]{}()]/
+  };
+}
+
+export {
+  rego
+};

package/dist/chunk-55FPWNBC.mjs

@@ -0,0 +1,61 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/powerquery.js
+powerquery.displayName = "powerquery";
+powerquery.aliases = ["mscript", "pq"];
+function powerquery(Prism) {
+  Prism.languages.powerquery = {
+    comment: {
+      pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/,
+      lookbehind: true,
+      greedy: true
+    },
+    "quoted-identifier": {
+      pattern: /#"(?:[^"\r\n]|"")*"(?!")/,
+      greedy: true
+    },
+    string: {
+      pattern: /(?:#!)?"(?:[^"\r\n]|"")*"(?!")/,
+      greedy: true
+    },
+    constant: [
+      /\bDay\.(?:Friday|Monday|Saturday|Sunday|Thursday|Tuesday|Wednesday)\b/,
+      /\bTraceLevel\.(?:Critical|Error|Information|Verbose|Warning)\b/,
+      /\bOccurrence\.(?:All|First|Last)\b/,
+      /\bOrder\.(?:Ascending|Descending)\b/,
+      /\bRoundingMode\.(?:AwayFromZero|Down|ToEven|TowardZero|Up)\b/,
+      /\bMissingField\.(?:Error|Ignore|UseNull)\b/,
+      /\bQuoteStyle\.(?:Csv|None)\b/,
+      /\bJoinKind\.(?:FullOuter|Inner|LeftAnti|LeftOuter|RightAnti|RightOuter)\b/,
+      /\bGroupKind\.(?:Global|Local)\b/,
+      /\bExtraValues\.(?:Error|Ignore|List)\b/,
+      /\bJoinAlgorithm\.(?:Dynamic|LeftHash|LeftIndex|PairwiseHash|RightHash|RightIndex|SortMerge)\b/,
+      /\bJoinSide\.(?:Left|Right)\b/,
+      /\bPrecision\.(?:Decimal|Double)\b/,
+      /\bRelativePosition\.From(?:End|Start)\b/,
+      /\bTextEncoding\.(?:Ascii|BigEndianUnicode|Unicode|Utf16|Utf8|Windows)\b/,
+      /\b(?:Any|Binary|Date|DateTime|DateTimeZone|Duration|Function|Int16|Int32|Int64|Int8|List|Logical|None|Number|Record|Table|Text|Time)\.Type\b/,
+      /\bnull\b/
+    ],
+    boolean: /\b(?:false|true)\b/,
+    keyword: /\b(?:and|as|each|else|error|if|in|is|let|meta|not|nullable|optional|or|otherwise|section|shared|then|try|type)\b|#(?:binary|date|datetime|datetimezone|duration|infinity|nan|sections|shared|table|time)\b/,
+    function: {
+      pattern: /(^|[^#\w.])[a-z_][\w.]*(?=\s*\()/i,
+      lookbehind: true
+    },
+    "data-type": {
+      pattern: /\b(?:any|anynonnull|binary|date|datetime|datetimezone|duration|function|list|logical|none|number|record|table|text|time)\b/,
+      alias: "class-name"
+    },
+    number: {
+      pattern: /\b0x[\da-f]+\b|(?:[+-]?(?:\b\d+\.)?\b\d+|[+-]\.\d+|(^|[^.])\B\.\d+)(?:e[+-]?\d+)?\b/i,
+      lookbehind: true
+    },
+    operator: /[-+*\/&?@^]|<(?:=>?|>)?|>=?|=>?|\.\.\.?/,
+    punctuation: /[,;\[\](){}]/
+  };
+  Prism.languages.pq = Prism.languages["powerquery"];
+  Prism.languages.mscript = Prism.languages["powerquery"];
+}
+
+export {
+  powerquery
+};