@photonix/basic 2.3.0 → 3.0.0

package/dist/chunk-4PP7IENX.mjs

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

@@ -1,39 +0,0 @@
-// ../../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

@@ -1,76 +0,0 @@
-// ../../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

@@ -1,41 +0,0 @@
-// ../../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

@@ -1,29 +0,0 @@
-// ../../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

@@ -1,34 +0,0 @@
-// ../../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

@@ -1,61 +0,0 @@
-// ../../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
-};