@kg-ui/kg-ui-plus 0.0.1 → 0.0.3

package/dist/es/node_modules/.pnpm/highlight.js@11.9.0/node_modules/highlight.js/es/languages/php.mjs

@@ -0,0 +1,589 @@
+function php(hljs) {
+  const regex = hljs.regex;
+  const NOT_PERL_ETC = /(?![A-Za-z0-9])(?![$])/;
+  const IDENT_RE = regex.concat(
+    /[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/,
+    NOT_PERL_ETC
+  );
+  const PASCAL_CASE_CLASS_NAME_RE = regex.concat(
+    /(\\?[A-Z][a-z0-9_\x7f-\xff]+|\\?[A-Z]+(?=[A-Z][a-z0-9_\x7f-\xff])){1,}/,
+    NOT_PERL_ETC
+  );
+  const VARIABLE = {
+    scope: "variable",
+    match: "\\$+" + IDENT_RE
+  };
+  const PREPROCESSOR = {
+    scope: "meta",
+    variants: [
+      { begin: /<\?php/, relevance: 10 },
+      // boost for obvious PHP
+      { begin: /<\?=/ },
+      // less relevant per PSR-1 which says not to use short-tags
+      { begin: /<\?/, relevance: 0.1 },
+      { begin: /\?>/ }
+      // end php tag
+    ]
+  };
+  const SUBST = {
+    scope: "subst",
+    variants: [
+      { begin: /\$\w+/ },
+      {
+        begin: /\{\$/,
+        end: /\}/
+      }
+    ]
+  };
+  const SINGLE_QUOTED = hljs.inherit(hljs.APOS_STRING_MODE, { illegal: null });
+  const DOUBLE_QUOTED = hljs.inherit(hljs.QUOTE_STRING_MODE, {
+    illegal: null,
+    contains: hljs.QUOTE_STRING_MODE.contains.concat(SUBST)
+  });
+  const HEREDOC = {
+    begin: /<<<[ \t]*(?:(\w+)|"(\w+)")\n/,
+    end: /[ \t]*(\w+)\b/,
+    contains: hljs.QUOTE_STRING_MODE.contains.concat(SUBST),
+    "on:begin": (m, resp) => {
+      resp.data._beginMatch = m[1] || m[2];
+    },
+    "on:end": (m, resp) => {
+      if (resp.data._beginMatch !== m[1])
+        resp.ignoreMatch();
+    }
+  };
+  const NOWDOC = hljs.END_SAME_AS_BEGIN({
+    begin: /<<<[ \t]*'(\w+)'\n/,
+    end: /[ \t]*(\w+)\b/
+  });
+  const WHITESPACE = "[ 	\n]";
+  const STRING = {
+    scope: "string",
+    variants: [
+      DOUBLE_QUOTED,
+      SINGLE_QUOTED,
+      HEREDOC,
+      NOWDOC
+    ]
+  };
+  const NUMBER = {
+    scope: "number",
+    variants: [
+      { begin: `\\b0[bB][01]+(?:_[01]+)*\\b` },
+      // Binary w/ underscore support
+      { begin: `\\b0[oO][0-7]+(?:_[0-7]+)*\\b` },
+      // Octals w/ underscore support
+      { begin: `\\b0[xX][\\da-fA-F]+(?:_[\\da-fA-F]+)*\\b` },
+      // Hex w/ underscore support
+      // Decimals w/ underscore support, with optional fragments and scientific exponent (e) suffix.
+      { begin: `(?:\\b\\d+(?:_\\d+)*(\\.(?:\\d+(?:_\\d+)*))?|\\B\\.\\d+)(?:[eE][+-]?\\d+)?` }
+    ],
+    relevance: 0
+  };
+  const LITERALS = [
+    "false",
+    "null",
+    "true"
+  ];
+  const KWS = [
+    // Magic constants:
+    // <https://www.php.net/manual/en/language.constants.predefined.php>
+    "__CLASS__",
+    "__DIR__",
+    "__FILE__",
+    "__FUNCTION__",
+    "__COMPILER_HALT_OFFSET__",
+    "__LINE__",
+    "__METHOD__",
+    "__NAMESPACE__",
+    "__TRAIT__",
+    // Function that look like language construct or language construct that look like function:
+    // List of keywords that may not require parenthesis
+    "die",
+    "echo",
+    "exit",
+    "include",
+    "include_once",
+    "print",
+    "require",
+    "require_once",
+    // These are not language construct (function) but operate on the currently-executing function and can access the current symbol table
+    // 'compact extract func_get_arg func_get_args func_num_args get_called_class get_parent_class ' +
+    // Other keywords:
+    // <https://www.php.net/manual/en/reserved.php>
+    // <https://www.php.net/manual/en/language.types.type-juggling.php>
+    "array",
+    "abstract",
+    "and",
+    "as",
+    "binary",
+    "bool",
+    "boolean",
+    "break",
+    "callable",
+    "case",
+    "catch",
+    "class",
+    "clone",
+    "const",
+    "continue",
+    "declare",
+    "default",
+    "do",
+    "double",
+    "else",
+    "elseif",
+    "empty",
+    "enddeclare",
+    "endfor",
+    "endforeach",
+    "endif",
+    "endswitch",
+    "endwhile",
+    "enum",
+    "eval",
+    "extends",
+    "final",
+    "finally",
+    "float",
+    "for",
+    "foreach",
+    "from",
+    "global",
+    "goto",
+    "if",
+    "implements",
+    "instanceof",
+    "insteadof",
+    "int",
+    "integer",
+    "interface",
+    "isset",
+    "iterable",
+    "list",
+    "match|0",
+    "mixed",
+    "new",
+    "never",
+    "object",
+    "or",
+    "private",
+    "protected",
+    "public",
+    "readonly",
+    "real",
+    "return",
+    "string",
+    "switch",
+    "throw",
+    "trait",
+    "try",
+    "unset",
+    "use",
+    "var",
+    "void",
+    "while",
+    "xor",
+    "yield"
+  ];
+  const BUILT_INS = [
+    // Standard PHP library:
+    // <https://www.php.net/manual/en/book.spl.php>
+    "Error|0",
+    "AppendIterator",
+    "ArgumentCountError",
+    "ArithmeticError",
+    "ArrayIterator",
+    "ArrayObject",
+    "AssertionError",
+    "BadFunctionCallException",
+    "BadMethodCallException",
+    "CachingIterator",
+    "CallbackFilterIterator",
+    "CompileError",
+    "Countable",
+    "DirectoryIterator",
+    "DivisionByZeroError",
+    "DomainException",
+    "EmptyIterator",
+    "ErrorException",
+    "Exception",
+    "FilesystemIterator",
+    "FilterIterator",
+    "GlobIterator",
+    "InfiniteIterator",
+    "InvalidArgumentException",
+    "IteratorIterator",
+    "LengthException",
+    "LimitIterator",
+    "LogicException",
+    "MultipleIterator",
+    "NoRewindIterator",
+    "OutOfBoundsException",
+    "OutOfRangeException",
+    "OuterIterator",
+    "OverflowException",
+    "ParentIterator",
+    "ParseError",
+    "RangeException",
+    "RecursiveArrayIterator",
+    "RecursiveCachingIterator",
+    "RecursiveCallbackFilterIterator",
+    "RecursiveDirectoryIterator",
+    "RecursiveFilterIterator",
+    "RecursiveIterator",
+    "RecursiveIteratorIterator",
+    "RecursiveRegexIterator",
+    "RecursiveTreeIterator",
+    "RegexIterator",
+    "RuntimeException",
+    "SeekableIterator",
+    "SplDoublyLinkedList",
+    "SplFileInfo",
+    "SplFileObject",
+    "SplFixedArray",
+    "SplHeap",
+    "SplMaxHeap",
+    "SplMinHeap",
+    "SplObjectStorage",
+    "SplObserver",
+    "SplPriorityQueue",
+    "SplQueue",
+    "SplStack",
+    "SplSubject",
+    "SplTempFileObject",
+    "TypeError",
+    "UnderflowException",
+    "UnexpectedValueException",
+    "UnhandledMatchError",
+    // Reserved interfaces:
+    // <https://www.php.net/manual/en/reserved.interfaces.php>
+    "ArrayAccess",
+    "BackedEnum",
+    "Closure",
+    "Fiber",
+    "Generator",
+    "Iterator",
+    "IteratorAggregate",
+    "Serializable",
+    "Stringable",
+    "Throwable",
+    "Traversable",
+    "UnitEnum",
+    "WeakReference",
+    "WeakMap",
+    // Reserved classes:
+    // <https://www.php.net/manual/en/reserved.classes.php>
+    "Directory",
+    "__PHP_Incomplete_Class",
+    "parent",
+    "php_user_filter",
+    "self",
+    "static",
+    "stdClass"
+  ];
+  const dualCase = (items) => {
+    const result = [];
+    items.forEach((item) => {
+      result.push(item);
+      if (item.toLowerCase() === item) {
+        result.push(item.toUpperCase());
+      } else {
+        result.push(item.toLowerCase());
+      }
+    });
+    return result;
+  };
+  const KEYWORDS = {
+    keyword: KWS,
+    literal: dualCase(LITERALS),
+    built_in: BUILT_INS
+  };
+  const normalizeKeywords = (items) => {
+    return items.map((item) => {
+      return item.replace(/\|\d+$/, "");
+    });
+  };
+  const CONSTRUCTOR_CALL = { variants: [
+    {
+      match: [
+        /new/,
+        regex.concat(WHITESPACE, "+"),
+        // to prevent built ins from being confused as the class constructor call
+        regex.concat("(?!", normalizeKeywords(BUILT_INS).join("\\b|"), "\\b)"),
+        PASCAL_CASE_CLASS_NAME_RE
+      ],
+      scope: {
+        1: "keyword",
+        4: "title.class"
+      }
+    }
+  ] };
+  const CONSTANT_REFERENCE = regex.concat(IDENT_RE, "\\b(?!\\()");
+  const LEFT_AND_RIGHT_SIDE_OF_DOUBLE_COLON = { variants: [
+    {
+      match: [
+        regex.concat(
+          /::/,
+          regex.lookahead(/(?!class\b)/)
+        ),
+        CONSTANT_REFERENCE
+      ],
+      scope: { 2: "variable.constant" }
+    },
+    {
+      match: [
+        /::/,
+        /class/
+      ],
+      scope: { 2: "variable.language" }
+    },
+    {
+      match: [
+        PASCAL_CASE_CLASS_NAME_RE,
+        regex.concat(
+          /::/,
+          regex.lookahead(/(?!class\b)/)
+        ),
+        CONSTANT_REFERENCE
+      ],
+      scope: {
+        1: "title.class",
+        3: "variable.constant"
+      }
+    },
+    {
+      match: [
+        PASCAL_CASE_CLASS_NAME_RE,
+        regex.concat(
+          "::",
+          regex.lookahead(/(?!class\b)/)
+        )
+      ],
+      scope: { 1: "title.class" }
+    },
+    {
+      match: [
+        PASCAL_CASE_CLASS_NAME_RE,
+        /::/,
+        /class/
+      ],
+      scope: {
+        1: "title.class",
+        3: "variable.language"
+      }
+    }
+  ] };
+  const NAMED_ARGUMENT = {
+    scope: "attr",
+    match: regex.concat(IDENT_RE, regex.lookahead(":"), regex.lookahead(/(?!::)/))
+  };
+  const PARAMS_MODE = {
+    relevance: 0,
+    begin: /\(/,
+    end: /\)/,
+    keywords: KEYWORDS,
+    contains: [
+      NAMED_ARGUMENT,
+      VARIABLE,
+      LEFT_AND_RIGHT_SIDE_OF_DOUBLE_COLON,
+      hljs.C_BLOCK_COMMENT_MODE,
+      STRING,
+      NUMBER,
+      CONSTRUCTOR_CALL
+    ]
+  };
+  const FUNCTION_INVOKE = {
+    relevance: 0,
+    match: [
+      /\b/,
+      // to prevent keywords from being confused as the function title
+      regex.concat("(?!fn\\b|function\\b|", normalizeKeywords(KWS).join("\\b|"), "|", normalizeKeywords(BUILT_INS).join("\\b|"), "\\b)"),
+      IDENT_RE,
+      regex.concat(WHITESPACE, "*"),
+      regex.lookahead(/(?=\()/)
+    ],
+    scope: { 3: "title.function.invoke" },
+    contains: [PARAMS_MODE]
+  };
+  PARAMS_MODE.contains.push(FUNCTION_INVOKE);
+  const ATTRIBUTE_CONTAINS = [
+    NAMED_ARGUMENT,
+    LEFT_AND_RIGHT_SIDE_OF_DOUBLE_COLON,
+    hljs.C_BLOCK_COMMENT_MODE,
+    STRING,
+    NUMBER,
+    CONSTRUCTOR_CALL
+  ];
+  const ATTRIBUTES = {
+    begin: regex.concat(/#\[\s*/, PASCAL_CASE_CLASS_NAME_RE),
+    beginScope: "meta",
+    end: /]/,
+    endScope: "meta",
+    keywords: {
+      literal: LITERALS,
+      keyword: [
+        "new",
+        "array"
+      ]
+    },
+    contains: [
+      {
+        begin: /\[/,
+        end: /]/,
+        keywords: {
+          literal: LITERALS,
+          keyword: [
+            "new",
+            "array"
+          ]
+        },
+        contains: [
+          "self",
+          ...ATTRIBUTE_CONTAINS
+        ]
+      },
+      ...ATTRIBUTE_CONTAINS,
+      {
+        scope: "meta",
+        match: PASCAL_CASE_CLASS_NAME_RE
+      }
+    ]
+  };
+  return {
+    case_insensitive: false,
+    keywords: KEYWORDS,
+    contains: [
+      ATTRIBUTES,
+      hljs.HASH_COMMENT_MODE,
+      hljs.COMMENT("//", "$"),
+      hljs.COMMENT(
+        "/\\*",
+        "\\*/",
+        { contains: [
+          {
+            scope: "doctag",
+            match: "@[A-Za-z]+"
+          }
+        ] }
+      ),
+      {
+        match: /__halt_compiler\(\);/,
+        keywords: "__halt_compiler",
+        starts: {
+          scope: "comment",
+          end: hljs.MATCH_NOTHING_RE,
+          contains: [
+            {
+              match: /\?>/,
+              scope: "meta",
+              endsParent: true
+            }
+          ]
+        }
+      },
+      PREPROCESSOR,
+      {
+        scope: "variable.language",
+        match: /\$this\b/
+      },
+      VARIABLE,
+      FUNCTION_INVOKE,
+      LEFT_AND_RIGHT_SIDE_OF_DOUBLE_COLON,
+      {
+        match: [
+          /const/,
+          /\s/,
+          IDENT_RE
+        ],
+        scope: {
+          1: "keyword",
+          3: "variable.constant"
+        }
+      },
+      CONSTRUCTOR_CALL,
+      {
+        scope: "function",
+        relevance: 0,
+        beginKeywords: "fn function",
+        end: /[;{]/,
+        excludeEnd: true,
+        illegal: "[$%\\[]",
+        contains: [
+          { beginKeywords: "use" },
+          hljs.UNDERSCORE_TITLE_MODE,
+          {
+            begin: "=>",
+            // No markup, just a relevance booster
+            endsParent: true
+          },
+          {
+            scope: "params",
+            begin: "\\(",
+            end: "\\)",
+            excludeBegin: true,
+            excludeEnd: true,
+            keywords: KEYWORDS,
+            contains: [
+              "self",
+              VARIABLE,
+              LEFT_AND_RIGHT_SIDE_OF_DOUBLE_COLON,
+              hljs.C_BLOCK_COMMENT_MODE,
+              STRING,
+              NUMBER
+            ]
+          }
+        ]
+      },
+      {
+        scope: "class",
+        variants: [
+          {
+            beginKeywords: "enum",
+            illegal: /[($"]/
+          },
+          {
+            beginKeywords: "class interface trait",
+            illegal: /[:($"]/
+          }
+        ],
+        relevance: 0,
+        end: /\{/,
+        excludeEnd: true,
+        contains: [
+          { beginKeywords: "extends implements" },
+          hljs.UNDERSCORE_TITLE_MODE
+        ]
+      },
+      // both use and namespace still use "old style" rules (vs multi-match)
+      // because the namespace name can include `\` and we still want each
+      // element to be treated as its own *individual* title
+      {
+        beginKeywords: "namespace",
+        relevance: 0,
+        end: ";",
+        illegal: /[.']/,
+        contains: [hljs.inherit(hljs.UNDERSCORE_TITLE_MODE, { scope: "title.class" })]
+      },
+      {
+        beginKeywords: "use",
+        relevance: 0,
+        end: ";",
+        contains: [
+          // TODO: title.function vs title.class
+          {
+            match: /\b(as|const|function)\b/,
+            scope: "keyword"
+          },
+          // TODO: could be title.class or title.function
+          hljs.UNDERSCORE_TITLE_MODE
+        ]
+      },
+      STRING,
+      NUMBER
+    ]
+  };
+}
+export {
+  php as default
+};