@fluidattacks/design 8.0.0 → 8.2.0

package/dist/node_modules/refractor/lang/kotlin.js

@@ -0,0 +1,83 @@
+import i from "./clike.js";
+a.displayName = "kotlin";
+a.aliases = ["kt", "kts"];
+function a(n) {
+  n.register(i), (function(e) {
+    e.languages.kotlin = e.languages.extend("clike", {
+      keyword: {
+        // The lookbehind prevents wrong highlighting of e.g. kotlin.properties.get
+        pattern: /(^|[^.])\b(?:abstract|actual|annotation|as|break|by|catch|class|companion|const|constructor|continue|crossinline|data|do|dynamic|else|enum|expect|external|final|finally|for|fun|get|if|import|in|infix|init|inline|inner|interface|internal|is|lateinit|noinline|null|object|open|operator|out|override|package|private|protected|public|reified|return|sealed|set|super|suspend|tailrec|this|throw|to|try|typealias|val|var|vararg|when|where|while)\b/,
+        lookbehind: !0
+      },
+      function: [
+        {
+          pattern: /(?:`[^\r\n`]+`|\b\w+)(?=\s*\()/,
+          greedy: !0
+        },
+        {
+          pattern: /(\.)(?:`[^\r\n`]+`|\w+)(?=\s*\{)/,
+          lookbehind: !0,
+          greedy: !0
+        }
+      ],
+      number: /\b(?:0[xX][\da-fA-F]+(?:_[\da-fA-F]+)*|0[bB][01]+(?:_[01]+)*|\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?(?:[eE][+-]?\d+(?:_\d+)*)?[fFL]?)\b/,
+      operator: /\+[+=]?|-[-=>]?|==?=?|!(?:!|==?)?|[\/*%<>]=?|[?:]:?|\.\.|&&|\|\||\b(?:and|inv|or|shl|shr|ushr|xor)\b/
+    }), delete e.languages.kotlin["class-name"];
+    var t = {
+      "interpolation-punctuation": {
+        pattern: /^\$\{?|\}$/,
+        alias: "punctuation"
+      },
+      expression: {
+        pattern: /[\s\S]+/,
+        inside: e.languages.kotlin
+      }
+    };
+    e.languages.insertBefore("kotlin", "string", {
+      // https://kotlinlang.org/spec/expressions.html#string-interpolation-expressions
+      "string-literal": [
+        {
+          pattern: /"""(?:[^$]|\$(?:(?!\{)|\{[^{}]*\}))*?"""/,
+          alias: "multiline",
+          inside: {
+            interpolation: {
+              pattern: /\$(?:[a-z_]\w*|\{[^{}]*\})/i,
+              inside: t
+            },
+            string: /[\s\S]+/
+          }
+        },
+        {
+          pattern: /"(?:[^"\\\r\n$]|\\.|\$(?:(?!\{)|\{[^{}]*\}))*"/,
+          alias: "singleline",
+          inside: {
+            interpolation: {
+              pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:[a-z_]\w*|\{[^{}]*\})/i,
+              lookbehind: !0,
+              inside: t
+            },
+            string: /[\s\S]+/
+          }
+        }
+      ],
+      char: {
+        // https://kotlinlang.org/spec/expressions.html#character-literals
+        pattern: /'(?:[^'\\\r\n]|\\(?:.|u[a-fA-F0-9]{0,4}))'/,
+        greedy: !0
+      }
+    }), delete e.languages.kotlin.string, e.languages.insertBefore("kotlin", "keyword", {
+      annotation: {
+        pattern: /\B@(?:\w+:)?(?:[A-Z]\w*|\[[^\]]+\])/,
+        alias: "builtin"
+      }
+    }), e.languages.insertBefore("kotlin", "function", {
+      label: {
+        pattern: /\b\w+@|@\w+\b/,
+        alias: "symbol"
+      }
+    }), e.languages.kt = e.languages.kotlin, e.languages.kts = e.languages.kotlin;
+  })(n);
+}
+export {
+  a as default
+};

package/dist/node_modules/refractor/lang/markup-templating.js

@@ -0,0 +1,74 @@
+import S from "./markup.js";
+_.displayName = "markup-templating";
+_.aliases = [];
+function _(g) {
+  g.register(S), (function(e) {
+    function s(a, r) {
+      return "___" + a.toUpperCase() + r + "___";
+    }
+    Object.defineProperties(e.languages["markup-templating"] = {}, {
+      buildPlaceholders: {
+        /**
+         * Tokenize all inline templating expressions matching `placeholderPattern`.
+         *
+         * If `replaceFilter` is provided, only matches of `placeholderPattern` for which `replaceFilter` returns
+         * `true` will be replaced.
+         *
+         * @param {object} env The environment of the `before-tokenize` hook.
+         * @param {string} language The language id.
+         * @param {RegExp} placeholderPattern The matches of this pattern will be replaced by placeholders.
+         * @param {(match: string) => boolean} [replaceFilter]
+         */
+        value: function(a, r, f, p) {
+          if (a.language === r) {
+            var u = a.tokenStack = [];
+            a.code = a.code.replace(f, function(n) {
+              if (typeof p == "function" && !p(n))
+                return n;
+              for (var i = u.length, t; a.code.indexOf(t = s(r, i)) !== -1; )
+                ++i;
+              return u[i] = n, t;
+            }), a.grammar = e.languages.markup;
+          }
+        }
+      },
+      tokenizePlaceholders: {
+        /**
+         * Replace placeholders with proper tokens after tokenizing.
+         *
+         * @param {object} env The environment of the `after-tokenize` hook.
+         * @param {string} language The language id.
+         */
+        value: function(a, r) {
+          if (a.language !== r || !a.tokenStack)
+            return;
+          a.grammar = e.languages[r];
+          var f = 0, p = Object.keys(a.tokenStack);
+          function u(n) {
+            for (var i = 0; i < n.length && !(f >= p.length); i++) {
+              var t = n[i];
+              if (typeof t == "string" || t.content && typeof t.content == "string") {
+                var y = p[f], d = a.tokenStack[y], c = typeof t == "string" ? t : t.content, k = s(r, y), l = c.indexOf(k);
+                if (l > -1) {
+                  ++f;
+                  var h = c.substring(0, l), b = new e.Token(
+                    r,
+                    e.tokenize(d, a.grammar),
+                    "language-" + r,
+                    d
+                  ), v = c.substring(l + k.length), o = [];
+                  h && o.push.apply(o, u([h])), o.push(b), v && o.push.apply(o, u([v])), typeof t == "string" ? n.splice.apply(n, [i, 1].concat(o)) : t.content = o;
+                }
+              } else t.content && u(t.content);
+            }
+            return n;
+          }
+          u(a.tokens);
+        }
+      }
+    });
+  })(g);
+}
+export {
+  _ as default
+};

package/dist/node_modules/refractor/lang/markup.js

@@ -0,0 +1,174 @@
+l.displayName = "markup";
+l.aliases = ["atom", "html", "mathml", "rss", "ssml", "svg", "xml"];
+function l(e) {
+  e.languages.markup = {
+    comment: {
+      pattern: /<!--(?:(?!<!--)[\s\S])*?-->/,
+      greedy: !0
+    },
+    prolog: {
+      pattern: /<\?[\s\S]+?\?>/,
+      greedy: !0
+    },
+    doctype: {
+      // https://www.w3.org/TR/xml/#NT-doctypedecl
+      pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
+      greedy: !0,
+      inside: {
+        "internal-subset": {
+          pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/,
+          lookbehind: !0,
+          greedy: !0,
+          inside: null
+          // see below
+        },
+        string: {
+          pattern: /"[^"]*"|'[^']*'/,
+          greedy: !0
+        },
+        punctuation: /^<!|>$|[[\]]/,
+        "doctype-tag": /^DOCTYPE/i,
+        name: /[^\s<>'"]+/
+      }
+    },
+    cdata: {
+      pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+      greedy: !0
+    },
+    tag: {
+      pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
+      greedy: !0,
+      inside: {
+        tag: {
+          pattern: /^<\/?[^\s>\/]+/,
+          inside: {
+            punctuation: /^<\/?/,
+            namespace: /^[^\s>\/:]+:/
+          }
+        },
+        "special-attr": [],
+        "attr-value": {
+          pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
+          inside: {
+            punctuation: [
+              {
+                pattern: /^=/,
+                alias: "attr-equals"
+              },
+              {
+                pattern: /^(\s*)["']|["']$/,
+                lookbehind: !0
+              }
+            ]
+          }
+        },
+        punctuation: /\/?>/,
+        "attr-name": {
+          pattern: /[^\s>\/]+/,
+          inside: {
+            namespace: /^[^\s>\/:]+:/
+          }
+        }
+      }
+    },
+    entity: [
+      {
+        pattern: /&[\da-z]{1,8};/i,
+        alias: "named-entity"
+      },
+      /&#x?[\da-f]{1,8};/i
+    ]
+  }, e.languages.markup.tag.inside["attr-value"].inside.entity = e.languages.markup.entity, e.languages.markup.doctype.inside["internal-subset"].inside = e.languages.markup, e.hooks.add("wrap", function(a) {
+    a.type === "entity" && (a.attributes.title = a.content.value.replace(/&amp;/, "&"));
+  }), Object.defineProperty(e.languages.markup.tag, "addInlined", {
+    /**
+     * Adds an inlined language to markup.
+     *
+     * An example of an inlined language is CSS with `<style>` tags.
+     *
+     * @param {string} tagName The name of the tag that contains the inlined language. This name will be treated as
+     * case insensitive.
+     * @param {string} lang The language key.
+     * @example
+     * addInlined('style', 'css');
+     */
+    value: function(t, n) {
+      var u = {};
+      u["language-" + n] = {
+        pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
+        lookbehind: !0,
+        inside: e.languages[n]
+      }, u.cdata = /^<!\[CDATA\[|\]\]>$/i;
+      var s = {
+        "included-cdata": {
+          pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+          inside: u
+        }
+      };
+      s["language-" + n] = {
+        pattern: /[\s\S]+/,
+        inside: e.languages[n]
+      };
+      var g = {};
+      g[t] = {
+        pattern: RegExp(
+          /(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(
+            /__/g,
+            function() {
+              return t;
+            }
+          ),
+          "i"
+        ),
+        lookbehind: !0,
+        greedy: !0,
+        inside: s
+      }, e.languages.insertBefore("markup", "cdata", g);
+    }
+  }), Object.defineProperty(e.languages.markup.tag, "addAttribute", {
+    /**
+     * Adds an pattern to highlight languages embedded in HTML attributes.
+     *
+     * An example of an inlined language is CSS with `style` attributes.
+     *
+     * @param {string} attrName The name of the tag that contains the inlined language. This name will be treated as
+     * case insensitive.
+     * @param {string} lang The language key.
+     * @example
+     * addAttribute('style', 'css');
+     */
+    value: function(a, t) {
+      e.languages.markup.tag.inside["special-attr"].push({
+        pattern: RegExp(
+          /(^|["'\s])/.source + "(?:" + a + ")" + /\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))/.source,
+          "i"
+        ),
+        lookbehind: !0,
+        inside: {
+          "attr-name": /^[^\s=]+/,
+          "attr-value": {
+            pattern: /=[\s\S]+/,
+            inside: {
+              value: {
+                pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
+                lookbehind: !0,
+                alias: [t, "language-" + t],
+                inside: e.languages[t]
+              },
+              punctuation: [
+                {
+                  pattern: /^=/,
+                  alias: "attr-equals"
+                },
+                /"|'/
+              ]
+            }
+          }
+        }
+      });
+    }
+  }), e.languages.html = e.languages.markup, e.languages.mathml = e.languages.markup, e.languages.svg = e.languages.markup, e.languages.xml = e.languages.extend("markup", {}), e.languages.ssml = e.languages.xml, e.languages.atom = e.languages.xml, e.languages.rss = e.languages.xml;
+}
+export {
+  l as default
+};

package/dist/node_modules/refractor/lang/php.js

@@ -0,0 +1,328 @@
+import p from "./markup-templating.js";
+d.displayName = "php";
+d.aliases = [];
+function d(a) {
+  a.register(p), (function(e) {
+    var n = /\/\*[\s\S]*?\*\/|\/\/.*|#(?!\[).*/, i = [
+      {
+        pattern: /\b(?:false|true)\b/i,
+        alias: "boolean"
+      },
+      {
+        pattern: /(::\s*)\b[a-z_]\w*\b(?!\s*\()/i,
+        greedy: !0,
+        lookbehind: !0
+      },
+      {
+        pattern: /(\b(?:case|const)\s+)\b[a-z_]\w*(?=\s*[;=])/i,
+        greedy: !0,
+        lookbehind: !0
+      },
+      /\b(?:null)\b/i,
+      /\b[A-Z_][A-Z0-9_]*\b(?!\s*\()/
+    ], r = /\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, s = /<?=>|\?\?=?|\.{3}|\??->|[!=]=?=?|::|\*\*=?|--|\+\+|&&|\|\||<<|>>|[?~]|[/^|%*&<>.+-]=?/, l = /[{}\[\](),:;]/;
+    e.languages.php = {
+      delimiter: {
+        pattern: /\?>$|^<\?(?:php(?=\s)|=)?/i,
+        alias: "important"
+      },
+      comment: n,
+      variable: /\$+(?:\w+\b|(?=\{))/,
+      package: {
+        pattern: /(namespace\s+|use\s+(?:function\s+)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
+        lookbehind: !0,
+        inside: {
+          punctuation: /\\/
+        }
+      },
+      "class-name-definition": {
+        pattern: /(\b(?:class|enum|interface|trait)\s+)\b[a-z_]\w*(?!\\)\b/i,
+        lookbehind: !0,
+        alias: "class-name"
+      },
+      "function-definition": {
+        pattern: /(\bfunction\s+)[a-z_]\w*(?=\s*\()/i,
+        lookbehind: !0,
+        alias: "function"
+      },
+      keyword: [
+        {
+          pattern: /(\(\s*)\b(?:array|bool|boolean|float|int|integer|object|string)\b(?=\s*\))/i,
+          alias: "type-casting",
+          greedy: !0,
+          lookbehind: !0
+        },
+        {
+          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: !0,
+          lookbehind: !0
+        },
+        {
+          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: !0,
+          lookbehind: !0
+        },
+        {
+          pattern: /\b(?:array(?!\s*\()|bool|float|int|iterable|mixed|object|string|void)\b/i,
+          alias: "type-declaration",
+          greedy: !0
+        },
+        {
+          pattern: /(\|\s*)(?:false|null)\b|\b(?:false|null)(?=\s*\|)/i,
+          alias: "type-declaration",
+          greedy: !0,
+          lookbehind: !0
+        },
+        {
+          pattern: /\b(?:parent|self|static)(?=\s*::)/i,
+          alias: "static-context",
+          greedy: !0
+        },
+        {
+          // yield from
+          pattern: /(\byield\s+)from\b/i,
+          lookbehind: !0
+        },
+        // `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: !0
+        }
+      ],
+      "argument-name": {
+        pattern: /([(,]\s*)\b[a-z_]\w*(?=\s*:(?!:))/i,
+        lookbehind: !0
+      },
+      "class-name": [
+        {
+          pattern: /(\b(?:extends|implements|instanceof|new(?!\s+self|\s+static))\s+|\bcatch\s*\()\b[a-z_]\w*(?!\\)\b/i,
+          greedy: !0,
+          lookbehind: !0
+        },
+        {
+          pattern: /(\|\s*)\b[a-z_]\w*(?!\\)\b/i,
+          greedy: !0,
+          lookbehind: !0
+        },
+        {
+          pattern: /\b[a-z_]\w*(?!\\)\b(?=\s*\|)/i,
+          greedy: !0
+        },
+        {
+          pattern: /(\|\s*)(?:\\?\b[a-z_]\w*)+\b/i,
+          alias: "class-name-fully-qualified",
+          greedy: !0,
+          lookbehind: !0,
+          inside: {
+            punctuation: /\\/
+          }
+        },
+        {
+          pattern: /(?:\\?\b[a-z_]\w*)+\b(?=\s*\|)/i,
+          alias: "class-name-fully-qualified",
+          greedy: !0,
+          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: !0,
+          lookbehind: !0,
+          inside: {
+            punctuation: /\\/
+          }
+        },
+        {
+          pattern: /\b[a-z_]\w*(?=\s*\$)/i,
+          alias: "type-declaration",
+          greedy: !0
+        },
+        {
+          pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i,
+          alias: ["class-name-fully-qualified", "type-declaration"],
+          greedy: !0,
+          inside: {
+            punctuation: /\\/
+          }
+        },
+        {
+          pattern: /\b[a-z_]\w*(?=\s*::)/i,
+          alias: "static-context",
+          greedy: !0
+        },
+        {
+          pattern: /(?:\\?\b[a-z_]\w*)+(?=\s*::)/i,
+          alias: ["class-name-fully-qualified", "static-context"],
+          greedy: !0,
+          inside: {
+            punctuation: /\\/
+          }
+        },
+        {
+          pattern: /([(,?]\s*)[a-z_]\w*(?=\s*\$)/i,
+          alias: "type-hint",
+          greedy: !0,
+          lookbehind: !0
+        },
+        {
+          pattern: /([(,?]\s*)(?:\\?\b[a-z_]\w*)+(?=\s*\$)/i,
+          alias: ["class-name-fully-qualified", "type-hint"],
+          greedy: !0,
+          lookbehind: !0,
+          inside: {
+            punctuation: /\\/
+          }
+        },
+        {
+          pattern: /(\)\s*:\s*(?:\?\s*)?)\b[a-z_]\w*(?!\\)\b/i,
+          alias: "return-type",
+          greedy: !0,
+          lookbehind: !0
+        },
+        {
+          pattern: /(\)\s*:\s*(?:\?\s*)?)(?:\\?\b[a-z_]\w*)+\b(?!\\)/i,
+          alias: ["class-name-fully-qualified", "return-type"],
+          greedy: !0,
+          lookbehind: !0,
+          inside: {
+            punctuation: /\\/
+          }
+        }
+      ],
+      constant: i,
+      function: {
+        pattern: /(^|[^\\\w])\\?[a-z_](?:[\w\\]*\w)?(?=\s*\()/i,
+        lookbehind: !0,
+        inside: {
+          punctuation: /\\/
+        }
+      },
+      property: {
+        pattern: /(->\s*)\w+/,
+        lookbehind: !0
+      },
+      number: r,
+      operator: s,
+      punctuation: l
+    };
+    var o = {
+      pattern: /\{\$(?:\{(?:\{[^{}]+\}|[^{}]+)\}|[^{}])+\}|(^|[^\\{])\$+(?:\w+(?:\[[^\r\n\[\]]+\]|->\w+)?)/,
+      lookbehind: !0,
+      inside: e.languages.php
+    }, u = [
+      {
+        pattern: /<<<'([^']+)'[\r\n](?:.*[\r\n])*?\1;/,
+        alias: "nowdoc-string",
+        greedy: !0,
+        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: !0,
+        inside: {
+          delimiter: {
+            pattern: /^<<<(?:"[^"]+"|[a-z_]\w*)|[a-z_]\w*;$/i,
+            alias: "symbol",
+            inside: {
+              punctuation: /^<<<"?|[";]$/
+            }
+          },
+          interpolation: o
+        }
+      },
+      {
+        pattern: /`(?:\\[\s\S]|[^\\`])*`/,
+        alias: "backtick-quoted-string",
+        greedy: !0
+      },
+      {
+        pattern: /'(?:\\[\s\S]|[^\\'])*'/,
+        alias: "single-quoted-string",
+        greedy: !0
+      },
+      {
+        pattern: /"(?:\\[\s\S]|[^\\"])*"/,
+        alias: "double-quoted-string",
+        greedy: !0,
+        inside: {
+          interpolation: o
+        }
+      }
+    ];
+    e.languages.insertBefore("php", "variable", {
+      string: u,
+      attribute: {
+        pattern: /#\[(?:[^"'\/#]|\/(?![*/])|\/\/.*$|#(?!\[).*$|\/\*(?:[^*]|\*(?!\/))*\*\/|"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*')+\](?=\s*[a-z$#])/im,
+        greedy: !0,
+        inside: {
+          "attribute-content": {
+            pattern: /^(#\[)[\s\S]+(?=\]$)/,
+            lookbehind: !0,
+            // inside can appear subset of php
+            inside: {
+              comment: n,
+              string: u,
+              "attribute-class-name": [
+                {
+                  pattern: /([^:]|^)\b[a-z_]\w*(?!\\)\b/i,
+                  alias: "class-name",
+                  greedy: !0,
+                  lookbehind: !0
+                },
+                {
+                  pattern: /([^:]|^)(?:\\?\b[a-z_]\w*)+/i,
+                  alias: ["class-name", "class-name-fully-qualified"],
+                  greedy: !0,
+                  lookbehind: !0,
+                  inside: {
+                    punctuation: /\\/
+                  }
+                }
+              ],
+              constant: i,
+              number: r,
+              operator: s,
+              punctuation: l
+            }
+          },
+          delimiter: {
+            pattern: /^#\[|\]$/,
+            alias: "punctuation"
+          }
+        }
+      }
+    }), e.hooks.add("before-tokenize", function(t) {
+      if (/<\?/.test(t.code)) {
+        var b = /<\?(?:[^"'/#]|\/(?![*/])|("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|(?:\/\/|#(?!\[))(?:[^?\n\r]|\?(?!>))*(?=$|\?>|[\r\n])|#\[|\/\*(?:[^*]|\*(?!\/))*(?:\*\/|$))*?(?:\?>|$)/g;
+        e.languages["markup-templating"].buildPlaceholders(
+          t,
+          "php",
+          b
+        );
+      }
+    }), e.hooks.add("after-tokenize", function(t) {
+      e.languages["markup-templating"].tokenizePlaceholders(t, "php");
+    });
+  })(a);
+}
+export {
+  d as default
+};