@apiuikit/web-component 1.4.0 → 1.5.0

package/dist/ocaml-T8IqWCjo-T8IqWCjo.js

@@ -0,0 +1,67 @@
+function n(e) {
+  return {
+    name: "OCaml",
+    aliases: ["ml"],
+    keywords: {
+      $pattern: "[a-z_]\\w*!?",
+      keyword: "and as assert asr begin class constraint do done downto else end exception external for fun function functor if in include inherit! inherit initializer land lazy let lor lsl lsr lxor match method!|10 method mod module mutable new object of open! open or private rec sig struct then to try type val! val virtual when while with parser value",
+      built_in: (
+        /* built-in types */
+        "array bool bytes char exn|5 float int int32 int64 list lazy_t|5 nativeint|5 string unit in_channel out_channel ref"
+      ),
+      literal: "true false"
+    },
+    illegal: /\/\/|>>/,
+    contains: [
+      {
+        className: "literal",
+        begin: "\\[(\\|\\|)?\\]|\\(\\)",
+        relevance: 0
+      },
+      e.COMMENT(
+        "\\(\\*",
+        "\\*\\)",
+        { contains: ["self"] }
+      ),
+      {
+        /* type variable */
+        className: "symbol",
+        begin: "'[A-Za-z_](?!')[\\w']*"
+        /* the grammar is ambiguous on how 'a'b should be interpreted but not the compiler */
+      },
+      {
+        /* polymorphic variant */
+        className: "type",
+        begin: "`[A-Z][\\w']*"
+      },
+      {
+        /* module or constructor */
+        className: "type",
+        begin: "\\b[A-Z][\\w']*",
+        relevance: 0
+      },
+      {
+        /* don't color identifiers, but safely catch all identifiers with ' */
+        begin: "[a-z_]\\w*'[\\w']*",
+        relevance: 0
+      },
+      e.inherit(e.APOS_STRING_MODE, {
+        className: "string",
+        relevance: 0
+      }),
+      e.inherit(e.QUOTE_STRING_MODE, { illegal: null }),
+      {
+        className: "number",
+        begin: "\\b(0[xX][a-fA-F0-9_]+[Lln]?|0[oO][0-7_]+[Lln]?|0[bB][01_]+[Lln]?|[0-9][0-9_]*([Lln]|(\\.[0-9_]*)?([eE][-+]?[0-9_]+)?)?)",
+        relevance: 0
+      },
+      {
+        begin: /->/
+        // relevance booster
+      }
+    ]
+  };
+}
+export {
+  n as default
+};

package/dist/php-BL35ZHWM-BVESXHm8.js

@@ -0,0 +1,566 @@
+function k(e) {
+  const t = e.regex, d = /(?![A-Za-z0-9])(?![$])/, o = t.concat(
+    /[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/,
+    d
+  ), n = t.concat(
+    /(\\?[A-Z][a-z0-9_\x7f-\xff]+|\\?[A-Z]+(?=[A-Z][a-z0-9_\x7f-\xff])){1,}/,
+    d
+  ), h = t.concat(
+    /[A-Z]+/,
+    d
+  ), _ = {
+    scope: "variable",
+    match: "\\$+" + o
+  }, S = {
+    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
+    ]
+  }, f = {
+    scope: "subst",
+    variants: [
+      { begin: /\$\w+/ },
+      {
+        begin: /\{\$/,
+        end: /\}/
+      }
+    ]
+  }, C = e.inherit(e.APOS_STRING_MODE, { illegal: null }), T = e.inherit(e.QUOTE_STRING_MODE, {
+    illegal: null,
+    contains: e.QUOTE_STRING_MODE.contains.concat(f)
+  }), A = {
+    begin: /<<<[ \t]*(?:(\w+)|"(\w+)")\n/,
+    end: /[ \t]*(\w+)\b/,
+    contains: e.QUOTE_STRING_MODE.contains.concat(f),
+    "on:begin": (r, a) => {
+      a.data._beginMatch = r[1] || r[2];
+    },
+    "on:end": (r, a) => {
+      a.data._beginMatch !== r[1] && a.ignoreMatch();
+    }
+  }, R = e.END_SAME_AS_BEGIN({
+    begin: /<<<[ \t]*'(\w+)'\n/,
+    end: /[ \t]*(\w+)\b/
+  }), m = `[ 	
+]`, i = {
+    scope: "string",
+    variants: [
+      T,
+      C,
+      A,
+      R
+    ]
+  }, s = {
+    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
+  }, p = [
+    "false",
+    "null",
+    "true"
+  ], I = [
+    // 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"
+  ], b = [
+    // 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"
+  ], u = {
+    keyword: I,
+    literal: ((r) => {
+      const a = [];
+      return r.forEach((c) => {
+        a.push(c), c.toLowerCase() === c ? a.push(c.toUpperCase()) : a.push(c.toLowerCase());
+      }), a;
+    })(p),
+    built_in: b
+  }, E = (r) => r.map((a) => a.replace(/\|\d+$/, "")), g = { variants: [
+    {
+      match: [
+        /new/,
+        t.concat(m, "+"),
+        // to prevent built ins from being confused as the class constructor call
+        t.concat("(?!", E(b).join("\\b|"), "\\b)"),
+        n
+      ],
+      scope: {
+        1: "keyword",
+        4: "title.class"
+      }
+    }
+  ] }, O = t.concat(o, "\\b(?!\\()"), l = { variants: [
+    {
+      match: [
+        t.concat(
+          /::/,
+          t.lookahead(/(?!class\b)/)
+        ),
+        O
+      ],
+      scope: { 2: "variable.constant" }
+    },
+    {
+      match: [
+        /::/,
+        /class/
+      ],
+      scope: { 2: "variable.language" }
+    },
+    {
+      match: [
+        n,
+        t.concat(
+          /::/,
+          t.lookahead(/(?!class\b)/)
+        ),
+        O
+      ],
+      scope: {
+        1: "title.class",
+        3: "variable.constant"
+      }
+    },
+    {
+      match: [
+        n,
+        t.concat(
+          "::",
+          t.lookahead(/(?!class\b)/)
+        )
+      ],
+      scope: { 1: "title.class" }
+    },
+    {
+      match: [
+        n,
+        /::/,
+        /class/
+      ],
+      scope: {
+        1: "title.class",
+        3: "variable.language"
+      }
+    }
+  ] }, v = {
+    scope: "attr",
+    match: t.concat(o, t.lookahead(":"), t.lookahead(/(?!::)/))
+  }, y = {
+    relevance: 0,
+    begin: /\(/,
+    end: /\)/,
+    keywords: u,
+    contains: [
+      v,
+      _,
+      l,
+      e.C_BLOCK_COMMENT_MODE,
+      i,
+      s,
+      g
+    ]
+  }, w = {
+    relevance: 0,
+    match: [
+      /\b/,
+      // to prevent keywords from being confused as the function title
+      t.concat("(?!fn\\b|function\\b|", E(I).join("\\b|"), "|", E(b).join("\\b|"), "\\b)"),
+      o,
+      t.concat(m, "*"),
+      t.lookahead(/(?=\()/)
+    ],
+    scope: { 3: "title.function.invoke" },
+    contains: [y]
+  };
+  y.contains.push(w);
+  const x = [
+    v,
+    l,
+    e.C_BLOCK_COMMENT_MODE,
+    i,
+    s,
+    g
+  ], M = {
+    begin: t.concat(
+      /#\[\s*\\?/,
+      t.either(
+        n,
+        h
+      )
+    ),
+    beginScope: "meta",
+    end: /]/,
+    endScope: "meta",
+    keywords: {
+      literal: p,
+      keyword: [
+        "new",
+        "array"
+      ]
+    },
+    contains: [
+      {
+        begin: /\[/,
+        end: /]/,
+        keywords: {
+          literal: p,
+          keyword: [
+            "new",
+            "array"
+          ]
+        },
+        contains: [
+          "self",
+          ...x
+        ]
+      },
+      ...x,
+      {
+        scope: "meta",
+        variants: [
+          { match: n },
+          { match: h }
+        ]
+      }
+    ]
+  };
+  return {
+    case_insensitive: !1,
+    keywords: u,
+    contains: [
+      M,
+      e.HASH_COMMENT_MODE,
+      e.COMMENT("//", "$"),
+      e.COMMENT(
+        "/\\*",
+        "\\*/",
+        { contains: [
+          {
+            scope: "doctag",
+            match: "@[A-Za-z]+"
+          }
+        ] }
+      ),
+      {
+        match: /__halt_compiler\(\);/,
+        keywords: "__halt_compiler",
+        starts: {
+          scope: "comment",
+          end: e.MATCH_NOTHING_RE,
+          contains: [
+            {
+              match: /\?>/,
+              scope: "meta",
+              endsParent: !0
+            }
+          ]
+        }
+      },
+      S,
+      {
+        scope: "variable.language",
+        match: /\$this\b/
+      },
+      _,
+      w,
+      l,
+      {
+        match: [
+          /const/,
+          /\s/,
+          o
+        ],
+        scope: {
+          1: "keyword",
+          3: "variable.constant"
+        }
+      },
+      g,
+      {
+        scope: "function",
+        relevance: 0,
+        beginKeywords: "fn function",
+        end: /[;{]/,
+        excludeEnd: !0,
+        illegal: "[$%\\[]",
+        contains: [
+          { beginKeywords: "use" },
+          e.UNDERSCORE_TITLE_MODE,
+          {
+            begin: "=>",
+            // No markup, just a relevance booster
+            endsParent: !0
+          },
+          {
+            scope: "params",
+            begin: "\\(",
+            end: "\\)",
+            excludeBegin: !0,
+            excludeEnd: !0,
+            keywords: u,
+            contains: [
+              "self",
+              M,
+              _,
+              l,
+              e.C_BLOCK_COMMENT_MODE,
+              i,
+              s
+            ]
+          }
+        ]
+      },
+      {
+        scope: "class",
+        variants: [
+          {
+            beginKeywords: "enum",
+            illegal: /[($"]/
+          },
+          {
+            beginKeywords: "class interface trait",
+            illegal: /[:($"]/
+          }
+        ],
+        relevance: 0,
+        end: /\{/,
+        excludeEnd: !0,
+        contains: [
+          { beginKeywords: "extends implements" },
+          e.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: [e.inherit(e.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
+          e.UNDERSCORE_TITLE_MODE
+        ]
+      },
+      i,
+      s
+    ]
+  };
+}
+export {
+  k as default
+};