@photonix/basic 2.2.1 → 3.0.0

package/dist/chunk-P7GNDSPG.mjs

@@ -1,92 +0,0 @@
-import {
-  markup
-} from "./chunk-ACDTS7FW.mjs";
-
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/wiki.js
-wiki.displayName = "wiki";
-wiki.aliases = [];
-function wiki(Prism) {
-  Prism.register(markup);
-  Prism.languages.wiki = Prism.languages.extend("markup", {
-    "block-comment": {
-      pattern: /(^|[^\\])\/\*[\s\S]*?\*\//,
-      lookbehind: true,
-      alias: "comment"
-    },
-    heading: {
-      pattern: /^(=+)[^=\r\n].*?\1/m,
-      inside: {
-        punctuation: /^=+|=+$/,
-        important: /.+/
-      }
-    },
-    emphasis: {
-      // TODO Multi-line
-      pattern: /('{2,5}).+?\1/,
-      inside: {
-        "bold-italic": {
-          pattern: /(''''').+?(?=\1)/,
-          lookbehind: true,
-          alias: ["bold", "italic"]
-        },
-        bold: {
-          pattern: /(''')[^'](?:.*?[^'])?(?=\1)/,
-          lookbehind: true
-        },
-        italic: {
-          pattern: /('')[^'](?:.*?[^'])?(?=\1)/,
-          lookbehind: true
-        },
-        punctuation: /^''+|''+$/
-      }
-    },
-    hr: {
-      pattern: /^-{4,}/m,
-      alias: "punctuation"
-    },
-    url: [
-      /ISBN +(?:97[89][ -]?)?(?:\d[ -]?){9}[\dx]\b|(?:PMID|RFC) +\d+/i,
-      /\[\[.+?\]\]|\[.+?\]/
-    ],
-    variable: [
-      /__[A-Z]+__/,
-      // FIXME Nested structures should be handled
-      // {{formatnum:{{#expr:{{{3}}}}}}}
-      /\{{3}.+?\}{3}/,
-      /\{\{.+?\}\}/
-    ],
-    symbol: [/^#redirect/im, /~{3,5}/],
-    // Handle table attrs:
-    // {|
-    // ! style="text-align:left;"| Item
-    // |}
-    "table-tag": {
-      pattern: /((?:^|[|!])[|!])[^|\r\n]+\|(?!\|)/m,
-      lookbehind: true,
-      inside: {
-        "table-bar": {
-          pattern: /\|$/,
-          alias: "punctuation"
-        },
-        rest: Prism.languages.markup["tag"].inside
-      }
-    },
-    punctuation: /^(?:\{\||\|\}|\|-|[*#:;!|])|\|\||!!/m
-  });
-  Prism.languages.insertBefore("wiki", "tag", {
-    // Prevent highlighting inside <nowiki>, <source> and <pre> tags
-    nowiki: {
-      pattern: /<(nowiki|pre|source)\b[^>]*>[\s\S]*?<\/\1>/i,
-      inside: {
-        tag: {
-          pattern: /<(?:nowiki|pre|source)\b[^>]*>|<\/(?:nowiki|pre|source)>/i,
-          inside: Prism.languages.markup["tag"].inside
-        }
-      }
-    }
-  });
-}
-
-export {
-  wiki
-};

package/dist/chunk-PEEMT7UZ.mjs

@@ -1,90 +0,0 @@
-import {
-  clike
-} from "./chunk-XWTEQUC3.mjs";
-
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/c.js
-c.displayName = "c";
-c.aliases = [];
-function c(Prism) {
-  Prism.register(clike);
-  Prism.languages.c = Prism.languages.extend("clike", {
-    comment: {
-      pattern: /\/\/(?:[^\r\n\\]|\\(?:\r\n?|\n|(?![\r\n])))*|\/\*[\s\S]*?(?:\*\/|$)/,
-      greedy: true
-    },
-    string: {
-      // https://en.cppreference.com/w/c/language/string_literal
-      pattern: /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/,
-      greedy: true
-    },
-    "class-name": {
-      pattern: /(\b(?:enum|struct)\s+(?:__attribute__\s*\(\([\s\S]*?\)\)\s*)?)\w+|\b[a-z]\w*_t\b/,
-      lookbehind: true
-    },
-    keyword: /\b(?:_Alignas|_Alignof|_Atomic|_Bool|_Complex|_Generic|_Imaginary|_Noreturn|_Static_assert|_Thread_local|__attribute__|asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|inline|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|typeof|union|unsigned|void|volatile|while)\b/,
-    function: /\b[a-z_]\w*(?=\s*\()/i,
-    number: /(?:\b0x(?:[\da-f]+(?:\.[\da-f]*)?|\.[\da-f]+)(?:p[+-]?\d+)?|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)[ful]{0,4}/i,
-    operator: />>=?|<<=?|->|([-+&|:])\1|[?:~]|[-+*/%&|^!=<>]=?/
-  });
-  Prism.languages.insertBefore("c", "string", {
-    char: {
-      // https://en.cppreference.com/w/c/language/character_constant
-      pattern: /'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n]){0,32}'/,
-      greedy: true
-    }
-  });
-  Prism.languages.insertBefore("c", "string", {
-    macro: {
-      // allow for multiline macro definitions
-      // spaces after the # character compile fine with gcc
-      pattern: /(^[\t ]*)#\s*[a-z](?:[^\r\n\\/]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|\\(?:\r\n|[\s\S]))*/im,
-      lookbehind: true,
-      greedy: true,
-      alias: "property",
-      inside: {
-        string: [
-          {
-            // highlight the path of the include statement as a string
-            pattern: /^(#\s*include\s*)<[^>]+>/,
-            lookbehind: true
-          },
-          Prism.languages.c["string"]
-        ],
-        char: Prism.languages.c["char"],
-        comment: Prism.languages.c["comment"],
-        "macro-name": [
-          {
-            pattern: /(^#\s*define\s+)\w+\b(?!\()/i,
-            lookbehind: true
-          },
-          {
-            pattern: /(^#\s*define\s+)\w+\b(?=\()/i,
-            lookbehind: true,
-            alias: "function"
-          }
-        ],
-        // highlight macro directives as keywords
-        directive: {
-          pattern: /^(#\s*)[a-z]+/,
-          lookbehind: true,
-          alias: "keyword"
-        },
-        "directive-hash": /^#/,
-        punctuation: /##|\\(?=[\r\n])/,
-        expression: {
-          pattern: /\S[\s\S]*/,
-          inside: Prism.languages.c
-        }
-      }
-    }
-  });
-  Prism.languages.insertBefore("c", "function", {
-    // highlight predefined macros as constants
-    constant: /\b(?:EOF|NULL|SEEK_CUR|SEEK_END|SEEK_SET|__DATE__|__FILE__|__LINE__|__TIMESTAMP__|__TIME__|__func__|stderr|stdin|stdout)\b/
-  });
-  delete Prism.languages.c["boolean"];
-}
-
-export {
-  c
-};

package/dist/chunk-PHEYXK6C.mjs

@@ -1,33 +0,0 @@
-import {
-  c
-} from "./chunk-PEEMT7UZ.mjs";
-
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/hlsl.js
-hlsl.displayName = "hlsl";
-hlsl.aliases = [];
-function hlsl(Prism) {
-  Prism.register(c);
-  Prism.languages.hlsl = Prism.languages.extend("c", {
-    // Regarding keywords and class names:
-    // The list of all keywords was split into 'keyword' and 'class-name' tokens based on whether they are capitalized.
-    // https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-appendix-keywords
-    // https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-appendix-reserved-words
-    "class-name": [
-      Prism.languages.c["class-name"],
-      /\b(?:AppendStructuredBuffer|BlendState|Buffer|ByteAddressBuffer|CompileShader|ComputeShader|ConsumeStructuredBuffer|DepthStencilState|DepthStencilView|DomainShader|GeometryShader|Hullshader|InputPatch|LineStream|OutputPatch|PixelShader|PointStream|RWBuffer|RWByteAddressBuffer|RWStructuredBuffer|RWTexture(?:1D|1DArray|2D|2DArray|3D)|RasterizerState|RenderTargetView|SamplerComparisonState|SamplerState|StructuredBuffer|Texture(?:1D|1DArray|2D|2DArray|2DMS|2DMSArray|3D|Cube|CubeArray)|TriangleStream|VertexShader)\b/
-    ],
-    keyword: [
-      // HLSL keyword
-      /\b(?:asm|asm_fragment|auto|break|case|catch|cbuffer|centroid|char|class|column_major|compile|compile_fragment|const|const_cast|continue|default|delete|discard|do|dynamic_cast|else|enum|explicit|export|extern|for|friend|fxgroup|goto|groupshared|if|in|inline|inout|interface|line|lineadj|linear|long|matrix|mutable|namespace|new|nointerpolation|noperspective|operator|out|packoffset|pass|pixelfragment|point|precise|private|protected|public|register|reinterpret_cast|return|row_major|sample|sampler|shared|short|signed|sizeof|snorm|stateblock|stateblock_state|static|static_cast|string|struct|switch|tbuffer|technique|technique10|technique11|template|texture|this|throw|triangle|triangleadj|try|typedef|typename|uniform|union|unorm|unsigned|using|vector|vertexfragment|virtual|void|volatile|while)\b/,
-      // scalar, vector, and matrix types
-      /\b(?:bool|double|dword|float|half|int|min(?:10float|12int|16(?:float|int|uint))|uint)(?:[1-4](?:x[1-4])?)?\b/
-    ],
-    // https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-appendix-grammar#floating-point-numbers
-    number: /(?:(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[eE][+-]?\d+)?|\b0x[\da-fA-F]+)[fFhHlLuU]?\b/,
-    boolean: /\b(?:false|true)\b/
-  });
-}
-
-export {
-  hlsl
-};

package/dist/chunk-PHGB2ZNF.mjs

@@ -1,22 +0,0 @@
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/matlab.js
-matlab.displayName = "matlab";
-matlab.aliases = [];
-function matlab(Prism) {
-  Prism.languages.matlab = {
-    comment: [/%\{[\s\S]*?\}%/, /%.+/],
-    string: {
-      pattern: /\B'(?:''|[^'\r\n])*'/,
-      greedy: true
-    },
-    // FIXME We could handle imaginary numbers as a whole
-    number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[eE][+-]?\d+)?(?:[ij])?|\b[ij]\b/,
-    keyword: /\b(?:NaN|break|case|catch|continue|else|elseif|end|for|function|if|inf|otherwise|parfor|pause|pi|return|switch|try|while)\b/,
-    function: /\b(?!\d)\w+(?=\s*\()/,
-    operator: /\.?[*^\/\\']|[+\-:@]|[<>=~]=?|&&?|\|\|?/,
-    punctuation: /\.{3}|[.,;\[\](){}!]/
-  };
-}
-
-export {
-  matlab
-};

package/dist/chunk-PLN33YHN.mjs

@@ -1,152 +0,0 @@
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/icu-message-format.js
-icuMessageFormat.displayName = "icu-message-format";
-icuMessageFormat.aliases = [];
-function icuMessageFormat(Prism) {
-  ;
-  (function(Prism2) {
-    function nested(source, level) {
-      if (level <= 0) {
-        return /[]/.source;
-      } else {
-        return source.replace(/<SELF>/g, function() {
-          return nested(source, level - 1);
-        });
-      }
-    }
-    var stringPattern = /'[{}:=,](?:[^']|'')*'(?!')/;
-    var escape = {
-      pattern: /''/,
-      greedy: true,
-      alias: "operator"
-    };
-    var string = {
-      pattern: stringPattern,
-      greedy: true,
-      inside: {
-        escape
-      }
-    };
-    var argumentSource = nested(
-      /\{(?:[^{}']|'(?![{},'])|''|<STR>|<SELF>)*\}/.source.replace(
-        /<STR>/g,
-        function() {
-          return stringPattern.source;
-        }
-      ),
-      8
-    );
-    var nestedMessage = {
-      pattern: RegExp(argumentSource),
-      inside: {
-        message: {
-          pattern: /^(\{)[\s\S]+(?=\}$)/,
-          lookbehind: true,
-          inside: null
-          // see below
-        },
-        "message-delimiter": {
-          pattern: /./,
-          alias: "punctuation"
-        }
-      }
-    };
-    Prism2.languages["icu-message-format"] = {
-      argument: {
-        pattern: RegExp(argumentSource),
-        greedy: true,
-        inside: {
-          content: {
-            pattern: /^(\{)[\s\S]+(?=\}$)/,
-            lookbehind: true,
-            inside: {
-              "argument-name": {
-                pattern: /^(\s*)[^{}:=,\s]+/,
-                lookbehind: true
-              },
-              "choice-style": {
-                // https://unicode-org.github.io/icu-docs/apidoc/released/icu4c/classicu_1_1ChoiceFormat.html#details
-                pattern: /^(\s*,\s*choice\s*,\s*)\S(?:[\s\S]*\S)?/,
-                lookbehind: true,
-                inside: {
-                  punctuation: /\|/,
-                  range: {
-                    pattern: /^(\s*)[+-]?(?:\d+(?:\.\d*)?|\u221e)\s*[<#\u2264]/,
-                    lookbehind: true,
-                    inside: {
-                      operator: /[<#\u2264]/,
-                      number: /\S+/
-                    }
-                  },
-                  rest: null
-                  // see below
-                }
-              },
-              "plural-style": {
-                // https://unicode-org.github.io/icu-docs/apidoc/released/icu4j/com/ibm/icu/text/PluralFormat.html#:~:text=Patterns%20and%20Their%20Interpretation
-                pattern: /^(\s*,\s*(?:plural|selectordinal)\s*,\s*)\S(?:[\s\S]*\S)?/,
-                lookbehind: true,
-                inside: {
-                  offset: /^offset:\s*\d+/,
-                  "nested-message": nestedMessage,
-                  selector: {
-                    pattern: /=\d+|[^{}:=,\s]+/,
-                    inside: {
-                      keyword: /^(?:few|many|one|other|two|zero)$/
-                    }
-                  }
-                }
-              },
-              "select-style": {
-                // https://unicode-org.github.io/icu-docs/apidoc/released/icu4j/com/ibm/icu/text/SelectFormat.html#:~:text=Patterns%20and%20Their%20Interpretation
-                pattern: /^(\s*,\s*select\s*,\s*)\S(?:[\s\S]*\S)?/,
-                lookbehind: true,
-                inside: {
-                  "nested-message": nestedMessage,
-                  selector: {
-                    pattern: /[^{}:=,\s]+/,
-                    inside: {
-                      keyword: /^other$/
-                    }
-                  }
-                }
-              },
-              keyword: /\b(?:choice|plural|select|selectordinal)\b/,
-              "arg-type": {
-                pattern: /\b(?:date|duration|number|ordinal|spellout|time)\b/,
-                alias: "keyword"
-              },
-              "arg-skeleton": {
-                pattern: /(,\s*)::[^{}:=,\s]+/,
-                lookbehind: true
-              },
-              "arg-style": {
-                pattern: /(,\s*)(?:currency|full|integer|long|medium|percent|short)(?=\s*$)/,
-                lookbehind: true
-              },
-              "arg-style-text": {
-                pattern: RegExp(
-                  /(^\s*,\s*(?=\S))/.source + nested(/(?:[^{}']|'[^']*'|\{(?:<SELF>)?\})+/.source, 8) + "$"
-                ),
-                lookbehind: true,
-                alias: "string"
-              },
-              punctuation: /,/
-            }
-          },
-          "argument-delimiter": {
-            pattern: /./,
-            alias: "operator"
-          }
-        }
-      },
-      escape,
-      string
-    };
-    nestedMessage.inside.message.inside = Prism2.languages["icu-message-format"];
-    Prism2.languages["icu-message-format"].argument.inside.content.inside["choice-style"].inside.rest = Prism2.languages["icu-message-format"];
-  })(Prism);
-}
-
-export {
-  icuMessageFormat
-};

package/dist/chunk-PMIBB7TT.mjs

@@ -1,35 +0,0 @@
-import {
-  clike
-} from "./chunk-XWTEQUC3.mjs";
-
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/birb.js
-birb.displayName = "birb";
-birb.aliases = [];
-function birb(Prism) {
-  Prism.register(clike);
-  Prism.languages.birb = Prism.languages.extend("clike", {
-    string: {
-      pattern: /r?("|')(?:\\.|(?!\1)[^\\])*\1/,
-      greedy: true
-    },
-    "class-name": [
-      /\b[A-Z](?:[\d_]*[a-zA-Z]\w*)?\b/,
-      // matches variable and function return types (parameters as well).
-      /\b(?:[A-Z]\w*|(?!(?:var|void)\b)[a-z]\w*)(?=\s+\w+\s*[;,=()])/
-    ],
-    keyword: /\b(?:assert|break|case|class|const|default|else|enum|final|follows|for|grab|if|nest|new|next|noSeeb|return|static|switch|throw|var|void|while)\b/,
-    operator: /\+\+|--|&&|\|\||<<=?|>>=?|~(?:\/=?)?|[+\-*\/%&^|=!<>]=?|\?|:/,
-    variable: /\b[a-z_]\w*\b/
-  });
-  Prism.languages.insertBefore("birb", "function", {
-    metadata: {
-      pattern: /<\w+>/,
-      greedy: true,
-      alias: "symbol"
-    }
-  });
-}
-
-export {
-  birb
-};

package/dist/chunk-PO3KWA2T.mjs

@@ -1,44 +0,0 @@
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/julia.js
-julia.displayName = "julia";
-julia.aliases = [];
-function julia(Prism) {
-  Prism.languages.julia = {
-    comment: {
-      // support one level of nested comments
-      // https://github.com/JuliaLang/julia/pull/6128
-      pattern: /(^|[^\\])(?:#=(?:[^#=]|=(?!#)|#(?!=)|#=(?:[^#=]|=(?!#)|#(?!=))*=#)*=#|#.*)/,
-      lookbehind: true
-    },
-    regex: {
-      // https://docs.julialang.org/en/v1/manual/strings/#Regular-Expressions-1
-      pattern: /r"(?:\\.|[^"\\\r\n])*"[imsx]{0,4}/,
-      greedy: true
-    },
-    string: {
-      // https://docs.julialang.org/en/v1/manual/strings/#String-Basics-1
-      // https://docs.julialang.org/en/v1/manual/strings/#non-standard-string-literals-1
-      // https://docs.julialang.org/en/v1/manual/running-external-programs/#Running-External-Programs-1
-      pattern: /"""[\s\S]+?"""|(?:\b\w+)?"(?:\\.|[^"\\\r\n])*"|`(?:[^\\`\r\n]|\\.)*`/,
-      greedy: true
-    },
-    char: {
-      // https://docs.julialang.org/en/v1/manual/strings/#man-characters-1
-      pattern: /(^|[^\w'])'(?:\\[^\r\n][^'\r\n]*|[^\\\r\n])'/,
-      lookbehind: true,
-      greedy: true
-    },
-    keyword: /\b(?:abstract|baremodule|begin|bitstype|break|catch|ccall|const|continue|do|else|elseif|end|export|finally|for|function|global|if|immutable|import|importall|in|let|local|macro|module|print|println|quote|return|struct|try|type|typealias|using|while)\b/,
-    boolean: /\b(?:false|true)\b/,
-    number: /(?:\b(?=\d)|\B(?=\.))(?:0[box])?(?:[\da-f]+(?:_[\da-f]+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[efp][+-]?\d+(?:_\d+)*)?j?/i,
-    // https://docs.julialang.org/en/v1/manual/mathematical-operations/
-    // https://docs.julialang.org/en/v1/manual/mathematical-operations/#Operator-Precedence-and-Associativity-1
-    operator: /&&|\|\||[-+*^%÷⊻&$\\]=?|\/[\/=]?|!=?=?|\|[=>]?|<(?:<=?|[=:|])?|>(?:=|>>?=?)?|==?=?|[~≠≤≥'√∛]/,
-    punctuation: /::?|[{}[\]();,.?]/,
-    // https://docs.julialang.org/en/v1/base/numbers/#Base.im
-    constant: /\b(?:(?:Inf|NaN)(?:16|32|64)?|im|pi)\b|[πℯ]/
-  };
-}
-
-export {
-  julia
-};

package/dist/chunk-PYP5HL6B.mjs

@@ -1,52 +0,0 @@
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/keyman.js
-keyman.displayName = "keyman";
-keyman.aliases = [];
-function keyman(Prism) {
-  Prism.languages.keyman = {
-    comment: {
-      pattern: /\bc .*/i,
-      greedy: true
-    },
-    string: {
-      pattern: /"[^"\r\n]*"|'[^'\r\n]*'/,
-      greedy: true
-    },
-    "virtual-key": {
-      pattern: /\[\s*(?:(?:ALT|CAPS|CTRL|LALT|LCTRL|NCAPS|RALT|RCTRL|SHIFT)\s+)*(?:[TKU]_[\w?]+|[A-E]\d\d?|"[^"\r\n]*"|'[^'\r\n]*')\s*\]/i,
-      greedy: true,
-      alias: "function"
-      // alias for styles
-    },
-    // https://help.keyman.com/developer/language/guide/headers
-    "header-keyword": {
-      pattern: /&\w+/,
-      alias: "bold"
-      // alias for styles
-    },
-    "header-statement": {
-      pattern: /\b(?:bitmap|bitmaps|caps always off|caps on only|copyright|hotkey|language|layout|message|name|shift frees caps|version)\b/i,
-      alias: "bold"
-      // alias for styles
-    },
-    "rule-keyword": {
-      pattern: /\b(?:any|baselayout|beep|call|context|deadkey|dk|if|index|layer|notany|nul|outs|platform|reset|return|save|set|store|use)\b/i,
-      alias: "keyword"
-    },
-    "structural-keyword": {
-      pattern: /\b(?:ansi|begin|group|match|newcontext|nomatch|postkeystroke|readonly|unicode|using keys)\b/i,
-      alias: "keyword"
-    },
-    "compile-target": {
-      pattern: /\$(?:keyman|keymanonly|keymanweb|kmfl|weaver):/i,
-      alias: "property"
-    },
-    // U+####, x###, d### characters and numbers
-    number: /\b(?:U\+[\dA-F]+|d\d+|x[\da-f]+|\d+)\b/i,
-    operator: /[+>\\$]|\.\./,
-    punctuation: /[()=,]/
-  };
-}
-
-export {
-  keyman
-};

package/dist/chunk-QD5GH24P.mjs

@@ -1,130 +0,0 @@
-import {
-  markup
-} from "./chunk-ACDTS7FW.mjs";
-
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/xeora.js
-xeora.displayName = "xeora";
-xeora.aliases = ["xeoracube"];
-function xeora(Prism) {
-  Prism.register(markup);
-  (function(Prism2) {
-    Prism2.languages.xeora = Prism2.languages.extend("markup", {
-      constant: {
-        pattern: /\$(?:DomainContents|PageRenderDuration)\$/,
-        inside: {
-          punctuation: {
-            pattern: /\$/
-          }
-        }
-      },
-      variable: {
-        pattern: /\$@?(?:#+|[-+*~=^])?[\w.]+\$/,
-        inside: {
-          punctuation: {
-            pattern: /[$.]/
-          },
-          operator: {
-            pattern: /#+|[-+*~=^@]/
-          }
-        }
-      },
-      "function-inline": {
-        pattern: /\$F:[-\w.]+\?[-\w.]+(?:,(?:(?:@[-#]*\w+\.[\w+.]\.*)*\|)*(?:(?:[\w+]|[-#*.~^]+[\w+]|=\S)(?:[^$=]|=+[^=])*=*|(?:@[-#]*\w+\.[\w+.]\.*)+(?:(?:[\w+]|[-#*~^][-#*.~^]*[\w+]|=\S)(?:[^$=]|=+[^=])*=*)?)?)?\$/,
-        inside: {
-          variable: {
-            pattern: /(?:[,|])@?(?:#+|[-+*~=^])?[\w.]+/,
-            inside: {
-              punctuation: {
-                pattern: /[,.|]/
-              },
-              operator: {
-                pattern: /#+|[-+*~=^@]/
-              }
-            }
-          },
-          punctuation: {
-            pattern: /\$\w:|[$:?.,|]/
-          }
-        },
-        alias: "function"
-      },
-      "function-block": {
-        pattern: /\$XF:\{[-\w.]+\?[-\w.]+(?:,(?:(?:@[-#]*\w+\.[\w+.]\.*)*\|)*(?:(?:[\w+]|[-#*.~^]+[\w+]|=\S)(?:[^$=]|=+[^=])*=*|(?:@[-#]*\w+\.[\w+.]\.*)+(?:(?:[\w+]|[-#*~^][-#*.~^]*[\w+]|=\S)(?:[^$=]|=+[^=])*=*)?)?)?\}:XF\$/,
-        inside: {
-          punctuation: {
-            pattern: /[$:{}?.,|]/
-          }
-        },
-        alias: "function"
-      },
-      "directive-inline": {
-        pattern: /\$\w(?:#\d+\+?)?(?:\[[-\w.]+\])?:[-\/\w.]+\$/,
-        inside: {
-          punctuation: {
-            pattern: /\$(?:\w:|C(?:\[|#\d))?|[:{[\]]/,
-            inside: {
-              tag: {
-                pattern: /#\d/
-              }
-            }
-          }
-        },
-        alias: "function"
-      },
-      "directive-block-open": {
-        pattern: /\$\w+:\{|\$\w(?:#\d+\+?)?(?:\[[-\w.]+\])?:[-\w.]+:\{(?:![A-Z]+)?/,
-        inside: {
-          punctuation: {
-            pattern: /\$(?:\w:|C(?:\[|#\d))?|[:{[\]]/,
-            inside: {
-              tag: {
-                pattern: /#\d/
-              }
-            }
-          },
-          attribute: {
-            pattern: /![A-Z]+$/,
-            inside: {
-              punctuation: {
-                pattern: /!/
-              }
-            },
-            alias: "keyword"
-          }
-        },
-        alias: "function"
-      },
-      "directive-block-separator": {
-        pattern: /\}:[-\w.]+:\{/,
-        inside: {
-          punctuation: {
-            pattern: /[:{}]/
-          }
-        },
-        alias: "function"
-      },
-      "directive-block-close": {
-        pattern: /\}:[-\w.]+\$/,
-        inside: {
-          punctuation: {
-            pattern: /[:{}$]/
-          }
-        },
-        alias: "function"
-      }
-    });
-    Prism2.languages.insertBefore(
-      "inside",
-      "punctuation",
-      {
-        variable: Prism2.languages.xeora["function-inline"].inside["variable"]
-      },
-      Prism2.languages.xeora["function-block"]
-    );
-    Prism2.languages.xeoracube = Prism2.languages.xeora;
-  })(Prism);
-}
-
-export {
-  xeora
-};