@photonix/basic 1.5.1 → 1.6.1

package/dist/chunk-P7GNDSPG.mjs

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

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

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

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

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

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

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

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

@@ -0,0 +1,130 @@
+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
+};